Loading...
Searching...
No Matches
AluGridVanguard.hpp
Go to the documentation of this file.
// -*- 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_VANGUARD_HPP
#define OPM_ALUGRID_VANGUARD_HPP
#include <dune/alugrid/common/fromtogridfactory.hh>
#include <dune/alugrid/dgf.hh>
#include <dune/alugrid/grid.hh>
#include <opm/common/OpmLog/OpmLog.hpp>
#include <opm/grid/CpGrid.hpp>
#include <opm/grid/cpgrid/LevelCartesianIndexMapper.hpp>
#include <opm/models/common/multiphasebaseproperties.hh>
#include <opm/simulators/flow/AluGridCartesianIndexMapper.hpp>
#include <opm/simulators/flow/AluGridLevelCartesianIndexMapper.hpp>
#include <opm/simulators/flow/FlowBaseVanguard.hpp>
#include <opm/simulators/flow/Transmissibility.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<FlowBaseVanguard>;
};
}
// 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 {
template <class TypeTag>
class AluGridVanguard : public FlowBaseVanguard<TypeTag>
{
friend class FlowBaseVanguard<TypeTag>;
using ParentType = FlowBaseVanguard<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 LevelCartesianIndexMapper = Opm::LevelCartesianIndexMapper<Grid>;
using EquilCartesianIndexMapper = Dune::CartesianIndexMapper<EquilGrid>;
using TransmissibilityType = Transmissibility<Grid, GridView, ElementMapper, CartesianIndexMapper, Scalar>;
using Factory = Dune::FromToGridFactory<Grid>;
static constexpr int dimension = Grid::dimension;
static constexpr int dimensionworld = Grid::dimensionworld;
explicit AluGridVanguard(Simulator& simulator)
: FlowBaseVanguard<TypeTag>(simulator)
{
this->mpiRank = FlowGenericVanguard::comm().rank();
this->callImplementationInit();
}
Grid& grid()
{ return *grid_; }
const Grid& grid() const
{ return *grid_; }
const EquilGrid& equilGrid() const
{ return *equilGrid_; }
void releaseEquilGrid()
{
delete equilCartesianIndexMapper_;
equilCartesianIndexMapper_ = nullptr;
delete equilGrid_;
equilGrid_ = nullptr;
}
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, TransmissibilityType::TransUpdateQuantities::Trans,
[&](unsigned int i) { return gridEquilIdxToGridIdx(i);});
}
}
void addLgrs()
{
// do nothing: AluGrid with LGRs not supported yet!
}
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
}
void releaseGlobalTransmissibilities()
{
globalTrans_.reset();
}
const CartesianIndexMapper& cartesianIndexMapper() const
{ return *cartesianIndexMapper_; }
const LevelCartesianIndexMapper levelCartesianIndexMapper() const
{ return LevelCartesianIndexMapper(*cartesianIndexMapper_); }
const EquilCartesianIndexMapper& equilCartesianIndexMapper() const
{ return *equilCartesianIndexMapper_; }
std::function<std::array<double,dimensionworld>(int)>
cellCentroids() const
{
return this->cellCentroids_(this->cartesianIndexMapper(), false);
}
const TransmissibilityType& globalTransmissibility() const
{
assert( globalTrans_ != nullptr );
return *globalTrans_;
}
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>(FlowGenericVanguard::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 (SFC) ordering is enabled: see flow_blackoil_alugrid for more informations on disabling/enabling SFC reordering");
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_;
// \Note: this globalTrans_ is used for domain decomposition and INIT file output.
// It only contains trans_ due to permeability and does not contain thermalHalfTrans_,
// diffusivity_ abd dispersivity_. The main reason is to reduce the memory usage for rank 0
// during parallel running.
std::unique_ptr<TransmissibilityType> globalTrans_;
int mpiRank;
};
} // namespace Opm
#endif // OPM_ALUGRID_VANGUARD_HPP
FlowBaseVanguard.hpp
Helper class for grid instantiation of ECL file-format using problems.
Transmissibility.hpp
Dune::CartesianIndexMapper
Definition CollectDataOnIORank.hpp:49
Opm::AluGridVanguard
Helper class for grid instantiation of ECL file-format using problems.
Definition AluGridVanguard.hpp:98
Opm::AluGridVanguard::loadBalance
void loadBalance()
Distribute the simulation grid over multiple processes.
Definition AluGridVanguard.hpp:171
Opm::AluGridVanguard::cartesianIndexMapper
const CartesianIndexMapper & cartesianIndexMapper() const
Returns the object which maps a global element index of the simulation grid to the corresponding elem...
Definition AluGridVanguard.hpp:240
Opm::AluGridVanguard::levelCartesianIndexMapper
const LevelCartesianIndexMapper levelCartesianIndexMapper() const
Returns the object which maps a global element index of the simulation grid to the corresponding elem...
Definition AluGridVanguard.hpp:248
Opm::AluGridVanguard::cellCentroids
std::function< std::array< double, dimensionworld >(int)> cellCentroids() const
Get function to query cell centroids for a distributed grid.
Definition AluGridVanguard.hpp:265
Opm::AluGridVanguard::releaseGlobalTransmissibilities
void releaseGlobalTransmissibilities()
Free the memory occupied by the global transmissibility object.
Definition AluGridVanguard.hpp:231
Opm::AluGridVanguard::grid
const Grid & grid() const
Return a reference to the simulation grid.
Definition AluGridVanguard.hpp:135
Opm::AluGridVanguard::equilCartesianIndexMapper
const EquilCartesianIndexMapper & equilCartesianIndexMapper() const
Returns mapper from compressed to cartesian indices for the EQUIL grid.
Definition AluGridVanguard.hpp:254
Opm::AluGridVanguard::grid
Grid & grid()
Return a reference to the simulation grid.
Definition AluGridVanguard.hpp:129
Opm::AluGridVanguard::equilGrid
const EquilGrid & equilGrid() const
Returns a refefence to the grid which should be used by the EQUIL initialization code.
Definition AluGridVanguard.hpp:147
Opm::AluGridVanguard::releaseEquilGrid
void releaseEquilGrid()
Indicates that the initial condition has been computed and the memory used by the EQUIL grid can be r...
Definition AluGridVanguard.hpp:157
Opm::BaseVanguard::addLgrs
void addLgrs()
Add LGRs to the grid, if any.
Definition basevanguard.hh:117
Opm::BaseVanguard::gridView
const GridView & gridView() const
Returns a reference to the grid view to be used.
Definition basevanguard.hh:70
Opm::FlowAluGridVanguard
Definition AluGridVanguard.hpp:55
Opm::FlowBaseVanguard::FlowBaseVanguard
FlowBaseVanguard(Simulator &simulator)
Create the grid for problem data files which use the ECL file format.
Definition FlowBaseVanguard.hpp:118
Opm::FlowBaseVanguard::cellCentroids_
std::function< std::array< double, dimensionworld >(int)> cellCentroids_(const CartMapper &cartMapper, const bool &isCpGrid) const
Get function to query cell centroids for a distributed grid.
Definition FlowBaseVanguard.hpp:302
Opm::FlowGenericVanguard::comm
static Parallel::Communication & comm()
Obtain global communicator.
Definition FlowGenericVanguard.hpp:336
Opm::FlowGenericVanguard::eclState
const EclipseState & eclState() const
Return a reference to the internalized ECL deck.
Definition FlowGenericVanguard.hpp:168
Opm::LevelCartesianIndexMapper
Definition RelpermDiagnostics.hpp:31
Opm::Transmissibility
Definition Transmissibility.hpp:54
multiphasebaseproperties.hh
Defines the common properties required by the porous medium multi-phase models.
Opm::Properties::TTag
The generic type tag for problems using the immiscible multi-phase model.
Definition blackoilmodel.hh:81
Opm
This file contains a set of helper functions used by VFPProd / VFPInj.
Definition blackoilbioeffectsmodules.hh:43
Opm::GetPropType
typename Properties::Detail::GetPropImpl< TypeTag, Property >::type::type GetPropType
get the type alias defined in the property (equivalent to old macro GET_PROP_TYPE(....
Definition propertysystem.hh:233
Opm::getPropValue
constexpr auto getPropValue()
get the value data member of a property
Definition propertysystem.hh:240
Opm::Properties::EnableDiffusion
Enable diffusive fluxes?
Definition multiphasebaseproperties.hh:91
Opm::Properties::EnableDispersion
Enable dispersive fluxes?
Definition multiphasebaseproperties.hh:95
Opm::Properties::EnableEnergy
Specify whether energy should be considered as a conservation quantity or not.
Definition multiphasebaseproperties.hh:87
Opm::Properties::EquilGrid
Definition FlowBaseVanguard.hpp:70
Opm::Properties::Grid
The type of the DUNE grid.
Definition basicproperties.hh:100
Opm::Properties::TTag::AluGridVanguard
Definition AluGridVanguard.hpp:62
Opm::Properties::Vanguard
Property which provides a Vanguard (manages grids).
Definition basicproperties.hh:96