def save_Nadir(cycle, ngrid, errnad, err, p, out_var, time=[]):
if type(ngrid.ipass) == str:
ofile = '{}nadir_c{:02d}_{}.nc'.format(p.file_output, cycle + 1,
ngrid.ipass)
else:
ofile = '{}nadir_c{:02d}_p{:03d}.nc'.format(p.file_output, cycle + 1,
ngrid.ipass)
OutputNadir = rw_data.Sat_nadir(nfile=ofile,
lon=(ngrid.lon + 360) % 360,
lat=ngrid.lat,
time=time,
x_al=ngrid.x_al,
cycle=ngrid.cycle)
OutputNadir.first_time = p.first_time
OutputNadir.gridfile = ngrid.gridfile
if err is None:
OutputNadir.write_data(out_var,
nadir_err=errnad.nadir,
SSH_obs=errnad.SSH)
else:
OutputNadir.write_data(out_var,
nadir_err=errnad.nadir,
SSH_obs=errnad.SSH,
pd_err_1b=err.wet_tropo1nadir,
pd=err.wtnadir,
pd_err_2b=err.wet_tropo2nadir)
return None
def save_Nadir(cycle,
ngrid,
errnad,
err,
p,
time=[],
vindice_nadir=[],
SSH_true_nadir=[]):
file_outputnadir = p.file_output + 'nadir_c' + str(cycle + 1).zfill(
2) + '_p' + str(ngrid.ipass).zfill(3) + '.nc'
OutputNadir = rw_data.Sat_nadir(file=file_outputnadir,
lon=(ngrid.lon + 360) % 360,
lat=ngrid.lat,
time=time,
x_al=ngrid.x_al,
cycle=ngrid.cycle)
OutputNadir.gridfile = ngrid.gridfile
OutputNadir.write_data(SSH_model=SSH_true_nadir,
index=vindice_nadir,
nadir_err=errnad.nadir,
SSH_obs=errnad.SSH,
pd_err_1b=err.wet_tropo1nadir,
pd=err.wtnadir,
pd_err_2b=err.wet_tropo2nadir)
return None
def load_ngrid(sgridfile, p):
ipass = int(sgridfile[-6: -3])
# Load Nadir track file
nfile = '{:s}nadir_p{:03d}.nc'.format((p.filesgrid).strip(), ipass)
ngrid = rw_data.Sat_nadir(nfile=nfile)
cycle = 0
x_al = []
al_cycle = 0
timeshift = 0
ngrid.load_orb(cycle=cycle, x_al=x_al, al_cycle=al_cycle,
timeshift=timeshift)
ngrid.loncirc = numpy.rad2deg(numpy.unwrap(ngrid.lon))
ngrid.ipass = ipass
return ngrid
def load_ngrid(sgridfile, p):
ipass = int(sgridfile[-6:-3])
## Load Nadir track file
ngrid = rw_data.Sat_nadir(file=p.filesgrid + 'nadir_p' +
str(ipass).zfill(3) + '.nc')
cycle = 0
x_al = []
al_cycle = 0
timeshift = 0
ngrid.load_orb(cycle=cycle,
x_al=x_al,
al_cycle=al_cycle,
timeshift=timeshift)
ngrid.loncirc = numpy.rad2deg(numpy.unwrap(ngrid.lon))
ngrid.ipass = ipass
return ngrid
def worker_method_nadir(*args, **kwargs):
# _args = list(args)# [0]
# msg_queue = _args.pop()
msg_queue, ipass, p2 = args[:3]
passtime, stime, x_al, tcycle, al_cycle, lon, lat, timeshift = args[3:]
p = mod_tools.fromdict(p2)
npoints = 1
sat_elev = p.sat_elev
if sat_elev is None:
sat_elev = const.sat_elev
# Detect indices corresponding to the pass
if ipass == numpy.shape(passtime)[0] - 1:
ind = numpy.where((stime >= passtime[ipass]))[0]
else:
ind = numpy.where((stime >= passtime[ipass])
& (stime < passtime[ipass + 1]))[0]
nind = numpy.shape(ind)[0]
# Compute swath grid if pass is in the subdomain
if nind > 5:
# pstep = float(ipass + 1) / float(numpy.shape(passtime)[0])
# str1 = 'selected pass: {}'.format(ipass + 1)
# mod_tools.update_progress(pstep, str1, None)
# Initialize SWOT grid, grid variables and Satellite
# direction and Location
# Initialize Nadir track, grid variables
filengrid = '{}_p{:03d}.nc'.format(p.filesgrid, ipass + 1)
ngrid = rw_data.Sat_nadir(nfile=filengrid)
ngrid.x_al = x_al[ind]
ngrid.cycle = tcycle
ngrid.al_cycle = al_cycle
ngrid.time = stime[ind]
# Save ngrid object
ngrid.timeshift = timeshift
ngrid.lon = (lon[ind] + 360) % 360
ngrid.lat = lat[ind]
# Remove grid file if it exists and save it
if os.path.exists(filengrid):
os.remove(filengrid)
ngrid.first_time = p.first_time
ngrid.write_orb()
msg_queue.put((os.getpid(), ipass, None, None))
return None
def run_nadir(file_param):
if os.path.isfile(file_param):
# basedir=os.path.dirname(swotsimulator.__file__)
shutil.copyfile(file_param, 'params.py') #os.path.join(basedir,'params.py'))
else:
print("Error: No such file: '%s'" % file_param)
sys.exit()
try:
import params as p
except:
if os.path.isfile('params.py'):
print("There is a wrong entry in your params file")
import params
else:
print("Error: No params.py module found")
sys.exit()
import swotsimulator.build_swath as build_swath
import swotsimulator.rw_data as rw_data
import swotsimulator.build_error as build_error
import swotsimulator.mod_tools as mod_tools
## - Initialize some parameters values
try: p.shift_lon=p.shift_lon
except: p.shift_lon=None
try: p.shift_time=p.shift_time
except: p.shift_time=None
try: model=p.model
except: model='NETCDF_MODEL'; p.model= model
try: p.model_nan=p.model_nan
except: p.model_nan=0.
try: p.SSH_factor=p.SSH_factor
except: p.SSH_factor=1. #; p.SSH_factor=SSH_factor
p.halfswath=0.
## - Read list of user model files """
if p.file_input:
list_file = [line.strip() for line in open(p.file_input)]
## - Read model input coordinates """
if p.file_input: model_data= eval('rw_data.'+model+'(file=p.indatadir+os.sep+list_file[0])')
if p.modelbox:
modelbox=numpy.array(p.modelbox, dtype='float')
if modelbox[0]<0: modelbox[0]=modelbox[0]+360
if modelbox[1]<0:modelbox[1]=modelbox[1]+360
else:
try: modelbox=model_data.calc_box()
except:
print('Modelbox could not be computed, a modelbox should be given if no model file is provided')
sys.exit()
if p.file_input:
model_data.read_coordinates()
model_index=numpy.where(((modelbox[0]-1)<=model_data.vlon) & (model_data.vlon<=(modelbox[1]+1)) & ((modelbox[2]-1)<=model_data.vlat) & (model_data.vlat<=(modelbox[3]+1)))#[0]
## - Initialize random coefficients that are use to compute
## random errors following the specified spectrum
errnad=build_error.errornadir(p)
if p.file_coeff:
if os.path.isfile(p.file_coeff[:-3]+'_nadir.nc') and (not p.makesgrid):
print('\n WARNING: old random coefficient file are used')
errnad.load_coeff(p)
else:
errnad.init_error(p)
errnad.save_coeff(p)
else:
errnad.init_error(p)
## - Compute interpolated SSH and errors for each pass, at each
## cycle
print('Compute interpolated SSH and errors:')
## load all SWOT grid files (one for each pass)
## model time step
modeltime=numpy.arange(0,p.nstep*p.timestep, p.timestep)
## remove the grid from the list of model files
if p.file_input: list_file.remove(list_file[0])
## initialize progress bar variables
istep=0; ntot=1
## - Loop on SWOT grid files
# for ifile in p.filsat:
istring=len(p.dir_setup)
if not isinstance(p.filesat, list):
p.filesat=[p.filesat]
for filesat in p.filesat:
## load SWOT grid file
ntmp, nfilesat=os.path.split(filesat[istring:-4])
if p.makesgrid:
print('\n Force creation of satellite grid')
orb=build_swath.makeorbit(modelbox, p, orbitfile=filesat)
orb.file=p.outdatadir+os.sep+nfilesat+'_grid.nc'
orb.write_orb()
else:
orb = rw_data.Sat_nadir(file=p.filesgrid+'.nc')
cycle=0 ; x_al=[] ; al_cycle=0 ; timeshift=0
orb.load_orb(cycle=cycle,x_al=x_al, al_cycle=al_cycle, timeshift=timeshift)
cycle=orb.cycle ; x_al=orb.x_al ; al_cycle=orb.al_cycle ; timeshift=orb.timeshift
## Look for model indices corresponding to the localization of the pass
## If the pass is not in the model region, continue to next loop
if numpy.min(orb.lon)<1. and numpy.max(orb.lon)>359.:
orb.lon[numpy.where(orb.lon>180.)]=orb.lon[numpy.where(orb.lon>180.)]-360
if p.file_input: model_data.vlon[numpy.where(model_data.vlon>180.)]=model_data.vlon[numpy.where(model_data.vlon>180.)]-360
if modelbox[0]>180.: modelbox[0]=modelbox[0]-360
if modelbox[1]>180.: modelbox[1]=modelbox[1]-360
if p.file_input:
model_index=numpy.where(((numpy.min(orb.lon))<=model_data.vlon) & (model_data.vlon<=(numpy.max(orb.lon))) & ((numpy.min(orb.lat))<=model_data.vlat) & (model_data.vlat<=(numpy.max(orb.lat))))
lonmodel1d=model_data.vlon[model_index].ravel()
latmodel1d=model_data.vlat[model_index].ravel()
if not model_index[0].any():
continue
## Compute number of cycles needed to cover all nstep model timesteps
rcycle=(p.timestep*p.nstep)/float(orb.cycle)
ncycle=int(rcycle)
## Switch to (-180,180) longitude range to interpolate near 360-0
## - Loop on all cycles
for cycle in range(0,ncycle+1):
## Initialiaze errors and SSH
errnad.nadir=numpy.zeros((numpy.shape(orb.x_al)[0]))
errnad.wet_tropo1=numpy.zeros((numpy.shape(orb.x_al)[0]))
errnad.wt=numpy.zeros((numpy.shape(orb.x_al)[0]))
date1=cycle*orb.cycle
SSH_true=numpy.zeros((numpy.shape(orb.x_al)[0])) #, p.nstep))
#SSH_obs=numpy.empty((numpy.shape(orb.x_al)[0]))
vindice=numpy.zeros(numpy.shape(SSH_true))
## Definition of the time in the model
stime=orb.time+date1
## Look for satellite data that are beween step-p.timesetp/2 end setp+p.step/2
if p.file_input:
index=numpy.where(((stime[-1]-timeshift)>=(modeltime-p.timestep/2.)) & ((stime[0]-timeshift)<(modeltime+p.timestep/2.)) )#[0]
## At each step, look for the corresponding time in the satellite data
for ifile in index[0]:
ntot=1
mod_tools.update_progress(float(istep)/float(p.nstep*ntot*numpy.shape(p.filesat)[0]), 'Sat: '+ filesat[istring:], 'model file: '+list_file[ifile] +', cycle:'+str(cycle+1))
#mod_tools.update_progress(float(istep)/float(p.nstep*ntot), 'Sat: '+ filesat[istring:], 'model file: '+list_file[ifile] +', cycle:'+str(cycle+1))
## If there are satellite data, Get true SSH from model
if numpy.shape(index)[1]>0:
ntot=ntot+numpy.shape(index)[1]-1
#if numpy.shape(index)[1]>1:
ind=numpy.where(((stime-timeshift)>=(modeltime[ifile]-p.timestep/2.)) & ((stime-timeshift)<(modeltime[ifile]+p.timestep/2.)) )
exec('model_step=rw_data.'+model+'(file=p.indatadir+os.sep+list_file[ifile], var=p.var)')
model_step.read_var(index=model_index)
SSH_model=model_step.vvar
SSH_true[ind[0]]=interpolate.griddata((lonmodel1d, latmodel1d), SSH_model.ravel(), (orb.lon[ind[0]], orb.lat[ind[0]]), method=p.interpolation)
if p.interpolation=='nearest':
if modelbox[0]>modelbox[1]:
SSH_true[numpy.where(((orb.lon<modelbox[0]) & (orb.lon>modelbox[1])) | (orb.lat<modelbox[2]) | (orb.lat>modelbox[3]))] = numpy.nan
else:
SSH_true[numpy.where((orb.lon<modelbox[0]) | (orb.lon>modelbox[1]) | (orb.lat<modelbox[2]) | (orb.lat>modelbox[3]))] = numpy.nan
#SSH_true[numpy.where((orb.lon<modelbox[0]) | (orb.lon>modelbox[1]) | (orb.lat<modelbox[2]) | (orb.lat>modelbox[3]))] = numpy.nan
vindice[ind[0]]=ifile
del ind, SSH_model, model_step
istep+=1
else:
istep+=1
mod_tools.update_progress(float(istep)/float(rcycle*numpy.shape(p.filesat)[0]), 'Sat: '+ filesat[istring:], 'no model file provide '+', cycle:'+str(cycle+1))
SSH_true[SSH_true==0]=numpy.nan
errnad.make_error(orb, cycle, SSH_true, p) #, ind[0])
if p.wet_tropo: errnad.SSH=SSH_true+errnad.nadir+errnad.wet_tropo1 #make_SSH_errornadir(SSH_true,p)
else: errnad.SSH=SSH_true+errnad.nadir #make_SSH_errornadir(SSH_true,p)
## Save outputs in a netcdf file
if vindice.any() or not p.file_input:
file_output=p.file_output+'_c'+str(cycle+1).zfill(2)+'.nc'
Output=rw_data.Sat_nadir(file=file_output, lon=(orb.lon+360)%360, lat=orb.lat, time=stime, x_al=orb.x_al, cycle=orb.cycle)
Output.write_data(SSH_model=SSH_true, index=vindice, nadir_err=errnad.nadir, SSH_obs=errnad.SSH, pd_err_1b=errnad.wet_tropo1,pd=errnad.wt) #, ncycle=cycle)
del stime
if p.file_input: del index
#orb.lon=(orb.lon+360)%360
#if p.file_input: model_data.vlon=(model_data.vlon+360)%360
#modelbox[0]=(modelbox[0]+360)%360
#modelbox[1]=(modelbox[1]+360)%360
del orb
## - Write Selected parameters in a txt file
rw_data.write_params(p,p.outdatadir+os.sep+'orbit_simulator.output')
print("\n Simulated orbit files have been written in " + p.outdatadir)
print("----------------------------------------------------------")
def worker_method_grid(*args, **kwargs):
#_args = list(args)# [0]
#msg_queue = _args.pop()
#ipass = _args[0]
msg_queue, ipass, p2, passtime, stime = args[:5]
x_al, x_ac, tcycle, al_cycle, nhalfswath, lon, lat, timeshift = args[5:]
p = mod_tools.fromdict(p2)
npoints = 1
sat_elev = p.sat_elev
if sat_elev is None:
sat_elev = const.sat_elev
# Detect indices corresponding to the pass
if ipass == numpy.shape(passtime)[0] - 1:
ind = numpy.where((stime >= passtime[ipass]))[0]
else:
ind = numpy.where((stime >= passtime[ipass])
& (stime < passtime[ipass + 1]))[0]
nind = numpy.shape(ind)[0]
# Compute swath grid if pass is in the subdomain
if nind > 5:
# pstep = float(ipass + 1) / float(numpy.shape(passtime)[0])
# str1 = 'selected pass: {}'.format(ipass + 1)
# mod_tools.update_progress(pstep, str1, None)
# Initialize SWOT grid, grid variables and Satellite
# direction and Location
filesgrid = '{}_p{:03d}.nc'.format(p.filesgrid, ipass + 1)
sgrid = rw_data.Sat_SWOT(nfile=filesgrid)
sgrid.x_al = x_al[ind]
sgrid.x_ac = x_ac
sgrid.cycle = tcycle
sgrid.al_cycle = al_cycle
sgrid.time = stime[ind]
sgrid.lon = numpy.zeros((nind, 2 * nhalfswath))
sgrid.lat = numpy.zeros((nind, 2 * nhalfswath))
SatDir = numpy.zeros((int(nind / npoints), 3))
SatLoc = numpy.zeros((int((nind) / npoints), 3))
# Initialize Nadir track, grid variables
filengrid = '{}nadir_p{:03d}.nc'.format(p.filesgrid, ipass + 1)
ngrid = rw_data.Sat_nadir(nfile=filengrid)
ngrid.x_al = x_al[ind]
ngrid.cycle = tcycle
ngrid.al_cycle = al_cycle
ngrid.time = stime[ind]
# Project in cartesian coordinates satellite ground location
s2cart = mod_tools.spher2cart(lon[ind[0]:ind[-1] + 1:npoints],
lat[ind[0]:ind[-1] + 1:npoints])
SatLoc[:, 0], SatLoc[:, 1], SatLoc[:, 2] = s2cart
# Compute satellite direction (SatLoc is periodic)
SatDir[1:-1, 0] = ((SatLoc[2:, 0] - SatLoc[:-2, 0]) /
numpy.sqrt(SatLoc[1:-1, 0]**2 + SatLoc[1:-1, 1]**2 +
SatLoc[1:-1, 2]**2))
SatDir[1:-1, 1] = ((SatLoc[2:, 1] - SatLoc[:-2, 1]) /
numpy.sqrt(SatLoc[1:-1, 0]**2 + SatLoc[1:-1, 1]**2 +
SatLoc[1:-1, 2]**2))
SatDir[1:-1, 2] = ((SatLoc[2:, 2] - SatLoc[:-2, 2]) /
numpy.sqrt(SatLoc[1:-1, 0]**2 + SatLoc[1:-1, 1]**2 +
SatLoc[1:-1, 2]**2))
SatDir[-1, :] = SatDir[-2, :]
SatDir[0, :] = SatDir[1, :]
# Rotate from earth center around satellite direction to compute
# swath points of angles between the borders of the swath in left
# and right swath
for i in range(0, nind, npoints):
for j in range(0, int(nhalfswath)):
R = mod_tools.rotationmat3D(
float((j * p.delta_ac + p.halfgap) /
(const.Rearth * 10**-3)),
SatDir[int(i / npoints), :])
ObsLoc = numpy.dot(R, SatLoc[int(i / npoints)])
cs = mod_tools.cart2spher(ObsLoc[0], ObsLoc[1], ObsLoc[2])
sgrid.lon[i, nhalfswath + j], sgrid.lat[i, nhalfswath + j] = cs
ObsLoc = numpy.dot(numpy.transpose(R),
SatLoc[int(i / npoints)])
cs = mod_tools.cart2spher(ObsLoc[0], ObsLoc[1], ObsLoc[2])
sgrid.lon[i, nhalfswath - j - 1], sgrid.lat[i, nhalfswath - j -
1] = cs
if npoints > p.delta_al:
if i >= npoints:
lon1 = +sgrid.lon[i - npoints, nhalfswath + j]
lon2 = +sgrid.lon[i, nhalfswath + j]
_lon = numpy.arange(lon1, lon2,
(lon2 - lon1) / npoints)
sgrid.lon[i - npoints:i, nhalfswath + j] = _lon
lat1 = +sgrid.lat[i - npoints, nhalfswath + j]
lat2 = +sgrid.lat[i, nhalfswath + j]
_lat = numpy.arange(lat1, lat2,
(lat2 - lat1) / npoints)
sgrid.lat[i - npoints:i, nhalfswath + j] = _lat
# if npoints>p.delta_al:
# for j in range(0, 2*int(nhalfswath+1)):
# sgrid.lon[:,j]=numpy.arange(sgrid.lon[0,j], sgrid.lon[ind[-1],j],
# (sgrid.lon[-1,j]-sgrid.lon[0,j])/npoints)
# sgrid.lat[:,j]=numpy.arange(sgrid.lat[0,j], sgrid.lat[-1,j],
# (sgrid.lat[-1,j]-sgrid.lat[0,j])/npoints)
# Save Sgrid object
sgrid.timeshift = timeshift
ngrid.timeshift = timeshift
ngrid.lon = (lon[ind] + 360) % 360
ngrid.lat = lat[ind]
sgrid.lon_nadir = (lon[ind] + 360) % 360
sgrid.lat_nadir = lat[ind]
# Remove grid file if it exists and save it
if os.path.exists(filesgrid):
os.remove(filesgrid)
sgrid.first_time = p.first_time
sgrid.write_swath()
if p.nadir:
if os.path.exists(filengrid):
os.remove(filengrid)
ngrid.first_time = p.first_time
ngrid.write_orb()
msg_queue.put((os.getpid(), ipass, None, None))
return None
def makeorbit(modelbox, p, orbitfile='orbit_292.txt', filealtimeter=None):
'''Computes the orbit nadir on a subdomain.
The path of the satellite is given by the orbit file and the subdomain
corresponds to the one in the model. Note that a subdomain can be manually
added in the parameters file. \n
Inputs are satellite orbit (p.filesat), subdomain (modelbox), Along track
sampling, along track resolution). \n
Outputs are Sat_Nadir object containing Nadir track (along track distance
x_al, longitude lon and latitude lat,
number of days in a cycle cycle, distance crossed in a cycle cycle_al,
time, time shfit and time of pass passtime'''
# npoints = 1
# - Load SWOT orbit ground track
logger.info('Load data from orbit file')
if p.order_orbit_col is None:
volon, volat, votime = numpy.loadtxt(orbitfile,
usecols=(1, 2, 0),
comments='#',
unpack=True)
else:
ncols = p.order_orbit_col
volon, volat, votime = numpy.loadtxt(orbitfile,
usecols=ncols,
comments='#',
unpack=True)
votime *= const.secinday
if (volon > 360).any() or (numpy.abs(volat) > 90).any():
logger.error('Error in orbit file or wrong order of column \n'
'Columns should be in the following order'
'(time, lon, lat)')
sys.exit(1)
dic_sat = {}
with open(orbitfile, 'r') as fh:
for i, line in enumerate(fh):
if line.strip().startswith('#'):
key, value = line.strip().split('=')
dic_sat[key[1:].strip()] = float(value.strip())
else:
break
if 'cycle' in dic_sat.keys() and 'elevation' in dic_sat.keys():
p.satcycle = dic_sat['cycle']
p.sat_elev = dic_sat['elevation']
# - If orbit is at low resolution, interpolate at 0.5 s resolution
# nop = numpy.shape(votime)[0]
# tcycle = votime[nop-1] + votime[1] - votime[0]
if numpy.mean(votime[1:] - votime[:-1]) > 0.5:
x, y, z = mod_tools.spher2cart(volon, volat)
time_hr = numpy.arange(0., votime[-1], 0.5)
f = interpolate.interp1d(votime, x)
x_hr = f(time_hr)
f = interpolate.interp1d(votime, y)
y_hr = f(time_hr)
f = interpolate.interp1d(votime, z)
z_hr = f(time_hr)
lon_hr = numpy.zeros(len(x_hr)) + numpy.nan
lat_hr = numpy.zeros(len(x_hr)) + numpy.nan
lon_hr, lat_hr = mod_tools.cart2sphervect(x_hr, y_hr, z_hr)
# Cut orbit if more than an orbit cycle
if p.satcycle is None:
p.satcycle = const.tcycle
time_hr = time_hr / const.secinday
ind = numpy.where((time_hr < p.satcycle))
volon = lon_hr[ind]
volat = lat_hr[ind]
votime = time_hr[ind]
# - Get number of points in orbit
nop = numpy.shape(votime)[0]
# - Get cycle period.
tcycle = votime[nop - 1] + votime[1] - votime[0]
# shift time if the user needs to shift the time of the orbit
if p.shift_time is not None:
shift_index = numpy.where(votime >= p.shift_time)[0]
volon = numpy.hstack([volon[shift_index[0]:], volon[:shift_index[0]]])
volat = numpy.hstack([volat[shift_index[0]:], volat[:shift_index[0]]])
# shift lon if the user needs to shift the localisation of the orbit
if p.shift_lon is not None:
volon = volon + p.shift_lon
volon = (volon + 360) % 360
# - Rearrange orbit starting from pass 1
# Detect the beginning of pass 1 in orbit txt file. By definition, it is
# the first passage at southernmost latitude.
dlat = numpy.roll(volat, 1) - volat
ind = numpy.where((dlat < 0) & (numpy.roll(dlat, 1) >= 0))
# Shift coordinates, so that the first point of the orbit is the beginning
# of pass 1
decal = ind[0][-1]
# timeshift = votime[-1] - votime[decal]
volon = numpy.hstack([volon[decal:], volon[:decal]])
volat = numpy.hstack([volat[decal:], volat[:decal]])
votime = numpy.hstack([votime[decal:], votime[:decal]])
votime = (votime - votime[0]) % tcycle
if votime[numpy.where(votime < 0)]:
logger.warn('WARNING: there are negative times in your orbit')
del ind
# Compute the initial time of each pass
dlat = numpy.roll(volat, 1) - volat
ind = numpy.where(((dlat < 0) & (numpy.roll(dlat, 1) >= 0))
| ((dlat > 0)
& (numpy.roll(dlat, 1) <= 0)))
# index=numpy.hstack([0,ind[0]-1])
index = ind[0]
passtime = votime[index] # Times of pass
# - Compute accumulated along-track distance, longitude, latitude
# in the subdomain chosen by the user or given by the model
# Extract points in the domain and count the number of points (nop) in the
# subdomain
# modelbox=[lonmin lonmax latmin latmax] add margin around the domain
# plus one point to compute Satdir
matnpbox = numpy.zeros((nop))
halfswath = getattr(p, 'halfswath', 1)
if modelbox[0] > modelbox[1]:
matnpbox[numpy.where(
(((modelbox[0] - halfswath /
(const.deg2km * math.cos(modelbox[2] * math.pi / 180.))
) <= volon)
| (volon <=
(modelbox[1] + halfswath /
(const.deg2km * math.cos(modelbox[3] * math.pi / 180.)))))
& ((modelbox[2] - halfswath / const.deg2km) <= volat)
& ((modelbox[3] + halfswath / const.deg2km) >= volat))] = 1
else:
matnpbox[numpy.where(
((modelbox[0] - halfswath /
(const.deg2km * math.cos(modelbox[2] * math.pi / 180.))) <= volon
)
& (volon <=
(modelbox[1] + halfswath /
(const.deg2km * math.cos(modelbox[3] * math.pi / 180.))))
& ((modelbox[2] - halfswath / const.deg2km) <= volat)
& ((modelbox[3] + halfswath / const.deg2km) >= volat))] = 1
norp = int(numpy.sum(matnpbox))
# Initialize total distance travelled by the satellite since the first
# point of the cycle in the subdomain at low (orbital file) resolution
x_al_lr = numpy.zeros((norp))
lon_lr = numpy.zeros((norp))
lat_lr = numpy.zeros((norp))
stime_lr = numpy.zeros((norp))
# Initialize vector with accumulated distance travelled by the satellite
indp = 0
distance = numpy.zeros((nop))
# Compute and store distances and coordinates that are in the defined
# subdomain
logger.info('Compute nadir coordinate in the new domain')
for i in range(0, nop - 1):
if p.progress_bar is True:
mod_tools.update_progress(float(i) / float(nop - 1), None, None)
if abs(volon[i + 1] - volon[i]) > 1:
if volon[i + 1] > 180.:
volon[i + 1] = volon[i + 1] - 360
if volon[i] > 180.:
volon[i] = volon[i] - 360
distance[i + 1] = (
distance[i] +
numpy.sqrt(((volon[i + 1] - volon[i]) * const.deg2km *
numpy.cos(volat[i + 1] * 2 * math.pi / 360.))**2 +
((volat[i + 1] - volat[i]) * const.deg2km)**2))
volon[i + 1] = (volon[i + 1] + 360) % 360
if matnpbox[i]:
x_al_lr[indp] = distance[i]
lon_lr[indp] = (volon[i] + 360) % 360
lat_lr[indp] = volat[i]
stime_lr[indp] = votime[i]
indp += 1
# - Interpolate orbit at delta_al km resolution (default is delta_al=1)
# Detect gap in time in stime (to detect step in x_al, lon and lat)
dstime = stime_lr[:] - numpy.roll(stime_lr[:], 1)
ind = numpy.where(dstime > 3 * (votime[1] - votime[0]))
index = numpy.hstack([0, ind[0]])
nindex = numpy.shape(index)[0]
# Initialize along track distance, time and coordinates at delta_al
# resolution
if nindex > 1:
dgap = numpy.zeros((nindex))
for i in range(1, nindex):
dgap[i] = x_al_lr[index[i]] - x_al_lr[max(index[i] - 1, 0)]
Ninterp = (int(
(x_al_lr[-1] - x_al_lr[0] - sum(dgap)) / float(p.delta_al)) + 1)
x_al = numpy.zeros((Ninterp))
stime = numpy.zeros((Ninterp))
lon = numpy.zeros((Ninterp))
lat = numpy.zeros((Ninterp))
imin = 0
imax = 0
for i in range(0, nindex - 1):
imax = imin + int((x_al_lr[index[i + 1] - 1] - x_al_lr[index[i]]) /
float(p.delta_al)) + 1
if imax <= (imin + 1):
x_al[imin] = x_al_lr[index[i]]
stime[imin] = stime_lr[index[i]]
lon[imin] = lon_lr[index[i]]
lat[imin] = lat_lr[index[i]]
else:
slicei = slice(index[i], index[i + 1])
x_al[imin:imax] = numpy.arange(x_al_lr[index[i]],
x_al_lr[index[i + 1] - 1],
p.delta_al)
stime[imin:imax] = numpy.interp(x_al[imin:imax],
x_al_lr[slicei],
stime_lr[slicei])
loncirc = numpy.rad2deg(
numpy.unwrap(numpy.deg2rad(lon_lr[slicei])))
# if numpy.min(lon_lr[index[i]:index[i+1]])<1.
# and numpy.max(lon_lr[index[i]:index[i+1]])>359.:
# lontmp=lon_lr[index[i]:index[i+1]]
# lontmp[numpy.where(lontmp>180.)]=lontmp[numpy.where(
# lontmp>180.)]-360.
# lon[imin:imax]=numpy.interp(x_al[imin:imax],
# x_al_lr[index[i]:index[i+1]], lontmp)
# lon[imin:imax]=(lon[imin:imax]+360)%360
# else:
# lon[imin:imax]=numpy.interp(x_al[imin:imax],
# x_al_lr[index[i]:index[i+1]], lon_lr[index[i]:index[i+1]])
lon[imin:imax] = numpy.interp(x_al[imin:imax], x_al_lr[slicei],
loncirc)
lat[imin:imax] = numpy.interp(x_al[imin:imax], x_al_lr[slicei],
lat_lr[slicei])
imin = imax
x_al[imin:] = numpy.arange(
x_al_lr[index[-1]],
x_al_lr[index[-1]] + (Ninterp - imin) * p.delta_al, p.delta_al)
stime[imin:] = numpy.interp(x_al[imin:], x_al_lr[index[-1]:],
stime_lr[index[-1]:])
loncirc = numpy.rad2deg(numpy.unwrap(numpy.deg2rad(
lon_lr[index[-1]:])))
lon[imin:] = numpy.interp(x_al[imin:], x_al_lr[index[-1]:], loncirc)
lat[imin:] = numpy.interp(x_al[imin:], x_al_lr[index[-1]:],
lat_lr[index[-1]:])
else:
Ninterp = int((x_al_lr[-2] - x_al_lr[0]) / float(p.delta_al)) + 1
x_al = numpy.zeros((Ninterp))
stime = numpy.zeros((Ninterp))
lon = numpy.zeros((Ninterp))
lat = numpy.zeros((Ninterp))
x_al = numpy.arange(x_al_lr[0], x_al_lr[-2], p.delta_al)
stime = numpy.interp(x_al, x_al_lr[:-1], stime_lr[:-1])
loncirc = numpy.rad2deg(numpy.unwrap(numpy.deg2rad(lon_lr[:-1])))
lon = numpy.interp(x_al, x_al_lr[:-1], loncirc)
lat = numpy.interp(x_al, x_al_lr[:-1], lat_lr[:-1])
lon = lon % 360
nfile = '{}.nc'.format(orbitfile[:-4])
orb = rw_data.Sat_nadir(nfile=nfile)
orb.x_al = x_al
orb.time = stime
orb.lon = lon
orb.lat = lat
orb.cycle = tcycle
orb.al_cycle = distance[-1]
orb.passtime = numpy.sort(passtime)
orb.timeshift = p.timeshift
orb.sat_elev = p.sat_elev
return orb
def orbit2swath(modelbox, p, orb):
'''Computes the swath of SWOT satellites on a subdomain from an orbit.
The path of the satellite is given by the orbit file and the subdomain
corresponds to the one in the model. Note that a subdomain can be manually
added in the parameters file. \n
Inputs are satellite orbit (p.filesat), subdomain (modelbox), Swath
parameters (half gap distance p.halfgap, half swath distance p.halfswath,
along track
resolution p.delta_al, across track resolution p.delta_ac). \n
Outputs are netcdf files containing SWOT grid (along track distance x_al,
across track distance from nadir x_ac, longitude lon and latitude lat,
number of days in a cycle cycle, distance crossed in a cycle cycle_al,
time'''
''' Compute orbit from Swath '''
# - Load altimeter orbit
npoints = 1
x_al = orb.x_al
stime = orb.time
lon = orb.lon
lat = orb.lat
tcycle = orb.cycle
al_cycle = orb.al_cycle
passtime = orb.passtime
# - Compute accross track distances from nadir
# Number of points in half of the swath
nhalfswath = int((p.halfswath-p.halfgap)/p.delta_ac) + 1
# Across track distance from nadir
x_ac = numpy.zeros((2*nhalfswath))
for i in range(0, int(nhalfswath)):
x_ac[i] = -(nhalfswath - i)*p.delta_ac - p.halfgap + p.delta_ac
x_ac[i + nhalfswath] = i * p.delta_ac + p.halfgap
# - Computation of SWOT grid and storage by passes
logger.info('\n Compute SWOT grid')
# Detect first pass that is in the subdomain
ipass0 = 0
# strpass = []
# Loop on all passes after the first pass detected
for ipass in range(ipass0, numpy.shape(passtime)[0]):
# Detect indices corresponding to the pass
if ipass == numpy.shape(passtime)[0]-1:
ind = numpy.where((stime >= passtime[ipass]))[0]
else:
ind = numpy.where((stime >= passtime[ipass])
& (stime < passtime[ipass+1]))[0]
nind = numpy.shape(ind)[0]
# Compute swath grid if pass is in the subdomain
if nind > 5:
pstep = float(ipass + 1) / float(numpy.shape(passtime)[0])
str1 = 'selected pass: {}'.format(ipass + 1)
mod_tools.update_progress(pstep, str1, None)
# Initialize SWOT grid, grid variables and Satellite
# direction and Location
filesgrid = '{}_p{:03d}.nc'.format(p.filesgrid,ipass + 1)
sgrid = rw_data.Sat_SWOT(nfile=filesgrid)
sgrid.x_al = x_al[ind]
sgrid.x_ac = x_ac
sgrid.cycle = tcycle
sgrid.al_cycle = al_cycle
sgrid.time = stime[ind]
sgrid.lon = numpy.zeros((nind, 2*nhalfswath))
sgrid.lat = numpy.zeros((nind, 2*nhalfswath))
SatDir = numpy.zeros((int(nind/npoints), 3))
SatLoc = numpy.zeros((int((nind)/npoints), 3))
# Initialize Nadir track, grid variables
filengrid = '{}nadir_p{:03d}.nc'.format(p.filesgrid,ipass + 1)
ngrid = rw_data.Sat_nadir(nfile=filengrid)
ngrid.x_al = x_al[ind]
ngrid.cycle = tcycle
ngrid.al_cycle = al_cycle
ngrid.time = stime[ind]
# Project in cartesian coordinates satellite ground location
s2cart = mod_tools.spher2cart(lon[ind[0]: ind[-1]+1: npoints],
lat[ind[0]: ind[-1]+1: npoints])
SatLoc[:, 0], SatLoc[:, 1], SatLoc[:, 2] = s2cart
# Compute satellite direction (SatLoc is periodic)
SatDir[1: -1, 0] = ((SatLoc[2:, 0] - SatLoc[: -2, 0])
/ numpy.sqrt(SatLoc[1: -1, 0]**2
+ SatLoc[1: -1, 1]**2 + SatLoc[1: -1, 2]**2))
SatDir[1: -1, 1] = ((SatLoc[2:, 1] - SatLoc[: -2, 1])
/ numpy.sqrt(SatLoc[1: -1, 0]**2
+ SatLoc[1: -1, 1]**2 + SatLoc[1: -1, 2]**2))
SatDir[1: -1, 2] = ((SatLoc[2:, 2] - SatLoc[: -2, 2])
/ numpy.sqrt(SatLoc[1: -1, 0]**2
+ SatLoc[1: -1, 1]**2 + SatLoc[1: -1, 2]**2))
SatDir[-1, :] = SatDir[-2, :]
SatDir[0, :] = SatDir[1, :]
# Rotate from earth center around satellite direction to compute
# swath points of angles between the borders of the swath in left
# and right swath
for i in range(0, nind, npoints):
for j in range(0, int(nhalfswath)):
R = mod_tools.rotationmat3D(float((j*p.delta_ac+p.halfgap)
/ (const.Rearth*10**-3)),
SatDir[int(i/npoints), :])
ObsLoc = numpy.dot(R, SatLoc[int(i/npoints)])
cs = mod_tools.cart2spher(ObsLoc[0], ObsLoc[1], ObsLoc[2])
sgrid.lon[i, nhalfswath+j], sgrid.lat[i, nhalfswath+j] = cs
ObsLoc = numpy.dot(numpy.transpose(R),
SatLoc[int(i/npoints)])
cs = mod_tools.cart2spher(ObsLoc[0], ObsLoc[1], ObsLoc[2])
sgrid.lon[i, nhalfswath-j-1], sgrid.lat[i, nhalfswath-j-1] = cs
if npoints > p.delta_al:
if i >= npoints:
sgrid.lon[i-npoints: i, nhalfswath+j] = numpy.arange(sgrid.lon[i-npoints, nhalfswath+j], sgrid.lon[i, nhalfswath+j], (sgrid.lon[i, nhalfswath+j]-sgrid.lon[i-npoints, nhalfswath+j])/npoints)
sgrid.lat[i-npoints: i, nhalfswath+j] = numpy.arange(sgrid.lat[i-npoints, nhalfswath+j], sgrid.lat[i, nhalfswath+j], (sgrid.lat[i, nhalfswath+j]-sgrid.lat[i-npoints, nhalfswath+j])/npoints)
# if npoints>p.delta_al:
# print 'interp not coded'
# for j in range(0, 2*int(nhalfswath+1)):
# sgrid.lon[:,j]=numpy.arange(sgrid.lon[0,j], sgrid.lon[ind[-1],j],
# (sgrid.lon[-1,j]-sgrid.lon[0,j])/npoints)
# sgrid.lat[:,j]=numpy.arange(sgrid.lat[0,j], sgrid.lat[-1,j],
# (sgrid.lat[-1,j]-sgrid.lat[0,j])/npoints)
# Save Sgrid object
sgrid.timeshift = orb.timeshift
ngrid.timeshift = orb.timeshift
ngrid.lon = (lon[ind] + 360) % 360
ngrid.lat = lat[ind]
sgrid.lon_nadir = (lon[ind] + 360) % 360
sgrid.lat_nadir = lat[ind]
# Remove grid file if it exists and save it
if os.path.exists(filesgrid):
os.remove(filesgrid)
sgrid.write_swath()
if p.nadir:
if os.path.exists(filengrid):
os.remove(filengrid)
ngrid.write_orb()
mod_tools.update_progress(1, 'All swaths have been processed', ' ')
return None
def run_nadir(p, die_on_error=False):
# - Initialize some parameters values
timestart = datetime.datetime.now()
mod_tools.initialize_parameters(p)
p.nadir = True
p.karin = False
p.phase = False
p.roll = False
p.baseline_dilation = False
p.timing = False
p.halfswath = 60.
# - Progress bar variables are global
global ntot
# Build model time steps from parameter file
modeltime = numpy.arange(0, p.nstep * p.timestep, p.timestep)
# - Read list of user model files """
if p.file_input is not None:
list_file = [line.strip() for line in open(p.file_input)]
if len(modeltime) > len(list_file):
logger.error('There is not enough model files in the list of '
'files')
sys.exit(1)
else:
list_file = None
# ############################################
# Select the spatial and temporal domains
# ############################################
# - Read model input coordinates '''
model_data, list_file = mod.load_coordinate_model(p)
# if no modelbox is specified (modelbox=None), the domain of the input data
# is taken as a modelbox
# coordinates from the region defined by modelbox are selected
logger.debug('Read input')
if p.modelbox is not None:
modelbox = numpy.array(p.modelbox, dtype='float')
# Use convert to 360 data
modelbox[0] = (modelbox[0] + 360) % 360
if modelbox[1] != 360:
modelbox[1] = (modelbox[1] + 360) % 360
else:
if p.file_input is not None:
modelbox = model_data.calc_box()
else:
logger.error('modelbox should be provided if no model file is '
'provided')
sys.exit()
p.modelbox_calc = modelbox
logger.debug(p.file_input)
if p.file_input is not None:
model_data.read_coordinates()
# Select model data in the region modelbox
model_data.len_coord = len(numpy.shape(model_data.vlon))
if p.grid == 'regular' or model_data.len_coord == 1:
if modelbox[0] < modelbox[1]:
_i_lon = numpy.where(((modelbox[0] - 1) <= model_data.vlon)
& (model_data.vlon <=
(modelbox[1] + 1)))[0]
else:
_i_lon = numpy.where(((modelbox[0] - 1) <= model_data.vlon)
| (model_data.vlon <= (modelbox[1] +
1)))[0]
model_data.model_index_lon = _i_lon
_i_lat = numpy.where(((modelbox[2] - 1) <= model_data.vlat)
& (model_data.vlat <= (modelbox[3] + 1)))[0]
model_data.model_index_lat = _i_lat
model_data.vlon = model_data.vlon[model_data.model_index_lon]
model_data.vlat = model_data.vlat[model_data.model_index_lat]
else:
if modelbox[0] < modelbox[1]:
_i_box = numpy.where(((modelbox[0] - 1) <= model_data.vlon)
& (model_data.vlon <= (modelbox[1] + 1))
& ((modelbox[2] - 1) <= model_data.vlat)
& (model_data.vlat <= (modelbox[3] + 1)))
else:
_i_box = numpy.where(((modelbox[0] - 1) <= model_data.vlon)
| (model_data.vlon <= (modelbox[1] + 1))
& ((modelbox[2] - 1) <= model_data.vlat)
& (model_data.vlat <= (modelbox[3] + 1)))
model_data.model_index = _i_box
model_data.vlon = model_data.vlon[model_data.model_index]
model_data.vlat = model_data.vlat[model_data.model_index]
model_data.model = p.model
model_data.vloncirc = numpy.rad2deg(numpy.unwrap(model_data.vlon))
# Ugly trick when model box is [0 360] to avoid box being empty (360=0%360)
if modelbox[1] == 0:
modelbox[1] = 359.99
# - Initialize random coefficients that are used to compute
# random errors following the specified spectrum
err, errnad = mod.load_error(p, nadir_alone=nadir_alone)
# - Compute interpolated SSH and errors for each pass, at each
# cycle
logger.info('Compute interpolated SSH and errors:')
# Remove the grid from the list of model files
if p.file_input:
list_file.remove(list_file[0])
if len(modeltime) > len(list_file):
logger.error('There is not enough model files in the list of'
' files')
sys.exit(1)
# Initialize progress bar variables
ntot = 1
# Initialize list of satellites
if not isinstance(p.filesat, list):
p.filesat = [p.filesat]
for filesat in p.filesat:
# Select satellite
# ntmp, nfilesat = os.path.split(filesat[istring:-4])
nfilesat = os.path.basename(os.path.splitext(filesat)[0])
# Make satellite orbit grid
if p.makesgrid is True:
logger.warning('\n Force creation of satellite grid')
ngrid = build_swath.makeorbit(modelbox, p, orbitfile=filesat)
ngrid.file = '{}{}_grid.nc'.format((p.filesgrid).strip(),
nfilesat.strip())
ngrid.write_orb()
ngrid.ipass = nfilesat
ngrid.gridfile = '{}{}_grid.nc'.format((p.filesgrid).strip(),
nfilesat.strip())
else:
# To be replaced by load_ngrid
gridfile = '{}{}_grid.nc'.format((p.filesgrid).strip(),
nfilesat.strip())
ngrid = rw_data.Sat_nadir(nfile=gridfile)
ngrid.file = gridfile
ngrid.ipass = nfilesat
cycle = 0
x_al = []
al_cycle = 0
timeshift = 0
ngrid.load_orb(cycle=cycle,
x_al=x_al,
al_cycle=al_cycle,
timeshift=timeshift)
ngrid.loncirc = numpy.rad2deg(numpy.unwrap(ngrid.lon))
# ngrid=load_ngrid(sgridfile, p)
# Select model data around the swath to reduce interpolation
# cost in griddata
# if p.file_input is not None:
# _ind = numpy.where((numpy.min(ngrid.lon) <= model_data.vlon)
# & (model_data.vlon <= numpy.max(ngrid.lon))
# & (numpy.min(ngrid.lat) <= model_data.vlat)
# & (model_data.vlat <= numpy.max(ngrid.lat)))
# model_index = _ind
# - Generate and nadir-like data:
# Compute number of cycles needed to cover all nstep model timesteps
rcycle = (p.timestep * p.nstep) / float(ngrid.cycle)
ncycle = int(rcycle)
# Loop on all cycles
for cycle in range(0, ncycle + 1):
### TODO move this line somwhere where we have ifile information
#if ifile > (p.nstep/p.timestep + 1):
# break
# Create SWOT-like and Nadir-like data
if p.file_input is None:
model_data = []
logger.debug('compute SSH nadir')
nfile = numpy.shape(p.filesat)[0] * rcycle
create = mod.create_Nadirlikedata(cycle,
nfile,
list_file,
modelbox,
ngrid,
model_data,
modeltime,
errnad,
p,
progress_bar=True)
SSH_true_nadir, vindice, time, progress = create
# SSH_true_nadir, vindice_nadir=create_Nadirlikedata(cycle, sgrid,
# ngrid, model_data, modeltime, err, errnad, p)
# Save outputs in a netcdf file
ngrid.gridfile = filesat
if (~numpy.isnan(vindice)).any() or p.file_input is None:
err = errnad
err.wtnadir = numpy.zeros((1))
err.wet_tropo2nadir = numpy.zeros((1))
logger.debug('write file')
mod.save_Nadir(cycle,
ngrid,
errnad,
err,
p,
time=time,
vindice_nadir=vindice,
SSH_true_nadir=SSH_true_nadir)
del time
# if p.file_input: del index
ngrid.lon = (ngrid.lon + 360) % 360
if p.file_input:
model_data.vlon = (model_data.vlon + 360) % 360
modelbox[0] = (modelbox[0] + 360) % 360
modelbox[1] = (modelbox[1] + 360) % 360
del ngrid
if progress != 1:
str1 = 'All passes have been processed'
progress = mod_tools.update_progress(1, str1, '')
# - Write Selected parameters in a txt file
timestop = datetime.datetime.now()
timestop = timestop.strftime('%Y%m%dT%H%M%SZ')
timestart = timestart.strftime('%Y%m%dT%H%M%SZ')
op_file = 'nadir_simulator_{}_{}.output'.format(timestart, timestop)
op_file = os.path.join(p.outdatadir, op_file)
rw_data.write_params(p, op_file)
logger.info("\nSimulated orbit files have been written in {}".format(
p.outdatadir))
logger.info("----------------------------------------------------------")
urcrnrlon = modelbox[1], \
urcrnrlat = modelbox[3], \
resolution = 'h', \
projection = proj, \
lon_0 = (modelbox[1]-modelbox[0])/2, \
lat_0 = (modelbox[3]-modelbox[2])/2)
m.drawcoastlines()
m.fillcontinents(color='#FFE4B5', lake_color='aqua')
m.drawmeridians(numpy.arange(int(modelbox[0]),
int(modelbox[1]) + 0.1,
(modelbox[1] - modelbox[0]) / 7.),
labels=[0, 0, 0, 2])
m.drawparallels(numpy.arange(int(modelbox[2]),
int(modelbox[3]) + 0.1,
(modelbox[3] - modelbox[2]) / 7.),
labels=[2, 0, 0, 0])
for coordfile in listfile:
print(coordfile)
data = rw_data.Sat_nadir(file=coordfile)
data.load_orb(SSH_model=[], SSH_obs=SSH_obs)
data.SSH_model[numpy.isnan(data.SSH_model)] = 0.
data.SSH_obs[numpy.isnan(data.SSH_obs)] = 0.
if isBasemap is True: x, y = m(data.lon, data.lat)
norm = mpl.colors.Normalize(-0.15, 0.15)
C = plt.scatter(data.lon[:],
data.lat[:],
c=data.SSH_obs,
edgecolors='None',
norm=norm)
plt.savefig(p.outdatadir + 'sat_pass.png')
def makeorbit(modelbox,p,orbitfile='orbit_292.txt', filealtimeter=None):
'''Computes the swath of SWOT satellites on a subdomain.
The path of the satellite is given by the orbit file and the subdomain
corresponds to the one in the model. Note that a subdomain can be manually
added in the parameters file. \n
Inputs are satellite orbit (p.filesat), subdomain (modelbox), Swath parameters
(half gap distance p.halfgap, half swath distance p.halfswath, along track
resolution p.delta_al, across track resolution p.delta_ac). \n
Outputs are netcdf files containing SWOT grid (along track distance x_al,
across track distance from nadir x_ac, longitude lon and latitude lat,
number of days in a cycle cycle, distance crossed in a cycle cycle_al,
time'''
npoints=1
## --Load SWOT orbit ground track
print('Load data from orbit file')
volon, volat, votime=numpy.loadtxt(orbitfile, usecols=(0,1,2), unpack=True)
## --If orbit is at low resolution, interpolate at 0.5 s resolution
if numpy.mean(votime[1:]-votime[:-1])>0.5:
x,y,z=mod_tools.spher2cart(volon, volat)
time_hr=numpy.arange(0.,votime[-1],0.5)
f = interpolate.interp1d(votime, x)
x_hr=f(time_hr)
f = interpolate.interp1d(votime, y)
y_hr=f(time_hr)
f = interpolate.interp1d(votime, z)
z_hr=f(time_hr)
lon_hr=numpy.zeros(len(x_hr))+numpy.nan
lat_hr=numpy.zeros(len(x_hr))+numpy.nan
for ii in range(len(x_hr)):
lon_hr[ii],lat_hr[ii]=mod_tools.cart2spher(x_hr[ii],y_hr[ii],z_hr[ii])
time_hr=time_hr/86400.
ind=numpy.where((time_hr<20.86455))
volon=lon_hr[ind]
volat=lat_hr[ind]
votime=time_hr[ind]
## --Get number of points in orbit
nop=numpy.shape(votime)[0]
## --Get cycle period.
tcycle=votime[nop-1]+votime[1]-votime[0]
# shift time if the user needs to shift the time of the orbit
try:
pshift_time=p.shift_time
if pshift_time:
shift_index=numpy.where(votime>=pshift_time)[0]
volon=numpy.hstack([volon[shift_index[0][0]:], volon[:shift_index[0][0]]])
volat=numpy.hstack([volat[shift_index[0][0]:], volat[:shift_index[0][0]]])
except: p.shift_time=None
# shift lon if the user needs to shift the localisation of the orbit
try:
pshift_lon=p.shift_lon
if pshift_lon:
volon=volon+pshift_lon
except: p.shift_lon=None
volon=(volon+360)%360
## --Rearrange orbit starting from pass 1
# Detect the beginning of pass 1 in orbit txt file. By definition, it is the first passage at southernmost latitude.
dlat=numpy.roll(volat,1) -volat
ind=numpy.where((dlat<0) & (numpy.roll(dlat,1)>=0))
# Shift coordinates, so that the first point of the orbit is the beginning of pass 1
decal=ind[0][-1]
timeshift=votime[-1]-votime[decal]
volon=numpy.hstack([volon[decal:], volon[:decal]]) #numpy.roll(volon,decal)
volat=numpy.hstack([volat[decal:], volat[:decal]]) #numpy.roll(volat,decal)
votime=numpy.hstack([votime[decal:], votime[:decal]]) #numpy.roll(votime,decal)
votime=(votime-votime[0])%tcycle
if votime[numpy.where(votime<0)]:
print('WARNING: there are negative times in your orbit')
del ind
# Compute the initial time of each pass
dlat=numpy.roll(volat,1) -volat
ind=numpy.where(((dlat<0) & (numpy.roll(dlat,1)>=0))|((dlat>0) & (numpy.roll(dlat,1)<=0)))
#index=numpy.hstack([0,ind[0]-1])
index=ind[0]
passtime=votime[index] # Times of pass
## -- Compute accumulated along-track distance, longitude, latitude in the subdomain
# chosen by the user or given by the model
# Extract points in the domain and count the number of points (nop) in the subdomain
#modelbox=[lonmin lonmax latmin latmax] add margin around the domain plus one point to compute Satdir
matnpbox=numpy.zeros((nop))
if modelbox[0]>modelbox[1]:
matnpbox[numpy.where((((modelbox[0]-p.halfswath/(const.deg2km*math.cos(modelbox[2]*math.pi/180.)))<=volon) | (volon<=(modelbox[1]+p.halfswath/(const.deg2km*math.cos(modelbox[3]*math.pi/180.))))) & ((modelbox[2]-p.halfswath/const.deg2km)<=volat) & ((modelbox[3]+p.halfswath/const.deg2km)>=volat))]=1
else:
matnpbox[numpy.where(((modelbox[0]-p.halfswath/(const.deg2km*math.cos(modelbox[2]*math.pi/180.)))<=volon) & (volon<=(modelbox[1]+p.halfswath/(const.deg2km*math.cos(modelbox[3]*math.pi/180.)))) & ((modelbox[2]-p.halfswath/const.deg2km)<=volat) & ((modelbox[3]+p.halfswath/const.deg2km)>=volat))]=1
norp=int(numpy.sum(matnpbox))
# Initialize total distance travelled by the satellite since the first point of the cycle
# in the subdomain at low (orbital file) resolution
x_al_lr=numpy.zeros((norp))
lon_lr=numpy.zeros((norp))
lat_lr=numpy.zeros((norp))
stime_lr=numpy.zeros((norp))
# Initialize vector with accumulated distance travelled by the satellite
indp = 0
distance=numpy.zeros((nop))
# Compute and store distances and coordinates that are in the defined subdomain
print('Compute SWOT nadir coordinate in the new domain')
for i in range(0,nop-1):
mod_tools.update_progress(float(i)/float(nop-1), None, None)
if abs(volon[i+1]-volon[i])>1:
if volon[i+1]>180. : volon[i+1]=volon[i+1]-360
if volon[i]>180. : volon[i]=volon[i]-360
distance[i+1]=distance[i]+numpy.sqrt(((volon[i+1]-volon[i])*const.deg2km*numpy.cos(volat[i+1]*2*math.pi/360.))**2 + ((volat[i+1]-volat[i])*const.deg2km)**2 ) #numpy.sum(dl[:i])
volon[i+1]=(volon[i+1]+360)%360
if matnpbox[i]:
x_al_lr[indp] = distance[i]
lon_lr[indp] = (volon[i]+360)%360
lat_lr[indp] = volat[i]
stime_lr[indp] = votime[i]
indp=indp+1
## -- Interpolate orbit at delta_al km resolution (default is delta_al=1)
#Detect gap in time in stime (to detect step in x_al, lon and lat)
dstime=stime_lr[:]-numpy.roll(stime_lr[:],1)
ind=numpy.where(dstime>3*(votime[1]-votime[0]))
index=numpy.hstack([0,ind[0]])
nindex=numpy.shape(index)[0]
# Initialize along track distance, time and coordinates at delta_al resolution
if nindex>1:
dgap=numpy.zeros((nindex))
for i in range(1,nindex):
dgap[i]=x_al_lr[index[i]]-x_al_lr[max(index[i]-1,0)]
Ninterp=int((x_al_lr[-1]-x_al_lr[0] -sum(dgap))/float(p.delta_al))+1
x_al=numpy.zeros((Ninterp))
stime=numpy.zeros((Ninterp))
lon=numpy.zeros((Ninterp))
lat=numpy.zeros((Ninterp))
imin=0 ; imax=0
for i in range(0,nindex-1):
imax=imin+int((x_al_lr[index[i+1]-1]-x_al_lr[index[i]])/float(p.delta_al))+1
if imax<=(imin+1):
x_al[imin]=x_al_lr[index[i]]
stime[imin]=stime_lr[index[i]]
lon[imin]=lon_lr[index[i]]
lat[imin]=lat_lr[index[i]]
else:
x_al[imin:imax]=numpy.arange(x_al_lr[index[i]],x_al_lr[index[i+1]-1], p.delta_al)
stime[imin:imax]=numpy.interp(x_al[imin:imax], x_al_lr[index[i]:index[i+1]], stime_lr[index[i]:index[i+1]])
loncirc=numpy.rad2deg(numpy.unwrap(numpy.deg2rad(lon_lr[index[i]:index[i+1]])))
#if numpy.min(lon_lr[index[i]:index[i+1]])<1. and numpy.max(lon_lr[index[i]:index[i+1]])>359.:
# lontmp=lon_lr[index[i]:index[i+1]]
# lontmp[numpy.where(lontmp>180.)]=lontmp[numpy.where(lontmp>180.)]-360.
# lon[imin:imax]=numpy.interp(x_al[imin:imax], x_al_lr[index[i]:index[i+1]], lontmp) #_lr[index[i]:index[i+1]])
# lon[imin:imax]=(lon[imin:imax]+360)%360
#else:
# lon[imin:imax]=numpy.interp(x_al[imin:imax], x_al_lr[index[i]:index[i+1]], lon_lr[index[i]:index[i+1]])
lon[imin:imax]=numpy.interp(x_al[imin:imax], x_al_lr[index[i]:index[i+1]], loncirc)
lat[imin:imax]=numpy.interp(x_al[imin:imax], x_al_lr[index[i]:index[i+1]], lat_lr[index[i]:index[i+1]])
imin=imax
x_al[imin:]=numpy.arange(x_al_lr[index[-1]],x_al_lr[index[-1]]+(Ninterp-imin)*p.delta_al, p.delta_al)
stime[imin:]=numpy.interp(x_al[imin:], x_al_lr[index[-1]:], stime_lr[index[-1]:])
loncirc=numpy.rad2deg(numpy.unwrap(numpy.deg2rad(lon_lr[index[-1]:])))
#if numpy.min(lon_lr[index[-1]:])<1. and numpy.max(lon_lr[index[-1]:])>539:
# lontmp=lon_lr[index[-1]:]
# lontmp[numpy.where(lontmp>180.)]=lontmp[numpy.where(lontmp>180.)]-360.
# lon[imin:]=numpy.interp(x_al[imin:], x_al_lr[index[-1]:], lontmp)
# lon[imin:]=(lon[imin:]+360)%360
#else:
# lon[imin:]=numpy.interp(x_al[imin:], x_al_lr[index[-1]:], lon_lr[index[-1]:])
lon[imin:]=numpy.interp(x_al[imin:], x_al_lr[index[-1]:], loncirc)
lat[imin:]=numpy.interp(x_al[imin:], x_al_lr[index[-1]:], lat_lr[index[-1]:])
else:
Ninterp=int((x_al_lr[-2]-x_al_lr[0] )/float(p.delta_al))+1
x_al=numpy.zeros((Ninterp))
stime=numpy.zeros((Ninterp))
lon=numpy.zeros((Ninterp))
lat=numpy.zeros((Ninterp))
x_al=numpy.arange(x_al_lr[0],x_al_lr[-2], p.delta_al)
stime=numpy.interp(x_al, x_al_lr[:-1], stime_lr[:-1])
loncirc=numpy.rad2deg(numpy.unwrap(numpy.deg2rad(lon_lr[:-1])))
lon=numpy.interp(x_al, x_al_lr[:-1],loncirc)
lat=numpy.interp(x_al, x_al_lr[:-1],lat_lr[:-1])
lon=lon%360
orb=rw_data.Sat_nadir(file=orbitfile[:-4]+'.nc')
orb.x_al=x_al
orb.time=stime
orb.lon=lon
orb.lat=lat
orb.cycle=tcycle
orb.al_cycle=distance[-1]
orb.passtime=numpy.sort(passtime)
orb.timeshift=timeshift
return orb
def orbit2swath(modelbox, p,orb):
# -- Load altimeter orbit
npoints=1
x_al=orb.x_al
stime=orb.time
lon=orb.lon
lat=orb.lat
tcycle=orb.cycle
al_cycle=orb.al_cycle
passtime=orb.passtime
## -- Compute accross track distances from nadir
# Number of points in half of the swath
nhalfswath=int( (p.halfswath-p.halfgap)/p.delta_ac) +1
# Across track distance from nadir
x_ac=numpy.zeros((2*nhalfswath))
for i in range(0, int(nhalfswath)):
x_ac[i]=-(nhalfswath-i)*p.delta_ac-p.halfgap+p.delta_ac
x_ac[i+nhalfswath]=i*p.delta_ac+p.halfgap
## -- Computation of SWOT grid and storage by passes
print('\n Compute SWOT grid')
# Detect first pass that is in the subdomain
ipass0=0
strpass=[]
# Loop on all passes after the first pass detected
for ipass in range(ipass0,numpy.shape(passtime)[0]):
# Detect indices corresponding to the pass
if ipass==numpy.shape(passtime)[0]-1:
ind=numpy.where((stime>=passtime[ipass]))[0]
else:
ind=numpy.where((stime>=passtime[ipass]) & (stime<passtime[ipass+1]))[0]
nind=numpy.shape(ind)[0]
# Compute swath grid if pass is in the subdomain
if nind>5:
mod_tools.update_progress(float(ipass+1)/float(numpy.shape(passtime)[0]), 'selected pass: '******'_p'+str(ipass+1).zfill(3)+'.nc'
sgrid=rw_data.Sat_SWOT(file=filesgrid)
sgrid.x_al=x_al[ind]
sgrid.x_ac=x_ac
sgrid.cycle=tcycle
sgrid.al_cycle=al_cycle
sgrid.time=stime[ind]
sgrid.lon=numpy.zeros((nind,2*nhalfswath))
sgrid.lat=numpy.zeros((nind,2*nhalfswath))
SatDir=numpy.zeros((int(nind/npoints),3))
SatLoc=numpy.zeros((int((nind)/npoints),3))
# Initialize Nadir track, grid variables
filengrid=p.filesgrid+'nadir_p'+str(ipass+1).zfill(3)+'.nc'
ngrid=rw_data.Sat_nadir(file=filengrid)
ngrid.x_al=x_al[ind]
ngrid.cycle=tcycle
ngrid.al_cycle=al_cycle
ngrid.time=stime[ind]
## Project in cartesian coordinates satellite ground location
#SatLoc[:,0], SatLoc[:,1], SatLoc[:,2]=mod_tools.spher2cart(lon[ind[0]:ind[-1]+npoints:npoints], lat[ind[0]:ind[-1]+npoints:npoints])
#if numpy.min(lon[ind[0]:ind[-1]+1])<1. and numpy.max(lon[ind[0]:ind[-1]+1])>359.:
#lontmp=lon[ind[0]:ind[-1]+1]
#lontmp[numpy.where(lontmp>180.)]=lontmp[numpy.where(lontmp>180.)]-360.
SatLoc[:,0], SatLoc[:,1], SatLoc[:,2]=mod_tools.spher2cart(lon[ind[0]:ind[-1]+1:npoints], lat[ind[0]:ind[-1]+1:npoints])
## Compute satellite direction (SatLoc is periodic)
SatDir[1:-1,0]=(SatLoc[2:,0]-SatLoc[:-2,0])/numpy.sqrt(SatLoc[1:-1,0]**2+SatLoc[1:-1,1]**2+SatLoc[1:-1,2]**2)
SatDir[1:-1,1]=(SatLoc[2:,1]-SatLoc[:-2,1])/numpy.sqrt(SatLoc[1:-1,0]**2+SatLoc[1:-1,1]**2+SatLoc[1:-1,2]**2)
SatDir[1:-1,2]=(SatLoc[2:,2]-SatLoc[:-2,2])/numpy.sqrt(SatLoc[1:-1,0]**2+SatLoc[1:-1,1]**2+SatLoc[1:-1,2]**2)
SatDir[-1]=SatDir[-2]
SatDir[0]=SatDir[1]
## Rotate from earth center around satellite direction to compute swath points of angles between the borders of the swath in left and right swath
for i in range(0, nind, npoints):
for j in range(0, int(nhalfswath)):
R=mod_tools.rotationmat3D(float((j*p.delta_ac + p.halfgap)/(const.Rearth*10**-3)) , SatDir[int(i/npoints),:])
ObsLoc=numpy.dot(R,SatLoc[int(i/npoints)])
sgrid.lon[i,nhalfswath+j], sgrid.lat[i, nhalfswath+j]=mod_tools.cart2spher(ObsLoc[0], ObsLoc[1], ObsLoc[2])
ObsLoc=numpy.dot(numpy.transpose(R),SatLoc[int(i/npoints)])
sgrid.lon[i,nhalfswath-j-1], sgrid.lat[i, nhalfswath-j-1]=mod_tools.cart2spher(ObsLoc[0], ObsLoc[1], ObsLoc[2])
if npoints>p.delta_al:
if i>=npoints:
sgrid.lon[i-npoints:i, nhalfswath+j]=numpy.arange(sgrid.lon[i-npoints,nhalfswath+j], sgrid.lon[i,nhalfswath+j], (sgrid.lon[i,nhalfswath+j]-sgrid.lon[i-npoints,nhalfswath+j])/npoints)
sgrid.lat[i-npoints:i,nhalfswath+j]=numpy.arange(sgrid.lat[i-npoints,nhalfswath+j], sgrid.lat[i,nhalfswath+j], (sgrid.lat[i,nhalfswath+j]-sgrid.lat[i-npoints,nhalfswath+j])/npoints)
#if npoints>p.delta_al:
#print 'interp not coded'
#for j in range(0, 2*int(nhalfswath+1)):
#sgrid.lon[:,j]=numpy.arange(sgrid.lon[0,j], sgrid.lon[ind[-1],j], (sgrid.lon[-1,j]-sgrid.lon[0,j])/npoints)
#sgrid.lat[:,j]=numpy.arange(sgrid.lat[0,j], sgrid.lat[-1,j], (sgrid.lat[-1,j]-sgrid.lat[0,j])/npoints)
sgrid.timeshift=orb.timeshift
ngrid.timeshift=orb.timeshift
ngrid.lon=(lon[ind]+360)%360
ngrid.lat=lat[ind]
sgrid.lon_nadir=(lon[ind]+360)%360
sgrid.lat_nadir=lat[ind]
if os.path.exists(filesgrid):
os.remove(filesgrid)
sgrid.write_swath()
if p.nadir:
if os.path.exists(filengrid):
os.remove(filengrid)
ngrid.write_orb()
mod_tools.update_progress(1, 'All swaths have been processed', ' ')
return None
def run_nadir(file_param):
if os.path.isfile(file_param):
# basedir=os.path.dirname(swotsimulator.__file__)
shutil.copyfile(file_param,
'params.py') #os.path.join(basedir,'params.py'))
else:
print("Error: No such file: '%s'" % file_param)
sys.exit()
try:
import params as p
except:
if os.path.isfile('params.py'):
print("There is a wrong entry in your params file")
import params
else:
print("Error: No params.py module found")
sys.exit()
import swotsimulator.build_swath as build_swath
import swotsimulator.rw_data as rw_data
import swotsimulator.build_error as build_error
import swotsimulator.mod_tools as mod_tools
import swotsimulator.const as const
## - Initialize some parameters values
try:
p.shift_lon = p.shift_lon
except:
p.shift_lon = None
try:
p.shift_time = p.shift_time
except:
p.shift_time = None
try:
model = p.model
except:
model = 'NETCDF_MODEL'
p.model = model
try:
p.model_nan = p.model_nan
except:
p.model_nan = 0.
try:
p.SSH_factor = p.SSH_factor
except:
p.SSH_factor = 1. #; p.SSH_factor=SSH_factor
try:
p.nadir = p.nadir
except:
p.nadir = True
try:
p.grid = p.grid
except:
p.grid = 'regular'
p.karin = False
p.phase = False
p.roll = False
p.baseline_dilation = False
p.timing = False
p.halfswath = 60.
## - Progress bar variables are global
global istep
global ntot
## - Read list of user model files """
if p.file_input:
list_file = [line.strip() for line in open(p.file_input)]
## - Read model input coordinates '''
# if no modelbox is specified (modelbox=None), the domain of the input data is taken as a modelbox
# coordinates from the region defined by modelbox are selected
if p.file_input:
model_data = eval('rw_data.' + model +
'(file=p.indatadir+os.sep+list_file[0])')
if p.modelbox:
modelbox = numpy.array(p.modelbox, dtype='float')
## Use convert to 360 data
modelbox[0] = (modelbox[0] + 360) % 360
if modelbox[1] != 360:
modelbox[1] = (modelbox[1] + 360) % 360
else:
if p.file_input:
modelbox = model_data.calc_box()
else:
print('modelbox should be provided if no model file is provided')
sys.exit()
if p.file_input:
model_data.read_coordinates()
## Select model data in the region modelbox
if p.grid == 'regular':
model_data.model_index_lon = numpy.where(
((modelbox[0] - 1) <= model_data.vlon)
& (model_data.vlon <= (modelbox[1] + 1)))[0]
model_data.model_index_lat = numpy.where(
((modelbox[2] - 1) <= model_data.vlat)
& (model_data.vlat <= (modelbox[3] + 1)))[0]
model_data.vlon = model_data.vlon[model_data.model_index_lon]
model_data.vlat = model_data.vlat[model_data.model_index_lat]
else:
model_data.model_index = numpy.where(
((modelbox[0] - 1) <= model_data.vlon) & (model_data.vlon <=
(modelbox[1] + 1)) &
((modelbox[2] - 1) <= model_data.vlat) &
(model_data.vlat <= (modelbox[3] + 1))) #[0]
model_data.model = model
model_data.vloncirc = numpy.rad2deg(numpy.unwrap(model_data.vlon))
## Ugly trick when model box is [0 360] to avoid box being empty (360=0%360)
if modelbox[1] == 0: modelbox[1] = 359.99
## - Initialize random coefficients that are used to compute
## random errors following the specified spectrum
err, errnad = load_error(p)
## - Compute interpolated SSH and errors for each pass, at each
## cycle
print('Compute interpolated SSH and errors:')
## Model time step
modeltime = numpy.arange(0, p.nstep * p.timestep, p.timestep)
## Remove the grid from the list of model files
if p.file_input: list_file.remove(list_file[0])
## Initialize progress bar variables
istep = 0
ntot = 1
## Initialize list of satellites
istring = len(p.dir_setup)
if not isinstance(p.filesat, list):
p.filesat = [p.filesat]
for filesat in p.filesat:
## Select satellite
ntmp, nfilesat = os.path.split(filesat[istring:-4])
## Make satellite orbit grid
if p.makesgrid:
print('\n Force creation of satellite grid')
ngrid = build_swath.makeorbit(modelbox, p, orbitfile=filesat)
ngrid.file = p.outdatadir + os.sep + nfilesat + '_grid.nc'
ngrid.write_orb()
ngrid.ipass = nfilesat
ngrid.gridfile = p.outdatadir + os.sep + nfilesat + '_grid.nc'
else:
## To be replaced by load_ngrid
ngrid = rw_data.Sat_nadir(file=p.filesgrid + '.nc')
ngrid.ipass = nfilesat
ngrid.gridfile = p.outdatadir + os.sep + nfilesat + '_grid.nc'
cycle = 0
x_al = []
al_cycle = 0
timeshift = 0
ngrid.load_orb(cycle=cycle,
x_al=x_al,
al_cycle=al_cycle,
timeshift=timeshift)
ngrid.loncirc = numpy.rad2deg(numpy.unwrap(ngrid.lon))
#ngrid=load_ngrid(sgridfile, p)
## Select model data around the swath to reduce interpolation cost in griddata
## - Generate SWOT like and nadir-like data:
## Compute number of cycles needed to cover all nstep model timesteps
if p.file_input:
model_index = numpy.where(
((numpy.min(ngrid.lon)) <= model_data.vlon)
& (model_data.vlon <= (numpy.max(ngrid.lon)))
& ((numpy.min(ngrid.lat)) <= model_data.vlat)
& (model_data.vlat <= (numpy.max(ngrid.lat))))
rcycle = (p.timestep * p.nstep) / float(ngrid.cycle)
ncycle = int(rcycle)
## Loop on all cycles
for cycle in range(0, ncycle + 1):
if ifile > (p.nstep / p.timestep + 1): break
## Create SWOT-like and Nadir-like data
if not p.file_input: model_data = []
SSH_true_nadir, vindice, time, progress = create_Nadirlikedata(
cycle,
numpy.shape(p.filesat)[0] * rcycle,
list_file,
modelbox,
ngrid,
model_data,
modeltime,
errnad,
p,
progress_bar=True)
#SSH_true_nadir, vindice_nadir=create_Nadirlikedata(cycle, sgrid, ngrid, model_data, modeltime, err, errnad, p)
## Save outputs in a netcdf file
ngrid.gridfile = filesat
if (~numpy.isnan(vindice)).any() or not p.file_input:
err = errnad
err.wtnadir = numpy.zeros((1))
err.wet_tropo2nadir = numpy.zeros((1))
save_Nadir(cycle,
ngrid,
errnad,
err,
p,
time=time,
vindice_nadir=vindice,
SSH_true_nadir=SSH_true_nadir)
del time
#if p.file_input: del index
ngrid.lon = (ngrid.lon + 360) % 360
if p.file_input: model_data.vlon = (model_data.vlon + 360) % 360
modelbox[0] = (modelbox[0] + 360) % 360
modelbox[1] = (modelbox[1] + 360) % 360
del ngrid
if progress != 1:
progress = mod_tools.update_progress(1,
'All passes have been processed',
'')
## - Write Selected parameters in a txt file
rw_data.write_params(p, p.outdatadir + os.sep + 'nadir_simulator.output')
print("\n Simulated orbit files have been written in " + p.outdatadir)
print("----------------------------------------------------------")
