// -*- 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 .
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::EclCpGridVanguard
*/
#ifndef EWOMS_ECL_CP_GRID_VANGUARD_HH
#define EWOMS_ECL_CP_GRID_VANGUARD_HH
#include
#include
#include "eclbasevanguard.hh"
#include "ecltransmissibility.hh"
#include "femcpgridcompat.hh"
#include "eclgenericcpgridvanguard.hh"
namespace Opm {
template
class EclCpGridVanguard;
}
namespace Opm::Properties {
namespace TTag {
struct EclCpGridVanguard {
using InheritsFrom = std::tuple;
};
}
// declare the properties
template
struct Vanguard {
using type = EclCpGridVanguard;
};
template
struct Grid {
using type = Dune::CpGrid;
};
template
struct EquilGrid {
using type = GetPropType;
};
} // namespace Opm::Properties
namespace Opm {
/*!
* \ingroup EclBlackOilSimulator
*
* \brief Helper class for grid instantiation of ECL file-format using problems.
*
* This class uses Dune::CpGrid as the simulation grid.
*/
template
class EclCpGridVanguard : public EclBaseVanguard
, public EclGenericCpGridVanguard,
GetPropType,
GetPropType>
{
friend class EclBaseVanguard;
using ParentType = EclBaseVanguard;
using Scalar = GetPropType;
using Simulator = GetPropType;
using ElementMapper = GetPropType;
public:
using Grid = GetPropType;
using CartesianIndexMapper = Dune::CartesianIndexMapper;
using EquilGrid = GetPropType;
using GridView = GetPropType;
using TransmissibilityType = EclTransmissibility;
static constexpr int dimensionworld = Grid::dimensionworld;
private:
using Element = typename GridView::template Codim<0>::Entity;
public:
EclCpGridVanguard(Simulator& simulator)
: EclBaseVanguard(simulator)
{
this->callImplementationInit();
}
/*!
* \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();
}
const TransmissibilityType& globalTransmissibility() const
{
assert( globalTrans_ != nullptr );
return *globalTrans_;
}
void releaseGlobalTransmissibility()
{
globalTrans_.reset();
}
/*!
* \brief Distribute the simulation grid over multiple processes
*
* (For parallel simulation runs.)
*/
void loadBalance()
{
#if HAVE_MPI
this->doLoadBalance_(this->edgeWeightsMethod(), this->ownersFirst(),
this->serialPartitioning(), this->enableDistributedWells(),
this->zoltanImbalanceTol(), this->gridView(),
this->schedule(), this->centroids_,
this->eclState(), this->parallelWells_, this->numJacobiBlocks());
#endif
this->updateGridView_();
this->updateCartesianToCompressedMapping_();
this->updateCellDepths_();
this->updateCellThickness_();
#if HAVE_MPI
this->distributeFieldProps_(this->eclState());
#endif
}
unsigned int gridEquilIdxToGridIdx(unsigned int elemIndex) const {
return elemIndex;
}
unsigned int gridIdxToEquilGridIdx(unsigned int elemIndex) const {
return elemIndex;
}
/*!
* \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(int)>
cellCentroids() const
{
return this->cellCentroids_(this->cartesianIndexMapper());
}
const std::vector& globalCell()
{
return this->grid().globalCell();
}
protected:
void createGrids_()
{
this->doCreateGrids_(this->eclState());
}
void allocTrans() override
{
OPM_TIMEBLOCK(allocateTrans);
globalTrans_.reset(new TransmissibilityType(this->eclState(),
this->gridView(),
this->cartesianIndexMapper(),
this->grid(),
this->cellCentroids(),
getPropValue(),
getPropValue()));
globalTrans_->update(false);
}
double getTransmissibility(unsigned I, unsigned J) const override
{
return globalTrans_->transmissibility(I,J);
}
#if HAVE_MPI
const std::string& zoltanParams() const override
{
return this->zoltanParams_;
}
#endif
// removing some connection located in inactive grid cells
void filterConnections_()
{
this->doFilterConnections_(this->schedule());
}
std::unique_ptr globalTrans_;
};
} // namespace Opm
#endif