mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-10 23:46:00 -06:00
289 lines
8.6 KiB
C++
289 lines
8.6 KiB
C++
// $Id: rmswell.cpp 1194 2013-08-19 08:24:58Z anner $
|
|
|
|
// Copyright (c) 2011, Norwegian Computing Center
|
|
// All rights reserved.
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
// • Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
// • Redistributions in binary form must reproduce the above copyright notice, this list of
|
|
// conditions and the following disclaimer in the documentation and/or other materials
|
|
// provided with the distribution.
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
// SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
|
// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <math.h>
|
|
#include "rmswell.hpp"
|
|
#include "../iotools/stringtools.hpp"
|
|
#include "../iotools/fileio.hpp"
|
|
|
|
using namespace NRLib;
|
|
|
|
|
|
RMSWell::RMSWell(const std::string& filename)
|
|
{
|
|
std::ifstream file;
|
|
OpenRead(file, filename);
|
|
|
|
size_t nlog;
|
|
std::string dummy;
|
|
getline(file,line1_);
|
|
getline(file,line2_);
|
|
int line = 0;
|
|
std::string token;
|
|
std::string wellName = ReadNext<std::string>(file, line);
|
|
SetWellName(wellName);
|
|
xpos0_ = ReadNext<double>(file, line);
|
|
ypos0_ = ReadNext<double>(file, line); // read wellname and positions
|
|
// getline(file,dummy);// Line may contain a dummy number
|
|
//-----line shift
|
|
DiscardRestOfLine(file, line, false);
|
|
nlog = ReadNext<int>(file, line); // read number of logs
|
|
DiscardRestOfLine(file, line, false);
|
|
lognames_.resize(nlog+3);
|
|
lognames_[0] = "X";
|
|
lognames_[1] = "Y";
|
|
lognames_[2] = "Z";
|
|
|
|
int ident;
|
|
std::string identstr;
|
|
size_t j(0);
|
|
size_t k(0);
|
|
isDiscrete_.resize(nlog+3);
|
|
unit_.resize(nlog);
|
|
scale_.resize(nlog);
|
|
isDiscrete_[0] = false;
|
|
isDiscrete_[1] = false;
|
|
isDiscrete_[2] = false;
|
|
for (size_t i = 0; i < nlog; i++) {
|
|
getline(file,dummy);
|
|
std::istringstream ist(dummy);
|
|
lognames_[i+3] = NRLib::Uppercase(ReadNext<std::string>(ist, line));
|
|
|
|
//token = ReadNext<std::string>(ist, line); //H Error if line only containts log-name (test_case 19).
|
|
ReadNextToken(ist, token, line);
|
|
|
|
if (token != "") {
|
|
if (token=="DISC") { // discrete log
|
|
isDiscrete_[i+3] = true;
|
|
std::map<int, std::string> disc;
|
|
while(ReadNextToken(ist,token,line)) {
|
|
ident = ParseType<int>(token);
|
|
identstr = ReadNext<std::string>(ist, line);
|
|
disc.insert(std::pair<int, std::string> (ident, identstr));
|
|
}
|
|
discnames_[lognames_[i+3]] = disc;
|
|
j++;
|
|
}
|
|
else {
|
|
isDiscrete_[i+3] = false;
|
|
unit_[k] = token;
|
|
scale_[k] = ReadNext<std::string>(ist, line);
|
|
k++;
|
|
}
|
|
}
|
|
else {
|
|
isDiscrete_[i+3] = false;
|
|
k++;
|
|
}
|
|
}
|
|
|
|
size_t ndisc(j);
|
|
size_t ncont = nlog + 3 - ndisc;
|
|
std::vector<std::vector<int> > disclogs(ndisc);
|
|
std::vector<std::vector<double> > contlogs(ncont);
|
|
|
|
int count = 0;
|
|
|
|
while(NRLib::CheckEndOfFile(file)==false && getline(file,dummy)) {
|
|
count ++;
|
|
std::istringstream ist(dummy);
|
|
contlogs[0].push_back(ReadNext<double>(ist, line)); //x
|
|
contlogs[1].push_back(ReadNext<double>(ist, line)); //y
|
|
contlogs[2].push_back(ReadNext<double>(ist, line)); //z
|
|
|
|
j = 0;
|
|
k = 3;
|
|
for (size_t i = 0; i < nlog; i++) {
|
|
if (isDiscrete_[i+3]) {
|
|
double dummy = ReadNext<double>(ist, line); //Double because of a problem with ReadNext<int> and facies on the form -9.9900000e+002
|
|
if(IsMissing(dummy) == false)
|
|
disclogs[j].push_back(static_cast<int>(dummy));
|
|
else
|
|
disclogs[j].push_back(GetIntMissing());
|
|
|
|
j++;
|
|
}
|
|
else {
|
|
contlogs[k].push_back(ReadNext<double>(ist, line));
|
|
k++;
|
|
}
|
|
}
|
|
}
|
|
|
|
AddContLog(lognames_[0], contlogs[0]);
|
|
AddContLog(lognames_[1], contlogs[1]);
|
|
AddContLog(lognames_[2], contlogs[2]);
|
|
j = 0;
|
|
k = 3;
|
|
for (size_t i = 0; i < nlog; i++) {
|
|
if (isDiscrete_[i+3]) {
|
|
AddDiscLog(lognames_[i+3], disclogs[j]);
|
|
j++;
|
|
}
|
|
else {
|
|
AddContLog(lognames_[i+3], contlogs[k]);
|
|
k++;
|
|
}
|
|
}
|
|
|
|
// Find n_data including WELLMISSING values
|
|
int n_data = static_cast<int>(GetContLog(lognames_[0]).size());
|
|
|
|
this->SetNumberOfData(n_data);
|
|
SetXPos0(xpos0_);
|
|
SetYPos0(ypos0_);
|
|
}
|
|
|
|
|
|
RMSWell::RMSWell(const Well& wellobj)
|
|
: Well(wellobj)
|
|
{
|
|
xpos0_ = GetContValue(0, "x");
|
|
ypos0_ = GetContValue(0, "y");
|
|
line1_ = "1.0";
|
|
line2_ = "Undefined";
|
|
size_t nlog = wellobj.GetNlog();
|
|
lognames_.resize(nlog + 3);
|
|
lognames_[0] = "x";
|
|
lognames_[1] = "y";
|
|
lognames_[2] = "z";
|
|
isDiscrete_.resize(nlog + 3);
|
|
isDiscrete_[0] = false;
|
|
isDiscrete_[1] = false;
|
|
isDiscrete_[2] = false;
|
|
size_t i = 0;
|
|
size_t k = 0;
|
|
|
|
typedef std::map<std::string, std::vector<int> >::const_iterator CI;
|
|
std::map<std::string,std::vector<int> > disclog = wellobj.GetDiscLog();
|
|
for (CI p = disclog.begin(); p != disclog.end(); ++p) {
|
|
lognames_[i+3] = p->first;
|
|
isDiscrete_[i+3] = true;
|
|
i++;
|
|
}
|
|
typedef std::map<std::string, std::vector<double> >::const_iterator CID;
|
|
std::map<std::string,std::vector<double> > contlog = wellobj.GetContLog();
|
|
for (CID p = contlog.begin(); p != contlog.end(); ++p) {
|
|
if (p->first != "x" && p->first != "y" && p->first != "z") {
|
|
lognames_[i+3] = p->first;
|
|
isDiscrete_[i+3] = false;
|
|
i++;
|
|
k++;
|
|
}
|
|
}
|
|
|
|
unit_.resize(k);
|
|
scale_.resize(k);
|
|
for (i = 0; i < k; i++) {
|
|
unit_[i] = "unit1";
|
|
scale_[i] ="scale1";
|
|
}
|
|
|
|
size_t ndisc = nlog - k - 3;
|
|
std::vector<std::vector<int> > discvalues(ndisc);
|
|
i = 0;
|
|
size_t j;
|
|
size_t kk = 0;
|
|
bool found = false;
|
|
for (CI p = disclog.begin(); p != disclog.end(); ++p) {
|
|
while(wellobj.IsMissing((p->second)[kk]))
|
|
kk++;
|
|
discvalues[i].push_back((p->second)[kk]);
|
|
|
|
for (j = kk + 1; j < p->second.size(); j++) {
|
|
for (k = 0; k < discvalues[i].size(); k++)
|
|
if ((p->second)[j] == discvalues[i][k])
|
|
found = true;
|
|
if (found == false && (!wellobj.IsMissing((p->second)[j])))
|
|
discvalues[i].push_back((p->second)[j]);
|
|
found = false;
|
|
}
|
|
}
|
|
////Frode NB: Må se nøyere på dette.
|
|
typedef std::pair<int, std::string> pp;
|
|
std::string identstr;
|
|
for (CI p = disclog.begin(); p !=disclog.end(); ++p) {
|
|
std::string disc_name = p->first;
|
|
for (j = 0; j < p->second.size(); j++) {
|
|
std::string identstr = ToString(p->second[j]);
|
|
discnames_[disc_name].insert(pp(p->second[j], identstr));
|
|
}
|
|
}
|
|
}
|
|
|
|
const std::map<int, std::string>
|
|
RMSWell::GetDiscNames(const std::string& log_name) const
|
|
{
|
|
return (discnames_.find(log_name)->second);
|
|
}
|
|
|
|
void RMSWell::WriteToFile(const std::string& filename)
|
|
{
|
|
std::ofstream file;
|
|
OpenWrite(file, filename, std::ios::out);
|
|
|
|
file << line1_ << "\n"
|
|
<< line2_ << "\n"
|
|
<< std::setprecision(8)
|
|
<< GetWellName() << " " << xpos0_ <<" " << ypos0_ << "\n"
|
|
<< GetNlog() - 3 << "\n";
|
|
|
|
size_t k = 0;
|
|
std::map<std::string, std::map<int, std::string> >::iterator iter = discnames_.begin();
|
|
typedef std::map<int, std::string>::const_iterator ci;
|
|
for (size_t i = 0; i < GetNlog(); i++) {
|
|
if (lognames_[i] != "x" && lognames_[i] != "y" && lognames_[i] != "z") {
|
|
file<< lognames_[i] << " ";
|
|
iter = discnames_.find(lognames_[i]);
|
|
if (isDiscrete_[i]==true) {
|
|
file << "DISC" << " ";
|
|
for (ci p = iter->second.begin(); p !=iter->second.end();++p)
|
|
file << p->first << " " << p->second << " ";
|
|
file << "\n";
|
|
// ++iter;
|
|
}
|
|
else {
|
|
file<< unit_[k] << " " << scale_[k] <<"\n";
|
|
k++;
|
|
}
|
|
}
|
|
}
|
|
file.precision(8);
|
|
size_t n = GetContLogLength(lognames_[0]);
|
|
for (size_t i = 0; i < n; i++) {
|
|
for (size_t j = 0; j < GetNlog(); j++) {
|
|
if (isDiscrete_[j]==true)
|
|
file << GetDiscValue(i, lognames_[j]) << " ";
|
|
else
|
|
file << GetContValue(i, lognames_[j]) << " ";
|
|
}
|
|
file << "\n";
|
|
}
|
|
file.close();
|
|
}
|