Plot a function that has two parts, a constant part and a variable part with matplotlib

Let's use the function shown in image 1 as an example for my question:

in the image you can see a decreasing function from 0 to t2, in my case I have one specific value of y_axis, like in the image which is the "m".

1. I have the value for "m" I need to know the x_value of it in this example it's the "t1" value, how can i get it, I know the interp() function to get the y_values, I don't know if I can use it to do the reverse to get the y_values?

2. after getting the x_value of "m" (t1) I have to delete the values or the data before the "m" otherwise the values before the "t1" or replace them with a constant which is the "m" so it will look like a [y(x)=m] constant from 0 to t1 and look like a decreasing function from t1 to the end of the range of x_axis.

something like:

for example:

x_axis=np.arange(0, frequency, 0.1)
y_axis=function(x_axis)

(https://stackoverflow.com/questions/55343417/find-y-value-for-respective-x-from-python-plot-matplotlib)

Here is an example of what you could do using the NumPy interp and piecewise functions. I'll first define an example function to generate the data points, but after that will assume that you just have the points and don't have access to the original function (which is what I assume from your question).

from matplotlib import pyplot as plt
import numpy as np


# create the function (which you may not have access to)
def myfunc(t, r=1.0):
    return np.sqrt(r**2 - t**2)

# generate some points at which the function has been evaluate
t = np.linspace(0, 1, 100)  # 100 points linearly spaced between 0 and 1
y = myfunc(t)  # the function evaluated at the points t

# assuming we just have t and y (and not myfunc), interpolate the value of
# the function at some point t1
t1 = 0.68354844
y1 = np.interp(t1, t, y)

# use piecewise to get a function which is constant below t1 and follows the
# original function above t1 (potentially evaluated at different points in t)
tnew = np.linspace(0, 1, 150)  # new (more highly sampled) points at which to evaluate the function

condlist = [tnew <= t1, tnew > t1]  # list of piecewise conditions
funclist = [y1, np.interp]  # use constant y1 for first condition and interp for second condition

# evaluate the piecewise function at tnew
yvals = np.piecewise(tnew, condlist, funclist, t, y)

# plot the original function and the new version with the constant section
fig, ax = plt.subplots()
ax.plot(t, y, label="Original function")
ax.plot(tnew, yvals, ls="--", label="Piecewise function")
ax.legend()

fig.show()

which gives: