Loading...
Searching...
No Matches
codim0extractor.hh
Go to the documentation of this file.
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
/*
* Filename: codim0extractor.hh
* Version: 1.0
* Created on: Jun 23, 2009
* Author: Oliver Sander, Christian Engwer
* ---------------------------------
* Project: dune-grid-glue
* Description: base class for grid extractors extracting surface grids
*
*/
#ifndef DUNE_GRIDGLUE_EXTRACTORS_CODIM0EXTRACTOR_HH
#define DUNE_GRIDGLUE_EXTRACTORS_CODIM0EXTRACTOR_HH
#include <deque>
#include <functional>
#include <dune/common/deprecated.hh>
#include <dune/grid/common/mcmgmapper.hh>
#include "extractor.hh"
namespace Dune {
namespace GridGlue {
template<typename GV>
class Codim0Extractor : public Extractor<GV,0>
{
public:
/* E X P O R T E D T Y P E S A N D C O N S T A N T S */
using Extractor<GV,0>::codim;
typedef typename Extractor<GV,0>::ctype ctype;
using Extractor<GV,0>::dim;
using Extractor<GV,0>::dimworld;
typedef typename Extractor<GV,0>::IndexType IndexType;
typedef typename GV::Traits::template Codim<dim>::Entity Vertex;
typedef typename GV::Traits::template Codim<0>::Entity Element;
typedef std::function<bool(const Element&, unsigned int subentity)> Predicate;
// import typedefs from base class
typedef typename Extractor<GV,0>::SubEntityInfo SubEntityInfo;
typedef typename Extractor<GV,0>::ElementInfo ElementInfo;
typedef typename Extractor<GV,0>::VertexInfo VertexInfo;
typedef typename Extractor<GV,0>::CoordinateInfo CoordinateInfo;
typedef typename Extractor<GV,0>::VertexInfoMap VertexInfoMap;
Codim0Extractor(const GV& gv, const Predicate& predicate)
: Extractor<GV,0>(gv), positiveNormalDirection_(false)
{
std::cout << "This is Codim0Extractor on a <"
<< GV::dimension << "," << GV::dimensionworld << "> grid!" << std::endl;
update(predicate);
}
bool & positiveNormalDirection() { return positiveNormalDirection_; }
const bool & positiveNormalDirection() const { return positiveNormalDirection_; }
protected:
bool positiveNormalDirection_;
private:
void update(const Predicate& predicate);
};
template<typename GV>
void Codim0Extractor<GV>::update(const Predicate& predicate)
{
// In this first pass iterate over all entities of codim 0.
// Get its corner vertices, find resp. store them together with their associated index,
// and remember the indices of the corners.
// free everything there is in this object
this->clear();
// several counter for consecutive indexing are needed
size_t element_index = 0;
size_t vertex_index = 0;
// a temporary container where newly acquired face
// information can be stored at first
std::deque<SubEntityInfo> temp_faces;
// iterate over all codim 0 elements on the grid
for (const auto& elmt : elements(this->gv_, Partitions::interior))
{
const auto geometry = elmt.geometry();
IndexType eindex = this->cellMapper_.index(elmt);
// only do sth. if this element is "interesting"
// implicit cast is done automatically
if (predicate(elmt,0))
{
// add an entry to the element info map, the index will be set properly later
this->elmtInfo_.emplace(eindex, ElementInfo(element_index, elmt, 1));
unsigned int numCorners = elmt.subEntities(dim);
unsigned int vertex_indices[numCorners]; // index in global vector
unsigned int vertex_numbers[numCorners]; // index in parent entity
// try for each of the faces vertices whether it is already inserted or not
for (unsigned int i = 0; i < numCorners; ++i)
{
vertex_numbers[i] = i;
// get the vertex pointer and the index from the index set
const Vertex vertex = elmt.template subEntity<dim>(vertex_numbers[i]);
IndexType vindex = this->gv_.indexSet().template index<dim>(vertex);
// if the vertex is not yet inserted in the vertex info map
// it is a new one -> it will be inserted now!
typename VertexInfoMap::iterator vimit = this->vtxInfo_.find(vindex);
if (vimit == this->vtxInfo_.end())
{
// insert into the map
this->vtxInfo_.emplace(vindex, VertexInfo(vertex_index, vertex));
// remember this vertex' index
vertex_indices[i] = vertex_index;
// increase the current index
vertex_index++;
}
else
{
// only remember the vertex' index
vertex_indices[i] = vimit->second.idx;
}
}
// flip cell if necessary
{
switch (int(dim))
{
case 0 :
break;
case 1 :
{
// The following test only works if the zero-th coordinate is the
// one that defines the orientation. A sufficient condition for
// this is dimworld == 1
/* assert(dimworld==1); */
bool elementNormalDirection =
(geometry.corner(1)[0] < geometry.corner(0)[0]);
if ( positiveNormalDirection_ != elementNormalDirection )
{
std::swap(vertex_indices[0], vertex_indices[1]);
std::swap(vertex_numbers[0], vertex_numbers[1]);
}
break;
}
case 2 :
{
Dune::FieldVector<ctype, dimworld>
v0 = geometry.corner(1),
v1 = geometry.corner(2);
v0 -= geometry.corner(0);
v1 -= geometry.corner(0);
ctype normal_sign = v0[0]*v1[1] - v0[1]*v1[0];
bool elementNormalDirection = (normal_sign < 0);
if ( positiveNormalDirection_ != elementNormalDirection )
{
std::cout << "swap\n";
if (elmt.type().isCube())
{
for (int i = 0; i < (1<<dim); i+=2)
{
// swap i and i+1
std::swap(vertex_indices[i], vertex_indices[i+1]);
std::swap(vertex_numbers[i], vertex_numbers[i+1]);
}
} else if (elmt.type().isSimplex()) {
std::swap(vertex_indices[0], vertex_indices[1]);
std::swap(vertex_numbers[0], vertex_numbers[1]);
} else {
DUNE_THROW(Dune::Exception, "Unexpected Geometrytype");
}
}
break;
}
}
}
// add a new face to the temporary collection
temp_faces.emplace_back(eindex, 0, elmt.type());
element_index++;
for (unsigned int i=0; i<numCorners; i++) {
temp_faces.back().corners[i].idx = vertex_indices[i];
// remember the vertices' numbers in parent element's vertices
temp_faces.back().corners[i].num = vertex_numbers[i];
}
}
} // end loop over elements
// allocate the array for the face specific information...
this->subEntities_.resize(element_index);
// ...and fill in the data from the temporary containers
copy(temp_faces.begin(), temp_faces.end(), this->subEntities_.begin());
// now first write the array with the coordinates...
this->coords_.resize(this->vtxInfo_.size());
for (const auto& vinfo : this->vtxInfo_)
{
// get a pointer to the associated info object
CoordinateInfo* current = &this->coords_[vinfo.second.idx];
// store this coordinates index // NEEDED?
current->index = vinfo.second.idx;
// store the vertex' index for the index2vertex mapping
current->vtxindex = vinfo.first;
// store the vertex' coordinates under the associated index
// in the coordinates array
const auto vtx = this->grid().entity(vinfo.second.p);
current->coord = vtx.geometry().corner(0);
}
}
} // namespace GridGlue
} // namespace Dune
#endif // DUNE_GRIDGLUE_EXTRACTORS_CODIM0EXTRACTOR_HH
extractor.hh
extractor base class
Dune
Definition gridglue.hh:37
Dune::GridGlue
Definition gridglue.hh:38
Dune::GridGlue::Codim0Extractor::positiveNormalDirection
bool & positiveNormalDirection()
Definition codim0extractor.hh:75
Dune::GridGlue::Codim0Extractor::IndexType
Extractor< GV, 0 >::IndexType IndexType
Definition codim0extractor.hh:49
Dune::GridGlue::Codim0Extractor::positiveNormalDirection
const bool & positiveNormalDirection() const
Definition codim0extractor.hh:76
Dune::GridGlue::Codim0Extractor::Vertex
GV::Traits::template Codim< dim >::Entity Vertex
Definition codim0extractor.hh:51
Dune::GridGlue::Codim0Extractor::CoordinateInfo
Extractor< GV, 0 >::CoordinateInfo CoordinateInfo
Definition codim0extractor.hh:59
Dune::GridGlue::Codim0Extractor::VertexInfo
Extractor< GV, 0 >::VertexInfo VertexInfo
Definition codim0extractor.hh:58
Dune::GridGlue::Codim0Extractor::ctype
Extractor< GV, 0 >::ctype ctype
Definition codim0extractor.hh:46
Dune::GridGlue::Codim0Extractor::positiveNormalDirection_
bool positiveNormalDirection_
Definition codim0extractor.hh:79
Dune::GridGlue::Codim0Extractor::VertexInfoMap
Extractor< GV, 0 >::VertexInfoMap VertexInfoMap
Definition codim0extractor.hh:60
Dune::GridGlue::Codim0Extractor::Predicate
std::function< bool(const Element &, unsigned int subentity)> Predicate
Definition codim0extractor.hh:53
Dune::GridGlue::Codim0Extractor::Codim0Extractor
Codim0Extractor(const GV &gv, const Predicate &predicate)
Constructor.
Definition codim0extractor.hh:67
Dune::GridGlue::Codim0Extractor::ElementInfo
Extractor< GV, 0 >::ElementInfo ElementInfo
Definition codim0extractor.hh:57
Dune::GridGlue::Codim0Extractor::Element
GV::Traits::template Codim< 0 >::Entity Element
Definition codim0extractor.hh:52
Dune::GridGlue::Codim0Extractor::SubEntityInfo
Extractor< GV, 0 >::SubEntityInfo SubEntityInfo
Definition codim0extractor.hh:56
Dune::GridGlue::IndexType
Dune::GridGlue::Extractor< GV, 0 >::dimworld
static constexpr auto dimworld
Definition extractor.hh:50
Dune::GridGlue::Extractor::IndexType
int IndexType
Definition extractor.hh:73
Dune::GridGlue::Extractor< GV, 0 >::codim
static constexpr auto codim
Definition extractor.hh:52
Dune::GridGlue::Extractor::VertexInfoMap
std::map< IndexType, VertexInfo > VertexInfoMap
Definition extractor.hh:186
Dune::GridGlue::Extractor::ctype
GV::Grid::ctype ctype
Definition extractor.hh:59
Dune::GridGlue::Extractor< GV, 0 >::Extractor
Extractor(const GV &gv)
Definition extractor.hh:225
Dune::GridGlue::Extractor< GV, 0 >::dim
static constexpr auto dim
Definition extractor.hh:51
Dune::GridGlue::Extractor::CoordinateInfo
Definition extractor.hh:94
Dune::GridGlue::Extractor::VertexInfo
simple struct holding a vertex pointer and an index
Definition extractor.hh:116
Dune::GridGlue::Extractor::ElementInfo
simple struct holding an element seed and an index
Definition extractor.hh:128
Dune::GridGlue::Extractor::SubEntityInfo
Holds some information about an element's subentity involved in a coupling.
Definition extractor.hh:147