OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-11-25 18:50:19 -06:00
Code Issues Packages Projects Releases Wiki Activity
8c6e6dc410
opm-simulators/ebos/eclbasegridmanager.hh

264 lines
8.4 KiB
C++
Raw Normal View History

ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
// -*- 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/>.
clean up the licensing preable of source files the in-file lists of authors has been removed in favor of a global list of authors in the LICENSE file. this is done because (a) maintaining a list of authors at the beginning of a file is a major pain in the a**, (b) the list of authors was not accurate in about 85% of all cases where more than one person was involved and (c) this list is not legally binding in any way (the copyright is at the person who authored a given change, if these lists had any legal relevance, one could "aquire" the copyright of the module by forking it and removing the lists...) the only exception of this is the eWoms fork of dune-istl's solvers.hh file. This is beneficial because the authors of that file do not appear in the global list. Further, carrying the fork of that file is required because we would like to use a reasonable convergence criterion for the linear solver. (the solvers from dune-istl do neither support user-defined convergence criteria not do the developers want support for it. (my patch was rejected a few years ago.))
2016-03-14 07:21:47 -05:00
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.
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
*/
/*!
* \file
* \copydoc Ewoms::EclBaseGridManager
*/
#ifndef EWOMS_ECL_BASE_GRID_MANAGER_HH
#define EWOMS_ECL_BASE_GRID_MANAGER_HH
#include <ewoms/io/basegridmanager.hh>
#include <ewoms/common/propertysystem.hh>
#include <ewoms/common/parametersystem.hh>
#include <opm/parser/eclipse/Parser/Parser.hpp>
rename ParseMode as ParseContext.
2016-03-16 20:08:50 -05:00
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/checkDeck.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <vector>
ebos: add the disabled well names kluge to the grid manager this array is only non-empty for parallel runs.
2016-12-06 12:39:06 -06:00
#include <unordered_set>
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
#include <array>
namespace Ewoms {
template <class TypeTag>
class EclBaseGridManager;
namespace Properties {
NEW_TYPE_TAG(EclBaseGridManager);
// declare the properties required by the for the ecl grid manager
NEW_PROP_TAG(Grid);
NEW_PROP_TAG(EquilGrid);
NEW_PROP_TAG(Scalar);
NEW_PROP_TAG(EclDeckFileName);
SET_STRING_PROP(EclBaseGridManager, EclDeckFileName, "ECLDECK.DATA");
} // namespace Properties
/*!
* \ingroup EclBlackOilSimulator
*
* \brief Helper class for grid instantiation of ECL file-format using problems.
*/
template <class TypeTag>
class EclBaseGridManager : public BaseGridManager<TypeTag>
{
typedef BaseGridManager<TypeTag> ParentType;
typedef typename GET_PROP_TYPE(TypeTag, GridManager) Implementation;
typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
typedef typename GET_PROP_TYPE(TypeTag, Simulator) Simulator;
public:
typedef typename GET_PROP_TYPE(TypeTag, Grid) Grid;
typedef typename GET_PROP_TYPE(TypeTag, GridView) GridView;
protected:
static const int dimension = Grid::dimension;
public:
/*!
* \brief Register all run-time parameters for the grid manager.
*/
static void registerParameters()
{
EWOMS_REGISTER_PARAM(TypeTag, std::string, EclDeckFileName,
"The name of the file which contains the ECL deck to be simulated");
}
/*!
* \brief Create the grid for problem data files which use the ECL file format.
*
* This is the file format used by the commercial ECLiPSE simulator. Usually it uses
* a cornerpoint description of the grid.
*/
fix most pedantic compiler warnings in the basic infrastructure i.e., using clang 3.8 to compile the test suite with the following flags: ``` -Weverything -Wno-documentation -Wno-documentation-unknown-command -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-undef -Wno-padded -Wno-global-constructors -Wno-exit-time-destructors -Wno-weak-vtables -Wno-float-equal ``` should not produce any warnings anymore. In my opinion the only flag which would produce beneficial warnings is -Wdocumentation. This has not been fixed in this patch because writing documentation is left for another day (or, more likely, year). note that this patch consists of a heavy dose of the OPM_UNUSED macro and plenty of static_casts (to fix signedness issues). Fixing the singedness issues were quite a nightmare and the fact that the Dune API is quite inconsistent in that regard was not exactly helpful. :/ Finally this patch includes quite a few formatting changes (e.g., all occurences of 'T &t' should be changed to `T& t`) and some fixes for minor issues which I've found during the excercise. I've made sure that all unit tests the test suite still pass successfully and I've made sure that flow_ebos still works for Norne and that it did not regress w.r.t. performance. (Note that this patch does not fix compiler warnings triggered `ebos` and `flow_ebos` but only those caused by the basic infrastructure or the unit tests.) v2: fix the warnings that occur if the dune-localfunctions module is not available. thanks to [at]atgeirr for testing. v3: fix dune 2.3 build issue
2016-11-07 08:14:07 -06:00
EclBaseGridManager(Simulator& simulator)
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
: ParentType(simulator)
{
ebos: notify the user about parallelism and Dune::CpGrid in a better way now, we abort at run time if the user tries to use with Dune::CpGrid in parallel simulations. The advantages are that during build there will be no warning anymore (before the warning was printed at compile time regardless of which grid was actually chosen), and that such simulations cannot be started with more than a single process (before they started just fine, but they did not work properly). This code should be removed as soon as "Dune::CpGrid" gets its act together and fixes the bug in the loadBalance() method.
2016-01-23 05:58:12 -06:00
int myRank = 0;
#if HAVE_MPI
MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
#endif
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
std::string fileName = EWOMS_GET_PARAM(TypeTag, std::string, EclDeckFileName);
// compute the base name of the input file name
const char directorySeparator = '/';
long int i;
for (i = fileName.size(); i >= 0; -- i)
if (fileName[i] == directorySeparator)
break;
std::string baseName = fileName.substr(i + 1, fileName.size());
// remove the extension from the input file
for (i = baseName.size(); i >= 0; -- i)
if (baseName[i] == '.')
break;
std::string rawCaseName;
if (i < 0)
rawCaseName = baseName;
else
rawCaseName = baseName.substr(0, i);
// transform the result to ALL_UPPERCASE
caseName_ = "";
for (size_t i = 0; i < rawCaseName.size(); ++i)
caseName_ += std::toupper(rawCaseName[i]);
ebos: notify the user about parallelism and Dune::CpGrid in a better way now, we abort at run time if the user tries to use with Dune::CpGrid in parallel simulations. The advantages are that during build there will be no warning anymore (before the warning was printed at compile time regardless of which grid was actually chosen), and that such simulations cannot be started with more than a single process (before they started just fine, but they did not work properly). This code should be removed as soon as "Dune::CpGrid" gets its act together and fixes the bug in the loadBalance() method.
2016-01-23 05:58:12 -06:00
if (myRank == 0)
std::cout << "Reading the deck file '" << fileName << "'" << std::endl;
Update to shared_ptr-less parser interface.
2016-10-14 06:18:56 -05:00
Opm::Parser parser;
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
typedef std::pair<std::string, Opm::InputError::Action> ParseModePair;
typedef std::vector<ParseModePair> ParseModePairs;
ParseModePairs tmp;
rename ParseMode as ParseContext.
2016-03-16 20:08:50 -05:00
tmp.push_back(ParseModePair(Opm::ParseContext::PARSE_RANDOM_SLASH , Opm::InputError::IGNORE));
Opm::ParseContext parseContext(tmp);
ebos: notify the user about parallelism and Dune::CpGrid in a better way now, we abort at run time if the user tries to use with Dune::CpGrid in parallel simulations. The advantages are that during build there will be no warning anymore (before the warning was printed at compile time regardless of which grid was actually chosen), and that such simulations cannot be started with more than a single process (before they started just fine, but they did not work properly). This code should be removed as soon as "Dune::CpGrid" gets its act together and fixes the bug in the loadBalance() method.
2016-01-23 05:58:12 -06:00
ebos: replace the opm-parser related pointers/smart pointers by references this seems to be the spirit of the season. note that now the deck object must be copied, but I suppose that copying it is pretty cheap.
2016-12-05 11:05:56 -06:00
deck_ = parser.parseFile(fileName , parseContext);
eclState_.reset(new Opm::EclipseState(deck_, parseContext));
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
asImp_().createGrids_();
asImp_().finalizeInit_();
}
/*!
* \brief Return a pointer to the parsed ECL deck
*/
ebos: replace the opm-parser related pointers/smart pointers by references this seems to be the spirit of the season. note that now the deck object must be copied, but I suppose that copying it is pretty cheap.
2016-12-05 11:05:56 -06:00
const Opm::Deck& deck() const
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
{ return deck_; }
ebos: replace the opm-parser related pointers/smart pointers by references this seems to be the spirit of the season. note that now the deck object must be copied, but I suppose that copying it is pretty cheap.
2016-12-05 11:05:56 -06:00
Opm::Deck& deck()
ebos: add accessor methods to the non-constant deck and eclipseState these are required by fun things like applyModifierDeck().
2016-08-08 08:47:41 -05:00
{ return deck_; }
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
/*!
* \brief Return a pointer to the internalized ECL deck
*/
ebos: replace the opm-parser related pointers/smart pointers by references this seems to be the spirit of the season. note that now the deck object must be copied, but I suppose that copying it is pretty cheap.
2016-12-05 11:05:56 -06:00
const Opm::EclipseState& eclState() const
{ return *eclState_; }
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
ebos: replace the opm-parser related pointers/smart pointers by references this seems to be the spirit of the season. note that now the deck object must be copied, but I suppose that copying it is pretty cheap.
2016-12-05 11:05:56 -06:00
Opm::EclipseState& eclState()
{ return *eclState_; }
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
/*!
* \brief Returns the name of the case.
*
* i.e., the all-uppercase version of the file name from which the
* deck is loaded with the ".DATA" suffix removed.
*/
const std::string& caseName() const
{ return caseName_; }
/*!
* \brief Returns the number of logically Cartesian cells in each direction
*/
const std::array<int, dimension>& cartesianDimensions() const
{ return asImp_().cartesianIndexMapper().cartesianDimensions(); }
/*!
* \brief Returns the overall number of cells of the logically Cartesian grid
*/
int cartesianSize() const
{ return asImp_().cartesianIndexMapper().cartesianSize(); }
EclEquil: use std::vector to store mappings.
2016-12-02 11:47:59 -06:00
/*!
* \brief Returns the overall number of cells of the logically EquilCartesian grid
*/
int equilCartesianSize() const
{ return asImp_().equilCartesianIndexMapper().cartesianSize(); }
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
/*!
* \brief Returns the Cartesian cell id for identifaction with ECL data
*/
unsigned cartesianIndex(unsigned compressedCellIdx) const
{ return asImp_().cartesianIndexMapper().cartesianIndex(compressedCellIdx); }
/*!
* \brief Return the index of the cells in the logical Cartesian grid
*/
unsigned cartesianIndex(const std::array<int,dimension>& coords) const
{
unsigned cartIndex = coords[0];
int factor = cartesianDimensions()[0];
for (unsigned i = 1; i < dimension; ++i) {
cartIndex += coords[i]*factor;
factor *= cartesianDimensions()[i];
}
return cartIndex;
}
/*!
* \brief Extract Cartesian index triplet (i,j,k) of an active cell.
*
* \param [in] cellIdx Active cell index.
* \param [out] ijk Cartesian index triplet
*/
void cartesianCoordinate(unsigned cellIdx, std::array<int,3>& ijk) const
{ return asImp_().cartesianIndexMapper().cartesianCoordinate(cellIdx, ijk); }
ebos: introduce a mapper from compressed to cartesian cell indices of the EQUIL grid this is because the nice opm-core code which does the equil initialization cannot cope with parallel grids and thus needs to get a special treatment.
2016-01-17 14:15:18 -06:00
/*!
* \brief Returns the Cartesian cell id given an element index for the grid used for equilibration
*/
unsigned equilCartesianIndex(unsigned compressedEquilCellIdx) const
{ return asImp_().equilCartesianIndexMapper().cartesianIndex(compressedEquilCellIdx); }
/*!
* \brief Extract Cartesian index triplet (i,j,k) of an active cell of the grid used for EQUIL.
*
* \param [in] cellIdx Active cell index.
* \param [out] ijk Cartesian index triplet
*/
void equilCartesianCoordinate(unsigned cellIdx, std::array<int,3>& ijk) const
{ return asImp_().equilCartesianIndexMapper().cartesianCoordinate(cellIdx, ijk); }
ebos: add the disabled well names kluge to the grid manager this array is only non-empty for parallel runs.
2016-12-06 12:39:06 -06:00
/*!
* \brief Return the names of the wells which do not penetrate any cells on the local
* process.
*
* This is a kludge around the fact that for distributed grids, not all wells are
* seen by all proccesses.
*/
std::unordered_set<std::string> defunctWellNames() const
{ return std::unordered_set<std::string>(); }
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
private:
Implementation& asImp_()
{ return *static_cast<Implementation*>(this); }
const Implementation& asImp_() const
{ return *static_cast<const Implementation*>(this); }
std::string caseName_;
ebos: replace the opm-parser related pointers/smart pointers by references this seems to be the spirit of the season. note that now the deck object must be copied, but I suppose that copying it is pretty cheap.
2016-12-05 11:05:56 -06:00
Opm::Deck deck_;
std::unique_ptr<Opm::EclipseState> eclState_;
ebos: replace the macro mess to select the grid type by specialized grid manager classes i.e., there is now a base class for the EclGridManagers and one class for each type of grid (Dune::ALUGrid, Dune::PolyhedralGrid and Dune::CpGrid). Selecting the concrete grid type is now done by deriving the EclProblem's type tag from the type tag of the respective grid manager.
2016-01-05 12:32:36 -06:00
};
} // namespace Ewoms
#endif
Reference in New Issue Copy Permalink