mirror of
https://github.com/OPM/opm-simulators.git
synced 2025-02-25 18:55:30 -06:00
Using GridManager and writeVtkData() from opm-core.
This commit is contained in:
Atgeirr Flø Rasmussen
parent
1763e8afd7
commit
b84c957e2b
@ -105,284 +105,6 @@ namespace Opm
|
||||
|
||||
|
||||
|
||||
void writeVtkDataAllCartesian(const std::tr1::array<int, 3>& dims,
|
||||
const std::tr1::array<double, 3>& cell_size,
|
||||
const std::vector<double>& pressure,
|
||||
const std::vector<double>& saturation,
|
||||
std::ostream& vtk_file)
|
||||
{
|
||||
// Dimension is hardcoded in the prototype and the next two lines,
|
||||
// but the rest is flexible (allows dimension == 2 or 3).
|
||||
int dimension = 3;
|
||||
int num_cells = dims[0]*dims[1]*dims[2];
|
||||
|
||||
ASSERT(dimension == 2 || dimension == 3);
|
||||
ASSERT(num_cells = dims[0]*dims[1]* (dimension == 2 ? 1 : dims[2]));
|
||||
|
||||
vtk_file << "# vtk DataFile Version 2.0\n";
|
||||
vtk_file << "Structured Grid\n \n";
|
||||
vtk_file << "ASCII \n";
|
||||
vtk_file << "DATASET STRUCTURED_POINTS\n";
|
||||
|
||||
vtk_file << "DIMENSIONS "
|
||||
<< dims[0] + 1 << " "
|
||||
<< dims[1] + 1 << " ";
|
||||
if (dimension == 3) {
|
||||
vtk_file << dims[2] + 1;
|
||||
} else {
|
||||
vtk_file << 1;
|
||||
}
|
||||
vtk_file << "\n";
|
||||
|
||||
vtk_file << "ORIGIN " << 0.0 << " " << 0.0 << " " << 0.0 << "\n";
|
||||
|
||||
vtk_file << "SPACING " << cell_size[0] << " " << cell_size[1];
|
||||
if (dimension == 3) {
|
||||
vtk_file << " " << cell_size[2];
|
||||
} else {
|
||||
vtk_file << " " << 0.0;
|
||||
}
|
||||
vtk_file << "\n";
|
||||
|
||||
vtk_file << "CELL_DATA " << num_cells << '\n';
|
||||
vtk_file << "SCALARS pressure float" << '\n';
|
||||
vtk_file << "LOOKUP_TABLE pressure_table " << '\n';
|
||||
for (int i = 0; i < num_cells; ++i) {
|
||||
vtk_file << pressure[i] << '\n';
|
||||
}
|
||||
|
||||
vtk_file << "SCALARS saturation float" << '\n';
|
||||
vtk_file << "LOOKUP_TABLE saturation_table " << '\n';
|
||||
for (int i = 0; i < num_cells; ++i) {
|
||||
double s = saturation[2*i];
|
||||
if (s > 1e-10) {
|
||||
vtk_file << s << '\n';
|
||||
} else {
|
||||
vtk_file << 0.0 << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
typedef std::map<std::string, std::string> PMap;
|
||||
|
||||
|
||||
struct Tag
|
||||
{
|
||||
Tag(const std::string& tag, const PMap& props, std::ostream& os)
|
||||
: name_(tag), os_(os)
|
||||
{
|
||||
indent(os);
|
||||
os << "<" << tag;
|
||||
for (PMap::const_iterator it = props.begin(); it != props.end(); ++it) {
|
||||
os << " " << it->first << "=\"" << it->second << "\"";
|
||||
}
|
||||
os << ">\n";
|
||||
++indent_;
|
||||
}
|
||||
Tag(const std::string& tag, std::ostream& os)
|
||||
: name_(tag), os_(os)
|
||||
{
|
||||
indent(os);
|
||||
os << "<" << tag << ">\n";
|
||||
++indent_;
|
||||
}
|
||||
~Tag()
|
||||
{
|
||||
--indent_;
|
||||
indent(os_);
|
||||
os_ << "</" << name_ << ">\n";
|
||||
}
|
||||
static void indent(std::ostream& os)
|
||||
{
|
||||
for (int i = 0; i < indent_; ++i) {
|
||||
os << " ";
|
||||
}
|
||||
}
|
||||
private:
|
||||
static int indent_;
|
||||
std::string name_;
|
||||
std::ostream& os_;
|
||||
};
|
||||
|
||||
int Tag::indent_ = 0;
|
||||
|
||||
|
||||
void writeVtkDataGeneralGrid(const UnstructuredGrid* grid,
|
||||
const DataMap& data,
|
||||
std::ostream& os)
|
||||
{
|
||||
if (grid->dimensions != 3) {
|
||||
THROW("Vtk output for 3d grids only");
|
||||
}
|
||||
os.precision(12);
|
||||
os << "<?xml version=\"1.0\"?>\n";
|
||||
PMap pm;
|
||||
pm["type"] = "UnstructuredGrid";
|
||||
Tag vtkfiletag("VTKFile", pm, os);
|
||||
Tag ugtag("UnstructuredGrid", os);
|
||||
int num_pts = grid->number_of_nodes;
|
||||
int num_cells = grid->number_of_cells;
|
||||
pm.clear();
|
||||
pm["NumberOfPoints"] = boost::lexical_cast<std::string>(num_pts);
|
||||
pm["NumberOfCells"] = boost::lexical_cast<std::string>(num_cells);
|
||||
Tag piecetag("Piece", pm, os);
|
||||
{
|
||||
Tag pointstag("Points", os);
|
||||
pm.clear();
|
||||
pm["type"] = "Float64";
|
||||
pm["Name"] = "Coordinates";
|
||||
pm["NumberOfComponents"] = "3";
|
||||
pm["format"] = "ascii";
|
||||
Tag datag("DataArray", pm, os);
|
||||
for (int i = 0; i < num_pts; ++i) {
|
||||
Tag::indent(os);
|
||||
os << grid->node_coordinates[3*i + 0] << ' '
|
||||
<< grid->node_coordinates[3*i + 1] << ' '
|
||||
<< grid->node_coordinates[3*i + 2] << '\n';
|
||||
}
|
||||
}
|
||||
{
|
||||
Tag cellstag("Cells", os);
|
||||
pm.clear();
|
||||
pm["type"] = "Int32";
|
||||
pm["NumberOfComponents"] = "1";
|
||||
pm["format"] = "ascii";
|
||||
std::vector<int> cell_numpts;
|
||||
cell_numpts.reserve(num_cells);
|
||||
{
|
||||
pm["Name"] = "connectivity";
|
||||
Tag t("DataArray", pm, os);
|
||||
int hf = 0;
|
||||
for (int c = 0; c < num_cells; ++c) {
|
||||
std::set<int> cell_pts;
|
||||
for (; hf < grid->cell_facepos[c+1]; ++hf) {
|
||||
int f = grid->cell_faces[hf];
|
||||
const int* fnbeg = grid->face_nodes + grid->face_nodepos[f];
|
||||
const int* fnend = grid->face_nodes + grid->face_nodepos[f+1];
|
||||
cell_pts.insert(fnbeg, fnend);
|
||||
}
|
||||
cell_numpts.push_back(cell_pts.size());
|
||||
Tag::indent(os);
|
||||
std::copy(cell_pts.begin(), cell_pts.end(),
|
||||
std::ostream_iterator<int>(os, " "));
|
||||
os << '\n';
|
||||
}
|
||||
}
|
||||
{
|
||||
pm["Name"] = "offsets";
|
||||
Tag t("DataArray", pm, os);
|
||||
int offset = 0;
|
||||
const int num_per_line = 10;
|
||||
for (int c = 0; c < num_cells; ++c) {
|
||||
if (c % num_per_line == 0) {
|
||||
Tag::indent(os);
|
||||
}
|
||||
offset += cell_numpts[c];
|
||||
os << offset << ' ';
|
||||
if (c % num_per_line == num_per_line - 1
|
||||
|| c == num_cells - 1) {
|
||||
os << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
std::vector<int> cell_foffsets;
|
||||
cell_foffsets.reserve(num_cells);
|
||||
{
|
||||
pm["Name"] = "faces";
|
||||
Tag t("DataArray", pm, os);
|
||||
const int* fp = grid->cell_facepos;
|
||||
int offset = 0;
|
||||
for (int c = 0; c < num_cells; ++c) {
|
||||
Tag::indent(os);
|
||||
os << fp[c+1] - fp[c] << '\n';
|
||||
++offset;
|
||||
for (int hf = fp[c]; hf < fp[c+1]; ++hf) {
|
||||
int f = grid->cell_faces[hf];
|
||||
const int* np = grid->face_nodepos;
|
||||
int f_num_pts = np[f+1] - np[f];
|
||||
Tag::indent(os);
|
||||
os << f_num_pts << ' ';
|
||||
++offset;
|
||||
std::copy(grid->face_nodes + np[f],
|
||||
grid->face_nodes + np[f+1],
|
||||
std::ostream_iterator<int>(os, " "));
|
||||
os << '\n';
|
||||
offset += f_num_pts;
|
||||
}
|
||||
cell_foffsets.push_back(offset);
|
||||
}
|
||||
}
|
||||
{
|
||||
pm["Name"] = "faceoffsets";
|
||||
Tag t("DataArray", pm, os);
|
||||
const int num_per_line = 10;
|
||||
for (int c = 0; c < num_cells; ++c) {
|
||||
if (c % num_per_line == 0) {
|
||||
Tag::indent(os);
|
||||
}
|
||||
os << cell_foffsets[c] << ' ';
|
||||
if (c % num_per_line == num_per_line - 1
|
||||
|| c == num_cells - 1) {
|
||||
os << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
pm["type"] = "UInt8";
|
||||
pm["Name"] = "types";
|
||||
Tag t("DataArray", pm, os);
|
||||
const int num_per_line = 10;
|
||||
for (int c = 0; c < num_cells; ++c) {
|
||||
if (c % num_per_line == 0) {
|
||||
Tag::indent(os);
|
||||
}
|
||||
os << "42 ";
|
||||
if (c % num_per_line == num_per_line - 1
|
||||
|| c == num_cells - 1) {
|
||||
os << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
pm.clear();
|
||||
if (data.find("saturation") != data.end()) {
|
||||
pm["Scalars"] = "saturation";
|
||||
} else if (data.find("pressure") != data.end()) {
|
||||
pm["Scalars"] = "pressure";
|
||||
}
|
||||
Tag celldatatag("CellData", pm, os);
|
||||
pm.clear();
|
||||
pm["type"] = "Int32";
|
||||
pm["NumberOfComponents"] = "1";
|
||||
pm["format"] = "ascii";
|
||||
pm["type"] = "Float64";
|
||||
for (DataMap::const_iterator dit = data.begin(); dit != data.end(); ++dit) {
|
||||
pm["Name"] = dit->first;
|
||||
const std::vector<double>& field = *(dit->second);
|
||||
// We always print only the first data item for every
|
||||
// cell, using 'stride'.
|
||||
// This is a hack to get water saturation nicely.
|
||||
// \TODO: Extend to properly printing vector data.
|
||||
const int stride = field.size()/grid->number_of_cells;
|
||||
Tag ptag("DataArray", pm, os);
|
||||
const int num_per_line = 5;
|
||||
for (int c = 0; c < num_cells; ++c) {
|
||||
if (c % num_per_line == 0) {
|
||||
Tag::indent(os);
|
||||
}
|
||||
os << field[stride*c] << ' ';
|
||||
if (c % num_per_line == num_per_line - 1
|
||||
|| c == num_cells - 1) {
|
||||
os << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void toWaterSat(const std::vector<double>& sboth, std::vector<double>& sw)
|
||||
|
||||
@ -59,76 +59,6 @@ namespace Opm
|
||||
{
|
||||
|
||||
|
||||
/// Concrete grid class constructing a
|
||||
/// corner point grid from a deck,
|
||||
/// or a cartesian grid.
|
||||
class Grid
|
||||
{
|
||||
public:
|
||||
Grid(const Opm::EclipseGridParser& deck)
|
||||
{
|
||||
// Extract data from deck.
|
||||
const std::vector<double>& zcorn = deck.getFloatingPointValue("ZCORN");
|
||||
const std::vector<double>& coord = deck.getFloatingPointValue("COORD");
|
||||
const std::vector<int>& actnum = deck.getIntegerValue("ACTNUM");
|
||||
std::vector<int> dims;
|
||||
if (deck.hasField("DIMENS")) {
|
||||
dims = deck.getIntegerValue("DIMENS");
|
||||
} else if (deck.hasField("SPECGRID")) {
|
||||
dims = deck.getSPECGRID().dimensions;
|
||||
} else {
|
||||
THROW("Deck must have either DIMENS or SPECGRID.");
|
||||
}
|
||||
|
||||
// Collect in input struct for preprocessing.
|
||||
struct grdecl grdecl;
|
||||
grdecl.zcorn = &zcorn[0];
|
||||
grdecl.coord = &coord[0];
|
||||
grdecl.actnum = &actnum[0];
|
||||
grdecl.dims[0] = dims[0];
|
||||
grdecl.dims[1] = dims[1];
|
||||
grdecl.dims[2] = dims[2];
|
||||
|
||||
// Process and compute.
|
||||
ug_ = preprocess(&grdecl, 0.0);
|
||||
compute_geometry(ug_);
|
||||
}
|
||||
|
||||
Grid(int nx, int ny)
|
||||
{
|
||||
ug_ = create_cart_grid_2d(nx, ny);
|
||||
}
|
||||
|
||||
Grid(int nx, int ny, int nz)
|
||||
{
|
||||
ug_ = create_cart_grid_3d(nx, ny, nz);
|
||||
}
|
||||
|
||||
Grid(int nx, int ny, int nz,
|
||||
double dx, double dy, double dz)
|
||||
{
|
||||
ug_ = create_hexa_grid_3d(nx, ny, nz, dx, dy, dz);
|
||||
}
|
||||
|
||||
~Grid()
|
||||
{
|
||||
free_grid(ug_);
|
||||
}
|
||||
|
||||
virtual const UnstructuredGrid* c_grid() const
|
||||
{
|
||||
return ug_;
|
||||
}
|
||||
|
||||
private:
|
||||
// Disable copying and assignment.
|
||||
Grid(const Grid& other);
|
||||
Grid& operator=(const Grid& other);
|
||||
struct UnstructuredGrid* ug_;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
class PressureSolver
|
||||
{
|
||||
@ -198,25 +128,6 @@ namespace Opm
|
||||
std::vector<double>& totmob);
|
||||
|
||||
|
||||
|
||||
|
||||
void writeVtkDataAllCartesian(const std::tr1::array<int, 3>& dims,
|
||||
const std::tr1::array<double, 3>& cell_size,
|
||||
const std::vector<double>& pressure,
|
||||
const std::vector<double>& saturation,
|
||||
std::ostream& vtk_file);
|
||||
|
||||
|
||||
|
||||
typedef std::map<std::string, const std::vector<double>*> DataMap;
|
||||
|
||||
void writeVtkDataGeneralGrid(const UnstructuredGrid* grid,
|
||||
const DataMap& data,
|
||||
std::ostream& os);
|
||||
|
||||
|
||||
|
||||
|
||||
void toWaterSat(const std::vector<double>& sboth, std::vector<double>& sw);
|
||||
|
||||
void toBothSat(const std::vector<double>& sw, std::vector<double>& sboth);
|
||||
|
||||
@ -25,12 +25,13 @@
|
||||
#include <opm/core/pressure/tpfa/ifs_tpfa.h>
|
||||
#include <opm/core/pressure/tpfa/trans_tpfa.h>
|
||||
|
||||
#include <opm/core/utility/cart_grid.h>
|
||||
#include <opm/core/grid.h>
|
||||
#include <opm/core/GridManager.hpp>
|
||||
#include <opm/core/utility/writeVtkData.hpp>
|
||||
#include <opm/core/utility/linearInterpolation.hpp>
|
||||
#include <opm/core/utility/ErrorMacros.hpp>
|
||||
#include <opm/core/utility/StopWatch.hpp>
|
||||
#include <opm/core/utility/Units.hpp>
|
||||
#include <opm/core/utility/cpgpreprocess/cgridinterface.h>
|
||||
#include <opm/core/utility/parameters/ParameterGroup.hpp>
|
||||
|
||||
#include <opm/core/fluid/SimpleFluid2p.hpp>
|
||||
@ -207,7 +208,7 @@ void outputState(const UnstructuredGrid* grid,
|
||||
dm["saturation"] = &state.saturation();
|
||||
dm["pressure"] = &state.pressure();
|
||||
dm["concentration"] = &state.concentration();
|
||||
Opm::writeVtkDataGeneralGrid(grid, dm, vtkfile);
|
||||
Opm::writeVtkData(grid, dm, vtkfile);
|
||||
|
||||
// Write data (not grid) in Matlab format
|
||||
for (Opm::DataMap::const_iterator it = dm.begin(); it != dm.end(); ++it) {
|
||||
@ -250,7 +251,7 @@ main(int argc, char** argv)
|
||||
|
||||
// If we have a "deck_filename", grid and props will be read from that.
|
||||
bool use_deck = param.has("deck_filename");
|
||||
boost::scoped_ptr<Opm::Grid> grid;
|
||||
boost::scoped_ptr<Opm::GridManager> grid;
|
||||
boost::scoped_ptr<Opm::IncompPropertiesInterface> props;
|
||||
Opm::PolymerData polydata;
|
||||
if (use_deck) {
|
||||
@ -258,7 +259,7 @@ main(int argc, char** argv)
|
||||
std::string deck_filename = param.get<std::string>("deck_filename");
|
||||
Opm::EclipseGridParser deck(deck_filename);
|
||||
// Grid init
|
||||
grid.reset(new Opm::Grid(deck));
|
||||
grid.reset(new Opm::GridManager(deck));
|
||||
// Rock and fluid init
|
||||
const int* gc = grid->c_grid()->global_cell;
|
||||
std::vector<int> global_cell(gc, gc + grid->c_grid()->number_of_cells);
|
||||
@ -271,7 +272,7 @@ main(int argc, char** argv)
|
||||
const int dx = param.getDefault("dx", 1.0);
|
||||
const int dy = param.getDefault("dy", 1.0);
|
||||
const int dz = param.getDefault("dz", 1.0);
|
||||
grid.reset(new Opm::Grid(nx, ny, nz, dx, dy, dz));
|
||||
grid.reset(new Opm::GridManager(nx, ny, nz, dx, dy, dz));
|
||||
// Rock and fluid init.
|
||||
// props.reset(new Opm::IncompPropertiesBasic(param, grid->c_grid()->dimensions, grid->c_grid()->number_of_cells));
|
||||
props.reset(new AdHocProps(param, grid->c_grid()->dimensions, grid->c_grid()->number_of_cells));
|
||||
|
||||
Loading…
Reference in New Issue
Block a user