mirror of
https://github.com/OPM/opm-simulators.git
synced 2025-02-25 18:55:30 -06:00
Merge pull request #5175 from akva2/move_alugrid
Move AluGrid files from ebos to opm/simulators/flow
This commit is contained in:
Kai Bao
GitHub
274
opm/simulators/flow/AluGridCartesianIndexMapper.hpp
Normal file
274
opm/simulators/flow/AluGridCartesianIndexMapper.hpp
Normal file
@@ -0,0 +1,274 @@
|
||||
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
// vi: set et ts=4 sw=4 sts=4:
|
||||
/*
|
||||
This file is part of the Open Porous Media project (OPM).
|
||||
|
||||
OPM is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OPM is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Consult the COPYING file in the top-level source directory of this
|
||||
module for the precise wording of the license and the list of
|
||||
copyright holders.
|
||||
*/
|
||||
|
||||
#ifndef OPM_ALUGRID_CARTESIAN_INDEX_MAPPER_HPP
|
||||
#define OPM_ALUGRID_CARTESIAN_INDEX_MAPPER_HPP
|
||||
|
||||
#include <dune/alugrid/grid.hh>
|
||||
#include <dune/alugrid/3d/gridview.hh>
|
||||
#include <opm/grid/common/CartesianIndexMapper.hpp>
|
||||
#include <dune/grid/common/datahandleif.hh>
|
||||
#include <dune/grid/utility/persistentcontainer.hh>
|
||||
|
||||
#include <array>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <memory>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
|
||||
namespace Dune {
|
||||
|
||||
/*!
|
||||
* \brief Interface class to access the logical Cartesian grid as used in industry
|
||||
* standard simulator decks.
|
||||
*/
|
||||
//#if HAVE_MPI
|
||||
template <>
|
||||
class CartesianIndexMapper<Dune::ALUGrid<3, 3, Dune::cube, Dune::nonconforming>>
|
||||
{
|
||||
public:
|
||||
|
||||
#if HAVE_MPI
|
||||
using Grid = Dune::ALUGrid<3, 3, Dune::cube, Dune::nonconforming, Dune::ALUGridMPIComm>;
|
||||
#else
|
||||
using Grid = Dune::ALUGrid<3, 3, Dune::cube, Dune::nonconforming, Dune::ALUGridNoComm>;
|
||||
#endif //HAVE_MPI
|
||||
|
||||
// data handle for communicating global ids during load balance and communication
|
||||
template <class GridView>
|
||||
class GlobalIndexDataHandle : public Dune::CommDataHandleIF<GlobalIndexDataHandle<GridView>, int>
|
||||
{
|
||||
// global id
|
||||
class GlobalCellIndex
|
||||
{
|
||||
public:
|
||||
GlobalCellIndex()
|
||||
: idx_(-1)
|
||||
{}
|
||||
|
||||
GlobalCellIndex& operator=(const int index)
|
||||
{
|
||||
idx_ = index;
|
||||
return *this;
|
||||
}
|
||||
|
||||
int index() const
|
||||
{ return idx_; }
|
||||
|
||||
private:
|
||||
int idx_;
|
||||
};
|
||||
|
||||
using GlobalIndexContainer = typename Dune::PersistentContainer<Grid, GlobalCellIndex>;
|
||||
|
||||
public:
|
||||
// constructor copying cartesian index to persistent container
|
||||
GlobalIndexDataHandle(const GridView& gridView,
|
||||
std::vector<int>& cartesianIndex)
|
||||
: gridView_(gridView)
|
||||
, globalIndex_(gridView.grid(), 0)
|
||||
, cartesianIndex_(cartesianIndex)
|
||||
{
|
||||
globalIndex_.resize();
|
||||
initialize();
|
||||
}
|
||||
|
||||
// constructor copying cartesian index to persistent container
|
||||
GlobalIndexDataHandle(const GlobalIndexDataHandle& other) = delete ;
|
||||
|
||||
// destrcutor writing load balanced cartesian index back to vector
|
||||
~GlobalIndexDataHandle()
|
||||
{ finalize(); }
|
||||
|
||||
bool contains(int /* dim */, int codim) const
|
||||
{ return codim == 0; }
|
||||
|
||||
bool fixedsize(int /* dim */, int /* codim */) const
|
||||
{ return true; }
|
||||
|
||||
//! \brief loop over all internal data handlers and call gather for
|
||||
//! given entity
|
||||
template<class MessageBufferImp, class EntityType>
|
||||
void gather(MessageBufferImp& buff, const EntityType& element) const
|
||||
{
|
||||
int globalIdx = globalIndex_[element].index();
|
||||
buff.write(globalIdx);
|
||||
}
|
||||
|
||||
//! \brief loop over all internal data handlers and call scatter for
|
||||
//! given entity
|
||||
template<class MessageBufferImp, class EntityType>
|
||||
void scatter(MessageBufferImp& buff, const EntityType& element, std::size_t /* n */)
|
||||
{
|
||||
int globalIdx = -1;
|
||||
buff.read(globalIdx);
|
||||
if (globalIdx >= 0)
|
||||
{
|
||||
globalIndex_.resize();
|
||||
globalIndex_[element] = globalIdx;
|
||||
}
|
||||
}
|
||||
|
||||
//! \brief loop over all internal data handlers and return sum of data
|
||||
//! size of given entity
|
||||
template<class EntityType>
|
||||
std::size_t size(const EntityType& /* en */) const
|
||||
{ return 1; }
|
||||
|
||||
protected:
|
||||
// initialize persistent container from given vector
|
||||
void initialize()
|
||||
{
|
||||
auto idx = cartesianIndex_.begin();
|
||||
auto it = gridView_.template begin<0>();
|
||||
const auto& endIt = gridView_.template end<0>();
|
||||
|
||||
for (; it != endIt; ++it, ++idx)
|
||||
globalIndex_[*it] = *idx;
|
||||
}
|
||||
|
||||
// update vector from given persistent container
|
||||
void finalize()
|
||||
{
|
||||
std::vector<int> newIndex ;
|
||||
newIndex.reserve(gridView_.indexSet().size(0));
|
||||
|
||||
auto it = gridView_.template begin<0>();
|
||||
const auto& endIt = gridView_.template end<0>();
|
||||
for (; it != endIt; ++it)
|
||||
newIndex.push_back(globalIndex_[*it].index()) ;
|
||||
|
||||
cartesianIndex_.swap(newIndex);
|
||||
}
|
||||
|
||||
GridView gridView_;
|
||||
GlobalIndexContainer globalIndex_;
|
||||
std::vector<int>& cartesianIndex_;
|
||||
};
|
||||
|
||||
public:
|
||||
/** \brief dimension of the grid */
|
||||
static constexpr int dimension = Grid::dimension ;
|
||||
|
||||
/** \brief constructor taking grid */
|
||||
CartesianIndexMapper(const Grid& grid,
|
||||
const std::array<int, dimension>& cartDims,
|
||||
const std::vector<int>& cartesianIndex)
|
||||
: grid_(grid)
|
||||
, cartesianDimensions_(cartDims)
|
||||
, cartesianIndex_(cartesianIndex)
|
||||
, cartesianSize_(computeCartesianSize())
|
||||
{}
|
||||
|
||||
/** \brief return Cartesian dimensions, i.e. number of cells in each direction */
|
||||
const std::array<int, dimension>& cartesianDimensions() const
|
||||
{ return cartesianDimensions_; }
|
||||
|
||||
/** \brief return total number of cells in the logical Cartesian grid */
|
||||
int cartesianSize() const
|
||||
{ return cartesianSize_; }
|
||||
|
||||
/** \brief return number of cells in the active grid */
|
||||
int compressedSize() const
|
||||
{ return cartesianIndex_.size(); }
|
||||
|
||||
/** \brief return number of cells in the active grid. Only for unifying calls with CpGrid and PolyhedralGrid specializations. */
|
||||
int compressedLevelZeroSize() const
|
||||
{ return cartesianIndex_.size(); }
|
||||
|
||||
/** \brief return index of the cells in the logical Cartesian grid */
|
||||
int cartesianIndex(const int compressedElementIndex) const
|
||||
{
|
||||
assert(compressedElementIndex < compressedSize());
|
||||
return cartesianIndex_[compressedElementIndex];
|
||||
}
|
||||
|
||||
/** \brief return index of the cells in the logical Cartesian grid */
|
||||
int cartesianIndex(const std::array<int, dimension>& coords) const
|
||||
{
|
||||
int cartIndex = coords[0];
|
||||
int factor = cartesianDimensions()[0];
|
||||
for (int i=1; i < dimension; ++i) {
|
||||
cartIndex += coords[i] * factor;
|
||||
factor *= cartesianDimensions()[i];
|
||||
}
|
||||
|
||||
return cartIndex;
|
||||
}
|
||||
|
||||
/** \brief return Cartesian coordinate, i.e. IJK, for a given cell */
|
||||
void cartesianCoordinate(const int compressedElementIndex, std::array<int, dimension>& coords) const
|
||||
{
|
||||
int gc = cartesianIndex(compressedElementIndex);
|
||||
if constexpr (dimension == 3) {
|
||||
coords[0] = gc % cartesianDimensions()[0];
|
||||
gc /= cartesianDimensions()[0];
|
||||
coords[1] = gc % cartesianDimensions()[1];
|
||||
coords[2] = gc / cartesianDimensions()[1];
|
||||
}
|
||||
else if constexpr (dimension == 2) {
|
||||
coords[0] = gc % cartesianDimensions()[0];
|
||||
coords[1] = gc / cartesianDimensions()[0];
|
||||
}
|
||||
else if constexpr (dimension == 1)
|
||||
coords[0] = gc ;
|
||||
else
|
||||
throw std::invalid_argument("cartesianCoordinate not implemented for dimension " + std::to_string(dimension));
|
||||
}
|
||||
|
||||
/** \brief Only for unifying calls with CartesianIndexMapper<CpGrid> where levels are relevant */
|
||||
void cartesianCoordinateLevel(const int compressedElementIndex, std::array<int, dimension>& coords, int level) const
|
||||
{
|
||||
if (level) {
|
||||
throw std::invalid_argument("Invalid level.\n");
|
||||
}
|
||||
cartesianCoordinate(compressedElementIndex, coords);
|
||||
}
|
||||
|
||||
template <class GridView>
|
||||
std::unique_ptr<GlobalIndexDataHandle<GridView> > dataHandle(const GridView& gridView)
|
||||
{
|
||||
using DataHandle = GlobalIndexDataHandle<GridView>;
|
||||
assert(&grid_ == &gridView.grid());
|
||||
return std::make_unique<DataHandle>(gridView, cartesianIndex_);
|
||||
}
|
||||
|
||||
protected:
|
||||
int computeCartesianSize() const
|
||||
{
|
||||
int size = cartesianDimensions()[0];
|
||||
for (int d=1; d<dimension; ++d)
|
||||
size *= cartesianDimensions()[d];
|
||||
return size ;
|
||||
}
|
||||
|
||||
const Grid& grid_;
|
||||
const std::array<int, dimension> cartesianDimensions_;
|
||||
std::vector<int> cartesianIndex_;
|
||||
const int cartesianSize_ ;
|
||||
};
|
||||
|
||||
} // end namespace Dune
|
||||
|
||||
#endif // OPM_ALUGRID_CARTESIAN_INDEX_MAPPER_HPP
|
||||
366
opm/simulators/flow/AluGridVanguard.hpp
Normal file
366
opm/simulators/flow/AluGridVanguard.hpp
Normal file
@@ -0,0 +1,366 @@
|
||||
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||||
// vi: set et ts=4 sw=4 sts=4:
|
||||
/*
|
||||
This file is part of the Open Porous Media project (OPM).
|
||||
|
||||
OPM is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
OPM is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Consult the COPYING file in the top-level source directory of this
|
||||
module for the precise wording of the license and the list of
|
||||
copyright holders.
|
||||
*/
|
||||
/*!
|
||||
* \file
|
||||
* \copydoc Opm::AluGridVanguard
|
||||
*/
|
||||
#ifndef OPM_ALUGRID_VANGUARD_HPP
|
||||
#define OPM_ALUGRID_VANGUARD_HPP
|
||||
|
||||
#include <dune/alugrid/common/fromtogridfactory.hh>
|
||||
#include <dune/alugrid/dgf.hh>
|
||||
#include <dune/alugrid/grid.hh>
|
||||
|
||||
#include <ebos/eclbasevanguard.hh>
|
||||
#include <ebos/ecltransmissibility.hh>
|
||||
|
||||
#include <opm/common/OpmLog/OpmLog.hpp>
|
||||
|
||||
#include <opm/grid/CpGrid.hpp>
|
||||
|
||||
#include <opm/models/common/multiphasebaseproperties.hh>
|
||||
|
||||
#include <opm/simulators/flow/AluGridCartesianIndexMapper.hpp>
|
||||
#include <opm/simulators/utils/ParallelEclipseState.hpp>
|
||||
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <memory>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
|
||||
namespace Opm {
|
||||
template <class TypeTag>
|
||||
class FlowAluGridVanguard;
|
||||
|
||||
} // namespace Opm
|
||||
|
||||
namespace Opm::Properties {
|
||||
|
||||
namespace TTag {
|
||||
struct AluGridVanguard {
|
||||
using InheritsFrom = std::tuple<EclBaseVanguard>;
|
||||
};
|
||||
}
|
||||
|
||||
// declare the properties
|
||||
template<class TypeTag>
|
||||
struct Vanguard<TypeTag, TTag::AluGridVanguard> {
|
||||
using type = Opm::FlowAluGridVanguard<TypeTag>;
|
||||
};
|
||||
template<class TypeTag>
|
||||
struct Grid<TypeTag, TTag::AluGridVanguard> {
|
||||
#if HAVE_MPI
|
||||
using type = Dune::ALUGrid<3, 3, Dune::cube, Dune::nonconforming, Dune::ALUGridMPIComm>;
|
||||
#else
|
||||
using type = Dune::ALUGrid<3, 3, Dune::cube, Dune::nonconforming, Dune::ALUGridNoComm>;
|
||||
#endif //HAVE_MPI
|
||||
};
|
||||
template<class TypeTag>
|
||||
struct EquilGrid<TypeTag, TTag::AluGridVanguard> {
|
||||
using type = Dune::CpGrid;
|
||||
};
|
||||
|
||||
} // namespace Opm::Properties
|
||||
|
||||
namespace Opm {
|
||||
|
||||
/*!
|
||||
* \ingroup EclBlackOilSimulator
|
||||
*
|
||||
* \brief Helper class for grid instantiation of ECL file-format using problems.
|
||||
*
|
||||
* This class uses Dune::ALUGrid as the simulation grid.
|
||||
*/
|
||||
template <class TypeTag>
|
||||
class AluGridVanguard : public EclBaseVanguard<TypeTag>
|
||||
{
|
||||
friend class EclBaseVanguard<TypeTag>;
|
||||
using ParentType = EclBaseVanguard<TypeTag>;
|
||||
|
||||
using ElementMapper = GetPropType<TypeTag, Properties::ElementMapper>;
|
||||
using Scalar = GetPropType<TypeTag, Properties::Scalar>;
|
||||
using Simulator = GetPropType<TypeTag, Properties::Simulator>;
|
||||
|
||||
public:
|
||||
using Grid = GetPropType<TypeTag, Properties::Grid>;
|
||||
using EquilGrid = GetPropType<TypeTag, Properties::EquilGrid>;
|
||||
using GridView = GetPropType<TypeTag, Properties::GridView>;
|
||||
using CartesianIndexMapper = Dune::CartesianIndexMapper<Grid>;
|
||||
using EquilCartesianIndexMapper = Dune::CartesianIndexMapper<EquilGrid>;
|
||||
using TransmissibilityType = EclTransmissibility<Grid, GridView, ElementMapper, CartesianIndexMapper, Scalar>;
|
||||
using Factory = Dune::FromToGridFactory<Grid>;
|
||||
|
||||
static constexpr int dimension = Grid::dimension;
|
||||
static constexpr int dimensionworld = Grid::dimensionworld;
|
||||
|
||||
AluGridVanguard(Simulator& simulator)
|
||||
: EclBaseVanguard<TypeTag>(simulator)
|
||||
{
|
||||
this->mpiRank = EclGenericVanguard::comm().rank();
|
||||
this->callImplementationInit();
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Return a reference to the simulation grid.
|
||||
*/
|
||||
Grid& grid()
|
||||
{ return *grid_; }
|
||||
|
||||
/*!
|
||||
* \brief Return a reference to the simulation grid.
|
||||
*/
|
||||
const Grid& grid() const
|
||||
{ return *grid_; }
|
||||
|
||||
/*!
|
||||
* \brief Returns a refefence to the grid which should be used by the EQUIL
|
||||
* initialization code.
|
||||
*
|
||||
* The EQUIL keyword is used to specify the initial condition of the reservoir in
|
||||
* hydrostatic equilibrium. Since the code which does this is not accepting arbitrary
|
||||
* DUNE grids (the code is part of the opm-core module), this is not necessarily the
|
||||
* same as the grid which is used for the actual simulation.
|
||||
*/
|
||||
const EquilGrid& equilGrid() const
|
||||
{ return *equilGrid_; }
|
||||
|
||||
/*!
|
||||
* \brief Indicates that the initial condition has been computed and the memory used
|
||||
* by the EQUIL grid can be released.
|
||||
*
|
||||
* Depending on the implementation, subsequent accesses to the EQUIL grid lead to
|
||||
* crashes.
|
||||
*/
|
||||
void releaseEquilGrid()
|
||||
{
|
||||
delete equilCartesianIndexMapper_;
|
||||
equilCartesianIndexMapper_ = nullptr;
|
||||
|
||||
delete equilGrid_;
|
||||
equilGrid_ = nullptr;
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Distribute the simulation grid over multiple processes
|
||||
*
|
||||
* (For parallel simulation runs.)
|
||||
*/
|
||||
void loadBalance()
|
||||
{
|
||||
auto gridView = grid().leafGridView();
|
||||
auto dataHandle = cartesianIndexMapper_->dataHandle(gridView);
|
||||
grid().loadBalance(*dataHandle);
|
||||
|
||||
// communicate non-interior cells values
|
||||
grid().communicate(*dataHandle,
|
||||
Dune::InteriorBorder_All_Interface,
|
||||
Dune::ForwardCommunication );
|
||||
|
||||
if (grid().size(0))
|
||||
{
|
||||
globalTrans_ = std::make_unique<TransmissibilityType>(this->eclState(),
|
||||
this->gridView(),
|
||||
this->cartesianIndexMapper(),
|
||||
this->grid(),
|
||||
this->cellCentroids(),
|
||||
getPropValue<TypeTag,
|
||||
Properties::EnableEnergy>(),
|
||||
getPropValue<TypeTag,
|
||||
Properties::EnableDiffusion>(),
|
||||
getPropValue<TypeTag,
|
||||
Properties::EnableDispersion>());
|
||||
// Re-ordering for ALUGrid
|
||||
globalTrans_->update(false, [&](unsigned int i) { return gridEquilIdxToGridIdx(i);});
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
template<class DataHandle>
|
||||
void scatterData(DataHandle& /*handle*/) const
|
||||
{
|
||||
// not existing for this type of grid yet
|
||||
}
|
||||
|
||||
template<class DataHandle>
|
||||
void gatherData(DataHandle& /*handle*/) const
|
||||
{
|
||||
// not existing for this type of grid yet
|
||||
}
|
||||
|
||||
template<class DataHandle, class InterfaceType, class CommunicationDirection>
|
||||
void communicate (DataHandle& /*data*/, InterfaceType /*iftype*/,
|
||||
CommunicationDirection /*dir*/) const
|
||||
{
|
||||
// not existing for this type of grid yet
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Free the memory occupied by the global transmissibility object.
|
||||
*
|
||||
* After writing the initial solution, this array should not be necessary anymore.
|
||||
*/
|
||||
void releaseGlobalTransmissibilities()
|
||||
{
|
||||
globalTrans_.reset();
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Returns the object which maps a global element index of the simulation grid
|
||||
* to the corresponding element index of the logically Cartesian index.
|
||||
*/
|
||||
const CartesianIndexMapper& cartesianIndexMapper() const
|
||||
{ return *cartesianIndexMapper_; }
|
||||
|
||||
/*!
|
||||
* \brief Returns mapper from compressed to cartesian indices for the EQUIL grid
|
||||
*/
|
||||
const EquilCartesianIndexMapper& equilCartesianIndexMapper() const
|
||||
{ return *equilCartesianIndexMapper_; }
|
||||
|
||||
/*!
|
||||
* \brief Get function to query cell centroids for a distributed grid.
|
||||
*
|
||||
* Currently this only non-empty for a loadbalanced CpGrid.
|
||||
* It is a function return the centroid for the given element
|
||||
* index.
|
||||
*/
|
||||
std::function<std::array<double,dimensionworld>(int)>
|
||||
cellCentroids() const
|
||||
{
|
||||
return this->cellCentroids_(this->cartesianIndexMapper(), false);
|
||||
}
|
||||
|
||||
const TransmissibilityType& globalTransmissibility() const
|
||||
{
|
||||
assert( globalTrans_ != nullptr );
|
||||
return *globalTrans_;
|
||||
}
|
||||
|
||||
void releaseGlobalTransmissibility()
|
||||
{
|
||||
globalTrans_.reset();
|
||||
}
|
||||
|
||||
const std::vector<int>& globalCell()
|
||||
{
|
||||
return cartesianCellId_;
|
||||
}
|
||||
|
||||
std::vector<int> cellPartition() const
|
||||
{
|
||||
// not required for this type of grid yet
|
||||
return {};
|
||||
}
|
||||
|
||||
unsigned int gridEquilIdxToGridIdx(unsigned int elemIndex) const {
|
||||
return equilGridToGrid_[elemIndex];
|
||||
}
|
||||
|
||||
unsigned int gridIdxToEquilGridIdx(unsigned int elemIndex) const {
|
||||
return ordering_[elemIndex];
|
||||
}
|
||||
|
||||
protected:
|
||||
void createGrids_()
|
||||
{
|
||||
// we use separate grid objects: one for the calculation of the initial condition
|
||||
// via EQUIL and one for the actual simulation. The reason is that the EQUIL code
|
||||
// cannot cope with arbitrary Dune grids and is also allergic to distributed
|
||||
// grids.
|
||||
|
||||
/////
|
||||
// create the EQUIL grid
|
||||
/////
|
||||
const EclipseGrid* input_grid = nullptr;
|
||||
std::vector<double> global_porv;
|
||||
// At this stage the ParallelEclipseState instance is still in global
|
||||
// view; on rank 0 we have undistributed data for the entire grid, on
|
||||
// the other ranks the EclipseState is empty.
|
||||
if (mpiRank == 0) {
|
||||
// Processing grid
|
||||
input_grid = &this->eclState().getInputGrid();
|
||||
global_porv = this->eclState().fieldProps().porv(true);
|
||||
OpmLog::info("\nProcessing grid");
|
||||
}
|
||||
|
||||
#if HAVE_MPI
|
||||
this->equilGrid_ = std::make_unique<Dune::CpGrid>(EclGenericVanguard::comm());
|
||||
#else
|
||||
this->equilGrid_ = std::make_unique<Dune::CpGrid>();
|
||||
#endif
|
||||
// Note: removed_cells is guaranteed to be empty on ranks other than 0.
|
||||
auto removed_cells =
|
||||
this->equilGrid_->processEclipseFormat(input_grid,
|
||||
&this->eclState(),
|
||||
/*isPeriodic=*/false,
|
||||
/*flipNormals=*/false,
|
||||
/*clipZ=*/false);
|
||||
|
||||
cartesianCellId_ = this->equilGrid_->globalCell();
|
||||
|
||||
for (unsigned i = 0; i < dimension; ++i)
|
||||
cartesianDimension_[i] = this->equilGrid_->logicalCartesianSize()[i];
|
||||
|
||||
equilCartesianIndexMapper_ = std::make_unique<EquilCartesianIndexMapper>(*equilGrid_);
|
||||
|
||||
/////
|
||||
// create the simulation grid
|
||||
/////
|
||||
|
||||
factory_ = std::make_unique<Factory>();
|
||||
grid_ = factory_->convert(*equilGrid_, cartesianCellId_, ordering_);
|
||||
OpmLog::warning("Space Filling Curve Ordering is not yet supported: DISABLE_ALUGRID_SFC_ORDERING is enabled");
|
||||
equilGridToGrid_.resize(ordering_.size());
|
||||
for (std::size_t index = 0; index < ordering_.size(); ++index) {
|
||||
equilGridToGrid_[ordering_[index]] = index;
|
||||
}
|
||||
|
||||
cartesianIndexMapper_ = std::make_unique<CartesianIndexMapper>(*grid_, cartesianDimension_, cartesianCellId_);
|
||||
this->updateGridView_();
|
||||
this->updateCartesianToCompressedMapping_();
|
||||
this->updateCellDepths_();
|
||||
this->updateCellThickness_();
|
||||
}
|
||||
|
||||
void filterConnections_()
|
||||
{
|
||||
// not handling the removal of completions for this type of grid yet.
|
||||
}
|
||||
|
||||
std::unique_ptr<Grid> grid_;
|
||||
std::unique_ptr<EquilGrid> equilGrid_;
|
||||
std::vector<int> cartesianCellId_;
|
||||
std::vector<unsigned int> ordering_;
|
||||
std::vector<unsigned int> equilGridToGrid_;
|
||||
std::array<int,dimension> cartesianDimension_;
|
||||
std::unique_ptr<CartesianIndexMapper> cartesianIndexMapper_;
|
||||
std::unique_ptr<EquilCartesianIndexMapper> equilCartesianIndexMapper_;
|
||||
std::unique_ptr<Factory> factory_;
|
||||
std::unique_ptr<TransmissibilityType> globalTrans_;
|
||||
int mpiRank;
|
||||
};
|
||||
|
||||
} // namespace Opm
|
||||
|
||||
#endif // OPM_ALUGRID_VANGUARD_HPP
|
||||
@@ -38,13 +38,6 @@
|
||||
#include <opm/simulators/linalg/bda/WellContributions.hpp>
|
||||
#endif
|
||||
|
||||
#if HAVE_DUNE_ALUGRID
|
||||
#include <dune/alugrid/grid.hh>
|
||||
#include <ebos/alucartesianindexmapper.hh>
|
||||
#endif // HAVE_DUNE_ALUGRID
|
||||
|
||||
#include <opm/grid/polyhedralgrid.hh>
|
||||
|
||||
namespace Opm {
|
||||
namespace detail {
|
||||
|
||||
|
||||
@@ -38,7 +38,7 @@
|
||||
|
||||
#if HAVE_DUNE_ALUGRID
|
||||
#include <dune/alugrid/grid.hh>
|
||||
#include <ebos/alucartesianindexmapper.hh>
|
||||
#include <opm/simulators/flow/AluGridCartesianIndexMapper.hpp>
|
||||
#endif // HAVE_DUNE_ALUGRID
|
||||
|
||||
#include <opm/grid/polyhedralgrid.hh>
|
||||
|
||||
Reference in New Issue
Block a user