FileIO::PetrelInterface Class Reference

Detailed Description

Definition at line 30 of file PetrelInterface.h.

#include <PetrelInterface.h>

Public Member Functions
	PetrelInterface (std::list< std::string > const &sfc_fnames, std::list< std::string > const &well_path_fnames, std::string &unique_model_name, GeoLib::GEOObjects *geo_obj)
	PetrelInterface (PetrelInterface const &other)=delete
	PetrelInterface (PetrelInterface &&other)=delete
PetrelInterface &	operator= (PetrelInterface const &)=delete
PetrelInterface &	operator= (PetrelInterface &&)=delete

Private Member Functions
void	readPetrelSurfacePoints (std::istream &in)
void	readPetrelWellTrace (std::istream &in)
void	readPetrelWellTraceData (std::istream &in)

Private Attributes
std::string	_unique_name
std::vector< GeoLib::Point * >	pnt_vec
std::vector< GeoLib::Point * >	well_vec

Constructor & Destructor Documentation

PetrelInterface() [1/3]

FileIO::PetrelInterface::PetrelInterface	(	std::list< std::string > const &	sfc_fnames,
		std::list< std::string > const &	well_path_fnames,
		std::string &	unique_model_name,
		GeoLib::GEOObjects *	geo_obj )

Definition at line 25 of file PetrelInterface.cpp.

    : _unique_name(unique_model_name)
{
    for (auto const& surface_fname : sfc_fnames)
    {
        INFO("PetrelInterface::PetrelInterface(): open surface file.");
        std::ifstream in(surface_fname);
        if (in)
        {
            INFO("PetrelInterface::PetrelInterface(): \tdone.");
            readPetrelSurfacePoints(in);
            in.close();
        }
        else
        {
            WARN(
                "PetrelInterface::PetrelInterface(): \tCould not open file "
                "{:s}.",
                surface_fname);
        }
    }
 
    for (auto const& well_path_fname : well_path_fnames)
    {
        INFO("PetrelInterface::PetrelInterface(): open well path file.");
        std::ifstream in(well_path_fname);
        if (in)
        {
            INFO("PetrelInterface::PetrelInterface(): \tdone.");
            readPetrelWellTrace(in);
            in.close();
        }
        else
        {
            WARN(
                "PetrelInterface::PetrelInterface(): \tCould not open well "
                "path file {:s}.",
                well_path_fname);
        }
    }
 
    // move data to GEOObject
    geo_obj->addPointVec(std::move(pnt_vec), _unique_name);
    if (!well_vec.empty())
    {
        geo_obj->addStationVec(std::move(well_vec), _unique_name);
    }
}

References _unique_name, GeoLib::GEOObjects::addPointVec(), INFO(), pnt_vec, readPetrelSurfacePoints(), readPetrelWellTrace(), WARN(), and well_vec.

PetrelInterface() [2/3]

FileIO::PetrelInterface::PetrelInterface ( PetrelInterface const & other )

delete

PetrelInterface() [3/3]

FileIO::PetrelInterface::PetrelInterface ( PetrelInterface && other )

delete

Member Function Documentation

operator=() [1/2]

PetrelInterface & FileIO::PetrelInterface::operator= ( PetrelInterface && )

delete

operator=() [2/2]

PetrelInterface & FileIO::PetrelInterface::operator= ( PetrelInterface const & )

delete

readPetrelSurfacePoints()

void FileIO::PetrelInterface::readPetrelSurfacePoints ( std::istream & in )

private

Definition at line 89 of file PetrelInterface.cpp.

{
    std::string line = readLine(in);
 
    if (line.find("# Petrel Points with attributes") != std::string::npos)
    {
        // read header
        // read Version string
        readLine(in);
        // read string BEGIN HEADER
        readLine(in);
 
        line = readLine(in);
        while (line.find("END HEADER") == std::string::npos)
        {
            line = readLine(in);
        }
 
        // read points
        while (in)
        {
            auto point = std::make_unique<GeoLib::Point>();
            in >> (*point)[0] >> (*point)[1] >> (*point)[2];
            if (in)
            {
                pnt_vec.push_back(point.release());
            }
        }
    }
    else
    {
        WARN(
            "PetrelInterface::readPetrelSurface(): problem reading petrel "
            "points from line\n'{:s}'.",
            line);
    }
}

References pnt_vec, FileIO::readLine(), and WARN().

Referenced by PetrelInterface().

readPetrelWellTrace()

void FileIO::PetrelInterface::readPetrelWellTrace ( std::istream & in )

private

Definition at line 142 of file PetrelInterface.cpp.

{
    std::string line = readLine(in);
 
    if (line.find("# WELL TRACE FROM PETREL") == std::string::npos)
    {
        return;
    }
 
    auto printInfo = [](auto const& list, std::string_view const message)
    { printListInfo(list, "readPetrelWellTrace", message); };
 
    {
        // read header
        // read well name
        printInfo(split(readLine(in)), "well name");
 
        // read well head x coordinate
        auto str_list = split(readLine(in));
        printInfo(str_list, "well head x coord");
        double const well_head_x = getLastNumberFromList(str_list);
 
        // read well head y coordinate
        str_list = split(readLine(in));
        printInfo(str_list, "well head y coord");
        double const well_head_y = getLastNumberFromList(str_list);
 
        // read well KB
        str_list = split(readLine(in));
        printInfo(str_list, "well kb entry");
        double const well_kb = getLastNumberFromList(str_list);
 
        INFO("PetrelInterface::readPetrelWellTrace(): {:f}, {:f}, {:f}.",
             well_head_x,
             well_head_y,
             well_kb);
        double const depth = 0.0;
        std::string const borehole_name = "";
        int const date = 0;
        well_vec.push_back(new GeoLib::StationBorehole(
            well_head_x, well_head_y, well_kb, depth, borehole_name, date));
 
        // read well type
        readLine(in);
        //        std::string type(*((str_list.end())--));
 
        readPetrelWellTraceData(in);
    }
}

References FileIO::getLastNumberFromList(), INFO(), FileIO::printListInfo(), FileIO::readLine(), readPetrelWellTraceData(), FileIO::split(), and well_vec.

Referenced by PetrelInterface().

readPetrelWellTraceData()

void FileIO::PetrelInterface::readPetrelWellTraceData ( std::istream & in )

private

Definition at line 192 of file PetrelInterface.cpp.

{
    readLine(in);
 
    // read yet another header line
    std::string line = readLine(in);
    while (line[0] == '#')
    {
        line = readLine(in);
    }
 
    // read column information
    printListInfo(split(line), "readPetrelWellTraceData", "column information");
 
    // read points
    double md;
    double x;
    double y;
    double z;
    double tvd;
    double dx;
    double dy;
    double azim;
    double incl;
    double dls;
    line = readLine(in);
    while (in)
    {
        if (line.size() > 1 && line[0] != '#')
        {
            std::stringstream stream(line);
            stream >> md;
            stream >> x >> y >> z;
            //            pnt_vec->push_back (new GeoLib::Point (x,y,z));
            static_cast<GeoLib::StationBorehole*>(well_vec.back())
                ->addSoilLayer(x, y, z, "unknown");
            stream >> tvd >> dx >> dy >> azim >> incl >> dls;
        }
        line = readLine(in);
    }
}

References GeoLib::StationBorehole::addSoilLayer(), FileIO::printListInfo(), FileIO::readLine(), FileIO::split(), and well_vec.

Referenced by readPetrelWellTrace().

Member Data Documentation

_unique_name

std::string FileIO::PetrelInterface::_unique_name

private

Definition at line 47 of file PetrelInterface.h.

Referenced by PetrelInterface().

pnt_vec

std::vector<GeoLib::Point*> FileIO::PetrelInterface::pnt_vec

private

Definition at line 48 of file PetrelInterface.h.

Referenced by PetrelInterface(), and readPetrelSurfacePoints().

well_vec

std::vector<GeoLib::Point*> FileIO::PetrelInterface::well_vec

private

Definition at line 49 of file PetrelInterface.h.

Referenced by PetrelInterface(), readPetrelWellTrace(), and readPetrelWellTraceData().

---

The documentation for this class was generated from the following files:

• Applications/FileIO/PetrelInterface.h
• Applications/FileIO/PetrelInterface.cpp