nmWTAI-Platform/Src/nmNum/nmData/nmDataReservoir.cpp

#include "nmDataReservoir.h"
#include "ZxSerializer.h"

nmDataReservoir::nmDataReservoir() {
    // 基础属性
	m_initialPressure = nmDataAttribute("Initial Pressure",40.0, "MPa", UNIT_TYPE_PRESSURE, QStringList(), QStringList() << "psia" << "Pa" << "kPa" << "atm" << "bara" << "kg/cm^2" << "m" << "psig" << "bar" << "MPa" << "kPag");
    // 求解器直接读取该数值，内部基准单位固定为D；显示换算由框架单位绑定器负责。
    m_permeability = nmDataAttribute("Permeability", 0.025, "D");
    m_thickness = nmDataAttribute("Thickness", 10.0, "m", UNIT_TYPE_LENGTH, QStringList(), QStringList() << "ft" << "m" << "cm" << "mm" << "in" << "0.1 in" << "mile" << "km");
    m_porosity = nmDataAttribute("Porosity", 0.1, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());
    m_kxKy = nmDataAttribute("Kx/Ky", 1.0, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());

    // 油相PVT单值
    m_Bo = nmDataAttribute("Bo", 1.2, "");
    m_Miuo = nmDataAttribute("Miuo", 0.5, "mPa.s");

    // 气相PVT单值
    m_Bg   = nmDataAttribute("Bg",   1.0, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());
    m_Miug = nmDataAttribute("Miug", 1.0, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());

    // 水相PVT单值
    m_Bw   = nmDataAttribute("Bw",   1.0, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());
    m_Miuw = nmDataAttribute("Miuw", 1.0, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());

    // 压缩系数
    m_Ct = nmDataAttribute("Ct", 0.001, "1/MPa");
	m_Cf = nmDataAttribute("Cf", 0.0001, "1/MPa");

    // 储层类型与传导率
    m_reservoirType = nmDataAttribute("Reservoir type", "Homogeneous", "", UNIT_TYPE_DIMENSIONLESS, QStringList() << "Homogeneous" << "Dual porosity pseudo steady state", QStringList());
    m_transmissibility = nmDataAttribute("Transmissibility", 1000.0, "md.m", UNIT_TYPE_CONDUCTIVITY, QStringList(), QStringList()<< "md.ft" << "md.m" << "m^3");

	// 初始饱和度
	m_Soi = nmDataAttribute("Soi", 0.8, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());
	m_Sgi = nmDataAttribute("Sgi", 0.0, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());
	m_Swi= nmDataAttribute("Swi", 0.2, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());

    m_dTempGasRe = 100;
    m_ePhaseType = PHASE_Oil;
}

void nmDataReservoir::resetToDefaults()
{
	m_permeability.setValue(0.025);
	m_transmissibility.setValue(1000.0);
}

// 修改拷贝构造函数实现
nmDataReservoir::nmDataReservoir(const nmDataReservoir& other) {
    *this = other;
}

// 修改赋值运算符实现
nmDataReservoir& nmDataReservoir::operator=(const nmDataReservoir& other) {
    if (this != &other) {
        // 调用基类赋值运算符
        //ZxDataObjectDbl::operator=(other);

        // 复制所有成员变量
        m_initialPressure = other.m_initialPressure;
        m_permeability = other.m_permeability;
        m_thickness = other.m_thickness;
        m_porosity = other.m_porosity;
        m_kxKy = other.m_kxKy;

        // 油相PVT单值
        m_Bo = other.m_Bo;
        m_Miuo = other.m_Miuo;

        // 气相PVT单值
        m_Bg   = other.m_Bg;
        m_Miug = other.m_Miug;

        // 水相PVT单值
        m_Bw   = other.m_Bw;
        m_Miuw = other.m_Miuw;

        // 压缩系数
        m_Ct = other.m_Ct;
		m_Cf = other.m_Cf;

        m_reservoirType = other.m_reservoirType;
        m_transmissibility = other.m_transmissibility;

		m_Soi = other.m_Soi;
		m_Sgi = other.m_Sgi;
		m_Swi = other.m_Swi;
        m_dTempGasRe = other.m_dTempGasRe;
        m_ePhaseType = other.m_ePhaseType;
    }
    return *this;
}

nmDataReservoir::~nmDataReservoir() {
}

// 序列化 nmDataRegion 为 RapidJSON Value
rapidjson::Value nmDataReservoir::ToJsonValue(rapidjson::Document::AllocatorType& allocator) const
{
	// 创建一个 RapidJSON 对象类型的值
	rapidjson::Value reservoirObject(rapidjson::kObjectType);

	// 序列化 nmDataAttribute 类型的成员
	// 调用 nmDataAttribute 自身的 ToJsonValue 方法进行递归序列化
	reservoirObject.AddMember("InitialPressure", m_initialPressure.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Permeability", m_permeability.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Thickness", m_thickness.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Porosity", m_porosity.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Kx/Ky", m_kxKy.ToJsonValue(allocator), allocator);

	// 油相PVT单值
	reservoirObject.AddMember("Bo", m_Bo.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Miuo", m_Miuo.ToJsonValue(allocator), allocator);

	// 气相PVT单值
	reservoirObject.AddMember("Bg",   m_Bg.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Miug", m_Miug.ToJsonValue(allocator), allocator);

	// 水相PVT单值
	reservoirObject.AddMember("Bw",   m_Bw.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Miuw", m_Miuw.ToJsonValue(allocator), allocator);

	// 压缩系数
	reservoirObject.AddMember("Ct", m_Ct.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Cf", m_Cf.ToJsonValue(allocator), allocator);

	reservoirObject.AddMember("ReservoirType", m_reservoirType.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Transmissibility", m_transmissibility.ToJsonValue(allocator), allocator);

	// 初始饱和度
	reservoirObject.AddMember("Soi", m_Soi.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Sgi", m_Sgi.ToJsonValue(allocator), allocator);
	reservoirObject.AddMember("Swi", m_Swi.ToJsonValue(allocator), allocator);

	// 多相流类型
	reservoirObject.AddMember("PhaseType", static_cast<int>(m_ePhaseType), allocator);

	return reservoirObject; // 返回序列化后的 RapidJSON Value
}

// 从 RapidJSON Value 反序列化数据到 nmDataFault
void nmDataReservoir::FromJsonValue(const rapidjson::Value& jsonValue)
{
	// 反序列化 nmDataAttribute 类型的成员
	// 调用 nmDataAttribute 自身的 FromJsonValue 方法进行递归反序列化
	if (jsonValue.HasMember("InitialPressure") && jsonValue["InitialPressure"].IsObject()) {
		m_initialPressure.FromJsonValue(jsonValue["InitialPressure"]);
	}
	if (jsonValue.HasMember("Permeability") && jsonValue["Permeability"].IsObject()) {
		m_permeability.FromJsonValue(jsonValue["Permeability"]);
		// JSON中的单位文本不参与兼容换算，读取后的内部单位始终按求解器标准固定为D。
		m_permeability.setUnit("D");
	}
	if (jsonValue.HasMember("Thickness") && jsonValue["Thickness"].IsObject()) {
		m_thickness.FromJsonValue(jsonValue["Thickness"]);
	}
	if (jsonValue.HasMember("Porosity") && jsonValue["Porosity"].IsObject()) {
		m_porosity.FromJsonValue(jsonValue["Porosity"]);
	}
	if (jsonValue.HasMember("Kx/Ky") && jsonValue["Kx/Ky"].IsObject()) {
		m_kxKy.FromJsonValue(jsonValue["Kx/Ky"]);
	}

	// 油相PVT单值
	if (jsonValue.HasMember("Bo") && jsonValue["Bo"].IsObject()) {
		m_Bo.FromJsonValue(jsonValue["Bo"]);
	}
	if (jsonValue.HasMember("Miuo") && jsonValue["Miuo"].IsObject()) {
		m_Miuo.FromJsonValue(jsonValue["Miuo"]);
	}

	// 气相PVT单值
	if (jsonValue.HasMember("Bg") && jsonValue["Bg"].IsObject()) {
		m_Bg.FromJsonValue(jsonValue["Bg"]);
	}
	if (jsonValue.HasMember("Miug") && jsonValue["Miug"].IsObject()) {
		m_Miug.FromJsonValue(jsonValue["Miug"]);
	}

	// 水相PVT单值
	if (jsonValue.HasMember("Bw") && jsonValue["Bw"].IsObject()) {
		m_Bw.FromJsonValue(jsonValue["Bw"]);
	}
	if (jsonValue.HasMember("Miuw") && jsonValue["Miuw"].IsObject()) {
		m_Miuw.FromJsonValue(jsonValue["Miuw"]);
	}

	// 压缩系数
	if (jsonValue.HasMember("Ct") && jsonValue["Ct"].IsObject()) {
		m_Ct.FromJsonValue(jsonValue["Ct"]);
	}
	if (jsonValue.HasMember("Cf") && jsonValue["Cf"].IsObject()) {
		m_Cf.FromJsonValue(jsonValue["Cf"]);
	}

	if (jsonValue.HasMember("ReservoirType") && jsonValue["ReservoirType"].IsObject()) {
		m_reservoirType.FromJsonValue(jsonValue["ReservoirType"]);
	}
	if (jsonValue.HasMember("Transmissibility") && jsonValue["Transmissibility"].IsObject()) {
		m_transmissibility.FromJsonValue(jsonValue["Transmissibility"]);
	}

	// 初始饱和度
	if (jsonValue.HasMember("Soi") && jsonValue["Soi"].IsObject()) {
		m_Soi.FromJsonValue(jsonValue["Soi"]);
	}
	if (jsonValue.HasMember("Sgi") && jsonValue["Sgi"].IsObject()) {
		m_Sgi.FromJsonValue(jsonValue["Sgi"]);
	}
	if (jsonValue.HasMember("Swi") && jsonValue["Swi"].IsObject()) {
		m_Swi.FromJsonValue(jsonValue["Swi"]);
	}

	// 多相流类型
	if (jsonValue.HasMember("PhaseType") && jsonValue["PhaseType"].IsInt()) {
		m_ePhaseType = static_cast<NM_PHASE_TYPE>(jsonValue["PhaseType"].GetInt());
	}
}


nmDataReservoir* nmDataReservoir::s_instance = nullptr;

nmDataReservoir* nmDataReservoir::getInstance() {
    if (s_instance == nullptr) {
        s_instance = new nmDataReservoir();
    }
    return s_instance;
}

QString nmDataReservoir::getTableName() {
    return "nmDataReservoir";
}

//ZxDataObject* nmDataReservoir::clone() {
//    return new nmDataReservoir(*this);
//}

QString nmDataReservoir::type() const {
    return "nmDataReservoir";
}

bool nmDataReservoir::_parseData(VecVariant vec, int& n) {
    m_initialPressure = nmDataAttribute("Initial Pressure", vec[n++].toString(), "MPa");
    m_reservoirType = nmDataAttribute("Reservoir Type", vec[n++].toString(), "");
    m_Bo = nmDataAttribute("Bo", vec[n++].toString(), "");
    m_Miuo = nmDataAttribute("Miuo", vec[n++].toString(), "mPa.s");
    m_permeability = nmDataAttribute("Permeability", vec[n++].toString(), "D");
    m_thickness = nmDataAttribute("Thickness", vec[n++].toString(), "m");
    m_porosity = nmDataAttribute("Porosity", vec[n++].toString(), "");
    m_Ct = nmDataAttribute("Ct", vec[n++].toString(), "1/MPa");
    m_kxKy = nmDataAttribute("Kx/Ky", vec[n++].toString(), "");
    return true;
}

bool nmDataReservoir::_sumUpData(VecVariant& vec) {
    vec.append(m_initialPressure.getValue());
    vec.append(m_reservoirType.getValue());
    vec.append(m_Bo.getValue());
    vec.append(m_Miuo.getValue());
    vec.append(m_permeability.getValue());
    vec.append(m_thickness.getValue());
    vec.append(m_porosity.getValue());
    vec.append(m_Ct.getValue());
    vec.append(m_kxKy.getValue());
    return true;
}

void nmDataReservoir::onSerialize(ZxSerializer* ser) {
    ser->write("InitialPressure", m_initialPressure.getValue());
    ser->write("ReservoirType", m_reservoirType.getValue());
    ser->write("Bo", m_Bo.getValue());
    ser->write("Miuo", m_Miuo.getValue());
    ser->write("Permeability", m_permeability.getValue());
    ser->write("Thickness", m_thickness.getValue());
    ser->write("Porosity", m_porosity.getValue());
    ser->write("Ct", m_Ct.getValue());
    ser->write("KxKy", m_kxKy.getValue());
}

void nmDataReservoir::onDeserialize(ZxSerializer* ser) {
    QString tempValue;

    ser->read("InitialPressure", tempValue); m_initialPressure = nmDataAttribute("Initial Pressure", tempValue, "MPa");
    ser->read("ReservoirType", tempValue); m_reservoirType = nmDataAttribute("Reservoir Type", tempValue, "");
    ser->read("Bo", tempValue); m_Bo = nmDataAttribute("Bo", tempValue, "");
    ser->read("Miuo", tempValue); m_Miuo = nmDataAttribute("Miuo", tempValue, "mPa.s");
    // 序列化格式只保存数值，读取时明确按求解器基准单位D解释。
    ser->read("Permeability", tempValue); m_permeability = nmDataAttribute("Permeability", tempValue, "D");
    ser->read("Thickness", tempValue); m_thickness = nmDataAttribute("Thickness", tempValue, "m");
    ser->read("Porosity", tempValue); m_porosity = nmDataAttribute("Porosity", tempValue, "");
    ser->read("Ct", tempValue); m_Ct = nmDataAttribute("Ct", tempValue, "1/MPa");
    ser->read("KxKy", tempValue); m_kxKy = nmDataAttribute("Kx/Ky", tempValue, "");
}

QIcon nmDataReservoir::getIcon(bool expanded) const {
    return zxLoadIcon("Reservoir");
}

// ===== Getters and Setters =====

// 基础属性
void nmDataReservoir::setInitialPressure(const nmDataAttribute& attr) {
    m_initialPressure = attr;
}

nmDataAttribute& nmDataReservoir::getInitialPressure() {
    return m_initialPressure;
}

void nmDataReservoir::setPermeability(const nmDataAttribute& attr) {
    m_permeability = attr;
}

nmDataAttribute& nmDataReservoir::getPermeability() {
    return m_permeability;
}

void nmDataReservoir::setThickness(const nmDataAttribute& attr) {
    m_thickness = attr;
}

nmDataAttribute& nmDataReservoir::getThickness() {
    return m_thickness;
}

void nmDataReservoir::setPorosity(const nmDataAttribute& attr) {
    m_porosity = attr;
}

nmDataAttribute& nmDataReservoir::getPorosity() {
    return m_porosity;
}

void nmDataReservoir::setKxKy(const nmDataAttribute& attr) {
    m_kxKy = attr;
}

nmDataAttribute& nmDataReservoir::getKxKy() {
    return m_kxKy;
}

// 油相PVT单值参数
void nmDataReservoir::setBo(const nmDataAttribute& attr) {
    m_Bo = attr;
}

nmDataAttribute& nmDataReservoir::getBo() {
    return m_Bo;
}

void nmDataReservoir::setMiuo(const nmDataAttribute& attr) {
    m_Miuo = attr;
}

nmDataAttribute& nmDataReservoir::getMiuo() {
    return m_Miuo;
}

// 气相PVT单值参数
void nmDataReservoir::setBg(const nmDataAttribute& attr) {
    m_Bg = attr;
}

nmDataAttribute& nmDataReservoir::getBg() {
    return m_Bg;
}

void nmDataReservoir::setMiug(const nmDataAttribute& attr) {
    m_Miug = attr;
}

nmDataAttribute& nmDataReservoir::getMiug() {
    return m_Miug;
}

// 水相PVT单值参数
void nmDataReservoir::setBw(const nmDataAttribute& attr) {
    m_Bw = attr;
}

nmDataAttribute& nmDataReservoir::getBw() {
    return m_Bw;
}

void nmDataReservoir::setMiuw(const nmDataAttribute& attr) {
    m_Miuw = attr;
}

nmDataAttribute& nmDataReservoir::getMiuw() {
    return m_Miuw;
}

// 压缩系数
void nmDataReservoir::setCt(const nmDataAttribute& attr) {
    m_Ct = attr;
}

nmDataAttribute& nmDataReservoir::getCt() {
    return m_Ct;
}

void nmDataReservoir::setCf(const nmDataAttribute& attr) {
	m_Cf = attr;
}

nmDataAttribute& nmDataReservoir::getCf() {
	return m_Cf;
}

// 储层类型与传导率
void nmDataReservoir::setReservoirType(const nmDataAttribute& attr) {
    m_reservoirType = attr;
}

nmDataAttribute& nmDataReservoir::getReservoirType() {
    return m_reservoirType;
}

void nmDataReservoir::setTransmissibility(const nmDataAttribute &attr) {
    m_transmissibility = attr;
}

nmDataAttribute& nmDataReservoir::getTransmissibility() {
    return m_transmissibility;
}

// 初始饱和度
void nmDataReservoir::setSoi(const nmDataAttribute &attr) {
	m_Soi = attr;
}

nmDataAttribute& nmDataReservoir::getSoi() {
	return m_Soi;
}

void nmDataReservoir::setSgi(const nmDataAttribute &attr) {
	m_Sgi = attr;
}

nmDataAttribute& nmDataReservoir::getSgi() {
	return m_Sgi;
}

void nmDataReservoir::setSwi(const nmDataAttribute &attr) {
	m_Swi = attr;
}

nmDataAttribute& nmDataReservoir::getSwi() {
	return m_Swi;
}

// 气藏温度
void nmDataReservoir::setTempGasRe(double temp) {
    m_dTempGasRe = temp;
}

double nmDataReservoir::getTempGasRe() const {
    return m_dTempGasRe;
}

// 多相流类型
void nmDataReservoir::setPhaseType(NM_PHASE_TYPE phaseType) {
    m_ePhaseType = phaseType;
}

NM_PHASE_TYPE nmDataReservoir::getPhaseType() const {
    return m_ePhaseType;
}