Modelo matemático de um radiotelescópio super longo

1. Introdução


Um dos primeiros radiotelescópios construídos pela American Grotto Reber em 1937. O radiotelescópio era um espelho de estanho com 9,5 m de diâmetro montado em uma moldura de madeira:



Em 1944, Reber havia compilado o primeiro mapa da distribuição de ondas de rádio espaciais na região da Via Láctea.

O desenvolvimento da radioastronomia envolveu uma série de descobertas: em 1946, foi descoberta a emissão de rádio da constelação Cygnus, em 1951 - radiação extragalática, em 1963 - quasares e em 1965, a radiação de fundo com comprimento de onda de 7,5 cm.

Em 1963, um único radiotelescópio de 300 metros foi construído em Arecibo (Porto Rico). Esta é uma tigela imóvel com um irradiador em movimento, construída em uma fenda natural do terreno.



Os radiotelescópios individuais têm uma pequena resolução angular, determinada pela fórmula:
 T h e t a = f r a c l a m b d a d  
onde  l a m b d a - comprimento de onda d - diâmetro do radiotelescópio.

Obviamente, para melhorar a resolução, é necessário aumentar o diâmetro da antena, o que é fisicamente uma tarefa difícil. Foi possível resolvê-lo com o advento dos interferômetros de rádio.



A frente de uma onda eletromagnética emitida por uma estrela distante perto da Terra pode ser considerada plana. No caso do interferômetro mais simples, constituído por duas antenas, a diferença no caminho dos raios que chegam a essas duas antenas será igual a:
 D e L t um = D c d o t s i n ( t e t um )   ,
onde:  D e l t a - a diferença no caminho dos raios; D - distância entre antenas;  T h e t uma - o ângulo entre a direção de chegada dos raios e o normal para a linha na qual as antenas estão localizadas.

At  T h e t a = 0 as ondas que chegam às duas antenas são somadas na fase. Na antifase, as ondas aparecerão pela primeira vez com:

 Delta= frac lambda2, Theta=arcsin frac lambda2D ,
onde:  lambda - comprimento de onda.

O próximo máximo será em  Delta= lambda, mínimo em  Delta= frac3 lambda2 etc. É obtido um padrão de radiação de múltiplas pétalas (DN), cuja largura do lóbulo principal  lambda<<D é igual a  lambda/D . A largura do lobo principal determina a resolução angular máxima do interferômetro de rádio, é aproximadamente igual à largura do lobo.

A interferometria por rádio de base ultra longa (VLBI) é um tipo de interferometria usada na radioastronomia, na qual os elementos receptores do interferômetro (telescópios) estão localizados não mais próximos do que as distâncias continentais.

O método VLBI permite combinar as observações feitas por vários telescópios e simular um telescópio cujas dimensões são iguais à distância máxima entre os telescópios originais. A resolução angular do VLBI é dezenas de milhares de vezes maior que a resolução dos melhores instrumentos ópticos.

O estado atual das redes VLBI


Hoje, várias redes VLBI estão ouvindo espaço:

  • European –EVN (Rede Europeia VLBI), composta por mais de 20 radiotelescópios;
  • American –VLBA (Very Long Baseline Array), que inclui dez telescópios com um diâmetro de 25 metros cada;
  • Japonês - JVN (Rede japonesa VLBI) consiste em dez antenas localizadas no Japão, incluindo quatro antenas astrométricas (projeto VERA - VLBI Exploration of Radio Astrometry);
  • Australiano - LBA (Long Baseline Array);
  • Chinês - CVN (rede chinesa VLBI), composto por quatro antenas;
  • Coreia do Sul - KVN (Korean VLBI Network), que inclui três radiotelescópios de 21 metros;
  • O russo - baseado no complexo permanente de rádio interferometria - "Kvazar-KVO" com radiotelescópios de diâmetro de 32 m, equipado com crioradiômetros altamente sensíveis no comprimento de onda de 1,35 cm a 21 cm. O comprimento das bases - o diâmetro efetivo do "espelho" sintetizado - é de cerca de 4400 km na direção leste-oeste (veja a figura).



No complexo VLBI "Kvazar-KVO", os padrões de hidrogênio são usados ​​como fonte de frequência de referência para todas as transformações de frequência, que usam a transição entre os níveis da estrutura hiperfina do estado fundamental de um átomo de hidrogênio com uma frequência de 1420,405 MHz, correspondendo a 21 cm em radioastronomia.

Tarefas resolvidas por meio do VLBI


  • Astrofísica A construção de imagens de rádio de objetos do espaço natural (quasares e outros objetos) é realizada com uma resolução de décimos e centésimos de mas (milissegundos de arco).
  • Estudos astrométricos. Construção de sistemas de tempo de coordenadas. Os objetos de pesquisa são fontes de rádio de tamanhos angulares extremamente pequenos, incluindo fontes de rádio quasistelares e núcleos de galáxias de rádio, que, devido à sua grande distância, são objetos quase ideais para criar uma rede de objetos estacionários de apoio.
  • Pesquisa sobre mecânica celeste e a dinâmica do sistema solar, navegação espacial. A instalação de um farol nas superfícies dos planetas e o rastreamento dos faróis das estações automáticas interplanetárias possibilita o uso do método VLBI para estudar parâmetros como o movimento orbital do planeta, a direção dos eixos de rotação e sua precessão, a dinâmica do sistema planeta-satélite. Para a Lua, o problema muito importante de determinar a libração física e determinar a dinâmica dos sistemas Lua-Terra também está sendo resolvido.

Navegação no espaço usando VLBI


  • Monitorando os movimentos dos astronautas na superfície lunar em 1971. Eles se moveram com a ajuda do rover lunar Rover. A precisão de determinar sua posição em relação ao módulo lunar atingiu 20 cm e dependia principalmente da libração da lua (Libration - oscilações periódicas pendulares do tipo pêndulo da lua em relação ao seu centro de massa);
  • Suporte de navegação para a entrega e descarga de sondas de aeróstato de veículos voadores na atmosfera de Vênus (projeto VEGA). A distância para Vênus é superior a 100 milhões de km, a potência do transmissor é de apenas 1 Watt. Os lançamentos do VEGA-1/2 ocorreram em dezembro de 1984. Os balões foram lançados na atmosfera de Vênus em 11 e 15 de junho de 1985. A observação foi realizada por 46 horas.

Diagrama estrutural de uma rede VLBI simplificada


Com base em uma rede VLBI real, usando o software Python, modelamos um sistema VLBI simplificado na forma de modelos separados para cada unidade ou processo. Este conjunto de modelos será suficiente para observar os processos básicos. O diagrama estrutural de uma rede VLBI simplificada é apresentado na figura:



O sistema inclui os seguintes componentes:

  • sinal modulado em fase útil do gerador (HS);
  • geradores de ruído (GSh1, GSh2). O sistema possui dois radiotelescópios (antenas receptoras) que possuem seu próprio ruído. Além disso, existem ruídos da atmosfera e outras fontes naturais e artificiais de emissão de rádio;
  • uma unidade de atraso de tempo simulando um atraso de variação linear devido à rotação da Terra;
  • deslocador de fase simulando o efeito Doppler;
  • sistema de conversão de sinal (SPS), consistindo em um oscilador local, para transferir o sinal para baixo em frequência, e um filtro passa-banda;
  • Correlacionador de FX.

O circuito correlacionador é mostrado na figura a seguir:



O circuito correlacionador fornecido, que inclui os seguintes blocos:

  • transformada rápida direta de Fourier (PBPF) e transformada inversa de Fourier (OBPF);
  • compensar o atraso introduzido anteriormente;
  • efeito Doppler compensador;
  • multiplicação complexa de dois espectros;
  • somando implementações acumuladas.

Modelo de Sinal de Navegação


Os mais convenientes para medições de VLBI são os sinais de navegação da espaçonave de sistemas de navegação por satélite, como GPS e GLONASS. Um número de requisitos é imposto aos sinais de navegação:

  • permite definir bem pseudo-faixa;
  • transmitir informações sobre a posição do sistema de navegação;
  • distinguir-se dos sinais de outros NS;
  • Não interfira com outros sistemas de rádio;
  • não requer equipamentos complexos para receber e transmitir.

Em uma extensão suficiente, eles estão satisfeitos com um sinal com modulação de fase binária (duas posições) - BPSK (tecla de mudança de fase binária), que na literatura russa é denominada FM-2. Essa modulação altera a fase da oscilação da portadora por π, que pode ser representada como:

S(t)=A cdotG(t) cdotcos(2 pipés),é

onde G (t) é a função de modulação.

Para implementar a modulação de fase, dois geradores podem ser usados, cada um dos quais forma a mesma frequência, mas com uma fase inicial diferente. A função de modulação permite expandir o espectro do sinal e medir com precisão a pseudo-faixa (a distância entre o satélite e o receptor, calculada pelo tempo de propagação do sinal sem correção para a diferença entre o relógio do satélite e o receptor).

Aqui está uma lista explicando os princípios básicos do BPSK:

Listagem
from scipy import* from pylab import* import numpy as np import scaleogram as scg f = 2; #f  fs = 100; #    t = arange(0,1,1/fs) #    1 / fs #      BPSK p1 = 0; p2 = pi; #     N =12#     #   bit_stream=np.random.random_integers(0, 1, N+1) #   time =[]; digital_signal =[]; PSK =[]; carrier_signal =[]; #  for ii in arange(1,N+1,1): #   if bit_stream [ii] == 0: bit = [0 for w in arange(1,len(t)+1,1)]; else: bit = [1 for w in arange(1,len(t)+1,1)]; digital_signal=hstack([digital_signal,bit ]) #  BPSK if bit_stream [ii] == 0: bit = sin (2*pi*f*t+p1); else: bit = sin (2*pi*f*t+p2); PSK=hstack([PSK,bit]) #   carrier = sin (2*f*t*pi); carrier_signal = hstack([carrier_signal,carrier]) ; time = hstack([time ,t]); t=t+1 suptitle("    (BPSK)") subplot (3,1,1); plot(time,digital_signal,'r'); grid(); subplot (3,1,2); plot (time,PSK); grid(); subplot (3,1,3); plot (time,carrier_signal); grid() show() figure() title("     (BPSK)") n = len(PSK) k = np.arange(n) T = n/fs frq = k/T frq = frq[np.arange(int(n/2))] Y = fft(PSK)/n Y = Y[range(n //2)] / max(Y[range(n // 2)]) plot(frq[75:150], abs(Y)[75:150], 'b')#    grid() #   PSK  scales = scg.periods2scales( arange(1, 40)) ax2 = scg.cws(PSK, scales=scales, figsize=(6.9,2.9)); show() 


Temos:







Modelo de Origem


O sinal harmônico de navegação modulado em fase de um satélite ou nave espacial tem a forma:

x=a(2 pifct+ sumsncos(2 pifnt)),

onde está a frequência portadora fc=$8, GHz

O sinal possui vários parâmetros controlados: a amplitude da enésima oscilação moduladora
sn, sua frequência fc e a amplitude da oscilação portadora a.

Para obter uma função de correlação na qual seus lobos laterais são suprimidos o máximo possível e o pico de correlação mais estreito for atingido, variaremos os valores de frequência usando os valores de 2, 4, 8 e 16 MHz e o índice de modulação no intervalo de 0 a 2π em incrementos de π. Deixe-me fornecer uma lista do programa para essa pesquisa de parâmetros de uma função de fase modulada para o resultado final:

Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7 #   N = 2**18 #-  delay =4 # t1 =linspace(0, T, N) t2 = linspace(0 + delay, T + delay, N) fs = (N - 1)/T #  ax = 1e-3 bx = 2e-6 ay = 2e-3 by = 3e-6 aex = 1e-3 + 30e-9 bex = 2e-6 + 10e-12 aey = 2e-3 + 30e-9 bey = 3e-6 + 10e-12 taux = ax + bx*t1 tauy = ay + by*t2 tauex = aex + bex*t1 tauey = aey + bey*t2 #  # print(" :") No1 = No2 = 0 fc = 8.4e9 #  #   A1 = 2*pi A2 = 0 A3 =2*pi A4 = 4*pi #   fm1 = 2e6 fm2 = 4e6 fm3 = 8e6 fm4 = 16e6 f = 20e6 #     ff = fc - f #   fco = 16e6 #     def korel(x,y): #  def phase_shifter1(x, t, tau, b): L = linspace(0, N, N) fexp = ifftshift((L) - ceil((N - 1)/2))/T s = ((ifft(fft(x)*exp(-1j*2*pi*tau*fexp))).real)*exp(1j*2*pi*b*fc*t) return s #   def phase_shifter2(x, t, tau, b): L = linspace(0,N,N) fexp = ifftshift((L) - ceil((N - 1)/2))/T s =((ifft(fft(x)*exp(1j*2*pi*tau*fexp))).real)*exp(-1j*2*pi*b*fc*t) return s # def heterodyning(x, t): return x*exp(-1j*2*pi*ff*t) # def filt(S): p = signal.convolve(S,h) y = p[int((n - 1)/2) : int(N+(n - 1)/2)] return y def corr(y1, y2): Y1 = fft(y1) Y2 = fft(y2) # Z = Y1*Y2.conjugate() # z = ifft(Z)/N return sqrt(z.real**2 + z.imag**2) #   def graf(c, t): c1=c[int(N/2):N] c2=c[0:int(N/2)] C = concatenate((c1, c2)) xlabel(',') ylabel('') title('   ') grid(True) plot(t*1e9 - 250, C, 'b',label="    \n    ") legend(loc='best') show() noise1 = random.uniform(-No1, No1, size = N) #   noise2 =noise1 #   x1 = heterodyning(phase_shifter1(x + noise1, t1, taux, bx), t1) y1 = heterodyning(phase_shifter1(y + noise2, t2, tauy, by), t2) n = 100001 #  #  h = signal.firwin(n, cutoff = [((f - fco) / (fs * 0.5)), ((f + fco) / (fs *0.5))], pass_zero = False) x2 = filt(x1) y2 = filt(y1) X2 = phase_shifter2(x2, t1, tauex, bex) Y2 = phase_shifter2(y2, t2, tauey, bey) Corr = corr(X2, Y2) graf(Corr, t1) #     ##for A1 in [pi/4,pi/2,pi]: ## x = cos(2*pi*fc*t1 + A1*cos(2*pi*fm1*t1)) ## y = cos(2*pi*fc*t2 + A1*cos(2*pi*fm1*t2)) ## korel(x,y) ##for fm in [ fm2,fm3,fm4]: ## A1=2*pi ## x = cos(2*pi*fc*t1 + A1*cos(2*pi*fm*t1)) ## y = cos(2*pi*fc*t2 + A1*cos(2*pi*fm*t2)) ## korel(x,y) #     ##for fm2 in [ fm1, fm2,fm3,fm4]: ## A1=2*pi ## A2=2*pi ## fm1=2e6 ## x = cos(2*pi*fc*t1 + A1*cos(2*pi*fm1*t1)+A2*np.cos(2*pi*fm2*t1)) ## y =cos(2*pi*fc*t2 + A1*cos(2*pi*fm1*t2)+A2*np.cos(2*pi*fm2*t2)) ## korel(x,y) x = cos(2*pi*fc*t1 + A1*cos(2*pi*fm1*t1)+A2*np.cos(2*pi*fm2*t1)+A3*cos(2*pi*fm3*t1)+A4*cos(2*pi*fm4*t1)) y = cos(2*pi*fc*t2 + A1*cos(2*pi*fm1*t2) +A2*cos(2*pi*fm2*t2) +A3*cos(2*pi*fm3*t2)+A4*cos(2*pi*fm4*t2)) korel(x,y) 


Temos:



A função resultante tem a forma:

x=cos(2 pifct+2 picos(2 pi106t)+2 picos(2 pi108t)+4 picos(2 pi1016t)).(1)

Além disso, esta função será usada para simular o VLBI.

Modelo de um gerador de ruído simulando interferência recebida junto com um sinal do espaço e da atmosfera da Terra


A função (1) do sinal de navegação com modulação de fase pode ser aplicada a ambos os canais do interferômetro de rádio, mas é necessário levar em consideração o atraso do sinal no segundo canal e o ruído nos dois canais, conforme mostrado na lista a seguir:

Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7 #   N = 2**16 #-  delay =1e-7 # t1 =linspace(0, T, N) t2 = linspace(0 + delay, T + delay, N) fc = 8.4e9 #  # print(" :") No1 = No2 = 0.5 noise1 = random.uniform(-No1, No1, size = N) #   noise2 =random.uniform(-No1, No1, size = N) #   x = cos(2*pi*fc*t1 + 2*pi*cos(2*pi*2*10**6*t1)+2*pi*cos(2*pi*8*10**6*t1)+4*pi*cos(2*pi*16*10**6*t1)) y = cos(2*pi*fc*t2 + 2*pi*cos(2*pi*2*10**6*t2)+2*pi*cos(2*pi*8*10**6*t2)+4*pi*cos(2*pi*16*10**6*t2)) title("    \n    ") plot(t1,x,label="  ") plot(t2,y,label="  c ") x=noise1;y=noise2 plot(t1,x,label="  ") plot(t2,y,label="  ") legend(loc='best') grid(True) figure() noise1_2 = np.random.uniform(-No1, No1, size = N) #     sko=np.std(noise1_2) mo= np.mean(noise1_2) sko=round(sko,2) mo=round(mo,2) title("  . :%s,:%s"%(sko,mo)) ylabel('   ') xlabel('  ') hist(noise1_2,bins='auto') show() 


Temos:



O atraso de atraso = 1e-7 é definido para demonstração, na realidade depende da base e pode atingir quatro ou mais unidades.



Ruídos cósmicos e próximos à Terra podem ser distribuídos de acordo com uma lei diferente do uniforme fornecido, o que requer estudos especiais.

Modelando o efeito Doppler


Devido ao fato de a Terra ter uma forma arredondada e girar em torno de seu eixo, os sinais do espaço chegam às antenas com atrasos diferentes. Por esse motivo, é necessário mudar os sinais no tempo e levar em consideração a frequência do Doppler. Consideraremos aproximadamente que o atraso varia de acordo com uma lei linear:

 taux(t)=ax+bxt,(2)

onde ax=1..3 cdot103 ms e bx=1..3 cdot106 ms A fase Doppler é encontrada como uma derivada do atraso:

fdx= fracd tau(t)dt=bx,(3)

O sinal recebido deve se parecer com:

 hatx=x(t taux)ej2 pifdxt,
onde x (t) é o sinal irradiado da nave espacial.

Uma demonstração do efeito Doppler é mostrada na lista a seguir:

Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7#   N = 2**16 #-  t1 =linspace(0, T, N) delay =4 # t2 = linspace(0 + delay, T + delay, N) fc = 8.4e9#  def phase_shifter1(x, t, tau, b): L = linspace(0, N, N) fexp = ifftshift((L) - ceil((N - 1)/2))/T s = ((ifft(fft(x)*exp(-1j*2*pi*tau*fexp))).real)*exp(1j*2*pi*b*fc*t) return s.real figure() title("    ") ax = 3e-3 bx = 3e-6 taux = ax + bx*t1 x = cos(2*pi*fc*t1 + 2*pi*cos(2*pi*2*10**6*t1)+2*pi*cos(2*pi*8*10**6*t1)+4*pi*cos(2*pi*16*10**6*t1)) sx=phase_shifter1(x, t1, taux, bx ) plot(t1[0:150],x[0:150],label="      ") plot(t1[0:150],sx[0:150],label="      ") grid(True) legend(loc='best') figure() title("    ") ay = 2e-3 by = 3e-6 tauy = ay + by*t2 y = cos(2*pi*fc*t2 + 2*pi*cos(2*pi*2*10**6*t2)+2*pi*cos(2*pi*8*10**6*t2)+4*pi*cos(2*pi*16*10**6*t2)) sy= phase_shifter1(y, t2, tauy, by) plot(t2[0:150],y[0:150],label="      ") plot(t2[0:150],sy[0:150],label="      ") grid(True) legend(loc='best') show() 


Temos:





Modelagem da Compensação Doppler


Obviamente, as alterações feitas no sinal devem ser compensadas. Para esse fim, o sistema contém suporte para a fase de atraso e Doppler. Depois que o sinal passa pelo sistema de registro, é introduzido um atraso:

 tauex(t)=ax+bext,(4)

Considerará que o atraso é calculado com uma certa precisão, de modo que  left|aexax right|<30 ns  left|bexbx right|<10 ns, ou seja, Será um pouco diferente do que ele fez com os atrasos anteriores. É claro que o atraso é introduzido com o sinal oposto ao introduzido anteriormente.

O sinal recebido será parecido com:

 hatx= tilx(t+ tauex)ej2 pifdet.(5)

A compensação do efeito Doppler é mostrada na lista a seguir:

Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7#   N = 2**16 #-  t1 =linspace(0, T, N) delay =4 # t2 = linspace(0 + delay, T + delay, N) fc = 8.4e9#  def phase_shifter1(x, t, tau, b): L = linspace(0, N, N) fexp = ifftshift((L) - ceil((N - 1)/2))/T s = ((ifft(fft(x)*exp(-1j*2*pi*tau*fexp))).real)*exp(1j*2*pi*b*fc*t) return s.real ax = 3e-3 bx = 3e-6 taux = ax + bx*t1 x = cos(2*pi*fc*t1 + 2*pi*cos(2*pi*2*10**6*t1)+2*pi*cos(2*pi*8*10**6*t1)+4*pi*cos(2*pi*16*10**6*t1)) sx=phase_shifter1(x, t1, taux, bx ) ay = 2e-3 by = 3e-6 tauy = ay + by*t2 y = cos(2*pi*fc*t2 + 2*pi*cos(2*pi*2*10**6*t2)+2*pi*cos(2*pi*8*10**6*t2)+4*pi*cos(2*pi*16*10**6*t2)) sy= phase_shifter1(y, t2, tauy, by) def phase_shifter2(x, t, tau, b): L = linspace(0,N,N) fexp = ifftshift((L) - ceil((N - 1)/2))/T s =((ifft(fft(x)*exp(1j*2*pi*tau*fexp))).real)*exp(-1j*2*pi*b*fc*t) return s.real figure() title("     ") aex = 1e-3 + 30e-9 bex = 2e-6 + 10e-12 tauex = aex + bex*t1 x1 = phase_shifter2(sx, t1, tauex, bex) plot(t1[0:150],x1[0:150],label="      ") grid(True) legend(loc='best') figure() title("     ") aey = 2e-3 + 30e-9 bey = 3e-6 + 10e-12 tauey = aey + bey*t2 y2 = phase_shifter2(sy, t2, tauey, bey) plot(t2[0:150],y2[0:150],label="      ") grid(True) legend(loc='best') show() 


Temos:





Simulação de heteródino de sinal


Depois que o sinal entra no sistema de registro, ocorre uma conversão de frequência, também chamada de heterodinâmica. Esta é uma transformação não linear em que dos sinais de duas frequências diferentes f1 e f2 o sinal de frequência de diferença é destacado - f= esquerda|f1f2 direita. A frequência do sinal do oscilador local será igual à diferença entre a frequência do sinal investigado e a frequência que você deseja obter após a transferência. A heterodinâmica é realizada usando um gerador auxiliar de oscilações harmônicas - um oscilador local e um elemento não linear. Matematicamente, heterodinâmica é a multiplicação de um sinal por um expoente:

xg= hatxej2 pifgt,(6)
onde fg - sinal do oscilador local.

Programa para heterodinâmica:

Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7 #   N = 2**16 #-  t1 =linspace(0, T, N) fs = (N - 1)/T #  fc = 8.4e9 #  f = 20e6 #     ff = fc - f #   def spectrum_wavelet(y,a,b,c,e,st):#   n = len(y)#   k = arange(n) T = n / a frq = k / T #    frq = frq[np.arange(int(n/2))] #    Y = fft(y)/ n # FFT    Y = Y[arange(int(n/2))]/max(Y[arange(int(n/2))]) plot(frq[b:c],abs(Y)[b:c],e,label=st) #   xlabel('Freq (Hz)') ylabel('|Y(freq)|') legend(loc='best') grid(True) x = cos(2*pi*fc*t1 + 2*pi*cos(2*pi*2*10**6*t1)+2*pi*cos(2*pi*8*10**6*t1)+4*pi*cos(2*pi*16*10**6*t1)) a=fs;b=0;c=20000;e='g'; st='     ' spectrum_wavelet(x,a,b,c,e,st) show() 


Temos:





Modelagem de filtragem de sinal após heterodinâmica


Após a heterodinâmica, o sinal entra no filtro passa-banda. Filtro de banda passante (PP) fpass=32 MHz A resposta de impulso do filtro é calculada pelo método da janela usando a função de biblioteca signal.firwin. Para obter um sinal na saída do filtro, é realizada a convolução do filtro e o sinal no domínio do tempo. A convolução integral para o nosso caso assume a forma:

 checkx(t)= int+ infty inftyxg(t)h(tt)dt,(7)

onde h (t) é a resposta ao impulso do filtro.

A convolução é encontrada usando a função de biblioteca signal.convolve. O sinal registrado, levando em consideração a heterodinâmica e a filtragem, é apresentado na forma de uma fórmula

 checkx(t)=( hatx(t)ej2 pifgt)h

onde a convolução é indicada por *.

Programa para modelagem de filtração:

Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7 #   N = 2**16 #-  t1 =linspace(0, T, N) fs = (N - 1)/T #  fc = 8.4e9 #  f = 20e6 #     ff = fc - f #   def spectrum_wavelet(y,a,b,c,e,st):#   n = len(y)#   k = arange(n) T = n / a frq = k / T #    frq = frq[np.arange(int(n/2))] #    Y = fft(y)/ n # FFT    Y = Y[arange(int(n/2))]/max(Y[arange(int(n/2))]) plot(frq[b:c],abs(Y)[b:c],e,label=st) #   xlabel('Freq (Hz)') ylabel('|Y(freq)|') legend(loc='best') grid(True) x = cos(2*pi*fc*t1 + 2*pi*cos(2*pi*2*10**6*t1)+2*pi*cos(2*pi*8*10**6*t1)+4*pi*cos(2*pi*16*10**6*t1)) def heterodyning(x, t): return x*exp(-1j*2*pi*ff*t).real z=heterodyning(x, t1) fco = 16e6 #     n = 100001 #  h = signal.firwin(n, cutoff = [((f - fco) / (fs * 0.5)), ((f + fco) / (fs *0.5))], pass_zero = False) def filt(S): p = signal.convolve(S,h) y = p[int((n - 1)/2) : int(N+(n - 1)/2)] return y q=filt(z) a=fs;b=0;c=850;e='g'; st='    ' spectrum_wavelet(q,a,b,c,e,st) show() 


Temos:



Os conversores de sinais digitais para VLBI usam principalmente filtros com resposta de impulso finito (FIR), pois possuem várias vantagens em comparação com filtros com resposta de impulso infinito (IIR):

  1. Os filtros FIR podem ter uma resposta de fase estritamente linear no caso de simetria da resposta ao impulso (IM). Isso significa que, usando esse filtro, é possível evitar distorções de fase, o que é especialmente importante para a interferometria de rádio. Os filtros com uma resposta de impulso infinito (IIR) não têm as propriedades de simetria deles e não podem ter uma resposta de fase linear.
  2. Os filtros FIR não são recursivos, o que significa que eles são sempre estáveis. A estabilidade dos filtros IIR nem sempre pode ser garantida.
  3. As consequências práticas do uso de um número limitado de bits para implementar filtros são significativamente menos significativas para os filtros FIR.

Na lista acima, o modelo do filtro passa-banda FIR é implementado usando o método window, a ordem do filtro foi selecionada para que o formato da resposta de frequência do filtro fosse quase retangular. O número de coeficientes do filtro simulado é n = 100001, ou seja, a ordem do filtro é P = 100000.

Programa para construir a resposta de frequência e resposta de fase do filtro FIR obtido:

Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7 #   N = 2**16 #-  t1 =linspace(0, T, N) fs = (N - 1)/T #  fc = 8.4e9 #  f = 20e6 #     ff = fc - f #   fco = 16e6 #     n = 100001 #  h = signal.firwin(n, cutoff = [((f - fco) / (fs * 0.5)), ((f + fco) / (fs *0.5))], pass_zero = False) #  def AFC(A, n, f, deltf, min, max): plot((fftfreq (n, 1./fs)/1e9), 10*log10(abs(fft(A))), 'k') axvline((f - fco)/1e9, color = 'red', label='  ') axvline((f + fco)/1e9, color = 'red') axhline(-3, color='green', linestyle='dashdot') text(8.381, -3, repr(round(-3, 9))) xlabel(', ') ylabel(' , ') title('') grid(True) axis([(f - deltf)/1e9, (f + deltf)/1e9, min, max]) grid(True) show() #  def PFC(A, n, f, deltf, min, max): plot(fftfreq(n, 1./fs)/1e9, np.unwrap(np.angle(fft(A))), 'k') axvline((f - fco)/1e9, color='red', label='  ') axvline((f + fco)/1e9, color='red') xlabel(', ') ylabel(',') title('') axis([(f - deltf)/1e9, (f + deltf)/1e9, min, max]) #  grid(True) legend(loc='best') show() AFC(h, n, f, 20e6, -30, 1) PFC(h, n, f, 20e6, -112, 0) 


Temos:





Modelo de correlação FX


A seguir, cada sinal passa por uma rápida transformação de Fourier (FFT). A FFT é implementada usando a função de biblioteca fft do scipy.fftpack. Os espectros resultantes são conjugados complexos multiplicados:

S(j omega)=S1(j omega)S2(j omega)=(a1+jb1)(a2jb2)=a1a2+b1b2+j(b1a2a1b2)

A última ação é o inverso da FFT. Como a amplitude da função de correlação é de interesse, o sinal resultante deve ser convertido pela fórmula:

A= sqrtre2+im2

O programa para a função de correlação sem levar em conta distorções do sistema de registro:

Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7#   N = 2**16 #-  t1 =linspace(0, T, N) delay =4 # t2 = linspace(0 + delay, T + delay, N) fc = 8.4e9#  def corr(y1, y2): Y1 = fft(y1) Y2 = fft(y2) # Z = Y1*Y2.conjugate() # z = ifft(Z)/N q=sqrt(z.real**2 + z.imag**2) c1=q[int(N/2):N] c2=q[0:int(N/2)] C = concatenate((c1, c2)) xlabel(',') ylabel('') title('  ') grid(True) plot(t1*1e9 - 250, C, 'b') show() x= cos(2*pi*fc*t1 + 2*pi*cos(2*pi*2*10**6*t1)+2*pi*cos(2*pi*8*10**6*t1)+4*pi*cos(2*pi*16*10**6*t1)) y = cos(2*pi*fc*t2 + 2*pi*cos(2*pi*2*10**6*t2)+2*pi*cos(2*pi*8*10**6*t2)+4*pi*cos(2*pi*16*10**6*t2)) corr(x, y) 


Temos:



Lista completa do modelo de computador do VLBI:


Listagem
 # coding: utf-8 from pylab import* from scipy import signal from scipy import * T = 5e-7 #   N = 2**18 #-  delay =4 # t1 =linspace(0, T, N) t2 = linspace(0 + delay, T + delay, N) fs = (N - 1)/T #  ax = 1e-3 bx = 2e-6 ay = 2e-3 by = 3e-6 aex = 1e-3 + 30e-9 bex = 2e-6 + 10e-12 aey = 2e-3 + 30e-9 bey = 3e-6 + 10e-12 taux = ax + bx*t1 tauy = ay + by*t2 tauex = aex + bex*t1 tauey = aey + bey*t2 #  # print(" :") No1 = No2 = 0 #    # print(" :") fc = 8.4e9 #  f = 20e6 #     ff = fc - f #   fco = 16e6 #     #  def phase_shifter1(x, t, tau, b): L = linspace(0, N, N) fexp = ifftshift((L) - ceil((N - 1)/2))/T s = ((ifft(fft(x)*exp(-1j*2*pi*tau*fexp))).real)*exp(1j*2*pi*b*fc*t) return s #   def phase_shifter2(x, t, tau, b): L = linspace(0,N,N) fexp = ifftshift((L) - ceil((N - 1)/2))/T s =((ifft(fft(x)*exp(1j*2*pi*tau*fexp))).real)*exp(-1j*2*pi*b*fc*t) return s # def heterodyning(x, t): return x*exp(-1j*2*pi*ff*t) # def filt(S): p = signal.convolve(S,h) y = p[int((n - 1)/2) : int(N+(n - 1)/2)] return y def spectrum_wavelet(y,a,b,c,e,st):#   n = len(y)#   k = arange(n) T = n / a frq = k / T #    frq = frq[np.arange(int(n/2))] #    Y = fft(y)/ n # FFT    Y = Y[arange(int(n/2))]/max(Y[arange(int(n/2))]) plot(frq[b:c],abs(Y)[b:c],e,label=st) #   xlabel('Freq (Hz)') ylabel('|Y(freq)|') legend(loc='best') grid(True) def corr(y1, y2): Y1 = fft(y1) Y2 = fft(y2) # Z = Y1*Y2.conjugate() # z = ifft(Z)/N return sqrt(z.real**2 + z.imag**2) #   def graf(c, t): c1=c[int(N/2):N] c2=c[0:int(N/2)] C = concatenate((c1, c2)) xlabel(', ') ylabel('') title('  ') grid(True) plot(t*1e9 - 250, C, 'b') show() noise1 = random.uniform(-No1, No1, size = N) #   noise2 =random.uniform(-No1, No1, size = N) #   def signal_0(): x = cos(2*pi*fc*t1 + 2*pi*cos(2*pi*2*10**6*t1)+2*pi*cos(2*pi*8*10**6*t1)+4*pi*cos(2*pi*16*10**6*t1)) y = cos(2*pi*fc*t2 + 2*pi*cos(2*pi*2*10**6*t2)+2*pi*cos(2*pi*8*10**6*t2)+4*pi*cos(2*pi*16*10**6*t2)) return x,y title(" +  +   ") x,y= signal_0() x1 = heterodyning(phase_shifter1(x + noise1, t1, taux, bx), t1) plot(x1.real,label="  ") y1 = heterodyning(phase_shifter1(y + noise2, t2, tauy, by), t2) plot(y1.real,label=" ") grid(True) legend(loc='best') show() n = 100001 #  #  h = signal.firwin(n, cutoff = [((f - fco) / (fs * 0.5)), ((f + fco) / (fs *0.5))], pass_zero = False) title("- -    ") x2 = filt(x1) plot(x2.real,label="  ") y2 = filt(y1) plot(y2.real,label="  ") grid(True) legend(loc='best') show() plt.title("      \n   ") a=fs;b=400;c=4400;e='r' st="    " spectrum_wavelet(x,a,b,c,e,st) a=fs;b=20;c=850;e='g' st="    " spectrum_wavelet(x1,a,b,c,e,st) show() X2 = phase_shifter2(x2, t1, tauex, bex) Y2 = phase_shifter2(y2, t2, tauey, bey) Corr = corr(X2, Y2) graf(Corr, t1) 


Temos:





Conclusões


  1. É apresentada uma breve história do desenvolvimento da radioastronomia.
  2. O estado atual das redes VLBI é analisado.
  3. Os problemas resolvidos por meio de redes VLBI são considerados.
  4. As ferramentas Python construíram um modelo de sinais de navegação com modulação de fase binária (duas posições) - BPSK (tecla de mudança de fase binária). O modelo usa análise wavelet de modulação de fase.
  5. Foi obtido um modelo de fontes de sinal, que permite determinar os parâmetros de modulação que fornecem a função de correlação ideal de acordo com o critério para suprimir os lobos laterais e a amplitude máxima do lobo central.
  6. É obtido um modelo de rede VLBI simplificada, levando em consideração o ruído e o efeito Doppler. Os recursos de filtragem usando um filtro com uma resposta de impulso finito são considerados.
  7. Após um breve resumo da teoria, todos os modelos estão equipados com programas de demonstração que permitem rastrear a influência dos parâmetros do modelo.

Source: https://habr.com/ru/post/pt458252/


All Articles