def valida_cdm(cdm_archivo):
"""
Extrae datos del CDM y calcula la PoC con el metodo
de formula explicita de Lei Chen.
"""
cdm=CDM(cdm_archivo)
#=================
# Desgloce del CDM
#=================
sat_id=cdm.noradID_mision
deb_id=cdm.noradID_deb
TCA=cdm.TCA
v_sat=cdm.v_sat
v_deb=cdm.v_deb
dr=float(cdm.dr)/1000.0
ds=float(cdm.ds)/1000.0
dw=float(cdm.dw)/1000.0
var_r=float(cdm.cr_r)*0.000001
var_s=float(cdm.ct_t)*0.000001
var_w=float(cdm.cn_n)*0.000001
# poc_cdm=float(cdm.POC)
#===============================================
#Calculo el angulo entre los vectores velocidad.
#===============================================
cos_phi=np.dot(v_sat,v_deb)/(np.sqrt(np.dot(v_sat,v_sat))*np.sqrt(np.dot(v_deb,v_deb)))
phi=np.arccos(cos_phi)
#===============================================
#Calculo la Probabilidad de Colision.
#===============================================
rsw_vect=[dr,ds,dw]
cov_rsw=np.array([[var_r,0,0],[0,var_s,0],[0,0,var_w]])
mu_x,mu_y,sig2_xc,sig2_yc=proyecta_plano_de_encuentro(rsw_vect,cov_rsw,phi)
PoC,PoC_int=calcula_Poc_manual(mu_x,mu_y,sig2_xc,sig2_yc)
# print '=========================================='
# print 'Proyeccion al Plano'
# print mu_x,mu_y,sig2_xc,sig2_yc
print '=========================================='
# print 'PoC del CDM = ','%.7e' % round(poc_cdm,11)
print 'PoC calculada en forma explicita = ','%.7e' % round(PoC,11)
print 'PoC calculada mediante una integral = ','%.7e' % round(PoC_int[0],11)
print '=========================================='
#===============================================
#Calculo del Encuentro.
#===============================================
tca_epoca=datetime.strptime(TCA,"%Y-%m-%dT%H:%M:%S.%f")
tle_sat=Tle.creadoxParam(sat_id, tca_epoca)
tle_deb=Tle.creadoxParam(deb_id, tca_epoca)
n=0
encuentro = Encuentro(tle_sat,tle_deb,tca_epoca,n)
print '=========================================='
print 'Min distancia Calculada = ', encuentro.mod_minDist
print 'TCA calculado = ', encuentro.tca_c
print 'Componentes RTN del CDM: ', dr, ds, dw
print 'Componentes RTN calculadas: ', encuentro.r_comp, encuentro.s_comp, encuentro.w_comp
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 sv_interpolados(tles):
"""
Arma la lista de TLEs y busca los valores
del Vector de Estado de CODS interpolado para las fechas
correspondientes a los TLEs.
"""
gpsf = open('../CodsAdmin/TOD_O/TOD_CODS_SACD_xyz.txt', 'r')
gpslista = gpsf.readlines()
lineaInterpol = []
for i in tles:
tle1 = Tle(i)
fecha = tle1.epoca()
r, v = tle1.propagaTLE()
fila = str(fecha) + ' ' + str(r[0]) + ' ' + str(r[1]) + ' ' + str(
r[2]) + ' ' + str(v[0]) + ' ' + str(v[1]) + ' ' + str(v[2])
inferior, superior = encuentraBordes(gpslista, fila)
lineaInterpol.append(interpola(fila, inferior, superior))
return lineaInterpol
def generaTOD(tles, sat_id):
listaTle = {}
for i in tles:
tle1 = Tle(i)
fecha = tle1.epoca()
r, v = tle1.propagaTLE()
r_teme = [r[0], r[1], r[2]]
r_tod = teme2tod(fecha, r_teme)
r_todx = np.array(r_tod[0][0])
listaTle[fecha] = str(r_todx[0][0]) + ' ' + str(
r_todx[0][1]) + ' ' + str(
r_todx[0][2]) + '\n' #+str(v[0])+' '+str(v[1])+' '+str(v[2])
listaTle = sorted(listaTle.items())
archivo = str(sat_id) + '_TOD_xyz.txt'
salidaTle = open('../TleAdmin/crudosTLE/' + archivo, 'w+')
for k in listaTle:
infoa = str(k[0])
infob = k[1]
linea = infoa + ' ' + infob + '\n'
salidaTle.write(linea)
salidaTle.close()
return archivo
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
if __name__ == '__main__':
#def EjecutaComparacion(sat_id,ArchivoTLE,ArchivoCODS):
"""
Ajusta TLE.
Propaga un TLE de SAC-D dos dias hacia adelante.
y compara con efemerides precisas.
Hace los promedios de las diferencias.
"""
#========================
# Descarga un TLE
#========================
fecha_tle = datetime(2013, 1, 1, 0, 0, 0, 0)
fecha_ini = fecha_tle + timedelta(days=1)
sat_id = '37673'
tle0 = Tle.creadoxParam(sat_id, fecha_tle)
#archivo de efemeride precisa.
cods_arch = '../CodsAdmin/TOD_O/CODS_20130103_135713_SACD_ORBEPHEM_TOD_XYZ_O.TXT'
cods_efem = open(cods_arch, 'r')
lista_efem = cods_efem.readlines()
#=======================================
# Propaga TLE y compara con CODS
#=======================================
while fecha_ini < datetime(2013, 1, 2, 0, 0, 0, 0) + timedelta(minutes=5):
r_teme, v_teme = tle0.propagaTLE(fecha_ini)
r_tod = np.array(teme2tod(fecha_ini, r_teme))
v_tod = np.array(teme2tod(fecha_ini, v_teme))
linea_tle = fecha_ini.strftime('%Y-%m-%d %H:%M:%S') + ' ' + str(
r_tod[0][0]) + ' ' + str(r_tod[0][1]) + ' ' + str(
sat_id = '27386' #ENVISAT deb_id = '12442' #COSMOS # TCA=datetime(2008,1,9,19,1,30,0) # sat_id='27386' #ENVISAT # deb_id='15482' #COSMOS # TCA=datetime(2013,1,1) # sat_id='37673' #SAC-D # deb_id='15482' #COSMOS """ Prediccion con n dias de aticipacion """ n = 3 # x ejemplo para un CDM que llega 72 hs antes. #=========================================================== # Satelite #=========================================================== tle_sat = Tle.creadoxParam(sat_id, TCA - timedelta(days=n)) #=========================================================== # Desecho #=========================================================== tle_deb = Tle.creadoxParam(deb_id, TCA - timedelta(days=n)) #=========================================================== # ENCUENTRO #=========================================================== encuentro1 = Encuentro(tle_sat, tle_deb, TCA, n) tca_calculado = encuentro1.tca_c min_distancia = encuentro1.mod_minDist dif_r = encuentro1.DistRic_min[0] dif_t = encuentro1.DistRic_min[1] dif_n = encuentro1.DistRic_min[2] #Calculo el angulo entre los vectores velocidad. # v_sat=encuentro1.vel_sat_tca
]
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
with open('tabladatos.csv') as File:
reader = csv.reader(File)
cdm_list = list(reader)
for row in cdm_list[4:6]:
obj1_id = row[0]
obj2_id = row[1]
tca = datetime.strptime(row[2], '%d/%m/%Y %H:%M:%S')
miss_distance = row[3]
poc = row[4]
# Instanciacion de los TLE
tle_sat = Tle.creadoxParam(obj1_id, tca)
tle_deb = Tle.creadoxParam(obj2_id, tca)
# Corroborar que el TLE es anterior en fecha y hora al tca
if tle_sat.epoca() >= tca:
tca_sust = tca - timedelta(days=1)
tle_sat = Tle.creadoxParam(obj1_id, tca_sust)
if tle_deb.epoca() >= tca:
tca_sust = tca - timedelta(days=1)
tle_deb = Tle.creadoxParam(obj2_id, tca_sust)
encuentro1 = Encuentro(tle_sat, tle_deb, tca, hr)
# Procesamiento Lei-Chen
#poc_lei=encuentro1.calculaPoC_circ()
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
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
'''
Created on 20/10/2017
----------------------------------------------------
A partir de una lista de NORAD ID.
El codigo se trae un TLE de Space-track y verifica
si el satelite en cuestion es LEO o DEEP SPACE
----------------------------------------------------
@author: mcvalenti
'''
from datetime import datetime
from sgp4.earth_gravity import wgs72, wgs84
from sgp4.io import twoline2rv
from TleAdmin.TLE import Tle
object_list = [
'25415', '31445', '20737', '20738', '27939', '31588', '11308', '32315',
'17583'
]
epocaf = datetime(2013, 03, 15)
whichconst = wgs84
for sat_id in object_list:
tle = Tle.creadoxParam(sat_id, epocaf)
satrec = twoline2rv(tle.linea1, tle.linea2, whichconst)
if (satrec.a - 1.0) * 6378 < 5877.5:
print 'LEO satellte: ', (satrec.a - 1.0) * 6378
else:
print 'DEEP SPACE OBJECT: ', (satrec.a - 1.0) * 6378
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
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
@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)
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# 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),
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)
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())
'''
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()
# min_d= 0.18 # dr=0.0359 # dt=-0.1488 # dn=0.0957 # MENSAJE # 8 # sat_id='27372' # deb_id='31413' # TCA=datetime(2013,01,11,5,30,55,0) # min_d= 0.15 # dr=-0.1191 # dt=0.0003 # dn=0.092 #tca_epoca=datetime.strptime(TCA,"%Y-%m-%dT%H:%M") tle_sat = Tle.creadoxParam(sat_id, TCA) tle_deb = Tle.creadoxParam(deb_id, TCA) n = 3 encuentro = Encuentro(tle_sat, tle_deb, TCA, n) rtn_dist = encuentro.DistRic_min set_data = encuentro.tca_min_data poc, poc_int = encuentro.calculaPoC_circ() # #============================== # # PLOTEO # #============================== # """ # Gestion de Fechas # """