'''
Created on Sun Aug 17 18:14:13 2014
code used for layered elastic model of surface loading
Wenliang Zhao
'''
import os, sys, re, glob, subprocess, math, time
import Rsmas_Utilib as ut
import ElasticSAR as es
import numpy as np
from osgeo import gdal
import time
para_list = ut.readProc(sys.argv[1])
processdir = para_list.get("processdir").strip()
disp_dir = processdir + "/InSAR"
line_insar = int(para_list.get("line_insar").strip())
col_insar = int(para_list.get("col_insar").strip())
left_lon_insar = float(para_list.get("left_lon_insar").strip())
top_lat_insar = float(para_list.get("top_lat_insar").strip())
res_lon_insar = float(para_list.get("res_lon_insar").strip())
res_lat_insar = float(para_list.get("res_lat_insar").strip())
lookAng_insar = float(para_list.get("lookAng").strip())
azimuth_insar = float(para_list.get("azimuth").strip())
utmZone = para_list.get("utmZone").strip()
res_x_utm = int(para_list.get("spacing").strip())
res_y_utm = res_x_utm
box = para_list.get("box")
method = para_list.get("method").strip()
def main():
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
if rank == 0:
procfile = sys.argv[1].strip()
para_list = ut.readProc(procfile)
ice_model_file = para_list.get("ice_model").strip() ### load model
ice_model_col = int(para_list.get("ice_model_col").strip())
grid_size = float(
para_list.get("grid_size").strip()) ### grid size in m
r = float(para_list.get("r").strip()) ### density
v = float(para_list.get("v").strip()) ### Poisson's ratio
E = int(para_list.get("E").strip()) ### Young's modulus
E_unit = para_list.get("E_unit").strip()
if E_unit == 'MPa':
E = E * (10**6)
elif E_unit == 'GPa':
E = E * (10**9)
else:
print "Unit of Young's modulus should be either MPa or GPa!\n"
exit(1)
print "Young's modulus is: ", E
angle_az = float(para_list.get("angle_az").strip())
angle_inc = float(para_list.get("angle_inc").strip())
ice_model_data = np.fromfile(ice_model_file, dtype=np.float32)
ice_model_lin = ice_model_data.size / ice_model_col
dis_model_v = np.zeros((ice_model_data.size), dtype=np.float32)
#dis_model_e = np.zeros((ice_model_data.size),dtype=np.float32).reshape(ice_model_lin,ice_model_col)
#dis_model_n = np.zeros((ice_model_data.size),dtype=np.float32).reshape(ice_model_lin,ice_model_col)
g = 9.81
vec_col = np.linspace(0, ice_model_col - 1, ice_model_col)
vec_lin = np.linspace(0, ice_model_lin - 1, ice_model_lin)
x1, y1 = np.meshgrid(vec_col, vec_lin)
x2, y2 = x1, y1
x1 = x1.reshape(x1.size)
y1 = y1.reshape(y1.size)
x2 = x2.reshape(ice_model_data.size)[np.abs(ice_model_data) > 0.00001]
y2 = y2.reshape(ice_model_data.size)[np.abs(ice_model_data) > 0.00001]
ice_model_data = ice_model_data[np.abs(ice_model_data) > 0.00001]
const_v = grid_size**2 * r * g * (1 - v**2) / E / np.pi
const_r = grid_size**2 * r * g * (1 + v) * (1 - 2 * v) / E / 2 / np.pi
print "2 constants are: ", const_v, " and ", const_r
dis_model_v_batch = np.array_split(dis_model_v, comm.size)
dis_model_v = None
dis_model_e_batch = dis_model_v_batch
dis_model_n_batch = dis_model_v_batch
x1_batch = np.array_split(x1, size)
y1_batch = np.array_split(y1, size)
else:
ice_model_data = None
dis_model_v_batch = None
dis_model_e_batch = None
dis_model_n_batch = None
x2 = None
y2 = None
const_v = None
const_r = None
x1_batch = None
y1_batch = None
grid_size = None
const_v = comm.bcast(const_v, root=0)
const_r = comm.bcast(const_r, root=0)
x2 = comm.bcast(x2, root=0)
y2 = comm.bcast(y2, root=0)
grid_size = comm.bcast(grid_size, root=0)
ice_model_data = comm.bcast(ice_model_data, root=0)
dis_model_v_batch = comm.scatter(dis_model_v_batch, root=0)
dis_model_e_batch = comm.scatter(dis_model_e_batch, root=0)
dis_model_n_batch = comm.scatter(dis_model_n_batch, root=0)
x1_batch = comm.scatter(x1_batch, root=0)
y1_batch = comm.scatter(y1_batch, root=0)
N_pix = len(x1_batch)
print N_pix, " data received!\n"
print "Shape of dis_model_v_batch is: ", dis_model_v_batch.shape
for ni in range(N_pix):
line1 = y1_batch[ni]
col1 = x1_batch[ni]
dis_y = line1 - y2
dis_x = col1 - x2
distance = np.power(np.power(dis_y, 2) + np.power(dis_x, 2), 0.5)
distance[distance < 1] = 10000000.
sin_ang = dis_x / distance
cos_ang = -1 * dis_y / distance
distance = distance * grid_size
dis_model_v_batch[ni] = np.sum(const_v * (1 / distance) *
ice_model_data)
dis_model_e_batch[ni] = np.sum(const_r * (1 / distance) *
ice_model_data * sin_ang)
dis_model_e_batch[ni] = np.sum(const_r * (1 / distance) *
ice_model_data * cos_ang)
dis_model_v_batch = comm.gather(dis_model_v_batch, root=0)
dis_model_e_batch = comm.gather(dis_model_e_batch, root=0)
dis_model_n_batch = comm.gather(dis_model_n_batch, root=0)
if rank == 0:
dis_model_v = dis_model_v_batch[0]
dis_model_e = dis_model_e_batch[0]
dis_model_n = dis_model_n_batch[0]
for ni in range(size - 1):
dis_model_v = np.hstack((dis_model_v, dis_model_v_batch[ni + 1]))
dis_model_e = np.hstack((dis_model_e, dis_model_e_batch[ni + 1]))
dis_model_n = np.hstack((dis_model_n, dis_model_n_batch[ni + 1]))
dis_model_los = dis_model_v * np.cos(angle_inc/180*np.pi) - \
dis_model_e * np.sin(angle_inc/180*np.pi) * np.cos(angle_az/180*np.pi) + \
dis_model_n * np.sin(angle_inc/180*np.pi) * np.sin(angle_az/180*np.pi)
dis_model_los.astype('float32').tofile(
'elastic_half_space_load_los_model')
import os
import re
import sys
import Rsmas_Utilib as ut
import glob
import subprocess
if len(sys.argv) != 2:
print '''
Usage: sparse_snaphu.py *.template
template must include path to interferogram
'''
exit(0)
para_list = ut.readProc(sys.argv[1])
int_str = para_list.get("unwrap_str")
#snaphu_def = os.getenv("INT_SCR").strip() + "/snaphu.default"
#para_snaphu1 = ut.readProc(snaphu_def)
if not para_list.get("method"):
method = "RSMAS"
else:
method = para_list.get("method").strip()
if method == "RSMAS":
processdir = os.getenv("PROCESSDIR")
#WDIR = processdir
processdir = processdir + "/" + sys.argv[1].partition('.')[0].strip()
folder_list = glob.glob(processdir + "/PO*")
elif method == "NSBAS":
processdir = para_list.get("processdir").strip()
#WDIR = processdir
def main():
para_list = ut.readProc(sys.argv[1])
interf_folder = para_list.get("interf").strip()
pattern = para_list.get("pattern").strip()
maskfile = para_list.get("mask").strip()
th_d = para_list.get("th_d")
if isinstance(th_d, str):
th_d = [th_d]
for ni in range(len(th_d)):
th_d[ni] = th_d[ni].strip()
th_c = para_list.get("th_c").strip()
iteration = len(th_d)
method = para_list.get("method").strip()
solution = para_list.get("solution").strip()
plane_type = para_list.get("plane_type").strip()
APS_type = para_list.get("APS_type").strip()
demfile = para_list.get("dem").strip()
step = para_list.get("step")
if isinstance(step, str):
step = [step]
for ni in range(len(step)):
step[ni] = step[ni].strip()
if para_list.get("software")=="RSMAS":
int_list = glob.glob(interf_folder+"/PO*")
else:
int_list = glob.glob(interf_folder+"/int_*")
N_line = 0
for f in int_list:
print "f is: ", f, "\n"
intfile = glob.glob(f+"/*"+pattern)[0]
intfile_rsc = intfile + ".rsc"
para_list1 = ut.readRsc(intfile_rsc)
temp_line = int(para_list1.get("FILE_LENGTH").strip())
if N_line < temp_line:
N_line = temp_line
print "maskfile is: ",bool(maskfile=='1'), "\n"
if maskfile == '1':
print "The maximum line is: ", N_line, "\n"
else:
Joblist = interf_folder + "/run_remove_ramp_aps"
for ni in range(iteration):
if ni < 2:
method = "0"
else:
method = "1"
k = 1
IN = open(Joblist, 'w')
for f in int_list:
intfile = glob.glob(f+"/*"+pattern)[0]
corfile = intfile[:-3]+"cor"
if ni>5:
APS_type == "2"
if ni % 2 == 0:
temp_str = "/nethome/wlzhao/python_code/remove_aps_wrap.py " + intfile + " " + corfile + " " + maskfile + " " + demfile + \
" " + plane_type + " " + "0" + " " + th_d[ni] + " " + th_c + " " + method + " " + \
solution + " " + str(ni+1) + " " + step[ni]
else:
temp_str = "/nethome/wlzhao/python_code/remove_aps_wrap.py " + intfile + " " + corfile + " " + maskfile + " " + demfile + \
" " + "0" + " " + APS_type + " " + th_d[ni] + " " + th_c + " " + method + " " + \
solution + " " + str(2) + " " + step[ni]
IN.write(temp_str)
if k<len(int_list):
IN.write("\n")
k = k+1
IN.close()
WT = "0:30"
temp_str = os.getenv("INT_SCR").strip() + "/createBatch_8.pl --workdir " + interf_folder + " --infile " + Joblist + " walltime=" + WT
temp_list = [os.getenv("INT_SCR").strip()+"/createBatch_8.pl","--workdir",interf_folder,"--infile",Joblist,"walltime="+WT]
sys.stderr.write(temp_str+"\n")
output = subprocess.Popen(temp_list).wait()
if output == 0:
print "Iteration ", str(ni+1), " has been done!\n"
else:
print "There is error happened. Check code again!\n"
exit(1)
print "All the jobs are done! Good luck!\n"
exit(0)
def main():
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
if rank == 0:
procfile = sys.argv[1].strip()
para_list = ut.readProc(procfile)
ice_model_file = para_list.get("ice_model").strip() ### load model
ice_model_col = int(para_list.get("ice_model_col").strip())
grid_size = float(para_list.get("grid_size").strip()) ### grid size in m
r = float(para_list.get("r").strip()) ### density
v = float(para_list.get("v").strip()) ### Poisson's ratio
E = int(para_list.get("E").strip()) ### Young's modulus
E_unit = para_list.get("E_unit").strip()
if E_unit == 'MPa':
E = E * (10 ** 6)
elif E_unit == 'GPa':
E = E * (10 ** 9)
else:
print "Unit of Young's modulus should be either MPa or GPa!\n"
exit(1)
print "Young's modulus is: ", E
angle_az = float(para_list.get("angle_az").strip())
angle_inc = float(para_list.get("angle_inc").strip())
ice_model_data = np.fromfile(ice_model_file,dtype=np.float32)
ice_model_lin = ice_model_data.size / ice_model_col
dis_model_v = np.zeros((ice_model_data.size),dtype=np.float32)
#dis_model_e = np.zeros((ice_model_data.size),dtype=np.float32).reshape(ice_model_lin,ice_model_col)
#dis_model_n = np.zeros((ice_model_data.size),dtype=np.float32).reshape(ice_model_lin,ice_model_col)
g = 9.81
vec_col = np.linspace(0,ice_model_col-1, ice_model_col)
vec_lin = np.linspace(0,ice_model_lin-1, ice_model_lin)
x1, y1 = np.meshgrid(vec_col, vec_lin)
x2, y2 = x1, y1
x1 = x1.reshape(x1.size)
y1 = y1.reshape(y1.size)
x2 = x2.reshape(ice_model_data.size)[np.abs(ice_model_data)>0.00001]
y2 = y2.reshape(ice_model_data.size)[np.abs(ice_model_data)>0.00001]
ice_model_data = ice_model_data[np.abs(ice_model_data)>0.00001]
const_v = grid_size ** 2 * r * g * (1-v**2) / E / np.pi
const_r = grid_size ** 2 * r * g * (1+v) * (1-2*v) / E / 2 / np.pi
print "2 constants are: ", const_v, " and ", const_r
dis_model_v_batch = np.array_split(dis_model_v,comm.size)
dis_model_v = None
dis_model_e_batch = dis_model_v_batch
dis_model_n_batch = dis_model_v_batch
x1_batch = np.array_split(x1,size)
y1_batch = np.array_split(y1,size)
else:
ice_model_data = None
dis_model_v_batch = None
dis_model_e_batch = None
dis_model_n_batch = None
x2 = None
y2 = None
const_v = None
const_r = None
x1_batch = None
y1_batch = None
grid_size = None
const_v = comm.bcast(const_v, root=0)
const_r = comm.bcast(const_r, root=0)
x2 = comm.bcast(x2, root=0)
y2 = comm.bcast(y2, root=0)
grid_size = comm.bcast(grid_size, root=0)
ice_model_data = comm.bcast(ice_model_data, root=0)
dis_model_v_batch = comm.scatter(dis_model_v_batch, root=0)
dis_model_e_batch = comm.scatter(dis_model_e_batch, root=0)
dis_model_n_batch = comm.scatter(dis_model_n_batch, root=0)
x1_batch = comm.scatter(x1_batch, root=0)
y1_batch = comm.scatter(y1_batch, root=0)
N_pix = len(x1_batch)
print N_pix, " data received!\n"
print "Shape of dis_model_v_batch is: ", dis_model_v_batch.shape
for ni in range(N_pix):
line1 = y1_batch[ni]
col1 = x1_batch[ni]
dis_y = line1 - y2
dis_x = col1 - x2
distance = np.power(np.power(dis_y,2) + np.power(dis_x,2), 0.5)
distance[distance<1] = 10000000.
sin_ang = dis_x / distance
cos_ang = -1 * dis_y / distance
distance = distance * grid_size
dis_model_v_batch[ni] = np.sum(const_v * (1 / distance) * ice_model_data)
dis_model_e_batch[ni] = np.sum(const_r * (1 /distance) * ice_model_data * sin_ang)
dis_model_e_batch[ni] = np.sum(const_r * (1 /distance) * ice_model_data * cos_ang)
dis_model_v_batch = comm.gather(dis_model_v_batch, root=0)
dis_model_e_batch = comm.gather(dis_model_e_batch, root=0)
dis_model_n_batch = comm.gather(dis_model_n_batch, root=0)
if rank == 0:
dis_model_v = dis_model_v_batch[0]
dis_model_e = dis_model_e_batch[0]
dis_model_n = dis_model_n_batch[0]
for ni in range(size-1):
dis_model_v = np.hstack((dis_model_v, dis_model_v_batch[ni+1]))
dis_model_e = np.hstack((dis_model_e, dis_model_e_batch[ni+1]))
dis_model_n = np.hstack((dis_model_n, dis_model_n_batch[ni+1]))
dis_model_los = dis_model_v * np.cos(angle_inc/180*np.pi) - \
dis_model_e * np.sin(angle_inc/180*np.pi) * np.cos(angle_az/180*np.pi) + \
dis_model_n * np.sin(angle_inc/180*np.pi) * np.sin(angle_az/180*np.pi)
dis_model_los.astype('float32').tofile('elastic_half_space_load_los_model')
def main():
para_list = ut.readProc(sys.argv[1])
interf_folder = para_list.get("interf").strip()
pattern = para_list.get("pattern").strip()
maskfile = para_list.get("mask").strip()
th_d = para_list.get("th_d")
if isinstance(th_d, str):
th_d = [th_d]
for ni in range(len(th_d)):
th_d[ni] = th_d[ni].strip()
th_c = para_list.get("th_c").strip()
iteration = len(th_d)
method = para_list.get("method").strip()
solution = para_list.get("solution").strip()
plane_type = para_list.get("plane_type").strip()
APS_type = para_list.get("APS_type").strip()
demfile = para_list.get("dem").strip()
step = para_list.get("step")
if isinstance(step, str):
step = [step]
for ni in range(len(step)):
step[ni] = step[ni].strip()
if para_list.get("software") == "RSMAS":
int_list = glob.glob(interf_folder + "/PO*")
else:
int_list = glob.glob(interf_folder + "/int_*")
N_line = 0
for f in int_list:
print "f is: ", f, "\n"
intfile = glob.glob(f + "/*" + pattern)[0]
intfile_rsc = intfile + ".rsc"
para_list1 = ut.readRsc(intfile_rsc)
temp_line = int(para_list1.get("FILE_LENGTH").strip())
if N_line < temp_line:
N_line = temp_line
print "maskfile is: ", bool(maskfile == '1'), "\n"
if maskfile == '1':
print "The maximum line is: ", N_line, "\n"
else:
Joblist = interf_folder + "/run_remove_ramp_aps"
for ni in range(iteration):
if ni < 2:
method = "0"
else:
method = "1"
k = 1
IN = open(Joblist, 'w')
for f in int_list:
intfile = glob.glob(f + "/*" + pattern)[0]
corfile = intfile[:-3] + "cor"
if ni > 5:
APS_type == "2"
if ni % 2 == 0:
temp_str = "/nethome/wlzhao/python_code/remove_aps_wrap.py " + intfile + " " + corfile + " " + maskfile + " " + demfile + \
" " + plane_type + " " + "0" + " " + th_d[ni] + " " + th_c + " " + method + " " + \
solution + " " + str(ni+1) + " " + step[ni]
else:
temp_str = "/nethome/wlzhao/python_code/remove_aps_wrap.py " + intfile + " " + corfile + " " + maskfile + " " + demfile + \
" " + "0" + " " + APS_type + " " + th_d[ni] + " " + th_c + " " + method + " " + \
solution + " " + str(2) + " " + step[ni]
IN.write(temp_str)
if k < len(int_list):
IN.write("\n")
k = k + 1
IN.close()
WT = "0:30"
temp_str = os.getenv("INT_SCR").strip(
) + "/createBatch_8.pl --workdir " + interf_folder + " --infile " + Joblist + " walltime=" + WT
temp_list = [
os.getenv("INT_SCR").strip() + "/createBatch_8.pl",
"--workdir", interf_folder, "--infile", Joblist,
"walltime=" + WT
]
sys.stderr.write(temp_str + "\n")
output = subprocess.Popen(temp_list).wait()
if output == 0:
print "Iteration ", str(ni + 1), " has been done!\n"
else:
print "There is error happened. Check code again!\n"
exit(1)
print "All the jobs are done! Good luck!\n"
exit(0)
import os
import re
import sys
import Rsmas_Utilib as ut
import glob
import subprocess
if len(sys.argv) != 2:
print '''
Usage: sparse_snaphu.py *.template
template must include path to interferogram
'''
exit(0)
para_list = ut.readProc(sys.argv[1])
int_str = para_list.get("unwrap_str")
#snaphu_def = os.getenv("INT_SCR").strip() + "/snaphu.default"
#para_snaphu1 = ut.readProc(snaphu_def)
if not para_list.get("method"):
method = "RSMAS"
else:
method = para_list.get("method").strip()
if method == "RSMAS":
processdir = os.getenv("PROCESSDIR")
#WDIR = processdir
processdir = processdir + "/" + sys.argv[1].partition('.')[0].strip()
folder_list = glob.glob(processdir+"/PO*")
elif method == "NSBAS":
processdir = para_list.get("processdir").strip()
#WDIR = processdir
import glob
if len(sys.argv) != 2:
print '''
Usage: sparse_snaphu.py int_folder
template must include path to interferogram
'''
exit(0)
int_folder = sys.argv[1].strip()
os.system("cd " + int_folder)
procfile = int_folder + "/sparse_para"
procfile1 = int_folder + "/snaphu_para"
para_list = ut.readProc(procfile)
para_list1 = ut.readProc(procfile1)
if para_list.get("interferogram"):
intfile = para_list.get("interferogram").strip()
else:
print "Must have path to interferogram!\n"
exit(0)
if para_list.get("coherence"):
corfile = para_list.get("coherence").strip()
else:
print "Must have path to coherence!\n"
exit(0)
'''
Created on Sun Aug 17 18:14:13 2014
code used for layered elastic model of surface loading
Wenliang Zhao
'''
import os,sys,re,glob,subprocess,math,time
import Rsmas_Utilib as ut
import ElasticSAR as es
import numpy as np
from osgeo import gdal
import time
para_list = ut.readProc(sys.argv[1])
processdir = para_list.get("processdir").strip()
disp_dir = processdir + "/InSAR"
line_insar = int(para_list.get("line_insar").strip())
col_insar = int(para_list.get("col_insar").strip())
left_lon_insar = float(para_list.get("left_lon_insar").strip())
top_lat_insar = float(para_list.get("top_lat_insar").strip())
res_lon_insar = float(para_list.get("res_lon_insar").strip())
res_lat_insar = float(para_list.get("res_lat_insar").strip())
lookAng_insar = float(para_list.get("lookAng").strip())
azimuth_insar = float(para_list.get("azimuth").strip())
utmZone = para_list.get("utmZone").strip()
res_x_utm = int(para_list.get("spacing").strip())
res_y_utm = res_x_utm
box = para_list.get("box")
method = para_list.get("method").strip()
