jroIO_simulator.py~
336 lines
| 12.7 KiB
| text/plain
|
TextLexer
| r1290 | 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) | ||||
