|
# 导入Flask类
|
from flask import Flask
|
from flask import jsonify
|
from flask import request
|
from flask_cors import CORS
|
import sys
|
import numpy as np
|
import pandas as pd
|
import flopy
|
import flopy.utils.binaryfile as bf
|
import csv
|
import time
|
from openpyxl import load_workbook
|
import os
|
import shutil
|
import Base as base
|
import CalHead
|
import Predict
|
import json
|
import ModelPeriod
|
|
# Flask函数接收一个参数__name__，它会指向程序所在的包
|
app = Flask(__name__)
|
CORS(app, supports_credentials=True, resources=r'/*')
|
|
|
#边界cell的数量
|
iboundCellSize = 240
|
iboundCellSize2= 213
|
|
iboundCellSizeTotle= 453
|
#河流cell的数量
|
riverCellSize = 109
|
|
iboundGroupSize = 5
|
iboundGroup={1:[1,86],2:[87,111],3:[112,142],4:[143,170],5:[171,240]}
|
|
iboundGroup3Size = 5
|
iboundGroup3={1:[241,282],2:[283,354],3:[355,393],4:[394,436],5:[437,453]}
|
|
riverGroupSize = 4
|
riverGroup={1:[454,479],2:[480,505],3:[506,527],4:[528,562]}
|
|
riverName=['雁翅-落坡岭','落坡岭-陇驾庄','陇驾庄-三家店','三家店-卢沟桥']
|
|
# 获取row colum layer Period 参数
|
|
def getModel(model_name):
|
model_ws=""
|
if not model_name:
|
model_ws = "202001_202212"
|
else:
|
model_ws = base.model_dir + model_name
|
|
m = flopy.modflow.Modflow.load("modflow.nam", model_ws = model_ws, exe_name="mf2005", verbose=True, version="mf2005", check=False)
|
return m
|
|
|
@app.route('/baseparam/', methods=['GET'])
|
def baseparam():
|
|
model_name = request.args.get('model_name')
|
ml= getModel(model_name)
|
nrclp = ml.get_nrow_ncol_nlay_nper()
|
dict = {"Row": nrclp[0], "Column": nrclp[1],
|
"Layer": nrclp[2], "period": nrclp[3]}
|
jsondata= CalHead.get_model_json(model_name)
|
start_time = jsondata["start_time"]
|
end_time = jsondata["end_time"]
|
|
months = ModelPeriod.get_months_in_range_ym(start_time, end_time)
|
dict["months"]=months
|
return jsonify(dict)
|
|
|
#读取wel文件 参数为 Period
|
@app.route('/welList/', methods=['GET'])
|
def welList():
|
|
period = request.args.get('period')
|
model_name = request.args.get('model_name')
|
layerparam = request.args.get('layer')
|
ml= getModel(model_name)
|
|
wel = []
|
wel = ml.wel.stress_period_data.__getitem__(kper=period)
|
result = []
|
welarray = []
|
riverarray = []
|
iboundarray = []
|
|
for Layer, Row, Column, Q in wel:
|
dict = {"Layer": str(Layer), "Row": str(
|
Row), "Column": str(Column), "Q": str(Q)}
|
result.append(dict)
|
|
result_len = len(result)
|
|
if layerparam == '1':
|
#边界
|
for i in range(0, 240):
|
iboundarray.append(result[i])
|
#河流
|
for i in range(453, 562):
|
riverarray.append(result[i])
|
|
for i in range(562, result_len):
|
r = int (result[i]['Row'])+1
|
c =int (result[i]['Column'])+1
|
name = base.getPumpWellName(str(r), str(c))
|
|
result[i]['name']=name
|
welarray.append(result[i])
|
|
elif layerparam == '3':
|
for i in range(240, 453):
|
iboundarray.append(result[i])
|
|
|
ibounddict = {"name": "ibound", "data": iboundarray}
|
riverdict = {"name": "river", "data": riverarray}
|
|
weldict = {"name": "wel", "data": welarray}
|
|
data = []
|
data.append(riverdict)
|
data.append(ibounddict)
|
data.append(weldict)
|
return jsonify(data)
|
|
#读取单个井的数据
|
@app.route('/wel/', methods=['GET'])
|
def wel():
|
row_param = request.args.get('Row')
|
column_param = request.args.get('Column')
|
model_name = request.args.get('model_name')
|
|
ml= getModel(model_name)
|
result = []
|
|
periods =CalHead.get_model_period(model_name)
|
periods_len= len(periods)
|
|
for i in range(periods_len):
|
wel = []
|
wel = ml.wel.stress_period_data.__getitem__(kper=i)
|
for Layer, Row, Column, Q in wel:
|
if str(Row) == row_param and str(Column) == column_param:
|
|
start_month = periods[i] + "-01"
|
end_month = ModelPeriod.last_day_of_month_start(periods[i])
|
|
dict = {"StartTime": start_month, "EndTime": end_month,
|
"Layer": str(Layer+1), "Row": str(Row), "Column": str(Column), "Q": str(Q)}
|
result.append(dict)
|
|
return jsonify(result)
|
|
|
#修改wel 文件
|
@app.route('/welInput', methods=['POST'])
|
def welInput():
|
|
json = request.get_json()
|
row_param = str(json['Row'])
|
column_param = str(json['Column'])
|
|
# model_name = request.args.get('model_name')
|
model_name = str(json['model_name'])
|
|
|
ml= getModel(model_name)
|
|
#有序的应力周期列表 json
|
data = json['data']
|
|
periods =CalHead.get_model_period(model_name)
|
periods_len= len(periods)
|
#循环设置wel文件，更新数据
|
# lrcq = {0:[[2, 3, 4, -100.]], 1:[[2, 3, 4, -100.]]}
|
lrcq = {}
|
for per in range(periods_len):
|
wel = []
|
wel = ml.wel.stress_period_data.__getitem__(kper=per)
|
|
#存储每个应力期的数据
|
array2d = []
|
|
for Layer, Row, Column, Q in wel:
|
array = []
|
if str(Row) == row_param and str(Column) == column_param:
|
|
array = [Layer, Row, Column, data[per]['Q']]
|
else:
|
array = [Layer, Row, Column, Q]
|
|
array2d.append(array)
|
|
lrcq[per] = array2d
|
|
flopy.modflow.ModflowWel(ml,stress_period_data=lrcq)
|
ml.write_input()
|
|
return jsonify("数据更新完毕！")
|
|
|
#读入电子表格文件生成wel 文件
|
@app.route('/cellFileInput', methods=['POST'])
|
def cellFileInput():
|
|
path ='C:\\Users\\ZMK\\Desktop\\待发送\\cell文件.xlsx'
|
|
data = get_cell_data(path)
|
|
lrcq= get_cell_struct(data["excel1"],data["excel2"],data["excel3"])
|
|
model_name = request.args.get('model_name')
|
|
ml= getModel(model_name)
|
|
flopy.modflow.ModflowWel(ml,stress_period_data=lrcq)
|
ml.write_input()
|
|
return jsonify("sucess")
|
|
|
def get_cell_struct(excel1,excel2,excel3):
|
lrcq={}
|
|
#周期数量
|
period = 7
|
start_row_index = 1
|
|
#边界数据 excel
|
for col in range (0,period):
|
array =[]
|
for row in range(start_row_index, len(excel1)):
|
|
arr = [excel1[row][2]-1,excel1[row][3]-1,excel1[row][4]-1,excel1[row][6+col]]
|
array.append(arr)
|
lrcq[col]= array
|
|
#河流数据 excel
|
for col in range (0,period):
|
array =[]
|
for row in range(start_row_index, len(excel2)):
|
|
arr = [excel2[row][2]-1,excel2[row][3]-1,excel2[row][4]-1,excel2[row][6+col]]
|
array.append(arr)
|
|
lrcq[col].extend(array)
|
|
#抽水数据 excel
|
for col in range (0,period):
|
|
array =[]
|
for row in range(start_row_index, len(excel3)):
|
|
arr = [excel3[row][1]-1,excel3[row][2]-1,excel3[row][3]-1,excel3[row][8+col]]
|
array.append(arr)
|
|
lrcq[col].extend(array)
|
|
return lrcq
|
|
|
|
#获取cell文件
|
#file_path 文件的路径
|
def get_cell_data(file_path):
|
|
workbook = load_workbook(file_path)
|
sheetnames = workbook.get_sheet_names()
|
#read first sheet
|
sheet1 = workbook[sheetnames[0]]
|
sheet2 = workbook[sheetnames[1]]
|
sheet3 = workbook[sheetnames[2]]
|
|
excel1 =[]
|
excel2=[]
|
excel3=[]
|
# 遍历读取整个工作表
|
for row in sheet1.iter_rows(values_only=True):
|
array=[]
|
for cell in row:
|
array.append(cell)
|
excel1.append(array)
|
|
for row in sheet2.iter_rows(values_only=True):
|
array=[]
|
for cell in row:
|
array.append(cell)
|
excel2.append(array)
|
|
for row in sheet3.iter_rows(values_only=True):
|
array=[]
|
for cell in row:
|
array.append(cell)
|
excel3.append(array)
|
|
# 关闭Excel文件
|
workbook.close()
|
data={"excel1":excel1,"excel2":excel2,"excel3":excel3}
|
|
return data
|
|
|
|
#读取wel文件 参数为 Period
|
@app.route('/iboundList/', methods=['GET'])
|
def iboundList():
|
|
return jsonify(iboundGroupSize)
|
|
|
#边界的分组数据
|
@app.route('/iboundData/', methods=['GET'])
|
def iboundData():
|
|
group_id = int(request.args.get('groupId'))
|
|
model_name = request.args.get('model_name')
|
ml= getModel(model_name)
|
data=[]
|
index = iboundGroup[group_id]
|
start_index = index[0]
|
|
periods =CalHead.get_model_period(model_name)
|
periods_len= len(periods)
|
|
for per in range(periods_len):
|
wel = []
|
wel = ml.wel.stress_period_data.__getitem__(kper = per)
|
|
result = []
|
|
for Layer, Row, Column, Q in wel:
|
dict = {"Layer": str(Layer+1), "Row": str(Row), "Column": str(Column), "Q": str(Q)}
|
result.append(dict)
|
|
start_month = periods[per] +"-01"
|
end_month = ModelPeriod.last_day_of_month_start(periods[per])
|
|
dict = {"StartTime": start_month, "EndTime": end_month,
|
"Layer": str(result[start_index]['Layer']),
|
"Q": str(result[start_index]['Q'])}
|
data.append(dict)
|
|
return jsonify(data)
|
|
|
#边界数据修改
|
@app.route('/iboundInput', methods=['POST'])
|
def iboundInput():
|
|
json = request.get_json()
|
no = int(json['No'])
|
#有序的应力周期列表 json
|
data = json['data']
|
|
model_name = json['model_name']
|
ml= getModel(model_name)
|
|
index = iboundGroup[no]
|
start_index = index[0]
|
end_index = index[1]
|
|
periods =CalHead.get_model_period(model_name)
|
periods_len= len(periods)
|
#循环设置wel文件，更新数据
|
# lrcq = {0:[[2, 3, 4, -100.]], 1:[[2, 3, 4, -100.]]}
|
lrcq = {}
|
for per in range(periods_len):
|
wel = []
|
wel = ml.wel.stress_period_data.__getitem__(kper=per)
|
|
#存储每个应力期的数据
|
array2d = []
|
|
count = 1
|
for Layer, Row, Column, Q in wel:
|
array = []
|
|
if count>= start_index and count <= end_index:
|
array = [Layer, Row, Column, data[per]['Q']]
|
else:
|
array = [Layer, Row, Column, Q]
|
|
array2d.append(array)
|
count +=1
|
|
lrcq[per] = array2d
|
|
flopy.modflow.ModflowWel(ml,stress_period_data=lrcq)
|
ml.write_input()
|
return jsonify("数据更新完毕！")
|
|
|
#读取wel文件 参数为 Period
|
@app.route('/riverList/', methods=['GET'])
|
def riverList():
|
|
riverResult=[]
|
for i in range(len(riverName)):
|
item ={"id":i+1,"name":riverName[i]}
|
riverResult.append(item)
|
return jsonify(riverResult)
|
|
|
#河流的数据
|
@app.route('/riverData/', methods=['GET'])
|
def riverData():
|
group_id = int(request.args.get('groupId'))
|
data=[]
|
index = riverGroup[group_id]
|
start_index = index[0]
|
|
model_name = request.args.get('model_name')
|
ml= getModel(model_name)
|
|
periods =CalHead.get_model_period(model_name)
|
periods_len= len(periods)
|
|
for per in range(periods_len):
|
wel = []
|
wel = ml.wel.stress_period_data.__getitem__(kper = per)
|
result = []
|
for Layer, Row, Column, Q in wel:
|
dict = {"Layer": str(Layer+1), "Row": str(
|
Row), "Column": str(Column), "Q": str(Q)}
|
result.append(dict)
|
|
|
start_month = periods[per] +"-01"
|
end_month = ModelPeriod.last_day_of_month_start(periods[per])
|
|
dict = {"StartTime": start_month, "EndTime": end_month,
|
"Layer": str(result[start_index]['Layer']),
|
"Q": str(result[start_index]['Q'])}
|
data.append(dict)
|
|
return jsonify(data)
|
|
|
|
#河流数据修改
|
@app.route('/riverInput', methods=['POST'])
|
def riverInput():
|
|
json = request.get_json()
|
no = int(json['No'])
|
#有序的应力周期列表 json
|
data = json['data']
|
|
index = riverGroup[no]
|
start_index = index[0]
|
end_index = index[1]
|
model_name = json['model_name']
|
|
ml= getModel(model_name)
|
|
periods =CalHead.get_model_period(model_name)
|
periods_len= len(periods)
|
|
#循环设置wel文件，更新数据
|
# lrcq = {0:[[2, 3, 4, -100.]], 1:[[2, 3, 4, -100.]]}
|
lrcq = {}
|
for per in range(periods_len):
|
wel = []
|
wel = ml.wel.stress_period_data.__getitem__(kper=per)
|
|
#存储每个应力期的数据
|
array2d = []
|
|
count = 1
|
for Layer, Row, Column, Q in wel:
|
array = []
|
|
if count>= start_index and count <= end_index:
|
array = [Layer, Row, Column, data[per]['Q']]
|
else:
|
array = [Layer, Row, Column, Q]
|
|
array2d.append(array)
|
count +=1
|
|
lrcq[per] = array2d
|
|
flopy.modflow.ModflowWel(ml,stress_period_data=lrcq)
|
ml.write_input()
|
return jsonify("数据更新完毕！")
|
|
|
#读取面 区域
|
@app.route('/precipitation/', methods=['GET'])
|
def precipitation():
|
model_name = request.args.get('model_name')
|
|
ml= getModel(model_name)
|
period = request.args.get('period')
|
|
per = int(period)
|
item = ml.rch.rech.__getitem__(kper=per)
|
value = item.get_value()
|
item_data = np.array(value).tolist()
|
|
#分组的字典下标值{"1":[(i,j)]}
|
areadict1= base.getAreaDictFirstIndex()
|
|
#分组的字典下标值{"1":[a,b,c,d]}
|
areadict = base.getAreaDictIndexArray()
|
|
#分组的字典下标值{"1":data}
|
areadatadict={}
|
|
for key in areadict1:
|
index1 = areadict1[key]
|
i = index1[0][0]
|
j= index1[0][1]
|
|
data= item_data[i][j]
|
|
areadatadict[str(key)]= format(data,'.8f')
|
|
result =[]
|
result.append(areadatadict)
|
result.append(areadict)
|
return jsonify(result)
|
|
|
#降水数据修改
|
# @app.route('/precipitationInput', methods=['POST'])
|
# def precipitationInput():
|
|
# json = request.get_json()
|
# model_name= str(json['model_name'])
|
# period = int(json['period'])
|
# #有序的应力周期列表 json
|
# data = json['data']
|
# dict = {}
|
# for i in range(len(data)):
|
# q1 = data[i]['Q1']
|
# q2 = data[i]['Q2']
|
# dict[q1] = q2
|
|
# ml= getModel(model_name)
|
|
# item = ml.rch.rech.__getitem__(kper=period)
|
# array2d = item.get_value()
|
|
# count = 0
|
|
# array2d_len = len(array2d)
|
|
# for i in range(array2d_len):
|
|
# array_len = len(array2d[i])
|
|
# for j in range(array_len):
|
|
# va = str(array2d[i][j])
|
# if va in dict:
|
# count += 1
|
# array2d[i][j] = float(dict[va])
|
|
# ml.rch.rech.__setitem__(key=period, value=array2d)
|
|
# rch = flopy.modflow.ModflowRch(ml, rech=ml.rch.rech)
|
# rch.write_file(check=False)
|
# #ml.write_input()
|
|
# return jsonify("降水参数修改完毕！")
|
|
|
@app.route('/precipitationInput', methods=['POST'])
|
def precipitationInput():
|
|
json = request.get_json()
|
model_name= str(json['model_name'])
|
period = int(json['period'])
|
#有序的应力周期列表 json
|
data = json['data']
|
dict = {}
|
for i in range(len(data)):
|
q1 = data[i]['Q1']
|
No = data[i]['No']
|
dict[No] = q1
|
|
ml= getModel(model_name)
|
|
item = ml.rch.rech.__getitem__(kper=period)
|
array2d = item.get_value()
|
areas= base.getAreas()
|
|
for key in areas:
|
|
tuples= areas[key]
|
zblen= len(tuples)
|
values = float(dict[key])
|
for i in range(zblen):
|
x = tuples[i][0]
|
y = tuples[i][1]
|
array2d[x][y]= values
|
|
ml.rch.rech.__setitem__(key=period, value=array2d)
|
|
rch = flopy.modflow.ModflowRch(ml, rech = ml.rch.rech)
|
rch.write_file(check=False)
|
# ml.write_input()
|
|
return jsonify("降水参数修改完毕！")
|
|
#导入csv文件
|
@app.route('/precipitationInputFile', methods=['POST'])
|
def precipitationInputFile():
|
|
model_name = request.args.get('model_name')
|
ml= getModel(model_name)
|
save_path = 'C:/Users/ZMK/Desktop/test1/' + "1111.xlsx"
|
file = request.files.get('file')
|
|
if file:
|
file.save(save_path)
|
|
#获取读取的excel 表格数据
|
stations = get_station_struct(save_path)
|
|
#循环周期
|
#perd周期变量
|
#array2d 每个周期的二维数组
|
for perd in range(0,36):
|
period = perd
|
item = ml.rch.rech.__getitem__(kper=period)
|
array2d = item.get_value()
|
|
array2d_len = len(array2d)
|
count = 0
|
#循环站点将一个period的所有stations进行字典存储
|
dict = {}
|
for k in range(0,len(stations)):
|
row = stations[k]["row"]
|
column = stations[k]["column"]
|
|
data_old = array2d[row][column]
|
data_new = stations[k]["data"][perd]
|
dict[data_old]= data_new
|
|
|
#循环设置每个period 的值
|
for i in range(array2d_len):
|
|
array_len = len(array2d[i])
|
|
for j in range(array_len):
|
|
va = str(array2d[i][j])
|
if va in dict:
|
array2d[i][j] = float(dict[va])
|
|
#将array2d重新set 对应的 item 周期内
|
ml.rch.rech.__setitem__(key=period, value=array2d)
|
|
rch = flopy.modflow.ModflowRch(ml, rech=ml.rch.rech)
|
rch.write_file(check=False)
|
# ml.write_input()
|
return '文件上传成功'
|
else:
|
return '上传失败，未选择文件'
|
|
|
#获取站点的数据，构造数据结构
|
#file_path 文件的路径
|
def get_station_struct(file_path):
|
|
workbook = load_workbook(file_path)
|
sheetnames = workbook.get_sheet_names()
|
#read first sheet
|
sheet = workbook[sheetnames[0]]
|
|
array2d_excel=[]
|
# 遍历读取整个工作表
|
for row in sheet.iter_rows(values_only=True):
|
array=[]
|
for cell in row:
|
array.append(cell)
|
array2d_excel.append(array)
|
# 关闭Excel文件
|
workbook.close()
|
|
#数据的开始下标
|
data_start_index=6
|
#信息的开始行号
|
start_row_index = 1
|
#存储站点信息
|
stations = []
|
for i in range (start_row_index,len(array2d_excel)):
|
st={"name":array2d_excel[i][1],"row":array2d_excel[i][4],"column":array2d_excel[i][5]}
|
data=[]
|
for j in range(data_start_index,len(array2d_excel[i])):
|
cell_data = array2d_excel[i][j]
|
cell_data= cell_data/100/30*0.15
|
data.append(round(cell_data, 6))
|
st["data"]= data
|
stations.append(st)
|
|
return stations
|
|
|
#运行模型
|
@app.route('/runModel/', methods=['GET'])
|
def runModel():
|
model_name = request.args.get('model_name')
|
|
msg= Predict.run_model_predict(model_name)
|
#导出csv文件
|
csvpath = CalHead.exportCsV(model_name)
|
|
#更新模型三维网格配置
|
base.updateModelConfig(model_name)
|
|
#创建模型的三维网格
|
filedir = base.model3d_path + model_name
|
|
print(filedir)
|
if not os.path.exists(filedir):
|
os.makedirs(filedir, exist_ok=True)
|
base.callModelexe()
|
|
return jsonify(msg)
|
|
#生成模型csv 文件
|
@app.route('/runModelCsv/', methods=['GET'])
|
def runModelCsv():
|
|
model_name = request.args.get('model_name')
|
outpath = CalHead.exportCsV(model_name)
|
result={"code":200,"msg":"生成计算结果CSV文件完毕！","output_path":outpath}
|
return jsonify(result)
|
|
|
|
#初始水位信息
|
@app.route('/initWater/', methods=['GET'])
|
def initWater():
|
|
period = request.args.get('period')
|
|
per = int(period)
|
|
model_name = request.args.get('model_name')
|
|
ml= getModel(model_name)
|
item = ml.rch.rech.__getitem__(kper=per)
|
value = item.get_value()
|
t = np.array(value).tolist()
|
return jsonify(t)
|
|
#创建新模型
|
@app.route('/saveModel/', methods=['GET'])
|
def saveModel():
|
|
modelname = request.args.get('name')
|
startTime = request.args.get('startTime')
|
endTime = request.args.get('endTime')
|
file_list = os.listdir(base.model_dir)
|
for name in file_list:
|
if name == modelname:
|
return jsonify("模型名称已经存在，不允许重复创建！")
|
|
dir = base.model_dir + modelname
|
shutil.copytree(base.predictModel,dir)
|
|
jsondata={"model_name":modelname,"start_time":startTime,"end_time":endTime}
|
predictionJson = base.model_dir + modelname +"\\prediction.json"
|
with open(predictionJson, "w",encoding='utf-8') as outfile:
|
json.dump(jsondata, outfile,ensure_ascii=False)
|
|
return jsonify("创建新模型完毕！")
|
|
|
#创建新模型
|
@app.route('/ModelList/', methods=['GET'])
|
def ModelList():
|
|
file_list = os.listdir(base.model_dir)
|
return jsonify(file_list)
|
|
|
#预测场景参数
|
@app.route('/prediction', methods=['POST'])
|
def prediction():
|
|
jsondata = request.get_json()
|
model_name = str(jsondata['model_name'])
|
file_list = os.listdir(base.model_dir)
|
if model_name not in file_list:
|
return jsonify("模型不存在，保存失败！")
|
|
predictionJson = base.model_dir + model_name +"\\prediction.json"
|
with open(predictionJson, "w",encoding='utf-8') as outfile:
|
json.dump(jsondata, outfile,ensure_ascii=False)
|
|
return jsonify("保存预测场景参数完毕！")
|
|
|
#预测场景参数
|
@app.route('/predictionparam', methods=['GET'])
|
def predictionparam():
|
|
model_name = request.args.get('model_name')
|
file_list = os.listdir(base.model_dir)
|
if model_name not in file_list:
|
return jsonify("模型不存在！")
|
|
predictiondata=""
|
prediction_path = base.model_dir + model_name +"\\prediction.json"
|
if os.path.exists(prediction_path):
|
with open(prediction_path,encoding='utf-8') as f:
|
predictiondata = json.load(f)
|
|
welldata=""
|
well_path = base.model_dir + model_name +"\\pump_well.json"
|
|
if os.path.exists(well_path):
|
with open(well_path,encoding='utf-8') as f:
|
welldata = json.load(f)
|
|
if not welldata and not predictiondata:
|
return jsonify([])
|
|
if not predictiondata:
|
return jsonify(welldata)
|
|
if not welldata:
|
return jsonify(predictiondata)
|
|
merged_dict = {**predictiondata, **welldata}
|
|
return jsonify(merged_dict)
|
|
|
|
#预测场景--保存井
|
@app.route('/pumpsavewell', methods=['POST'])
|
def pump_savewell():
|
|
jsondata = request.get_json()
|
model_name = str(jsondata['model_name'])
|
file_list = os.listdir(base.model_dir)
|
if model_name not in file_list:
|
return jsonify("模型不存在，保存失败！")
|
|
pump_json = base.model_dir + model_name +"\\pump_well.json"
|
with open(pump_json, "w") as outfile:
|
json.dump(jsondata, outfile)
|
|
return jsonify("保存井参数完毕！")
|
|
#预测场景--导入井数据
|
@app.route('/pumpimportdata', methods=['POST'])
|
def pump_importdata():
|
|
model_name = request.form.get('model_name')
|
|
# ml= getModel(model_name)
|
file = request.files.get('file')
|
|
save_path = base.model_dir + model_name +"\\extra_cell.xlsx"
|
|
if file:
|
file.save(save_path)
|
|
resultDict={"code":200,"msg":"保存数据完毕！"}
|
return jsonify(resultDict)
|
|
#观测井列表
|
@app.route('/obsWellList', methods=['GET'])
|
def obsWellList():
|
obswell= base.obs_well
|
dict =[]
|
for name , row ,column in obswell:
|
obj ={"name":name,"row":row,"column":column,"Layer":1}
|
dict.append(obj)
|
|
return jsonify(dict)
|
|
|
#观测井chart数据接口
|
@app.route('/obsWellChart', methods=['GET'])
|
def obsWellChart():
|
model_name = request.args.get('model_name')
|
row = request.args.get('row')
|
column = request.args.get('column')
|
|
result = CalHead.obsChartdata(model_name, row, column)
|
|
return jsonify(result)
|
|
|
#预测页面 永定河图表
|
@app.route('/predictRiverChart', methods=['GET'])
|
def predictRiverChart():
|
base_year = request.args.get('base_year')
|
start_time = request.args.get('start_time')
|
end_time = request.args.get('end_time')
|
|
return jsonify(Predict.predict_river_chart(base_year, start_time, end_time))
|
|
#预测页面 降水图表
|
@app.route('/predictWaterChart', methods=['GET'])
|
def predictWaterChart():
|
base_year = request.args.get('base_year')
|
start_time = request.args.get('start_time')
|
end_time = request.args.get('end_time')
|
return jsonify(Predict.predict_water_chart(base_year, start_time, end_time))
|
|
@app.route('/heatmap', methods=['GET'])
|
def heatmap():
|
model_name = request.args.get('model_name')
|
period = request.args.get('period')
|
data = CalHead.heatmapdata(model_name,period)
|
maximum_value = np.max(data)
|
return jsonify(np.array(data).tolist())
|
|
|
#降水均衡
|
@app.route('/waterEqu', methods=['GET'])
|
def waterEqu():
|
model_name = request.args.get('model_name')
|
data = CalHead.waterEqu(model_name)
|
return jsonify(data)
|
|
|
#地球页面数据
|
@app.route('/earthWaterChart', methods=['GET'])
|
def earthWaterChart():
|
|
indexId = int(request.args.get('index_id'))
|
data = CalHead.earthWaterChart("202001_202212",indexId)
|
return jsonify(data)
|
|
if __name__ == '__main__':
|
#app.run() # 可以指定运行的主机IP地址，端口，是否开启调试模式
|
app.run(host="192.168.0.122", port=5000)
|
