def tlePrimario(tlepri):
"""
-----------------------------------------------------------------
Devuelve el vector de estado y la epoca
correspondiente a la referencia como dato primario
-----------------------------------------------------------------
input
tlepri: nombre del archivo con el TLE primario (string)
output
r,v: vector posicion y velocidad para el TLE primario (array)
ffin: epoca del TLE primario (datetime)
"""
whichconst = wgs72
archivo = '../TleAdmin/tle/' + tlepri
tle0 = Tle.creadoxArchivo(archivo)
line1 = tle0.linea1
line2 = tle0.linea2
r, v = tle0.propagaTLE()
satrec = twoline2rv(line1, line2, whichconst)
ffin = satrec.epoch
# r,v = sgp4(satrec,0)
xf, yf, zf = tuplaFloat(r)
xv, yv, zv = tuplaFloat(v)
r = np.array([xf, yf, zf])
v = np.array([xv, yv, zv])
return r, v, ffin
def tleSecundario(tlesec, ffin):
"""
---------------------------------------------------------------------------------
Calcula la posicion del satelite propagada a la fecha del TLE primario.
---------------------------------------------------------------------------------
input
tlesec: nombre del archivo que contiene el TLE secundario (string)
output
pos,vel: vector posicion y velocidad que resultan de la propagacion del
TLE secundario hasta la fecha del TLE primario (array)
fsec: epoca del TLE secundario
"""
whichconst = wgs72
archivo = '../TleAdmin/tle/' + tlesec
tle1 = Tle.creadoxArchivo(archivo)
line1 = tle1.linea1
line2 = tle1.linea2
satrec1 = twoline2rv(line1, line2, whichconst)
ffin_anno = ffin.year
ffin_mes = ffin.month
ffin_dia = ffin.day
ffin_hora = ffin.hour
ffin_min = ffin.minute
ffin_s = ffin.second
# pos, vel = sgp4(satrec1,0)
pos, vel = satrec1.propagate(ffin_anno, ffin_mes, ffin_dia, ffin_hora,
ffin_min, ffin_s)
x, y, z = tuplaFloat(pos)
vx, vy, vz = tuplaFloat(vel)
pos = np.array([x, y, z])
vel = np.array([vx, vy, vz])
fsec = satrec1.epoch
return pos, vel, fsec
def diferencias_tleCODS(salida, tles, linea_interpol, data):
"""
Toma la lista de archivos TLEs y propaga cada uno hasta la epoca de la
linea interpolada. Luego compara los valores de las coordenadas propagadas
con los valores de la linea interpolada y genera las diferencias.
Imprime los resultados en el archivo salida.
----------------------------------------------------------------------------------------------------------
input
salida: archivo donde se escribe (Instancia de apertura de archivo)
tles: lista de nombres de archivos tle (diccionario)
linea_interpol: Linea interpolada de los datos CODS para la epoca del TLE primario. (String)
output
difTot_satId_fini_ffin.cods: Archivo con todas las diferencias ('../Comparar/diferencias/')
"""
fecha = linea_interpol[:26]
d = datetime.strptime(fecha, '%Y-%m-%d %H:%M:%S.%f')
r = np.array([
float(linea_interpol.split()[2]),
float(linea_interpol.split()[3]),
float(linea_interpol.split()[4])
])
rp = np.array([
float(linea_interpol.split()[5]),
float(linea_interpol.split()[6]),
float(linea_interpol.split()[7])
])
item = range(0, len(tles))
whichconst = wgs72
for j in item:
tle0 = Tle.creadoxArchivo('../TleAdmin/tle/' + tles[j][0])
fecha_tle = tle0.epoca()
if fecha_tle <= d:
dif_fechas = (d - fecha_tle).total_seconds() / 86400.0
line1 = tle0.linea1
line2 = tle0.linea2
satrec = twoline2rv(line1, line2, whichconst)
pos1, vel1 = satrec.propagate(d.year, d.month, d.day, d.hour,
d.minute, d.second)
pos = teme2tod(fecha_tle, pos1)
vel = teme2tod(fecha_tle, vel1)
difx = [pos[0, 0] - r[0], pos[0, 1] - r[1], pos[0, 2] - r[2]]
difv = [vel[0, 0] - rp[0], vel[0, 1] - rp[1], vel[0, 2] - rp[2]]
# difx=[pos1[0]-r[0],pos1[1]-r[1],pos1[2]-r[2]]
# difv=[vel1[0]-rp[0],vel1[1]-rp[1],vel1[2]-rp[2]]
v, n, c = vncSis(r, rp, difx)
vv, nn, cc = vncSis(r, rp, difv)
dato = str(fecha_tle) + ' ' + str(v) + ' ' + str(n) + ' ' + str(
c) + ' ' + str(vv) + ' ' + str(nn) + ' ' + str(cc) + '\n'
salida.write(dato)
data[0].append(fecha_tle)
data[1].append(v)
data[2].append(n)
data[3].append(c)
data[4].append(vv)
data[5].append(nn)
data[6].append(cc)
data[7].append(dif_fechas)
return data
def interpola_3sv(tle, arch3_cods):
"""
Extrale del tle primario la epoca y luego busca entre los archivos
CODS cual de los mas actualizados contiene la epoca del TLE.
Luego interpola los valores de CODS para la epoca del TLE
y devuelve el vector de estado interpolado correspondiente a la epoca.
----------------------------------------------------------------------------------------
input
tle: nombre del archivo del TLE primario (String)
arch3_cods: nombre de los archivos CODS que contienen la epoca del TLE. (Lista)
output
linea_interpol: linea con el vector de estado interpolado a la epoca del TLE. (String)
"""
tle1 = Tle.creadoxArchivo(tle)
fecha_tle = tle1.epoca()
r, v = tle1.propagaTLE()
fila = str(fecha_tle) + ' ' + str(r[0]) + ' ' + str(r[1]) + ' ' + str(
r[2]) + ' ' + str(v[0]) + ' ' + str(v[1]) + ' ' + str(v[2])
fecha_minutos = datetime(int(fecha_tle.year), int(fecha_tle.month),
int(fecha_tle.day), int(fecha_tle.hour),
int(fecha_tle.minute), 0)
inferior = 'NULO'
m = 0
for arch in arch3_cods:
a = open(arch, 'r')
contenido = a.readlines()
lista_epocas = []
for c in contenido:
c1 = c.split(' ')
if c1[0] == '*HEADER':
continue
fecha = c[:16]
hr = fecha[11:13]
if hr != '24':
d = datetime.strptime(fecha, '%Y/%m/%d %H:%M')
lista_epocas.append(d)
if fecha_minutos in lista_epocas and m == 0:
indice = lista_epocas.index(fecha_minutos)
inferior = contenido[indice + 1]
if indice + 2 >= len(contenido):
superior = contenido[indice]
else:
superior = contenido[indice + 2]
m = m + 1
if inferior != 'NULO':
linea_interpol = interpola(fila, inferior, superior)
return linea_interpol
else:
return None
def generadorDatos(lista):
"""
----------------------------------------------------------------------
Genera un diccionario, cuyas claves son tle1, tle2, tle3...tle10
y para cada campo, se indica la fecha del tle asociado.
-----------------------------------------------------------------------
input
lista: lista de nombres de los archivos del directorio 'tle' - (string)
output
tledic: diccionario
"""
tledic = {}
datos = []
for arch in lista:
nombre = arch.split('/')[-1]
tle = Tle.creadoxArchivo(arch) # instancia un objeto de la clase TLE
datos.append(tle.epoca()) # ejecuta un metodo de la clase TLE
tledic[nombre] = datos
datos = []
return tledic
def FiltraArchivos(tle):
"""
Extrae la fecha del TLE y busca los
archivos CODS que podrian contener la fecha necesaria.
Toma el nombre del archivo cuyo nombre contiene la fecha el TLE
primario y agrega a su vez el nombre de los proximos 3 archivos
ya que tambien contendran esa fecha y con valores mas actualizados.
----------------------------------------------------------------
input
tle: nombre del archivo del TLE a procesar (String)
output
archivos_datos: nombres de los archivos CODS que contienen la fecha
del TLE primario - (Lista)
"""
tle1 = Tle.creadoxArchivo(tle)
fecha = tle1.epoca()
fechas_busqueda = [
datetime(fecha.year, fecha.month, fecha.day) + timedelta(days=2),
datetime(fecha.year, fecha.month, fecha.day) + timedelta(days=1),
datetime(fecha.year, fecha.month, fecha.day)
]
nombre_archivos = glob.glob('../CodsAdmin/TOD_O/*')
lista_fechas = []
archivos_datos = []
for nom in nombre_archivos:
e_CODS = EphemCODS(nom.split('/')[-1])
anio, mes, dia, hora, minu, seg = EphemCODS.parsea_epoca_nombre(e_CODS)
fecha_cods_nombre = datetime(int(anio), int(mes), int(dia))
lista_fechas.append(fecha_cods_nombre)
for f in fechas_busqueda:
if f in lista_fechas:
indice = lista_fechas.index(f)
archivos_datos.append(nombre_archivos[indice])
else:
pass
return archivos_datos
def ejecutaProcesamientoCods():
#if __name__ == '__main__':
"""
REVISAR - FUE MODIFICADO
Lista y ordena los nombres de los archivos de la carpeta: TleAdmin/tles.
Recupera la informacion del ultimo TLE del set (TLE primario), en particular la epoca.
Busca entre los archivos de CODS, la epoca coincidente con la epoca del TLE primario.
Interpola para la fecha al nivel del segundo.
Luego propaga todos los TLEs del set a la epoca del CODS interpolado y calcular las
diferencias.
---------------------------------------------------------------------------------------
Nota! LOS DATOS CODS SON SOLO DE LA MISION SAC-D.
Luego los tles, previamente procesados y archivados en la carpeta de TleAdmin/tles, deben
corresponderse con esa mision.
"""
# print 'PROCESANDO DATOS DE MISION...'
tles = glob.glob('../TleAdmin/tle/*')
dic_tles = generadorDatos(tles)
tle_ordenados = ordenaTles(dic_tles)
# tles=glob.glob('../TleAdmin/tle/*')
# dic_tles=generadorDatos(tles)
# tle_ordenados=ordenaTles(dic_tles)
tle_inicio = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[0][0])
cat_id = tle_inicio.catID()
epoca_ini = tle_inicio.epoca()
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[-1][0])
epoca_fin = tle_primario.epoca()
epoca_ffin = epoca_fin
epoca15dias = epoca_ffin - timedelta(days=15)
"""
Impresiones de info de TLEs.
"""
tle_inicio = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[0][0])
cat_id = tle_inicio.catID()
epoca_ini = tle_inicio.epoca()
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[-1][0])
epoca_fin = tle_primario.epoca()
epoca_ffin = epoca_fin
linea1 = tle_primario.linea1
linea2 = tle_primario.linea2
fecha_ini = str(epoca_ini.year) + str(epoca_ini.month).zfill(2) + str(
epoca_ini.day).zfill(2)
fecha_fin = str(epoca_fin.year) + str(epoca_fin.month).zfill(2) + str(
epoca_fin.day).zfill(2)
# print '------------------------------------------------------------------------'
# print '-------------------------TLE PRIMARIO-----------------------------------'
# print linea1
# print linea2
# print epoca_ffin
# print '------------------------------------------------------------------------'
t = []
dv = []
du = []
dc = []
dvv = []
dnn = []
dcc = []
dt_frac = []
t15 = []
dv15 = []
du15 = []
dc15 = []
dvv15 = []
dnn15 = []
dcc15 = []
dt_frac15 = []
#===============
# Set de Datos
#===============
data = [t, dv, du, dc, dvv, dnn, dcc, dt_frac]
data15 = [t15, dv15, du15, dc15, dvv15, dnn15, dcc15, dt_frac15]
#======================
# Nomenclatura Archivos
#======================
archivo = cat_id + '_' + fecha_ini + '_' + fecha_fin + '.cods'
salida = open('../Comparar/diferencias/difTot_' + archivo, 'w')
salida1 = open('../Comparar/diferencias/' + archivo, 'w')
salida15 = open('../Comparar/diferencias/dif_15dias_' + archivo, 'w')
#===============================================
# Bucle de comparacion total (tiene sentido?)
#===============================================
for m in range(len(tle_ordenados) - 1, 0, -1):
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[m][0])
epoca_fin = tle_primario.epoca()
arch3_cods = FiltraArchivos('../TleAdmin/tle/' + tle_ordenados[m][0])
linea_interpol = interpola_3sv(
'../TleAdmin/tle/' + tle_ordenados[m][0], arch3_cods)
if linea_interpol != None:
data = diferencias_tleCODS(salida, tle_ordenados, linea_interpol,
data)
if m == len(tle_ordenados) - 1:
for k in range(len(data[0])):
info = data[0][k].strftime(
"%Y-%m-%d %H:%M:%S.%f") + ' ' + str(
data[1][k]) + ' ' + str(data[2][k]) + ' ' + str(
data[3][k]) + ' ' + str(
data[4][k]) + ' ' + str(
data[5][k]) + ' ' + str(
data[6][k]) + '\n'
salida1.write(info)
else:
continue
#==================================================
# Bucle de comparacion del set primario (15 TLEs)
#==================================================
epoca15 = epoca_ffin - timedelta(days=15)
for m in range(len(tle_ordenados) - 1, 0, -1):
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[m][0])
epoca_fin = tle_primario.epoca()
if epoca_fin > epoca15:
arch3_cods = FiltraArchivos('../TleAdmin/tle/' +
tle_ordenados[m][0])
linea_interpol = interpola_3sv(
'../TleAdmin/tle/' + tle_ordenados[m][0], arch3_cods)
if linea_interpol != None:
data15 = dif_tleCODS15dias()
if m == len(tle_ordenados) - 1:
for k in range(len(data15[0])):
info = data15[0][k] + ' ' + str(
data15[1][k]) + ' ' + str(
data15[2][k]) + ' ' + str(
data15[3][k]) + ' ' + str(
data15[4][k]) + ' ' + str(
data15[5][k]) + ' ' + str(
data15[6][k]) + '\n'
# info = data15[0][k].strftime("%Y-%m-%d %H:%M:%S.%f")+' '+str(data15[1][k])+' '+str(data15[2][k])+' '+str(data15[3][k])+' '+str(data15[4][k])+' '+str(data15[5][k])+' '+str(data15[6][k])+'\n'
salida15.write(info)
else:
continue
else:
continue
salida1.close()
"""
AJUSTE Y GENERACION DE COEFICIENTES.
"""
# dt,coef,statsReport=ajustar_diferencias(epoca_ffin,data15,2)
# dt1,coef1,statsReport1=ajustar_diferencias(epoca_ffin,data15,1)
coef1 = 0
"""
Guarda en archivos las diferencias que se corresponden al
ultimo TLE del set. (Estadistica/archivos)
tendenciaTle.py toma luego esos archivos, y grafica.
"""
estadistica_salida = open(
'../Estadistica/archivos/' + fecha_ini + '_' + fecha_fin +
'_difEst.txt', 'w')
info_esta = fecha_fin + ' ' + str(data[1][len(tles)]) + ' ' + str(
data[2][len(tles)]) + ' ' + str(data[3][len(tles)])
estadistica_salida.write(info_esta)
estadistica_salida.close()
print 'DIFERENCIAS:'
print '-------------------------------------------------------------------------'
diferencias = [
data[1][len(tles) - 1], data[2][len(tles) - 1], data[3][len(tles) - 1],
data[4][len(tles) - 1], data[5][len(tles) - 1], data[6][len(tles) - 1]
]
print 'dv =', data[1][len(tles) - 1]
print 'dn =', data[2][len(tles) - 1]
print 'dc =', data[3][len(tles) - 1]
print '-------------------------------------------------------------------------'
print 'Fin del Calculo de Diferencias'
# set_datos=[str(cat_id),linea1,linea2,epoca_ini.strftime("%Y-%m-%d %H:%M:%S.%f"),epoca_ffin.strftime("%Y-%m-%d %H:%M:%S.%f"),dt,data,coef,archivo]
set_data15 = [
str(cat_id), linea1, linea2,
epoca_ini.strftime("%Y-%m-%d %H:%M:%S.%f"),
epoca_ffin.strftime("%Y-%m-%d %H:%M:%S.%f"), data15, coef1, archivo
]
return diferencias, set_data15
def dif_tleCODS15dias():
t = []
dv = []
du = []
dc = []
dvv = []
dnn = []
dcc = []
dt_frac = []
#===============
# Set de Datos
#===============
data = [t, dv, du, dc, dvv, dnn, dcc, dt_frac]
# print 'PROCESANDO DATOS DE MISION...'
tles = glob.glob('../TleAdmin/tle/*')
dic_tles = generadorDatos(tles)
tle_ordenados = ordenaTles(dic_tles)
salida = open('../Comparar/diferencias/difPri_prueba', 'w')
tles = glob.glob('../TleAdmin/tle/*')
dic_tles = generadorDatos(tles)
tle_ordenados = ordenaTles(dic_tles)
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[-1][0])
epoca_ffin = tle_primario.epoca()
cat_id = tle_primario.catID()
linea1 = tle_primario.linea1
linea2 = tle_primario.linea2
epoca15dias = epoca_ffin - timedelta(days=15)
tle_inicio = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[0][0])
epoca_ini = tle_inicio.epoca()
arch3_cods = FiltraArchivos('../TleAdmin/tle/' + tle_ordenados[-1][0])
linea_interpol = interpola_3sv('../TleAdmin/tle/' + tle_ordenados[-1][0],
arch3_cods)
archivo = cat_id + '_' + epoca_ini.strftime(
"%Y-%m-%d %H:%M:%S.%f") + '_' + epoca_ffin.strftime(
"%Y-%m-%d %H:%M:%S.%f") + '.cods'
#===============================================
# Bucle de comparacion total (tiene sentido?)
#===============================================
for m in range(len(tle_ordenados) - 1, 0, -1):
tle0 = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[m][0])
epoca_tle0 = tle0.epoca()
if epoca_tle0 >= epoca15dias:
data = diferencias_tleCODS(salida, tle_ordenados, linea_interpol,
data)
if m == len(tle_ordenados) - 1:
for k in range(len(data[0])):
info = data[0][k].strftime(
"%Y-%m-%d %H:%M:%S.%f") + ' ' + str(
data[1][k]) + ' ' + str(data[2][k]) + ' ' + str(
data[3][k]) + ' ' + str(
data[4][k]) + ' ' + str(
data[5][k]) + ' ' + str(
data[6][k]) + '\n'
salida.write(info)
else:
continue
dt, coef, statsReport = ajustar_diferencias(epoca_ffin, data, 2)
# print statsReport
set_data15 = [
str(cat_id), linea1, linea2,
epoca_ini.strftime("%Y-%m-%d %H:%M:%S.%f"),
epoca_ffin.strftime("%Y-%m-%d %H:%M:%S.%f"), dt, data, coef, archivo
]
return set_data15
linea_interpol = interpola_3sv('../TleAdmin/tle/' + tle,
tres_archivos)
if linea_interpol != None:
fecha = linea_interpol[:26]
d = datetime.strptime(fecha, '%Y-%m-%d %H:%M:%S.%f')
r = np.array([
float(linea_interpol.split()[2]),
float(linea_interpol.split()[3]),
float(linea_interpol.split()[4])
])
rp = np.array([
float(linea_interpol.split()[5]),
float(linea_interpol.split()[6]),
float(linea_interpol.split()[7])
])
tle0 = Tle.creadoxArchivo('../TleAdmin/tle/' + tle)
line1 = tle0.linea1
line2 = tle0.linea2
satrec = twoline2rv(line1, line2, whichconst)
pos1, vel1 = tle0.propagaTLE(d)
#satrec.propagate(d.year, d.month, d.day,d.hour, d.minute, d.second)
r_teme = [pos1[0], pos1[1], pos1[2]]
v_teme = [vel1[0], vel1[1], vel1[2]]
semi, e, inc, Omega, w, nu = xv2eo(r, rp)
a.append(semi / 1000.0)
i.append(inc * 180.0 / (np.pi))
r_tod = teme2tod(d, r_teme)
r_tod = np.array(r_tod[0])
v_tod = teme2tod(d, v_teme)
v_tod = np.array(v_tod[0])
t.append(tle0.epoca())
def difTle(tleOrdenados, cantidad_tles):
"""
---------------------------------------------------------------
Diferencias de Osweiler. (Pair-Wise Differencing)
Calcula las diferencias entre TLE primario y secundarios
en el sistema v,n y c; o (ric).
Lo hace en forma iterativa, recorriendo todos los TLE a fin
de que todos son primarios en algun momento.
---------------------------------------------------------------
input:
tleOrdeandos: lista de TLEs y sus 2-lineas (lista de lista)
output:
difTotal# : archivo de texto plano (4 columnas) para cada set
[AjustarTLE/diferencias/difTotal_satID_fechaIni#]
bin : lista de listas, con las diferencias por bin.
data: lista de listas, [dt_frac,dv,dn,dc]
"""
print 'Procesando datos TLE...'
tles = glob.glob('../TleAdmin/tle/*')
dic_tles = generadorDatos(tles)
tle_ordenados = ordenaTles(dic_tles)
tle_inicio = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[0][0])
cat_id = tle_inicio.catID()
epoca_ini = tle_inicio.epoca()
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[-1][0])
epoca_fin = tle_primario.epoca()
epoca_ffin = epoca_fin
nombre = 'difTot_' + str(cat_id) + '_' + epoca_ffin.strftime(
'%Y%m%d') + '_' + epoca_ini.strftime('%Y%m%d') + '.TLE'
nombre2 = 'difTot_xyz_' + str(cat_id) + '_' + epoca_ffin.strftime(
'%Y%m%d') + '_' + epoca_ini.strftime('%Y%m%d') + '.TLE'
dtot = open('../AjustarTLE/diferencias/' + nombre + '', 'w')
dtot2 = open('../AjustarTLE/diferencias/' + nombre2 + '', 'w')
dt_tle = []
dt_frac = []
dv = []
dn = []
dc = []
dvv = []
dnn = []
dcc = []
dx = []
dy = []
dz = []
dxx = []
dyy = []
dzz = []
bin = [[], [], [], [], [], [], [], [], [], [], [], [], [], [], []]
m = 0
for i in range(cantidad_tles - 1, 0, -1):
tlepri = tleOrdenados[i][0]
r, rp, ffin = tlePrimario(tlepri)
item = range(i - 1, -1, -1)
for j in item:
tlesec = tleOrdenados[j][0]
pos, vel, fsec = tleSecundario(tlesec, ffin)
dt_tle.append(fsec)
dr = pos - r
d_v = vel - rp
x = dr[0]
y = dr[1]
z = dr[2]
xx = d_v[0]
yy = d_v[1]
zz = d_v[2]
dt = abs(fsec - ffin)
dtfracdias = dt.total_seconds() / 86400.0
v, n, c = vncSis(r, rp, dr)
vv, nn, cc = vncSis(r, rp, d_v)
# v,n,c=ricSis(r, rp, dr)
# vv,nn,cc=ricSis(r,rp,dv)
infodiftot = str(fsec) + ' ' + str(v) + ' ' + str(n) + ' ' + str(
c) + ' ' + str(vv) + ' ' + str(nn) + ' ' + str(
cc) + ' ' + tlesec + '\n'
infodiftot2 = str(fsec) + ' ' + str(x) + ' ' + str(y) + ' ' + str(
z) + ' ' + str(xx) + ' ' + str(yy) + ' ' + str(
zz) + ' ' + tlesec + '\n'
dtot.write(infodiftot)
dtot2.write(infodiftot2)
dt_frac.append(dtfracdias)
'''
Sistema VNC
'''
dv.append(v)
dn.append(n)
dc.append(c)
dvv.append(vv)
dnn.append(nn)
dcc.append(cc)
'''
Sistema TEMA
'''
dx.append(x)
dy.append(y)
dz.append(z)
dxx.append(xx)
dyy.append(yy)
dzz.append(zz)
"""
Clasificacion por bin.
"""
rangos = np.array([[0, 0.5], [0.5, 1.5], [1.5, 2.5], [2.5, 3.5],
[3.5, 4.5], [4.5, 5.5], [5.5, 6.5], [6.5, 7.5],
[7.5, 8.5], [8.5, 9.5], [9.5, 10.5],
[10.5, 11.5], [11.5, 12.5], [12.5, 13.5],
[13.5, 14.5]])
for k in range(len(rangos)):
if dtfracdias >= rangos[k][0] and dtfracdias < rangos[k][1]:
bin[k].append(infodiftot)
m = m + 1
dataPri = [
dt_tle[:15], dv[:15], dn[:15], dc[:15], dvv[:15], dnn[:15], dcc[:15],
dt_frac[:15]
]
data1 = [dt_tle, dv, dn, dc, dvv, dnn, dnn, dt_frac]
print '++++++++++++GRADO 2++++++++++++++++++'
dt, coef, statsReport = ajustar_diferencias(epoca_ffin, dataPri, 2)
print coef
print statsReport
print '++++++++++++GRADO 1++++++++++++++++++'
dt1, coef1, statsReport1 = ajustar_diferencias(epoca_ffin, dataPri, 1)
print coef1
print statsReport1
data = [dt, data1, coef, nombre]
dtot.close()
return bin, data, dataPri, coef1
cods_date_dic={}
for fcods in cods_files:
campos=fcods.split('/')
ephem=EphemCODS(campos[4])
y_cods, mon_cods, d_cods, hs_cods, min_cods, sec_cods = ephem.parsea_epoca_nombre()
cods_date_dic[datetime(int(y_cods), int(mon_cods),int(d_cods))]={'nombre':fcods}
cods_dates.append(datetime(int(y_cods), int(mon_cods),int(d_cods)))
error_file_number=0
epoca_tle_list=[]
dx=[]
dy=[]
dz=[]
for f in tle_files[1:3]:
# TLE data - transformacion al sistema TOD
tle=Tle.creadoxArchivo(f)
epoca_tle=tle.epoca()
r,v=tle.propagaTLE(datetime(epoca_tle.year,epoca_tle.month,epoca_tle.day,epoca_tle.hour,epoca_tle.minute,epoca_tle.second))
r_tod=teme2tod(epoca_tle, r)
date_tle=datetime(epoca_tle.year,epoca_tle.month,epoca_tle.day)
# Busqueda del archivo correspondiente.
cods_date=date_tle+timedelta(days=2)
existe_dosmas=cods_date_dic.has_key(cods_date)
if existe_dosmas:
nombre_cods=cods_date_dic[cods_date]['nombre']
ephem_sv = EphemCODS(nombre_cods)
ephem_dic= ephem_sv.genera_diccionario()
else:
cods_date=date_tle+timedelta(days=1)
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# Se realizan las propagaciones y las comparaciones.
#--------------------------------------------------------------------------------
n = 0
with progressbar.ProgressBar(max_value=7 * 1440) as progress:
#==============
progress.update(n)
n = n + 1
#==============
for k in range(1): # cant_tle
dia_n = 1
while dia_n <= 7:
# Instancio el TLE
tle0 = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[k][0])
dia_prop = tle0.epoca() + timedelta(
days=dia_n) # dial al cual propaga
ini_prop = datetime(dia_prop.year, dia_prop.month, dia_prop.day, 0,
0, 0)
fin_prop = datetime(dia_prop.year, dia_prop.month, dia_prop.day,
23, 59, 59)
dia = dia_prop.strftime('%Y_%m_%d')
# Abro el archivo donde busco para comparar
nombre_archivo = '../Validaciones/tle/37673_xyz_' + dia
lista_archivos = glob.glob('../Validaciones/tle/*')
if nombre_archivo in lista_archivos:
archivo_tle = open(nombre_archivo, 'r')
contenido = archivo_tle.readlines()
archivo_diferencias = open('../Validaciones/tle/37673_xyz_' +
dia + '_' + str(dia_n),
@author: mcvalenti
'''
import numpy as np
from datetime import datetime, timedelta
from TleAdmin.TLE import Tle
from SistReferencia.sist_deCoordenadas import teme2tod
if __name__ == '__main__':
"""
Compara el codigo de transformacion de sistemas de referencia
de TEME (salida del SGP4) a TOD.
"""
path_arch = '../TleAdmin/validacion/'
tle_arch = '37673tle0'
tle = Tle.creadoxArchivo(path_arch + tle_arch)
fecha = tle.epoca()
salida = open('../TleAdmin/validacion/SacD_TEME.txt', 'w')
salida2 = open('../TleAdmin/validacion/SacD_TOD.txt', 'w')
stk_arch = open('../Validaciones/SAC-D_376731_TOD _01ENERO13_STK.txt', 'r')
contenido = stk_arch.readlines()
fecha_inicio = datetime(fecha.year, fecha.month, fecha.day, 0, 0, 0)
dx = []
dy = []
dz = []
for i in range(1440):
# Propaga el TLE cada 1 minuto.
r_f, v_f = tle.propagaTLE(fecha_inicio)
info = fecha_inicio.strftime('%Y-%m-%d %H:%M:%S') + ' ' + str(
r_f[0]) + ' ' + str(r_f[1]) + ' ' + str(r_f[2]) + ' ' + str(
v_f[0]) + ' ' + str(v_f[1]) + ' ' + str(v_f[2]) + '\n'
def difPrimario():
"""
Extrae todos los TLEs que contiene la carpeta tle del administrador
de TLEs. Propaga cada TLEs a la epoca del ultimo del set y calcula
las diferencias. (falta que sea opcional el sistema de ref)
NOTA: Transforma los resultados al sistema TOD.
----------------------------------------------------------------
output:
set de datos ... describir.
"""
tles = glob.glob('../TleAdmin/tle/*')
dic_tles = generadorDatos(tles)
tle_ordenados = ordenaTles(dic_tles)
tle_inicio = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[0][0])
cat_id = tle_inicio.catID()
epoca_ini = tle_inicio.epoca()
#=========================
# Ultimo TLE del set
#=========================
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[-1][0])
epoca_fin = tle_primario.epoca()
epoca_ffin = epoca_fin
epoca15dias = epoca_ffin - timedelta(days=15)
nombre = 'difPri_' + str(cat_id) + '_' + epoca_ffin.strftime(
'%Y%m%d') + '_' + epoca_ini.strftime('%Y%m%d') + '.TLE'
nombre2 = 'difPri_xyz_' + str(cat_id) + '_' + epoca_ffin.strftime(
'%Y%m%d') + '_' + epoca_ini.strftime('%Y%m%d') + '.TLE'
dtot = open('../AjustarTLE/diferencias/' + nombre + '', 'w')
dtot2 = open('../AjustarTLE/diferencias/' + nombre2 + '', 'w')
dt_tle = []
dt_frac = []
dv = []
dn = []
dc = []
dvv = []
dnn = []
dcc = []
dx = []
dy = []
dz = []
dxx = []
dyy = []
dzz = []
tlepri = tle_ordenados[-1][0]
r, rp, ffin = tlePrimario(tlepri) # En TEME
"""
Transformacion del TEME al TOD.
"""
r = teme2tod(ffin, r)
r = np.array([r[0, 0], r[0, 1], r[0, 2]])
rp = teme2tod(ffin, rp)
rp = np.array([rp[0, 0], rp[0, 1], rp[0, 2]])
"""
fin de la transformacion
"""
item = range(len(tle_ordenados) - 2, -1, -1)
for j in item:
tlesec = tle_ordenados[j][0]
tle1 = Tle.creadoxArchivo('../TleAdmin/tle/' + tlesec)
tle1_epoca = tle1.epoca()
if tle1_epoca >= epoca15dias:
pos, vel, fsec = tleSecundario(tlesec, ffin)
"""
Transformacion del TEME al TOD.
"""
pos = teme2tod(fsec, pos)
pos = np.array([pos[0, 0], pos[0, 1], pos[0, 2]])
vel = teme2tod(fsec, vel)
vel = np.array([vel[0, 0], vel[0, 1], vel[0, 2]])
"""
fin de la transformacion
"""
dt_tle.append(fsec)
dr = pos - r
d_v = vel - rp
x = dr[0]
y = dr[1]
z = dr[2]
xx = d_v[0]
yy = d_v[1]
zz = d_v[2]
dt = abs(fsec - ffin)
dtfracdias = dt.total_seconds() / 86400.0
v, n, c = vncSis(r, rp, dr)
vv, nn, cc = vncSis(r, rp, d_v)
# v,n,c=ricSis(r, rp, dr)
# vv,nn,cc=ricSis(r,rp,dv)
infodifpri = str(fsec) + ' ' + str(v) + ' ' + str(n) + ' ' + str(
c) + ' ' + str(vv) + ' ' + str(nn) + ' ' + str(
cc) + ' ' + tlesec + '\n'
infodifpri2 = str(fsec) + ' ' + str(x) + ' ' + str(y) + ' ' + str(
z) + ' ' + str(xx) + ' ' + str(yy) + ' ' + str(
zz) + ' ' + tlesec + '\n'
dtot.write(infodifpri)
dtot2.write(infodifpri2)
dt_frac.append(dtfracdias)
'''
Sistema VNC
'''
dv.append(v)
dn.append(n)
dc.append(c)
dvv.append(vv)
dnn.append(nn)
dcc.append(cc)
'''
Sistema TEME
'''
dx.append(x)
dy.append(y)
dz.append(z)
dxx.append(xx)
dyy.append(yy)
dzz.append(zz)
data1 = [dt_tle, dv, dn, dc, dvv, dnn, dnn, dt_frac]
var_v = np.var(dv)
var_n = np.var(dn)
var_c = np.var(dc)
print '*******************************************************'
print '-----------------Varianzas---------------------------'
print '*******************************************************'
print 'Var en R = ', var_v
print 'Var en T = ', var_n
print 'Var en N = ', var_c
# print '++++++++++++GRADO 2++++++++++++++++++'
dt, coef, statsReport = ajustar_diferencias(epoca_ffin, data1, 2)
# print coef
# print statsReport
#
# print '++++++++++++GRADO 1++++++++++++++++++'
dt1, coef1, statsReport1 = ajustar_diferencias(epoca_ffin, data1, 1)
# print coef1
# print statsReport1
data = [dt, data1, coef, nombre]
dtot.close()
dtot2.close()
return data
#if __name__=='__main__':
#
# d1='../TleAdmin/tle'
# if not os.path.exists(d1):
# os.mkdir(d1)
# d2='../AjustarTLE/diferencias'
# if not os.path.exists(d2):
# os.mkdir(d2)
# d3='../main/matrices/'
# if not os.path.exists(d3):
# os.mkdir(d3)
# d4='../visual/archivos'
# if not os.path.exists(d4):
# os.mkdir(d4)
# # ejecuta_procesamiento_TLE():
# """
# Se crean los directorios necesarios.
# """
#
# d1='../TleAdmin/tle'
# if not os.path.exists(d1):
# os.mkdir(d1)
# d2='../AjustarTLE/diferencias'
# if not os.path.exists(d2):
# os.mkdir(d2)
# d3='../main/matrices/'
# if not os.path.exists(d3):
# os.mkdir(d3)
# d4='../visual/archivos'
# if not os.path.exists(d4):
# os.mkdir(d4)
#
# files=glob.glob('../AjustarTLE/diferencias/*')
# for filename in files:
# os.unlink(filename)
#
# self.bin=difTle(self.tleOrdenados, self.tles)
# self.cantxbin,self.mediaxbin=genera_estadisticaBin(self.bin)
# self.diferencias=difPrimario(self.filename,self.tles-1)
#
# t=[]
# dv=[]
# dn=[]
# dc=[]
#
#
# archivo=open('../AjustarTLE/diferencias/difTotal','r')
# contenido=archivo.readlines()
#
# for c in contenido:
# campos=c.split(',')
# t.append(float(campos[0]))
# dv.append(float(campos[1]))
# dn.append(float(campos[2]))
# dc.append(float(campos[3]))
#
# c, b, a = P.polynomial.polyfit(t, dv, deg=2)
# print c,b,a
#
# x=np.linspace(0,30, 60)
# y=[]
# for i in x:
# y.append(-0.002373*i*i+0.061160*i-0.077031)
#
# plt.plot(t,dv,'x')
# plt.plot(x,y,'-')
# plt.show()
# """
# Verificacion de generacion del archivo con las diferencias
# """
# print '---------------------------------------------------------------------------------'
# print "Verifiacion de la Generacion del archivo de diferencias: ",salida
# print "Ultima modificacion %s" % time.ctime(os.path.getmtime('../AjustarTLE/diferencias/difTotal'))
# print "creado: %s" % time.ctime(os.path.getctime('../AjustarTLE/diferencias/difTotal'))
# print ' '
# print ' '
# """
# generacion de graficos
# """
# gegrafTot('../AjustarTLE/diferencias/difTotal'+setID,setID)
# #gegraf('../AjustarTLE/diferencias/diferencias'+tlepri,tlepri)
def calcula_matriz_OSWcorregido(cat_id, tca0, tca1, crudo, diferencias):
"""
Metodo de Osweiler pero contra el vector de estado
del Tle primario corregido.
"""
files = glob.glob('../TleAdmin/tle/*')
for filename in files:
os.unlink(filename)
set_deb = SetTLE(cat_id, tca0, tca1, crudo)
set_deb.divide_setTLE()
tles = glob.glob('../TleAdmin/tle/*')
dic_tles = generadorDatos(tles)
tle_ordenados = ordenaTles(dic_tles)
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[-1][0])
epoca_primario = tle_primario.epoca()
# En TEME
r0 = np.array([diferencias[0], diferencias[1], diferencias[2]])
rp0 = np.array([diferencias[3], diferencias[4], diferencias[5]])
nombre_archivo = 'difRTN_' + str(cat_id) + '_' + tca1.strftime(
'%Y%m%d') + '.TLE'
archivo_dif_rsw = open('../AjustarTLE/diferencias/' + nombre_archivo + '',
'w')
# listas de diferencias (RTN)
dr = []
dt = []
dn = []
drr = []
dtt = []
dnn = []
item = range(len(tle_ordenados) - 2, -1, -1)
for j in item:
tle1 = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[j][0])
fsec = tle1.epoca()
pos, vel = tle1.propagaTLE(epoca_primario)
pos = np.array([pos[0], pos[1], pos[2]])
vel = np.array([vel[0], vel[1], vel[2]])
# Calculo de Diferencias
d_r = pos - r0
d_v = vel - rp0
r, t, n = vncSis(r0, rp0, d_r)
rr, tt, nn = vncSis(r0, rp0, d_v)
# r,t,n=ricSis(r0, rp0, d_r)
# rr,tt,nn=ricSis(r0,rp0,d_v)
'''
Sistema RTN
'''
dr.append(r)
dt.append(t)
dn.append(n)
drr.append(rr)
dtt.append(tt)
dnn.append(nn)
infodifRST = fsec.strftime('%Y-%m-%d %H:%M:%S') + ' ' + str(
r) + ' ' + str(t) + ' ' + str(n) + ' ' + str(rr) + ' ' + str(
tt) + ' ' + str(nn) + '\n'
archivo_dif_rsw.write(infodifRST)
var_r = np.var(dr)
var_t = np.var(dt)
var_n = np.var(dn)
return nombre_archivo, var_r, var_t, var_n
def calcula_matriz_Tles(cat_id, tca0, tca1, crudo):
"""
Metodo de Osweiler.
Dado un objeto y un intervalo temporal.
Ejecuta el metodo de Osweiler de pair-wise para comparar las
propagaciones de cada TLE a la epoca del ultimo TLE del set,
y generar el archivo de diferencias.
------------------------------------------------------------------
inputs
cat_id: identificador NORAD del objeto (String)
tca0: epoca de inicio del intervalo (Datetime)
tca1: epoca de fin del intervalo (Datetime)
crudo: nombre del archivo con el set de TLEs (String)
'../TleAdmin/tle/*' - viene vacio.
outputs
nombre_archivo: nombre de archivo donde se imprimen las diferencias
('../AjustarTle/ diferencias/') (String)
var_x: varianzas en r,t,n (Float)
"""
files = glob.glob('../TleAdmin/tle/*')
for filename in files:
os.unlink(filename)
set_deb = SetTLE(cat_id, tca0, tca1, crudo)
set_deb.divide_setTLE()
tles = glob.glob('../TleAdmin/tle/*')
# print "=============================================="
# print "Cantidad de TLE: ", len(tles)
dic_tles = generadorDatos(tles)
tle_ordenados = ordenaTles(dic_tles)
tle_primario = Tle.creadoxArchivo('../TleAdmin/tle/' +
tle_ordenados[-1][0])
epoca_primario = tle_primario.epoca()
r0, rp0 = tle_primario.propagaTLE() # En TEME
r0 = np.array([r0[0], r0[1], r0[2]])
nombre_archivo = 'difRTN_' + str(cat_id) + '_' + tca1.strftime(
'%Y%m%d') + '.TLE'
archivo_dif_rsw = open('../AjustarTLE/diferencias/' + nombre_archivo, 'w')
# listas de diferencias (RTN)
dr = []
dt = []
dn = []
drr = []
dtt = []
dnn = []
item = range(len(tle_ordenados) - 2, -1, -1)
for j in item:
tle1 = Tle.creadoxArchivo('../TleAdmin/tle/' + tle_ordenados[j][0])
fsec = tle1.epoca()
# print '======================================='
# print 'Epoca del TLE: ',fsec
# print '=======================================
pos, vel = tle1.propagaTLE(epoca_primario)
pos = np.array([pos[0], pos[1], pos[2]])
vel = np.array([vel[0], vel[1], vel[2]])
# Calculo de Diferencias
d_r = pos - r0
d_v = vel - rp0
# r,t,n=vncSis(r0, rp0, d_r)
# rr,tt,nn=vncSis(r0,rp0,d_v)
r, t, n = ricSis(r0, rp0, d_r)
rr, tt, nn = ricSis(r0, rp0, d_v)
'''
Sistema RTN
'''
dr.append(r)
dt.append(t)
dn.append(n)
drr.append(rr)
dtt.append(tt)
dnn.append(nn)
infodifRST = fsec.strftime('%Y-%m-%d %H:%M:%S') + ' ' + str(
r) + ' ' + str(t) + ' ' + str(n) + ' ' + str(rr) + ' ' + str(
tt) + ' ' + str(nn) + '\n'
archivo_dif_rsw.write(infodifRST)
var_r = np.var(dr)
var_t = np.var(dt)
var_n = np.var(dn)
return nombre_archivo, var_r, var_t, var_n
'''
Created on 28 nov. 2017
@author: curso
'''
import glob
from TleAdmin.TLE import SetTLE, Tle
from datetime import datetime
N_ID='32315'
tca0=datetime(2013,03,10)
tca1=datetime(2013,03,18)
set1=SetTLE(N_ID,tca0,tca1,'11308prueba1.tle')
set1.divide_setTLE()
tle_files=glob.glob('../TleAdmin/tle/*')
for tle in tle_files:
tle_test=Tle.creadoxArchivo(tle)
print tle_test.epoca()