|
# 导入Flask类
|
from flask import Flask
|
from flask import jsonify
|
from flask import request
|
from flask_cors import CORS
|
import numpy as np
|
import flopy
|
import time
|
import os
|
import shutil
|
import json
|
import Base as base
|
import CalHead
|
import Predict
|
import ModelPeriod
|
import AchiveReport as achiveReport
|
import BigData
|
import OpenExcel
|
import DataTransf
|
import DataTask
|
|
# Flask函数接收一个参数__name__，它会指向程序所在的包
|
app = Flask(__name__)
|
CORS(app, supports_credentials=True, resources=r'/*')
|
|
|
#边界cell的数量
|
iboundCellSize = 240
|
iboundCellSize2= 213
|
|
iboundCellSizeTotle= 453
|
#河流cell的数量
|
riverCellSize = 109
|
|
iboundGroupSize = 10
|
iboundGroup={1:[1,86],2:[87,111],3:[112,142],4:[143,170],5:[171,240],
|
6:[241,282],7:[283,354],8:[355,393],9:[394,436],10:[437,453]}
|
|
iboundName =["西侧流入","北部流入","东北部流入","东部流出","南部流出",
|
"山区流入","永定河断裂流入","黄庄高丽断裂流入","八宝山断裂流入","昆明湖断裂入流"]
|
|
|
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 = base.not_allowed_model
|
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
|
print(jsondata)
|
if "initHeader" in jsondata:
|
dict["initHead"] = jsondata["initHeader"]
|
else:
|
dict["initHead"] = ""
|
return jsonify(dict)
|
|
#保存初始水头
|
@app.route('/saveInitHead', methods=['POST'])
|
def saveInitHead():
|
jsondata = request.get_json()
|
model_name = str(jsondata['model_name'])
|
initHeader = str(jsondata['initHead'])
|
|
if model_name == base.not_allowed_model or model_name in base.archive_models:
|
return jsonify("本模型为验证模型,不允许修改！")
|
|
jsondata= CalHead.get_model_json(model_name)
|
jsondata["initHeader"] = initHeader
|
|
jpath = base.model_dir + model_name +"\\prediction.json"
|
with open(jpath, "w",encoding='utf-8') as outfile:
|
json.dump(jsondata, outfile,ensure_ascii=False)
|
|
return jsonify("保存初始水头成功！")
|
|
#读取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)
|
|
ibound_segment={}
|
|
if layerparam == '1':
|
#边界
|
|
ibound_segment={"1":[0,85],"2":[86,110],"3":[111,141],"4":[142,169],"5":[170,239]}
|
|
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':
|
|
ibound_segment={"6":[0,41],"7":[42,113],"8":[114,152],"9":[153,195],"10":[196,212]}
|
|
for i in range(240, 453):
|
iboundarray.append(result[i])
|
|
ibounddict = {"name": "ibound", "data": iboundarray,"segment":ibound_segment}
|
|
riversgement={"1":[0,25],"2":[26,51],"3":[52,73],"4":[74,108]}
|
riverdict = {"name": "river", "data": riverarray,"segment":riversgement}
|
|
|
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'])
|
|
if model_name == base.not_allowed_model or model_name in base.archive_models:
|
return jsonify("本模型为验证模型,不允许修改！")
|
|
|
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,ipakcb= ml.wel.ipakcb,dtype=ml.wel.dtype,
|
options=ml.wel.options,
|
stress_period_data=lrcq)
|
ml.write_input()
|
|
return jsonify("数据更新完毕！")
|
|
|
#读取wel文件 参数为 Period
|
@app.route('/iboundList/', methods=['GET'])
|
def iboundList():
|
|
return jsonify(iboundName)
|
|
|
#边界的分组数据
|
@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']
|
|
if model_name == base.not_allowed_model or model_name in base.archive_models:
|
return jsonify("本模型为验证模型,不允许修改！")
|
|
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,ipakcb= ml.wel.ipakcb,
|
dtype=ml.wel.dtype,
|
options=ml.wel.options,
|
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']
|
|
if model_name == base.not_allowed_model or model_name in base.archive_models:
|
return jsonify("本模型为验证模型,不允许修改！")
|
|
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,ipakcb= ml.wel.ipakcb,
|
dtype=ml.wel.dtype,
|
options=ml.wel.options,
|
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'])
|
if model_name == base.not_allowed_model or model_name in base.archive_models:
|
return jsonify("本模型为验证模型,不允许修改！")
|
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 = round(float(dict[key]),8)
|
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,nrchop=ml.rch.nrchop,
|
ipakcb=ml.rch.ipakcb,
|
rech=ml.rch.rech,
|
irch =ml.rch.irch)
|
rch.write_file(check=False)
|
# ml.write_input()
|
|
return jsonify("降水参数修改完毕！")
|
|
|
#运行模型
|
@app.route('/runModel/', methods=['GET'])
|
def runModel():
|
model_name = request.args.get('model_name')
|
|
if model_name == base.not_allowed_model or model_name in base.archive_models:
|
return jsonify("本模型为验证模型,不允许修改！")
|
|
dicts= Predict.run_model_predict(model_name)
|
if dicts["code"] == 400:
|
return dicts["msg"]
|
#导出csv文件
|
CalHead.exportCsV(model_name)
|
|
# #更新模型三维网格配置
|
base.updateModelConfig(model_name)
|
|
# #创建模型的三维网格
|
filedir = base.model3d_path + model_name
|
|
if not os.path.exists(filedir):
|
os.makedirs(filedir, exist_ok=True)
|
|
base.callModelexe()
|
#计算水资源量和水均衡
|
CalHead.run_zonebudget_bal(model_name)
|
CalHead.run_zonebudget_res(model_name)
|
|
return jsonify(dicts["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('/saveModel/', methods=['GET'])
|
def saveModel():
|
|
modelname = request.args.get('name')
|
startTime = request.args.get('startTime')
|
endTime = request.args.get('endTime')
|
remark = request.args.get('remark')
|
file_list = os.listdir(base.model_dir)
|
for name in file_list:
|
if name == modelname:
|
return jsonify("模型名称已经存在，不允许重复创建！")
|
|
pers = ModelPeriod.get_months_in_range_count(startTime,endTime)
|
if pers > 60 :
|
return jsonify("模型创建失败，最多只允许60个周期的连续预测！")
|
|
dir = base.model_dir + modelname
|
|
if pers==12:
|
shutil.copytree(base.predictModel,dir)
|
else:
|
#如果不是一年的预测， 可能为 其他的多周期的预测 大于 12 个周期或者 小于12个周期
|
#首先把60个周期的当做模型clone一份， 然后修改 dis wel rch 文件
|
#wel 文件和 rch 文件不需要修改
|
shutil.copytree(base.predictModel60,dir)
|
Predict.updateDisFile(modelname,pers)
|
|
|
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)
|
|
CalHead.addModelJson(modelname, startTime, endTime, remark)
|
return jsonify("创建新模型完毕！")
|
|
|
#创建新模型
|
@app.route('/ModelList/', methods=['GET'])
|
def ModelList():
|
file_list = os.listdir(base.model_dir)
|
return jsonify(file_list)
|
|
#模型列表2
|
@app.route('/ModelList2/', methods=['GET'])
|
def ModelList2():
|
model_path = base.prefix +"\\model_list.json"
|
model_lsit=""
|
with open(model_path,encoding='utf-8') as f:
|
model_lsit = json.load(f)
|
return jsonify(model_lsit)
|
|
#删除模型
|
@app.route('/deleteModel/', methods=['GET'])
|
def deleteModel():
|
model_name = request.args.get('model_name')
|
if not model_name:
|
return jsonify({"code":400,"msg":"不允许删除空目录！"})
|
if model_name == base.not_allowed_model:
|
return jsonify({"code":400,"msg":"验证模型不允许删除！"})
|
|
paths = base.model_dir + model_name
|
shutil.rmtree(paths)
|
CalHead.removeModelJson(model_name)
|
return jsonify({"code":200,"msg":"模型删除完毕！"})
|
|
#预测场景参数
|
@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)
|
|
#运行模型
|
dicts = Predict.run_model(model_name)
|
return jsonify(dicts["msg"])
|
|
|
|
#预测场景参数
|
@app.route('/predictionparam', methods=['GET'])
|
def predictionparam():
|
|
model_name = request.args.get('model_name')
|
print(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')
|
types = request.form.get('type')
|
file = request.files.get('file')
|
print(types)
|
|
save_path = base.model_dir + model_name +"\\"+types+".xlsx"
|
print(save_path)
|
|
if file:
|
file.save(save_path)
|
|
data= DataTransf.base_excel(model_name,types)
|
|
resultDict={"code":200,"msg":"保存数据完毕！","data":data}
|
return jsonify(resultDict)
|
|
#观测井列表
|
@app.route('/obsWellList', methods=['GET'])
|
def obsWellList():
|
obswell= base.obs_well
|
dicts =[]
|
for wellId, name , row ,column in obswell:
|
obj ={"wellId":wellId,"name":name,"row":row,"column":column,"Layer":1}
|
dicts.append(obj)
|
|
return jsonify(dicts)
|
|
|
#观测井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')
|
wellId = request.args.get('wellId')
|
|
result = CalHead.obsChartdata(wellId,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')
|
value = float(request.args.get('value'))
|
return jsonify(Predict.predict_river_chart(base_year, start_time, end_time,value))
|
|
#预测页面 降水图表
|
@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')
|
value = float(request.args.get('value'))
|
return jsonify(Predict.predict_water_chart(base_year, start_time, end_time,value))
|
|
#开采量的折线图
|
@app.route('/predictWellChart', methods=['POST'])
|
def predictWellChart():
|
|
json = request.get_json()
|
base_year = str(json['base_year'])
|
start_time = json['start_time']
|
end_time = json['end_time']
|
data = json['data']
|
|
return jsonify(Predict.predict_well_chart(base_year, start_time, end_time,data))
|
|
#流场图
|
@app.route('/flowField', methods=['GET'])
|
def flowField():
|
model_name = request.args.get('model_name')
|
flowStartTime = int(request.args.get('flowStartTime'))
|
flowEndTime=int(request.args.get('flowEndTime'))
|
flowType= request.args.get('flowType')
|
# layer = int(request.args.get('layer') )
|
|
pic = str(int(time.time())) +".png"
|
outpath = base.flow_file + pic
|
dicts={}
|
if flowType=="水位":
|
dicts = achiveReport.flow_field(model_name, flowStartTime, 0,"流场信息", "online", outpath)
|
if flowType=="变幅":
|
dicts = achiveReport.getFlowFieldBF(model_name,flowStartTime,flowEndTime,outpath)
|
|
if flowType=="埋深":
|
dicts = achiveReport.getFlowFieldDepth(model_name,flowStartTime, 0,"流场信息", "online", outpath)
|
|
dicts["path"] = "/xishan/xinshanFlow/"+pic
|
return jsonify(dicts)
|
|
|
#初始水位流场信息
|
@app.route('/initWaterFlow/', methods=['GET'])
|
def initWater():
|
|
model_name = request.args.get('model_name')
|
layer = int(request.args.get('layer') )
|
pic = str(int(time.time())) +".png"
|
outpath = base.flow_file + pic
|
result= achiveReport.init_flow_field(model_name, layer,"初始流场信息", "online", outpath)
|
if result == "#":
|
return jsonify("")
|
return jsonify("/xishan/xinshanFlow/"+pic)
|
|
|
#降水均衡
|
@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():
|
model_name = request.args.get('model_name')
|
indexId = int(request.args.get('index_id'))
|
data = CalHead.earthWaterChart(model_name,indexId)
|
return jsonify(data)
|
|
#渗透系数
|
@app.route('/mdLpf', methods=['GET'])
|
def mdLpf():
|
lf = base.md_lpf
|
return jsonify(np.array(lf).tolist())
|
|
#水资源量
|
@app.route('/water_res', methods=['GET'])
|
def water_res():
|
model_name = request.args.get('model_name')
|
#水均衡
|
path1=base.muiltyModel + model_name +"\\water_bal.txt"
|
bal = CalHead.water_balance(model_name, path1)
|
path2=base.muiltyModel + model_name +"\\water_res.txt"
|
res = CalHead.water_res(model_name,path2)
|
|
dicts = BigData.mergeWaterData(bal,res)
|
|
initFlowPNG = achiveReport.getWaterResFiled(model_name,0)
|
dicts["initFlowPNG"]= "/xishan/xinshanFlow/" + initFlowPNG
|
|
FlowPNG2 = achiveReport.getWaterResFiled(model_name,11)
|
dicts["lastFlowPNG"]= "/xishan/xinshanFlow/" + FlowPNG2
|
dicts["initMonth"] ="2023-01"
|
dicts["lastMonth"] ="2023-12"
|
|
#水资源量
|
return dicts
|
|
|
#多模型地下水位
|
@app.route('/water_depth', methods=['GET'])
|
def water_depth():
|
model_name = request.args.get('model_name')
|
|
result = CalHead.water_depth(model_name)
|
#水资源量
|
return result
|
|
|
#小场景 单个模型水位 和变幅
|
@app.route('/xs_depth', methods=['GET'])
|
def xs_depth():
|
model_name = request.args.get('model_name')
|
|
res = CalHead.xs_depth(model_name)
|
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)
|
res["months"] = months
|
#水资源量
|
return res
|
|
#保存监测站降雨量
|
@app.route('/sensor_jyl_list', methods=['GET'])
|
def sensor_jyl_list():
|
model_name = request.args.get('model_name')
|
data = OpenExcel.read_excel(model_name)
|
return jsonify(data)
|
|
#保存监测站降雨量
|
@app.route('/sensor_jyl_save', methods=['POST'])
|
def sensor_jyl_save():
|
json = request.get_json()
|
model_name = str(json['model_name'])
|
data = json['data']
|
OpenExcel.write_excel(model_name,data)
|
return jsonify("保存完毕")
|
|
#月报内容
|
@app.route('/xs_month_report', methods=['GET'])
|
def xs_month_report():
|
model_name = request.args.get('model_name')
|
per = int(request.args.get('period'))
|
res = achiveReport.archive_report_content(model_name,per)
|
return res
|
|
|
#实时数据
|
@app.route('/xs_real_data', methods=['GET'])
|
def xs_real_data():
|
num = request.args.get('num')
|
start_time = request.args.get('start_time')
|
end_time = request.args.get('end_time')
|
types = request.args.get('types')
|
res = DataTask.get_data(types,num,start_time,end_time)
|
return jsonify(res)
|
|
|
if __name__ == '__main__':
|
#app.run() # 可以指定运行的主机IP地址，端口，是否开启调试模式
|
app.run(host="localhost", port=5000)
|
|
|
