Temperature Interpolation
The problems start with this code being fairly unreadable. A few simple rules can help:


Every comma is followed by a space: xi, yi instead of xi,yi.
Every binary operator like + is surrounded by a space on each side: 

int(round((xi[i] - xEast) / res, 0) + 1)


instead of int(round((xi[i]-xEast)/res,0)+1).
If an expression becomes to complicated, assign intermediate values to variables which also assist in explaining the code to a reader:

start = l * i
end = l * (i + 1)
chunk_x = xi[start:end]
chunk_y = yi[start:end]
interp = rbfInterp(x, y, temp0m, chunk_x, chunk_y)
result = interpData(chunk_x, chunk_y, z, interp, xEast, ySouth, xWest, yNorth, res)
grid2 += list(result)[start:end]


instead of

interp = rbfInterp(x,y,temp0m,xi[(l*i):(l*(i+1))],yi[(l*i):(l*(i+1))])
grid2 = grid2 + list(interpData(xi[(l*i):(l*(i+1))],yi[(l*i):(l*(i+1))],z,interp,xEast,ySouth,xWest,yNorth,res))[(l*i):(l*(i+1))]

At least try to provide meaningful names for your variables. Expressions like tmp2[tmp1] are unacceptable.
Avoid overly clever things like append = t.append; …; append(…), as you gain nothing by this indirection. t.append(…) directly.
In a function call, never put a space between the function name and the parens.


plot(x, y, temp0m, grid2) instead of plot (x,y,temp0m,grid2)
append(None) instead of append (None)

Most of Python is using the convention that variable names should use snake_case not camelCase. While consistency is more important than following any specific style, I suggest you adopt this common style.
Some variable names like chunkSize are misleading – this is the number of chunks, not their size.


Once we have cleaned up the code, we can investigate where performance could be increased. This is done mostly by avoiding unnecessary recalculations, but also by finding more efficient expressions.

For example, Rbf(x, y, temp0m, function='linear') will always produce the same value as the parameters never change. Therefore, calculate it once outside of any loops. Actually, you can remove the whole rbfInterp function.

Inside interpData, you translate and rescale the data: (yi[i]-ySouth)/res. If you do this outside of an explicit loop, then numpy can do this more efficiently: translated_yi = (yi - ySouth)/res.

The whole meshgrid business is obfuscating which calculation you are actually performing:

# prepare an interpolation function for this data
interpolation_function = Rbf(x, y, temp0m, function='linear')

# the actual coordinates
yis = np.linspace(ySouth + 0.1, yNorth - 0.1, ny)
xis = np.linspace(xEast + 0.1, xWest - 0.1, nx)

# the grid positions in the data file
yis_normalized = ((yis - ySouth)/res).round(0).astype(np.int)
xis_normalized = ((xis - xEast)/res + 1).round(0).astype(np.int)

grid = np.zeros((ny, nx))
for i in range(ny):
    heights = linecache.getline('dem_final2.txt', yis_normalized[i]).split(' ')
    for j in range(nx):
        height = float(height[xis_normalized[j]])
        result = height * z + interpolation_function(xis[j], yis[i])
        grid[i][j] = result if data_item &gt; -10 else np.nan


Some important points:


We fetch and parse each line once per line, instead of once per grid column.
We factor out repeated calculations outside of the loops
We avoid any confusing reshaping by writing the results directly into the correct data structure.
We try to avoid explicit loops by using numpy transformations


The purpose of the code is now much more obvious.

However, the usage of linecache is quite suspicious. We read the lines in sequential order, so caching will be of no use → read the file manually. You should also consider reading it into a numpy array, as the file in this form should only be using a few MB of memory:

heights = np.loadtxt('dem_final2.txt')
...
result = heights[yis_normalized[i]][xis_normalized[j]] * z + ...