def extract_rfd(path, rfd=1, export=True):
"""
Function to extract the x and y values of a given rfd or to load it from previosly exportet .txt-files.
Parameters
----------
path : string
path to ogs directory
rfd : int
Extract the #rfd curve from the rfd file and save it as txt. rfd = 0 : no extraction
export : bool (Default: True)
If True .txt-files will be saved to the path.
Yields
------
A txt file for x and y values of given rfd and returns x_values and y_values as tuple of lists.
"""
import numpy as np
import os.path
from tools import get_ogs_task_id
# get the task if from ogs model run
task_id = get_ogs_task_id(path)
# extract the series given in the rfd file
if rfd != 0:
if os.path.exists(str(path) + "/" + "rfd_curve#" + str(rfd) + "_x_values.txt") and os.path.exists(str(path) + "/" + "rfd_curve#" + str(rfd) + "_y_values.txt"):
print("Txt.file of corresponding rfd curve already exists. Continuing without checking if content is correct.")
# load this files to return from function
x_values = np.loadtxt(path + "/" + "rfd_curve#" + str(rfd) + "_x_values.txt")
y_values = np.loadtxt(path + "/" + "rfd_curve#" + str(rfd) + "_y_values.txt")
else:
from ogs5py import OGS
ogs = OGS(task_root=path + "/", task_id=task_id)
ogs.rfd.read_file(path=path + "/" + task_id + ".rfd")
#print(ogs.rfd.get_block(rfd-1)[''])
y_values = np.asarray([y_values[1] for y_values in ogs.rfd.get_block(rfd - 1)[""]])
x_values = np.asarray([x_values[0] for x_values in ogs.rfd.get_block(rfd - 1)[""]])
if export == True:
np.savetxt(str(path) + "/" + "rfd_curve#" + str(rfd) + "_x_values.txt", x_values)
np.savetxt(str(path) + "/" + "rfd_curve#" + str(rfd) + "_y_values.txt", y_values)
else:
pass
return x_values, y_values
print(
"###################################################################"
)
print("Project folder: " + project_folder)
print("Observation point: " + obs_point)
print("Observation point location: " + str(obs_loc))
if obs_loc == aquifer_length:
print(
"Spectral analysis for the baseflow (not every functionality is considered (e.g. cut_index, norm))"
)
# If the current observation point is equal to the aquifer
# length, it is assumed that this polyline-file contains the
# velocities to calculate the baseflow. First, the baseflow
# is calculated and afterwards, the diffusivity is derived
# with the spectral analysis.
task_id = get_ogs_task_id(path_to_project)
baseflow = get_baseflow_from_polyline(
task_id, path_to_project,
path_to_project + "/" + task_id + "_ply_obs_01000_t" +
str(len(obs_point_list)) + "_GROUNDWATER_FLOW.tec")
# multiply the recharge time series with the aquifer length to get the total inflow
recharge = recharge_time_series * aquifer_length
try:
D, D_cov, frequency, Sqq = discharge_ftf_fit(
recharge, baseflow, time_step_size, aquifer_length)
except RuntimeError:
print("Optimal parameters not found...")
D[0], D_cov[0] = [np.nan, np.nan], [[np.nan, np.nan],
[np.nan, np.nan]]
print("popt and pcov have been set to np.nan")
except ValueError:
def extract_timeseries(path, which="mean", process="GROUNDWATER_FLOW"):
"""
Function to extract time series for each observation point and store them as .txt.
Parameters
----------
path : string
path to ogs directory
which : string, 'mean', 'max', 'min'
Which value should be taken from the vertical polyline of obs point.
process : string
Which modelling process.
Yields
------
.txt from every observation point with head values
"""
import numpy as np
from ogs5py.reader import readtec_polyline
import glob
import vtk
from tools import get_ogs_task_id
# pipe vtk output errors to file
errOut = vtk.vtkFileOutputWindow()
errOut.SetFileName(path + "/VTK_Error_Out.txt")
vtkStdErrOut = vtk.vtkOutputWindow()
vtkStdErrOut.SetInstance(errOut)
task_id = get_ogs_task_id(path)
# read all tec files
print("Reading tec-files from " + path)
# This will throw an ERROR which is redirected to VTK_Error_Out.txt
tecs = readtec_polyline(task_id=task_id, task_root=path)
# extract the time series and save them as .txt
for obs in tecs["GROUNDWATER_FLOW"].keys():
time_steps = len(tecs["GROUNDWATER_FLOW"][obs]["TIME"])
number_of_columns = tecs[process][obs]["HEAD"].shape[1]
if which == "max":
# select the maximum value (i.e. the uppermost) of polyline as long as polylines are defined from bottom to top
head_ogs_timeseries_each_obs = tecs[process][obs]["HEAD"][
:, number_of_columns - 1
]
elif which == "min":
# select the minimum value (i.e. the lowermost) of polyline as long as polylines are defined from bottom to top
head_ogs_timeseries_each_obs = tecs[process][obs]["HEAD"][:, 0]
elif which == "mean":
head_ogs_timeseries_each_obs = []
for step in range(time_steps):
# calculates the mean of each time step
head_ogs_timeseries_each_obs.append(
np.mean(tecs[process][obs]["HEAD"][step, :])
)
head_ogs_timeseries_each_obs = np.asarray(head_ogs_timeseries_each_obs)
np.savetxt(
str(path) + "/" + "head_ogs_" + str(obs) + "_" + str(which) + ".txt",
head_ogs_timeseries_each_obs,
)
