|
|
// netgen-2010.cpp : 定义控制台应用程序的入口点。
|
|
|
//
|
|
|
|
|
|
#include <stdafx.h>
|
|
|
#include "../include/singlePhaseSolver.h"
|
|
|
#include "windows.h"
|
|
|
#include <iostream>
|
|
|
#include <fstream>
|
|
|
#include <vector>
|
|
|
#include <string>
|
|
|
#include <sstream>
|
|
|
#include <cstdlib>
|
|
|
#include <algorithm>
|
|
|
#include <stdexcept>
|
|
|
#include <iterator>
|
|
|
using namespace std;
|
|
|
|
|
|
// 添加全局变量用于进度跟踪
|
|
|
int g_timeStep = 0;
|
|
|
int g_totalSteps = 100;
|
|
|
volatile bool g_calculationRunning = true;
|
|
|
UINT_PTR g_timerID = 0;
|
|
|
|
|
|
// 添加一个进度条显示函数
|
|
|
void ShowProgressBar(int timeStep, int totalSteps, int barWidth = 50) {
|
|
|
float progress = (float)timeStep / totalSteps;
|
|
|
int pos = barWidth * progress;
|
|
|
|
|
|
std::cout << "[";
|
|
|
|
|
|
for (int i = 0; i < barWidth; ++i) {
|
|
|
if (i < pos) {
|
|
|
std::cout << "=";
|
|
|
} else if (i == pos) {
|
|
|
std::cout << ">";
|
|
|
} else {
|
|
|
std::cout << " ";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
std::cout << "] " << int(progress * 100.0) << "% (" << timeStep << "/" << totalSteps << ")\r";
|
|
|
std::cout.flush();
|
|
|
}
|
|
|
|
|
|
// 添加定时器回调函数
|
|
|
VOID CALLBACK ProgressTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime) {
|
|
|
if (g_calculationRunning && g_totalSteps > 0) {
|
|
|
ShowProgressBar(g_timeStep, g_totalSteps);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 添加油藏类型枚举
|
|
|
enum RESERVOIR_TYPE {
|
|
|
OIL_RESERVOIR = 0, // 油藏
|
|
|
GAS_RESERVOIR = 1 // 气藏
|
|
|
};
|
|
|
|
|
|
void Ng2VTKWithData(Ng_Mesh *mesh, std::vector<double> vecField, std::string filename) {
|
|
|
std::cout << "Convert Ng_Mesh to vtk legacy file version of 4.2" << std::endl;
|
|
|
int i, nseg, ne, np, matnum;
|
|
|
int nodes[3];
|
|
|
double point[2];
|
|
|
// int *EleNodeNum;
|
|
|
// double *NodeCoors;
|
|
|
|
|
|
np = Ng_GetNP_2D(mesh);
|
|
|
ne = Ng_GetNE_2D(mesh);
|
|
|
nseg = Ng_GetNSeg_2D(mesh);
|
|
|
|
|
|
std::ofstream vtkFile;
|
|
|
vtkFile.open(filename);
|
|
|
|
|
|
if (!vtkFile.is_open()) {
|
|
|
std::cerr << "Error opening file: " << "mesh.vtk" << std::endl;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// Write VTK file header
|
|
|
vtkFile << "# vtk DataFile Version 4.1" << std::endl;
|
|
|
vtkFile << "Mesh data" << std::endl;
|
|
|
vtkFile << "ASCII" << std::endl;
|
|
|
vtkFile << "DATASET UNSTRUCTURED_GRID" << std::endl;
|
|
|
|
|
|
// Write points
|
|
|
vtkFile << "POINTS " << np << " float" << std::endl;
|
|
|
|
|
|
for (i = 1; i <= np; i++) {
|
|
|
Ng_GetPoint_2D(mesh, i, point);
|
|
|
vtkFile << point[0] << " " << point[1] << " " << 0 << std::endl;
|
|
|
}
|
|
|
|
|
|
// Write cells
|
|
|
vtkFile << "CELLS " << ne << " " << ne * 4 << std::endl;
|
|
|
std::vector<int> vecMater;
|
|
|
|
|
|
for (int i = 1; i <= ne; i++) {
|
|
|
Ng_GetElement_2D(mesh, i, nodes, &matnum);
|
|
|
vecMater.emplace_back(matnum);
|
|
|
vtkFile << 3 << " " << nodes[0] - 1 << " " << nodes[1] - 1 << " " << nodes[2] - 1 << std::endl;
|
|
|
}
|
|
|
|
|
|
// Write cell types
|
|
|
vtkFile << "CELL_TYPES " << ne << std::endl;
|
|
|
|
|
|
for (int i = 1; i <= ne; i++) {
|
|
|
vtkFile << 5 << std::endl; // Assuming getCellType is a method that returns the VTK cell type
|
|
|
}
|
|
|
|
|
|
// Write cell data
|
|
|
vtkFile << "CELL_DATA " << ne << std::endl;
|
|
|
vtkFile << "SCALARS Material int 1" << std::endl;
|
|
|
vtkFile << "LOOKUP_TABLE default" << std::endl;
|
|
|
|
|
|
for (int i = 0; i < vecMater.size(); i++) {
|
|
|
vtkFile << vecMater[i] << std::endl;
|
|
|
}
|
|
|
|
|
|
// Write point data
|
|
|
vtkFile << "POINT_DATA " << np << std::endl;
|
|
|
vtkFile << "SCALARS Pressure double 1" << std::endl;
|
|
|
vtkFile << "LOOKUP_TABLE default" << std::endl;
|
|
|
|
|
|
for (int i = 0; i < vecField.size(); i++) {
|
|
|
vtkFile << vecField[i] << std::endl;
|
|
|
}
|
|
|
|
|
|
vtkFile.close();
|
|
|
}
|
|
|
|
|
|
// 辅助函数
|
|
|
string trim(const string &s) {
|
|
|
size_t start = s.find_first_not_of(" \t");
|
|
|
size_t end = s.find_last_not_of(" \t");
|
|
|
return (start == string::npos) ? "" : s.substr(start, end - start + 1);
|
|
|
}
|
|
|
|
|
|
vector<string> split(const string &s, char delimiter) {
|
|
|
vector<string> tokens;
|
|
|
string token;
|
|
|
stringstream iss(s);
|
|
|
|
|
|
while (getline(iss, token, delimiter)) {
|
|
|
if (!token.empty()) {
|
|
|
tokens.push_back(token);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return tokens;
|
|
|
}
|
|
|
|
|
|
// 边界类型字符串转枚举值的辅助函数
|
|
|
BOUND_TYPE StringToBoundType(const string &s) {
|
|
|
string str = trim(s);
|
|
|
transform(str.begin(), str.end(), str.begin(), ::toupper);
|
|
|
|
|
|
if (str == "CONST_PRESSURE") {
|
|
|
return CONST_PRESSURE;
|
|
|
}
|
|
|
|
|
|
if (str == "CONST_RATE") {
|
|
|
return CONST_RATE;
|
|
|
}
|
|
|
|
|
|
if (str == "CLOSED") {
|
|
|
return CLOSED;
|
|
|
}
|
|
|
|
|
|
throw runtime_error("未知边界条件类型: " + str);
|
|
|
}
|
|
|
|
|
|
// 井类型字符串转枚举值的辅助函数
|
|
|
WELL_TYPE StringToWellType(const string &s) {
|
|
|
string str = trim(s);
|
|
|
transform(str.begin(), str.end(), str.begin(), ::toupper);
|
|
|
|
|
|
if (str == "VERTICAL") {
|
|
|
return VERTICAL;
|
|
|
}
|
|
|
|
|
|
if (str == "VERTICAL_FRACTURED") {
|
|
|
return VERTICAL_FRACTURED;
|
|
|
}
|
|
|
|
|
|
if (str == "MULTI_FRACED_HORIZONTAL") {
|
|
|
return MULTI_FRACED_HORIZONTAL;
|
|
|
}
|
|
|
|
|
|
throw runtime_error("未知井类型: " + str);
|
|
|
}
|
|
|
|
|
|
void ReadParameters(const string &filename,
|
|
|
CBoundShape &shape,
|
|
|
vector<CBoundWell>& wells,
|
|
|
vector<CBoundPolygon>& limits,
|
|
|
vector<Frac>& faults,
|
|
|
vector<Frac>& fracs,
|
|
|
double pBaseData[8],
|
|
|
TimeDis &timeDis,
|
|
|
RESERVOIR_TYPE &reservoirType,
|
|
|
double& reservoirTemp,
|
|
|
double gasComponents[32]) {
|
|
|
ifstream fin(filename.c_str());
|
|
|
|
|
|
if (!fin) {
|
|
|
throw runtime_error("无法打开文件: " + filename);
|
|
|
}
|
|
|
|
|
|
string line, section;
|
|
|
int currentWell = -1;
|
|
|
vector<CBoundWell> tempWells;
|
|
|
vector<CBoundPolygon> tempLimits;
|
|
|
CBoundPolygon *currentLimit = nullptr;
|
|
|
vector<Frac> tempFaults, tempFracs;
|
|
|
|
|
|
// 设置默认值
|
|
|
reservoirType = OIL_RESERVOIR; // 默认为油藏
|
|
|
reservoirTemp = 43; // 默认43℃
|
|
|
|
|
|
for (int i = 0; i < 32; i++) {
|
|
|
gasComponents[i] = 0.0; // 默认所有组分为0
|
|
|
}
|
|
|
|
|
|
// 设置TimeDis默认值
|
|
|
timeDis.nLogNum = 20; // 默认日志数量
|
|
|
timeDis.dTB = 1.0; // 默认时间基准值
|
|
|
|
|
|
while (getline(fin, line)) {
|
|
|
line = trim(line);
|
|
|
|
|
|
if (line.empty() || line[0] == '/') { // 跳过空行和注释行
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (line[0] == '[') {
|
|
|
section = line.substr(1, line.find(']') - 1);
|
|
|
transform(section.begin(), section.end(), section.begin(), ::toupper);
|
|
|
currentWell = -1;
|
|
|
currentLimit = nullptr;
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
vector<string> tokens = split(line, ' ');
|
|
|
|
|
|
if (tokens.empty()) {
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
try {
|
|
|
if (section == "RESERVOIRBASEDATA") {
|
|
|
if (tokens.size() == 9) { // 基础参数 + 油藏类型
|
|
|
for (int i = 0; i < 8; ++i) {
|
|
|
pBaseData[i] = atof(tokens[i].c_str());
|
|
|
}
|
|
|
|
|
|
// 读取油藏类型
|
|
|
reservoirType = (RESERVOIR_TYPE)atoi(tokens[8].c_str());
|
|
|
} else if (tokens.size() == 8) { // 仅基础参数，默认为油藏
|
|
|
for (int i = 0; i < 8; ++i) {
|
|
|
pBaseData[i] = atof(tokens[i].c_str());
|
|
|
}
|
|
|
|
|
|
reservoirType = OIL_RESERVOIR; // 默认为油藏
|
|
|
} else {
|
|
|
throw runtime_error("油藏基础参数个数不正确");
|
|
|
}
|
|
|
} else if (section == "GASRESERVOIRDATA" && reservoirType == GAS_RESERVOIR) {
|
|
|
if (tokens[0] == "Temperature" && tokens.size() >= 2) {
|
|
|
reservoirTemp = atof(tokens[1].c_str());
|
|
|
} else if (tokens[0] == "Components") {
|
|
|
// 等待下一行读取组分数据
|
|
|
} else if (tokens.size() >= 32) { // 气体组分数据，应有32个值
|
|
|
// 确保有足够的数字用于32个组分
|
|
|
int compCount = min(32, (int)tokens.size());
|
|
|
|
|
|
for (int i = 0; i < compCount; ++i) {
|
|
|
gasComponents[i] = atof(tokens[i].c_str());
|
|
|
}
|
|
|
}
|
|
|
} else if (section == "BOUNDSHAPE") {
|
|
|
if (tokens[0] == "type") {
|
|
|
if (tokens.size() < 2) {
|
|
|
throw runtime_error("缺少边界类型");
|
|
|
}
|
|
|
|
|
|
if (tokens[1] == "CIRCLE") {
|
|
|
shape.boundShape = CIRCLE;
|
|
|
} else if (tokens[1] == "POLYGON") {
|
|
|
shape.boundShape = POLYGON;
|
|
|
} else {
|
|
|
throw runtime_error("未知边界类型: " + tokens[1]);
|
|
|
}
|
|
|
} else if (shape.boundShape == CIRCLE) {
|
|
|
// 处理圆形边界参数
|
|
|
if (tokens[0] == "center" && tokens.size() >= 3) {
|
|
|
shape.cCenter.x = atof(tokens[1].c_str());
|
|
|
shape.cCenter.y = atof(tokens[2].c_str());
|
|
|
} else if (tokens[0] == "radius" && tokens.size() >= 2) {
|
|
|
shape.dRadius = atof(tokens[1].c_str());
|
|
|
} else if (tokens[0] == "boundType" && tokens.size() >= 2) {
|
|
|
shape.boundType = StringToBoundType(tokens[1]);
|
|
|
} else if (tokens[0] == "dConstPressure" && tokens.size() >= 2) {
|
|
|
shape.dConstPressure = atof(tokens[1].c_str());
|
|
|
}
|
|
|
} else if (shape.boundShape == POLYGON) {
|
|
|
// 处理多边形边界参数
|
|
|
if (tokens[0] == "segments" && tokens.size() >= 2) {
|
|
|
shape.nNumSegs = atoi(tokens[1].c_str());
|
|
|
} else if (tokens.size() >= 5) { // 至少需要4个坐标值和1个边界类型
|
|
|
Segment seg;
|
|
|
seg.p1 = Point(atof(tokens[0].c_str()), atof(tokens[1].c_str()));
|
|
|
seg.p2 = Point(atof(tokens[2].c_str()), atof(tokens[3].c_str()));
|
|
|
seg.boundType = StringToBoundType(tokens[4]);
|
|
|
|
|
|
// 如果是定压力边界，还需要读取压力值
|
|
|
if (tokens.size() >= 6 && seg.boundType == CONST_PRESSURE) {
|
|
|
seg.dConstPressure = atof(tokens[5].c_str());
|
|
|
}
|
|
|
|
|
|
shape.vecSegments.push_back(seg);
|
|
|
}
|
|
|
}
|
|
|
} else if (section == "WELLS") {
|
|
|
// 开始读取一个新井
|
|
|
if (tokens.size() >= 4 && currentWell == -1) {
|
|
|
CBoundWell well;
|
|
|
well.wellType = StringToWellType(tokens[0]);
|
|
|
|
|
|
// 根据井类型读取不同参数
|
|
|
if (well.wellType == VERTICAL) {
|
|
|
if (tokens.size() < 4) {
|
|
|
throw runtime_error("垂直井参数不足");
|
|
|
}
|
|
|
|
|
|
well.cCenter.x = atof(tokens[1].c_str());
|
|
|
well.cCenter.y = atof(tokens[2].c_str());
|
|
|
well.dRadius = atof(tokens[3].c_str());
|
|
|
tempWells.push_back(well);
|
|
|
currentWell = tempWells.size() - 1;
|
|
|
} else if (well.wellType == VERTICAL_FRACTURED) {
|
|
|
// 垂直压裂井参数
|
|
|
if (tokens.size() < 6) {
|
|
|
throw runtime_error("垂直压裂井参数不足");
|
|
|
}
|
|
|
|
|
|
well.cCenter.x = atof(tokens[1].c_str());
|
|
|
well.cCenter.y = atof(tokens[2].c_str());
|
|
|
well.dRadius = atof(tokens[3].c_str());
|
|
|
well.dBeta = atof(tokens[4].c_str());
|
|
|
well.dHf = atof(tokens[5].c_str());
|
|
|
tempWells.push_back(well);
|
|
|
currentWell = tempWells.size() - 1;
|
|
|
} else if (well.wellType == MULTI_FRACED_HORIZONTAL) {
|
|
|
// 多段压裂水平井参数，只需要读取cCenter, dRadius, dBeta, dLength, nFracNum, dHf
|
|
|
if (tokens.size() < 7) {
|
|
|
throw runtime_error("多段压裂水平井参数不足");
|
|
|
}
|
|
|
|
|
|
well.cCenter.x = atof(tokens[1].c_str());
|
|
|
well.cCenter.y = atof(tokens[2].c_str());
|
|
|
well.dRadius = atof(tokens[3].c_str());
|
|
|
well.dBeta = atof(tokens[4].c_str());
|
|
|
well.dLength = atof(tokens[5].c_str());
|
|
|
well.nFracNum = atoi(tokens[6].c_str());
|
|
|
|
|
|
if (tokens.size() >= 8) {
|
|
|
well.dHf = atof(tokens[7].c_str());
|
|
|
} else {
|
|
|
well.dHf = 100.0; // 默认裂缝半长
|
|
|
}
|
|
|
|
|
|
// 初始化裂缝数组
|
|
|
if (well.nFracNum > 0) {
|
|
|
well.vecFracs.resize(2 * well.nFracNum);
|
|
|
// 裂缝的具体位置会在模型中自动计算，这里不需要读取
|
|
|
}
|
|
|
|
|
|
tempWells.push_back(well);
|
|
|
currentWell = tempWells.size() - 1;
|
|
|
}
|
|
|
} else if (currentWell >= 0) {
|
|
|
CBoundWell &w = tempWells[currentWell];
|
|
|
|
|
|
if (tokens[0] == "bisMultFlow" && tokens.size() >= 2) {
|
|
|
w.bisMultFlow = (atoi(tokens[1].c_str()) != 0);
|
|
|
} else if (tokens[0] == "dSkin" && tokens.size() >= 2) {
|
|
|
w.dSkin = atof(tokens[1].c_str());
|
|
|
} else if (tokens[0] == "dC" && tokens.size() >= 2) {
|
|
|
w.dC = atof(tokens[1].c_str());
|
|
|
} else if (tokens[0] == "TimeQ" && tokens.size() >= 2) {
|
|
|
int numTimes = atoi(tokens[1].c_str());
|
|
|
w.nTimeNumQ = numTimes;
|
|
|
// w.pdTimeQ = new double[numTimes];
|
|
|
// w.pdQ = new double[numTimes];
|
|
|
} else if (tokens.size() == 2 && w.pdTimeQ != nullptr && w.pdQ != nullptr) {
|
|
|
// 这里假设TimeQ后的每行数据都是时间和流量对
|
|
|
static int timeIdx = 0;
|
|
|
|
|
|
if (timeIdx < w.nTimeNumQ) {
|
|
|
w.pdTimeQ[timeIdx] = atof(tokens[0].c_str());
|
|
|
w.pdQ[timeIdx] = atof(tokens[1].c_str());
|
|
|
timeIdx++;
|
|
|
|
|
|
// 如果读完了所有时间流量对，重置计数器
|
|
|
if (timeIdx == w.nTimeNumQ) {
|
|
|
timeIdx = 0;
|
|
|
}
|
|
|
}
|
|
|
} else if (tokens[0] == "FracFc" && w.wellType == VERTICAL_FRACTURED) {
|
|
|
if (tokens.size() - 1 != 2) {
|
|
|
throw runtime_error("导流能力数量不匹配");
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
|
w.wFrac[i].dFc = atof(tokens[i + 1].c_str());
|
|
|
}
|
|
|
} else if (tokens[0] == "FracFc" && w.wellType == MULTI_FRACED_HORIZONTAL) {
|
|
|
if (tokens.size() - 1 != w.nFracNum) {
|
|
|
throw runtime_error("导流能力数量不匹配");
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < w.nFracNum; ++i) {
|
|
|
w.vecFracs[2 * i].dFc = atof(tokens[i + 1].c_str());
|
|
|
w.vecFracs[2 * i + 1].dFc = atof(tokens[i + 1].c_str());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
} else if (section == "LIMITS") {
|
|
|
// 修改LIMITS部分，支持更多参数
|
|
|
if (tokens[0] == "segments" && tokens.size() >= 2) {
|
|
|
tempLimits.push_back(CBoundPolygon());
|
|
|
currentLimit = &tempLimits.back();
|
|
|
currentLimit->nNumSegs = atoi(tokens[1].c_str());
|
|
|
} else if (currentLimit && tokens[0] == "bAnchor" && tokens.size() >= 2) {
|
|
|
currentLimit->bAnchor = (atoi(tokens[1].c_str()) != 0);
|
|
|
} else if (currentLimit && tokens[0] == "dComKr" && tokens.size() >= 2) {
|
|
|
currentLimit->dComKr = atof(tokens[1].c_str());
|
|
|
} else if (currentLimit && tokens[0] == "dComW" && tokens.size() >= 2) {
|
|
|
currentLimit->dComW = atof(tokens[1].c_str());
|
|
|
} else if (currentLimit && tokens.size() == 4) { // 复合区的线段只需要4个坐标值
|
|
|
Segment seg;
|
|
|
seg.p1 = Point(atof(tokens[0].c_str()), atof(tokens[1].c_str()));
|
|
|
seg.p2 = Point(atof(tokens[2].c_str()), atof(tokens[3].c_str()));
|
|
|
// 复合区不需要指定边界类型
|
|
|
currentLimit->vecSegments.push_back(seg);
|
|
|
}
|
|
|
// 向后兼容旧格式（前两个数字分别表示nNumSegs和bAnchor）
|
|
|
else if (tokens.size() == 2 && isdigit(tokens[0][0]) && isdigit(tokens[1][0])) {
|
|
|
tempLimits.push_back(CBoundPolygon());
|
|
|
currentLimit = &tempLimits.back();
|
|
|
currentLimit->nNumSegs = atoi(tokens[0].c_str());
|
|
|
currentLimit->bAnchor = (atoi(tokens[1].c_str()) != 0);
|
|
|
}
|
|
|
} else if (section == "FAULTS") {
|
|
|
if (tokens.size() == 4) {
|
|
|
Frac f;
|
|
|
f.p1 = Point(atof(tokens[0].c_str()), atof(tokens[1].c_str()));
|
|
|
f.p2 = Point(atof(tokens[2].c_str()), atof(tokens[3].c_str()));
|
|
|
tempFaults.push_back(f);
|
|
|
}
|
|
|
} else if (section == "FRACS") {
|
|
|
if (tokens.size() >= 4) {
|
|
|
Frac f;
|
|
|
f.p1 = Point(atof(tokens[0].c_str()), atof(tokens[1].c_str()));
|
|
|
f.p2 = Point(atof(tokens[2].c_str()), atof(tokens[3].c_str()));
|
|
|
|
|
|
// 读取储能比和导流能力
|
|
|
if (tokens.size() >= 5) {
|
|
|
f.dW = atof(tokens[4].c_str());
|
|
|
} else {
|
|
|
f.dW = 1.0; // 默认储能比为1.0
|
|
|
}
|
|
|
|
|
|
if (tokens.size() >= 6) {
|
|
|
f.dFc = atof(tokens[5].c_str());
|
|
|
} else {
|
|
|
f.dFc = 100.0; // 默认导流能力为100.0
|
|
|
}
|
|
|
|
|
|
tempFracs.push_back(f);
|
|
|
}
|
|
|
} else if (section == "TIMEDIS") {
|
|
|
if (tokens[0] == "nLogNum" && tokens.size() >= 2) {
|
|
|
timeDis.nLogNum = atoi(tokens[1].c_str());
|
|
|
} else if (tokens[0] == "dTB" && tokens.size() >= 2) {
|
|
|
timeDis.dTB = atof(tokens[1].c_str());
|
|
|
}
|
|
|
}
|
|
|
} catch (const exception &e) {
|
|
|
throw runtime_error("解析错误[" + section + "]: " + e.what() + ", 行: " + line);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 最终数据校验
|
|
|
if (shape.boundShape == CIRCLE) {
|
|
|
if (shape.dRadius <= 0) {
|
|
|
throw runtime_error("圆形边界半径必须大于0");
|
|
|
}
|
|
|
} else if (shape.boundShape == POLYGON) {
|
|
|
if (shape.vecSegments.size() != shape.nNumSegs) {
|
|
|
throw runtime_error("多边形边界线段数量不匹配");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 给每个复合区设置默认值(如果未指定)，并验证线段数量
|
|
|
for (int i = 0; i < tempLimits.size(); ++i) {
|
|
|
if (tempLimits[i].dComKr <= 0) {
|
|
|
tempLimits[i].dComKr = 1.0; // 默认渗透率比为1.0
|
|
|
}
|
|
|
|
|
|
if (tempLimits[i].dComW <= 0) {
|
|
|
tempLimits[i].dComW = 1.0; // 默认孔隙度比为1.0
|
|
|
}
|
|
|
|
|
|
// 验证线段数量
|
|
|
if (tempLimits[i].vecSegments.size() != tempLimits[i].nNumSegs) {
|
|
|
throw runtime_error("复合区线段数量与指定数量不匹配");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 对气藏参数进行验证
|
|
|
if (reservoirType == GAS_RESERVOIR) {
|
|
|
|
|
|
// 检查气体组分总和是否接近1.0
|
|
|
double sum = 0.0;
|
|
|
|
|
|
for (int i = 0; i < 32; i++) {
|
|
|
sum += gasComponents[i];
|
|
|
}
|
|
|
|
|
|
if (sum < (100.0 - 1e-5) || sum > (100.0 + 1e-5)) {
|
|
|
// 使用stringstream替代to_string，以兼容VS2010
|
|
|
std::stringstream ss;
|
|
|
ss << sum;
|
|
|
throw runtime_error("气体组分总和应接近100.0%，当前值为: " + ss.str() + "%");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
wells = tempWells;
|
|
|
limits = tempLimits;
|
|
|
faults = tempFaults;
|
|
|
fracs = tempFracs;
|
|
|
}
|
|
|
|
|
|
void PrintWell(const CBoundWell &w) {
|
|
|
cout << "井类型: ";
|
|
|
|
|
|
switch (w.wellType) {
|
|
|
case VERTICAL:
|
|
|
cout << "垂直井";
|
|
|
break;
|
|
|
|
|
|
case VERTICAL_FRACTURED:
|
|
|
cout << "垂直压裂井";
|
|
|
break;
|
|
|
|
|
|
case MULTI_FRACED_HORIZONTAL:
|
|
|
cout << "多段压裂水平井";
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
cout << "\n位置: (" << w.cCenter.x << ", " << w.cCenter.y << ")"
|
|
|
<< "\n半径: " << w.dRadius
|
|
|
<< "\n流动模式: " << (w.bisMultFlow ? "多级" : "单级")
|
|
|
<< "\n时间流量数据(" << w.nTimeNumQ << "个):\n";
|
|
|
|
|
|
for (int i = 0; i < w.nTimeNumQ; ++i) {
|
|
|
cout << " " << w.pdTimeQ[i] << "hr: " << w.pdQ[i] << " m^3/d\n";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 气体组分名称数组(包含英文名称和化学式)
|
|
|
const char* gasComponentNames[32] = {
|
|
|
"甲烷(Methane, CH4)", "乙烷(Ethane, C2H6)", "丙烷(Propane, C3H8)",
|
|
|
"异丁烷(Isobutane, i-C4H10)", "正丁烷(n-Butane, n-C4H10)",
|
|
|
"异戊烷(Isopentane, i-C5H12)", "正戊烷(n-Pentane, n-C5H12)",
|
|
|
"己烷(Hexane, C6H14)", "庚烷(Heptane, C7H16)", "辛烷(Octane, C8H18)",
|
|
|
"壬烷(Nonane, C9H20)", "葵烷(Decane, C10H22)",
|
|
|
"十一烷(Undecane, C11H24)", "十二烷(Dodecane, C12H26)",
|
|
|
"十三烷(Tridecane, C13H28)", "十四烷(Tetradecane, C14H30)",
|
|
|
"十五烷(Pentadecane, C15H32)", "十六烷(Hexadecane, C16H34)",
|
|
|
"十七烷(Heptadecane, C17H36)", "十八烷(Octadecane, C18H38)",
|
|
|
"十九烷(Nonadecane, C19H40)", "廿烷(Icosane, C20H42)",
|
|
|
"廿一烷(Henicosane, C21H44)", "廿一以上烷(C21+)",
|
|
|
"硫化氢(Hydrogen Sulfide, H2S)", "二氧化碳(Carbon Dioxide, CO2)",
|
|
|
"氮气(Nitrogen, N2)", "水(Water, H2O)", "氢气(Hydrogen, H2)",
|
|
|
"氦气(Helium, He)", "氧气(Oxygen, O2)", "一氧化碳(Carbon Monoxide, CO)"
|
|
|
};
|
|
|
|
|
|
// 输出油藏基本信息及类型信息
|
|
|
void OutputReservoirInfo(const double pBaseData[8],
|
|
|
RESERVOIR_TYPE reservoirType,
|
|
|
double reservoirTemp,
|
|
|
const double gasComponents[32],
|
|
|
const std::string reservoirPara[8],
|
|
|
std::ostream &out = std::cout) {
|
|
|
out << "====================== 油藏基本信息 ======================" << std::endl;
|
|
|
|
|
|
// 使用预定义的参数名称
|
|
|
for (int i = 0; i < 8; i++) {
|
|
|
out << reservoirPara[i] << ": " << pBaseData[i];
|
|
|
|
|
|
// 根据参数类型添加适当的单位
|
|
|
if (i == 0) {
|
|
|
out << " MPa"; // 初始压力
|
|
|
} else if (i == 1) {
|
|
|
out << " mD"; // 渗透率
|
|
|
} else if (i == 2) {
|
|
|
out << " m"; // 厚度
|
|
|
} else if (i == 3) {
|
|
|
out << " mPa·s"; // 油粘度
|
|
|
} else if (i == 5) {
|
|
|
out << " (分数)"; // 孔隙度
|
|
|
} else if (i == 6) {
|
|
|
out << " MPa^(-1)"; // 岩石压缩系数
|
|
|
}
|
|
|
|
|
|
out << std::endl;
|
|
|
}
|
|
|
|
|
|
// 输出油藏类型
|
|
|
out << "油藏类型: ";
|
|
|
|
|
|
if (reservoirType == OIL_RESERVOIR) {
|
|
|
out << "油藏" << std::endl;
|
|
|
} else if (reservoirType == GAS_RESERVOIR) {
|
|
|
out << "气藏" << std::endl;
|
|
|
out << "气藏温度: " << reservoirTemp << " K" << std::endl;
|
|
|
|
|
|
// 输出气体组分
|
|
|
out << "气体组分:" << std::endl;
|
|
|
double sum = 0.0;
|
|
|
|
|
|
for (int i = 0; i < 32; i++) {
|
|
|
if (gasComponents[i] > 1.0e-5) {
|
|
|
// 只输出非零组分
|
|
|
// 使用名称数组，显示组分名称
|
|
|
out << " " << gasComponentNames[i] << ": " << gasComponents[i] << "%" << std::endl;
|
|
|
sum += gasComponents[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
out << "组分总和: " << sum << "%" << std::endl;
|
|
|
}
|
|
|
|
|
|
out << "==========================================================" << std::endl;
|
|
|
}
|
|
|
|
|
|
DWORD WINAPI MessagePumpThread(LPVOID lpParam) {
|
|
|
MSG msg;
|
|
|
|
|
|
while (g_calculationRunning) {
|
|
|
// 处理所有消息
|
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
|
|
TranslateMessage(&msg);
|
|
|
DispatchMessage(&msg);
|
|
|
}
|
|
|
|
|
|
// 显示进度条
|
|
|
ShowProgressBar(g_timeStep, g_totalSteps);
|
|
|
|
|
|
// 短暂休眠，减少CPU使用率
|
|
|
Sleep(100);
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
std::string reservoirPara[8] = {"初始压力", "渗透率", "厚度", "黏度", "体积系数", "孔隙度", "综合压缩系数", "渗透率各向异性系数"};
|
|
|
|
|
|
try {
|
|
|
CBoundShape shape;
|
|
|
vector<CBoundWell> wells;
|
|
|
vector<CBoundPolygon> limits;
|
|
|
vector<Frac> faults, fracs;
|
|
|
double pBaseData[8] = {0};
|
|
|
TimeDis timeDis;
|
|
|
RESERVOIR_TYPE reservoirType;
|
|
|
double reservoirTemp;
|
|
|
double gasComponents[32];
|
|
|
|
|
|
ReadParameters("input/case_oil_faults.txt", shape, wells, limits, faults, fracs, pBaseData, timeDis, reservoirType,
|
|
|
reservoirTemp, gasComponents);
|
|
|
|
|
|
// 详细油藏信息输出
|
|
|
OutputReservoirInfo(pBaseData, reservoirType, reservoirTemp, gasComponents, reservoirPara);
|
|
|
|
|
|
cout << "\n===== 井数据 =====" << endl;
|
|
|
|
|
|
for (size_t i = 0; i < wells.size(); ++i) {
|
|
|
cout << "\n井 " << i + 1 << ":\n";
|
|
|
PrintWell(wells[i]);
|
|
|
}
|
|
|
|
|
|
/************************************************************************/
|
|
|
/* load netgen mesh generation library and generate mesh */
|
|
|
/************************************************************************/
|
|
|
HMODULE hMod = LoadLibrary("meshgene.dll");
|
|
|
|
|
|
if (NULL == hMod) {
|
|
|
std::cout << "meshgene.dll加载失败！\n";
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
typedef Ng_Mesh *(*NgMeshGen2DByIn2d)(std::vector<CBoundWell>& wells, const std::vector<CBoundPolygon> limits,
|
|
|
const std::vector<Frac>& faults, const std::vector<Frac>& fracs, const CBoundShape & shape);
|
|
|
typedef Ng_Mesh *(*NgMeshGen2D)(std::string strFileIn2D);
|
|
|
typedef void *(*Ng2VTK)(Ng_Mesh * mesh);
|
|
|
// Get the address of the Ng_Mesh function
|
|
|
NgMeshGen2DByIn2d meshgene1 = (NgMeshGen2DByIn2d)GetProcAddress(hMod, "NgMeshGen2DByIn2d");
|
|
|
NgMeshGen2D meshgene2 = (NgMeshGen2D)GetProcAddress(hMod, "NgMeshGen2D");
|
|
|
|
|
|
if (NULL == meshgene1) {
|
|
|
FreeLibrary(hMod);
|
|
|
std::cout << "meshgene文件加载函数地址获取失败！\n";
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
Ng_Mesh *mesh = meshgene1(wells, limits, faults, fracs, shape);
|
|
|
|
|
|
// Ng_Mesh *mesh=meshgene2("netgen-1.in2d");
|
|
|
Ng2VTK ng = (Ng2VTK)GetProcAddress(hMod, "Ng2VTK");
|
|
|
ng(mesh);
|
|
|
// return 0;
|
|
|
|
|
|
HMODULE hMod_solver = LoadLibrary("singlePhaseSolverDll.dll");
|
|
|
|
|
|
if (NULL == hMod_solver) {
|
|
|
std::cout << "singlePhaseSolverDll.dll加载失败！\n";
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
// TimeDis timeDis;
|
|
|
// timeDis.dTB = 1.0e-5; //
|
|
|
// 初始化全局进度变量
|
|
|
g_timeStep = 0;
|
|
|
g_totalSteps = 100;
|
|
|
g_calculationRunning = true;
|
|
|
|
|
|
// 创建消息处理线程
|
|
|
std::cout << "开始计算，请稍候...\n";
|
|
|
HANDLE hThread = CreateThread(NULL, 0, MessagePumpThread, NULL, 0, NULL);
|
|
|
|
|
|
std::vector<std::pair<double, std::vector<double>>> vecFieldPre;
|
|
|
int timeStep, totalSteps;
|
|
|
|
|
|
if (reservoirType == OIL_RESERVOIR) {
|
|
|
typedef int (*Solver)(const TimeDis time, double* m_pBaseData, nglib::Ng_Mesh * mesh, std::vector<CBoundWell>& m_wWell,
|
|
|
const std::vector<CBoundPolygon>& comPolygon, const std::vector<Frac>& faultPolygon, std::vector<Frac>& fracs,
|
|
|
CBoundShape & outBound, std::vector<std::pair<double, std::vector<double>>>& vecNodePre, int& timeStep,
|
|
|
int& totalSteps);
|
|
|
Solver solverFun = (Solver)GetProcAddress(hMod_solver, "singlePhaseSolverNgmesh");
|
|
|
|
|
|
if (NULL == solverFun) {
|
|
|
FreeLibrary(hMod_solver);
|
|
|
std::cout << "singlePhaseSolverNgmesh failed!\n";
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
// std::vector<std::vector<Point>> vecBP;
|
|
|
// std::vector<std::pair<double, std::vector<double>>> vecFieldPre;
|
|
|
solverFun(timeDis, pBaseData, mesh, wells, limits, faults, fracs, shape, vecFieldPre, g_timeStep, g_totalSteps);
|
|
|
// 更新全局变量，确保显示100%进度
|
|
|
} else if (reservoirType == GAS_RESERVOIR) {
|
|
|
typedef int (*Solver)(double* component, double temperature, const TimeDis time, double* m_pBaseData,
|
|
|
nglib::Ng_Mesh * mesh, std::vector<CBoundWell>& m_wWell, const std::vector<CBoundPolygon>& comPolygon,
|
|
|
const std::vector<Frac>& faultPolygon, std::vector<Frac>& fracs, CBoundShape & outBound,
|
|
|
std::vector<std::pair<double, std::vector<double>>>& vecNodePre, int& timeStep, int& totalSteps);
|
|
|
Solver solverFun = (Solver)GetProcAddress(hMod_solver, "singlePhaseGasSolverNgmesh");
|
|
|
|
|
|
if (NULL == solverFun) {
|
|
|
FreeLibrary(hMod_solver);
|
|
|
std::cout << "singlePhaseGasSolverNgmesh failed!\n";
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
// std::vector<std::vector<Point>> vecBP;
|
|
|
solverFun(gasComponents, reservoirTemp, timeDis, pBaseData, mesh, wells, limits, faults, fracs, shape, vecFieldPre,
|
|
|
g_timeStep, g_totalSteps);
|
|
|
}
|
|
|
|
|
|
// 停止消息处理线程
|
|
|
g_calculationRunning = false;
|
|
|
|
|
|
if (hThread != NULL) {
|
|
|
WaitForSingleObject(hThread, INFINITE);
|
|
|
CloseHandle(hThread);
|
|
|
}
|
|
|
|
|
|
// 显示100%完成的进度条
|
|
|
ShowProgressBar(g_totalSteps, g_totalSteps);
|
|
|
std::cout << std::endl
|
|
|
<< "计算完成！" << std::endl;
|
|
|
|
|
|
// export bottom hole pressure history
|
|
|
std::cout << "Export log-log plot and history plot data to files\n";
|
|
|
std::ofstream historyFile;
|
|
|
historyFile.precision(12);
|
|
|
historyFile.open("output/history.txt");
|
|
|
|
|
|
if (!historyFile.is_open()) {
|
|
|
std::cerr << "Error opening file: " << "history.txt" << std::endl;
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
int nWell = 0;
|
|
|
|
|
|
for (int i = 0; i < wells[nWell].m_PressureData.size(); i++) {
|
|
|
historyFile << wells[nWell].m_PressureData[i].x << "\t" << wells[nWell].m_PressureData[i].y << "\t" << std::endl;
|
|
|
}
|
|
|
|
|
|
historyFile.close();
|
|
|
|
|
|
// calculate the pressure derivative
|
|
|
typedef bool (*PreLog)(const std::vector<Point>& pressure, const int& nSection, double* TimeQ, double* dQ, int nTimeQ,
|
|
|
std::vector<Point>& logPre);
|
|
|
PreLog preLogFun = (PreLog)GetProcAddress(hMod_solver, "logLogPre");
|
|
|
|
|
|
if (NULL == preLogFun) {
|
|
|
FreeLibrary(hMod_solver);
|
|
|
std::cout << "preLogFun failed!\n";
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
int nSection = 3;
|
|
|
std::vector<Point> logPre;
|
|
|
preLogFun(wells[nWell].m_PressureData, nSection, wells[nWell].pdTimeQ, wells[nWell].pdQ, wells[nWell].nTimeNumQ,
|
|
|
logPre);
|
|
|
|
|
|
// export the pressure derivative
|
|
|
std::ofstream logFile;
|
|
|
logFile.precision(8);
|
|
|
logFile.open("output/logPre.txt");
|
|
|
|
|
|
if (!logFile.is_open()) {
|
|
|
std::cerr << "Error opening file: " << "logPre.txt" << std::endl;
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < logPre.size(); i++) {
|
|
|
logFile << logPre[i].x << "\t" << logPre[i].y << "\t" << logPre[i].z << "\t" << logPre[i].pointData[1] << std::endl;
|
|
|
}
|
|
|
|
|
|
logFile.close();
|
|
|
|
|
|
// export the semi-log data
|
|
|
std::ofstream semiLogFile;
|
|
|
semiLogFile.precision(8);
|
|
|
semiLogFile.open("output/semiLogPre.txt");
|
|
|
|
|
|
if (!semiLogFile.is_open()) {
|
|
|
std::cerr << "Error opening file: " << "semiLogPre.txt" << std::endl;
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < logPre.size(); i++) {
|
|
|
semiLogFile << logPre[i].x << "\t" << logPre[i].pointData[0] << "\t" << std::endl;
|
|
|
}
|
|
|
|
|
|
semiLogFile.close();
|
|
|
|
|
|
// export the rate of selected well
|
|
|
std::ofstream rateFile;
|
|
|
rateFile.precision(8);
|
|
|
rateFile.open("output/rate.txt");
|
|
|
|
|
|
if (!rateFile.is_open()) {
|
|
|
std::cerr << "Error opening file: " << "rate.txt" << std::endl;
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < wells[nWell].nTimeNumQ; i++) {
|
|
|
rateFile << wells[nWell].pdTimeQ[i] << "\t" << wells[nWell].pdQ[i] << std::endl;
|
|
|
}
|
|
|
|
|
|
rateFile.close();
|
|
|
|
|
|
// export with pressure field with vtk format (version 4.2)
|
|
|
for (int i = 0; i < vecFieldPre.size(); ++i) {
|
|
|
if (i % 10 == 0) {
|
|
|
Ng2VTKWithData(mesh, vecFieldPre[i].second, "output/" + std::to_string(long double(i)) + ".vtk");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
FreeLibrary(hMod);
|
|
|
|
|
|
system("run_python.bat");
|
|
|
} catch (const exception &e) {
|
|
|
cerr << "错误: " << e.what() << endl;
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
} |