|
|
#include "nmDataWellBase.h"
|
|
|
#include "nmDataReservoir.h"
|
|
|
#include "nmDataAnalyzeManager.h"
|
|
|
|
|
|
#include <QDir>
|
|
|
#include <QFile>
|
|
|
#include <QTextStream>
|
|
|
#include <QCoreApplication>
|
|
|
#include <QDateTime>
|
|
|
|
|
|
nmDataWellBase::nmDataWellBase()
|
|
|
: m_nIndexF(0)
|
|
|
, m_bPlotVisible(true)
|
|
|
, m_bTimeDependentSkin(false)
|
|
|
, m_eWellType(Vertical_Well)
|
|
|
, m_dLastWellLength(0.0)
|
|
|
, m_pReservoir(nullptr)
|
|
|
{
|
|
|
m_pReservoir = nmDataAnalyzeManager::getCurrentInstance()->getReservoirData();
|
|
|
m_wellName = "";
|
|
|
m_x = nmDataAttribute("X", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
m_y = nmDataAttribute("Y", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
m_radius = nmDataAttribute("Radius", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
m_drillFloorElevation = nmDataAttribute("Drill floor elevation", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
m_zw = nmDataAttribute("Zw", 22.5, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
m_wellLength = nmDataAttribute("Well length", m_pReservoir->getThickness().getValue(), "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
m_rateDependentSkin = nmDataAttribute("Rate dependent skin", false, "");
|
|
|
|
|
|
m_dSdQ = nmDataAttribute("dS/dQ", 0.0, "1/B/D", UNIT_TYPE_FLOW_RATE_RECIPROCAL, QStringList(), QStringList() << "1/B/D" << "1/MMm^3/D" << "1/Mcf/D" << "1/Mm^3/D" << "1/Mm^3/hr"
|
|
|
<< "1/U.K. gal/hr" << "1/U.K. gal/min" << "1/U.S. gal/hr" << "1/U.S. gal/min" << "1/cf/D" << "1/cf/s" << "1/cm^3/sec" << "1/l/min" << "1/m^3/D" << "1/m^3/hr" << "1/m^3/min" << "1/m^3/sec");
|
|
|
m_wellboreModel = nmDataAttribute("Wellbore model", "Constant", "", UNIT_TYPE_DIMENSIONLESS, QStringList() << "None" << "Constant" << "Changing hegeman" << "Changing fair"
|
|
|
<< "Changing spivey packer" << "Changing spivey fissures", QStringList());
|
|
|
m_wellboreStorage = nmDataAttribute("Wellbore storage", 0.01, "m^3/MPa", UNIT_TYPE_COMPRESSIBILITY, QStringList(), QStringList() << "bbl/psi" << "m^3/bar" << "m^3/kPa" << "m^3/Pa" << "m^3.cm^2/kg" << "m^2" << "m^3/MPa");
|
|
|
m_bottomholeMD = nmDataAttribute("Bottomhole MD", 6000.0, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
|
|
|
// 初始化新添加的成员
|
|
|
m_inputWellHead = nmDataAttribute("Input well head", "", "");
|
|
|
m_wellHeadX = nmDataAttribute("Well head X", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
m_wellHeadY = nmDataAttribute("Well head Y", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km");
|
|
|
|
|
|
m_finalWellboreStorage = nmDataAttribute("Final wellbore storage", 0.01, "bbl/psi", UNIT_TYPE_COMPRESSIBILITY, QStringList(), QStringList() << "bbl/psi" << "m^3/bar" << "m^3/kPa" << "m^3/Pa" << "m^3.cm^2/kg" << "m^2" << "m^3/MPa");
|
|
|
m_cInitialCFinal = nmDataAttribute("C[initial]/C[final]", 10.0, "");
|
|
|
m_dtChangingStorage = nmDataAttribute("Dt changing storage", 1.0, "hr", UNIT_TYPE_TIME, QStringList(), QStringList() << "ms" << "sec" << "min" << "hr" << "day" << "Week" << "Month" << "Year");
|
|
|
m_leakSkin = nmDataAttribute("Leak Skin", 0.0, "");
|
|
|
|
|
|
// 图元可见性，默认为true
|
|
|
m_bPlotVisible = true;
|
|
|
|
|
|
m_bTimeDependentSkin = false;
|
|
|
|
|
|
// 添加一段射孔，默认与井身长度相同 (现在创建对象并添加指针)
|
|
|
nmDataPerforation* defaultPerforation = new nmDataPerforation();
|
|
|
defaultPerforation->getMdStart().setValue(m_bottomholeMD.getValue().toDouble());
|
|
|
defaultPerforation->getMdEnd().setValue(m_bottomholeMD.getValue().toDouble() + m_wellLength.getValue().toDouble());
|
|
|
m_vecPerforations.append(defaultPerforation); // 添加指针
|
|
|
|
|
|
// 默认与当前井身长度一致
|
|
|
m_dLastWellLength = m_wellLength.getValue().toDouble();
|
|
|
|
|
|
this->connectAttributeSignals();
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::resetToDefaults()
|
|
|
{
|
|
|
m_wellboreStorage.setValue(0.01);
|
|
|
// 重置第一段射孔的皮损系数
|
|
|
if(getPerforationCount() > 0) {
|
|
|
nmDataPerforation* firstPerforation = getPerforation(0);
|
|
|
if(firstPerforation) {
|
|
|
firstPerforation->getSkin().setValue(0.0); // 皮损系数
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
nmDataWellBase::nmDataWellBase(const nmDataWellBase& other)
|
|
|
{
|
|
|
*this = other; // 使用赋值运算符实现
|
|
|
}
|
|
|
|
|
|
nmDataWellBase::~nmDataWellBase()
|
|
|
{
|
|
|
// 释放所有射孔段对象
|
|
|
qDeleteAll(m_vecPerforations);
|
|
|
m_vecPerforations.clear();
|
|
|
}
|
|
|
|
|
|
nmDataWellBase& nmDataWellBase::operator=(const nmDataWellBase& other)
|
|
|
{
|
|
|
if(this != &other) {
|
|
|
m_wellName = other.m_wellName;
|
|
|
m_x = other.m_x;
|
|
|
m_y = other.m_y;
|
|
|
m_radius = other.m_radius;
|
|
|
m_drillFloorElevation = other.m_drillFloorElevation;
|
|
|
m_zw = other.m_zw;
|
|
|
m_wellLength = other.m_wellLength;
|
|
|
m_rateDependentSkin = other.m_rateDependentSkin;
|
|
|
m_dSdQ = other.m_dSdQ;
|
|
|
m_wellboreModel = other.m_wellboreModel;
|
|
|
m_wellboreStorage = other.m_wellboreStorage;
|
|
|
m_bottomholeMD = other.m_bottomholeMD;
|
|
|
m_vecPtsP = other.m_vecPtsP;
|
|
|
m_vecPtsF = other.m_vecPtsF;
|
|
|
m_nIndexF = other.m_nIndexF;
|
|
|
m_finalWellboreStorage = other.m_finalWellboreStorage;
|
|
|
m_inputWellHead = other.m_inputWellHead;
|
|
|
m_wellHeadX = other.m_wellHeadX;
|
|
|
m_wellHeadY = other.m_wellHeadY;
|
|
|
m_cInitialCFinal = other.m_cInitialCFinal;
|
|
|
m_dtChangingStorage = other.m_dtChangingStorage;
|
|
|
m_leakSkin = other.m_leakSkin;
|
|
|
m_bPlotVisible = other.m_bPlotVisible;
|
|
|
m_bTimeDependentSkin = other.m_bTimeDependentSkin;
|
|
|
m_eWellType = other.m_eWellType;
|
|
|
|
|
|
// 先释放当前的射孔段对象
|
|
|
qDeleteAll(m_vecPerforations);
|
|
|
m_vecPerforations.clear();
|
|
|
|
|
|
// 深拷贝新的射孔段对象
|
|
|
foreach(nmDataPerforation* perf, other.m_vecPerforations) {
|
|
|
if(perf) {
|
|
|
m_vecPerforations.append(new nmDataPerforation(*perf));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 复制历史数据
|
|
|
m_vvecHsyPressure = other.m_vvecHsyPressure;
|
|
|
m_vvecHsyLogLog = other.m_vvecHsyLogLog;
|
|
|
m_vvecHsySemiLog = other.m_vvecHsySemiLog;
|
|
|
|
|
|
// 复制计算结果数据
|
|
|
m_vvecRstPressure = other.m_vvecRstPressure;
|
|
|
m_vvecRstLogLog = other.m_vvecRstLogLog;
|
|
|
m_vvecRstSemiLog = other.m_vvecRstSemiLog;
|
|
|
|
|
|
// 默认与当前井身长度一致
|
|
|
m_dLastWellLength = m_wellLength.getValue().toDouble();
|
|
|
}
|
|
|
|
|
|
return *this;
|
|
|
}
|
|
|
|
|
|
// 序列化 nmDataWellBase 为 RapidJSON Value
|
|
|
rapidjson::Value nmDataWellBase::ToJsonValue(rapidjson::Document::AllocatorType& allocator) const
|
|
|
{
|
|
|
// 创建一个 RapidJSON 对象类型的值
|
|
|
rapidjson::Value wellObject(rapidjson::kObjectType);
|
|
|
|
|
|
// 序列化名称
|
|
|
wellObject.AddMember("WellName", rapidjson::Value(m_wellName.toStdString().c_str(), allocator).Move(), allocator);
|
|
|
|
|
|
// 序列化井类型
|
|
|
wellObject.AddMember("WellType", rapidjson::Value(static_cast<int>(m_eWellType)), allocator);
|
|
|
|
|
|
// 序列化 nmDataAttribute 类型的成员
|
|
|
// 调用 nmDataAttribute 自身的 ToJsonValue 方法进行递归序列化
|
|
|
wellObject.AddMember("X", m_x.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("Y", m_y.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("Radius", m_radius.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("DrillFloorElevation", m_drillFloorElevation.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("Zw", m_zw.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("WellLength", m_wellLength.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("RateDependentSkin", m_rateDependentSkin.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("dSdQ", m_dSdQ.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("WellboreModel", m_wellboreModel.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("WellboreStorage", m_wellboreStorage.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("BottomholeMD", m_bottomholeMD.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("InputWellHead", m_inputWellHead.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("WellHeadX", m_wellHeadX.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("WellHeadY", m_wellHeadY.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("FinalWellboreStorage", m_finalWellboreStorage.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("CInitialCFinal", m_cInitialCFinal.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("DtChangingStorage", m_dtChangingStorage.ToJsonValue(allocator), allocator);
|
|
|
wellObject.AddMember("LeakSkin", m_leakSkin.ToJsonValue(allocator), allocator);
|
|
|
// 序列化时间变表皮状态
|
|
|
wellObject.AddMember("TimeDependentSkin", m_bTimeDependentSkin, allocator);
|
|
|
|
|
|
// 序列化图元可见性 (m_bPlotVisible)
|
|
|
wellObject.AddMember("PlotVisible", m_bPlotVisible, allocator);
|
|
|
|
|
|
// 序列化井的流动段索引 (m_nIndexF)
|
|
|
wellObject.AddMember("IndexFlow", m_nIndexF, allocator);
|
|
|
|
|
|
// 序列化射孔段集合 (现在处理指针)
|
|
|
rapidjson::Value perforationsArray(rapidjson::kArrayType);
|
|
|
|
|
|
foreach(const nmDataPerforation* perfPtr, m_vecPerforations) {
|
|
|
if(perfPtr) { // 检查指针是否有效
|
|
|
perforationsArray.PushBack(perfPtr->ToJsonValue(allocator), allocator);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
wellObject.AddMember("Perforations", perforationsArray, allocator);
|
|
|
|
|
|
return wellObject; // 返回序列化后的 RapidJSON Value
|
|
|
}
|
|
|
|
|
|
// 从 RapidJSON Value 反序列化数据到 nmDataWellBase
|
|
|
void nmDataWellBase::FromJsonValue(const rapidjson::Value& jsonValue)
|
|
|
{
|
|
|
// 反序列化名称
|
|
|
if(jsonValue.HasMember("WellName") && jsonValue["WellName"].IsString()) {
|
|
|
m_wellName = QString::fromUtf8(jsonValue["WellName"].GetString());
|
|
|
}
|
|
|
|
|
|
// 反序列化井类型 (m_eWellType)
|
|
|
if(jsonValue.HasMember("WellType") && jsonValue["WellType"].IsInt()) {
|
|
|
m_eWellType = static_cast<NM_WELL_MODEL>(jsonValue["WellType"].GetInt());
|
|
|
}
|
|
|
|
|
|
// 反序列化 nmDataAttribute 类型的成员
|
|
|
// 调用 nmDataAttribute 自身的 FromJsonValue 方法进行递归反序列化
|
|
|
if(jsonValue.HasMember("X") && jsonValue["X"].IsObject()) {
|
|
|
m_x.FromJsonValue(jsonValue["X"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("Y") && jsonValue["Y"].IsObject()) {
|
|
|
m_y.FromJsonValue(jsonValue["Y"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("Radius") && jsonValue["Radius"].IsObject()) {
|
|
|
m_radius.FromJsonValue(jsonValue["Radius"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("DrillFloorElevation") && jsonValue["DrillFloorElevation"].IsObject()) {
|
|
|
m_drillFloorElevation.FromJsonValue(jsonValue["DrillFloorElevation"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("Zw") && jsonValue["Zw"].IsObject()) {
|
|
|
m_zw.FromJsonValue(jsonValue["Zw"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("WellLength") && jsonValue["WellLength"].IsObject()) {
|
|
|
m_wellLength.FromJsonValue(jsonValue["WellLength"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("RateDependentSkin") && jsonValue["RateDependentSkin"].IsObject()) {
|
|
|
m_rateDependentSkin.FromJsonValue(jsonValue["RateDependentSkin"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("dSdQ") && jsonValue["dSdQ"].IsObject()) {
|
|
|
m_dSdQ.FromJsonValue(jsonValue["dSdQ"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("WellboreModel") && jsonValue["WellboreModel"].IsObject()) {
|
|
|
m_wellboreModel.FromJsonValue(jsonValue["WellboreModel"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("WellboreStorage") && jsonValue["WellboreStorage"].IsObject()) {
|
|
|
m_wellboreStorage.FromJsonValue(jsonValue["WellboreStorage"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("BottomholeMD") && jsonValue["BottomholeMD"].IsObject()) {
|
|
|
m_bottomholeMD.FromJsonValue(jsonValue["BottomholeMD"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("InputWellHead") && jsonValue["InputWellHead"].IsObject()) {
|
|
|
m_inputWellHead.FromJsonValue(jsonValue["InputWellHead"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("WellHeadX") && jsonValue["WellHeadX"].IsObject()) {
|
|
|
m_wellHeadX.FromJsonValue(jsonValue["WellHeadX"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("WellHeadY") && jsonValue["WellHeadY"].IsObject()) {
|
|
|
m_wellHeadY.FromJsonValue(jsonValue["WellHeadY"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("FinalWellboreStorage") && jsonValue["FinalWellboreStorage"].IsObject()) {
|
|
|
m_finalWellboreStorage.FromJsonValue(jsonValue["FinalWellboreStorage"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("CInitialCFinal") && jsonValue["CInitialCFinal"].IsObject()) {
|
|
|
m_cInitialCFinal.FromJsonValue(jsonValue["CInitialCFinal"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("DtChangingStorage") && jsonValue["DtChangingStorage"].IsObject()) {
|
|
|
m_dtChangingStorage.FromJsonValue(jsonValue["DtChangingStorage"]);
|
|
|
}
|
|
|
|
|
|
if(jsonValue.HasMember("LeakSkin") && jsonValue["LeakSkin"].IsObject()) {
|
|
|
m_leakSkin.FromJsonValue(jsonValue["LeakSkin"]);
|
|
|
}
|
|
|
|
|
|
// 反序列化时间变表皮状态
|
|
|
if(jsonValue.HasMember("TimeDependentSkin") && jsonValue["TimeDependentSkin"].IsBool()) {
|
|
|
m_bTimeDependentSkin = jsonValue["TimeDependentSkin"].GetBool();
|
|
|
}
|
|
|
|
|
|
// 反序列化图元可见性 (m_bPlotVisible)
|
|
|
if(jsonValue.HasMember("PlotVisible") && jsonValue["PlotVisible"].IsBool()) {
|
|
|
m_bPlotVisible = jsonValue["PlotVisible"].GetBool();
|
|
|
}
|
|
|
|
|
|
// 反序列化井的流动段索引 (m_nIndexF)
|
|
|
if(jsonValue.HasMember("IndexFlow") && jsonValue["IndexFlow"].IsInt()) {
|
|
|
m_nIndexF = jsonValue["IndexFlow"].GetInt();
|
|
|
}
|
|
|
|
|
|
// 反序列化射孔段集合 (现在处理指针)
|
|
|
if(jsonValue.HasMember("Perforations") && jsonValue["Perforations"].IsArray()) {
|
|
|
// 清空并释放现有射孔段对象
|
|
|
qDeleteAll(m_vecPerforations);
|
|
|
m_vecPerforations.clear();
|
|
|
|
|
|
const rapidjson::Value& perforationsArray = jsonValue["Perforations"];
|
|
|
|
|
|
for(rapidjson::SizeType i = 0; i < perforationsArray.Size(); ++i) {
|
|
|
if(perforationsArray[i].IsObject()) {
|
|
|
nmDataPerforation* newPerforation = new nmDataPerforation(); // 创建新对象
|
|
|
newPerforation->FromJsonValue(perforationsArray[i]);
|
|
|
m_vecPerforations.append(newPerforation); // 添加指针
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 默认与当前井身长度一致
|
|
|
m_dLastWellLength = m_wellLength.getValue().toDouble();
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::connectAttributeSignals() {
|
|
|
// 通用属性
|
|
|
connect(&m_inputWellHead, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_wellHeadX, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_wellHeadY, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_x, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_y, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_drillFloorElevation, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_radius, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_zw, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_wellLength, SIGNAL(sigValueChanged()), this, SLOT(slotWellLengthChanged()));
|
|
|
connect(&m_rateDependentSkin, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_dSdQ, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_wellboreModel, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_wellboreStorage, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_finalWellboreStorage, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_cInitialCFinal, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_dtChangingStorage, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_leakSkin, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
connect(&m_bottomholeMD, SIGNAL(sigValueChanged()), this, SIGNAL(sigWellDataChanged()));
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::notifyParameterChanged()
|
|
|
{
|
|
|
emit sigParameterChanged();
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::slotWellLengthChanged()
|
|
|
{
|
|
|
double oldLength = m_dLastWellLength;
|
|
|
double newLength = m_wellLength.getValue().toDouble();
|
|
|
|
|
|
// 避免除以零和不必要的计算
|
|
|
if (qFuzzyIsNull(oldLength) || oldLength <= 0 || qFuzzyCompare(oldLength, newLength)) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 获取井口深度
|
|
|
double wellHeadMd = this->getBottomholeMD().getValue().toDouble();
|
|
|
|
|
|
// 对于多段压裂水平井类型，井口MD是第一段射孔的起点
|
|
|
if (m_eWellType == Horizontal_Fractured_Well)
|
|
|
{
|
|
|
wellHeadMd = getPerforations()[0]->getMdStart().getValue().toDouble();
|
|
|
}
|
|
|
|
|
|
// 遍历所有射孔段，并按比例更新其MD数据
|
|
|
foreach(nmDataPerforation* pPerfData, m_vecPerforations) {
|
|
|
if(pPerfData) {
|
|
|
double originalPerforationMdStart = pPerfData->getMdStart().getValue().toDouble();
|
|
|
double originalPerforationMdEnd = pPerfData->getMdEnd().getValue().toDouble();
|
|
|
|
|
|
// 计算射孔在旧井筒上的相对位置
|
|
|
double relativePerforationStart = (originalPerforationMdStart - wellHeadMd) / oldLength;
|
|
|
double relativePerforationEnd = (originalPerforationMdEnd - wellHeadMd) / oldLength;
|
|
|
|
|
|
// 根据新的井筒长度计算新的绝对MD值
|
|
|
double newPerforationMdStart = wellHeadMd + (relativePerforationStart * newLength);
|
|
|
double newPerforationMdEnd = wellHeadMd + (relativePerforationEnd * newLength);
|
|
|
|
|
|
pPerfData->getMdStart().setValue(newPerforationMdStart);
|
|
|
pPerfData->getMdEnd().setValue(newPerforationMdEnd);
|
|
|
}
|
|
|
}
|
|
|
// 更新历史井身
|
|
|
m_dLastWellLength = newLength;
|
|
|
|
|
|
emit sigWellDataChanged();
|
|
|
}
|
|
|
|
|
|
// Getters and Setters
|
|
|
void nmDataWellBase::setWellName(const QString& name)
|
|
|
{
|
|
|
m_wellName = name;
|
|
|
}
|
|
|
|
|
|
QString nmDataWellBase::getWellName() const
|
|
|
{
|
|
|
return m_wellName;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setX(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_x = attr;
|
|
|
emit sigWellDataChanged();
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getX()
|
|
|
{
|
|
|
return m_x;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setY(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_y = attr;
|
|
|
emit sigWellDataChanged();
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getY()
|
|
|
{
|
|
|
return m_y;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setRadius(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_radius = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getRadius()
|
|
|
{
|
|
|
return m_radius;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setDrillFloorElevation(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_drillFloorElevation = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getDrillFloorElevation()
|
|
|
{
|
|
|
return m_drillFloorElevation;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setZw(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_zw = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getZw()
|
|
|
{
|
|
|
return m_zw;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setWellLength(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_wellLength = attr;
|
|
|
emit sigWellDataChanged();
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getWellLength()
|
|
|
{
|
|
|
return m_wellLength;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setRateDependentSkin(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_rateDependentSkin = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getRateDependentSkin()
|
|
|
{
|
|
|
return m_rateDependentSkin;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setdSdQ(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_dSdQ = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getdSdQ()
|
|
|
{
|
|
|
return m_dSdQ;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setWellboreModel(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_wellboreModel = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getWellboreModel()
|
|
|
{
|
|
|
return m_wellboreModel;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setWellboreStorage(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_wellboreStorage = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getWellboreStorage()
|
|
|
{
|
|
|
return m_wellboreStorage;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setBottomholeMD(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_bottomholeMD = attr;
|
|
|
emit sigWellDataChanged();
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getBottomholeMD()
|
|
|
{
|
|
|
return m_bottomholeMD;
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::isTimeDependentSkin() const
|
|
|
{
|
|
|
return m_bTimeDependentSkin;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setTimeDependentSkin(bool enabled)
|
|
|
{
|
|
|
m_bTimeDependentSkin = enabled;
|
|
|
}
|
|
|
|
|
|
// 获取压力曲线点数据
|
|
|
QVector<QPointF> nmDataWellBase::getPressurePoints() const
|
|
|
{
|
|
|
return m_vecPtsP;
|
|
|
}
|
|
|
|
|
|
// 设置压力曲线点数据
|
|
|
void nmDataWellBase::setPressurePoints(const QVector<QPointF>& points)
|
|
|
{
|
|
|
m_vecPtsP = points;
|
|
|
}
|
|
|
|
|
|
// 获取流量曲线点数据
|
|
|
QVector<QPointF> nmDataWellBase::getFlowPoints() const
|
|
|
{
|
|
|
return m_vecPtsF;
|
|
|
}
|
|
|
|
|
|
// 设置流量曲线点数据
|
|
|
void nmDataWellBase::setFlowPoints(const QVector<QPointF>& points)
|
|
|
{
|
|
|
m_vecPtsF = points;
|
|
|
}
|
|
|
|
|
|
int nmDataWellBase::getIndexF() const
|
|
|
{
|
|
|
return m_nIndexF;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setIndexF(const int newIndex)
|
|
|
{
|
|
|
m_nIndexF = newIndex;
|
|
|
}
|
|
|
|
|
|
// Location---位置
|
|
|
void nmDataWellBase::setInputWellHead(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_inputWellHead = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getInputWellHead()
|
|
|
{
|
|
|
return m_inputWellHead;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setWellHeadX(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_wellHeadX = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getWellHeadX()
|
|
|
{
|
|
|
return m_wellHeadX;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setWellHeadY(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_wellHeadY = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getWellHeadY()
|
|
|
{
|
|
|
return m_wellHeadY;
|
|
|
}
|
|
|
|
|
|
// Wellbore---井储
|
|
|
void nmDataWellBase::setCInitialCFinal(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_cInitialCFinal = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getCInitialCFinal()
|
|
|
{
|
|
|
return m_cInitialCFinal;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setDtChangingStorage(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_dtChangingStorage = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getDtChangingStorage()
|
|
|
{
|
|
|
return m_dtChangingStorage;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setLeakSkin(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_leakSkin = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getLeakSkin()
|
|
|
{
|
|
|
return m_leakSkin;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setFinalWellboreStorage(const nmDataAttribute& attr)
|
|
|
{
|
|
|
m_finalWellboreStorage = attr;
|
|
|
}
|
|
|
|
|
|
nmDataAttribute& nmDataWellBase::getFinalWellboreStorage()
|
|
|
{
|
|
|
return m_finalWellboreStorage;
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::getPlotVisible() const
|
|
|
{
|
|
|
return m_bPlotVisible;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setPlotVisible(const bool newState)
|
|
|
{
|
|
|
m_bPlotVisible = newState;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setWellType(NM_WELL_MODEL newWellType)
|
|
|
{
|
|
|
m_eWellType = newWellType;
|
|
|
}
|
|
|
|
|
|
NM_WELL_MODEL nmDataWellBase::getWellType() const
|
|
|
{
|
|
|
return m_eWellType;
|
|
|
}
|
|
|
|
|
|
// 历史数据相关方法
|
|
|
QVector<QVector<double>> nmDataWellBase::getHistoryPressure() {
|
|
|
return m_vvecHsyPressure;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setHistoryPressure(QVector<QVector<double>> pressureData) {
|
|
|
m_vvecHsyPressure = pressureData;
|
|
|
}
|
|
|
|
|
|
QVector<QVector<double>> nmDataWellBase::getHistoryLogLog() {
|
|
|
return m_vvecHsyLogLog;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setHistoryLogLog(QVector<QVector<double>> loglogData) {
|
|
|
m_vvecHsyLogLog = loglogData;
|
|
|
}
|
|
|
|
|
|
QVector<QVector<double>> nmDataWellBase::getHistorySemiLog() {
|
|
|
return m_vvecHsySemiLog;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setHistorySemiLog(QVector<QVector<double>> semiLogData) {
|
|
|
m_vvecHsySemiLog = semiLogData;
|
|
|
}
|
|
|
|
|
|
// 计算结果相关方法
|
|
|
QVector<QVector<double>> nmDataWellBase::getResultPressure()
|
|
|
{
|
|
|
return m_vvecRstPressure;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setResultPressure(QVector<QVector<double>> pressureData)
|
|
|
{
|
|
|
m_vvecRstPressure = pressureData;
|
|
|
}
|
|
|
|
|
|
QVector<QVector<double>> nmDataWellBase::getResultLogLog()
|
|
|
{
|
|
|
return m_vvecRstLogLog;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setResultLogLog(QVector<QVector<double>> loglogData)
|
|
|
{
|
|
|
m_vvecRstLogLog = loglogData;
|
|
|
}
|
|
|
|
|
|
QVector<QVector<double>> nmDataWellBase::getResultSemiLog()
|
|
|
{
|
|
|
return m_vvecRstSemiLog;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::setResultSemiLog(QVector<QVector<double>> semiLogData)
|
|
|
{
|
|
|
m_vvecRstSemiLog = semiLogData;
|
|
|
}
|
|
|
|
|
|
// 射孔管理相关方法
|
|
|
void nmDataWellBase::addPerforation(nmDataPerforation* perforation)
|
|
|
{
|
|
|
if(perforation) { // 确保传入的指针非空
|
|
|
m_vecPerforations.append(perforation);
|
|
|
emit sigWellDataChanged();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::removePerforation(int index)
|
|
|
{
|
|
|
if(index >= 0 && index < m_vecPerforations.size()) {
|
|
|
delete m_vecPerforations.at(index); // 释放内存
|
|
|
m_vecPerforations.remove(index); // 从 QVector 中移除指针
|
|
|
emit sigWellDataChanged();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
nmDataPerforation* nmDataWellBase::getPerforation(int index)
|
|
|
{
|
|
|
if(index >= 0 && index < m_vecPerforations.size()) {
|
|
|
return m_vecPerforations.at(index);
|
|
|
}
|
|
|
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
nmDataPerforation nmDataWellBase::getPerforationCopy(int index)
|
|
|
{
|
|
|
if (index >= 0 && index < m_vecPerforations.size() && m_vecPerforations[index] != nullptr) {
|
|
|
return *m_vecPerforations[index]; // 调用拷贝构造函数
|
|
|
}
|
|
|
|
|
|
return nmDataPerforation(); // 返回默认构造对象
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::updatePerforation(int index, const nmDataPerforation& newData)
|
|
|
{
|
|
|
if (index >= 0 && index < m_vecPerforations.size() && m_vecPerforations[index] != nullptr) {
|
|
|
*m_vecPerforations[index] = newData; // 调用赋值运算符
|
|
|
emit sigWellDataChanged(); // 发出数据变化信号
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int nmDataWellBase::getPerforationCount()
|
|
|
{
|
|
|
return m_vecPerforations.size();
|
|
|
}
|
|
|
|
|
|
QVector<nmDataPerforation*>& nmDataWellBase::getPerforations()
|
|
|
{
|
|
|
return m_vecPerforations;
|
|
|
}
|
|
|
|
|
|
void nmDataWellBase::clearPerforations()
|
|
|
{
|
|
|
foreach (nmDataPerforation* perf , m_vecPerforations)
|
|
|
{
|
|
|
delete perf;
|
|
|
}
|
|
|
m_vecPerforations.clear();
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::isBasePerforation()
|
|
|
{
|
|
|
if(m_vecPerforations.size() > 1 || m_vecPerforations.size() <= 0 ) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 检查第一个射孔段数据是不是基础射孔
|
|
|
nmDataPerforation* pPerf = m_vecPerforations[0];
|
|
|
if (pPerf == nullptr)
|
|
|
return false;
|
|
|
// 名称检查
|
|
|
if (pPerf->getName().getValue().toString() != "Perforation#1")
|
|
|
return false;
|
|
|
// 长度检查
|
|
|
double bottomholeMd = this->getBottomholeMD().getValue().toDouble();
|
|
|
double mdStart = pPerf->getMdStart().getValue().toDouble();
|
|
|
double mdEnd = pPerf->getMdEnd().getValue().toDouble();
|
|
|
double expectedMdEnd = bottomholeMd + this->getWellLength().getValue().toDouble();
|
|
|
if (qAbs(mdStart - bottomholeMd) > 1e-9)
|
|
|
return false;
|
|
|
if (qAbs(mdEnd - expectedMdEnd) > 1e-9)
|
|
|
return false;
|
|
|
// 表皮系数检查
|
|
|
if(qAbs(pPerf->getSkin().getValue().toDouble()) > 1e-9)
|
|
|
return false;
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// 井级别的流量和时间查询方法
|
|
|
double nmDataWellBase::getTotalTimeRange() const
|
|
|
{
|
|
|
QVector<QPointF> allFlowPoints = getFlowPoints();
|
|
|
double totalTime = 0.0;
|
|
|
|
|
|
for (int i = 0; i < allFlowPoints.size(); ++i) {
|
|
|
totalTime += allFlowPoints[i].x();
|
|
|
}
|
|
|
|
|
|
return totalTime;
|
|
|
}
|
|
|
|
|
|
double nmDataWellBase::getFlowRateAtTime(double time) const
|
|
|
{
|
|
|
QVector<QPointF> allFlowPoints = getFlowPoints();
|
|
|
double currentTime = 0.0;
|
|
|
|
|
|
// 遍历所有流量点，找到包含指定时间的阶梯段
|
|
|
for (int i = 0; i < allFlowPoints.size(); ++i) {
|
|
|
const QPointF& point = allFlowPoints.at(i);
|
|
|
double stepStartTime = currentTime;
|
|
|
double stepEndTime = currentTime + point.x();
|
|
|
|
|
|
// 如果时间在这个阶梯段内
|
|
|
if (time >= stepStartTime && time < stepEndTime) {
|
|
|
return point.y(); // 返回该阶梯段的流量值
|
|
|
}
|
|
|
|
|
|
currentTime = stepEndTime;
|
|
|
|
|
|
// 如果时间超出了所有阶梯段，返回最后一个阶梯段的流量值
|
|
|
if (time >= stepEndTime && i == allFlowPoints.size() - 1) {
|
|
|
return point.y();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果没有找到合适的阶梯段（可能是时间为0或负数），返回第一个阶梯段的流量值
|
|
|
if (!allFlowPoints.isEmpty()) {
|
|
|
return allFlowPoints.first().y();
|
|
|
}
|
|
|
|
|
|
return 100.0; // 默认值
|
|
|
}
|
|
|
|
|
|
QVector<double> nmDataWellBase::getAllFlowStepBoundaries() const
|
|
|
{
|
|
|
QVector<double> allBoundaries;
|
|
|
QVector<QPointF> allFlowPoints = getFlowPoints();
|
|
|
double currentTime = 0.0;
|
|
|
|
|
|
// 添加起始时间
|
|
|
allBoundaries.append(currentTime);
|
|
|
|
|
|
// 遍历所有流量点，收集所有阶梯边界时间
|
|
|
for (int i = 0; i < allFlowPoints.size(); ++i) {
|
|
|
const QPointF& point = allFlowPoints.at(i);
|
|
|
currentTime += point.x();
|
|
|
allBoundaries.append(currentTime);
|
|
|
}
|
|
|
|
|
|
return allBoundaries;
|
|
|
}
|
|
|
|
|
|
QVector<QPointF> nmDataWellBase::getFlowStepsInTimeRange(double startTime, double endTime) const
|
|
|
{
|
|
|
QVector<QPointF> stepsInRange;
|
|
|
QVector<QPointF> allFlowPoints = getFlowPoints();
|
|
|
double currentTime = 0.0;
|
|
|
|
|
|
for (int i = 0; i < allFlowPoints.size(); ++i) {
|
|
|
const QPointF& point = allFlowPoints.at(i);
|
|
|
double stepStartTime = currentTime;
|
|
|
double stepEndTime = currentTime + point.x();
|
|
|
|
|
|
// 检查这个阶梯段是否与指定时间范围有重叠
|
|
|
if (stepEndTime > startTime && stepStartTime < endTime) {
|
|
|
// 计算在范围内的部分
|
|
|
double overlapStart = qMax(stepStartTime, startTime);
|
|
|
double overlapEnd = qMin(stepEndTime, endTime);
|
|
|
|
|
|
if (overlapEnd > overlapStart) {
|
|
|
stepsInRange.append(QPointF(overlapEnd - overlapStart, point.y()));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
currentTime = stepEndTime;
|
|
|
|
|
|
if (currentTime >= endTime) {
|
|
|
break; // 超出范围，停止
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return stepsInRange;
|
|
|
}
|
|
|
|
|
|
double nmDataWellBase::findFlowStepBoundaryAtTime(double timePoint) const
|
|
|
{
|
|
|
QVector<QPointF> allFlowPoints = getFlowPoints();
|
|
|
double currentTime = 0.0;
|
|
|
|
|
|
// 遍历所有流量点，找到包含timePoint的阶梯段
|
|
|
for (int i = 0; i < allFlowPoints.count(); ++i) {
|
|
|
const QPointF& point = allFlowPoints.at(i);
|
|
|
double stepStartTime = currentTime;
|
|
|
double stepEndTime = currentTime + point.x();
|
|
|
|
|
|
// 如果timePoint在这个阶梯段内
|
|
|
if (timePoint >= stepStartTime && timePoint < stepEndTime) {
|
|
|
return stepEndTime; // 返回该阶梯段的结束时间作为分割边界
|
|
|
}
|
|
|
|
|
|
currentTime = stepEndTime;
|
|
|
}
|
|
|
|
|
|
return -1.0; // 没有找到合适的阶梯边界
|
|
|
}
|
|
|
|
|
|
double nmDataWellBase::findSmartFlowStepBoundary(double targetTime) const
|
|
|
{
|
|
|
QVector<QPointF> allFlowPoints = getFlowPoints();
|
|
|
double currentTime = 0.0;
|
|
|
|
|
|
// 遍历所有流量点，找到包含targetTime的阶梯段
|
|
|
for (int i = 0; i < allFlowPoints.count(); ++i) {
|
|
|
const QPointF& point = allFlowPoints.at(i);
|
|
|
double stepStartTime = currentTime;
|
|
|
double stepEndTime = currentTime + point.x();
|
|
|
|
|
|
// 如果targetTime在这个阶梯段内
|
|
|
if (targetTime >= stepStartTime && targetTime <= stepEndTime) {
|
|
|
double stepMidTime = (stepStartTime + stepEndTime) / 2.0;
|
|
|
|
|
|
// 根据在阶梯段的前半部分还是后半部分决定吸附位置
|
|
|
if (targetTime <= stepMidTime) {
|
|
|
// 在前半部分，吸附到阶梯段开始
|
|
|
return stepStartTime;
|
|
|
} else {
|
|
|
// 在后半部分，吸附到阶梯段结束
|
|
|
return stepEndTime;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
currentTime = stepEndTime;
|
|
|
}
|
|
|
|
|
|
// 如果没有找到对应的阶梯段，使用已有的findNearestFlowStepBoundary函数
|
|
|
return findNearestFlowStepBoundary(targetTime);
|
|
|
}
|
|
|
|
|
|
double nmDataWellBase::findNearestFlowStepBoundary(double targetTime) const
|
|
|
{
|
|
|
QVector<double> boundaries = getAllFlowStepBoundaries();
|
|
|
|
|
|
if (boundaries.isEmpty()) {
|
|
|
return targetTime; // 如果没有边界，返回原时间
|
|
|
}
|
|
|
|
|
|
double nearestBoundary = boundaries[0];
|
|
|
double minDistance = qAbs(targetTime - boundaries[0]);
|
|
|
|
|
|
for (int i = 1; i < boundaries.size(); ++i) {
|
|
|
double distance = qAbs(targetTime - boundaries[i]);
|
|
|
|
|
|
if (distance < minDistance) {
|
|
|
minDistance = distance;
|
|
|
nearestBoundary = boundaries[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return nearestBoundary;
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::isTimeInFlowStepFirstHalf(double time) const
|
|
|
{
|
|
|
QVector<QPointF> allFlowPoints = getFlowPoints();
|
|
|
double currentTime = 0.0;
|
|
|
|
|
|
// 遍历所有流量点，找到包含time的阶梯段
|
|
|
for (int i = 0; i < allFlowPoints.count(); ++i) {
|
|
|
const QPointF& point = allFlowPoints.at(i);
|
|
|
double stepStartTime = currentTime;
|
|
|
double stepEndTime = currentTime + point.x();
|
|
|
|
|
|
// 如果time在这个阶梯段内
|
|
|
if (time >= stepStartTime && time <= stepEndTime) {
|
|
|
double stepMidTime = (stepStartTime + stepEndTime) / 2.0;
|
|
|
return time <= stepMidTime;
|
|
|
}
|
|
|
|
|
|
currentTime = stepEndTime;
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 射孔段相关的查询方法
|
|
|
QVector<double> nmDataWellBase::getFlowStepBoundariesInSegment(int segmentIndex, int perforationIndex) const
|
|
|
{
|
|
|
QVector<double> boundaries;
|
|
|
|
|
|
if (perforationIndex < 0 || perforationIndex >= m_vecPerforations.size()) {
|
|
|
return boundaries;
|
|
|
}
|
|
|
|
|
|
nmDataPerforation* perforation = m_vecPerforations[perforationIndex];
|
|
|
if (!perforation) {
|
|
|
return boundaries;
|
|
|
}
|
|
|
|
|
|
const QVector<FlowSegmentData>& segments = perforation->getFlowSegments();
|
|
|
if (segmentIndex < 0 || segmentIndex >= segments.size()) {
|
|
|
return boundaries;
|
|
|
}
|
|
|
|
|
|
const FlowSegmentData& segment = segments[segmentIndex];
|
|
|
double segmentStartTime = segment.segmentStart.getValue().toDouble();
|
|
|
double segmentEndTime = segment.segmentEnd.getValue().toDouble();
|
|
|
|
|
|
QVector<QPointF> allFlowPoints = getFlowPoints();
|
|
|
double currentTime = 0.0;
|
|
|
|
|
|
// 遍历所有流量点，找到在该段范围内的所有阶梯边界
|
|
|
for (int i = 0; i < allFlowPoints.size(); ++i) {
|
|
|
const QPointF& point = allFlowPoints.at(i);
|
|
|
double stepEndTime = currentTime + point.x();
|
|
|
|
|
|
// 如果这个阶梯段与目标段有重叠
|
|
|
if (stepEndTime > segmentStartTime && currentTime < segmentEndTime) {
|
|
|
// 添加在段范围内的边界点
|
|
|
if (stepEndTime <= segmentEndTime) {
|
|
|
boundaries.append(stepEndTime);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
currentTime = stepEndTime;
|
|
|
|
|
|
// 如果已经超出段的结束时间，停止遍历
|
|
|
if (currentTime >= segmentEndTime) {
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 确保最后一个边界不超过段的结束时间
|
|
|
if (!boundaries.isEmpty() && boundaries.last() > segmentEndTime) {
|
|
|
boundaries[boundaries.size() - 1] = segmentEndTime;
|
|
|
}
|
|
|
|
|
|
// 如果没有找到任何边界，添加段的结束时间
|
|
|
if (boundaries.isEmpty()) {
|
|
|
boundaries.append(segmentEndTime);
|
|
|
}
|
|
|
|
|
|
return boundaries;
|
|
|
}
|
|
|
|
|
|
QVector<double> nmDataWellBase::getAllBoundariesInSegment(int segmentIndex, int perforationIndex) const
|
|
|
{
|
|
|
QVector<double> allBoundaries;
|
|
|
|
|
|
if (perforationIndex < 0 || perforationIndex >= m_vecPerforations.size()) {
|
|
|
return allBoundaries;
|
|
|
}
|
|
|
|
|
|
nmDataPerforation* perforation = m_vecPerforations[perforationIndex];
|
|
|
if (!perforation) {
|
|
|
return allBoundaries;
|
|
|
}
|
|
|
|
|
|
const QVector<FlowSegmentData>& segments = perforation->getFlowSegments();
|
|
|
if (segmentIndex < 0 || segmentIndex >= segments.size()) {
|
|
|
return allBoundaries;
|
|
|
}
|
|
|
|
|
|
const FlowSegmentData& segment = segments[segmentIndex];
|
|
|
double segmentStartTime = segment.segmentStart.getValue().toDouble();
|
|
|
double segmentEndTime = segment.segmentEnd.getValue().toDouble();
|
|
|
|
|
|
// 获取流量阶梯边界
|
|
|
QVector<double> flowBoundaries = getFlowStepBoundariesInSegment(segmentIndex, perforationIndex);
|
|
|
|
|
|
// 添加所有边界
|
|
|
allBoundaries.append(segmentStartTime);
|
|
|
|
|
|
for (int i = 0; i < flowBoundaries.size(); ++i) {
|
|
|
double boundary = flowBoundaries[i];
|
|
|
|
|
|
if (boundary > segmentStartTime && boundary <= segmentEndTime) {
|
|
|
allBoundaries.append(boundary);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 排序并去重
|
|
|
qSort(allBoundaries);
|
|
|
|
|
|
for (int i = allBoundaries.size() - 1; i > 0; --i) {
|
|
|
if (qAbs(allBoundaries[i] - allBoundaries[i - 1]) < 1e-6) {
|
|
|
allBoundaries.remove(i);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return allBoundaries;
|
|
|
}
|
|
|
|
|
|
int nmDataWellBase::countFlowStepsInSegment(int segmentIndex, int perforationIndex) const
|
|
|
{
|
|
|
if (perforationIndex < 0 || perforationIndex >= m_vecPerforations.size()) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
nmDataPerforation* perforation = m_vecPerforations[perforationIndex];
|
|
|
if (!perforation) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
const QVector<FlowSegmentData>& segments = perforation->getFlowSegments();
|
|
|
if (segmentIndex < 0 || segmentIndex >= segments.size()) {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
const FlowSegmentData& segment = segments[segmentIndex];
|
|
|
double startTime = segment.segmentStart.getValue().toDouble();
|
|
|
double endTime = segment.segmentEnd.getValue().toDouble();
|
|
|
|
|
|
QVector<QPointF> stepsInRange = getFlowStepsInTimeRange(startTime, endTime);
|
|
|
return stepsInRange.size();
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::canFlowSegmentBeSplit(int segmentIndex, int perforationIndex) const
|
|
|
{
|
|
|
return countFlowStepsInSegment(segmentIndex, perforationIndex) > 1;
|
|
|
}
|
|
|
|
|
|
double nmDataWellBase::findNearestFlowStepBoundaryBeforeSegment(int segmentIndex, int perforationIndex) const
|
|
|
{
|
|
|
if (perforationIndex < 0 || perforationIndex >= m_vecPerforations.size()) {
|
|
|
return -1.0;
|
|
|
}
|
|
|
|
|
|
nmDataPerforation* perforation = m_vecPerforations[perforationIndex];
|
|
|
if (!perforation) {
|
|
|
return -1.0;
|
|
|
}
|
|
|
|
|
|
const QVector<FlowSegmentData>& segments = perforation->getFlowSegments();
|
|
|
if (segmentIndex <= 0 || segmentIndex >= segments.size()) {
|
|
|
return -1.0; // 第一个段或无效索引，无法插入
|
|
|
}
|
|
|
|
|
|
// 获取当前段的开始时间
|
|
|
double currentSegmentStartTime = segments[segmentIndex].segmentStart.getValue().toDouble();
|
|
|
|
|
|
// 获取前一个段的开始和结束时间
|
|
|
double prevSegmentStartTime = segments[segmentIndex - 1].segmentStart.getValue().toDouble();
|
|
|
double prevSegmentEndTime = segments[segmentIndex - 1].segmentEnd.getValue().toDouble();
|
|
|
|
|
|
// 在前一个段内查找所有流量阶梯边界
|
|
|
QVector<double> boundaries = getFlowStepBoundariesInSegment(segmentIndex - 1, perforationIndex);
|
|
|
|
|
|
if (boundaries.isEmpty()) {
|
|
|
return -1.0;
|
|
|
}
|
|
|
|
|
|
// 找到距离当前段开始时间最近的边界（但要小于当前段的开始时间，且不等于前一个段的结束时间）
|
|
|
double nearestBoundary = -1.0;
|
|
|
double minDistance = 1e10;
|
|
|
|
|
|
for (int i = 0; i < boundaries.size(); ++i) {
|
|
|
double boundary = boundaries[i];
|
|
|
|
|
|
// 边界必须在前一个段内部，且小于当前段的开始时间，且不等于前一个段的结束时间
|
|
|
if (boundary > prevSegmentStartTime &&
|
|
|
boundary < currentSegmentStartTime &&
|
|
|
qAbs(boundary - prevSegmentEndTime) > 1e-6) { // 不等于前一个段的结束时间
|
|
|
double distance = currentSegmentStartTime - boundary;
|
|
|
|
|
|
if (distance < minDistance) {
|
|
|
minDistance = distance;
|
|
|
nearestBoundary = boundary;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return nearestBoundary;
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::exportHistoryLogLogToCsv(const QString& outDir)
|
|
|
{
|
|
|
// 1) 取历史数据：期望 hist[0]=t, hist[1]=p, hist[2]=deriv
|
|
|
QVector<QVector<double> > hist = this->getHistoryLogLog();
|
|
|
|
|
|
if(hist.size() < 2) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const QVector<double>& t = hist[0];
|
|
|
const QVector<double>& p = hist[1];
|
|
|
|
|
|
QVector<double> deriv;
|
|
|
bool hasDeriv = false;
|
|
|
if(hist.size() >= 3) {
|
|
|
deriv = hist[2];
|
|
|
hasDeriv = true;
|
|
|
}
|
|
|
|
|
|
// 2) 长度检查
|
|
|
int n = t.size();
|
|
|
if(n <= 0) return false;
|
|
|
if(p.size() != n) return false;
|
|
|
if(hasDeriv && deriv.size() != n) {
|
|
|
// 导数长度不一致就当没有导数
|
|
|
hasDeriv = false;
|
|
|
}
|
|
|
|
|
|
// 3) 输出文件名
|
|
|
QString wellName = this->getWellName(); // 你已有方法
|
|
|
if(wellName.isEmpty()) wellName = "UnknownWell";
|
|
|
|
|
|
// 文件直接放 temp 目录，不创建子目录
|
|
|
QString filePath = QDir(outDir).filePath(wellName + "_loglog.csv");
|
|
|
|
|
|
QFile file(filePath);
|
|
|
if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
QTextStream out(&file);
|
|
|
|
|
|
// 4) 写表头
|
|
|
if(hasDeriv) {
|
|
|
out << "t,p,deriv\n";
|
|
|
} else {
|
|
|
out << "t,p\n";
|
|
|
}
|
|
|
|
|
|
// 5) 正确写入：按索引 i 写 t[i], p[i], deriv[i]
|
|
|
for(int i = 0; i < n; ++i) {
|
|
|
|
|
|
// 过滤非法数据
|
|
|
double ti = t[i];
|
|
|
double pi = p[i];
|
|
|
if(ti <= 0) continue;
|
|
|
if(pi <= 0) continue;
|
|
|
|
|
|
out << QString::number(ti, 'g', 12) << ",";
|
|
|
out << QString::number(pi, 'g', 12);
|
|
|
|
|
|
if(hasDeriv) {
|
|
|
double di = deriv[i];
|
|
|
if(di <= 0) di = 1e-12; // 你后续 log10 时需要正数
|
|
|
out << "," << QString::number(di, 'g', 12);
|
|
|
}
|
|
|
|
|
|
out << "\n";
|
|
|
}
|
|
|
|
|
|
file.close();
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::exportHistoryRateToCsv(const QString& outDir)
|
|
|
{
|
|
|
// 1) 获取流量点 (t, q)
|
|
|
QVector<QPointF> vecTimeQ = this->getFlowPoints();
|
|
|
|
|
|
if(vecTimeQ.size() < 2) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 2) 移除第一个点 (0,0)
|
|
|
if(!vecTimeQ.isEmpty()
|
|
|
&& vecTimeQ[0].x() == 0.0
|
|
|
&& vecTimeQ[0].y() == 0.0)
|
|
|
{
|
|
|
vecTimeQ.remove(0);
|
|
|
}
|
|
|
|
|
|
if(vecTimeQ.size() < 2) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 3) sectionIndex（流动段索引）
|
|
|
int sectionIndex = this->getIndexF();
|
|
|
|
|
|
// 4) 输出文件名
|
|
|
QString wellName = this->getWellName();
|
|
|
if(wellName.isEmpty()) wellName = "UnknownWell";
|
|
|
|
|
|
QString filePath = QDir(outDir).filePath(wellName + "_rate.csv");
|
|
|
|
|
|
QFile file(filePath);
|
|
|
if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
QTextStream out(&file);
|
|
|
|
|
|
// 5) 写表头
|
|
|
out << "t,qo,sectionIndex\n";
|
|
|
|
|
|
// 6) 写入每个点
|
|
|
for(int i = 0; i < vecTimeQ.size(); ++i)
|
|
|
{
|
|
|
double ti = vecTimeQ[i].x();
|
|
|
double qi = vecTimeQ[i].y();
|
|
|
|
|
|
if(ti <= 0) continue;
|
|
|
if(qi < 0) qi = 0; // 流量允许关井
|
|
|
|
|
|
out << QString::number(ti, 'g', 12) << ",";
|
|
|
out << QString::number(qi, 'g', 12) << ",";
|
|
|
out << sectionIndex << "\n";
|
|
|
}
|
|
|
|
|
|
file.close();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::exportHistoryPressureToCsv(const QString& outDir)
|
|
|
{
|
|
|
// 1) 取历史压力数据：期望 hist[0]=t, hist[1]=p
|
|
|
QVector<QVector<double> > hist = this->getHistoryPressure();
|
|
|
|
|
|
if(hist.size() < 2) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const QVector<double>& t = hist[0];
|
|
|
const QVector<double>& p = hist[1];
|
|
|
|
|
|
// 2) 长度检查
|
|
|
int n = t.size();
|
|
|
if(n <= 0) return false;
|
|
|
if(p.size() != n) return false;
|
|
|
|
|
|
// 3) 输出文件名
|
|
|
QString wellName = this->getWellName();
|
|
|
if(wellName.isEmpty()) wellName = "UnknownWell";
|
|
|
|
|
|
// 文件直接放 temp 目录，不创建子目录
|
|
|
QString filePath = QDir(outDir).filePath(wellName + "_pressure.csv");
|
|
|
|
|
|
QFile file(filePath);
|
|
|
if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
QTextStream out(&file);
|
|
|
out.setRealNumberPrecision(12); // 设置精度
|
|
|
|
|
|
// 4) 写表头
|
|
|
out << "t,p\n";
|
|
|
|
|
|
// 5) 写入数据
|
|
|
for(int i = 0; i < n; ++i) {
|
|
|
double ti = t[i];
|
|
|
double pi = p[i];
|
|
|
|
|
|
// 过滤非法数据
|
|
|
if(ti <= 0) continue;
|
|
|
if(pi <= 0) continue; // 假设压力为正
|
|
|
|
|
|
out << ti << "," << pi << "\n";
|
|
|
}
|
|
|
|
|
|
file.close();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::exportResultLogLogToCsv(const QString& outDir)
|
|
|
{
|
|
|
QVector<QVector<double> > result = this->getResultLogLog();
|
|
|
|
|
|
if(result.size() < 2) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const QVector<double>& t = result[0];
|
|
|
const QVector<double>& p = result[1];
|
|
|
|
|
|
QVector<double> deriv;
|
|
|
bool hasDeriv = false;
|
|
|
if(result.size() >= 3) {
|
|
|
deriv = result[2];
|
|
|
hasDeriv = true;
|
|
|
}
|
|
|
|
|
|
int n = t.size();
|
|
|
if(n <= 0) return false;
|
|
|
if(p.size() != n) return false;
|
|
|
if(hasDeriv && deriv.size() != n) {
|
|
|
hasDeriv = false;
|
|
|
}
|
|
|
|
|
|
QString wellName = this->getWellName();
|
|
|
if(wellName.isEmpty()) wellName = "UnknownWell";
|
|
|
|
|
|
QString filePath = QDir(outDir).filePath(wellName + "_result_loglog.csv");
|
|
|
|
|
|
QFile file(filePath);
|
|
|
if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
QTextStream out(&file);
|
|
|
if(hasDeriv) {
|
|
|
out << "t,p,deriv\n";
|
|
|
} else {
|
|
|
out << "t,p\n";
|
|
|
}
|
|
|
|
|
|
for(int i = 0; i < n; ++i) {
|
|
|
double ti = t[i];
|
|
|
double pi = p[i];
|
|
|
if(ti <= 0) continue;
|
|
|
if(pi <= 0) continue;
|
|
|
|
|
|
out << QString::number(ti, 'g', 12) << ",";
|
|
|
out << QString::number(pi, 'g', 12);
|
|
|
|
|
|
if(hasDeriv) {
|
|
|
double di = deriv[i];
|
|
|
if(di <= 0) di = 1e-12;
|
|
|
out << "," << QString::number(di, 'g', 12);
|
|
|
}
|
|
|
|
|
|
out << "\n";
|
|
|
}
|
|
|
|
|
|
file.close();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool nmDataWellBase::exportResultPressureToCsv(const QString& outDir)
|
|
|
{
|
|
|
QVector<QVector<double> > result = this->getResultPressure();
|
|
|
|
|
|
if(result.size() < 2) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const QVector<double>& t = result[0];
|
|
|
const QVector<double>& p = result[1];
|
|
|
|
|
|
int n = t.size();
|
|
|
if(n <= 0) return false;
|
|
|
if(p.size() != n) return false;
|
|
|
|
|
|
QString wellName = this->getWellName();
|
|
|
if(wellName.isEmpty()) wellName = "UnknownWell";
|
|
|
|
|
|
QString filePath = QDir(outDir).filePath(wellName + "_result_pressure.csv");
|
|
|
|
|
|
QFile file(filePath);
|
|
|
if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
QTextStream out(&file);
|
|
|
out.setRealNumberPrecision(12);
|
|
|
out << "t,p\n";
|
|
|
|
|
|
for(int i = 0; i < n; ++i) {
|
|
|
double ti = t[i];
|
|
|
double pi = p[i];
|
|
|
if(ti <= 0) continue;
|
|
|
if(pi <= 0) continue;
|
|
|
|
|
|
out << ti << "," << pi << "\n";
|
|
|
}
|
|
|
|
|
|
file.close();
|
|
|
return true;
|
|
|
}
|