│ │ │ │ Classes
Implement iterators over GridGlue intersections.
Describes the parallel communication interface class for Dune::GridGlue.
Describes the parallel communication interface class for Dune::GridGlue.
Implement iterators over GridGlue intersections.
Model of the Intersection concept provided by GridGlue.
Definition: gridglue.hh:37
sequential adapter to couple two grids at specified close together boundaries
Definition: gridglue.hh:67
Dune::FieldVector< ctype, dimworld > Coords
The type used for coordinate vectors.
Definition: gridglue.hh:174
Intersection getIntersection(int i) const
Definition: gridglue.hh:388
GridVertex< 1 > Grid1Vertex
The type of the Grid1 vertices.
Definition: gridglue.hh:194
Dune::GridGlue::IntersectionIndexSet< P0, P1 > IndexSet
Type of remote intersection indexSet.
Definition: gridglue.hh:206
-
│ │ │ │
│ │ │ │
│ │ │ │ +Namespaces |
│ │ │ │ +Typedefs |
│ │ │ │ +Functions
│ │ │ │ +
│ │ │ │ Classes |
│ │ │ │ -Namespaces
│ │ │ │ - intersectioniterator.hh File Reference
gridgluecommunicate.hh File Reference
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,27 +5,62 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Classes | Namespaces
│ │ │ │ │ -intersectioniterator.hh File Reference
│ │ │ │ │ -Implement iterators over GridGlue intersections. More...
│ │ │ │ │ -#include
│ │ │ │ │ +Classes | Namespaces | Typedefs | Functions
│ │ │ │ │ +gridgluecommunicate.hh File Reference
│ │ │ │ │ +Describes the parallel communication interface class for Dune::GridGlue.
│ │ │ │ │ +More...
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Classes
│ │ │ │ │ -class Dune::GridGlue::IntersectionIterator<_P0,_P1,_inside,_outside_>
│ │ │ │ │ +struct Dune::GridGlue::GlobalId
│ │ │ │ │ +
│ │ │ │ │ + class Dune::GridGlue::CommDataHandle<_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ + describes the features of a data handle for communication in parallel
│ │ │ │ │ + runs using the GridGlue::communicate methods. More...
│ │ │ │ │ +
│ │ │ │ │ + class Dune::GridGlue::StreamingMessageBuffer<_DT_>
│ │ │ │ │ +
│ │ │ │ │ + class Dune::GridGlue::CommunicationOperator<_dir_>
│ │ │ │ │ + forward gather scatter to user defined CommInfo class More...
│ │ │ │ │ +
│ │ │ │ │ +struct Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ + collects all GridGlue data requried for communication More...
│ │ │ │ │ +
│ │ │ │ │ +struct Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,
│ │ │ │ │ + DataTypeImp_>_>
│ │ │ │ │ + specialization of the CommPolicy struct, required for the
│ │ │ │ │ + ParallelIndexsets More...
│ │ │ │ │
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ + Typedefs
│ │ │ │ │ + typedef std::pair< int, int > Dune::GridGlue::RankPair
│ │ │ │ │ +
│ │ │ │ │ +typedef CommunicationOperator< Dune::
│ │ │ │ │ + ForwardCommunication > Dune::GridGlue::ForwardOperator
│ │ │ │ │ +
│ │ │ │ │ +typedef CommunicationOperator< Dune::
│ │ │ │ │ + BackwardCommunication > Dune::GridGlue::BackwardOperator
│ │ │ │ │ +
│ │ │ │ │ + Functions
│ │ │ │ │ +std::ostream & Dune::GridGlue::operator<< (std::ostream &os, const GlobalId
│ │ │ │ │ + &id)
│ │ │ │ │ +
│ │ │ │ │ ***** Detailed Description *****
│ │ │ │ │ -Implement iterators over GridGlue intersections.
│ │ │ │ │ +Describes the parallel communication interface class for Dune::GridGlue.
│ │ │ │ │ Author
│ │ │ │ │ Christian Engwer
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00005_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: intersectioniterator.hh Source File
│ │ │ │ +dune-grid-glue: gridgluecommunicate.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -62,85 +62,323 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,100 +5,443 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -intersectioniterator.hh
│ │ │ │ │ +gridgluecommunicate.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 12#ifndef DUNE_GRIDGLUE_ADAPTER_INTERSECTIONITERATOR_HH
│ │ │ │ │ - 13#define DUNE_GRIDGLUE_ADAPTER_INTERSECTIONITERATOR_HH
│ │ │ │ │ + 5#ifndef DUNE_GRIDGLUE_ADAPTER_GRIDGLUECOMMUNICATE_HH
│ │ │ │ │ + 6#define DUNE_GRIDGLUE_ADAPTER_GRIDGLUECOMMUNICATE_HH
│ │ │ │ │ + 7
│ │ │ │ │ + 13#include
│ │ │ │ │ 14
│ │ │ │ │ - 15#include
│ │ │ │ │ - 16
│ │ │ │ │ - 17namespace Dune {
│ │ │ │ │ - 18 namespace GridGlue {
│ │ │ │ │ + 15#include
│ │ │ │ │ + 16#include
│ │ │ │ │ + 17#include
│ │ │ │ │ + 18#include
│ │ │ │ │ 19
│ │ │ │ │ - 21 template
│ │ │ │ │ -22 class IntersectionIterator :
│ │ │ │ │ - 23 public Dune::ForwardIteratorFacade<
│ │ │ │ │ -IntersectionIterator,
│ │ │ │ │ - 24 const Intersection >
│ │ │ │ │ - 25 {
│ │ │ │ │ - 26 public:
│ │ │ │ │ - 27
│ │ │ │ │ -28 typedef ::Dune::GridGlue::GridGlue GridGlue;
│ │ │ │ │ -29 typedef ::Dune::GridGlue::Intersection Intersection;
│ │ │ │ │ - 30
│ │ │ │ │ -31 IntersectionIterator(const GridGlue * glue, unsigned int i)
│ │ │ │ │ - 32 : glue_(glue),
│ │ │ │ │ - 33 index_(i),
│ │ │ │ │ - 34 intersection_(glue_, & glue_->intersections_[index_])
│ │ │ │ │ - 35 {}
│ │ │ │ │ - 36
│ │ │ │ │ -37 const Intersection& dereference() const
│ │ │ │ │ - 38 {
│ │ │ │ │ - 39 assert(("never dereference the end iterator" &&
│ │ │ │ │ - 40 index_ != glue_->index__sz));
│ │ │ │ │ - 41 return intersection_;
│ │ │ │ │ + 20
│ │ │ │ │ + 21namespace Dune {
│ │ │ │ │ + 22 namespace GridGlue {
│ │ │ │ │ + 23
│ │ │ │ │ +24 typedef std::pair RankPair;
│ │ │ │ │ +25 struct GlobalId : public std::pair
│ │ │ │ │ + 26 {
│ │ │ │ │ +30 GlobalId() {
│ │ │ │ │ + 31 this->first.first = 0;
│ │ │ │ │ + 32 this->first.second = 0;
│ │ │ │ │ + 33 this->second = 0;
│ │ │ │ │ + 34 }
│ │ │ │ │ +38 GlobalId(int i) {
│ │ │ │ │ + 39 this->first.first = i;
│ │ │ │ │ + 40 this->first.second = i;
│ │ │ │ │ + 41 this->second = 0;
│ │ │ │ │ 42 }
│ │ │ │ │ - 43
│ │ │ │ │ -44 void increment()
│ │ │ │ │ - 45 {
│ │ │ │ │ - 46 intersection_ = Intersection(glue_, & glue_->intersections_[++index_]);
│ │ │ │ │ - 47 }
│ │ │ │ │ - 48
│ │ │ │ │ -49 bool equals(const IntersectionIterator& iter) const
│ │ │ │ │ - 50 {
│ │ │ │ │ - 51 return iter.index_ == index_;
│ │ │ │ │ +48 GlobalId(int i, int j, unsigned int n) {
│ │ │ │ │ + 49 this->first.first = std::min(i,j);
│ │ │ │ │ + 50 this->first.second = std::max(i,j);
│ │ │ │ │ + 51 this->second = n;
│ │ │ │ │ 52 }
│ │ │ │ │ - 53
│ │ │ │ │ - 54 private:
│ │ │ │ │ - 55
│ │ │ │ │ - 56 const GridGlue* glue_;
│ │ │ │ │ - 57 unsigned int index_;
│ │ │ │ │ - 58
│ │ │ │ │ - 59 Intersection intersection_;
│ │ │ │ │ - 60 };
│ │ │ │ │ - 61
│ │ │ │ │ - 62 } // end namespace GridGlue
│ │ │ │ │ - 63} // end namespace Dune
│ │ │ │ │ - 64
│ │ │ │ │ - 65#endif // DUNE_GRIDGLUE_ADAPTER_INTERSECTIONITERATOR_HH
│ │ │ │ │ -gridglue.hh
│ │ │ │ │ -Central component of the module implementing the coupling of two grids.
│ │ │ │ │ + 53 };
│ │ │ │ │ + 54
│ │ │ │ │ +55 inline std::ostream& operator<<(std::ostream& os, const GlobalId & id)
│ │ │ │ │ + 56 {
│ │ │ │ │ + 57 os << "("
│ │ │ │ │ + 58 << id.first.first << "," << id.first.second << ","
│ │ │ │ │ + 59 << id.second << ")";
│ │ │ │ │ + 60 return os;
│ │ │ │ │ + 61 }
│ │ │ │ │ + 62
│ │ │ │ │ + 75 template
│ │ │ │ │ +76 class CommDataHandle
│ │ │ │ │ + 77 {
│ │ │ │ │ + 78 public:
│ │ │ │ │ +80 typedef DataTypeImp DataType;
│ │ │ │ │ + 81
│ │ │ │ │ + 82 protected:
│ │ │ │ │ + 83 // one should not create an explicit instance of this inteface object
│ │ │ │ │ +84 CommDataHandle() {}
│ │ │ │ │ + 85
│ │ │ │ │ + 86 public:
│ │ │ │ │ + 87
│ │ │ │ │ + 91 template
│ │ │ │ │ +92 size_t size (RISType& i) const
│ │ │ │ │ + 93 {
│ │ │ │ │ + 94 CHECK_INTERFACE_IMPLEMENTATION((asImp().size(i)));
│ │ │ │ │ + 95 return asImp().size(i);
│ │ │ │ │ + 96 }
│ │ │ │ │ + 97
│ │ │ │ │ + 103 template
│ │ │ │ │ +104 void gather (MessageBufferImp& buff, const EntityType& e, const RISType &
│ │ │ │ │ +i) const
│ │ │ │ │ + 105 {
│ │ │ │ │ + 106 MessageBufferIF buffIF(buff);
│ │ │ │ │ + 107 CHECK_AND_CALL_INTERFACE_IMPLEMENTATION((asImp().gather(buffIF,e,i)));
│ │ │ │ │ + 108 }
│ │ │ │ │ + 109
│ │ │ │ │ + 117 template
│ │ │ │ │ +118 void scatter (MessageBufferImp& buff, const EntityType& e, const RISType &
│ │ │ │ │ +i, size_t n)
│ │ │ │ │ + 119 {
│ │ │ │ │ + 120 MessageBufferIF buffIF(buff);
│ │ │ │ │ + 121 CHECK_AND_CALL_INTERFACE_IMPLEMENTATION((asImp().scatter(buffIF,e,i,n)));
│ │ │ │ │ + 122 }
│ │ │ │ │ + 123
│ │ │ │ │ + 124 private:
│ │ │ │ │ + 126 DataHandleImp& asImp () {
│ │ │ │ │ + 127 return static_cast (*this);
│ │ │ │ │ + 128 }
│ │ │ │ │ + 130 const DataHandleImp& asImp () const
│ │ │ │ │ + 131 {
│ │ │ │ │ + 132 return static_cast(*this);
│ │ │ │ │ + 133 }
│ │ │ │ │ + 134 }; // end class CommDataHandleIF
│ │ │ │ │ + 135
│ │ │ │ │ + 140 template
│ │ │ │ │ +141 class StreamingMessageBuffer {
│ │ │ │ │ + 142 public:
│ │ │ │ │ +143 typedef DT value_type;
│ │ │ │ │ + 144
│ │ │ │ │ + 145 // Constructor
│ │ │ │ │ +146 StreamingMessageBuffer (DT *p)
│ │ │ │ │ + 147 {
│ │ │ │ │ + 148 a=p;
│ │ │ │ │ + 149 i=0;
│ │ │ │ │ + 150 j=0;
│ │ │ │ │ + 151 }
│ │ │ │ │ + 152
│ │ │ │ │ + 153 // write data to message buffer, acts like a stream !
│ │ │ │ │ + 154 template
│ │ │ │ │ +155 void write (const Y& data)
│ │ │ │ │ + 156 {
│ │ │ │ │ + 157 static_assert(std::is_same::value, "DataType mismatch");
│ │ │ │ │ + 158 a[i++] = data;
│ │ │ │ │ + 159 }
│ │ │ │ │ + 160
│ │ │ │ │ + 161 // read data from message buffer, acts like a stream !
│ │ │ │ │ + 162 template
│ │ │ │ │ +163 void read (Y& data) const
│ │ │ │ │ + 164 {
│ │ │ │ │ + 165 static_assert(std::is_same::value, "DataType mismatch");
│ │ │ │ │ + 166 data = a[j++];
│ │ │ │ │ + 167 }
│ │ │ │ │ + 168
│ │ │ │ │ +169 size_t counter() const { return i; }
│ │ │ │ │ + 170
│ │ │ │ │ +171 void clear()
│ │ │ │ │ + 172 {
│ │ │ │ │ + 173 i = 0;
│ │ │ │ │ + 174 j = 0;
│ │ │ │ │ + 175 }
│ │ │ │ │ + 176
│ │ │ │ │ + 177 // we need access to these variables in an assertion
│ │ │ │ │ + 178#ifdef NDEBUG
│ │ │ │ │ + 179 private:
│ │ │ │ │ + 180#endif
│ │ │ │ │ +181 DT *a;
│ │ │ │ │ +182 size_t i;
│ │ │ │ │ +183 mutable size_t j;
│ │ │ │ │ + 184 };
│ │ │ │ │ + 185
│ │ │ │ │ + 192 template
│ │ │ │ │ +193 class CommunicationOperator
│ │ │ │ │ + 194 {
│ │ │ │ │ + 195 public:
│ │ │ │ │ + 196 template
│ │ │ │ │ +197 static const typename CommInfo::DataType& gather(const CommInfo& commInfo,
│ │ │ │ │ +size_t i, size_t j = 0)
│ │ │ │ │ + 198 {
│ │ │ │ │ + 199 // get Intersection
│ │ │ │ │ + 200 typedef typename CommInfo::GridGlue::Intersection Intersection;
│ │ │ │ │ + 201 Intersection ris(commInfo.gridglue->getIntersection(i));
│ │ │ │ │ + 202
│ │ │ │ │ + 203 // fill buffer if we have a new intersection
│ │ │ │ │ + 204 if (j == 0)
│ │ │ │ │ + 205 {
│ │ │ │ │ + 206 commInfo.mbuffer.clear();
│ │ │ │ │ + 207 if (dir == Dune::ForwardCommunication)
│ │ │ │ │ + 208 {
│ │ │ │ │ + 209 // read from grid0
│ │ │ │ │ + 210 if(ris.self())
│ │ │ │ │ + 211 commInfo.data->gather(commInfo.mbuffer, ris.inside(), ris);
│ │ │ │ │ + 212 }
│ │ │ │ │ + 213 else // (dir == Dune::BackwardCommunication)
│ │ │ │ │ + 214 {
│ │ │ │ │ + 215 // read from grid1
│ │ │ │ │ + 216 if(ris.neighbor())
│ │ │ │ │ + 217 commInfo.data->gather(commInfo.mbuffer, ris.outside(), ris.flip());
│ │ │ │ │ + 218 }
│ │ │ │ │ + 219 }
│ │ │ │ │ + 220
│ │ │ │ │ + 221 // return the j'th value in the buffer
│ │ │ │ │ + 222 assert(j < commInfo.mbuffer.i);
│ │ │ │ │ + 223 return commInfo.buffer[j];
│ │ │ │ │ + 224 }
│ │ │ │ │ + 225
│ │ │ │ │ + 226 template
│ │ │ │ │ +227 static void scatter(CommInfo& commInfo, const typename CommInfo::DataType&
│ │ │ │ │ +v, std::size_t i, std::size_t j = 0)
│ │ │ │ │ + 228 {
│ │ │ │ │ + 229 // extract GridGlue objects...
│ │ │ │ │ + 230 typedef typename CommInfo::GridGlue::Intersection Intersection;
│ │ │ │ │ + 231 Intersection ris(commInfo.gridglue->getIntersection(i));
│ │ │ │ │ + 232
│ │ │ │ │ + 233 // get size if we have a new intersection
│ │ │ │ │ + 234 if (j == 0)
│ │ │ │ │ + 235 {
│ │ │ │ │ + 236 commInfo.mbuffer.clear();
│ │ │ │ │ + 237 commInfo.currentsize = commInfo.data->size(ris);
│ │ │ │ │ + 238 }
│ │ │ │ │ + 239
│ │ │ │ │ + 240 // write entry to buffer
│ │ │ │ │ + 241 commInfo.buffer[j] = v;
│ │ │ │ │ + 242
│ │ │ │ │ + 243 // write back the buffer if we are at the end of this intersection
│ │ │ │ │ + 244 if (j == commInfo.currentsize-1)
│ │ │ │ │ + 245 {
│ │ │ │ │ + 246 if (dir == Dune::ForwardCommunication)
│ │ │ │ │ + 247 {
│ │ │ │ │ + 248 // write to grid1
│ │ │ │ │ + 249 if(ris.neighbor())
│ │ │ │ │ + 250 commInfo.data->scatter(commInfo.mbuffer, ris.outside(), ris.flip(),
│ │ │ │ │ +commInfo.currentsize);
│ │ │ │ │ + 251 }
│ │ │ │ │ + 252 else // (dir == Dune::BackwardCommunication)
│ │ │ │ │ + 253 {
│ │ │ │ │ + 254 // write to grid0
│ │ │ │ │ + 255 if(ris.self())
│ │ │ │ │ + 256 commInfo.data->scatter(commInfo.mbuffer, ris.inside(), ris,
│ │ │ │ │ +commInfo.currentsize);
│ │ │ │ │ + 257 }
│ │ │ │ │ + 258 assert(commInfo.mbuffer.j <= commInfo.currentsize);
│ │ │ │ │ + 259 }
│ │ │ │ │ + 260 }
│ │ │ │ │ + 261 };
│ │ │ │ │ + 262
│ │ │ │ │ +263 typedef CommunicationOperator ForwardOperator;
│ │ │ │ │ +264 typedef CommunicationOperator
│ │ │ │ │ +BackwardOperator;
│ │ │ │ │ + 265
│ │ │ │ │ + 270 template
│ │ │ │ │ +271 struct CommInfo
│ │ │ │ │ + 272 {
│ │ │ │ │ +273 typedef DataTypeImp value_type;
│ │ │ │ │ +274 typedef GG GridGlue;
│ │ │ │ │ +275 typedef DataTypeImp DataType;
│ │ │ │ │ + 276
│ │ │ │ │ +277 CommInfo() : buffer(100), mbuffer(&buffer[0])
│ │ │ │ │ + 278 {}
│ │ │ │ │ + 279
│ │ │ │ │ + 280 // tunnel information to the policy and the operators
│ │ │ │ │ +281 const GridGlue * gridglue;
│ │ │ │ │ +282 ::Dune::GridGlue::CommDataHandle * data;
│ │ │ │ │ + 283
│ │ │ │ │ + 284 // state variables
│ │ │ │ │ +285 std::vector buffer;
│ │ │ │ │ +286 mutable ::Dune::GridGlue::StreamingMessageBuffer mbuffer;
│ │ │ │ │ +287 size_t currentsize;
│ │ │ │ │ +288 Dune::CommunicationDirection dir;
│ │ │ │ │ + 289 };
│ │ │ │ │ + 290
│ │ │ │ │ + 291 } // end namespace GridGlue
│ │ │ │ │ + 292
│ │ │ │ │ + 293#if HAVE_MPI
│ │ │ │ │ + 298 template
│ │ │ │ │ +299 struct CommPolicy< ::Dune::GridGlue::CommInfo >
│ │ │ │ │ + 300 {
│ │ │ │ │ +304 typedef ::Dune::GridGlue::CommInfo Type;
│ │ │ │ │ + 305
│ │ │ │ │ +309 typedef DataTypeImp IndexedType;
│ │ │ │ │ + 310
│ │ │ │ │ + 314 // typedef SizeOne IndexedTypeFlag;
│ │ │ │ │ +315 typedef VariableSize IndexedTypeFlag;
│ │ │ │ │ + 316
│ │ │ │ │ +320 static size_t getSize(const Type& commInfo, size_t i)
│ │ │ │ │ + 321 {
│ │ │ │ │ + 322 // get Intersection
│ │ │ │ │ + 323 typedef typename Type::GridGlue::Intersection Intersection;
│ │ │ │ │ + 324 Intersection ris(commInfo.gridglue->getIntersection(i));
│ │ │ │ │ + 325
│ │ │ │ │ + 326 // ask data handle for size
│ │ │ │ │ + 327 return commInfo.data->size(ris);
│ │ │ │ │ + 328 }
│ │ │ │ │ + 329 };
│ │ │ │ │ + 330#endif
│ │ │ │ │ + 331
│ │ │ │ │ + 332} // end namespace Dune
│ │ │ │ │ + 333#endif
│ │ │ │ │ Dune
│ │ │ │ │ Definition: gridglue.hh:37
│ │ │ │ │ -Dune::GridGlue::GridGlue
│ │ │ │ │ -sequential adapter to couple two grids at specified close together boundaries
│ │ │ │ │ -Definition: gridglue.hh:67
│ │ │ │ │ -Dune::GridGlue::Intersection<_P0,_P1,_inside,_outside_>
│ │ │ │ │ -Dune::GridGlue::IntersectionIterator
│ │ │ │ │ -Definition: intersectioniterator.hh:25
│ │ │ │ │ -Dune::GridGlue::IntersectionIterator::GridGlue
│ │ │ │ │ -::Dune::GridGlue::GridGlue< P0, P1 > GridGlue
│ │ │ │ │ -Definition: intersectioniterator.hh:28
│ │ │ │ │ -Dune::GridGlue::IntersectionIterator::dereference
│ │ │ │ │ -const Intersection & dereference() const
│ │ │ │ │ -Definition: intersectioniterator.hh:37
│ │ │ │ │ -Dune::GridGlue::IntersectionIterator::increment
│ │ │ │ │ -void increment()
│ │ │ │ │ -Definition: intersectioniterator.hh:44
│ │ │ │ │ -Dune::GridGlue::IntersectionIterator::Intersection
│ │ │ │ │ -::Dune::GridGlue::Intersection< P0, P1, inside, outside > Intersection
│ │ │ │ │ -Definition: intersectioniterator.hh:29
│ │ │ │ │ -Dune::GridGlue::IntersectionIterator::IntersectionIterator
│ │ │ │ │ -IntersectionIterator(const GridGlue *glue, unsigned int i)
│ │ │ │ │ -Definition: intersectioniterator.hh:31
│ │ │ │ │ -Dune::GridGlue::IntersectionIterator::equals
│ │ │ │ │ -bool equals(const IntersectionIterator &iter) const
│ │ │ │ │ -Definition: intersectioniterator.hh:49
│ │ │ │ │ +Dune::GridGlue::BackwardOperator
│ │ │ │ │ +CommunicationOperator< Dune::BackwardCommunication > BackwardOperator
│ │ │ │ │ +Definition: gridgluecommunicate.hh:264
│ │ │ │ │ +Dune::GridGlue::ForwardOperator
│ │ │ │ │ +CommunicationOperator< Dune::ForwardCommunication > ForwardOperator
│ │ │ │ │ +Definition: gridgluecommunicate.hh:263
│ │ │ │ │ +Dune::GridGlue::RankPair
│ │ │ │ │ +std::pair< int, int > RankPair
│ │ │ │ │ +Definition: gridgluecommunicate.hh:24
│ │ │ │ │ +Dune::GridGlue::operator<<
│ │ │ │ │ +std::ostream & operator<<(std::ostream &os, const GlobalId &id)
│ │ │ │ │ +Definition: gridgluecommunicate.hh:55
│ │ │ │ │ +Dune::GridGlue::Intersection
│ │ │ │ │ +The intersection of two entities of the two patches of a GridGlue.
│ │ │ │ │ +Definition: intersection.hh:261
│ │ │ │ │ +Dune::GridGlue::Intersection::flip
│ │ │ │ │ +Intersection< P0, P1, O, I > flip() const
│ │ │ │ │ +Return a copy of the intersection with inside and outside switched.
│ │ │ │ │ +Definition: intersection.hh:483
│ │ │ │ │ +Dune::GridGlue::Intersection::self
│ │ │ │ │ +bool self() const
│ │ │ │ │ +For parallel computations: Return true if inside() entity exists locally.
│ │ │ │ │ +Definition: intersection.hh:393
│ │ │ │ │ +Dune::GridGlue::Intersection::inside
│ │ │ │ │ +InsideEntity inside(unsigned int parentId=0) const
│ │ │ │ │ +Return element on the inside of this intersection.
│ │ │ │ │ +Definition: intersection.hh:319
│ │ │ │ │ +Dune::GridGlue::Intersection::neighbor
│ │ │ │ │ +size_t neighbor(unsigned int g=0) const
│ │ │ │ │ +Return number of embeddings into local grid0 (grid1) entities.
│ │ │ │ │ +Definition: intersection.hh:399
│ │ │ │ │ +Dune::GridGlue::Intersection::outside
│ │ │ │ │ +OutsideEntity outside(unsigned int parentId=0) const
│ │ │ │ │ +Return element on the outside of this intersection.
│ │ │ │ │ +Definition: intersection.hh:328
│ │ │ │ │ +Dune::GridGlue::GlobalId
│ │ │ │ │ +Definition: gridgluecommunicate.hh:26
│ │ │ │ │ +Dune::GridGlue::GlobalId::GlobalId
│ │ │ │ │ +GlobalId(int i)
│ │ │ │ │ +Definition: gridgluecommunicate.hh:38
│ │ │ │ │ +Dune::GridGlue::GlobalId::GlobalId
│ │ │ │ │ +GlobalId()
│ │ │ │ │ +Definition: gridgluecommunicate.hh:30
│ │ │ │ │ +Dune::GridGlue::GlobalId::GlobalId
│ │ │ │ │ +GlobalId(int i, int j, unsigned int n)
│ │ │ │ │ +Definition: gridgluecommunicate.hh:48
│ │ │ │ │ +Dune::GridGlue::CommDataHandle
│ │ │ │ │ +describes the features of a data handle for communication in parallel runs
│ │ │ │ │ +using the GridGlue::commun...
│ │ │ │ │ +Definition: gridgluecommunicate.hh:77
│ │ │ │ │ +Dune::GridGlue::CommDataHandle::size
│ │ │ │ │ +size_t size(RISType &i) const
│ │ │ │ │ +Definition: gridgluecommunicate.hh:92
│ │ │ │ │ +Dune::GridGlue::CommDataHandle::scatter
│ │ │ │ │ +void scatter(MessageBufferImp &buff, const EntityType &e, const RISType &i,
│ │ │ │ │ +size_t n)
│ │ │ │ │ +Definition: gridgluecommunicate.hh:118
│ │ │ │ │ +Dune::GridGlue::CommDataHandle::gather
│ │ │ │ │ +void gather(MessageBufferImp &buff, const EntityType &e, const RISType &i)
│ │ │ │ │ +const
│ │ │ │ │ +pack data from user to message buffer
│ │ │ │ │ +Definition: gridgluecommunicate.hh:104
│ │ │ │ │ +Dune::GridGlue::CommDataHandle::DataType
│ │ │ │ │ +DataTypeImp DataType
│ │ │ │ │ +data type of data to communicate
│ │ │ │ │ +Definition: gridgluecommunicate.hh:80
│ │ │ │ │ +Dune::GridGlue::CommDataHandle::CommDataHandle
│ │ │ │ │ +CommDataHandle()
│ │ │ │ │ +Definition: gridgluecommunicate.hh:84
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer
│ │ │ │ │ +Definition: gridgluecommunicate.hh:141
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::j
│ │ │ │ │ +size_t j
│ │ │ │ │ +Definition: gridgluecommunicate.hh:183
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::StreamingMessageBuffer
│ │ │ │ │ +StreamingMessageBuffer(DT *p)
│ │ │ │ │ +Definition: gridgluecommunicate.hh:146
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::a
│ │ │ │ │ +DT * a
│ │ │ │ │ +Definition: gridgluecommunicate.hh:181
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::counter
│ │ │ │ │ +size_t counter() const
│ │ │ │ │ +Definition: gridgluecommunicate.hh:169
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::write
│ │ │ │ │ +void write(const Y &data)
│ │ │ │ │ +Definition: gridgluecommunicate.hh:155
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::read
│ │ │ │ │ +void read(Y &data) const
│ │ │ │ │ +Definition: gridgluecommunicate.hh:163
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::value_type
│ │ │ │ │ +DT value_type
│ │ │ │ │ +Definition: gridgluecommunicate.hh:143
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::i
│ │ │ │ │ +size_t i
│ │ │ │ │ +Definition: gridgluecommunicate.hh:182
│ │ │ │ │ +Dune::GridGlue::StreamingMessageBuffer::clear
│ │ │ │ │ +void clear()
│ │ │ │ │ +Definition: gridgluecommunicate.hh:171
│ │ │ │ │ +Dune::GridGlue::CommunicationOperator
│ │ │ │ │ +forward gather scatter to user defined CommInfo class
│ │ │ │ │ +Definition: gridgluecommunicate.hh:194
│ │ │ │ │ +Dune::GridGlue::CommunicationOperator::scatter
│ │ │ │ │ +static void scatter(CommInfo &commInfo, const typename CommInfo::DataType &v,
│ │ │ │ │ +std::size_t i, std::size_t j=0)
│ │ │ │ │ +Definition: gridgluecommunicate.hh:227
│ │ │ │ │ +Dune::GridGlue::CommunicationOperator::gather
│ │ │ │ │ +static const CommInfo::DataType & gather(const CommInfo &commInfo, size_t i,
│ │ │ │ │ +size_t j=0)
│ │ │ │ │ +Definition: gridgluecommunicate.hh:197
│ │ │ │ │ +Dune::GridGlue::CommInfo
│ │ │ │ │ +collects all GridGlue data requried for communication
│ │ │ │ │ +Definition: gridgluecommunicate.hh:272
│ │ │ │ │ +Dune::GridGlue::CommInfo::dir
│ │ │ │ │ +Dune::CommunicationDirection dir
│ │ │ │ │ +Definition: gridgluecommunicate.hh:288
│ │ │ │ │ +Dune::GridGlue::CommInfo::value_type
│ │ │ │ │ +DataTypeImp value_type
│ │ │ │ │ +Definition: gridgluecommunicate.hh:273
│ │ │ │ │ +Dune::GridGlue::CommInfo::DataType
│ │ │ │ │ +DataTypeImp DataType
│ │ │ │ │ +Definition: gridgluecommunicate.hh:275
│ │ │ │ │ +Dune::GridGlue::CommInfo::data
│ │ │ │ │ +::Dune::GridGlue::CommDataHandle< DataHandleImp, DataTypeImp > * data
│ │ │ │ │ +Definition: gridgluecommunicate.hh:282
│ │ │ │ │ +Dune::GridGlue::CommInfo::GridGlue
│ │ │ │ │ +GG GridGlue
│ │ │ │ │ +Definition: gridgluecommunicate.hh:274
│ │ │ │ │ +Dune::GridGlue::CommInfo::currentsize
│ │ │ │ │ +size_t currentsize
│ │ │ │ │ +Definition: gridgluecommunicate.hh:287
│ │ │ │ │ +Dune::GridGlue::CommInfo::CommInfo
│ │ │ │ │ +CommInfo()
│ │ │ │ │ +Definition: gridgluecommunicate.hh:277
│ │ │ │ │ +Dune::GridGlue::CommInfo::mbuffer
│ │ │ │ │ +mutable ::Dune::GridGlue::StreamingMessageBuffer< DataType > mbuffer
│ │ │ │ │ +Definition: gridgluecommunicate.hh:286
│ │ │ │ │ +Dune::GridGlue::CommInfo::gridglue
│ │ │ │ │ +const GridGlue * gridglue
│ │ │ │ │ +Definition: gridgluecommunicate.hh:281
│ │ │ │ │ +Dune::GridGlue::CommInfo::buffer
│ │ │ │ │ +std::vector< DataType > buffer
│ │ │ │ │ +Definition: gridgluecommunicate.hh:285
│ │ │ │ │ +Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ +>::getSize
│ │ │ │ │ +static size_t getSize(const Type &commInfo, size_t i)
│ │ │ │ │ +Get the number of objects at an intersection.
│ │ │ │ │ +Definition: gridgluecommunicate.hh:320
│ │ │ │ │ +Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ +>::IndexedType
│ │ │ │ │ +DataTypeImp IndexedType
│ │ │ │ │ +The datatype that should be communicated.
│ │ │ │ │ +Definition: gridgluecommunicate.hh:309
│ │ │ │ │ +Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ +>::Type
│ │ │ │ │ +::Dune::GridGlue::CommInfo< GG, DataHandleImp, DataTypeImp > Type
│ │ │ │ │ +The type of the GridGlueCommInfo.
│ │ │ │ │ +Definition: gridgluecommunicate.hh:304
│ │ │ │ │ +Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ +>::IndexedTypeFlag
│ │ │ │ │ +VariableSize IndexedTypeFlag
│ │ │ │ │ +Each intersection can communicate a different number of objects.
│ │ │ │ │ +Definition: gridgluecommunicate.hh:315
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00008.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: gridglue.cc File Reference
│ │ │ │ +dune-grid-glue: rangegenerators.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -63,38 +63,42 @@
│ │ │ │
│ │ │ │
│ │ │ │ Implement iterators over GridGlue intersections. │ │ │ │ +
Describes the parallel communication interface class for Dune::GridGlue. │ │ │ │ More...
│ │ │ │ -#include <dune/grid-glue/gridglue.hh>│ │ │ │ +
#include <type_traits>│ │ │ │ +
#include <dune/common/bartonnackmanifcheck.hh>│ │ │ │ +
#include <dune/common/parallel/communicator.hh>│ │ │ │ +
#include <dune/grid/common/datahandleif.hh>│ │ │ │ +
#include <dune/grid/common/gridenums.hh>│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ Classes | |
| class | Dune::GridGlue::IntersectionIterator< P0, P1, inside, outside > |
| struct | Dune::GridGlue::GlobalId |
| class | Dune::GridGlue::CommDataHandle< DataHandleImp, DataTypeImp > |
| describes the features of a data handle for communication in parallel runs using the GridGlue::communicate methods. More... | |
| class | Dune::GridGlue::StreamingMessageBuffer< DT > |
| class | Dune::GridGlue::CommunicationOperator< dir > |
| forward gather scatter to user defined CommInfo class More... | |
| struct | Dune::GridGlue::CommInfo< GG, DataHandleImp, DataTypeImp > |
| collects all GridGlue data requried for communication More... | |
| struct | Dune::CommPolicy< ::Dune::GridGlue::CommInfo< GG, DataHandleImp, DataTypeImp > > |
| specialization of the CommPolicy struct, required for the ParallelIndexsets More... | |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
│ │ │ │ +Typedefs | |
| typedef std::pair< int, int > | Dune::GridGlue::RankPair |
| typedef CommunicationOperator< Dune::ForwardCommunication > | Dune::GridGlue::ForwardOperator |
| typedef CommunicationOperator< Dune::BackwardCommunication > | Dune::GridGlue::BackwardOperator |
│ │ │ │ +Functions | |
| std::ostream & | Dune::GridGlue::operator<< (std::ostream &os, const GlobalId &id) |
Detailed Description
│ │ │ │ -Implement iterators over GridGlue intersections.
│ │ │ │ +Describes the parallel communication interface class for Dune::GridGlue.
│ │ │ │ │ │ │ ││ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,27 +5,62 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Classes | Namespaces
│ │ │ │ │ -intersectioniterator.hh File Reference
│ │ │ │ │ -Implement iterators over GridGlue intersections. More...
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ intersectioniterator.hh
gridgluecommunicate.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -Central component of the module implementing the coupling of two grids.
197 static const typename CommInfo::DataType& gather(const CommInfo& commInfo, size_t i, size_t j = 0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 227 static void scatter(CommInfo& commInfo, const typename CommInfo::DataType& v, std::size_t i, std::size_t j = 0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ Definition: gridglue.hh:37
sequential adapter to couple two grids at specified close together boundaries
Definition: gridglue.hh:67
Definition: intersectioniterator.hh:25
::Dune::GridGlue::GridGlue< P0, P1 > GridGlue
Definition: intersectioniterator.hh:28
const Intersection & dereference() const
Definition: intersectioniterator.hh:37
void increment()
Definition: intersectioniterator.hh:44
::Dune::GridGlue::Intersection< P0, P1, inside, outside > Intersection
Definition: intersectioniterator.hh:29
IntersectionIterator(const GridGlue *glue, unsigned int i)
Definition: intersectioniterator.hh:31
bool equals(const IntersectionIterator &iter) const
Definition: intersectioniterator.hh:49
CommunicationOperator< Dune::BackwardCommunication > BackwardOperator
Definition: gridgluecommunicate.hh:264
CommunicationOperator< Dune::ForwardCommunication > ForwardOperator
Definition: gridgluecommunicate.hh:263
std::ostream & operator<<(std::ostream &os, const GlobalId &id)
Definition: gridgluecommunicate.hh:55
The intersection of two entities of the two patches of a GridGlue.
Definition: intersection.hh:261
Intersection< P0, P1, O, I > flip() const
Return a copy of the intersection with inside and outside switched.
Definition: intersection.hh:483
bool self() const
For parallel computations: Return true if inside() entity exists locally.
Definition: intersection.hh:393
InsideEntity inside(unsigned int parentId=0) const
Return element on the inside of this intersection.
Definition: intersection.hh:319
size_t neighbor(unsigned int g=0) const
Return number of embeddings into local grid0 (grid1) entities.
Definition: intersection.hh:399
OutsideEntity outside(unsigned int parentId=0) const
Return element on the outside of this intersection.
Definition: intersection.hh:328
Definition: gridgluecommunicate.hh:26
GlobalId(int i, int j, unsigned int n)
Definition: gridgluecommunicate.hh:48
describes the features of a data handle for communication in parallel runs using the GridGlue::commun...
Definition: gridgluecommunicate.hh:77
size_t size(RISType &i) const
Definition: gridgluecommunicate.hh:92
void scatter(MessageBufferImp &buff, const EntityType &e, const RISType &i, size_t n)
Definition: gridgluecommunicate.hh:118
void gather(MessageBufferImp &buff, const EntityType &e, const RISType &i) const
pack data from user to message buffer
Definition: gridgluecommunicate.hh:104
DataTypeImp DataType
data type of data to communicate
Definition: gridgluecommunicate.hh:80
Definition: gridgluecommunicate.hh:141
StreamingMessageBuffer(DT *p)
Definition: gridgluecommunicate.hh:146
size_t counter() const
Definition: gridgluecommunicate.hh:169
void write(const Y &data)
Definition: gridgluecommunicate.hh:155
void read(Y &data) const
Definition: gridgluecommunicate.hh:163
DT value_type
Definition: gridgluecommunicate.hh:143
forward gather scatter to user defined CommInfo class
Definition: gridgluecommunicate.hh:194
static void scatter(CommInfo &commInfo, const typename CommInfo::DataType &v, std::size_t i, std::size_t j=0)
Definition: gridgluecommunicate.hh:227
static const CommInfo::DataType & gather(const CommInfo &commInfo, size_t i, size_t j=0)
Definition: gridgluecommunicate.hh:197
collects all GridGlue data requried for communication
Definition: gridgluecommunicate.hh:272
::Dune::GridGlue::CommDataHandle< DataHandleImp, DataTypeImp > * data
Definition: gridgluecommunicate.hh:282
mutable ::Dune::GridGlue::StreamingMessageBuffer< DataType > mbuffer
Definition: gridgluecommunicate.hh:286
std::vector< DataType > buffer
Definition: gridgluecommunicate.hh:285
static size_t getSize(const Type &commInfo, size_t i)
Get the number of objects at an intersection.
Definition: gridgluecommunicate.hh:320
DataTypeImp IndexedType
The datatype that should be communicated.
Definition: gridgluecommunicate.hh:309
::Dune::GridGlue::CommInfo< GG, DataHandleImp, DataTypeImp > Type
The type of the GridGlueCommInfo.
Definition: gridgluecommunicate.hh:304
VariableSize IndexedTypeFlag
Each intersection can communicate a different number of objects.
Definition: gridgluecommunicate.hh:315
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,100 +5,443 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -intersectioniterator.hh
│ │ │ │ │ +gridgluecommunicate.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 12#ifndef DUNE_GRIDGLUE_ADAPTER_INTERSECTIONITERATOR_HH
│ │ │ │ │ - 13#define DUNE_GRIDGLUE_ADAPTER_INTERSECTIONITERATOR_HH
│ │ │ │ │ + 5#ifndef DUNE_GRIDGLUE_ADAPTER_GRIDGLUECOMMUNICATE_HH
│ │ │ │ │ + 6#define DUNE_GRIDGLUE_ADAPTER_GRIDGLUECOMMUNICATE_HH
│ │ │ │ │ + 7
│ │ │ │ │ + 13#include
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ gridglue.cc File Reference
rangegenerators.hh File Reference
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,28 +5,28 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Namespaces | Functions
│ │ │ │ │ -gridglue.cc File Reference
│ │ │ │ │ -#include "intersection.hh"
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include "../gridglue.hh"
│ │ │ │ │ -#include "../common/ringcomm.hh"
│ │ │ │ │ -#include
│ │ │ │ │ +Classes | Namespaces | Functions
│ │ │ │ │ +rangegenerators.hh File Reference
│ │ │ │ │ +#include
│ │ │ │ │ +Go_to_the_source_code_of_this_file.
│ │ │ │ │ + Classes
│ │ │ │ │ +struct Dune::GridGlue::Reverse<_reverse_>
│ │ │ │ │ +
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ Functions
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::printVector (const std::vector< T > &v, std::string name,
│ │ │ │ │ - int rank)
│ │ │ │ │ +template<... >
│ │ │ │ │ +IteratorRange<... > Dune::GridGlue::intersections (const GridGlue<... > &glue,
│ │ │ │ │ + const Reverse<... > &reverse=!reversed)
│ │ │ │ │ + Iterate over all intersections of a GridGlue. More...
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00017.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: gridgluecommunicate.hh File Reference
│ │ │ │ +dune-grid-glue: intersectioniterator.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -64,73 +64,39 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,28 +5,29 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Classes | Namespaces | Functions
│ │ │ │ │ -rangegenerators.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ │ +Classes | Namespaces
│ │ │ │ │ +gridglueamirawriter.hh File Reference
│ │ │ │ │ +Write all remote intersections to a AmiraMesh file. More...
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Classes
│ │ │ │ │ -struct Dune::GridGlue::Reverse<_reverse_>
│ │ │ │ │ +class Dune::GridGlue::GridGlueAmiraWriter
│ │ │ │ │ + Write remote intersections to a AmiraMesh file for debugging purposes.
│ │ │ │ │ + More...
│ │ │ │ │
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ - Functions
│ │ │ │ │ -template<... >
│ │ │ │ │ -IteratorRange<... > Dune::GridGlue::intersections (const GridGlue<... > &glue,
│ │ │ │ │ - const Reverse<... > &reverse=!reversed)
│ │ │ │ │ - Iterate over all intersections of a GridGlue. More...
│ │ │ │ │ -
│ │ │ │ │ +***** Detailed Description *****
│ │ │ │ │ +Write all remote intersections to a AmiraMesh file.
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00023_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: rangegenerators.hh Source File
│ │ │ │ +dune-grid-glue: gridglueamirawriter.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -62,74 +62,162 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,89 +5,166 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -rangegenerators.hh
│ │ │ │ │ +gridglueamirawriter.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#ifndef DUNE_GRIDGLUE_ADAPTER_RANGEGENERATORS_HH
│ │ │ │ │ - 4#define DUNE_GRIDGLUE_ADAPTER_RANGEGENERATORS_HH
│ │ │ │ │ - 5
│ │ │ │ │ - 6#include
│ │ │ │ │ - 7
│ │ │ │ │ - 8namespace Dune {
│ │ │ │ │ - 9namespace GridGlue {
│ │ │ │ │ + 8#ifndef DUNE_GRIDGLUE_ADAPTER_GRIDGLUEAMIRAWRITER_HH
│ │ │ │ │ + 9#define DUNE_GRIDGLUE_ADAPTER_GRIDGLUEAMIRAWRITER_HH
│ │ │ │ │ 10
│ │ │ │ │ - 14template
│ │ │ │ │ -15struct Reverse
│ │ │ │ │ - 16 : std::integral_constant
│ │ │ │ │ - 17{
│ │ │ │ │ -18 typedef Reverse type;
│ │ │ │ │ - 19
│ │ │ │ │ - 20 constexpr
│ │ │ │ │ -21 Reverse operator!() const
│ │ │ │ │ - 22 { return {}; }
│ │ │ │ │ - 23};
│ │ │ │ │ - 24
│ │ │ │ │ - 25#ifdef DOXYGEN
│ │ │ │ │ - 26
│ │ │ │ │ -31const Reverse reversed;
│ │ │ │ │ + 11#include
│ │ │ │ │ + 12#include
│ │ │ │ │ + 13#include
│ │ │ │ │ + 14
│ │ │ │ │ + 15namespace Dune {
│ │ │ │ │ + 16namespace GridGlue {
│ │ │ │ │ + 17
│ │ │ │ │ +20class GridGlueAmiraWriter
│ │ │ │ │ + 21{
│ │ │ │ │ + 22
│ │ │ │ │ + 26 template
│ │ │ │ │ + 27 static void writeIntersections(const Glue& glue, const std::string&
│ │ │ │ │ +filename)
│ │ │ │ │ + 28 {
│ │ │ │ │ + 29 static_assert((side==0 || side==1), "'side' can only be 0 or 1");
│ │ │ │ │ + 30
│ │ │ │ │ + 31 std::ofstream fgrid;
│ │ │ │ │ 32
│ │ │ │ │ - 66template<...>
│ │ │ │ │ - 67IteratorRange<...>
│ │ │ │ │ -68intersections(const GridGlue<...>& glue, const Reverse<...>& reverse =
│ │ │ │ │ -!reversed);
│ │ │ │ │ - 69
│ │ │ │ │ - 70#else
│ │ │ │ │ - 71
│ │ │ │ │ - 72namespace {
│ │ │ │ │ - 73const Reverse reversed = {};
│ │ │ │ │ - 74} /* namespace */
│ │ │ │ │ + 33 fgrid.open(filename.c_str());
│ │ │ │ │ + 34
│ │ │ │ │ + 35 using GridView = typename Glue::template GridView;
│ │ │ │ │ + 36 const int dim = GridView::dimension;
│ │ │ │ │ + 37 const int domdimw = GridView::dimensionworld;
│ │ │ │ │ + 38
│ │ │ │ │ + 39 // coordinates have to be in R^3 in the VTK format
│ │ │ │ │ + 40 std::string coordinatePadding;
│ │ │ │ │ + 41 for (int i=domdimw; i<3; i++)
│ │ │ │ │ + 42 coordinatePadding += " 0";
│ │ │ │ │ + 43
│ │ │ │ │ + 44 int overlaps = glue.size();
│ │ │ │ │ + 45
│ │ │ │ │ + 46 if (dim==3) {
│ │ │ │ │ + 47
│ │ │ │ │ + 48 fgrid << "# HyperSurface 0.1 ASCII \n" << std::endl;
│ │ │ │ │ + 49 fgrid<<"\n";
│ │ │ │ │ + 50 fgrid<<"Parameters {\n";
│ │ │ │ │ + 51 fgrid<<" Materials {\n";
│ │ │ │ │ + 52 fgrid<<" outside {\n";
│ │ │ │ │ + 53 fgrid<<" Id 0\n";
│ │ │ │ │ + 54 fgrid<<" }\n";
│ │ │ │ │ + 55 fgrid<<" inside {\n";
│ │ │ │ │ + 56 fgrid<<" Id 1\n";
│ │ │ │ │ + 57 fgrid<<" }\n";
│ │ │ │ │ + 58 fgrid<<" }\n";
│ │ │ │ │ + 59 fgrid<<"\n";
│ │ │ │ │ + 60 fgrid<<"}\n";
│ │ │ │ │ + 61
│ │ │ │ │ + 62 // ////////////////////////////////////////////
│ │ │ │ │ + 63 // Write vertices
│ │ │ │ │ + 64 // ////////////////////////////////////////////
│ │ │ │ │ + 65
│ │ │ │ │ + 66 //use dim and not dim+1
│ │ │ │ │ + 67 fgrid<<"\nVertices "<< overlaps*(dim)<<"\n";
│ │ │ │ │ + 68 auto isEnd = glue.template iend();
│ │ │ │ │ + 69 for (auto isIt = glue.template ibegin(); isIt != isEnd; ++isIt)
│ │ │ │ │ + 70 {
│ │ │ │ │ + 71 const auto& geometry = isIt->geometry();
│ │ │ │ │ + 72 for (int i = 0; i < geometry.corners(); ++i)
│ │ │ │ │ + 73 fgrid << geometry.corner(i) << coordinatePadding << std::endl;
│ │ │ │ │ + 74 }
│ │ │ │ │ 75
│ │ │ │ │ - 76template
│ │ │ │ │ - 77IteratorRange< typename GridGlue::template
│ │ │ │ │ -IntersectionIterator >
│ │ │ │ │ - 78intersections(const GridGlue& glue, const Reverse& = {})
│ │ │ │ │ - 79{
│ │ │ │ │ - 80 const static int side = reverse ? 1 : 0;
│ │ │ │ │ - 81 return {glue.template ibegin(), glue.template iend()};
│ │ │ │ │ - 82}
│ │ │ │ │ - 83
│ │ │ │ │ - 84#endif // DOXYGEN
│ │ │ │ │ - 85
│ │ │ │ │ - 86} /* namespace GridGlue */
│ │ │ │ │ - 87} /* namespace Dune */
│ │ │ │ │ - 88
│ │ │ │ │ - 89#endif
│ │ │ │ │ + 76 // ////////////////////////////////////////////
│ │ │ │ │ + 77 // Write triangles
│ │ │ │ │ + 78 // ////////////////////////////////////////////
│ │ │ │ │ + 79
│ │ │ │ │ + 80 fgrid<<"NBranchingPoints 0\n";
│ │ │ │ │ + 81 fgrid<<"NVerticesOnCurves 0\n";
│ │ │ │ │ + 82 fgrid<<"BoundaryCurves 0\n";
│ │ │ │ │ + 83 fgrid<<"Patches 1\n";
│ │ │ │ │ + 84 fgrid<<"{\n";
│ │ │ │ │ + 85 fgrid<<"InnerRegion inside\n";
│ │ │ │ │ + 86 fgrid<<"OuterRegion outside\n";
│ │ │ │ │ + 87 fgrid<<"BoundaryID 0\n";
│ │ │ │ │ + 88 fgrid<<"BranchingPoints 0";
│ │ │ │ │ + 89 fgrid<<"\n";
│ │ │ │ │ + 90
│ │ │ │ │ + 91 fgrid<<"Triangles "<();
│ │ │ │ │ + 119 for (auto isIt = glue.template ibegin(); isIt != isEnd; ++isIt) {
│ │ │ │ │ + 120 const auto& geometry = isIt->geometry();
│ │ │ │ │ + 121 for (int i = 0; i <2; ++i)
│ │ │ │ │ + 122 fgrid << geometry.corner(i) <<" "<<0<<"\n";
│ │ │ │ │ + 123 }
│ │ │ │ │ + 124 }
│ │ │ │ │ + 125
│ │ │ │ │ + 126 fgrid.close();
│ │ │ │ │ + 127 }
│ │ │ │ │ + 128
│ │ │ │ │ + 129public:
│ │ │ │ │ + 130 template
│ │ │ │ │ +131 static void write(const Glue& glue, const std::string& path, int
│ │ │ │ │ +appendix=1)
│ │ │ │ │ + 132 {
│ │ │ │ │ + 133 std::ostringstream name0;
│ │ │ │ │ + 134 name0 << path;
│ │ │ │ │ + 135 name0 << "/domain.surf" << std::setw(3) << std::setfill('0') << appendix;
│ │ │ │ │ + 136
│ │ │ │ │ + 137 // Write extracted grid and remote intersection on the grid1-side
│ │ │ │ │ + 138 writeIntersections(glue,name0.str());
│ │ │ │ │ + 139
│ │ │ │ │ + 140 std::ostringstream name1;
│ │ │ │ │ + 141 name1 << path;
│ │ │ │ │ + 142 name1 << "/target.surf" << std::setw(3) << std::setfill('0') << appendix;
│ │ │ │ │ + 143
│ │ │ │ │ + 144 writeIntersections(glue, name1.str());
│ │ │ │ │ + 145 }
│ │ │ │ │ + 146
│ │ │ │ │ + 147};
│ │ │ │ │ + 148
│ │ │ │ │ + 149} // namespace GridGlue
│ │ │ │ │ + 150} // namespace Dune
│ │ │ │ │ + 151
│ │ │ │ │ + 152#endif // DUNE_GRIDGLUE_ADAPTER_GRIDGLUEAMIRAWRITER_HH
│ │ │ │ │ Dune
│ │ │ │ │ Definition: gridglue.hh:37
│ │ │ │ │ -Dune::GridGlue::intersections
│ │ │ │ │ -IteratorRange<... > intersections(const GridGlue<... > &glue, const Reverse<...
│ │ │ │ │ -> &reverse=!reversed)
│ │ │ │ │ -Iterate over all intersections of a GridGlue.
│ │ │ │ │ -Dune::GridGlue::GridGlue
│ │ │ │ │ -sequential adapter to couple two grids at specified close together boundaries
│ │ │ │ │ -Definition: gridglue.hh:67
│ │ │ │ │ -Dune::GridGlue::GridGlue::intersections
│ │ │ │ │ -IteratorRange<... > intersections(const GridGlue<... > &glue, const Reverse<...
│ │ │ │ │ -> &reverse=!reversed)
│ │ │ │ │ -Iterate over all intersections of a GridGlue.
│ │ │ │ │ -Dune::GridGlue::Reverse
│ │ │ │ │ -Definition: rangegenerators.hh:17
│ │ │ │ │ -Dune::GridGlue::Reverse::reversed
│ │ │ │ │ -const Reverse< true > reversed
│ │ │ │ │ -Definition: rangegenerators.hh:31
│ │ │ │ │ -Dune::GridGlue::Reverse::type
│ │ │ │ │ -Reverse type
│ │ │ │ │ -Definition: rangegenerators.hh:18
│ │ │ │ │ -Dune::GridGlue::Reverse::operator!
│ │ │ │ │ -constexpr Reverse operator!() const
│ │ │ │ │ -Definition: rangegenerators.hh:21
│ │ │ │ │ +Dune::GridGlue::GridGlueAmiraWriter
│ │ │ │ │ +Write remote intersections to a AmiraMesh file for debugging purposes.
│ │ │ │ │ +Definition: gridglueamirawriter.hh:21
│ │ │ │ │ +Dune::GridGlue::GridGlueAmiraWriter::write
│ │ │ │ │ +static void write(const Glue &glue, const std::string &path, int appendix=1)
│ │ │ │ │ +Definition: gridglueamirawriter.hh:131
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00026.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: gridglueamirawriter.hh File Reference
│ │ │ │ +dune-grid-glue: gridglue.cc File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -63,43 +63,39 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
#include "intersection.hh"│ │ │ │ -
#include <vector>│ │ │ │ -
#include <iterator>│ │ │ │ -
#include "../gridglue.hh"│ │ │ │ -
#include "../common/ringcomm.hh"│ │ │ │ -
#include <dune/common/unused.hh>│ │ │ │ -
│ │ │ │ +Classes | |
| struct | Dune::GridGlue::Reverse< reverse > |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
│ │ │ │ Functions | |
| template<typename T > | |
| void | Dune::GridGlue::printVector (const std::vector< T > &v, std::string name, int rank) |
| template<... > | |
| IteratorRange<... > | Dune::GridGlue::intersections (const GridGlue<... > &glue, const Reverse<... > &reverse=!reversed) |
| Iterate over all intersections of a GridGlue. More... | |
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,28 +5,28 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Namespaces | Functions
│ │ │ │ │ -gridglue.cc File Reference
│ │ │ │ │ -#include "intersection.hh"
│ │ │ │ │ -#include -
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ +Namespaces
│ │ │ │ + gridgluecommunicate.hh File Reference
intersectioniterator.hh File Reference
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,62 +5,27 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Classes | Namespaces | Typedefs | Functions
│ │ │ │ │ -gridgluecommunicate.hh File Reference
│ │ │ │ │ -Describes the parallel communication interface class for Dune::GridGlue.
│ │ │ │ │ -More...
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +Classes | Namespaces
│ │ │ │ │ +intersectioniterator.hh File Reference
│ │ │ │ │ +Implement iterators over GridGlue intersections. More...
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Classes
│ │ │ │ │ -struct Dune::GridGlue::GlobalId
│ │ │ │ │ -
│ │ │ │ │ - class Dune::GridGlue::CommDataHandle<_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ - describes the features of a data handle for communication in parallel
│ │ │ │ │ - runs using the GridGlue::communicate methods. More...
│ │ │ │ │ -
│ │ │ │ │ - class Dune::GridGlue::StreamingMessageBuffer<_DT_>
│ │ │ │ │ -
│ │ │ │ │ - class Dune::GridGlue::CommunicationOperator<_dir_>
│ │ │ │ │ - forward gather scatter to user defined CommInfo class More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ - collects all GridGlue data requried for communication More...
│ │ │ │ │ -
│ │ │ │ │ -struct Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,
│ │ │ │ │ - DataTypeImp_>_>
│ │ │ │ │ - specialization of the CommPolicy struct, required for the
│ │ │ │ │ - ParallelIndexsets More...
│ │ │ │ │ +class Dune::GridGlue::IntersectionIterator<_P0,_P1,_inside,_outside_>
│ │ │ │ │
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ - Typedefs
│ │ │ │ │ - typedef std::pair< int, int > Dune::GridGlue::RankPair
│ │ │ │ │ -
│ │ │ │ │ -typedef CommunicationOperator< Dune::
│ │ │ │ │ - ForwardCommunication > Dune::GridGlue::ForwardOperator
│ │ │ │ │ -
│ │ │ │ │ -typedef CommunicationOperator< Dune::
│ │ │ │ │ - BackwardCommunication > Dune::GridGlue::BackwardOperator
│ │ │ │ │ -
│ │ │ │ │ - Functions
│ │ │ │ │ -std::ostream & Dune::GridGlue::operator<< (std::ostream &os, const GlobalId
│ │ │ │ │ - &id)
│ │ │ │ │ -
│ │ │ │ │ ***** Detailed Description *****
│ │ │ │ │ -Describes the parallel communication interface class for Dune::GridGlue.
│ │ │ │ │ +Implement iterators over GridGlue intersections.
│ │ │ │ │ Author
│ │ │ │ │ Christian Engwer
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00017_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: gridgluecommunicate.hh Source File
│ │ │ │ +dune-grid-glue: intersectioniterator.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -62,323 +62,85 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,443 +5,100 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -gridgluecommunicate.hh
│ │ │ │ │ +intersectioniterator.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 5#ifndef DUNE_GRIDGLUE_ADAPTER_GRIDGLUECOMMUNICATE_HH
│ │ │ │ │ - 6#define DUNE_GRIDGLUE_ADAPTER_GRIDGLUECOMMUNICATE_HH
│ │ │ │ │ - 7
│ │ │ │ │ - 13#include
│ │ │ │ │ + 12#ifndef DUNE_GRIDGLUE_ADAPTER_INTERSECTIONITERATOR_HH
│ │ │ │ │ + 13#define DUNE_GRIDGLUE_ADAPTER_INTERSECTIONITERATOR_HH
│ │ │ │ │ 14
│ │ │ │ │ - 15#include
│ │ │ │ │ - 16#include
│ │ │ │ │ - 17#include
│ │ │ │ │ - 18#include
│ │ │ │ │ + 15#include
│ │ │ │ │ + 16
│ │ │ │ │ + 17namespace Dune {
│ │ │ │ │ + 18 namespace GridGlue {
│ │ │ │ │ 19
│ │ │ │ │ - 20
│ │ │ │ │ - 21namespace Dune {
│ │ │ │ │ - 22 namespace GridGlue {
│ │ │ │ │ - 23
│ │ │ │ │ -24 typedef std::pair RankPair;
│ │ │ │ │ -25 struct GlobalId : public std::pair
│ │ │ │ │ - 26 {
│ │ │ │ │ -30 GlobalId() {
│ │ │ │ │ - 31 this->first.first = 0;
│ │ │ │ │ - 32 this->first.second = 0;
│ │ │ │ │ - 33 this->second = 0;
│ │ │ │ │ - 34 }
│ │ │ │ │ -38 GlobalId(int i) {
│ │ │ │ │ - 39 this->first.first = i;
│ │ │ │ │ - 40 this->first.second = i;
│ │ │ │ │ - 41 this->second = 0;
│ │ │ │ │ + 21 template
│ │ │ │ │ +22 class IntersectionIterator :
│ │ │ │ │ + 23 public Dune::ForwardIteratorFacade<
│ │ │ │ │ +IntersectionIterator,
│ │ │ │ │ + 24 const Intersection >
│ │ │ │ │ + 25 {
│ │ │ │ │ + 26 public:
│ │ │ │ │ + 27
│ │ │ │ │ +28 typedef ::Dune::GridGlue::GridGlue GridGlue;
│ │ │ │ │ +29 typedef ::Dune::GridGlue::Intersection Intersection;
│ │ │ │ │ + 30
│ │ │ │ │ +31 IntersectionIterator(const GridGlue * glue, unsigned int i)
│ │ │ │ │ + 32 : glue_(glue),
│ │ │ │ │ + 33 index_(i),
│ │ │ │ │ + 34 intersection_(glue_, & glue_->intersections_[index_])
│ │ │ │ │ + 35 {}
│ │ │ │ │ + 36
│ │ │ │ │ +37 const Intersection& dereference() const
│ │ │ │ │ + 38 {
│ │ │ │ │ + 39 assert(("never dereference the end iterator" &&
│ │ │ │ │ + 40 index_ != glue_->index__sz));
│ │ │ │ │ + 41 return intersection_;
│ │ │ │ │ 42 }
│ │ │ │ │ -48 GlobalId(int i, int j, unsigned int n) {
│ │ │ │ │ - 49 this->first.first = std::min(i,j);
│ │ │ │ │ - 50 this->first.second = std::max(i,j);
│ │ │ │ │ - 51 this->second = n;
│ │ │ │ │ + 43
│ │ │ │ │ +44 void increment()
│ │ │ │ │ + 45 {
│ │ │ │ │ + 46 intersection_ = Intersection(glue_, & glue_->intersections_[++index_]);
│ │ │ │ │ + 47 }
│ │ │ │ │ + 48
│ │ │ │ │ +49 bool equals(const IntersectionIterator& iter) const
│ │ │ │ │ + 50 {
│ │ │ │ │ + 51 return iter.index_ == index_;
│ │ │ │ │ 52 }
│ │ │ │ │ - 53 };
│ │ │ │ │ - 54
│ │ │ │ │ -55 inline std::ostream& operator<<(std::ostream& os, const GlobalId & id)
│ │ │ │ │ - 56 {
│ │ │ │ │ - 57 os << "("
│ │ │ │ │ - 58 << id.first.first << "," << id.first.second << ","
│ │ │ │ │ - 59 << id.second << ")";
│ │ │ │ │ - 60 return os;
│ │ │ │ │ - 61 }
│ │ │ │ │ - 62
│ │ │ │ │ - 75 template
│ │ │ │ │ -76 class CommDataHandle
│ │ │ │ │ - 77 {
│ │ │ │ │ - 78 public:
│ │ │ │ │ -80 typedef DataTypeImp DataType;
│ │ │ │ │ - 81
│ │ │ │ │ - 82 protected:
│ │ │ │ │ - 83 // one should not create an explicit instance of this inteface object
│ │ │ │ │ -84 CommDataHandle() {}
│ │ │ │ │ - 85
│ │ │ │ │ - 86 public:
│ │ │ │ │ - 87
│ │ │ │ │ - 91 template
│ │ │ │ │ -92 size_t size (RISType& i) const
│ │ │ │ │ - 93 {
│ │ │ │ │ - 94 CHECK_INTERFACE_IMPLEMENTATION((asImp().size(i)));
│ │ │ │ │ - 95 return asImp().size(i);
│ │ │ │ │ - 96 }
│ │ │ │ │ - 97
│ │ │ │ │ - 103 template
│ │ │ │ │ -104 void gather (MessageBufferImp& buff, const EntityType& e, const RISType &
│ │ │ │ │ -i) const
│ │ │ │ │ - 105 {
│ │ │ │ │ - 106 MessageBufferIF buffIF(buff);
│ │ │ │ │ - 107 CHECK_AND_CALL_INTERFACE_IMPLEMENTATION((asImp().gather(buffIF,e,i)));
│ │ │ │ │ - 108 }
│ │ │ │ │ - 109
│ │ │ │ │ - 117 template
│ │ │ │ │ -118 void scatter (MessageBufferImp& buff, const EntityType& e, const RISType &
│ │ │ │ │ -i, size_t n)
│ │ │ │ │ - 119 {
│ │ │ │ │ - 120 MessageBufferIF buffIF(buff);
│ │ │ │ │ - 121 CHECK_AND_CALL_INTERFACE_IMPLEMENTATION((asImp().scatter(buffIF,e,i,n)));
│ │ │ │ │ - 122 }
│ │ │ │ │ - 123
│ │ │ │ │ - 124 private:
│ │ │ │ │ - 126 DataHandleImp& asImp () {
│ │ │ │ │ - 127 return static_cast (*this);
│ │ │ │ │ - 128 }
│ │ │ │ │ - 130 const DataHandleImp& asImp () const
│ │ │ │ │ - 131 {
│ │ │ │ │ - 132 return static_cast(*this);
│ │ │ │ │ - 133 }
│ │ │ │ │ - 134 }; // end class CommDataHandleIF
│ │ │ │ │ - 135
│ │ │ │ │ - 140 template
│ │ │ │ │ -141 class StreamingMessageBuffer {
│ │ │ │ │ - 142 public:
│ │ │ │ │ -143 typedef DT value_type;
│ │ │ │ │ - 144
│ │ │ │ │ - 145 // Constructor
│ │ │ │ │ -146 StreamingMessageBuffer (DT *p)
│ │ │ │ │ - 147 {
│ │ │ │ │ - 148 a=p;
│ │ │ │ │ - 149 i=0;
│ │ │ │ │ - 150 j=0;
│ │ │ │ │ - 151 }
│ │ │ │ │ - 152
│ │ │ │ │ - 153 // write data to message buffer, acts like a stream !
│ │ │ │ │ - 154 template
│ │ │ │ │ -155 void write (const Y& data)
│ │ │ │ │ - 156 {
│ │ │ │ │ - 157 static_assert(std::is_same::value, "DataType mismatch");
│ │ │ │ │ - 158 a[i++] = data;
│ │ │ │ │ - 159 }
│ │ │ │ │ - 160
│ │ │ │ │ - 161 // read data from message buffer, acts like a stream !
│ │ │ │ │ - 162 template
│ │ │ │ │ -163 void read (Y& data) const
│ │ │ │ │ - 164 {
│ │ │ │ │ - 165 static_assert(std::is_same::value, "DataType mismatch");
│ │ │ │ │ - 166 data = a[j++];
│ │ │ │ │ - 167 }
│ │ │ │ │ - 168
│ │ │ │ │ -169 size_t counter() const { return i; }
│ │ │ │ │ - 170
│ │ │ │ │ -171 void clear()
│ │ │ │ │ - 172 {
│ │ │ │ │ - 173 i = 0;
│ │ │ │ │ - 174 j = 0;
│ │ │ │ │ - 175 }
│ │ │ │ │ - 176
│ │ │ │ │ - 177 // we need access to these variables in an assertion
│ │ │ │ │ - 178#ifdef NDEBUG
│ │ │ │ │ - 179 private:
│ │ │ │ │ - 180#endif
│ │ │ │ │ -181 DT *a;
│ │ │ │ │ -182 size_t i;
│ │ │ │ │ -183 mutable size_t j;
│ │ │ │ │ - 184 };
│ │ │ │ │ - 185
│ │ │ │ │ - 192 template
│ │ │ │ │ -193 class CommunicationOperator
│ │ │ │ │ - 194 {
│ │ │ │ │ - 195 public:
│ │ │ │ │ - 196 template
│ │ │ │ │ -197 static const typename CommInfo::DataType& gather(const CommInfo& commInfo,
│ │ │ │ │ -size_t i, size_t j = 0)
│ │ │ │ │ - 198 {
│ │ │ │ │ - 199 // get Intersection
│ │ │ │ │ - 200 typedef typename CommInfo::GridGlue::Intersection Intersection;
│ │ │ │ │ - 201 Intersection ris(commInfo.gridglue->getIntersection(i));
│ │ │ │ │ - 202
│ │ │ │ │ - 203 // fill buffer if we have a new intersection
│ │ │ │ │ - 204 if (j == 0)
│ │ │ │ │ - 205 {
│ │ │ │ │ - 206 commInfo.mbuffer.clear();
│ │ │ │ │ - 207 if (dir == Dune::ForwardCommunication)
│ │ │ │ │ - 208 {
│ │ │ │ │ - 209 // read from grid0
│ │ │ │ │ - 210 if(ris.self())
│ │ │ │ │ - 211 commInfo.data->gather(commInfo.mbuffer, ris.inside(), ris);
│ │ │ │ │ - 212 }
│ │ │ │ │ - 213 else // (dir == Dune::BackwardCommunication)
│ │ │ │ │ - 214 {
│ │ │ │ │ - 215 // read from grid1
│ │ │ │ │ - 216 if(ris.neighbor())
│ │ │ │ │ - 217 commInfo.data->gather(commInfo.mbuffer, ris.outside(), ris.flip());
│ │ │ │ │ - 218 }
│ │ │ │ │ - 219 }
│ │ │ │ │ - 220
│ │ │ │ │ - 221 // return the j'th value in the buffer
│ │ │ │ │ - 222 assert(j < commInfo.mbuffer.i);
│ │ │ │ │ - 223 return commInfo.buffer[j];
│ │ │ │ │ - 224 }
│ │ │ │ │ - 225
│ │ │ │ │ - 226 template
│ │ │ │ │ -227 static void scatter(CommInfo& commInfo, const typename CommInfo::DataType&
│ │ │ │ │ -v, std::size_t i, std::size_t j = 0)
│ │ │ │ │ - 228 {
│ │ │ │ │ - 229 // extract GridGlue objects...
│ │ │ │ │ - 230 typedef typename CommInfo::GridGlue::Intersection Intersection;
│ │ │ │ │ - 231 Intersection ris(commInfo.gridglue->getIntersection(i));
│ │ │ │ │ - 232
│ │ │ │ │ - 233 // get size if we have a new intersection
│ │ │ │ │ - 234 if (j == 0)
│ │ │ │ │ - 235 {
│ │ │ │ │ - 236 commInfo.mbuffer.clear();
│ │ │ │ │ - 237 commInfo.currentsize = commInfo.data->size(ris);
│ │ │ │ │ - 238 }
│ │ │ │ │ - 239
│ │ │ │ │ - 240 // write entry to buffer
│ │ │ │ │ - 241 commInfo.buffer[j] = v;
│ │ │ │ │ - 242
│ │ │ │ │ - 243 // write back the buffer if we are at the end of this intersection
│ │ │ │ │ - 244 if (j == commInfo.currentsize-1)
│ │ │ │ │ - 245 {
│ │ │ │ │ - 246 if (dir == Dune::ForwardCommunication)
│ │ │ │ │ - 247 {
│ │ │ │ │ - 248 // write to grid1
│ │ │ │ │ - 249 if(ris.neighbor())
│ │ │ │ │ - 250 commInfo.data->scatter(commInfo.mbuffer, ris.outside(), ris.flip(),
│ │ │ │ │ -commInfo.currentsize);
│ │ │ │ │ - 251 }
│ │ │ │ │ - 252 else // (dir == Dune::BackwardCommunication)
│ │ │ │ │ - 253 {
│ │ │ │ │ - 254 // write to grid0
│ │ │ │ │ - 255 if(ris.self())
│ │ │ │ │ - 256 commInfo.data->scatter(commInfo.mbuffer, ris.inside(), ris,
│ │ │ │ │ -commInfo.currentsize);
│ │ │ │ │ - 257 }
│ │ │ │ │ - 258 assert(commInfo.mbuffer.j <= commInfo.currentsize);
│ │ │ │ │ - 259 }
│ │ │ │ │ - 260 }
│ │ │ │ │ - 261 };
│ │ │ │ │ - 262
│ │ │ │ │ -263 typedef CommunicationOperator ForwardOperator;
│ │ │ │ │ -264 typedef CommunicationOperator
│ │ │ │ │ -BackwardOperator;
│ │ │ │ │ - 265
│ │ │ │ │ - 270 template
│ │ │ │ │ -271 struct CommInfo
│ │ │ │ │ - 272 {
│ │ │ │ │ -273 typedef DataTypeImp value_type;
│ │ │ │ │ -274 typedef GG GridGlue;
│ │ │ │ │ -275 typedef DataTypeImp DataType;
│ │ │ │ │ - 276
│ │ │ │ │ -277 CommInfo() : buffer(100), mbuffer(&buffer[0])
│ │ │ │ │ - 278 {}
│ │ │ │ │ - 279
│ │ │ │ │ - 280 // tunnel information to the policy and the operators
│ │ │ │ │ -281 const GridGlue * gridglue;
│ │ │ │ │ -282 ::Dune::GridGlue::CommDataHandle * data;
│ │ │ │ │ - 283
│ │ │ │ │ - 284 // state variables
│ │ │ │ │ -285 std::vector buffer;
│ │ │ │ │ -286 mutable ::Dune::GridGlue::StreamingMessageBuffer mbuffer;
│ │ │ │ │ -287 size_t currentsize;
│ │ │ │ │ -288 Dune::CommunicationDirection dir;
│ │ │ │ │ - 289 };
│ │ │ │ │ - 290
│ │ │ │ │ - 291 } // end namespace GridGlue
│ │ │ │ │ - 292
│ │ │ │ │ - 293#if HAVE_MPI
│ │ │ │ │ - 298 template
│ │ │ │ │ -299 struct CommPolicy< ::Dune::GridGlue::CommInfo >
│ │ │ │ │ - 300 {
│ │ │ │ │ -304 typedef ::Dune::GridGlue::CommInfo Type;
│ │ │ │ │ - 305
│ │ │ │ │ -309 typedef DataTypeImp IndexedType;
│ │ │ │ │ - 310
│ │ │ │ │ - 314 // typedef SizeOne IndexedTypeFlag;
│ │ │ │ │ -315 typedef VariableSize IndexedTypeFlag;
│ │ │ │ │ - 316
│ │ │ │ │ -320 static size_t getSize(const Type& commInfo, size_t i)
│ │ │ │ │ - 321 {
│ │ │ │ │ - 322 // get Intersection
│ │ │ │ │ - 323 typedef typename Type::GridGlue::Intersection Intersection;
│ │ │ │ │ - 324 Intersection ris(commInfo.gridglue->getIntersection(i));
│ │ │ │ │ - 325
│ │ │ │ │ - 326 // ask data handle for size
│ │ │ │ │ - 327 return commInfo.data->size(ris);
│ │ │ │ │ - 328 }
│ │ │ │ │ - 329 };
│ │ │ │ │ - 330#endif
│ │ │ │ │ - 331
│ │ │ │ │ - 332} // end namespace Dune
│ │ │ │ │ - 333#endif
│ │ │ │ │ + 53
│ │ │ │ │ + 54 private:
│ │ │ │ │ + 55
│ │ │ │ │ + 56 const GridGlue* glue_;
│ │ │ │ │ + 57 unsigned int index_;
│ │ │ │ │ + 58
│ │ │ │ │ + 59 Intersection intersection_;
│ │ │ │ │ + 60 };
│ │ │ │ │ + 61
│ │ │ │ │ + 62 } // end namespace GridGlue
│ │ │ │ │ + 63} // end namespace Dune
│ │ │ │ │ + 64
│ │ │ │ │ + 65#endif // DUNE_GRIDGLUE_ADAPTER_INTERSECTIONITERATOR_HH
│ │ │ │ │ +gridglue.hh
│ │ │ │ │ +Central component of the module implementing the coupling of two grids.
│ │ │ │ │ Dune
│ │ │ │ │ Definition: gridglue.hh:37
│ │ │ │ │ -Dune::GridGlue::BackwardOperator
│ │ │ │ │ -CommunicationOperator< Dune::BackwardCommunication > BackwardOperator
│ │ │ │ │ -Definition: gridgluecommunicate.hh:264
│ │ │ │ │ -Dune::GridGlue::ForwardOperator
│ │ │ │ │ -CommunicationOperator< Dune::ForwardCommunication > ForwardOperator
│ │ │ │ │ -Definition: gridgluecommunicate.hh:263
│ │ │ │ │ -Dune::GridGlue::RankPair
│ │ │ │ │ -std::pair< int, int > RankPair
│ │ │ │ │ -Definition: gridgluecommunicate.hh:24
│ │ │ │ │ -Dune::GridGlue::operator<<
│ │ │ │ │ -std::ostream & operator<<(std::ostream &os, const GlobalId &id)
│ │ │ │ │ -Definition: gridgluecommunicate.hh:55
│ │ │ │ │ -Dune::GridGlue::Intersection
│ │ │ │ │ -The intersection of two entities of the two patches of a GridGlue.
│ │ │ │ │ -Definition: intersection.hh:261
│ │ │ │ │ -Dune::GridGlue::Intersection::flip
│ │ │ │ │ -Intersection< P0, P1, O, I > flip() const
│ │ │ │ │ -Return a copy of the intersection with inside and outside switched.
│ │ │ │ │ -Definition: intersection.hh:483
│ │ │ │ │ -Dune::GridGlue::Intersection::self
│ │ │ │ │ -bool self() const
│ │ │ │ │ -For parallel computations: Return true if inside() entity exists locally.
│ │ │ │ │ -Definition: intersection.hh:393
│ │ │ │ │ -Dune::GridGlue::Intersection::inside
│ │ │ │ │ -InsideEntity inside(unsigned int parentId=0) const
│ │ │ │ │ -Return element on the inside of this intersection.
│ │ │ │ │ -Definition: intersection.hh:319
│ │ │ │ │ -Dune::GridGlue::Intersection::neighbor
│ │ │ │ │ -size_t neighbor(unsigned int g=0) const
│ │ │ │ │ -Return number of embeddings into local grid0 (grid1) entities.
│ │ │ │ │ -Definition: intersection.hh:399
│ │ │ │ │ -Dune::GridGlue::Intersection::outside
│ │ │ │ │ -OutsideEntity outside(unsigned int parentId=0) const
│ │ │ │ │ -Return element on the outside of this intersection.
│ │ │ │ │ -Definition: intersection.hh:328
│ │ │ │ │ -Dune::GridGlue::GlobalId
│ │ │ │ │ -Definition: gridgluecommunicate.hh:26
│ │ │ │ │ -Dune::GridGlue::GlobalId::GlobalId
│ │ │ │ │ -GlobalId(int i)
│ │ │ │ │ -Definition: gridgluecommunicate.hh:38
│ │ │ │ │ -Dune::GridGlue::GlobalId::GlobalId
│ │ │ │ │ -GlobalId()
│ │ │ │ │ -Definition: gridgluecommunicate.hh:30
│ │ │ │ │ -Dune::GridGlue::GlobalId::GlobalId
│ │ │ │ │ -GlobalId(int i, int j, unsigned int n)
│ │ │ │ │ -Definition: gridgluecommunicate.hh:48
│ │ │ │ │ -Dune::GridGlue::CommDataHandle
│ │ │ │ │ -describes the features of a data handle for communication in parallel runs
│ │ │ │ │ -using the GridGlue::commun...
│ │ │ │ │ -Definition: gridgluecommunicate.hh:77
│ │ │ │ │ -Dune::GridGlue::CommDataHandle::size
│ │ │ │ │ -size_t size(RISType &i) const
│ │ │ │ │ -Definition: gridgluecommunicate.hh:92
│ │ │ │ │ -Dune::GridGlue::CommDataHandle::scatter
│ │ │ │ │ -void scatter(MessageBufferImp &buff, const EntityType &e, const RISType &i,
│ │ │ │ │ -size_t n)
│ │ │ │ │ -Definition: gridgluecommunicate.hh:118
│ │ │ │ │ -Dune::GridGlue::CommDataHandle::gather
│ │ │ │ │ -void gather(MessageBufferImp &buff, const EntityType &e, const RISType &i)
│ │ │ │ │ -const
│ │ │ │ │ -pack data from user to message buffer
│ │ │ │ │ -Definition: gridgluecommunicate.hh:104
│ │ │ │ │ -Dune::GridGlue::CommDataHandle::DataType
│ │ │ │ │ -DataTypeImp DataType
│ │ │ │ │ -data type of data to communicate
│ │ │ │ │ -Definition: gridgluecommunicate.hh:80
│ │ │ │ │ -Dune::GridGlue::CommDataHandle::CommDataHandle
│ │ │ │ │ -CommDataHandle()
│ │ │ │ │ -Definition: gridgluecommunicate.hh:84
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer
│ │ │ │ │ -Definition: gridgluecommunicate.hh:141
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::j
│ │ │ │ │ -size_t j
│ │ │ │ │ -Definition: gridgluecommunicate.hh:183
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::StreamingMessageBuffer
│ │ │ │ │ -StreamingMessageBuffer(DT *p)
│ │ │ │ │ -Definition: gridgluecommunicate.hh:146
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::a
│ │ │ │ │ -DT * a
│ │ │ │ │ -Definition: gridgluecommunicate.hh:181
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::counter
│ │ │ │ │ -size_t counter() const
│ │ │ │ │ -Definition: gridgluecommunicate.hh:169
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::write
│ │ │ │ │ -void write(const Y &data)
│ │ │ │ │ -Definition: gridgluecommunicate.hh:155
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::read
│ │ │ │ │ -void read(Y &data) const
│ │ │ │ │ -Definition: gridgluecommunicate.hh:163
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::value_type
│ │ │ │ │ -DT value_type
│ │ │ │ │ -Definition: gridgluecommunicate.hh:143
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::i
│ │ │ │ │ -size_t i
│ │ │ │ │ -Definition: gridgluecommunicate.hh:182
│ │ │ │ │ -Dune::GridGlue::StreamingMessageBuffer::clear
│ │ │ │ │ -void clear()
│ │ │ │ │ -Definition: gridgluecommunicate.hh:171
│ │ │ │ │ -Dune::GridGlue::CommunicationOperator
│ │ │ │ │ -forward gather scatter to user defined CommInfo class
│ │ │ │ │ -Definition: gridgluecommunicate.hh:194
│ │ │ │ │ -Dune::GridGlue::CommunicationOperator::scatter
│ │ │ │ │ -static void scatter(CommInfo &commInfo, const typename CommInfo::DataType &v,
│ │ │ │ │ -std::size_t i, std::size_t j=0)
│ │ │ │ │ -Definition: gridgluecommunicate.hh:227
│ │ │ │ │ -Dune::GridGlue::CommunicationOperator::gather
│ │ │ │ │ -static const CommInfo::DataType & gather(const CommInfo &commInfo, size_t i,
│ │ │ │ │ -size_t j=0)
│ │ │ │ │ -Definition: gridgluecommunicate.hh:197
│ │ │ │ │ -Dune::GridGlue::CommInfo
│ │ │ │ │ -collects all GridGlue data requried for communication
│ │ │ │ │ -Definition: gridgluecommunicate.hh:272
│ │ │ │ │ -Dune::GridGlue::CommInfo::dir
│ │ │ │ │ -Dune::CommunicationDirection dir
│ │ │ │ │ -Definition: gridgluecommunicate.hh:288
│ │ │ │ │ -Dune::GridGlue::CommInfo::value_type
│ │ │ │ │ -DataTypeImp value_type
│ │ │ │ │ -Definition: gridgluecommunicate.hh:273
│ │ │ │ │ -Dune::GridGlue::CommInfo::DataType
│ │ │ │ │ -DataTypeImp DataType
│ │ │ │ │ -Definition: gridgluecommunicate.hh:275
│ │ │ │ │ -Dune::GridGlue::CommInfo::data
│ │ │ │ │ -::Dune::GridGlue::CommDataHandle< DataHandleImp, DataTypeImp > * data
│ │ │ │ │ -Definition: gridgluecommunicate.hh:282
│ │ │ │ │ -Dune::GridGlue::CommInfo::GridGlue
│ │ │ │ │ -GG GridGlue
│ │ │ │ │ -Definition: gridgluecommunicate.hh:274
│ │ │ │ │ -Dune::GridGlue::CommInfo::currentsize
│ │ │ │ │ -size_t currentsize
│ │ │ │ │ -Definition: gridgluecommunicate.hh:287
│ │ │ │ │ -Dune::GridGlue::CommInfo::CommInfo
│ │ │ │ │ -CommInfo()
│ │ │ │ │ -Definition: gridgluecommunicate.hh:277
│ │ │ │ │ -Dune::GridGlue::CommInfo::mbuffer
│ │ │ │ │ -mutable ::Dune::GridGlue::StreamingMessageBuffer< DataType > mbuffer
│ │ │ │ │ -Definition: gridgluecommunicate.hh:286
│ │ │ │ │ -Dune::GridGlue::CommInfo::gridglue
│ │ │ │ │ -const GridGlue * gridglue
│ │ │ │ │ -Definition: gridgluecommunicate.hh:281
│ │ │ │ │ -Dune::GridGlue::CommInfo::buffer
│ │ │ │ │ -std::vector< DataType > buffer
│ │ │ │ │ -Definition: gridgluecommunicate.hh:285
│ │ │ │ │ -Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ ->::getSize
│ │ │ │ │ -static size_t getSize(const Type &commInfo, size_t i)
│ │ │ │ │ -Get the number of objects at an intersection.
│ │ │ │ │ -Definition: gridgluecommunicate.hh:320
│ │ │ │ │ -Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ ->::IndexedType
│ │ │ │ │ -DataTypeImp IndexedType
│ │ │ │ │ -The datatype that should be communicated.
│ │ │ │ │ -Definition: gridgluecommunicate.hh:309
│ │ │ │ │ -Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ ->::Type
│ │ │ │ │ -::Dune::GridGlue::CommInfo< GG, DataHandleImp, DataTypeImp > Type
│ │ │ │ │ -The type of the GridGlueCommInfo.
│ │ │ │ │ -Definition: gridgluecommunicate.hh:304
│ │ │ │ │ -Dune::CommPolicy<_::Dune::GridGlue::CommInfo<_GG,_DataHandleImp,_DataTypeImp_>
│ │ │ │ │ ->::IndexedTypeFlag
│ │ │ │ │ -VariableSize IndexedTypeFlag
│ │ │ │ │ -Each intersection can communicate a different number of objects.
│ │ │ │ │ -Definition: gridgluecommunicate.hh:315
│ │ │ │ │ +Dune::GridGlue::GridGlue
│ │ │ │ │ +sequential adapter to couple two grids at specified close together boundaries
│ │ │ │ │ +Definition: gridglue.hh:67
│ │ │ │ │ +Dune::GridGlue::Intersection<_P0,_P1,_inside,_outside_>
│ │ │ │ │ +Dune::GridGlue::IntersectionIterator
│ │ │ │ │ +Definition: intersectioniterator.hh:25
│ │ │ │ │ +Dune::GridGlue::IntersectionIterator::GridGlue
│ │ │ │ │ +::Dune::GridGlue::GridGlue< P0, P1 > GridGlue
│ │ │ │ │ +Definition: intersectioniterator.hh:28
│ │ │ │ │ +Dune::GridGlue::IntersectionIterator::dereference
│ │ │ │ │ +const Intersection & dereference() const
│ │ │ │ │ +Definition: intersectioniterator.hh:37
│ │ │ │ │ +Dune::GridGlue::IntersectionIterator::increment
│ │ │ │ │ +void increment()
│ │ │ │ │ +Definition: intersectioniterator.hh:44
│ │ │ │ │ +Dune::GridGlue::IntersectionIterator::Intersection
│ │ │ │ │ +::Dune::GridGlue::Intersection< P0, P1, inside, outside > Intersection
│ │ │ │ │ +Definition: intersectioniterator.hh:29
│ │ │ │ │ +Dune::GridGlue::IntersectionIterator::IntersectionIterator
│ │ │ │ │ +IntersectionIterator(const GridGlue *glue, unsigned int i)
│ │ │ │ │ +Definition: intersectioniterator.hh:31
│ │ │ │ │ +Dune::GridGlue::IntersectionIterator::equals
│ │ │ │ │ +bool equals(const IntersectionIterator &iter) const
│ │ │ │ │ +Definition: intersectioniterator.hh:49
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00023.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: rangegenerators.hh File Reference
│ │ │ │ +dune-grid-glue: gridglueamirawriter.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -64,42 +64,42 @@
│ │ │ │
│ │ │ │
│ │ │ │ Describes the parallel communication interface class for Dune::GridGlue. │ │ │ │ +
Implement iterators over GridGlue intersections. │ │ │ │ More...
│ │ │ │ -#include <type_traits>│ │ │ │ -
#include <dune/common/bartonnackmanifcheck.hh>│ │ │ │ -
#include <dune/common/parallel/communicator.hh>│ │ │ │ -
#include <dune/grid/common/datahandleif.hh>│ │ │ │ -
#include <dune/grid/common/gridenums.hh>│ │ │ │ +
#include <dune/grid-glue/gridglue.hh>│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ Classes | |
| struct | Dune::GridGlue::GlobalId |
| class | Dune::GridGlue::CommDataHandle< DataHandleImp, DataTypeImp > |
| describes the features of a data handle for communication in parallel runs using the GridGlue::communicate methods. More... | |
| class | Dune::GridGlue::StreamingMessageBuffer< DT > |
| class | Dune::GridGlue::CommunicationOperator< dir > |
| forward gather scatter to user defined CommInfo class More... | |
| struct | Dune::GridGlue::CommInfo< GG, DataHandleImp, DataTypeImp > |
| collects all GridGlue data requried for communication More... | |
| struct | Dune::CommPolicy< ::Dune::GridGlue::CommInfo< GG, DataHandleImp, DataTypeImp > > |
| specialization of the CommPolicy struct, required for the ParallelIndexsets More... | |
| class | Dune::GridGlue::IntersectionIterator< P0, P1, inside, outside > |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
│ │ │ │ -Typedefs | |
| typedef std::pair< int, int > | Dune::GridGlue::RankPair |
| typedef CommunicationOperator< Dune::ForwardCommunication > | Dune::GridGlue::ForwardOperator |
| typedef CommunicationOperator< Dune::BackwardCommunication > | Dune::GridGlue::BackwardOperator |
│ │ │ │ -Functions | |
| std::ostream & | Dune::GridGlue::operator<< (std::ostream &os, const GlobalId &id) |
Detailed Description
│ │ │ │ -Describes the parallel communication interface class for Dune::GridGlue.
│ │ │ │ +Implement iterators over GridGlue intersections.
│ │ │ │ │ │ │ ││ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,62 +5,27 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Classes | Namespaces | Typedefs | Functions
│ │ │ │ │ -gridgluecommunicate.hh File Reference
│ │ │ │ │ -Describes the parallel communication interface class for Dune::GridGlue.
│ │ │ │ │ -More...
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ gridgluecommunicate.hh
intersectioniterator.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 197 static const typename CommInfo::DataType& gather(const CommInfo& commInfo, size_t i, size_t j = 0)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 227 static void scatter(CommInfo& commInfo, const typename CommInfo::DataType& v, std::size_t i, std::size_t j = 0)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +Central component of the module implementing the coupling of two grids.
Definition: gridglue.hh:37
CommunicationOperator< Dune::BackwardCommunication > BackwardOperator
Definition: gridgluecommunicate.hh:264
CommunicationOperator< Dune::ForwardCommunication > ForwardOperator
Definition: gridgluecommunicate.hh:263
std::ostream & operator<<(std::ostream &os, const GlobalId &id)
Definition: gridgluecommunicate.hh:55
The intersection of two entities of the two patches of a GridGlue.
Definition: intersection.hh:261
Intersection< P0, P1, O, I > flip() const
Return a copy of the intersection with inside and outside switched.
Definition: intersection.hh:483
bool self() const
For parallel computations: Return true if inside() entity exists locally.
Definition: intersection.hh:393
InsideEntity inside(unsigned int parentId=0) const
Return element on the inside of this intersection.
Definition: intersection.hh:319
size_t neighbor(unsigned int g=0) const
Return number of embeddings into local grid0 (grid1) entities.
Definition: intersection.hh:399
OutsideEntity outside(unsigned int parentId=0) const
Return element on the outside of this intersection.
Definition: intersection.hh:328
Definition: gridgluecommunicate.hh:26
GlobalId(int i, int j, unsigned int n)
Definition: gridgluecommunicate.hh:48
describes the features of a data handle for communication in parallel runs using the GridGlue::commun...
Definition: gridgluecommunicate.hh:77
size_t size(RISType &i) const
Definition: gridgluecommunicate.hh:92
void scatter(MessageBufferImp &buff, const EntityType &e, const RISType &i, size_t n)
Definition: gridgluecommunicate.hh:118
void gather(MessageBufferImp &buff, const EntityType &e, const RISType &i) const
pack data from user to message buffer
Definition: gridgluecommunicate.hh:104
DataTypeImp DataType
data type of data to communicate
Definition: gridgluecommunicate.hh:80
Definition: gridgluecommunicate.hh:141
StreamingMessageBuffer(DT *p)
Definition: gridgluecommunicate.hh:146
size_t counter() const
Definition: gridgluecommunicate.hh:169
void write(const Y &data)
Definition: gridgluecommunicate.hh:155
void read(Y &data) const
Definition: gridgluecommunicate.hh:163
DT value_type
Definition: gridgluecommunicate.hh:143
forward gather scatter to user defined CommInfo class
Definition: gridgluecommunicate.hh:194
static void scatter(CommInfo &commInfo, const typename CommInfo::DataType &v, std::size_t i, std::size_t j=0)
Definition: gridgluecommunicate.hh:227
static const CommInfo::DataType & gather(const CommInfo &commInfo, size_t i, size_t j=0)
Definition: gridgluecommunicate.hh:197
collects all GridGlue data requried for communication
Definition: gridgluecommunicate.hh:272
::Dune::GridGlue::CommDataHandle< DataHandleImp, DataTypeImp > * data
Definition: gridgluecommunicate.hh:282
mutable ::Dune::GridGlue::StreamingMessageBuffer< DataType > mbuffer
Definition: gridgluecommunicate.hh:286
std::vector< DataType > buffer
Definition: gridgluecommunicate.hh:285
static size_t getSize(const Type &commInfo, size_t i)
Get the number of objects at an intersection.
Definition: gridgluecommunicate.hh:320
DataTypeImp IndexedType
The datatype that should be communicated.
Definition: gridgluecommunicate.hh:309
::Dune::GridGlue::CommInfo< GG, DataHandleImp, DataTypeImp > Type
The type of the GridGlueCommInfo.
Definition: gridgluecommunicate.hh:304
VariableSize IndexedTypeFlag
Each intersection can communicate a different number of objects.
Definition: gridgluecommunicate.hh:315
sequential adapter to couple two grids at specified close together boundaries
Definition: gridglue.hh:67
Definition: intersectioniterator.hh:25
::Dune::GridGlue::GridGlue< P0, P1 > GridGlue
Definition: intersectioniterator.hh:28
const Intersection & dereference() const
Definition: intersectioniterator.hh:37
void increment()
Definition: intersectioniterator.hh:44
::Dune::GridGlue::Intersection< P0, P1, inside, outside > Intersection
Definition: intersectioniterator.hh:29
IntersectionIterator(const GridGlue *glue, unsigned int i)
Definition: intersectioniterator.hh:31
bool equals(const IntersectionIterator &iter) const
Definition: intersectioniterator.hh:49
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,443 +5,100 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -gridgluecommunicate.hh
│ │ │ │ │ +intersectioniterator.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 5#ifndef DUNE_GRIDGLUE_ADAPTER_GRIDGLUECOMMUNICATE_HH
│ │ │ │ │ - 6#define DUNE_GRIDGLUE_ADAPTER_GRIDGLUECOMMUNICATE_HH
│ │ │ │ │ - 7
│ │ │ │ │ - 13#include -
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ +Namespaces
│ │ │ │ + rangegenerators.hh File Reference
gridglueamirawriter.hh File Reference
│ │ │ │ -
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ #include <dune/common/iteratorrange.hh>│ │ │ │ + │ │ │ │ +
Write all remote intersections to a AmiraMesh file. │ │ │ │ +More...
│ │ │ │ +#include <fstream>│ │ │ │ +
#include <sstream>│ │ │ │ +
#include <type_traits>│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ Classes | |
| struct | Dune::GridGlue::Reverse< reverse > |
| class | Dune::GridGlue::GridGlueAmiraWriter |
| Write remote intersections to a AmiraMesh file for debugging purposes. More... | |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
│ │ │ │ -Functions | |
| template<... > | |
| IteratorRange<... > | Dune::GridGlue::intersections (const GridGlue<... > &glue, const Reverse<... > &reverse=!reversed) |
| Iterate over all intersections of a GridGlue. More... | |
Detailed Description
│ │ │ │ +Write all remote intersections to a AmiraMesh file.
│ │ │ │ +│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,28 +5,29 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Classes | Namespaces | Functions
│ │ │ │ │ -rangegenerators.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ rangegenerators.hh
gridglueamirawriter.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ Definition: gridglue.hh:37
IteratorRange<... > intersections(const GridGlue<... > &glue, const Reverse<... > &reverse=!reversed)
Iterate over all intersections of a GridGlue.
sequential adapter to couple two grids at specified close together boundaries
Definition: gridglue.hh:67
IteratorRange<... > intersections(const GridGlue<... > &glue, const Reverse<... > &reverse=!reversed)
Iterate over all intersections of a GridGlue.
Definition: rangegenerators.hh:17
constexpr Reverse<!reverse > operator!() const
Definition: rangegenerators.hh:21
Write remote intersections to a AmiraMesh file for debugging purposes.
Definition: gridglueamirawriter.hh:21
static void write(const Glue &glue, const std::string &path, int appendix=1)
Definition: gridglueamirawriter.hh:131
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,89 +5,166 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -rangegenerators.hh
│ │ │ │ │ +gridglueamirawriter.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#ifndef DUNE_GRIDGLUE_ADAPTER_RANGEGENERATORS_HH
│ │ │ │ │ - 4#define DUNE_GRIDGLUE_ADAPTER_RANGEGENERATORS_HH
│ │ │ │ │ - 5
│ │ │ │ │ - 6#include
│ │ │ │
│ │ │ │ +Namespaces |
│ │ │ │ +Functions
│ │ │ │ +
│ │ │ │ -Classes |
│ │ │ │ -Namespaces
│ │ │ │ - gridglueamirawriter.hh File Reference
gridglue.cc File Reference
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,29 +5,28 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Classes | Namespaces
│ │ │ │ │ -gridglueamirawriter.hh File Reference
│ │ │ │ │ -Write all remote intersections to a AmiraMesh file. More...
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -Go_to_the_source_code_of_this_file.
│ │ │ │ │ - Classes
│ │ │ │ │ -class Dune::GridGlue::GridGlueAmiraWriter
│ │ │ │ │ - Write remote intersections to a AmiraMesh file for debugging purposes.
│ │ │ │ │ - More...
│ │ │ │ │ -
│ │ │ │ │ +Namespaces | Functions
│ │ │ │ │ +gridglue.cc File Reference
│ │ │ │ │ +#include "intersection.hh"
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include "../gridglue.hh"
│ │ │ │ │ +#include "../common/ringcomm.hh"
│ │ │ │ │ +#include
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ -***** Detailed Description *****
│ │ │ │ │ -Write all remote intersections to a AmiraMesh file.
│ │ │ │ │ + Functions
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::GridGlue::printVector (const std::vector< T > &v, std::string name,
│ │ │ │ │ + int rank)
│ │ │ │ │ +
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00029.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: projectionwriter_impl.hh File Reference
│ │ │ │ +dune-grid-glue: crossproduct.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -65,59 +65,33 @@
│ │ │ │ dune grid-glue common
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -6,60 +6,24 @@
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ Namespaces | Functions
│ │ │ │ │ -projectionwriter_impl.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ │ +crossproduct.hh File Reference
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ -namespace Dune::GridGlue::ProjectionWriterImplementation
│ │ │ │ │ -
│ │ │ │ │ Functions
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::ProjectionWriterImplementation::write_points (const
│ │ │ │ │ - Projection< Coordinate > &projection, const Corners &corners, std::
│ │ │ │ │ - ostream &out)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::ProjectionWriterImplementation::write_normals (const
│ │ │ │ │ - Projection< Coordinate > &projection, const Normals &normals, std::
│ │ │ │ │ - ostream &out)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::ProjectionWriterImplementation::
│ │ │ │ │ - write_edge_intersection_points (const Projection< Coordinate >
│ │ │ │ │ - &projection, const Corners &corners, std::ostream &out)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::ProjectionWriterImplementation::
│ │ │ │ │ - write_edge_intersection_normals (const Projection< Coordinate >
│ │ │ │ │ - &projection, const Normals &normals, std::ostream &out)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::ProjectionWriterImplementation::write_success (const
│ │ │ │ │ - Projection< Coordinate > &projection, std::ostream &out)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::write (const Projection< Coordinate > &projection, const
│ │ │ │ │ - Corners &corners, const Normals &normals, std::ostream &out)
│ │ │ │ │ - write projection in VTK format More...
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::write (const Projection< Coordinate > &projection, const
│ │ │ │ │ - Corners &corners, const Normals &normals, const std::string &filename)
│ │ │ │ │ - write projection in VTK format More...
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::print (const Projection< Coordinate > &projection, const
│ │ │ │ │ - Corners &corners, const Normals &normals)
│ │ │ │ │ - Print information about the projection to std::cout stream. More...
│ │ │ │ │ +template
│ │ │ │ │ +static Dune::FieldVector< T, dim > Dune::GridGlue::crossProduct (const Dune::
│ │ │ │ │ + FieldVector< T, dim > &a, const Dune::
│ │ │ │ │ + FieldVector< T, dim > &b)
│ │ │ │ │ + compute cross product More...
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00029_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: projectionwriter_impl.hh Source File
│ │ │ │ +dune-grid-glue: crossproduct.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -62,195 +62,46 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,246 +5,50 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -projectionwriter_impl.hh
│ │ │ │ │ +crossproduct.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#include
│ │ │ │ │ - 4
│ │ │ │ │ - 5namespace Dune {
│ │ │ │ │ - 6namespace GridGlue {
│ │ │ │ │ - 7
│ │ │ │ │ -8namespace ProjectionWriterImplementation {
│ │ │ │ │ - 9
│ │ │ │ │ - 10template
│ │ │ │ │ -11void write_points(const Projection& projection, const Corners&
│ │ │ │ │ -corners, std::ostream& out)
│ │ │ │ │ - 12{
│ │ │ │ │ - 13 using namespace ProjectionImplementation;
│ │ │ │ │ - 14 using std::get;
│ │ │ │ │ - 15 const unsigned other_side = 1 - side;
│ │ │ │ │ - 16
│ │ │ │ │ - 17 for (const auto& c : get(corners))
│ │ │ │ │ - 18 out << c << "\n";
│ │ │ │ │ - 19
│ │ │ │ │ - 20 for (const auto& i : get(projection.images())) {
│ │ │ │ │ - 21 const auto global = interpolate(i, get(corners));
│ │ │ │ │ - 22 out << global << "\n";
│ │ │ │ │ - 23 }
│ │ │ │ │ - 24}
│ │ │ │ │ + 3#ifndef DUNE_GRIDGLUE_COMMON_CROSSPRODUCT_HH
│ │ │ │ │ + 4#define DUNE_GRIDGLUE_COMMON_CROSSPRODUCT_HH 1
│ │ │ │ │ + 5
│ │ │ │ │ + 6namespace Dune {
│ │ │ │ │ + 7namespace GridGlue {
│ │ │ │ │ + 8
│ │ │ │ │ + 14template
│ │ │ │ │ +15static Dune::FieldVector crossProduct(const Dune::FieldVector&
│ │ │ │ │ +a,
│ │ │ │ │ + 16 const Dune::FieldVector& b)
│ │ │ │ │ + 17{
│ │ │ │ │ + 18 if (dim!=3)
│ │ │ │ │ + 19 DUNE_THROW(Dune::NotImplemented, "crossProduct does not work for dimension
│ │ │ │ │ +" << dim);
│ │ │ │ │ + 20
│ │ │ │ │ + 21 Dune::FieldVector c;
│ │ │ │ │ + 22 c[0] = a[1]*b[2] - a[2]*b[1];
│ │ │ │ │ + 23 c[1] = a[2]*b[0] - a[0]*b[2];
│ │ │ │ │ + 24 c[2] = a[0]*b[1] - a[1]*b[0];
│ │ │ │ │ 25
│ │ │ │ │ - 26template
│ │ │ │ │ -27void write_normals(const Projection& projection, const Normals&
│ │ │ │ │ -normals, std::ostream& out)
│ │ │ │ │ - 28{
│ │ │ │ │ - 29 using namespace ProjectionImplementation;
│ │ │ │ │ - 30 using std::get;
│ │ │ │ │ - 31 const unsigned other_side = 1 - side;
│ │ │ │ │ - 32
│ │ │ │ │ - 33 for (const auto& n : get(normals))
│ │ │ │ │ - 34 out << n << "\n";
│ │ │ │ │ - 35
│ │ │ │ │ - 36 for (const auto& x : get(projection.images())) {
│ │ │ │ │ - 37 const auto n = interpolate_unit_normals(x, get(normals));
│ │ │ │ │ - 38 out << n << "\n";
│ │ │ │ │ - 39 }
│ │ │ │ │ - 40}
│ │ │ │ │ - 41
│ │ │ │ │ - 42template
│ │ │ │ │ -43void write_edge_intersection_points(const Projection& projection,
│ │ │ │ │ -const Corners& corners, std::ostream& out)
│ │ │ │ │ - 44{
│ │ │ │ │ - 45 using namespace ProjectionImplementation;
│ │ │ │ │ - 46 using std::get;
│ │ │ │ │ - 47
│ │ │ │ │ - 48 for (std::size_t i = 0; i < projection.numberOfEdgeIntersections(); ++i) {
│ │ │ │ │ - 49 const auto& local = projection.edgeIntersections()[i].local;
│ │ │ │ │ - 50 out << interpolate(local[0], get<0>(corners)) << "\n"
│ │ │ │ │ - 51 << interpolate(local[1], get<1>(corners)) << "\n";
│ │ │ │ │ - 52 }
│ │ │ │ │ - 53}
│ │ │ │ │ - 54
│ │ │ │ │ - 55template
│ │ │ │ │ -56void write_edge_intersection_normals(const Projection&
│ │ │ │ │ -projection, const Normals& normals, std::ostream& out)
│ │ │ │ │ - 57{
│ │ │ │ │ - 58 using namespace ProjectionImplementation;
│ │ │ │ │ - 59 using std::get;
│ │ │ │ │ - 60
│ │ │ │ │ - 61 for (std::size_t i = 0; i < projection.numberOfEdgeIntersections(); ++i) {
│ │ │ │ │ - 62 const auto& local = projection.edgeIntersections()[i].local;
│ │ │ │ │ - 63 const auto n0 = interpolate_unit_normals(local[0], get<0>(normals));
│ │ │ │ │ - 64 const auto n1 = interpolate_unit_normals(local[1], get<1>(normals));
│ │ │ │ │ - 65
│ │ │ │ │ - 66 out << n0 << "\n"
│ │ │ │ │ - 67 << n1 << "\n";
│ │ │ │ │ - 68 }
│ │ │ │ │ - 69}
│ │ │ │ │ - 70
│ │ │ │ │ - 71template
│ │ │ │ │ -72void write_success(const Projection& projection, std::ostream&
│ │ │ │ │ -out)
│ │ │ │ │ - 73{
│ │ │ │ │ - 74 using std::get;
│ │ │ │ │ - 75
│ │ │ │ │ - 76 out << side << "\n";
│ │ │ │ │ - 77
│ │ │ │ │ - 78 const auto& success = get(projection.success());
│ │ │ │ │ - 79 for (std::size_t i = 0; i < success.size(); ++i)
│ │ │ │ │ - 80 out << (success[i] ? "1\n" : "0\n");
│ │ │ │ │ - 81}
│ │ │ │ │ - 82
│ │ │ │ │ - 83} /* namespace ProjectionWriterImplementation */
│ │ │ │ │ - 84
│ │ │ │ │ - 85template
│ │ │ │ │ -86void write(const Projection& projection,
│ │ │ │ │ - 87 const Corners& corners,
│ │ │ │ │ - 88 const Normals& normals,
│ │ │ │ │ - 89 std::ostream& out)
│ │ │ │ │ - 90{
│ │ │ │ │ - 91 using namespace ProjectionWriterImplementation;
│ │ │ │ │ - 92
│ │ │ │ │ - 93 const auto numberOfEdgeIntersections = projection.numberOfEdgeIntersections
│ │ │ │ │ -();
│ │ │ │ │ - 94 const auto nPoints = 12 + 2 * numberOfEdgeIntersections;
│ │ │ │ │ - 95
│ │ │ │ │ - 96 out << "# vtk DataFile Version2.0\n"
│ │ │ │ │ - 97 << "Filename: projection\n"
│ │ │ │ │ - 98 << "ASCII\n"
│ │ │ │ │ - 99 << "DATASET UNSTRUCTURED_GRID\n"
│ │ │ │ │ - 100 << "POINTS " << nPoints << " double\n";
│ │ │ │ │ - 101 write_points<0>(projection, corners, out);
│ │ │ │ │ - 102 write_points<1>(projection, corners, out);
│ │ │ │ │ - 103 write_edge_intersection_points(projection, corners, out);
│ │ │ │ │ - 104 out << "CELLS " << (8 + numberOfEdgeIntersections) << " " << (26 + 3 *
│ │ │ │ │ -numberOfEdgeIntersections) << "\n";
│ │ │ │ │ - 105 out << "3 0 1 2\n" "2 0 3\n" "2 1 4\n" "2 2 5\n"
│ │ │ │ │ - 106 << "3 6 7 8\n" "2 6 9\n" "2 7 10\n" "2 8 11\n";
│ │ │ │ │ - 107 for (std::size_t i = 0; i < numberOfEdgeIntersections; ++i)
│ │ │ │ │ - 108 out << "2 " << (12 + 2*i) << " " << (12 + 2*i + 1) << "\n";
│ │ │ │ │ - 109 out << "CELL_TYPES " << (8 + numberOfEdgeIntersections) << "\n"
│ │ │ │ │ -"5\n3\n3\n3\n" "5\n3\n3\n3\n";
│ │ │ │ │ - 110 for (std::size_t i = 0; i < numberOfEdgeIntersections; ++i)
│ │ │ │ │ - 111 out << "3\n";
│ │ │ │ │ - 112 out << "CELL_DATA " << (8 + numberOfEdgeIntersections) << "\n";
│ │ │ │ │ - 113 out << "SCALARS success int 1\n"
│ │ │ │ │ - 114 << "LOOKUP_TABLE success\n";
│ │ │ │ │ - 115 write_success<0>(projection, out);
│ │ │ │ │ - 116 write_success<1>(projection, out);
│ │ │ │ │ - 117 for (std::size_t i = 0; i < numberOfEdgeIntersections; ++i)
│ │ │ │ │ - 118 out << "2\n";
│ │ │ │ │ - 119 out << "LOOKUP_TABLE success 2\n"
│ │ │ │ │ - 120 << "1.0 0.0 0.0 1.0\n"
│ │ │ │ │ - 121 << "0.0 1.0 0.0 1.0\n";
│ │ │ │ │ - 122 out << "POINT_DATA " << nPoints << "\n"
│ │ │ │ │ - 123 << "NORMALS normals double\n";
│ │ │ │ │ - 124 write_normals<0>(projection, normals, out);
│ │ │ │ │ - 125 write_normals<1>(projection, normals, out);
│ │ │ │ │ - 126 write_edge_intersection_normals(projection, normals, out);
│ │ │ │ │ - 127}
│ │ │ │ │ - 128
│ │ │ │ │ - 129template
│ │ │ │ │ -130void write(const Projection& projection,
│ │ │ │ │ - 131 const Corners& corners,
│ │ │ │ │ - 132 const Normals& normals,
│ │ │ │ │ - 133 const std::string& filename)
│ │ │ │ │ - 134{
│ │ │ │ │ - 135 std::ofstream out(filename.c_str());
│ │ │ │ │ - 136 write(projection, corners, normals, out);
│ │ │ │ │ - 137}
│ │ │ │ │ - 138
│ │ │ │ │ - 139template
│ │ │ │ │ -140void print(const Projection& projection,
│ │ │ │ │ - 141 const Corners& corners,
│ │ │ │ │ - 142 const Normals& normals)
│ │ │ │ │ - 143{
│ │ │ │ │ - 144 using namespace ProjectionWriterImplementation;
│ │ │ │ │ - 145
│ │ │ │ │ - 146 std::cout << "Side 0 corners and images:\n";
│ │ │ │ │ - 147 write_points<0>(projection, corners, std::cout);
│ │ │ │ │ - 148 std::cout << "Side 0 success:\n";
│ │ │ │ │ - 149 write_success<0>(projection, std::cout);
│ │ │ │ │ - 150 std::cout << "Side 1 corners and images:\n";
│ │ │ │ │ - 151 write_points<1>(projection, corners, std::cout);
│ │ │ │ │ - 152 std::cout << "Side 1 success:\n";
│ │ │ │ │ - 153 write_success<1>(projection, std::cout);
│ │ │ │ │ - 154 std::cout << "Side 0 normals and projected normals:\n";
│ │ │ │ │ - 155 write_normals<0>(projection, normals, std::cout);
│ │ │ │ │ - 156 std::cout << "Side 1 normals and projected normals:\n";
│ │ │ │ │ - 157 write_normals<1>(projection, normals, std::cout);
│ │ │ │ │ - 158 std::cout << projection.numberOfEdgeIntersections() << " edge
│ │ │ │ │ -intersections:\n";
│ │ │ │ │ - 159 write_edge_intersection_points(projection, corners, std::cout);
│ │ │ │ │ - 160}
│ │ │ │ │ - 161
│ │ │ │ │ - 162} /* namespace GridGlue */
│ │ │ │ │ - 163} /* namespace Dune */
│ │ │ │ │ + 26 return c;
│ │ │ │ │ + 27}
│ │ │ │ │ + 28
│ │ │ │ │ + 29} /* namespace GridGlue */
│ │ │ │ │ + 30} /* namespace Dune */
│ │ │ │ │ + 31
│ │ │ │ │ + 32#endif
│ │ │ │ │ Dune
│ │ │ │ │ Definition: gridglue.hh:37
│ │ │ │ │ -Dune::GridGlue::write
│ │ │ │ │ -void write(const Projection< Coordinate > &projection, const Corners &corners,
│ │ │ │ │ -const Normals &normals, std::ostream &out)
│ │ │ │ │ -write projection in VTK format
│ │ │ │ │ -Definition: projectionwriter_impl.hh:86
│ │ │ │ │ -Dune::GridGlue::print
│ │ │ │ │ -void print(const Projection< Coordinate > &projection, const Corners &corners,
│ │ │ │ │ -const Normals &normals)
│ │ │ │ │ -Print information about the projection to std::cout stream.
│ │ │ │ │ -Definition: projectionwriter_impl.hh:140
│ │ │ │ │ -Dune::GridGlue::ProjectionImplementation::interpolate
│ │ │ │ │ -Corners::value_type interpolate(const Coordinate &x, const Corners &corners)
│ │ │ │ │ -Definition: projection_impl.hh:70
│ │ │ │ │ -Dune::GridGlue::ProjectionImplementation::interpolate_unit_normals
│ │ │ │ │ -Normals::value_type interpolate_unit_normals(const Coordinate &x, const Normals
│ │ │ │ │ -&normals)
│ │ │ │ │ -Definition: projection_impl.hh:91
│ │ │ │ │ -Dune::GridGlue::ProjectionWriterImplementation::write_normals
│ │ │ │ │ -void write_normals(const Projection< Coordinate > &projection, const Normals
│ │ │ │ │ -&normals, std::ostream &out)
│ │ │ │ │ -Definition: projectionwriter_impl.hh:27
│ │ │ │ │ -Dune::GridGlue::ProjectionWriterImplementation::write_points
│ │ │ │ │ -void write_points(const Projection< Coordinate > &projection, const Corners
│ │ │ │ │ -&corners, std::ostream &out)
│ │ │ │ │ -Definition: projectionwriter_impl.hh:11
│ │ │ │ │ -Dune::GridGlue::ProjectionWriterImplementation::write_success
│ │ │ │ │ -void write_success(const Projection< Coordinate > &projection, std::ostream
│ │ │ │ │ -&out)
│ │ │ │ │ -Definition: projectionwriter_impl.hh:72
│ │ │ │ │ -Dune::GridGlue::ProjectionWriterImplementation::write_edge_intersection_points
│ │ │ │ │ -void write_edge_intersection_points(const Projection< Coordinate > &projection,
│ │ │ │ │ -const Corners &corners, std::ostream &out)
│ │ │ │ │ -Definition: projectionwriter_impl.hh:43
│ │ │ │ │ -Dune::GridGlue::ProjectionWriterImplementation::write_edge_intersection_normals
│ │ │ │ │ -void write_edge_intersection_normals(const Projection< Coordinate >
│ │ │ │ │ -&projection, const Normals &normals, std::ostream &out)
│ │ │ │ │ -Definition: projectionwriter_impl.hh:56
│ │ │ │ │ -Dune::GridGlue::Projection
│ │ │ │ │ -Projection of a line (triangle) on another line (triangle).
│ │ │ │ │ -Definition: projection.hh:21
│ │ │ │ │ -Dune::GridGlue::Projection::success
│ │ │ │ │ -const std::tuple< std::bitset< dim >, std::bitset< dim > > & success() const
│ │ │ │ │ -Indicate whether projection (inverse projection) is valid for each corner or
│ │ │ │ │ -not.
│ │ │ │ │ -Definition: projection.hh:252
│ │ │ │ │ -Dune::GridGlue::Projection::numberOfEdgeIntersections
│ │ │ │ │ -unsigned numberOfEdgeIntersections() const
│ │ │ │ │ -Number of edge intersections.
│ │ │ │ │ -Definition: projection.hh:262
│ │ │ │ │ -Dune::GridGlue::Projection::images
│ │ │ │ │ -const std::tuple< Images, Preimages > & images() const
│ │ │ │ │ -Images and preimages of corners.
│ │ │ │ │ -Definition: projection.hh:235
│ │ │ │ │ -Dune::GridGlue::Projection::edgeIntersections
│ │ │ │ │ -const std::array< EdgeIntersection, maxEdgeIntersections > & edgeIntersections
│ │ │ │ │ -() const
│ │ │ │ │ -Edge-edge intersections.
│ │ │ │ │ -Definition: projection.hh:273
│ │ │ │ │ +Dune::GridGlue::crossProduct
│ │ │ │ │ +static Dune::FieldVector< T, dim > crossProduct(const Dune::FieldVector< T, dim
│ │ │ │ │ +> &a, const Dune::FieldVector< T, dim > &b)
│ │ │ │ │ +compute cross product
│ │ │ │ │ +Definition: crossproduct.hh:15
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00032.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: crossproduct.hh File Reference
│ │ │ │ +dune-grid-glue: areawriter_impl.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -63,35 +63,56 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,25 +5,44 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -Namespaces | Functions
│ │ │ │ │ -crossproduct.hh File Reference
│ │ │ │ │ +Classes | Namespaces | Functions
│ │ │ │ │ +areawriter_impl.hh File Reference
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ + Classes
│ │ │ │ │ +struct Dune::GridGlue::AreaWriterImplementation::FacetLayout<_dimgrid_>
│ │ │ │ │ +
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ +namespace Dune::GridGlue::AreaWriterImplementation
│ │ │ │ │ +
│ │ │ │ │ Functions
│ │ │ │ │ -template
│ │ │ │ │ -static Dune::FieldVector< T, dim > Dune::GridGlue::crossProduct (const Dune::
│ │ │ │ │ - FieldVector< T, dim > &a, const Dune::
│ │ │ │ │ - FieldVector< T, dim > &b)
│ │ │ │ │ - compute cross product More...
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::GridGlue::AreaWriterImplementation::write_facet_geometry (const
│ │ │ │ │ + GridView &gv, std::ostream &out)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::GridGlue::write_glue_area_vtk (const Glue &glue, std::ostream &out)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::GridGlue::write_glue_area_vtk (const Glue &glue, const std::string
│ │ │ │ │ + &filename)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::GridGlue::write_glue_areas_vtk (const Glue &glue, const std::string
│ │ │ │ │ + &base)
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00032_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: crossproduct.hh Source File
│ │ │ │ +dune-grid-glue: areawriter_impl.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -62,46 +62,169 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,50 +5,185 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -crossproduct.hh
│ │ │ │ │ +areawriter_impl.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#ifndef DUNE_GRIDGLUE_COMMON_CROSSPRODUCT_HH
│ │ │ │ │ - 4#define DUNE_GRIDGLUE_COMMON_CROSSPRODUCT_HH 1
│ │ │ │ │ + 3#include
│ │ │ │ │ + 4#include
│ │ │ │ │ 5
│ │ │ │ │ - 6namespace Dune {
│ │ │ │ │ - 7namespace GridGlue {
│ │ │ │ │ - 8
│ │ │ │ │ - 14template
│ │ │ │ │ -15static Dune::FieldVector crossProduct(const Dune::FieldVector&
│ │ │ │ │ -a,
│ │ │ │ │ - 16 const Dune::FieldVector& b)
│ │ │ │ │ + 6#include
│ │ │ │ │ + 7#include
│ │ │ │ │ + 8#include
│ │ │ │ │ + 9
│ │ │ │ │ + 10namespace Dune {
│ │ │ │ │ + 11namespace GridGlue {
│ │ │ │ │ + 12
│ │ │ │ │ +13namespace AreaWriterImplementation {
│ │ │ │ │ + 14
│ │ │ │ │ + 15template
│ │ │ │ │ +16struct FacetLayout
│ │ │ │ │ 17{
│ │ │ │ │ - 18 if (dim!=3)
│ │ │ │ │ - 19 DUNE_THROW(Dune::NotImplemented, "crossProduct does not work for dimension
│ │ │ │ │ -" << dim);
│ │ │ │ │ - 20
│ │ │ │ │ - 21 Dune::FieldVector c;
│ │ │ │ │ - 22 c[0] = a[1]*b[2] - a[2]*b[1];
│ │ │ │ │ - 23 c[1] = a[2]*b[0] - a[0]*b[2];
│ │ │ │ │ - 24 c[2] = a[0]*b[1] - a[1]*b[0];
│ │ │ │ │ - 25
│ │ │ │ │ - 26 return c;
│ │ │ │ │ - 27}
│ │ │ │ │ +18 bool contains(Dune::GeometryType gt) const
│ │ │ │ │ + 19 {
│ │ │ │ │ + 20 return gt.dim() == dimgrid - 1;
│ │ │ │ │ + 21 }
│ │ │ │ │ + 22};
│ │ │ │ │ + 23
│ │ │ │ │ + 24template
│ │ │ │ │ +25void write_facet_geometry(const GridView& gv, std::ostream& out)
│ │ │ │ │ + 26{
│ │ │ │ │ + 27 using Coordinate = Dune::FieldVector;
│ │ │ │ │ 28
│ │ │ │ │ - 29} /* namespace GridGlue */
│ │ │ │ │ - 30} /* namespace Dune */
│ │ │ │ │ - 31
│ │ │ │ │ - 32#endif
│ │ │ │ │ + 29 std::vector corners;
│ │ │ │ │ + 30 for (const auto& facet : facets(gv)) {
│ │ │ │ │ + 31 const auto geometry = facet.geometry();
│ │ │ │ │ + 32 for (int i = 0; i < geometry.corners(); ++i) {
│ │ │ │ │ + 33 /* VTK always needs 3-dim coordinates... */
│ │ │ │ │ + 34 const auto c0 = geometry.corner(i);
│ │ │ │ │ + 35 Coordinate c1;
│ │ │ │ │ + 36 for (int d = 0; d < GridView::dimensionworld; ++d)
│ │ │ │ │ + 37 c1[d] = c0[d];
│ │ │ │ │ + 38 for (int d = GridView::dimensionworld; d < Coordinate::dimension; ++d)
│ │ │ │ │ + 39 c1[d] = double(0);
│ │ │ │ │ + 40 corners.push_back(c1);
│ │ │ │ │ + 41 }
│ │ │ │ │ + 42 }
│ │ │ │ │ + 43
│ │ │ │ │ + 44 {
│ │ │ │ │ + 45 out << "DATASET UNSTRUCTURED_GRID\n"
│ │ │ │ │ + 46 << "POINTS " << corners.size() << " double\n";
│ │ │ │ │ + 47 for (const auto& c : corners)
│ │ │ │ │ + 48 out << c << "\n";
│ │ │ │ │ + 49 }
│ │ │ │ │ + 50 {
│ │ │ │ │ + 51 out << "CELLS " << gv.size(1) << " " << (gv.size(1) + corners.size()) <<
│ │ │ │ │ +"\n";
│ │ │ │ │ + 52 std::size_t c = 0;
│ │ │ │ │ + 53 for (const auto& facet : facets(gv)) {
│ │ │ │ │ + 54 const auto geometry = facet.geometry();
│ │ │ │ │ + 55 out << geometry.corners();
│ │ │ │ │ + 56 for (int i = 0; i < geometry.corners(); ++i, ++c)
│ │ │ │ │ + 57 out << " " << c;
│ │ │ │ │ + 58 out << "\n";
│ │ │ │ │ + 59 }
│ │ │ │ │ + 60 }
│ │ │ │ │ + 61 {
│ │ │ │ │ + 62 out << "CELL_TYPES " << gv.size(1) << "\n";
│ │ │ │ │ + 63 for (const auto& facet : facets(gv)) {
│ │ │ │ │ + 64 const auto type = facet.type();
│ │ │ │ │ + 65 if (type.isVertex())
│ │ │ │ │ + 66 out << "1\n";
│ │ │ │ │ + 67 else if (type.isLine())
│ │ │ │ │ + 68 out << "2\n";
│ │ │ │ │ + 69 else if (type.isTriangle())
│ │ │ │ │ + 70 out << "5\n";
│ │ │ │ │ + 71 else if (type.isQuadrilateral())
│ │ │ │ │ + 72 out << "9\n";
│ │ │ │ │ + 73 else if (type.isTetrahedron())
│ │ │ │ │ + 74 out << "10\n";
│ │ │ │ │ + 75 else
│ │ │ │ │ + 76 DUNE_THROW(Dune::Exception, "Unhandled geometry type");
│ │ │ │ │ + 77 }
│ │ │ │ │ + 78 }
│ │ │ │ │ + 79}
│ │ │ │ │ + 80
│ │ │ │ │ + 81} /* namespace AreaWriterImplementation */
│ │ │ │ │ + 82
│ │ │ │ │ + 83template
│ │ │ │ │ +84void write_glue_area_vtk(const Glue& glue, std::ostream& out)
│ │ │ │ │ + 85{
│ │ │ │ │ + 86 using GridView = typename std::decay< decltype(glue.template gridView
│ │ │ │ │ +()) >::type;
│ │ │ │ │ + 87 using Mapper = Dune::MultipleCodimMultipleGeomTypeMapper;
│ │ │ │ │ + 88 using ctype = typename GridView::ctype;
│ │ │ │ │ + 89
│ │ │ │ │ + 90 const GridView gv = glue.template gridView();
│ │ │ │ │ + 91 Mapper mapper(gv);
│ │ │ │ │ + 92 std::vector coveredArea(mapper.size(), ctype(0));
│ │ │ │ │ + 93 std::vector totalArea(mapper.size(), ctype(1));
│ │ │ │ │ + 94
│ │ │ │ │ + 95 for (const auto& in : intersections(glue, Reverse())) {
│ │ │ │ │ + 96 const auto element = in.inside();
│ │ │ │ │ + 97 const auto index = mapper.subIndex(element, in.indexInInside(), 1);
│ │ │ │ │ + 98 coveredArea[index] += in.geometryInInside().volume();
│ │ │ │ │ + 99
│ │ │ │ │ + 100 const auto& refElement = Dune::ReferenceElements::general(element.type());
│ │ │ │ │ + 101 const auto& subGeometry = refElement.template geometry<1>(in.indexInInside
│ │ │ │ │ +());
│ │ │ │ │ + 102 totalArea[index] = subGeometry.volume();
│ │ │ │ │ + 103 }
│ │ │ │ │ + 104
│ │ │ │ │ + 105 for (std::size_t i = 0; i < coveredArea.size(); ++i)
│ │ │ │ │ + 106 coveredArea[i] /= totalArea[i];
│ │ │ │ │ + 107
│ │ │ │ │ + 108 out << "# vtk DataFile Version 2.0\n"
│ │ │ │ │ + 109 << "Filename: Glue Area\n"
│ │ │ │ │ + 110 << "ASCII\n";
│ │ │ │ │ + 111
│ │ │ │ │ + 112 AreaWriterImplementation::write_facet_geometry(gv, out);
│ │ │ │ │ + 113
│ │ │ │ │ + 114 out << "CELL_DATA " << coveredArea.size() << "\n"
│ │ │ │ │ + 115 << "SCALARS CoveredArea double 1\n"
│ │ │ │ │ + 116 << "LOOKUP_TABLE default\n";
│ │ │ │ │ + 117 for (const auto& value : coveredArea)
│ │ │ │ │ + 118 out << value << "\n";
│ │ │ │ │ + 119}
│ │ │ │ │ + 120
│ │ │ │ │ + 121template
│ │ │ │ │ +122void write_glue_area_vtk(const Glue& glue, const std::string& filename)
│ │ │ │ │ + 123{
│ │ │ │ │ + 124 std::ofstream out(filename.c_str());
│ │ │ │ │ + 125 write_glue_area_vtk(glue, out);
│ │ │ │ │ + 126}
│ │ │ │ │ + 127
│ │ │ │ │ + 128template
│ │ │ │ │ +129void write_glue_areas_vtk(const Glue& glue, const std::string& base)
│ │ │ │ │ + 130{
│ │ │ │ │ + 131 {
│ │ │ │ │ + 132 std::string filename = base;
│ │ │ │ │ + 133 filename += "-inside.vtk";
│ │ │ │ │ + 134 write_glue_area_vtk<0>(glue, filename);
│ │ │ │ │ + 135 }
│ │ │ │ │ + 136 {
│ │ │ │ │ + 137 std::string filename = base;
│ │ │ │ │ + 138 filename += "-outside.vtk";
│ │ │ │ │ + 139 write_glue_area_vtk<1>(glue, filename);
│ │ │ │ │ + 140 }
│ │ │ │ │ + 141}
│ │ │ │ │ + 142
│ │ │ │ │ + 143} /* namespace GridGlue */
│ │ │ │ │ + 144} /* namespace Dune */
│ │ │ │ │ Dune
│ │ │ │ │ Definition: gridglue.hh:37
│ │ │ │ │ -Dune::GridGlue::crossProduct
│ │ │ │ │ -static Dune::FieldVector< T, dim > crossProduct(const Dune::FieldVector< T, dim
│ │ │ │ │ -> &a, const Dune::FieldVector< T, dim > &b)
│ │ │ │ │ -compute cross product
│ │ │ │ │ -Definition: crossproduct.hh:15
│ │ │ │ │ +Dune::GridGlue::write_glue_area_vtk
│ │ │ │ │ +void write_glue_area_vtk(const Glue &glue, std::ostream &out)
│ │ │ │ │ +Definition: areawriter_impl.hh:84
│ │ │ │ │ +Dune::GridGlue::write_glue_areas_vtk
│ │ │ │ │ +void write_glue_areas_vtk(const Glue &glue, const std::string &base)
│ │ │ │ │ +Definition: areawriter_impl.hh:129
│ │ │ │ │ +Dune::GridGlue::intersections
│ │ │ │ │ +IteratorRange<... > intersections(const GridGlue<... > &glue, const Reverse<...
│ │ │ │ │ +> &reverse=!reversed)
│ │ │ │ │ +Iterate over all intersections of a GridGlue.
│ │ │ │ │ +Dune::GridGlue::AreaWriterImplementation::write_facet_geometry
│ │ │ │ │ +void write_facet_geometry(const GridView &gv, std::ostream &out)
│ │ │ │ │ +Definition: areawriter_impl.hh:25
│ │ │ │ │ +Dune::GridGlue::Reverse
│ │ │ │ │ +Definition: rangegenerators.hh:17
│ │ │ │ │ +Dune::GridGlue::AreaWriterImplementation::FacetLayout
│ │ │ │ │ +Definition: areawriter_impl.hh:17
│ │ │ │ │ +Dune::GridGlue::AreaWriterImplementation::FacetLayout::contains
│ │ │ │ │ +bool contains(Dune::GeometryType gt) const
│ │ │ │ │ +Definition: areawriter_impl.hh:18
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00035.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: areawriter.hh File Reference
│ │ │ │ +dune-grid-glue: ringcomm.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -64,43 +64,77 @@
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,185 +5,494 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -areawriter_impl.hh
│ │ │ │ │ +projection_impl.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#include
│ │ │ │ │ - 4#include
│ │ │ │ │ - 5
│ │ │ │ │ - 6#include
│ │ │ │ │ - 7#include
│ │ │ │ │ - 8#include
│ │ │ │ │ + 3#include
│ │ │ │ │ + 4
│ │ │ │ │ + 5#include
│ │ │ │ │ + 6
│ │ │ │ │ + 7namespace Dune {
│ │ │ │ │ + 8namespace GridGlue {
│ │ │ │ │ 9
│ │ │ │ │ - 10namespace Dune {
│ │ │ │ │ - 11namespace GridGlue {
│ │ │ │ │ - 12
│ │ │ │ │ -13namespace AreaWriterImplementation {
│ │ │ │ │ - 14
│ │ │ │ │ - 15template
│ │ │ │ │ -16struct FacetLayout
│ │ │ │ │ - 17{
│ │ │ │ │ -18 bool contains(Dune::GeometryType gt) const
│ │ │ │ │ - 19 {
│ │ │ │ │ - 20 return gt.dim() == dimgrid - 1;
│ │ │ │ │ - 21 }
│ │ │ │ │ - 22};
│ │ │ │ │ - 23
│ │ │ │ │ - 24template
│ │ │ │ │ -25void write_facet_geometry(const GridView& gv, std::ostream& out)
│ │ │ │ │ - 26{
│ │ │ │ │ - 27 using Coordinate = Dune::FieldVector;
│ │ │ │ │ - 28
│ │ │ │ │ - 29 std::vector corners;
│ │ │ │ │ - 30 for (const auto& facet : facets(gv)) {
│ │ │ │ │ - 31 const auto geometry = facet.geometry();
│ │ │ │ │ - 32 for (int i = 0; i < geometry.corners(); ++i) {
│ │ │ │ │ - 33 /* VTK always needs 3-dim coordinates... */
│ │ │ │ │ - 34 const auto c0 = geometry.corner(i);
│ │ │ │ │ - 35 Coordinate c1;
│ │ │ │ │ - 36 for (int d = 0; d < GridView::dimensionworld; ++d)
│ │ │ │ │ - 37 c1[d] = c0[d];
│ │ │ │ │ - 38 for (int d = GridView::dimensionworld; d < Coordinate::dimension; ++d)
│ │ │ │ │ - 39 c1[d] = double(0);
│ │ │ │ │ - 40 corners.push_back(c1);
│ │ │ │ │ - 41 }
│ │ │ │ │ - 42 }
│ │ │ │ │ - 43
│ │ │ │ │ - 44 {
│ │ │ │ │ - 45 out << "DATASET UNSTRUCTURED_GRID\n"
│ │ │ │ │ - 46 << "POINTS " << corners.size() << " double\n";
│ │ │ │ │ - 47 for (const auto& c : corners)
│ │ │ │ │ - 48 out << c << "\n";
│ │ │ │ │ +10namespace ProjectionImplementation {
│ │ │ │ │ + 11
│ │ │ │ │ + 22template
│ │ │ │ │ + 23inline Coordinate
│ │ │ │ │ +24corner(unsigned c)
│ │ │ │ │ + 25{
│ │ │ │ │ + 26 Coordinate x(Field(0));
│ │ │ │ │ + 27 if (c == 0)
│ │ │ │ │ + 28 return x;
│ │ │ │ │ + 29 x[c-1] = Field(1);
│ │ │ │ │ + 30 return x;
│ │ │ │ │ + 31}
│ │ │ │ │ + 32
│ │ │ │ │ + 42inline std::pair
│ │ │ │ │ +43edgeToCorners(unsigned edge)
│ │ │ │ │ + 44{
│ │ │ │ │ + 45 switch(edge) {
│ │ │ │ │ + 46 case 0: return {0, 1};
│ │ │ │ │ + 47 case 1: return {0, 2};
│ │ │ │ │ + 48 case 2: return {1, 2};
│ │ │ │ │ 49 }
│ │ │ │ │ - 50 {
│ │ │ │ │ - 51 out << "CELLS " << gv.size(1) << " " << (gv.size(1) + corners.size()) <<
│ │ │ │ │ -"\n";
│ │ │ │ │ - 52 std::size_t c = 0;
│ │ │ │ │ - 53 for (const auto& facet : facets(gv)) {
│ │ │ │ │ - 54 const auto geometry = facet.geometry();
│ │ │ │ │ - 55 out << geometry.corners();
│ │ │ │ │ - 56 for (int i = 0; i < geometry.corners(); ++i, ++c)
│ │ │ │ │ - 57 out << " " << c;
│ │ │ │ │ - 58 out << "\n";
│ │ │ │ │ - 59 }
│ │ │ │ │ - 60 }
│ │ │ │ │ - 61 {
│ │ │ │ │ - 62 out << "CELL_TYPES " << gv.size(1) << "\n";
│ │ │ │ │ - 63 for (const auto& facet : facets(gv)) {
│ │ │ │ │ - 64 const auto type = facet.type();
│ │ │ │ │ - 65 if (type.isVertex())
│ │ │ │ │ - 66 out << "1\n";
│ │ │ │ │ - 67 else if (type.isLine())
│ │ │ │ │ - 68 out << "2\n";
│ │ │ │ │ - 69 else if (type.isTriangle())
│ │ │ │ │ - 70 out << "5\n";
│ │ │ │ │ - 71 else if (type.isQuadrilateral())
│ │ │ │ │ - 72 out << "9\n";
│ │ │ │ │ - 73 else if (type.isTetrahedron())
│ │ │ │ │ - 74 out << "10\n";
│ │ │ │ │ - 75 else
│ │ │ │ │ - 76 DUNE_THROW(Dune::Exception, "Unhandled geometry type");
│ │ │ │ │ - 77 }
│ │ │ │ │ - 78 }
│ │ │ │ │ - 79}
│ │ │ │ │ - 80
│ │ │ │ │ - 81} /* namespace AreaWriterImplementation */
│ │ │ │ │ - 82
│ │ │ │ │ - 83template
│ │ │ │ │ -84void write_glue_area_vtk(const Glue& glue, std::ostream& out)
│ │ │ │ │ - 85{
│ │ │ │ │ - 86 using GridView = typename std::decay< decltype(glue.template gridView
│ │ │ │ │ -()) >::type;
│ │ │ │ │ - 87 using Mapper = Dune::MultipleCodimMultipleGeomTypeMapper;
│ │ │ │ │ - 88 using ctype = typename GridView::ctype;
│ │ │ │ │ - 89
│ │ │ │ │ - 90 const GridView gv = glue.template gridView();
│ │ │ │ │ - 91 Mapper mapper(gv);
│ │ │ │ │ - 92 std::vector coveredArea(mapper.size(), ctype(0));
│ │ │ │ │ - 93 std::vector totalArea(mapper.size(), ctype(1));
│ │ │ │ │ - 94
│ │ │ │ │ - 95 for (const auto& in : intersections(glue, Reverse())) {
│ │ │ │ │ - 96 const auto element = in.inside();
│ │ │ │ │ - 97 const auto index = mapper.subIndex(element, in.indexInInside(), 1);
│ │ │ │ │ - 98 coveredArea[index] += in.geometryInInside().volume();
│ │ │ │ │ - 99
│ │ │ │ │ - 100 const auto& refElement = Dune::ReferenceElements::general(element.type());
│ │ │ │ │ - 101 const auto& subGeometry = refElement.template geometry<1>(in.indexInInside
│ │ │ │ │ -());
│ │ │ │ │ - 102 totalArea[index] = subGeometry.volume();
│ │ │ │ │ - 103 }
│ │ │ │ │ - 104
│ │ │ │ │ - 105 for (std::size_t i = 0; i < coveredArea.size(); ++i)
│ │ │ │ │ - 106 coveredArea[i] /= totalArea[i];
│ │ │ │ │ - 107
│ │ │ │ │ - 108 out << "# vtk DataFile Version 2.0\n"
│ │ │ │ │ - 109 << "Filename: Glue Area\n"
│ │ │ │ │ - 110 << "ASCII\n";
│ │ │ │ │ - 111
│ │ │ │ │ - 112 AreaWriterImplementation::write_facet_geometry(gv, out);
│ │ │ │ │ - 113
│ │ │ │ │ - 114 out << "CELL_DATA " << coveredArea.size() << "\n"
│ │ │ │ │ - 115 << "SCALARS CoveredArea double 1\n"
│ │ │ │ │ - 116 << "LOOKUP_TABLE default\n";
│ │ │ │ │ - 117 for (const auto& value : coveredArea)
│ │ │ │ │ - 118 out << value << "\n";
│ │ │ │ │ - 119}
│ │ │ │ │ - 120
│ │ │ │ │ - 121template
│ │ │ │ │ -122void write_glue_area_vtk(const Glue& glue, const std::string& filename)
│ │ │ │ │ - 123{
│ │ │ │ │ - 124 std::ofstream out(filename.c_str());
│ │ │ │ │ - 125 write_glue_area_vtk(glue, out);
│ │ │ │ │ - 126}
│ │ │ │ │ + 50 DUNE_THROW(Dune::Exception, "Unexpected edge number.");
│ │ │ │ │ + 51}
│ │ │ │ │ + 52
│ │ │ │ │ + 68template
│ │ │ │ │ + 69inline typename Corners::value_type
│ │ │ │ │ +70interpolate(const Coordinate& x, const Corners& corners)
│ │ │ │ │ + 71{
│ │ │ │ │ + 72 auto y = corners[0];
│ │ │ │ │ + 73 for (unsigned i = 0; i < corners.size() - 1; ++i)
│ │ │ │ │ + 74 y.axpy(x[i], corners[i+1] - corners[0]);
│ │ │ │ │ + 75 return y;
│ │ │ │ │ + 76}
│ │ │ │ │ + 77
│ │ │ │ │ + 89template
│ │ │ │ │ + 90inline typename Normals::value_type
│ │ │ │ │ +91interpolate_unit_normals(const Coordinate& x, const Normals& normals)
│ │ │ │ │ + 92{
│ │ │ │ │ + 93 auto n = interpolate(x, normals);
│ │ │ │ │ + 94 n /= n.two_norm();
│ │ │ │ │ + 95 return n;
│ │ │ │ │ + 96}
│ │ │ │ │ + 97
│ │ │ │ │ + 109template
│ │ │ │ │ + 110inline bool
│ │ │ │ │ +111inside(const Coordinate& x, const Field& epsilon)
│ │ │ │ │ + 112{
│ │ │ │ │ + 113 const unsigned dim = Coordinate::dimension;
│ │ │ │ │ + 114 Field sum(0);
│ │ │ │ │ + 115 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ + 116 if (x[i] < -epsilon)
│ │ │ │ │ + 117 return false;
│ │ │ │ │ + 118 sum += x[i];
│ │ │ │ │ + 119 }
│ │ │ │ │ + 120 /* If any xᵢ is NaN, sum will be NaN and this comparison false! */
│ │ │ │ │ + 121 if (sum <= Field(1) + epsilon)
│ │ │ │ │ + 122 return true;
│ │ │ │ │ + 123 return false;
│ │ │ │ │ + 124}
│ │ │ │ │ + 125
│ │ │ │ │ + 126} /* namespace ProjectionImplementation */
│ │ │ │ │ 127
│ │ │ │ │ - 128template
│ │ │ │ │ -129void write_glue_areas_vtk(const Glue& glue, const std::string& base)
│ │ │ │ │ - 130{
│ │ │ │ │ - 131 {
│ │ │ │ │ - 132 std::string filename = base;
│ │ │ │ │ - 133 filename += "-inside.vtk";
│ │ │ │ │ - 134 write_glue_area_vtk<0>(glue, filename);
│ │ │ │ │ - 135 }
│ │ │ │ │ - 136 {
│ │ │ │ │ - 137 std::string filename = base;
│ │ │ │ │ - 138 filename += "-outside.vtk";
│ │ │ │ │ - 139 write_glue_area_vtk<1>(glue, filename);
│ │ │ │ │ - 140 }
│ │ │ │ │ - 141}
│ │ │ │ │ - 142
│ │ │ │ │ - 143} /* namespace GridGlue */
│ │ │ │ │ - 144} /* namespace Dune */
│ │ │ │ │ + 128template
│ │ │ │ │ + 129Projection
│ │ │ │ │ +130::Projection(const Field overlap, const Field max_normal_product)
│ │ │ │ │ + 131 : m_overlap(overlap)
│ │ │ │ │ + 132 , m_max_normal_product(max_normal_product)
│ │ │ │ │ + 133{
│ │ │ │ │ + 134 /* Nothing. */
│ │ │ │ │ + 135}
│ │ │ │ │ + 136
│ │ │ │ │ + 137template
│ │ │ │ │ + 138void
│ │ │ │ │ + 139Projection
│ │ │ │ │ +140::epsilon(const Field epsilon)
│ │ │ │ │ + 141{
│ │ │ │ │ + 142 m_epsilon = epsilon;
│ │ │ │ │ + 143}
│ │ │ │ │ + 144
│ │ │ │ │ + 145template
│ │ │ │ │ + 146template
│ │ │ │ │ + 147void
│ │ │ │ │ + 148Projection
│ │ │ │ │ + 149::doProjection(const std::tuple& corners, const std::
│ │ │ │ │ +tuple& normals)
│ │ │ │ │ + 150{
│ │ │ │ │ + 151 /* Try to obtain Φ(xᵢ) for each corner xᵢ of the preimage triangle.
│ │ │ │ │ + 152 * This means solving a linear system of equations
│ │ │ │ │ + 153 * Φ(xᵢ) = (1-α-β) y₀ + α y₁ + β y₂ = xᵢ + δ nᵢ
│ │ │ │ │ + 154 * or α (y₁ - y₀) + β (y₂ - y₀) - δ nᵢ = xᵢ - y₀
│ │ │ │ │ + 155 * to obtain the barycentric coordinates (α, β) of Φ(xᵢ) in the image
│ │ │ │ │ + 156 * triangle and the distance δ.
│ │ │ │ │ + 157 *
│ │ │ │ │ + 158 * In the matrix m corresponding to the system, only the third column and
│ │ │ │ │ +the
│ │ │ │ │ + 159 * right-hand side depend on i. The first two columns can be assembled
│ │ │ │ │ +before
│ │ │ │ │ + 160 * and reused.
│ │ │ │ │ + 161 */
│ │ │ │ │ + 162 using namespace ProjectionImplementation;
│ │ │ │ │ + 163 using std::get;
│ │ │ │ │ + 164 typedef Dune::FieldMatrix Matrix;
│ │ │ │ │ + 165 Matrix m;
│ │ │ │ │ + 166
│ │ │ │ │ + 167 const auto& origin = get<0>(corners);
│ │ │ │ │ + 168 const auto& origin_normals = get<0>(normals);
│ │ │ │ │ + 169 const auto& target = get<1>(corners);
│ │ │ │ │ + 170 const auto& target_normals = get<1>(normals);
│ │ │ │ │ + 171 auto& images = get<0>(m_images);
│ │ │ │ │ + 172 auto& success = get<0>(m_success);
│ │ │ │ │ + 173
│ │ │ │ │ + 174 /* directionsᵢ = (yᵢ - y₀) / ||yᵢ - y₀||
│ │ │ │ │ + 175 * These are the first to columns of the system matrix; the rescaling is
│ │ │ │ │ +done
│ │ │ │ │ + 176 * to ensure all columns have a comparable norm (the last has the normal
│ │ │ │ │ +with norm 1.
│ │ │ │ │ + 177 */
│ │ │ │ │ + 178 std::array directions;
│ │ │ │ │ + 179 std::array scales;
│ │ │ │ │ + 180 /* estimator for the diameter of the target face */
│ │ │ │ │ + 181 Field scaleSum(0);
│ │ │ │ │ + 182 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ + 183 directions[i] = target[i+1] - target[0];
│ │ │ │ │ + 184 scales[i] = directions[i].infinity_norm();
│ │ │ │ │ + 185 directions[i] /= scales[i];
│ │ │ │ │ + 186 scaleSum += scales[i];
│ │ │ │ │ + 187 }
│ │ │ │ │ + 188
│ │ │ │ │ + 189 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ + 190 for (unsigned j = 0; j < dim; ++j) {
│ │ │ │ │ + 191 m[j][i] = directions[i][j];
│ │ │ │ │ + 192 }
│ │ │ │ │ + 193 }
│ │ │ │ │ + 194
│ │ │ │ │ + 195 m_projection_valid = true;
│ │ │ │ │ + 196 success.reset();
│ │ │ │ │ + 197
│ │ │ │ │ + 198 /* Now project xᵢ for each i */
│ │ │ │ │ + 199 for (unsigned i = 0; i < origin.size(); ++i) {
│ │ │ │ │ + 200 for (unsigned j = 0; j < dim; ++j)
│ │ │ │ │ + 201 m[j][dim-1] = origin_normals[i][j];
│ │ │ │ │ + 202
│ │ │ │ │ + 203 const Coordinate rhs = origin[i] - target[0];
│ │ │ │ │ + 204
│ │ │ │ │ + 205 try {
│ │ │ │ │ + 206 /* y = (α, β, δ) */
│ │ │ │ │ + 207 auto& y = images[i];
│ │ │ │ │ + 208 m.solve(y, rhs);
│ │ │ │ │ + 209 for (unsigned j = 0; j < dim-1; ++j)
│ │ │ │ │ + 210 y[j] /= scales[j];
│ │ │ │ │ + 211 /* Solving gave us -δ as the term is "-δ nᵢ". */
│ │ │ │ │ + 212 y[dim-1] *= Field(-1);
│ │ │ │ │ + 213
│ │ │ │ │ + 214 /* If the forward projection is too far in the wrong direction
│ │ │ │ │ + 215 * then this might result in artificial inverse projections or
│ │ │ │ │ + 216 * edge intersections. To prevent these wrong cases but not
│ │ │ │ │ + 217 * dismiss feasible intersections, the projection is dismissed
│ │ │ │ │ + 218 * if the forward projection is further than two times the
│ │ │ │ │ + 219 * approximate diameter of the image triangle.
│ │ │ │ │ + 220 */
│ │ │ │ │ + 221 if(y[dim-1] < -2*scaleSum) {
│ │ │ │ │ + 222 success.set(i,false);
│ │ │ │ │ + 223 m_projection_valid = false;
│ │ │ │ │ + 224 return;
│ │ │ │ │ + 225 }
│ │ │ │ │ + 226
│ │ │ │ │ + 227 const bool feasible = projectionFeasible(origin[i], origin_normals[i], y,
│ │ │ │ │ +target, target_normals);
│ │ │ │ │ + 228 success.set(i, feasible);
│ │ │ │ │ + 229 }
│ │ │ │ │ + 230 catch (const Dune::FMatrixError&) {
│ │ │ │ │ + 231 success.set(i, false);
│ │ │ │ │ + 232 m_projection_valid = false;
│ │ │ │ │ + 233 }
│ │ │ │ │ + 234 }
│ │ │ │ │ + 235}
│ │ │ │ │ + 236
│ │ │ │ │ + 237template
│ │ │ │ │ + 238template
│ │ │ │ │ + 239void
│ │ │ │ │ + 240Projection
│ │ │ │ │ + 241::doInverseProjection(const std::tuple& corners, const
│ │ │ │ │ +std::tuple& normals)
│ │ │ │ │ + 242{
│ │ │ │ │ + 243 /* Try to obtain Φ⁻¹(yᵢ) for each corner yᵢ of the image triangle.
│ │ │ │ │ + 244 * Instead of solving the problem directly (which would lead to
│ │ │ │ │ + 245 * non-linear equations), we make use of the forward projection Φ
│ │ │ │ │ + 246 * which projects the preimage triangle on the plane spanned by the
│ │ │ │ │ + 247 * image triangle. The inverse projection is then given by finding
│ │ │ │ │ + 248 * the barycentric coordinates of yᵢ with respect to the triangle
│ │ │ │ │ + 249 * with the corners Φ(xᵢ). This way we only have to solve linear
│ │ │ │ │ + 250 * equations.
│ │ │ │ │ + 251 */
│ │ │ │ │ + 252
│ │ │ │ │ + 253 using namespace ProjectionImplementation;
│ │ │ │ │ + 254 using std::get;
│ │ │ │ │ + 255 typedef Dune::FieldMatrix Matrix;
│ │ │ │ │ + 256 typedef Dune::FieldVector Vector;
│ │ │ │ │ + 257
│ │ │ │ │ + 258 /* The inverse projection can only be computed if the forward projection
│ │ │ │ │ + 259 * managed to project all xᵢ on the plane spanned by the yᵢ
│ │ │ │ │ + 260 */
│ │ │ │ │ + 261 if (!m_projection_valid) {
│ │ │ │ │ + 262 get<1>(m_success).reset();
│ │ │ │ │ + 263 return;
│ │ │ │ │ + 264 }
│ │ │ │ │ + 265
│ │ │ │ │ + 266 const auto& images = get<0>(m_images);
│ │ │ │ │ + 267 const auto& target_corners = get<1>(corners);
│ │ │ │ │ + 268 auto& preimages = get<1>(m_images);
│ │ │ │ │ + 269 auto& success = get<1>(m_success);
│ │ │ │ │ + 270
│ │ │ │ │ + 271 std::array v;
│ │ │ │ │ + 272 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ + 273 v[i] = interpolate(images[i+1], target_corners);
│ │ │ │ │ + 274 v[i] -= interpolate(images[0], target_corners);
│ │ │ │ │ + 275 }
│ │ │ │ │ + 276
│ │ │ │ │ + 277 Matrix m;
│ │ │ │ │ + 278 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ + 279 for (unsigned j = 0; j < dim-1; ++j) {
│ │ │ │ │ + 280 m[i][j] = v[i]*v[j];
│ │ │ │ │ + 281 }
│ │ │ │ │ + 282 }
│ │ │ │ │ + 283
│ │ │ │ │ + 284 for (unsigned i = 0; i < dim; ++i) {
│ │ │ │ │ + 285 /* Convert yᵢ to barycentric coordinates with respect to Φ(xⱼ) */
│ │ │ │ │ + 286 v[dim-1] = target_corners[i];
│ │ │ │ │ + 287 v[dim-1] -= interpolate(images[0], target_corners);
│ │ │ │ │ + 288
│ │ │ │ │ + 289 Vector rhs, z;
│ │ │ │ │ + 290 for (unsigned j = 0; j < dim-1; ++j)
│ │ │ │ │ + 291 rhs[j] = v[dim-1]*v[j];
│ │ │ │ │ + 292 m.solve(z, rhs);
│ │ │ │ │ + 293
│ │ │ │ │ + 294 for (unsigned j = 0; j < dim-1; ++j)
│ │ │ │ │ + 295 preimages[i][j] = z[j];
│ │ │ │ │ + 296
│ │ │ │ │ + 297 /* Calculate distance along normal direction */
│ │ │ │ │ + 298 const auto x = interpolate(z, get<0>(corners));
│ │ │ │ │ + 299 preimages[i][dim-1] = (x - target_corners[i]) * get<1>(normals)[i];
│ │ │ │ │ + 300
│ │ │ │ │ + 301 /* Check y_i lies inside the Φ(xⱼ) */
│ │ │ │ │ + 302 const bool feasible = projectionFeasible(target_corners[i], get<1>
│ │ │ │ │ +(normals)[i], preimages[i], get<0>(corners), get<0>(normals));
│ │ │ │ │ + 303 success.set(i, feasible);
│ │ │ │ │ + 304 }
│ │ │ │ │ + 305}
│ │ │ │ │ + 306
│ │ │ │ │ + 307template
│ │ │ │ │ + 308template
│ │ │ │ │ + 309void
│ │ │ │ │ + 310Projection
│ │ │ │ │ + 311::doEdgeIntersection(const std::tuple& corners, const
│ │ │ │ │ +std::tuple& normals)
│ │ │ │ │ + 312{
│ │ │ │ │ + 313 using namespace ProjectionImplementation;
│ │ │ │ │ + 314 using std::get;
│ │ │ │ │ + 315
│ │ │ │ │ + 316 m_number_of_edge_intersections = 0;
│ │ │ │ │ + 317
│ │ │ │ │ + 318 /* There are no edge intersections for 2d, only for 3d */
│ │ │ │ │ + 319 if (dim != 3)
│ │ │ │ │ + 320 return;
│ │ │ │ │ + 321
│ │ │ │ │ + 322 /* There are no edge intersections
│ │ │ │ │ + 323 * - when the projection is invalid,
│ │ │ │ │ + 324 * - when the projected triangle lies fully in the target triangle,
│ │ │ │ │ + 325 * - or when the target triangle lies fully in the projected triangle.
│ │ │ │ │ + 326 */
│ │ │ │ │ + 327 if (!m_projection_valid || get<0>(m_success).all() || get<1>
│ │ │ │ │ +(m_success).all()) {
│ │ │ │ │ + 328 return;
│ │ │ │ │ + 329 }
│ │ │ │ │ + 330
│ │ │ │ │ + 331 const auto& images = get<0>(m_images);
│ │ │ │ │ + 332 const auto& ys = get<1>(corners);
│ │ │ │ │ + 333
│ │ │ │ │ + 334 /* Intersect line through Φ(xᵢ), Φ(xⱼ) with line through yₖ, yₗ:
│ │ │ │ │ + 335 We want α, β ∈ ℝ such that
│ │ │ │ │ + 336 Φ(xᵢ) + α (Φ(xⱼ) - Φ(xᵢ)) = yₖ + β (yₗ - yₖ)
│ │ │ │ │ + 337 or
│ │ │ │ │ + 338 α (Φ(xⱼ)-Φ(xᵢ)) + β (yₗ-yₖ) = yₖ-Φ(xᵢ)
│ │ │ │ │ + 339 To get a 2×2 system of equations, multiply with yₘ-y₀ for
│ │ │ │ │ + 340 m ∈ {1,̣̣2} which are linear indep. (and so the system is
│ │ │ │ │ + 341 equivalent to the original 3×2 system)
│ │ │ │ │ + 342 */
│ │ │ │ │ + 343 for (unsigned edgex = 0; edgex < dim; ++edgex) {
│ │ │ │ │ + 344 unsigned i, j;
│ │ │ │ │ + 345 std::tie(i, j) = edgeToCorners(edgex);
│ │ │ │ │ + 346
│ │ │ │ │ + 347 /* Both sides of edgex lie in the target triangle means no edge
│ │ │ │ │ +intersection */
│ │ │ │ │ + 348 if (get<0>(m_success)[i] && get<0>(m_success)[j])
│ │ │ │ │ + 349 continue;
│ │ │ │ │ + 350
│ │ │ │ │ + 351 const auto pxi = interpolate(images[i], ys);
│ │ │ │ │ + 352 const auto pxj = interpolate(images[j], ys);
│ │ │ │ │ + 353 const auto pxjpxi = pxj - pxi;
│ │ │ │ │ + 354
│ │ │ │ │ + 355 typedef Dune::FieldMatrix Matrix;
│ │ │ │ │ + 356 typedef Dune::FieldVector Vector;
│ │ │ │ │ + 357
│ │ │ │ │ + 358 for (unsigned edgey = 0; edgey < dim; ++edgey) {
│ │ │ │ │ + 359 unsigned k, l;
│ │ │ │ │ + 360 std::tie(k, l) = edgeToCorners(edgey);
│ │ │ │ │ + 361
│ │ │ │ │ + 362 /* Both sides of edgey lie in the projected triangle means no edge
│ │ │ │ │ +intersection */
│ │ │ │ │ + 363 if (get<1>(m_success)[k] && get<1>(m_success)[l])
│ │ │ │ │ + 364 continue;
│ │ │ │ │ + 365
│ │ │ │ │ + 366 const auto ykyl = ys[k] - ys[l];
│ │ │ │ │ + 367 const auto ykpxi = ys[k] - pxi;
│ │ │ │ │ + 368
│ │ │ │ │ + 369 /* If edges are parallel then the intersection is already computed by
│ │ │ │ │ +vertex projections. */
│ │ │ │ │ + 370 bool parallel = true;
│ │ │ │ │ + 371 for (unsigned h=0; h<3; h++)
│ │ │ │ │ + 372 parallel &= std::abs(ykyl[(h+1)%3]*pxjpxi[(h+2)%3] - ykyl[(h+2)%3]*pxjpxi[
│ │ │ │ │ +(h+1)%3])<1e-14;
│ │ │ │ │ + 373 if (parallel)
│ │ │ │ │ + 374 continue;
│ │ │ │ │ + 375
│ │ │ │ │ + 376 Matrix mat;
│ │ │ │ │ + 377 Vector rhs, z;
│ │ │ │ │ + 378
│ │ │ │ │ + 379 for (unsigned m = 0; m < dim-1; ++m) {
│ │ │ │ │ + 380 const auto ym1y0 = ys[m+1] - ys[0];
│ │ │ │ │ + 381 mat[m][0] = pxjpxi * ym1y0;
│ │ │ │ │ + 382 mat[m][1] = ykyl * ym1y0;
│ │ │ │ │ + 383 rhs[m] = ykpxi * ym1y0;
│ │ │ │ │ + 384 }
│ │ │ │ │ + 385
│ │ │ │ │ + 386 try {
│ │ │ │ │ + 387 using std::isfinite;
│ │ │ │ │ + 388
│ │ │ │ │ + 389 mat.solve(z, rhs);
│ │ │ │ │ + 390
│ │ │ │ │ + 391 /* If solving the system gives a NaN, the edges are probably parallel. */
│ │ │ │ │ + 392 if (!isfinite(z[0]) || !isfinite(z[1]))
│ │ │ │ │ + 393 continue;
│ │ │ │ │ + 394
│ │ │ │ │ + 395 /* Filter out corner (pre)images. We only want "real" edge-edge
│ │ │ │ │ +intersections here. */
│ │ │ │ │ + 396 if (z[0] < m_epsilon || z[0] > Field(1) - m_epsilon
│ │ │ │ │ + 397 || z[1] < m_epsilon || z[1] > Field(1) - m_epsilon)
│ │ │ │ │ + 398 continue;
│ │ │ │ │ + 399
│ │ │ │ │ + 400 Coordinate local_x = corner(i);
│ │ │ │ │ + 401 local_x.axpy(z[0], corner(j) - corner(i));
│ │ │ │ │ + 402 Coordinate local_y = corner(k);
│ │ │ │ │ + 403 local_y.axpy(z[1], corner(l) - corner(k));
│ │ │ │ │ + 404
│ │ │ │ │ + 405 /* Make sure the intersection is in the triangle. */
│ │ │ │ │ + 406 if (!inside(local_x, m_epsilon) || !inside(local_y, m_epsilon))
│ │ │ │ │ + 407 continue;
│ │ │ │ │ + 408
│ │ │ │ │ + 409 /* Make sure the intersection respects overlap. */
│ │ │ │ │ + 410 auto xy = interpolate(local_x, get<0>(corners));
│ │ │ │ │ + 411 xy -= interpolate(local_y, get<1>(corners));
│ │ │ │ │ + 412 const auto nx = interpolate_unit_normals(local_x, get<0>(normals));
│ │ │ │ │ + 413 const auto ny = interpolate_unit_normals(local_y, get<1>(normals));
│ │ │ │ │ + 414 local_x[dim-1] = -(xy*nx);
│ │ │ │ │ + 415 local_y[dim-1] = xy*ny;
│ │ │ │ │ + 416
│ │ │ │ │ + 417 if (local_x[dim-1] < -m_overlap-m_epsilon || local_y[dim-1] < -m_overlap-
│ │ │ │ │ +m_epsilon)
│ │ │ │ │ + 418 continue;
│ │ │ │ │ + 419
│ │ │ │ │ + 420 /* Normals should be opposing. */
│ │ │ │ │ + 421 if (nx*ny > m_max_normal_product + m_epsilon)
│ │ │ │ │ + 422 continue;
│ │ │ │ │ + 423
│ │ │ │ │ + 424 /* Intersection is feasible. Store it. */
│ │ │ │ │ + 425 auto& intersection = m_edge_intersections
│ │ │ │ │ +[m_number_of_edge_intersections++];
│ │ │ │ │ + 426 intersection = { {{edgex, edgey}}, {{local_x, local_y}} };
│ │ │ │ │ + 427 }
│ │ │ │ │ + 428 catch(const Dune::FMatrixError&) {
│ │ │ │ │ + 429 /* Edges might be parallel, ignore and continue with next edge */
│ │ │ │ │ + 430 }
│ │ │ │ │ + 431 }
│ │ │ │ │ + 432 }
│ │ │ │ │ + 433}
│ │ │ │ │ + 434
│ │ │ │ │ + 435template
│ │ │ │ │ + 436template
│ │ │ │ │ + 437bool Projection
│ │ │ │ │ + 438::projectionFeasible(const Coordinate& x, const Coordinate& nx, const
│ │ │ │ │ +Coordinate& px, const Corners& corners, const Normals& normals) const
│ │ │ │ │ + 439{
│ │ │ │ │ + 440 using namespace ProjectionImplementation;
│ │ │ │ │ + 441
│ │ │ │ │ + 442 /* Image must be within simplex. */
│ │ │ │ │ + 443 if (!inside(px, m_epsilon))
│ │ │ │ │ + 444 return false;
│ │ │ │ │ + 445
│ │ │ │ │ + 446 /* Distance along normal must not be smaller than -overlap. */
│ │ │ │ │ + 447 if (px[dim-1] < -m_overlap-m_epsilon)
│ │ │ │ │ + 448 return false;
│ │ │ │ │ + 449
│ │ │ │ │ + 450 /* Distance along normal at image must not be smaller than -overlap. */
│ │ │ │ │ + 451 auto xmy = x;
│ │ │ │ │ + 452 xmy -= interpolate(px, corners);
│ │ │ │ │ + 453 const auto n = interpolate_unit_normals(px, normals);
│ │ │ │ │ + 454 const auto d = xmy * n;
│ │ │ │ │ + 455 if (d < -m_overlap-m_epsilon)
│ │ │ │ │ + 456 return false;
│ │ │ │ │ + 457
│ │ │ │ │ + 458 /* Normals at x and Φ(x) are opposing. */
│ │ │ │ │ + 459 if (nx * n > m_max_normal_product + m_epsilon)
│ │ │ │ │ + 460 return false;
│ │ │ │ │ + 461
│ │ │ │ │ + 462 /* Okay, projection is feasible. */
│ │ │ │ │ + 463 return true;
│ │ │ │ │ + 464}
│ │ │ │ │ + 465
│ │ │ │ │ + 466template
│ │ │ │ │ + 467template
│ │ │ │ │ + 468void Projection
│ │ │ │ │ +469::project(const std::tuple& corners, const std::
│ │ │ │ │ +tuple& normals)
│ │ │ │ │ + 470{
│ │ │ │ │ + 471 doProjection(corners, normals);
│ │ │ │ │ + 472 doInverseProjection(corners, normals);
│ │ │ │ │ + 473 doEdgeIntersection(corners, normals);
│ │ │ │ │ + 474}
│ │ │ │ │ + 475
│ │ │ │ │ + 476} /* namespace GridGlue */
│ │ │ │ │ + 477} /* namespace Dune */
│ │ │ │ │ Dune
│ │ │ │ │ Definition: gridglue.hh:37
│ │ │ │ │ -Dune::GridGlue::write_glue_area_vtk
│ │ │ │ │ -void write_glue_area_vtk(const Glue &glue, std::ostream &out)
│ │ │ │ │ -Definition: areawriter_impl.hh:84
│ │ │ │ │ -Dune::GridGlue::write_glue_areas_vtk
│ │ │ │ │ -void write_glue_areas_vtk(const Glue &glue, const std::string &base)
│ │ │ │ │ -Definition: areawriter_impl.hh:129
│ │ │ │ │ -Dune::GridGlue::intersections
│ │ │ │ │ -IteratorRange<... > intersections(const GridGlue<... > &glue, const Reverse<...
│ │ │ │ │ -> &reverse=!reversed)
│ │ │ │ │ -Iterate over all intersections of a GridGlue.
│ │ │ │ │ -Dune::GridGlue::AreaWriterImplementation::write_facet_geometry
│ │ │ │ │ -void write_facet_geometry(const GridView &gv, std::ostream &out)
│ │ │ │ │ -Definition: areawriter_impl.hh:25
│ │ │ │ │ -Dune::GridGlue::Reverse
│ │ │ │ │ -Definition: rangegenerators.hh:17
│ │ │ │ │ -Dune::GridGlue::AreaWriterImplementation::FacetLayout
│ │ │ │ │ -Definition: areawriter_impl.hh:17
│ │ │ │ │ -Dune::GridGlue::AreaWriterImplementation::FacetLayout::contains
│ │ │ │ │ -bool contains(Dune::GeometryType gt) const
│ │ │ │ │ -Definition: areawriter_impl.hh:18
│ │ │ │ │ +Dune::GridGlue::ProjectionImplementation::interpolate
│ │ │ │ │ +Corners::value_type interpolate(const Coordinate &x, const Corners &corners)
│ │ │ │ │ +Definition: projection_impl.hh:70
│ │ │ │ │ +Dune::GridGlue::ProjectionImplementation::inside
│ │ │ │ │ +bool inside(const Coordinate &x, const Field &epsilon)
│ │ │ │ │ +Definition: projection_impl.hh:111
│ │ │ │ │ +Dune::GridGlue::ProjectionImplementation::edgeToCorners
│ │ │ │ │ +std::pair< unsigned, unsigned > edgeToCorners(unsigned edge)
│ │ │ │ │ +Definition: projection_impl.hh:43
│ │ │ │ │ +Dune::GridGlue::ProjectionImplementation::corner
│ │ │ │ │ +Coordinate corner(unsigned c)
│ │ │ │ │ +Definition: projection_impl.hh:24
│ │ │ │ │ +Dune::GridGlue::ProjectionImplementation::interpolate_unit_normals
│ │ │ │ │ +Normals::value_type interpolate_unit_normals(const Coordinate &x, const Normals
│ │ │ │ │ +&normals)
│ │ │ │ │ +Definition: projection_impl.hh:91
│ │ │ │ │ +Dune::GridGlue::Projection
│ │ │ │ │ +Projection of a line (triangle) on another line (triangle).
│ │ │ │ │ +Definition: projection.hh:21
│ │ │ │ │ +Dune::GridGlue::Projection::Field
│ │ │ │ │ +Coordinate::field_type Field
│ │ │ │ │ +Scalar type.
│ │ │ │ │ +Definition: projection.hh:61
│ │ │ │ │ +Dune::GridGlue::Projection::Projection
│ │ │ │ │ +Projection(const Field overlap=Field(0), const Field max_normal_product=Field(-
│ │ │ │ │ +0.1))
│ │ │ │ │ +Definition: projection_impl.hh:130
│ │ │ │ │ +Dune::GridGlue::Projection::epsilon
│ │ │ │ │ +void epsilon(const Field epsilon)
│ │ │ │ │ +Set epsilon used for floating-point comparisons.
│ │ │ │ │ +Definition: projection_impl.hh:140
│ │ │ │ │ +Dune::GridGlue::Projection::project
│ │ │ │ │ +void project(const std::tuple< Corners &, Corners & > &corners, const std::
│ │ │ │ │ +tuple< Normals &, Normals & > &normals)
│ │ │ │ │ +Do the actual projection.
│ │ │ │ │ +Definition: projection_impl.hh:469
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00041.html
│ │ │ │ @@ -71,15 +71,15 @@
│ │ │ │ Namespaces
│ │ │ │
│ │ │ │
│ │ │ │
Write all remote intersections to a AmiraMesh file. │ │ │ │ -More...
│ │ │ │ -#include <fstream>│ │ │ │ -
#include <sstream>│ │ │ │ -
#include <type_traits>│ │ │ │ -
Go to the source code of this file.
│ │ │ │ -│ │ │ │ -Classes | |
| class | Dune::GridGlue::GridGlueAmiraWriter |
| Write remote intersections to a AmiraMesh file for debugging purposes. More... | |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
│ │ │ │ +Functions | |
| template<typename T > | |
| void | Dune::GridGlue::printVector (const std::vector< T > &v, std::string name, int rank) |
Detailed Description
│ │ │ │ -Write all remote intersections to a AmiraMesh file.
│ │ │ │ -│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,29 +5,28 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * adapter
│ │ │ │ │ -Classes | Namespaces
│ │ │ │ │ -gridglueamirawriter.hh File Reference
│ │ │ │ │ -Write all remote intersections to a AmiraMesh file. More...
│ │ │ │ │ -#include
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ Namespaces |
│ │ │ │ Functions
│ │ │ │ - projectionwriter_impl.hh File Reference
crossproduct.hh File Reference
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ #include <fstream>│ │ │ │ -
Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
| namespace | Dune::GridGlue::ProjectionWriterImplementation |
│ │ │ │ Functions | |
| template<unsigned side, typename Coordinate , typename Corners > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_points (const Projection< Coordinate > &projection, const Corners &corners, std::ostream &out) |
| template<unsigned side, typename Coordinate , typename Normals > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_normals (const Projection< Coordinate > &projection, const Normals &normals, std::ostream &out) |
| template<typename Coordinate , typename Corners > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_edge_intersection_points (const Projection< Coordinate > &projection, const Corners &corners, std::ostream &out) |
| template<typename Coordinate , typename Normals > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_edge_intersection_normals (const Projection< Coordinate > &projection, const Normals &normals, std::ostream &out) |
| template<unsigned side, typename Coordinate > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_success (const Projection< Coordinate > &projection, std::ostream &out) |
| template<typename Coordinate , typename Corners , typename Normals > | |
| void | Dune::GridGlue::write (const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals, std::ostream &out) |
| write projection in VTK format More... | |
| template<typename Coordinate , typename Corners , typename Normals > | |
| void | Dune::GridGlue::write (const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals, const std::string &filename) |
| write projection in VTK format More... | |
| template<typename Coordinate , typename Corners , typename Normals > | |
| void | Dune::GridGlue::print (const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals) |
| Print information about the projection to std::cout stream. More... | |
| template<class T , int dim> | |
| static Dune::FieldVector< T, dim > | Dune::GridGlue::crossProduct (const Dune::FieldVector< T, dim > &a, const Dune::FieldVector< T, dim > &b) |
| compute cross product More... | |
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -6,60 +6,24 @@
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ Namespaces | Functions
│ │ │ │ │ -projectionwriter_impl.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ projectionwriter_impl.hh
crossproduct.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 11void write_points(const Projection<Coordinate>& projection, const Corners& corners, std::ostream& out)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ - 27void write_normals(const Projection<Coordinate>& projection, const Normals& normals, std::ostream& out)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 43void write_edge_intersection_points(const Projection<Coordinate>& projection, const Corners& corners, std::ostream& out)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 56void write_edge_intersection_normals(const Projection<Coordinate>& projection, const Normals& normals, std::ostream& out)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 104 out << "CELLS " << (8 + numberOfEdgeIntersections) << " " << (26 + 3 * numberOfEdgeIntersections) << "\n";
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ Definition: gridglue.hh:37
void write(const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals, std::ostream &out)
write projection in VTK format
Definition: projectionwriter_impl.hh:86
void print(const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals)
Print information about the projection to std::cout stream.
Definition: projectionwriter_impl.hh:140
Corners::value_type interpolate(const Coordinate &x, const Corners &corners)
Definition: projection_impl.hh:70
Normals::value_type interpolate_unit_normals(const Coordinate &x, const Normals &normals)
Definition: projection_impl.hh:91
void write_normals(const Projection< Coordinate > &projection, const Normals &normals, std::ostream &out)
Definition: projectionwriter_impl.hh:27
void write_points(const Projection< Coordinate > &projection, const Corners &corners, std::ostream &out)
Definition: projectionwriter_impl.hh:11
void write_success(const Projection< Coordinate > &projection, std::ostream &out)
Definition: projectionwriter_impl.hh:72
void write_edge_intersection_points(const Projection< Coordinate > &projection, const Corners &corners, std::ostream &out)
Definition: projectionwriter_impl.hh:43
void write_edge_intersection_normals(const Projection< Coordinate > &projection, const Normals &normals, std::ostream &out)
Definition: projectionwriter_impl.hh:56
Projection of a line (triangle) on another line (triangle).
Definition: projection.hh:21
const std::tuple< std::bitset< dim >, std::bitset< dim > > & success() const
Indicate whether projection (inverse projection) is valid for each corner or not.
Definition: projection.hh:252
unsigned numberOfEdgeIntersections() const
Number of edge intersections.
Definition: projection.hh:262
const std::tuple< Images, Preimages > & images() const
Images and preimages of corners.
Definition: projection.hh:235
const std::array< EdgeIntersection, maxEdgeIntersections > & edgeIntersections() const
Edge-edge intersections.
Definition: projection.hh:273
static Dune::FieldVector< T, dim > crossProduct(const Dune::FieldVector< T, dim > &a, const Dune::FieldVector< T, dim > &b)
compute cross product
Definition: crossproduct.hh:15
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,246 +5,50 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -projectionwriter_impl.hh
│ │ │ │ │ +crossproduct.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#include
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ crossproduct.hh File Reference
areawriter_impl.hh File Reference
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ #include <fstream>│ │ │ │ +
#include <vector>│ │ │ │ +
#include <dune/common/fvector.hh>│ │ │ │ +
#include <dune/geometry/type.hh>│ │ │ │ +
#include <dune/grid/common/mcmgmapper.hh>│ │ │ │ +
Go to the source code of this file.
│ │ │ ││ │ │ │ +Classes | |
| struct | Dune::GridGlue::AreaWriterImplementation::FacetLayout< dimgrid > |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
| namespace | Dune::GridGlue::AreaWriterImplementation |
│ │ │ │ Functions | |
| template<class T , int dim> | |
| static Dune::FieldVector< T, dim > | Dune::GridGlue::crossProduct (const Dune::FieldVector< T, dim > &a, const Dune::FieldVector< T, dim > &b) |
| compute cross product More... | |
| template<typename GridView > | |
| void | Dune::GridGlue::AreaWriterImplementation::write_facet_geometry (const GridView &gv, std::ostream &out) |
| template<int side, typename Glue > | |
| void | Dune::GridGlue::write_glue_area_vtk (const Glue &glue, std::ostream &out) |
| template<int side, typename Glue > | |
| void | Dune::GridGlue::write_glue_area_vtk (const Glue &glue, const std::string &filename) |
| template<typename Glue > | |
| void | Dune::GridGlue::write_glue_areas_vtk (const Glue &glue, const std::string &base) |
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,25 +5,44 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -Namespaces | Functions
│ │ │ │ │ -crossproduct.hh File Reference
│ │ │ │ │ +Classes | Namespaces | Functions
│ │ │ │ │ +areawriter_impl.hh File Reference
│ │ │ │ │ +#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ crossproduct.hh
areawriter_impl.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 87 using Mapper = Dune::MultipleCodimMultipleGeomTypeMapper<GridView, AreaWriterImplementation::FacetLayout>;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 100 const auto& refElement = Dune::ReferenceElements<ctype, GridView::dimension>::general(element.type());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ Definition: gridglue.hh:37
static Dune::FieldVector< T, dim > crossProduct(const Dune::FieldVector< T, dim > &a, const Dune::FieldVector< T, dim > &b)
compute cross product
Definition: crossproduct.hh:15
void write_glue_area_vtk(const Glue &glue, std::ostream &out)
Definition: areawriter_impl.hh:84
void write_glue_areas_vtk(const Glue &glue, const std::string &base)
Definition: areawriter_impl.hh:129
IteratorRange<... > intersections(const GridGlue<... > &glue, const Reverse<... > &reverse=!reversed)
Iterate over all intersections of a GridGlue.
void write_facet_geometry(const GridView &gv, std::ostream &out)
Definition: areawriter_impl.hh:25
Definition: rangegenerators.hh:17
Definition: areawriter_impl.hh:17
bool contains(Dune::GeometryType gt) const
Definition: areawriter_impl.hh:18
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,50 +5,185 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -crossproduct.hh
│ │ │ │ │ +areawriter_impl.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#ifndef DUNE_GRIDGLUE_COMMON_CROSSPRODUCT_HH
│ │ │ │ │ - 4#define DUNE_GRIDGLUE_COMMON_CROSSPRODUCT_HH 1
│ │ │ │ │ + 3#include -
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ areawriter.hh File Reference
ringcomm.hh File Reference
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,33 +5,40 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -Namespaces | Functions
│ │ │ │ │ -areawriter.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include "areawriter_impl.hh"
│ │ │ │ │ +Namespaces | Macros | Functions
│ │ │ │ │ +ringcomm.hh File Reference
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ -namespace Dune::GridGlue
│ │ │ │ │ +namespace Dune::Parallel
│ │ │ │ │
│ │ │ │ │ - Functions
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::write_glue_area_vtk (const Glue &glue, std::ostream &out)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::write_glue_area_vtk (const Glue &glue, const std::string
│ │ │ │ │ - &filename)
│ │ │ │ │ + Macros
│ │ │ │ │ +#define CheckMPIStatus(A, B) {}
│ │ │ │ │
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::write_glue_areas_vtk (const Glue &glue, const std::string
│ │ │ │ │ - &base)
│ │ │ │ │ + Functions
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::Parallel::MPI_AllApply (MPI_Comm mpicomm, OP &&op, const Args &...
│ │ │ │ │ + data)
│ │ │ │ │ + apply an operator locally to a difstributed data set More...
│ │ │ │ │
│ │ │ │ │ +***** Macro Definition Documentation *****
│ │ │ │ │ +***** ◆ CheckMPIStatus *****
│ │ │ │ │ +#define CheckMPIStatus ( A,
│ │ │ │ │ + B
│ │ │ │ │ + ) {}
│ │ │ │ │ + Todo:
│ │ │ │ │ + Implement MPI Status check with exception handling
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00035_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: areawriter.hh Source File
│ │ │ │ +dune-grid-glue: ringcomm.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -62,47 +62,305 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ #include <ostream>│ │ │ │ -
#include <string>│ │ │ │ -
#include "areawriter_impl.hh"│ │ │ │ +
#include <mpi.h>│ │ │ │ +
#include <functional>│ │ │ │ +
#include <utility>│ │ │ │ +
#include <dune/common/fvector.hh>│ │ │ │ +
#include <dune/common/hybridutilities.hh>│ │ │ │ +
#include <dune/geometry/type.hh>│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
| namespace | Dune::Parallel |
│ │ │ │ +Macros | |
| #define | CheckMPIStatus(A, B) {} |
│ │ │ │ Functions | |
| template<int side, typename Glue > | |
| void | Dune::GridGlue::write_glue_area_vtk (const Glue &glue, std::ostream &out) |
| template<int side, typename Glue > | |
| void | Dune::GridGlue::write_glue_area_vtk (const Glue &glue, const std::string &filename) |
| template<typename Glue > | |
| void | Dune::GridGlue::write_glue_areas_vtk (const Glue &glue, const std::string &base) |
| template<typename OP , typename... Args> | |
| void | Dune::Parallel::MPI_AllApply (MPI_Comm mpicomm, OP &&op, const Args &... data) |
| apply an operator locally to a difstributed data set More... | |
Macro Definition Documentation
│ │ │ │ + │ │ │ │ +◆ CheckMPIStatus
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
| #define CheckMPIStatus | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | A, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | B | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +{} | │ │ │ │ +
│ │ │ │ +
│ │ │ │ +- Todo:
- Implement MPI Status check with exception handling
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,33 +5,40 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -Namespaces | Functions
│ │ │ │ │ -areawriter.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ areawriter.hh
ringcomm.hh
│ │ │ │ -Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,49 +5,309 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -areawriter.hh
│ │ │ │ │ +ringcomm.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ - 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ + 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ + 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ + 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ - 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ + 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#ifndef DUNE_GRIDGLUE_COMMON_AREAWRITER_HH
│ │ │ │ │ - 4#define DUNE_GRIDGLUE_COMMON_AREAWRITER_HH
│ │ │ │ │ - 5
│ │ │ │ │ - 6#include
│ │ │ │ │ - 7#include
│ │ │ │ │ - 8
│ │ │ │ │ - 9namespace Dune {
│ │ │ │ │ - 10namespace GridGlue {
│ │ │ │ │ - 11
│ │ │ │ │ - 12template
│ │ │ │ │ - 13void write_glue_area_vtk(const Glue& glue, std::ostream& out);
│ │ │ │ │ - 14
│ │ │ │ │ - 15template
│ │ │ │ │ - 16void write_glue_area_vtk(const Glue& glue, const std::string& filename);
│ │ │ │ │ - 17
│ │ │ │ │ - 37template
│ │ │ │ │ - 38void write_glue_areas_vtk(const Glue& glue, const std::string& base);
│ │ │ │ │ - 39
│ │ │ │ │ - 40} /* namespace GridGlue */
│ │ │ │ │ - 41} /* namespace Dune */
│ │ │ │ │ - 42
│ │ │ │ │ - 43#include "areawriter_impl.hh"
│ │ │ │ │ - 44
│ │ │ │ │ - 45#endif
│ │ │ │ │ -areawriter_impl.hh
│ │ │ │ │ + 5/* IMPLEMENTATION OF CLASS G R I D G L U E */
│ │ │ │ │ + 6
│ │ │ │ │ +8#define CheckMPIStatus(A,B) {}
│ │ │ │ │ + 9
│ │ │ │ │ + 10#include
│ │ │ │ │ + 11#include
│ │ │ │ │ + 12#include
│ │ │ │ │ + 13
│ │ │ │ │ + 14#include
│ │ │ │ │ + 15#include
│ │ │ │ │ + 16
│ │ │ │ │ + 17#include
│ │ │ │ │ + 18
│ │ │ │ │ + 19namespace Dune {
│ │ │ │ │ +20namespace Parallel {
│ │ │ │ │ + 21
│ │ │ │ │ + 22 namespace Impl {
│ │ │ │ │ + 23
│ │ │ │ │ + 25 template
│ │ │ │ │ + 26 struct MPITypeInfo {};
│ │ │ │ │ + 27
│ │ │ │ │ + 28 template<>
│ │ │ │ │ + 29 struct MPITypeInfo< int >
│ │ │ │ │ + 30 {
│ │ │ │ │ + 31 static const unsigned int size = 1;
│ │ │ │ │ + 32 static inline MPI_Datatype getType()
│ │ │ │ │ + 33 {
│ │ │ │ │ + 34 return MPI_INT;
│ │ │ │ │ + 35 }
│ │ │ │ │ + 36 };
│ │ │ │ │ + 37
│ │ │ │ │ + 38 template
│ │ │ │ │ + 39 struct MPITypeInfo< Dune::FieldVector >
│ │ │ │ │ + 40 {
│ │ │ │ │ + 41 static const unsigned int size = N;
│ │ │ │ │ + 42 static inline MPI_Datatype getType()
│ │ │ │ │ + 43 {
│ │ │ │ │ + 44 return Dune::MPITraits::getType();
│ │ │ │ │ + 45 }
│ │ │ │ │ + 46 };
│ │ │ │ │ + 47
│ │ │ │ │ + 48 template<>
│ │ │ │ │ + 49 struct MPITypeInfo< unsigned int >
│ │ │ │ │ + 50 {
│ │ │ │ │ + 51 static const unsigned int size = 1;
│ │ │ │ │ + 52 static inline MPI_Datatype getType()
│ │ │ │ │ + 53 {
│ │ │ │ │ + 54 return MPI_UNSIGNED;
│ │ │ │ │ + 55 }
│ │ │ │ │ + 56 };
│ │ │ │ │ + 57
│ │ │ │ │ + 58 template<>
│ │ │ │ │ + 59 struct MPITypeInfo< Dune::GeometryType >
│ │ │ │ │ + 60 {
│ │ │ │ │ + 61 static const unsigned int size = 1;
│ │ │ │ │ + 62 static inline MPI_Datatype getType()
│ │ │ │ │ + 63 {
│ │ │ │ │ + 64 return Dune::MPITraits< Dune::GeometryType >::getType();
│ │ │ │ │ + 65 }
│ │ │ │ │ + 66 };
│ │ │ │ │ + 67
│ │ │ │ │ + 68 template
│ │ │ │ │ + 69 void MPI_SetVectorSize(
│ │ │ │ │ + 70 std::vector & data,
│ │ │ │ │ + 71 MPI_Status & status)
│ │ │ │ │ + 72 {
│ │ │ │ │ + 73 typedef MPITypeInfo Info;
│ │ │ │ │ + 74 int sz;
│ │ │ │ │ + 75 MPI_Get_count(&status, Info::getType(), &sz);
│ │ │ │ │ + 76 assert(sz%Info::size == 0);
│ │ │ │ │ + 77 data.resize(sz/Info::size);
│ │ │ │ │ + 78 }
│ │ │ │ │ + 79
│ │ │ │ │ + 89 template
│ │ │ │ │ + 90 void MPI_SendVectorInRing(
│ │ │ │ │ + 91 std::vector & data,
│ │ │ │ │ + 92 std::vector & next,
│ │ │ │ │ + 93 int tag,
│ │ │ │ │ + 94 int rightrank,
│ │ │ │ │ + 95 int leftrank,
│ │ │ │ │ + 96 MPI_Comm comm,
│ │ │ │ │ + 97 MPI_Request& r_send,
│ │ │ │ │ + 98 MPI_Request& r_recv
│ │ │ │ │ + 99 )
│ │ │ │ │ + 100 {
│ │ │ │ │ + 101 // mpi status stuff
│ │ │ │ │ + 102 [[maybe_unused]] int result = 0;
│ │ │ │ │ + 103 typedef MPITypeInfo Info;
│ │ │ │ │ + 104 // resize next buffer to maximum size
│ │ │ │ │ + 105 next.resize(next.capacity());
│ │ │ │ │ + 106 // send data (explicitly send data.size elements)
│ │ │ │ │ + 107 result =
│ │ │ │ │ + 108 MPI_Isend(
│ │ │ │ │ + 109 &(data[0]), Info::size*data.size(), Info::getType(), rightrank, tag,
│ │ │ │ │ + 110 comm, &r_send);
│ │ │ │ │ + 111 // receive up to maximum size. The acutal size is stored in the status
│ │ │ │ │ + 112 result =
│ │ │ │ │ + 113 MPI_Irecv(
│ │ │ │ │ + 114 &(next[0]), Info::size*next.size(), Info::getType(), leftrank, tag,
│ │ │ │ │ + 115 comm, &r_recv);
│ │ │ │ │ + 116 // // check result
│ │ │ │ │ + 117 // MPI_Status status;
│ │ │ │ │ + 118 // CheckMPIStatus(result, status);
│ │ │ │ │ + 119 }
│ │ │ │ │ + 120
│ │ │ │ │ + 121 template
│ │ │ │ │ + 122 using ptr_t = T*;
│ │ │ │ │ + 123
│ │ │ │ │ + 124 /* these helper structs are needed as long as we still support
│ │ │ │ │ + 125 C++11, as we can't use variadic lambdas */
│ │ │ │ │ + 126 template
│ │ │ │ │ + 127 struct call_MPI_SendVectorInRing
│ │ │ │ │ + 128 {
│ │ │ │ │ + 129 std::tuple & remotedata;
│ │ │ │ │ + 130 std::tuple & nextdata;
│ │ │ │ │ + 131 int & tag;
│ │ │ │ │ + 132 int & rightrank;
│ │ │ │ │ + 133 int & leftrank;
│ │ │ │ │ + 134 MPI_Comm & mpicomm;
│ │ │ │ │ + 135 std::array & requests_send;
│ │ │ │ │ + 136 std::array & requests_recv;
│ │ │ │ │ + 137
│ │ │ │ │ + 138 template
│ │ │ │ │ + 139 void operator()(I i)
│ │ │ │ │ + 140 {
│ │ │ │ │ + 141 MPI_SendVectorInRing(
│ │ │ │ │ + 142 std::get(remotedata),
│ │ │ │ │ + 143 std::get(nextdata),
│ │ │ │ │ + 144 tag+i,
│ │ │ │ │ + 145 rightrank, leftrank, mpicomm,
│ │ │ │ │ + 146 requests_send[i],
│ │ │ │ │ + 147 requests_recv[i]);
│ │ │ │ │ + 148 }
│ │ │ │ │ + 149 };
│ │ │ │ │ + 150 template
│ │ │ │ │ + 151 struct call_MPI_SetVectorSize
│ │ │ │ │ + 152 {
│ │ │ │ │ + 153 std::tuple & nextdata;
│ │ │ │ │ + 154 std::array & status_recv;
│ │ │ │ │ + 155
│ │ │ │ │ + 156 template
│ │ │ │ │ + 157 void operator()(I i)
│ │ │ │ │ + 158 {
│ │ │ │ │ + 159 MPI_SetVectorSize(std::get(nextdata),status_recv[i]);
│ │ │ │ │ + 160 }
│ │ │ │ │ + 161 };
│ │ │ │ │ + 162
│ │ │ │ │ + 163 template
│ │ │ │ │ + 164 void MPI_AllApply_impl(MPI_Comm mpicomm,
│ │ │ │ │ + 165 OP && op,
│ │ │ │ │ + 166 std::index_sequence indices,
│ │ │ │ │ + 167 const Args&... data)
│ │ │ │ │ + 168 {
│ │ │ │ │ + 169 constexpr std::size_t N = sizeof...(Args);
│ │ │ │ │ + 170 int myrank = 0;
│ │ │ │ │ + 171 int commsize = 0;
│ │ │ │ │ + 172#if HAVE_MPI
│ │ │ │ │ + 173 MPI_Comm_rank(mpicomm, &myrank);
│ │ │ │ │ + 174 MPI_Comm_size(mpicomm, &commsize);
│ │ │ │ │ + 175#endif // HAVE_MPI
│ │ │ │ │ + 176
│ │ │ │ │ + 177 if (commsize > 1)
│ │ │ │ │ + 178 {
│ │ │ │ │ + 179#ifdef DEBUG_GRIDGLUE_PARALLELMERGE
│ │ │ │ │ + 180 std::cout << myrank << " Start Communication, size " << commsize << std::
│ │ │ │ │ +endl;
│ │ │ │ │ + 181#endif
│ │ │ │ │ + 182
│ │ │ │ │ + 183 // get data sizes
│ │ │ │ │ + 184 std::array size({ ((unsigned int)data.size())... });
│ │ │ │ │ + 185
│ │ │ │ │ + 186 // communicate max data size
│ │ │ │ │ + 187 std::array maxSize;
│ │ │ │ │ + 188 MPI_Allreduce(&size, &maxSize,
│ │ │ │ │ + 189 size.size(), MPI_UNSIGNED, MPI_MAX, mpicomm);
│ │ │ │ │ + 190#ifdef DEBUG_GRIDGLUE_PARALLELMERGE
│ │ │ │ │ + 191 std::cout << myrank << " maxSize " << "done... " << std::endl;
│ │ │ │ │ + 192#endif
│ │ │ │ │ + 193
│ │ │ │ │ + 194 // allocate receiving buffers with maxsize to ensure sufficient buffer
│ │ │ │ │ +size for communication
│ │ │ │ │ + 195 std::tuple remotedata { Args(maxSize[Indices])... };
│ │ │ │ │ + 196
│ │ │ │ │ + 197 // copy local data to receiving buffer
│ │ │ │ │ + 198 remotedata = std::tie(data...);
│ │ │ │ │ + 199
│ │ │ │ │ + 200 // allocate second set of receiving buffers necessary for async
│ │ │ │ │ +communication
│ │ │ │ │ + 201 std::tuple nextdata { Args(maxSize[Indices])... };
│ │ │ │ │ + 202
│ │ │ │ │ + 203 // communicate data in the ring
│ │ │ │ │ + 204 int rightrank = (myrank + 1 + commsize) % commsize;
│ │ │ │ │ + 205 int leftrank = (myrank - 1 + commsize) % commsize;
│ │ │ │ │ + 206
│ │ │ │ │ + 207 std::cout << myrank << ": size = " << commsize << std::endl;
│ │ │ │ │ + 208 std::cout << myrank << ": left = " << leftrank
│ │ │ │ │ + 209 << " right = " << rightrank << std::endl;
│ │ │ │ │ + 210
│ │ │ │ │ + 211 // currently the remote data is our own data
│ │ │ │ │ + 212 int remoterank = myrank;
│ │ │ │ │ + 213
│ │ │ │ │ + 214 for (int i=1; i
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: areawriter_impl.hh File Reference
│ │ │ │ +dune-grid-glue: projection_impl.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -63,56 +63,49 @@
│ │ │ │
│ │ │ │
│ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ - 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +Go to the documentation of this file.
│ │ │ │ +
│ │ │ │ +
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ + 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ Definition: gridglue.hh:37
void write_glue_area_vtk(const Glue &glue, std::ostream &out)
Definition: areawriter_impl.hh:84
void write_glue_areas_vtk(const Glue &glue, const std::string &base)
Definition: areawriter_impl.hh:129
void MPI_AllApply(MPI_Comm mpicomm, OP &&op, const Args &... data)
apply an operator locally to a difstributed data set
Definition: ringcomm.hh:297
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,49 +5,309 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -areawriter.hh
│ │ │ │ │ +ringcomm.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ - 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ + 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ + 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ + 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ - 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ + 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#ifndef DUNE_GRIDGLUE_COMMON_AREAWRITER_HH
│ │ │ │ │ - 4#define DUNE_GRIDGLUE_COMMON_AREAWRITER_HH
│ │ │ │ │ - 5
│ │ │ │ │ - 6#include
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ areawriter_impl.hh File Reference
projection_impl.hh File Reference
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,44 +5,45 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -Classes | Namespaces | Functions
│ │ │ │ │ -areawriter_impl.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +Namespaces | Functions
│ │ │ │ │ +projection_impl.hh File Reference
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ - Classes
│ │ │ │ │ -struct Dune::GridGlue::AreaWriterImplementation::FacetLayout<_dimgrid_>
│ │ │ │ │ -
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ -namespace Dune::GridGlue::AreaWriterImplementation
│ │ │ │ │ +namespace Dune::GridGlue::ProjectionImplementation
│ │ │ │ │
│ │ │ │ │ Functions
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::AreaWriterImplementation::write_facet_geometry (const
│ │ │ │ │ - GridView &gv, std::ostream &out)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::write_glue_area_vtk (const Glue &glue, std::ostream &out)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::write_glue_area_vtk (const Glue &glue, const std::string
│ │ │ │ │ - &filename)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ -void Dune::GridGlue::write_glue_areas_vtk (const Glue &glue, const std::string
│ │ │ │ │ - &base)
│ │ │ │ │ +template
│ │ │ │ │ + Coordinate Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ + corner (unsigned c)
│ │ │ │ │ +
│ │ │ │ │ +std::pair< unsigned, unsigned > Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ + edgeToCorners (unsigned edge)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ + Corners::value_type Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ + interpolate (const Coordinate &x, const
│ │ │ │ │ + Corners &corners)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ + Normals::value_type Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ + interpolate_unit_normals (const Coordinate &x,
│ │ │ │ │ + const Normals &normals)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ + bool Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ + inside (const Coordinate &x, const Field
│ │ │ │ │ + &epsilon)
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00038_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: areawriter_impl.hh Source File
│ │ │ │ +dune-grid-glue: projection_impl.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -62,169 +62,449 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ #include <fstream>│ │ │ │ -
#include <vector>│ │ │ │ -
#include <dune/common/fvector.hh>│ │ │ │ -
#include <dune/geometry/type.hh>│ │ │ │ -
#include <dune/grid/common/mcmgmapper.hh>│ │ │ │ +
#include <dune/common/fmatrix.hh>│ │ │ │ +
#include <cmath>│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ -Classes | |
| struct | Dune::GridGlue::AreaWriterImplementation::FacetLayout< dimgrid > |
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
| namespace | Dune::GridGlue::AreaWriterImplementation |
| namespace | Dune::GridGlue::ProjectionImplementation |
│ │ │ │ Functions | |
| template<typename GridView > | |
| void | Dune::GridGlue::AreaWriterImplementation::write_facet_geometry (const GridView &gv, std::ostream &out) |
| template<int side, typename Glue > | |
| void | Dune::GridGlue::write_glue_area_vtk (const Glue &glue, std::ostream &out) |
| template<int side, typename Glue > | |
| void | Dune::GridGlue::write_glue_area_vtk (const Glue &glue, const std::string &filename) |
| template<typename Glue > | |
| void | Dune::GridGlue::write_glue_areas_vtk (const Glue &glue, const std::string &base) |
| template<typename Coordinate , typename Field > | |
| Coordinate | Dune::GridGlue::ProjectionImplementation::corner (unsigned c) |
| std::pair< unsigned, unsigned > | Dune::GridGlue::ProjectionImplementation::edgeToCorners (unsigned edge) |
| template<typename Coordinate , typename Corners > | |
| Corners::value_type | Dune::GridGlue::ProjectionImplementation::interpolate (const Coordinate &x, const Corners &corners) |
| template<typename Coordinate , typename Normals > | |
| Normals::value_type | Dune::GridGlue::ProjectionImplementation::interpolate_unit_normals (const Coordinate &x, const Normals &normals) |
| template<typename Coordinate , typename Field > | |
| bool | Dune::GridGlue::ProjectionImplementation::inside (const Coordinate &x, const Field &epsilon) |
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,44 +5,45 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -Classes | Namespaces | Functions
│ │ │ │ │ -areawriter_impl.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ areawriter_impl.hh
projection_impl.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 87 using Mapper = Dune::MultipleCodimMultipleGeomTypeMapper<GridView, AreaWriterImplementation::FacetLayout>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 100 const auto& refElement = Dune::ReferenceElements<ctype, GridView::dimension>::general(element.type());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 149::doProjection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 227 const bool feasible = projectionFeasible(origin[i], origin_normals[i], y, target, target_normals);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 241::doInverseProjection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 302 const bool feasible = projectionFeasible(target_corners[i], get<1>(normals)[i], preimages[i], get<0>(corners), get<0>(normals));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 311::doEdgeIntersection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 438::projectionFeasible(const Coordinate& x, const Coordinate& nx, const Coordinate& px, const Corners& corners, const Normals& normals) const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 469::project(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ Definition: gridglue.hh:37
void write_glue_area_vtk(const Glue &glue, std::ostream &out)
Definition: areawriter_impl.hh:84
void write_glue_areas_vtk(const Glue &glue, const std::string &base)
Definition: areawriter_impl.hh:129
IteratorRange<... > intersections(const GridGlue<... > &glue, const Reverse<... > &reverse=!reversed)
Iterate over all intersections of a GridGlue.
void write_facet_geometry(const GridView &gv, std::ostream &out)
Definition: areawriter_impl.hh:25
Definition: rangegenerators.hh:17
Definition: areawriter_impl.hh:17
bool contains(Dune::GeometryType gt) const
Definition: areawriter_impl.hh:18
Corners::value_type interpolate(const Coordinate &x, const Corners &corners)
Definition: projection_impl.hh:70
bool inside(const Coordinate &x, const Field &epsilon)
Definition: projection_impl.hh:111
std::pair< unsigned, unsigned > edgeToCorners(unsigned edge)
Definition: projection_impl.hh:43
Coordinate corner(unsigned c)
Definition: projection_impl.hh:24
Normals::value_type interpolate_unit_normals(const Coordinate &x, const Normals &normals)
Definition: projection_impl.hh:91
Projection of a line (triangle) on another line (triangle).
Definition: projection.hh:21
Coordinate::field_type Field
Scalar type.
Definition: projection.hh:61
Projection(const Field overlap=Field(0), const Field max_normal_product=Field(-0.1))
Definition: projection_impl.hh:130
void epsilon(const Field epsilon)
Set epsilon used for floating-point comparisons.
Definition: projection_impl.hh:140
void project(const std::tuple< Corners &, Corners & > &corners, const std::tuple< Normals &, Normals & > &normals)
Do the actual projection.
Definition: projection_impl.hh:469
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,185 +5,494 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -areawriter_impl.hh
│ │ │ │ │ +projection_impl.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#include projection.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,494 +5,49 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -projection_impl.hh
│ │ │ │ │ +areawriter.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#include
│ │ │ │ │ - 4
│ │ │ │ │ - 5#include
│ │ │ │ │ - 6
│ │ │ │ │ - 7namespace Dune {
│ │ │ │ │ - 8namespace GridGlue {
│ │ │ │ │ - 9
│ │ │ │ │ -10namespace ProjectionImplementation {
│ │ │ │ │ + 3#ifndef DUNE_GRIDGLUE_COMMON_AREAWRITER_HH
│ │ │ │ │ + 4#define DUNE_GRIDGLUE_COMMON_AREAWRITER_HH
│ │ │ │ │ + 5
│ │ │ │ │ + 6#include
│ │ │ │ │ + 7#include
│ │ │ │ │ + 8
│ │ │ │ │ + 9namespace Dune {
│ │ │ │ │ + 10namespace GridGlue {
│ │ │ │ │ 11
│ │ │ │ │ - 22template
│ │ │ │ │ - 23inline Coordinate
│ │ │ │ │ -24corner(unsigned c)
│ │ │ │ │ - 25{
│ │ │ │ │ - 26 Coordinate x(Field(0));
│ │ │ │ │ - 27 if (c == 0)
│ │ │ │ │ - 28 return x;
│ │ │ │ │ - 29 x[c-1] = Field(1);
│ │ │ │ │ - 30 return x;
│ │ │ │ │ - 31}
│ │ │ │ │ - 32
│ │ │ │ │ - 42inline std::pair
│ │ │ │ │ -43edgeToCorners(unsigned edge)
│ │ │ │ │ - 44{
│ │ │ │ │ - 45 switch(edge) {
│ │ │ │ │ - 46 case 0: return {0, 1};
│ │ │ │ │ - 47 case 1: return {0, 2};
│ │ │ │ │ - 48 case 2: return {1, 2};
│ │ │ │ │ - 49 }
│ │ │ │ │ - 50 DUNE_THROW(Dune::Exception, "Unexpected edge number.");
│ │ │ │ │ - 51}
│ │ │ │ │ - 52
│ │ │ │ │ - 68template
│ │ │ │ │ - 69inline typename Corners::value_type
│ │ │ │ │ -70interpolate(const Coordinate& x, const Corners& corners)
│ │ │ │ │ - 71{
│ │ │ │ │ - 72 auto y = corners[0];
│ │ │ │ │ - 73 for (unsigned i = 0; i < corners.size() - 1; ++i)
│ │ │ │ │ - 74 y.axpy(x[i], corners[i+1] - corners[0]);
│ │ │ │ │ - 75 return y;
│ │ │ │ │ - 76}
│ │ │ │ │ - 77
│ │ │ │ │ - 89template
│ │ │ │ │ - 90inline typename Normals::value_type
│ │ │ │ │ -91interpolate_unit_normals(const Coordinate& x, const Normals& normals)
│ │ │ │ │ - 92{
│ │ │ │ │ - 93 auto n = interpolate(x, normals);
│ │ │ │ │ - 94 n /= n.two_norm();
│ │ │ │ │ - 95 return n;
│ │ │ │ │ - 96}
│ │ │ │ │ - 97
│ │ │ │ │ - 109template
│ │ │ │ │ - 110inline bool
│ │ │ │ │ -111inside(const Coordinate& x, const Field& epsilon)
│ │ │ │ │ - 112{
│ │ │ │ │ - 113 const unsigned dim = Coordinate::dimension;
│ │ │ │ │ - 114 Field sum(0);
│ │ │ │ │ - 115 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ - 116 if (x[i] < -epsilon)
│ │ │ │ │ - 117 return false;
│ │ │ │ │ - 118 sum += x[i];
│ │ │ │ │ - 119 }
│ │ │ │ │ - 120 /* If any xᵢ is NaN, sum will be NaN and this comparison false! */
│ │ │ │ │ - 121 if (sum <= Field(1) + epsilon)
│ │ │ │ │ - 122 return true;
│ │ │ │ │ - 123 return false;
│ │ │ │ │ - 124}
│ │ │ │ │ - 125
│ │ │ │ │ - 126} /* namespace ProjectionImplementation */
│ │ │ │ │ - 127
│ │ │ │ │ - 128template
│ │ │ │ │ - 129Projection
│ │ │ │ │ -130::Projection(const Field overlap, const Field max_normal_product)
│ │ │ │ │ - 131 : m_overlap(overlap)
│ │ │ │ │ - 132 , m_max_normal_product(max_normal_product)
│ │ │ │ │ - 133{
│ │ │ │ │ - 134 /* Nothing. */
│ │ │ │ │ - 135}
│ │ │ │ │ - 136
│ │ │ │ │ - 137template
│ │ │ │ │ - 138void
│ │ │ │ │ - 139Projection
│ │ │ │ │ -140::epsilon(const Field epsilon)
│ │ │ │ │ - 141{
│ │ │ │ │ - 142 m_epsilon = epsilon;
│ │ │ │ │ - 143}
│ │ │ │ │ - 144
│ │ │ │ │ - 145template
│ │ │ │ │ - 146template
│ │ │ │ │ - 147void
│ │ │ │ │ - 148Projection
│ │ │ │ │ - 149::doProjection(const std::tuple& corners, const std::
│ │ │ │ │ -tuple& normals)
│ │ │ │ │ - 150{
│ │ │ │ │ - 151 /* Try to obtain Φ(xᵢ) for each corner xᵢ of the preimage triangle.
│ │ │ │ │ - 152 * This means solving a linear system of equations
│ │ │ │ │ - 153 * Φ(xᵢ) = (1-α-β) y₀ + α y₁ + β y₂ = xᵢ + δ nᵢ
│ │ │ │ │ - 154 * or α (y₁ - y₀) + β (y₂ - y₀) - δ nᵢ = xᵢ - y₀
│ │ │ │ │ - 155 * to obtain the barycentric coordinates (α, β) of Φ(xᵢ) in the image
│ │ │ │ │ - 156 * triangle and the distance δ.
│ │ │ │ │ - 157 *
│ │ │ │ │ - 158 * In the matrix m corresponding to the system, only the third column and
│ │ │ │ │ -the
│ │ │ │ │ - 159 * right-hand side depend on i. The first two columns can be assembled
│ │ │ │ │ -before
│ │ │ │ │ - 160 * and reused.
│ │ │ │ │ - 161 */
│ │ │ │ │ - 162 using namespace ProjectionImplementation;
│ │ │ │ │ - 163 using std::get;
│ │ │ │ │ - 164 typedef Dune::FieldMatrix Matrix;
│ │ │ │ │ - 165 Matrix m;
│ │ │ │ │ - 166
│ │ │ │ │ - 167 const auto& origin = get<0>(corners);
│ │ │ │ │ - 168 const auto& origin_normals = get<0>(normals);
│ │ │ │ │ - 169 const auto& target = get<1>(corners);
│ │ │ │ │ - 170 const auto& target_normals = get<1>(normals);
│ │ │ │ │ - 171 auto& images = get<0>(m_images);
│ │ │ │ │ - 172 auto& success = get<0>(m_success);
│ │ │ │ │ - 173
│ │ │ │ │ - 174 /* directionsᵢ = (yᵢ - y₀) / ||yᵢ - y₀||
│ │ │ │ │ - 175 * These are the first to columns of the system matrix; the rescaling is
│ │ │ │ │ -done
│ │ │ │ │ - 176 * to ensure all columns have a comparable norm (the last has the normal
│ │ │ │ │ -with norm 1.
│ │ │ │ │ - 177 */
│ │ │ │ │ - 178 std::array directions;
│ │ │ │ │ - 179 std::array scales;
│ │ │ │ │ - 180 /* estimator for the diameter of the target face */
│ │ │ │ │ - 181 Field scaleSum(0);
│ │ │ │ │ - 182 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ - 183 directions[i] = target[i+1] - target[0];
│ │ │ │ │ - 184 scales[i] = directions[i].infinity_norm();
│ │ │ │ │ - 185 directions[i] /= scales[i];
│ │ │ │ │ - 186 scaleSum += scales[i];
│ │ │ │ │ - 187 }
│ │ │ │ │ - 188
│ │ │ │ │ - 189 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ - 190 for (unsigned j = 0; j < dim; ++j) {
│ │ │ │ │ - 191 m[j][i] = directions[i][j];
│ │ │ │ │ - 192 }
│ │ │ │ │ - 193 }
│ │ │ │ │ - 194
│ │ │ │ │ - 195 m_projection_valid = true;
│ │ │ │ │ - 196 success.reset();
│ │ │ │ │ - 197
│ │ │ │ │ - 198 /* Now project xᵢ for each i */
│ │ │ │ │ - 199 for (unsigned i = 0; i < origin.size(); ++i) {
│ │ │ │ │ - 200 for (unsigned j = 0; j < dim; ++j)
│ │ │ │ │ - 201 m[j][dim-1] = origin_normals[i][j];
│ │ │ │ │ - 202
│ │ │ │ │ - 203 const Coordinate rhs = origin[i] - target[0];
│ │ │ │ │ - 204
│ │ │ │ │ - 205 try {
│ │ │ │ │ - 206 /* y = (α, β, δ) */
│ │ │ │ │ - 207 auto& y = images[i];
│ │ │ │ │ - 208 m.solve(y, rhs);
│ │ │ │ │ - 209 for (unsigned j = 0; j < dim-1; ++j)
│ │ │ │ │ - 210 y[j] /= scales[j];
│ │ │ │ │ - 211 /* Solving gave us -δ as the term is "-δ nᵢ". */
│ │ │ │ │ - 212 y[dim-1] *= Field(-1);
│ │ │ │ │ - 213
│ │ │ │ │ - 214 /* If the forward projection is too far in the wrong direction
│ │ │ │ │ - 215 * then this might result in artificial inverse projections or
│ │ │ │ │ - 216 * edge intersections. To prevent these wrong cases but not
│ │ │ │ │ - 217 * dismiss feasible intersections, the projection is dismissed
│ │ │ │ │ - 218 * if the forward projection is further than two times the
│ │ │ │ │ - 219 * approximate diameter of the image triangle.
│ │ │ │ │ - 220 */
│ │ │ │ │ - 221 if(y[dim-1] < -2*scaleSum) {
│ │ │ │ │ - 222 success.set(i,false);
│ │ │ │ │ - 223 m_projection_valid = false;
│ │ │ │ │ - 224 return;
│ │ │ │ │ - 225 }
│ │ │ │ │ - 226
│ │ │ │ │ - 227 const bool feasible = projectionFeasible(origin[i], origin_normals[i], y,
│ │ │ │ │ -target, target_normals);
│ │ │ │ │ - 228 success.set(i, feasible);
│ │ │ │ │ - 229 }
│ │ │ │ │ - 230 catch (const Dune::FMatrixError&) {
│ │ │ │ │ - 231 success.set(i, false);
│ │ │ │ │ - 232 m_projection_valid = false;
│ │ │ │ │ - 233 }
│ │ │ │ │ - 234 }
│ │ │ │ │ - 235}
│ │ │ │ │ - 236
│ │ │ │ │ - 237template
│ │ │ │ │ - 238template
│ │ │ │ │ - 239void
│ │ │ │ │ - 240Projection
│ │ │ │ │ - 241::doInverseProjection(const std::tuple& corners, const
│ │ │ │ │ -std::tuple& normals)
│ │ │ │ │ - 242{
│ │ │ │ │ - 243 /* Try to obtain Φ⁻¹(yᵢ) for each corner yᵢ of the image triangle.
│ │ │ │ │ - 244 * Instead of solving the problem directly (which would lead to
│ │ │ │ │ - 245 * non-linear equations), we make use of the forward projection Φ
│ │ │ │ │ - 246 * which projects the preimage triangle on the plane spanned by the
│ │ │ │ │ - 247 * image triangle. The inverse projection is then given by finding
│ │ │ │ │ - 248 * the barycentric coordinates of yᵢ with respect to the triangle
│ │ │ │ │ - 249 * with the corners Φ(xᵢ). This way we only have to solve linear
│ │ │ │ │ - 250 * equations.
│ │ │ │ │ - 251 */
│ │ │ │ │ - 252
│ │ │ │ │ - 253 using namespace ProjectionImplementation;
│ │ │ │ │ - 254 using std::get;
│ │ │ │ │ - 255 typedef Dune::FieldMatrix Matrix;
│ │ │ │ │ - 256 typedef Dune::FieldVector Vector;
│ │ │ │ │ - 257
│ │ │ │ │ - 258 /* The inverse projection can only be computed if the forward projection
│ │ │ │ │ - 259 * managed to project all xᵢ on the plane spanned by the yᵢ
│ │ │ │ │ - 260 */
│ │ │ │ │ - 261 if (!m_projection_valid) {
│ │ │ │ │ - 262 get<1>(m_success).reset();
│ │ │ │ │ - 263 return;
│ │ │ │ │ - 264 }
│ │ │ │ │ - 265
│ │ │ │ │ - 266 const auto& images = get<0>(m_images);
│ │ │ │ │ - 267 const auto& target_corners = get<1>(corners);
│ │ │ │ │ - 268 auto& preimages = get<1>(m_images);
│ │ │ │ │ - 269 auto& success = get<1>(m_success);
│ │ │ │ │ - 270
│ │ │ │ │ - 271 std::array v;
│ │ │ │ │ - 272 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ - 273 v[i] = interpolate(images[i+1], target_corners);
│ │ │ │ │ - 274 v[i] -= interpolate(images[0], target_corners);
│ │ │ │ │ - 275 }
│ │ │ │ │ - 276
│ │ │ │ │ - 277 Matrix m;
│ │ │ │ │ - 278 for (unsigned i = 0; i < dim-1; ++i) {
│ │ │ │ │ - 279 for (unsigned j = 0; j < dim-1; ++j) {
│ │ │ │ │ - 280 m[i][j] = v[i]*v[j];
│ │ │ │ │ - 281 }
│ │ │ │ │ - 282 }
│ │ │ │ │ - 283
│ │ │ │ │ - 284 for (unsigned i = 0; i < dim; ++i) {
│ │ │ │ │ - 285 /* Convert yᵢ to barycentric coordinates with respect to Φ(xⱼ) */
│ │ │ │ │ - 286 v[dim-1] = target_corners[i];
│ │ │ │ │ - 287 v[dim-1] -= interpolate(images[0], target_corners);
│ │ │ │ │ - 288
│ │ │ │ │ - 289 Vector rhs, z;
│ │ │ │ │ - 290 for (unsigned j = 0; j < dim-1; ++j)
│ │ │ │ │ - 291 rhs[j] = v[dim-1]*v[j];
│ │ │ │ │ - 292 m.solve(z, rhs);
│ │ │ │ │ - 293
│ │ │ │ │ - 294 for (unsigned j = 0; j < dim-1; ++j)
│ │ │ │ │ - 295 preimages[i][j] = z[j];
│ │ │ │ │ - 296
│ │ │ │ │ - 297 /* Calculate distance along normal direction */
│ │ │ │ │ - 298 const auto x = interpolate(z, get<0>(corners));
│ │ │ │ │ - 299 preimages[i][dim-1] = (x - target_corners[i]) * get<1>(normals)[i];
│ │ │ │ │ - 300
│ │ │ │ │ - 301 /* Check y_i lies inside the Φ(xⱼ) */
│ │ │ │ │ - 302 const bool feasible = projectionFeasible(target_corners[i], get<1>
│ │ │ │ │ -(normals)[i], preimages[i], get<0>(corners), get<0>(normals));
│ │ │ │ │ - 303 success.set(i, feasible);
│ │ │ │ │ - 304 }
│ │ │ │ │ - 305}
│ │ │ │ │ - 306
│ │ │ │ │ - 307template
│ │ │ │ │ - 308template
│ │ │ │ │ - 309void
│ │ │ │ │ - 310Projection
│ │ │ │ │ - 311::doEdgeIntersection(const std::tuple& corners, const
│ │ │ │ │ -std::tuple& normals)
│ │ │ │ │ - 312{
│ │ │ │ │ - 313 using namespace ProjectionImplementation;
│ │ │ │ │ - 314 using std::get;
│ │ │ │ │ - 315
│ │ │ │ │ - 316 m_number_of_edge_intersections = 0;
│ │ │ │ │ - 317
│ │ │ │ │ - 318 /* There are no edge intersections for 2d, only for 3d */
│ │ │ │ │ - 319 if (dim != 3)
│ │ │ │ │ - 320 return;
│ │ │ │ │ - 321
│ │ │ │ │ - 322 /* There are no edge intersections
│ │ │ │ │ - 323 * - when the projection is invalid,
│ │ │ │ │ - 324 * - when the projected triangle lies fully in the target triangle,
│ │ │ │ │ - 325 * - or when the target triangle lies fully in the projected triangle.
│ │ │ │ │ - 326 */
│ │ │ │ │ - 327 if (!m_projection_valid || get<0>(m_success).all() || get<1>
│ │ │ │ │ -(m_success).all()) {
│ │ │ │ │ - 328 return;
│ │ │ │ │ - 329 }
│ │ │ │ │ - 330
│ │ │ │ │ - 331 const auto& images = get<0>(m_images);
│ │ │ │ │ - 332 const auto& ys = get<1>(corners);
│ │ │ │ │ - 333
│ │ │ │ │ - 334 /* Intersect line through Φ(xᵢ), Φ(xⱼ) with line through yₖ, yₗ:
│ │ │ │ │ - 335 We want α, β ∈ ℝ such that
│ │ │ │ │ - 336 Φ(xᵢ) + α (Φ(xⱼ) - Φ(xᵢ)) = yₖ + β (yₗ - yₖ)
│ │ │ │ │ - 337 or
│ │ │ │ │ - 338 α (Φ(xⱼ)-Φ(xᵢ)) + β (yₗ-yₖ) = yₖ-Φ(xᵢ)
│ │ │ │ │ - 339 To get a 2×2 system of equations, multiply with yₘ-y₀ for
│ │ │ │ │ - 340 m ∈ {1,̣̣2} which are linear indep. (and so the system is
│ │ │ │ │ - 341 equivalent to the original 3×2 system)
│ │ │ │ │ - 342 */
│ │ │ │ │ - 343 for (unsigned edgex = 0; edgex < dim; ++edgex) {
│ │ │ │ │ - 344 unsigned i, j;
│ │ │ │ │ - 345 std::tie(i, j) = edgeToCorners(edgex);
│ │ │ │ │ - 346
│ │ │ │ │ - 347 /* Both sides of edgex lie in the target triangle means no edge
│ │ │ │ │ -intersection */
│ │ │ │ │ - 348 if (get<0>(m_success)[i] && get<0>(m_success)[j])
│ │ │ │ │ - 349 continue;
│ │ │ │ │ - 350
│ │ │ │ │ - 351 const auto pxi = interpolate(images[i], ys);
│ │ │ │ │ - 352 const auto pxj = interpolate(images[j], ys);
│ │ │ │ │ - 353 const auto pxjpxi = pxj - pxi;
│ │ │ │ │ - 354
│ │ │ │ │ - 355 typedef Dune::FieldMatrix Matrix;
│ │ │ │ │ - 356 typedef Dune::FieldVector Vector;
│ │ │ │ │ - 357
│ │ │ │ │ - 358 for (unsigned edgey = 0; edgey < dim; ++edgey) {
│ │ │ │ │ - 359 unsigned k, l;
│ │ │ │ │ - 360 std::tie(k, l) = edgeToCorners(edgey);
│ │ │ │ │ - 361
│ │ │ │ │ - 362 /* Both sides of edgey lie in the projected triangle means no edge
│ │ │ │ │ -intersection */
│ │ │ │ │ - 363 if (get<1>(m_success)[k] && get<1>(m_success)[l])
│ │ │ │ │ - 364 continue;
│ │ │ │ │ - 365
│ │ │ │ │ - 366 const auto ykyl = ys[k] - ys[l];
│ │ │ │ │ - 367 const auto ykpxi = ys[k] - pxi;
│ │ │ │ │ - 368
│ │ │ │ │ - 369 /* If edges are parallel then the intersection is already computed by
│ │ │ │ │ -vertex projections. */
│ │ │ │ │ - 370 bool parallel = true;
│ │ │ │ │ - 371 for (unsigned h=0; h<3; h++)
│ │ │ │ │ - 372 parallel &= std::abs(ykyl[(h+1)%3]*pxjpxi[(h+2)%3] - ykyl[(h+2)%3]*pxjpxi[
│ │ │ │ │ -(h+1)%3])<1e-14;
│ │ │ │ │ - 373 if (parallel)
│ │ │ │ │ - 374 continue;
│ │ │ │ │ - 375
│ │ │ │ │ - 376 Matrix mat;
│ │ │ │ │ - 377 Vector rhs, z;
│ │ │ │ │ - 378
│ │ │ │ │ - 379 for (unsigned m = 0; m < dim-1; ++m) {
│ │ │ │ │ - 380 const auto ym1y0 = ys[m+1] - ys[0];
│ │ │ │ │ - 381 mat[m][0] = pxjpxi * ym1y0;
│ │ │ │ │ - 382 mat[m][1] = ykyl * ym1y0;
│ │ │ │ │ - 383 rhs[m] = ykpxi * ym1y0;
│ │ │ │ │ - 384 }
│ │ │ │ │ - 385
│ │ │ │ │ - 386 try {
│ │ │ │ │ - 387 using std::isfinite;
│ │ │ │ │ - 388
│ │ │ │ │ - 389 mat.solve(z, rhs);
│ │ │ │ │ - 390
│ │ │ │ │ - 391 /* If solving the system gives a NaN, the edges are probably parallel. */
│ │ │ │ │ - 392 if (!isfinite(z[0]) || !isfinite(z[1]))
│ │ │ │ │ - 393 continue;
│ │ │ │ │ - 394
│ │ │ │ │ - 395 /* Filter out corner (pre)images. We only want "real" edge-edge
│ │ │ │ │ -intersections here. */
│ │ │ │ │ - 396 if (z[0] < m_epsilon || z[0] > Field(1) - m_epsilon
│ │ │ │ │ - 397 || z[1] < m_epsilon || z[1] > Field(1) - m_epsilon)
│ │ │ │ │ - 398 continue;
│ │ │ │ │ - 399
│ │ │ │ │ - 400 Coordinate local_x = corner(i);
│ │ │ │ │ - 401 local_x.axpy(z[0], corner(j) - corner(i));
│ │ │ │ │ - 402 Coordinate local_y = corner(k);
│ │ │ │ │ - 403 local_y.axpy(z[1], corner(l) - corner(k));
│ │ │ │ │ - 404
│ │ │ │ │ - 405 /* Make sure the intersection is in the triangle. */
│ │ │ │ │ - 406 if (!inside(local_x, m_epsilon) || !inside(local_y, m_epsilon))
│ │ │ │ │ - 407 continue;
│ │ │ │ │ - 408
│ │ │ │ │ - 409 /* Make sure the intersection respects overlap. */
│ │ │ │ │ - 410 auto xy = interpolate(local_x, get<0>(corners));
│ │ │ │ │ - 411 xy -= interpolate(local_y, get<1>(corners));
│ │ │ │ │ - 412 const auto nx = interpolate_unit_normals(local_x, get<0>(normals));
│ │ │ │ │ - 413 const auto ny = interpolate_unit_normals(local_y, get<1>(normals));
│ │ │ │ │ - 414 local_x[dim-1] = -(xy*nx);
│ │ │ │ │ - 415 local_y[dim-1] = xy*ny;
│ │ │ │ │ - 416
│ │ │ │ │ - 417 if (local_x[dim-1] < -m_overlap-m_epsilon || local_y[dim-1] < -m_overlap-
│ │ │ │ │ -m_epsilon)
│ │ │ │ │ - 418 continue;
│ │ │ │ │ - 419
│ │ │ │ │ - 420 /* Normals should be opposing. */
│ │ │ │ │ - 421 if (nx*ny > m_max_normal_product + m_epsilon)
│ │ │ │ │ - 422 continue;
│ │ │ │ │ - 423
│ │ │ │ │ - 424 /* Intersection is feasible. Store it. */
│ │ │ │ │ - 425 auto& intersection = m_edge_intersections
│ │ │ │ │ -[m_number_of_edge_intersections++];
│ │ │ │ │ - 426 intersection = { {{edgex, edgey}}, {{local_x, local_y}} };
│ │ │ │ │ - 427 }
│ │ │ │ │ - 428 catch(const Dune::FMatrixError&) {
│ │ │ │ │ - 429 /* Edges might be parallel, ignore and continue with next edge */
│ │ │ │ │ - 430 }
│ │ │ │ │ - 431 }
│ │ │ │ │ - 432 }
│ │ │ │ │ - 433}
│ │ │ │ │ - 434
│ │ │ │ │ - 435template
│ │ │ │ │ - 436template
│ │ │ │ │ - 437bool Projection
│ │ │ │ │ - 438::projectionFeasible(const Coordinate& x, const Coordinate& nx, const
│ │ │ │ │ -Coordinate& px, const Corners& corners, const Normals& normals) const
│ │ │ │ │ - 439{
│ │ │ │ │ - 440 using namespace ProjectionImplementation;
│ │ │ │ │ - 441
│ │ │ │ │ - 442 /* Image must be within simplex. */
│ │ │ │ │ - 443 if (!inside(px, m_epsilon))
│ │ │ │ │ - 444 return false;
│ │ │ │ │ - 445
│ │ │ │ │ - 446 /* Distance along normal must not be smaller than -overlap. */
│ │ │ │ │ - 447 if (px[dim-1] < -m_overlap-m_epsilon)
│ │ │ │ │ - 448 return false;
│ │ │ │ │ - 449
│ │ │ │ │ - 450 /* Distance along normal at image must not be smaller than -overlap. */
│ │ │ │ │ - 451 auto xmy = x;
│ │ │ │ │ - 452 xmy -= interpolate(px, corners);
│ │ │ │ │ - 453 const auto n = interpolate_unit_normals(px, normals);
│ │ │ │ │ - 454 const auto d = xmy * n;
│ │ │ │ │ - 455 if (d < -m_overlap-m_epsilon)
│ │ │ │ │ - 456 return false;
│ │ │ │ │ - 457
│ │ │ │ │ - 458 /* Normals at x and Φ(x) are opposing. */
│ │ │ │ │ - 459 if (nx * n > m_max_normal_product + m_epsilon)
│ │ │ │ │ - 460 return false;
│ │ │ │ │ - 461
│ │ │ │ │ - 462 /* Okay, projection is feasible. */
│ │ │ │ │ - 463 return true;
│ │ │ │ │ - 464}
│ │ │ │ │ - 465
│ │ │ │ │ - 466template
│ │ │ │ │ - 467template
│ │ │ │ │ - 468void Projection
│ │ │ │ │ -469::project(const std::tuple& corners, const std::
│ │ │ │ │ -tuple& normals)
│ │ │ │ │ - 470{
│ │ │ │ │ - 471 doProjection(corners, normals);
│ │ │ │ │ - 472 doInverseProjection(corners, normals);
│ │ │ │ │ - 473 doEdgeIntersection(corners, normals);
│ │ │ │ │ - 474}
│ │ │ │ │ - 475
│ │ │ │ │ - 476} /* namespace GridGlue */
│ │ │ │ │ - 477} /* namespace Dune */
│ │ │ │ │ + 12template
│ │ │ │ │ + 13void write_glue_area_vtk(const Glue& glue, std::ostream& out);
│ │ │ │ │ + 14
│ │ │ │ │ + 15template
│ │ │ │ │ + 16void write_glue_area_vtk(const Glue& glue, const std::string& filename);
│ │ │ │ │ + 17
│ │ │ │ │ + 37template
│ │ │ │ │ + 38void write_glue_areas_vtk(const Glue& glue, const std::string& base);
│ │ │ │ │ + 39
│ │ │ │ │ + 40} /* namespace GridGlue */
│ │ │ │ │ + 41} /* namespace Dune */
│ │ │ │ │ + 42
│ │ │ │ │ + 43#include "areawriter_impl.hh"
│ │ │ │ │ + 44
│ │ │ │ │ + 45#endif
│ │ │ │ │ +areawriter_impl.hh
│ │ │ │ │ Dune
│ │ │ │ │ Definition: gridglue.hh:37
│ │ │ │ │ -Dune::GridGlue::ProjectionImplementation::interpolate
│ │ │ │ │ -Corners::value_type interpolate(const Coordinate &x, const Corners &corners)
│ │ │ │ │ -Definition: projection_impl.hh:70
│ │ │ │ │ -Dune::GridGlue::ProjectionImplementation::inside
│ │ │ │ │ -bool inside(const Coordinate &x, const Field &epsilon)
│ │ │ │ │ -Definition: projection_impl.hh:111
│ │ │ │ │ -Dune::GridGlue::ProjectionImplementation::edgeToCorners
│ │ │ │ │ -std::pair< unsigned, unsigned > edgeToCorners(unsigned edge)
│ │ │ │ │ -Definition: projection_impl.hh:43
│ │ │ │ │ -Dune::GridGlue::ProjectionImplementation::corner
│ │ │ │ │ -Coordinate corner(unsigned c)
│ │ │ │ │ -Definition: projection_impl.hh:24
│ │ │ │ │ -Dune::GridGlue::ProjectionImplementation::interpolate_unit_normals
│ │ │ │ │ -Normals::value_type interpolate_unit_normals(const Coordinate &x, const Normals
│ │ │ │ │ -&normals)
│ │ │ │ │ -Definition: projection_impl.hh:91
│ │ │ │ │ -Dune::GridGlue::Projection
│ │ │ │ │ -Projection of a line (triangle) on another line (triangle).
│ │ │ │ │ -Definition: projection.hh:21
│ │ │ │ │ -Dune::GridGlue::Projection::Field
│ │ │ │ │ -Coordinate::field_type Field
│ │ │ │ │ -Scalar type.
│ │ │ │ │ -Definition: projection.hh:61
│ │ │ │ │ -Dune::GridGlue::Projection::Projection
│ │ │ │ │ -Projection(const Field overlap=Field(0), const Field max_normal_product=Field(-
│ │ │ │ │ -0.1))
│ │ │ │ │ -Definition: projection_impl.hh:130
│ │ │ │ │ -Dune::GridGlue::Projection::epsilon
│ │ │ │ │ -void epsilon(const Field epsilon)
│ │ │ │ │ -Set epsilon used for floating-point comparisons.
│ │ │ │ │ -Definition: projection_impl.hh:140
│ │ │ │ │ -Dune::GridGlue::Projection::project
│ │ │ │ │ -void project(const std::tuple< Corners &, Corners & > &corners, const std::
│ │ │ │ │ -tuple< Normals &, Normals & > &normals)
│ │ │ │ │ -Do the actual projection.
│ │ │ │ │ -Definition: projection_impl.hh:469
│ │ │ │ │ +Dune::GridGlue::write_glue_area_vtk
│ │ │ │ │ +void write_glue_area_vtk(const Glue &glue, std::ostream &out)
│ │ │ │ │ +Definition: areawriter_impl.hh:84
│ │ │ │ │ +Dune::GridGlue::write_glue_areas_vtk
│ │ │ │ │ +void write_glue_areas_vtk(const Glue &glue, const std::string &base)
│ │ │ │ │ +Definition: areawriter_impl.hh:129
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00050.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: projectionwriter.hh File Reference
│ │ │ │ +dune-grid-glue: projectionwriter_impl.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -65,33 +65,47 @@
│ │ │ │ dune grid-glue common
│ │ │ │
│ │ │ │
│ │ │ │
#include <array>│ │ │ │
#include <bitset>│ │ │ │
#include <tuple>│ │ │ │ -
#include "projection_impl.hh"│ │ │ │ +
#include "projection_impl.hh"│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ Classes | |||
| class | Dune::GridGlue::Projection< Coordinate > | ||
| Projection of a line (triangle) on another line (triangle). More... | |||
│ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::Parallel |
| namespace | Dune::GridGlue |
│ │ │ │ -Macros | |
| #define | CheckMPIStatus(A, B) {} |
│ │ │ │ Functions | |
| template<typename OP , typename... Args> | |
| void | Dune::Parallel::MPI_AllApply (MPI_Comm mpicomm, OP &&op, const Args &... data) |
| apply an operator locally to a difstributed data set More... | |
| template<typename Coordinate , typename Corners , typename Normals > | |
| void | Dune::GridGlue::write (const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals, std::ostream &out) |
| write projection in VTK format More... | |
| template<typename Coordinate , typename Corners , typename Normals > | |
| void | Dune::GridGlue::write (const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals, const std::string &filename) |
| write projection in VTK format More... | |
| template<typename Coordinate , typename Corners , typename Normals > | |
| void | Dune::GridGlue::print (const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals) |
| Print information about the projection to std::cout stream. More... | |
Macro Definition Documentation
│ │ │ │ - │ │ │ │ -◆ CheckMPIStatus
│ │ │ │ - │ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
| #define CheckMPIStatus | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | A, | │ │ │ │ -
| │ │ │ │ - | │ │ │ │ - | │ │ │ │ - | B | │ │ │ │ -
| │ │ │ │ - | ) | │ │ │ │ -{} | │ │ │ │ -
│ │ │ │ -
│ │ │ │ -- Todo:
- Implement MPI Status check with exception handling
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,40 +5,38 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -Namespaces | Macros | Functions
│ │ │ │ │ -ringcomm.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ ringcomm.hh
projectionwriter.hh
│ │ │ │ -Go to the documentation of this file.
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,309 +5,63 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -ringcomm.hh
│ │ │ │ │ +projectionwriter.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ - 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ - 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ - 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ + 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ - 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ + 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 5/* IMPLEMENTATION OF CLASS G R I D G L U E */
│ │ │ │ │ - 6
│ │ │ │ │ -8#define CheckMPIStatus(A,B) {}
│ │ │ │ │ - 9
│ │ │ │ │ - 10#include
│ │ │ │ │ - 11#include
│ │ │ │ │ - 12#include
│ │ │ │ │ + 3#ifndef DUNE_GRIDGLUE_COMMON_PROJECTIONWRITER_HH
│ │ │ │ │ + 4#define DUNE_GRIDGLUE_COMMON_PROJECTIONWRITER_HH
│ │ │ │ │ + 5
│ │ │ │ │ + 6#include
│ │ │ │ │ + 7#include
│ │ │ │ │ + 8
│ │ │ │ │ + 9#include
│ │ │ │ │ + 10
│ │ │ │ │ + 11namespace Dune {
│ │ │ │ │ + 12namespace GridGlue {
│ │ │ │ │ 13
│ │ │ │ │ - 14#include
│ │ │ │ │ - 15#include
│ │ │ │ │ - 16
│ │ │ │ │ - 17#include
│ │ │ │ │ - 18
│ │ │ │ │ - 19namespace Dune {
│ │ │ │ │ -20namespace Parallel {
│ │ │ │ │ - 21
│ │ │ │ │ - 22 namespace Impl {
│ │ │ │ │ - 23
│ │ │ │ │ - 25 template
│ │ │ │ │ - 26 struct MPITypeInfo {};
│ │ │ │ │ - 27
│ │ │ │ │ - 28 template<>
│ │ │ │ │ - 29 struct MPITypeInfo< int >
│ │ │ │ │ - 30 {
│ │ │ │ │ - 31 static const unsigned int size = 1;
│ │ │ │ │ - 32 static inline MPI_Datatype getType()
│ │ │ │ │ - 33 {
│ │ │ │ │ - 34 return MPI_INT;
│ │ │ │ │ - 35 }
│ │ │ │ │ - 36 };
│ │ │ │ │ - 37
│ │ │ │ │ - 38 template
│ │ │ │ │ - 39 struct MPITypeInfo< Dune::FieldVector >
│ │ │ │ │ - 40 {
│ │ │ │ │ - 41 static const unsigned int size = N;
│ │ │ │ │ - 42 static inline MPI_Datatype getType()
│ │ │ │ │ - 43 {
│ │ │ │ │ - 44 return Dune::MPITraits::getType();
│ │ │ │ │ - 45 }
│ │ │ │ │ - 46 };
│ │ │ │ │ - 47
│ │ │ │ │ - 48 template<>
│ │ │ │ │ - 49 struct MPITypeInfo< unsigned int >
│ │ │ │ │ - 50 {
│ │ │ │ │ - 51 static const unsigned int size = 1;
│ │ │ │ │ - 52 static inline MPI_Datatype getType()
│ │ │ │ │ - 53 {
│ │ │ │ │ - 54 return MPI_UNSIGNED;
│ │ │ │ │ - 55 }
│ │ │ │ │ - 56 };
│ │ │ │ │ - 57
│ │ │ │ │ - 58 template<>
│ │ │ │ │ - 59 struct MPITypeInfo< Dune::GeometryType >
│ │ │ │ │ - 60 {
│ │ │ │ │ - 61 static const unsigned int size = 1;
│ │ │ │ │ - 62 static inline MPI_Datatype getType()
│ │ │ │ │ - 63 {
│ │ │ │ │ - 64 return Dune::MPITraits< Dune::GeometryType >::getType();
│ │ │ │ │ - 65 }
│ │ │ │ │ - 66 };
│ │ │ │ │ - 67
│ │ │ │ │ - 68 template
│ │ │ │ │ - 69 void MPI_SetVectorSize(
│ │ │ │ │ - 70 std::vector & data,
│ │ │ │ │ - 71 MPI_Status & status)
│ │ │ │ │ - 72 {
│ │ │ │ │ - 73 typedef MPITypeInfo Info;
│ │ │ │ │ - 74 int sz;
│ │ │ │ │ - 75 MPI_Get_count(&status, Info::getType(), &sz);
│ │ │ │ │ - 76 assert(sz%Info::size == 0);
│ │ │ │ │ - 77 data.resize(sz/Info::size);
│ │ │ │ │ - 78 }
│ │ │ │ │ - 79
│ │ │ │ │ - 89 template
│ │ │ │ │ - 90 void MPI_SendVectorInRing(
│ │ │ │ │ - 91 std::vector & data,
│ │ │ │ │ - 92 std::vector & next,
│ │ │ │ │ - 93 int tag,
│ │ │ │ │ - 94 int rightrank,
│ │ │ │ │ - 95 int leftrank,
│ │ │ │ │ - 96 MPI_Comm comm,
│ │ │ │ │ - 97 MPI_Request& r_send,
│ │ │ │ │ - 98 MPI_Request& r_recv
│ │ │ │ │ - 99 )
│ │ │ │ │ - 100 {
│ │ │ │ │ - 101 // mpi status stuff
│ │ │ │ │ - 102 [[maybe_unused]] int result = 0;
│ │ │ │ │ - 103 typedef MPITypeInfo Info;
│ │ │ │ │ - 104 // resize next buffer to maximum size
│ │ │ │ │ - 105 next.resize(next.capacity());
│ │ │ │ │ - 106 // send data (explicitly send data.size elements)
│ │ │ │ │ - 107 result =
│ │ │ │ │ - 108 MPI_Isend(
│ │ │ │ │ - 109 &(data[0]), Info::size*data.size(), Info::getType(), rightrank, tag,
│ │ │ │ │ - 110 comm, &r_send);
│ │ │ │ │ - 111 // receive up to maximum size. The acutal size is stored in the status
│ │ │ │ │ - 112 result =
│ │ │ │ │ - 113 MPI_Irecv(
│ │ │ │ │ - 114 &(next[0]), Info::size*next.size(), Info::getType(), leftrank, tag,
│ │ │ │ │ - 115 comm, &r_recv);
│ │ │ │ │ - 116 // // check result
│ │ │ │ │ - 117 // MPI_Status status;
│ │ │ │ │ - 118 // CheckMPIStatus(result, status);
│ │ │ │ │ - 119 }
│ │ │ │ │ - 120
│ │ │ │ │ - 121 template
│ │ │ │ │ - 122 using ptr_t = T*;
│ │ │ │ │ - 123
│ │ │ │ │ - 124 /* these helper structs are needed as long as we still support
│ │ │ │ │ - 125 C++11, as we can't use variadic lambdas */
│ │ │ │ │ - 126 template
│ │ │ │ │ - 127 struct call_MPI_SendVectorInRing
│ │ │ │ │ - 128 {
│ │ │ │ │ - 129 std::tuple & remotedata;
│ │ │ │ │ - 130 std::tuple & nextdata;
│ │ │ │ │ - 131 int & tag;
│ │ │ │ │ - 132 int & rightrank;
│ │ │ │ │ - 133 int & leftrank;
│ │ │ │ │ - 134 MPI_Comm & mpicomm;
│ │ │ │ │ - 135 std::array & requests_send;
│ │ │ │ │ - 136 std::array & requests_recv;
│ │ │ │ │ - 137
│ │ │ │ │ - 138 template
│ │ │ │ │ - 139 void operator()(I i)
│ │ │ │ │ - 140 {
│ │ │ │ │ - 141 MPI_SendVectorInRing(
│ │ │ │ │ - 142 std::get(remotedata),
│ │ │ │ │ - 143 std::get(nextdata),
│ │ │ │ │ - 144 tag+i,
│ │ │ │ │ - 145 rightrank, leftrank, mpicomm,
│ │ │ │ │ - 146 requests_send[i],
│ │ │ │ │ - 147 requests_recv[i]);
│ │ │ │ │ - 148 }
│ │ │ │ │ - 149 };
│ │ │ │ │ - 150 template
│ │ │ │ │ - 151 struct call_MPI_SetVectorSize
│ │ │ │ │ - 152 {
│ │ │ │ │ - 153 std::tuple & nextdata;
│ │ │ │ │ - 154 std::array & status_recv;
│ │ │ │ │ - 155
│ │ │ │ │ - 156 template
│ │ │ │ │ - 157 void operator()(I i)
│ │ │ │ │ - 158 {
│ │ │ │ │ - 159 MPI_SetVectorSize(std::get(nextdata),status_recv[i]);
│ │ │ │ │ - 160 }
│ │ │ │ │ - 161 };
│ │ │ │ │ - 162
│ │ │ │ │ - 163 template
│ │ │ │ │ - 164 void MPI_AllApply_impl(MPI_Comm mpicomm,
│ │ │ │ │ - 165 OP && op,
│ │ │ │ │ - 166 std::index_sequence indices,
│ │ │ │ │ - 167 const Args&... data)
│ │ │ │ │ - 168 {
│ │ │ │ │ - 169 constexpr std::size_t N = sizeof...(Args);
│ │ │ │ │ - 170 int myrank = 0;
│ │ │ │ │ - 171 int commsize = 0;
│ │ │ │ │ - 172#if HAVE_MPI
│ │ │ │ │ - 173 MPI_Comm_rank(mpicomm, &myrank);
│ │ │ │ │ - 174 MPI_Comm_size(mpicomm, &commsize);
│ │ │ │ │ - 175#endif // HAVE_MPI
│ │ │ │ │ - 176
│ │ │ │ │ - 177 if (commsize > 1)
│ │ │ │ │ - 178 {
│ │ │ │ │ - 179#ifdef DEBUG_GRIDGLUE_PARALLELMERGE
│ │ │ │ │ - 180 std::cout << myrank << " Start Communication, size " << commsize << std::
│ │ │ │ │ -endl;
│ │ │ │ │ - 181#endif
│ │ │ │ │ - 182
│ │ │ │ │ - 183 // get data sizes
│ │ │ │ │ - 184 std::array size({ ((unsigned int)data.size())... });
│ │ │ │ │ - 185
│ │ │ │ │ - 186 // communicate max data size
│ │ │ │ │ - 187 std::array maxSize;
│ │ │ │ │ - 188 MPI_Allreduce(&size, &maxSize,
│ │ │ │ │ - 189 size.size(), MPI_UNSIGNED, MPI_MAX, mpicomm);
│ │ │ │ │ - 190#ifdef DEBUG_GRIDGLUE_PARALLELMERGE
│ │ │ │ │ - 191 std::cout << myrank << " maxSize " << "done... " << std::endl;
│ │ │ │ │ - 192#endif
│ │ │ │ │ - 193
│ │ │ │ │ - 194 // allocate receiving buffers with maxsize to ensure sufficient buffer
│ │ │ │ │ -size for communication
│ │ │ │ │ - 195 std::tuple remotedata { Args(maxSize[Indices])... };
│ │ │ │ │ - 196
│ │ │ │ │ - 197 // copy local data to receiving buffer
│ │ │ │ │ - 198 remotedata = std::tie(data...);
│ │ │ │ │ - 199
│ │ │ │ │ - 200 // allocate second set of receiving buffers necessary for async
│ │ │ │ │ -communication
│ │ │ │ │ - 201 std::tuple nextdata { Args(maxSize[Indices])... };
│ │ │ │ │ - 202
│ │ │ │ │ - 203 // communicate data in the ring
│ │ │ │ │ - 204 int rightrank = (myrank + 1 + commsize) % commsize;
│ │ │ │ │ - 205 int leftrank = (myrank - 1 + commsize) % commsize;
│ │ │ │ │ - 206
│ │ │ │ │ - 207 std::cout << myrank << ": size = " << commsize << std::endl;
│ │ │ │ │ - 208 std::cout << myrank << ": left = " << leftrank
│ │ │ │ │ - 209 << " right = " << rightrank << std::endl;
│ │ │ │ │ - 210
│ │ │ │ │ - 211 // currently the remote data is our own data
│ │ │ │ │ - 212 int remoterank = myrank;
│ │ │ │ │ - 213
│ │ │ │ │ - 214 for (int i=1; i &projection, const Corners &corners,
│ │ │ │ │ +const Normals &normals, std::ostream &out)
│ │ │ │ │ +write projection in VTK format
│ │ │ │ │ +Definition: projectionwriter_impl.hh:86
│ │ │ │ │ +Dune::GridGlue::print
│ │ │ │ │ +void print(const Projection< Coordinate > &projection, const Corners &corners,
│ │ │ │ │ +const Normals &normals)
│ │ │ │ │ +Print information about the projection to std::cout stream.
│ │ │ │ │ +Definition: projectionwriter_impl.hh:140
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00047.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: projection_impl.hh File Reference
│ │ │ │ +dune-grid-glue: areawriter.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -65,47 +65,41 @@
│ │ │ │ dune grid-glue common
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ - 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +Go to the documentation of this file. 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ + 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ Definition: gridglue.hh:37
void MPI_AllApply(MPI_Comm mpicomm, OP &&op, const Args &... data)
apply an operator locally to a difstributed data set
Definition: ringcomm.hh:297
void write(const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals, std::ostream &out)
write projection in VTK format
Definition: projectionwriter_impl.hh:86
void print(const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals)
Print information about the projection to std::cout stream.
Definition: projectionwriter_impl.hh:140
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,309 +5,63 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -ringcomm.hh
│ │ │ │ │ +projectionwriter.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ - 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ - 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ - 3// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ + 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ - 4// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ + 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 5/* IMPLEMENTATION OF CLASS G R I D G L U E */
│ │ │ │ │ - 6
│ │ │ │ │ -8#define CheckMPIStatus(A,B) {}
│ │ │ │ │ - 9
│ │ │ │ │ - 10#include
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ Namespaces |
│ │ │ │ Functions
│ │ │ │ - projection_impl.hh File Reference
areawriter.hh File Reference
│ │ │ │ -
│ │ │ │ -
│ │ │ │ + │ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ Generated by 1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -6,44 +6,32 @@
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ Namespaces | Functions
│ │ │ │ │ -projection_impl.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +areawriter.hh File Reference
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include "areawriter_impl.hh"
│ │ │ │ │ Go_to_the_source_code_of_this_file.
│ │ │ │ │ Namespaces
│ │ │ │ │ namespace Dune
│ │ │ │ │
│ │ │ │ │ namespace Dune::GridGlue
│ │ │ │ │
│ │ │ │ │ -namespace Dune::GridGlue::ProjectionImplementation
│ │ │ │ │ -
│ │ │ │ │ Functions
│ │ │ │ │ -template
│ │ │ │ │ - Coordinate Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ - corner (unsigned c)
│ │ │ │ │ -
│ │ │ │ │ -std::pair< unsigned, unsigned > Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ - edgeToCorners (unsigned edge)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - Corners::value_type Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ - interpolate (const Coordinate &x, const
│ │ │ │ │ - Corners &corners)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - Normals::value_type Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ - interpolate_unit_normals (const Coordinate &x,
│ │ │ │ │ - const Normals &normals)
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::GridGlue::write_glue_area_vtk (const Glue &glue, std::ostream &out)
│ │ │ │ │
│ │ │ │ │ -template
│ │ │ │ │ - bool Dune::GridGlue::ProjectionImplementation::
│ │ │ │ │ - inside (const Coordinate &x, const Field
│ │ │ │ │ - &epsilon)
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::GridGlue::write_glue_area_vtk (const Glue &glue, const std::string
│ │ │ │ │ + &filename)
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void Dune::GridGlue::write_glue_areas_vtk (const Glue &glue, const std::string
│ │ │ │ │ + &base)
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by [doxygen] 1.9.4
│ │ │ ├── ./usr/share/doc/libdune-grid-glue-doc/doxygen/a00047_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -dune-grid-glue: projection_impl.hh Source File
│ │ │ │ +dune-grid-glue: areawriter.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -62,449 +62,47 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ #include <dune/common/fmatrix.hh>│ │ │ │ -
#include <cmath>│ │ │ │ + │ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
| namespace | Dune::GridGlue::ProjectionImplementation |
│ │ │ │ Functions | |
| template<typename Coordinate , typename Field > | |
| Coordinate | Dune::GridGlue::ProjectionImplementation::corner (unsigned c) |
| std::pair< unsigned, unsigned > | Dune::GridGlue::ProjectionImplementation::edgeToCorners (unsigned edge) |
| template<typename Coordinate , typename Corners > | |
| Corners::value_type | Dune::GridGlue::ProjectionImplementation::interpolate (const Coordinate &x, const Corners &corners) |
| template<typename Coordinate , typename Normals > | |
| Normals::value_type | Dune::GridGlue::ProjectionImplementation::interpolate_unit_normals (const Coordinate &x, const Normals &normals) |
| template<typename Coordinate , typename Field > | |
| bool | Dune::GridGlue::ProjectionImplementation::inside (const Coordinate &x, const Field &epsilon) |
| template<int side, typename Glue > | |
| void | Dune::GridGlue::write_glue_area_vtk (const Glue &glue, std::ostream &out) |
| template<int side, typename Glue > | |
| void | Dune::GridGlue::write_glue_area_vtk (const Glue &glue, const std::string &filename) |
| template<typename Glue > | |
| void | Dune::GridGlue::write_glue_areas_vtk (const Glue &glue, const std::string &base) |
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -6,44 +6,32 @@
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ Namespaces | Functions
│ │ │ │ │ -projection_impl.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ projection_impl.hh
areawriter.hh
│ │ │ │ Go to the documentation of this file.
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
│ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 149::doProjection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 227 const bool feasible = projectionFeasible(origin[i], origin_normals[i], y, target, target_normals);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 241::doInverseProjection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 302 const bool feasible = projectionFeasible(target_corners[i], get<1>(normals)[i], preimages[i], get<0>(corners), get<0>(normals));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 311::doEdgeIntersection(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 438::projectionFeasible(const Coordinate& x, const Coordinate& nx, const Coordinate& px, const Corners& corners, const Normals& normals) const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ - 469::project(const std::tuple<Corners&, Corners&>& corners, const std::tuple<Normals&, Normals&>& normals)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ Definition: gridglue.hh:37
Corners::value_type interpolate(const Coordinate &x, const Corners &corners)
Definition: projection_impl.hh:70
bool inside(const Coordinate &x, const Field &epsilon)
Definition: projection_impl.hh:111
std::pair< unsigned, unsigned > edgeToCorners(unsigned edge)
Definition: projection_impl.hh:43
Coordinate corner(unsigned c)
Definition: projection_impl.hh:24
Normals::value_type interpolate_unit_normals(const Coordinate &x, const Normals &normals)
Definition: projection_impl.hh:91
Projection of a line (triangle) on another line (triangle).
Definition: projection.hh:21
Coordinate::field_type Field
Scalar type.
Definition: projection.hh:61
Projection(const Field overlap=Field(0), const Field max_normal_product=Field(-0.1))
Definition: projection_impl.hh:130
void epsilon(const Field epsilon)
Set epsilon used for floating-point comparisons.
Definition: projection_impl.hh:140
void project(const std::tuple< Corners &, Corners & > &corners, const std::tuple< Normals &, Normals & > &normals)
Do the actual projection.
Definition: projection_impl.hh:469
void write_glue_area_vtk(const Glue &glue, std::ostream &out)
Definition: areawriter_impl.hh:84
void write_glue_areas_vtk(const Glue &glue, const std::string &base)
Definition: areawriter_impl.hh:129
│ │ │ │ Generated by
1.9.4
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,494 +5,49 @@
│ │ │ │ │
│ │ │ │ │ dune-grid-glue 2.9
│ │ │ │ │
│ │ │ │ │
│ │ │ │ │ * dune
│ │ │ │ │ * grid-glue
│ │ │ │ │ * common
│ │ │ │ │ -projection_impl.hh
│ │ │ │ │ +areawriter.hh
│ │ │ │ │ Go_to_the_documentation_of_this_file.
│ │ │ │ │ 1// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-
│ │ │ │ │ with-dune-grid-glue-exception
│ │ │ │ │ - 3#include
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ Namespaces |
│ │ │ │ Functions
│ │ │ │ - projectionwriter.hh File Reference
projectionwriter_impl.hh File Reference
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
#include <iostream>│ │ │ │ -
#include <string>│ │ │ │ -
#include <dune/grid-glue/common/projection.hh>│ │ │ │ -
#include "projectionwriter_impl.hh"│ │ │ │ +
#include <fstream>│ │ │ │
Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | Dune |
| namespace | Dune::GridGlue |
| namespace | Dune::GridGlue::ProjectionWriterImplementation |
│ │ │ │ Functions | |
| template<unsigned side, typename Coordinate , typename Corners > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_points (const Projection< Coordinate > &projection, const Corners &corners, std::ostream &out) |
| template<unsigned side, typename Coordinate , typename Normals > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_normals (const Projection< Coordinate > &projection, const Normals &normals, std::ostream &out) |
| template<typename Coordinate , typename Corners > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_edge_intersection_points (const Projection< Coordinate > &projection, const Corners &corners, std::ostream &out) |
| template<typename Coordinate , typename Normals > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_edge_intersection_normals (const Projection< Coordinate > &projection, const Normals &normals, std::ostream &out) |
| template<unsigned side, typename Coordinate > | |
| void | Dune::GridGlue::ProjectionWriterImplementation::write_success (const Projection< Coordinate > &projection, std::ostream &out) |
| template<typename Coordinate , typename Corners , typename Normals > | |
| void | Dune::GridGlue::write (const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals, std::ostream &out) |
| write projection in VTK format More... | |
| template<typename Coordinate , typename Corners , typename Normals > | |
| void | Dune::GridGlue::write (const Projection< Coordinate > &projection, const Corners &corners, const Normals &normals, const std::string &filename) |
| write projection in VTK format More... | |