##// END OF EJS Templates
schain
RSS
simulador y pruebas de librerias
simulador y pruebas de librerias
avaldez - - Load All Authors

File last commit:

r1290:a2308e7c2e9e
r1290:a2308e7c2e9e
Show More
jroIO_simulator.py~
336 lines | 12.7 KiB | text/plain | TextLexer
/ schainpy / model / io / jroIO_simulator.py~
History | Annotation | Raw |Copy content |Copy permalink
import numpy,math
import zmq
import tempfile
from io import StringIO
########## 1 Heredamos JRODatareader
from schainpy.model.io.jroIO_base import *
########## 2 Heredamos las propiedades de ProcessingUnit
from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator
########## 3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader
from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader
########## 4 Importaremos el objeto Voltge
from schainpy.model.data.jrodata import Voltage
@MPDecorator
class SimulatorReader(JRODataReader, ProcessingUnit):
incIntFactor = 1
nFFTPoints = 0
FixPP_IncInt = 1
FixRCP_IPP = 1000
FixPP_CohInt = 1
Tau_0 = 250
AcqH0_0 = 70
H0 = AcqH0_0
AcqDH_0 = 1.25
DH0 = AcqDH_0
Bauds = 32
FixRCP_TXA = 40
fAngle = 2.0*math.pi*(1/16)
DC_level = 500
stdev = 8
Num_codes = 2
code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
Dyn_sncode = numpy.array([Num_codes,Bauds])
samples = 200
channels = 1
def __init__(self):
"""
Inicializador de la clases SimulatorReader para
generar datos de voltage simulados.
Input:
dataOut: Objeto de la clase Voltage.
Este Objeto sera utilizado apra almacenar
un perfil de datos cada vez qe se haga psiversho
un requerimiento (getData)
"""
ProcessingUnit.__init__(self)
print(" [ START ] init - Metodo Simulator Reader")
self.isConfig = False
self.basicHeaderObj = BasicHeader(LOCALTIME)
self.systemHeaderObj = SystemHeader()
self.radarControlHeaderObj = RadarControllerHeader()
self.processingHeaderObj = ProcessingHeader()
self.profileIndex = 2**32-1
self.dataOut = Voltage()
#self.server = "simulate"
print(" [ END ] init - Metodo simulator Reader" )
def __hasNotDataInBuffer(self):
if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:
return 1
return 0
def __setNewBlock(self):
if self.flagIsNewFile:
#self.lastUTTime = self.basicHeaderObj.utc
return 1
def readNextBlock(self):
while True:
self.__setNewBlock()
print (" [ START ] readNexBlock")
if not(self.readBlock()):
return 0
self.getBasicHeader()
break
if self.verbose:
print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlock,
self.processingHeaderObj.dataBlocksPerfile,
self.dataOut.datatime.ctime()) )
return 1
def getFirstHeader(self):
self.getBasicHeader()
self.dataOut.processingHeaderObj= self.processingHeaderObj.copy()
self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
def getBasicHeader(self):
self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
self.dataOut.timeZone = self.basicHeaderObj.timeZone
self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
self.dataOut.errorCount = self.basicHeaderObj.errorCount
self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
def reshapeData(self):
if self.nTxs==1:
return
def readBlock(self):
self.init_acquisition()
pulses, num_codes, pulse_size = self.init_pulse()
self.jro_GenerateBlockOfData()
self.profileIndex = 0
self.flagIsNewFile = 0
self.flagIsNewBlock = 1
self.nTotalBlocks += 1
self.nReadBlocks += 1
return 1
def getData(self): ### metodo propio de VoltageReader
if self.flagNoMoreFiles:
self.dataOut.flagNodata= True
self.flagDiscontinuousBlock=0
self.flagIsNewBlock = 0
if self.__hasNotDataInBuffer(): # aqui es verdad
if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header
return 0
self.getFirstHeader() # atributo
self.reshapeData() # nTxx1 =1 return , n
if not self.getByBlock:
self.dataOut.flagDataAsBlock = False
self.dataOut.data = self.datablock[:, self.profileIndex, :]
self.dataOut.profileIndex = self.profileIndex
self.profileIndex += 1
else:
pass
self.getBasicHeader()
self.dataOut.realtime = self.searchFilesOnline
return self.dataOut.data
def set_kwargs(self, **kwargs):
for key, value in kwargs.items():
print(" set_kwargs ",key,value)
setattr(self, key, value)
def setup(self,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=100,
FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,
FixRCP_TXA = 40, fAngle = 2.0*math.pi*(1/16),DC_level= 500, stdev= 8,
Num_codes = None , Dyn_snCode = None, samples=200,channels=1,
**kwargs):
print(" [ START ] - SETUP metodo")
self.set_kwargs(**kwargs)
self.processingHeaderObj.profilesPerBlock = 100
self.incIntFactor = incIntFactor
self.nFFTPoints = nFFTPoints
self.FixPP_IncInt = FixPP_IncInt
self.FixRCP_IPP = FixRCP_IPP
self.FixPP_CohInt = FixPP_CohInt
self.Tau_0 = Tau_0
self.AcqH0_0 = AcqH0_0
self.H0 = AcqH0_0
self.AcqDH_0 = AcqDH_0
self.DH0 = AcqDH_0
self.Bauds = Bauds
self.FixRCP_TXA = FixRCP_TXA
self.fAngle = fAngle
self.DC_level = DC_level
self.stdev = stdev
self.Num_codes = Num_codes
#self.code0 = code0
#self.code1 = code1
self.Dyn_snCode = Dyn_snCode
self.samples = samples
self.channels = channels
print(" [ END ] - SETUP metodo")
return
def run(self,**kwargs): # metodo propio
print(" [ START ] Metodo RUN: ", self.server)
if not(self.isConfig):
self.setup(**kwargs)
self.isConfig = True
import time
time.sleep(3)
#if self.server is None:
self.getData()
#else:
# self.getFromServer()
##################################################################
###### Aqui ingresamos las clases y metodos propios del simulador
##################################################################
#############################################
############## INIT_ACQUISITION##############
#############################################
def init_acquisition(self):
if self.nFFTPoints != 0:
self.incIntfactor = m_nProfilesperBlock/self.nFFTPoints
if (self.FixPP_IncInt > self.incIntfactor):
self.incIntfactor = self.FixPP_IncInt/ self.incIntfactor
elif(self.FixPP_IncInt< self.incIntfactor):
print("False alert...")
ProfilesperBLock = self.processingHeaderObj.profilesPerBlock
self.timeperblock =int(((self.FixRCP_m_fIPP
*m_nProfilesperBlock
*self.FixPP_CohInt
*self.incIntfactor)
/150.0)
*0.9
+0.5)
# para cada canal
prof_gen = m_nProfilesperBlock*FixPP_m_n_CoherentIntegrations
prof_gen = m_nProfilesperBlock
m_nReference = int((Dyn_sfTau_0-Dyn_sfAcqH0_0)/(Dyn_sfAcqDH_0)+0.5)
print(m_nReference)
BaudWidth = int((FixRCP_m_fTXA/Dyn_sfAcqDH_0)/m_nBauds + 0.5 )
print(BaudWidth)
if (BaudWidth==0):
BaudWidth=1
#################################################################
##################### init_pulse
################################################################
def init_pulse(m_nNum_Codes,m_nBauds,BaudWidth,Dyn_snCode):
fAngle = 2.0*math.pi*(1/16)
DC_level = 500
stdev = 8
m_nNum_Codes= m_nNum_Codes
m_nBauds = m_nBauds
BaudWidth = BaudWidth
Dyn_snCode = Dyn_snCode
if m_nBauds:
pulses = list(range(0,m_nNum_Codes))
num_codes = m_nNum_Codes
for i in range(num_codes):
pulse_size = m_nBauds*BaudWidth
pulses[i] = numpy.zeros(pulse_size)
for j in range(m_nBauds):
for k in range(BaudWidth):
pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600)
else:
pulses = list(range(1))
pulse_size = int(FixRCP_m_fTXB/0.15+0.5)
pulses[0] = numpy.ones(pulse_size)
pulses = 600*pulses[0]
return pulses,num_codes,pulse_size
#################################################################
##################### Generate block data
################################################################
# m_nChannels
# prof_gen
# fAngle = 2.0*math.pi*(1/16)
# DC_level = 500
# stdev
# num_codes
#fAngle = 2.0*math.pi*(1/16)
#num_codes = 8
def jro_GenerateBlockOfData(m_nSamples,DC_level,stdev,m_nReference,pulses,num_codes,pulse_size,prof_gen,H0,DH0):
m_nSamples = m_nSamples
DC_level = DC_level
stdev = stdev
m_nR = m_nReference
pulses = pulses
num_codes = num_codes
ps = pulse_size
prof_gen = prof_gen
H0 = H0
DH0 = DH0
fAngle = 2.0*math.pi*(1/16)
# NOISE
Seed_r=random.seed(2)
Noise_r = numpy.random.normal(DC_level,stdev,m_nSamples)
Seed_i=random.seed(3)
Noise_i = numpy.random.normal(DC_level,stdev,m_nSamples)
Noise = numpy.zeros(m_nSamples,dtype=complex)
Noise.real = Noise_r
Noise.imag = Noise_i
Pulso = numpy.zeros(pulse_size,dtype=complex)
#DOPPLER
x = m_nSamples
time_space = (DH0*numpy.linspace(0, x-1,num=x) +H0)
time_vec = time_space*(1.0e-3/150.0)
fd = 10
d_signal = numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
for i in range(m_nChannels):
for k in range(prof_gen):
Pulso.real = pulses[k%num_codes]
Pulso.imag = pulses[k%num_codes]
InBuffer = numpy.zeros(m_nSamples,dtype=complex)
InBuffer[m_nR:m_nR+ps] = Pulso
InBuffer = Noise+ InBuffer
InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps]*(math.cos( fAngle)*5)
InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( fAngle)*5)
InBuffer=InBuffer
#print(InBuffer[:10])
#print(InBuffer.shape)
plot_cts(InBuffer,H0=H0,DH0=DH0)
#wave_fft(x=InBuffer,plot_show=True)
#time.sleep(1)