##// END OF EJS Templates
schain
RSS
simulador y pruebas de librerias
avaldez -
r1290:a2308e7c2e9e
parent child
Show More
Side by Side Unified
Context file:
r1290:a2308e7c2e9e Loading diff...:
Show file before | Show file after | Hide comments
@@ -0,0 +1,485
1 import numpy,math,random,time
2 import zmq
3 import tempfile
4 from io import StringIO
5 ########## 1 Heredamos JRODatareader
6 from schainpy.model.io.jroIO_base import *
7 ########## 2 Heredamos las propiedades de ProcessingUnit
8 from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator
9 ########## 3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader
10 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader
11 ########## 4 Importaremos el objeto Voltge
12 from schainpy.model.data.jrodata import Voltage
13
14 @MPDecorator
15 class SimulatorReader(JRODataReader, ProcessingUnit):
16 incIntFactor = 1
17 nFFTPoints = 0
18 FixPP_IncInt = 1
19 FixRCP_IPP = 1000
20 FixPP_CohInt = 1
21 Tau_0 = 250
22 AcqH0_0 = 70
23 H0 = AcqH0_0
24 AcqDH_0 = 1.25
25 DH0 = AcqDH_0
26 Bauds = 32
27 BaudWidth = None
28 FixRCP_TXA = 40
29 FixRCP_TXB = 70
30 fAngle = 2.0*math.pi*(1/16)
31 DC_level = 500
32 stdev = 8
33 Num_Codes = 2
34 #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])
35 #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])
36 #Dyn_snCode = numpy.array([Num_Codes,Bauds])
37 Dyn_snCode = None
38 Samples = 200
39 channels = 5
40 pulses = None
41 Reference = None
42 pulse_size = None
43 prof_gen = None
44 Fdoppler = 100
45 Hdoppler = 36
46 def __init__(self):
47 """
48 Inicializador de la clases SimulatorReader para
49 generar datos de voltage simulados.
50 Input:
51 dataOut: Objeto de la clase Voltage.
52 Este Objeto sera utilizado apra almacenar
53 un perfil de datos cada vez qe se haga psiversho
54 un requerimiento (getData)
55 """
56 ProcessingUnit.__init__(self)
57 print(" [ START ] init - Metodo Simulator Reader")
58
59 self.isConfig = False
60 self.basicHeaderObj = BasicHeader(LOCALTIME)
61 self.systemHeaderObj = SystemHeader()
62 self.radarControllerHeaderObj = RadarControllerHeader()
63 self.processingHeaderObj = ProcessingHeader()
64 self.profileIndex = 2**32-1
65 self.dataOut = Voltage()
66 #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])
67 code0 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])
68 #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])
69 code1 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])
70 #self.Dyn_snCode = numpy.array([code0,code1])
71 self.Dyn_snCode = None
72 print(" [ END ] init - Metodo simulator Reader" )
73
74
75 def __hasNotDataInBuffer(self):
76
77 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:
78 if self.nReadBlocks>0:
79 tmp = self.dataOut.utctime
80 tmp_utc = int(self.dataOut.utctime)
81 tmp_milisecond = int((tmp-tmp_utc)*1000)
82 self.basicHeaderObj.utc = tmp_utc
83 self.basicHeaderObj.miliSecond= tmp_milisecond
84 return 1
85 return 0
86
87
88 def setNextFile(self):
89 """Set the next file to be readed open it and parse de file header"""
90
91 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
92 print('------------------- [Opening file] ------------------------------')
93 self.nReadBlocks = 0
94
95 def __setNewBlock(self):
96
97 self.setNextFile()
98 if self.flagIsNewFile:
99 return 1
100
101 def readNextBlock(self):
102 while True:
103 self.__setNewBlock()
104 if not(self.readBlock()):
105 return 0
106 self.getBasicHeader()
107 break
108 if self.verbose:
109 print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
110 self.processingHeaderObj.dataBlocksPerFile,
111 self.dataOut.datatime.ctime()) )
112 return 1
113
114 def getFirstHeader(self):
115 self.getBasicHeader()
116 self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
117 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
118 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
119 #ADD NEW
120 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
121 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
122 self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
123 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
124 # asumo q la data no esta decodificada
125 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode
126 # asumo q la data no esta sin flip
127 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip
128 self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
129
130 def getBasicHeader(self):
131
132 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
133 1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
134
135 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
136
137 self.dataOut.timeZone = self.basicHeaderObj.timeZone
138
139 self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
140
141 self.dataOut.errorCount = self.basicHeaderObj.errorCount
142
143 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
144
145 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
146
147 def reshapeData(self):
148 if self.nTxs==1:
149 return
150
151 def readBlock(self):
152
153 self.jro_GenerateBlockOfData(Samples= self.samples,DC_level=self.DC_level,
154 stdev=self.stdev,Reference= self.Reference,
155 pulses = self.pulses,Num_Codes=self.Num_Codes,
156 pulse_size=self.pulse_size,prof_gen=self.profiles,
157 H0=self.H0,DH0=self.DH0)
158
159 self.profileIndex = 0
160 self.flagIsNewFile = 0
161 self.flagIsNewBlock = 1
162 self.nTotalBlocks += 1
163 self.nReadBlocks += 1
164
165 return 1
166
167
168 def getData(self): ### metodo propio de VoltageReader
169
170 if self.flagNoMoreFiles:
171 self.dataOut.flagNodata = True
172 self.flagDiscontinuousBlock = 0
173 self.flagIsNewBlock = 0
174 if self.__hasNotDataInBuffer(): # aqui es verdad
175 if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header
176 return 0
177 self.getFirstHeader() # atributo
178 self.reshapeData() # nTxx1 =1 return , n
179
180 if not self.getByBlock:
181 self.dataOut.flagDataAsBlock = False
182 self.dataOut.data = self.datablock[:, self.profileIndex, :]
183 self.dataOut.profileIndex = self.profileIndex
184 self.profileIndex += 1
185 else:
186 pass
187 self.dataOut.flagNoData = False
188 self.getBasicHeader()
189 self.dataOut.realtime = self.online
190 return self.dataOut.data
191
192 def set_kwargs(self, **kwargs):
193 for key, value in kwargs.items():
194 setattr(self, key, value)
195
196 def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,
197 nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
198 numTaus=0, line6Function=0, line5Function=0, fClock=None,
199 prePulseBefore=0, prePulseAfter=0,
200 codeType=0, nCode=0, nBaud=0, code=None,
201 flip1=0, flip2=0):
202
203 self.radarControllerHeaderObj.expType = expType
204 self.radarControllerHeaderObj.nTx = nTx
205 self.radarControllerHeaderObj.ipp = float(ipp)
206 self.radarControllerHeaderObj.txA = float(txA)
207 self.radarControllerHeaderObj.txB = float(txB)
208 self.radarControllerHeaderObj.rangeIPP = ipp
209 self.radarControllerHeaderObj.rangeTxA = txA
210 self.radarControllerHeaderObj.rangeTxB = txB
211
212 self.radarControllerHeaderObj.nHeights = int(nHeights)
213 self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight])
214 self.radarControllerHeaderObj.deltaHeight = numpy.array([deltaHeight])
215 self.radarControllerHeaderObj.samplesWin = numpy.array([nHeights])
216
217
218 self.radarControllerHeaderObj.nWindows = nWindows
219 self.radarControllerHeaderObj.numTaus = numTaus
220 self.radarControllerHeaderObj.codeType = codeType
221 self.radarControllerHeaderObj.line6Function = line6Function
222 self.radarControllerHeaderObj.line5Function = line5Function
223 self.radarControllerHeaderObj.fclock = fClock
224 self.radarControllerHeaderObj.prePulseBefore= prePulseBefore
225 self.radarControllerHeaderObj.prePulseAfter = prePulseAfter
226
227 self.radarControllerHeaderObj.nCode = nCode
228 self.radarControllerHeaderObj.nBaud = nBaud
229 self.radarControllerHeaderObj.code = code
230 self.radarControllerHeaderObj.flip1 = flip1
231 self.radarControllerHeaderObj.flip2 = flip2
232
233 self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4
234
235 if fClock is None and deltaHeight is not None:
236 self.fClock = 0.15 / (deltaHeight * 1e-6)
237
238 def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,
239 dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
240 nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0,
241 deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
242 code=0, nBaud=None, shif_fft=False, flag_dc=False,
243 flag_cspc=False, flag_decode=False, flag_deflip=False):
244
245 self.processingHeaderObj.profilesPerBlock = profilesPerBlock
246 self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile
247 self.processingHeaderObj.nWindows = nWindows
248 self.processingHeaderObj.nCohInt = nCohInt
249 self.processingHeaderObj.nIncohInt = nIncohInt
250 self.processingHeaderObj.totalSpectra = totalSpectra
251 self.processingHeaderObj.nHeights = int(nHeights)
252 self.processingHeaderObj.firstHeight = firstHeight
253 self.processingHeaderObj.deltaHeight = deltaHeight
254 self.processingHeaderObj.samplesWin = nHeights
255
256 def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):
257 self.basicHeaderObj.utc = utc
258 self.basicHeaderObj.miliSecond = miliSecond
259 self.basicHeaderObj.timeZone = timeZone
260
261 def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
262 self.systemHeaderObj.nSamples = nSamples
263 self.systemHeaderObj.nProfiles = nProfiles
264 self.systemHeaderObj.nChannels = nChannels
265 self.systemHeaderObj.adcResolution = adcResolution
266 self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth
267
268 def setup(self,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000,
269 FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,
270 FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0*math.pi*(1/16),DC_level= 500,
271 stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,channels=1,Fdoppler=20,Hdoppler=36,
272 **kwargs):
273
274 self.set_kwargs(**kwargs)
275 self.nReadBlocks = 0
276 tmp = time.time()
277 tmp_utc = int(tmp)
278 tmp_milisecond = int((tmp-tmp_utc)*1000)
279 print(" SETUP -basicHeaderObj.utc",datetime.datetime.utcfromtimestamp(tmp))
280 if Dyn_snCode is None:
281 Num_Codes=1
282 Bauds =1
283
284
285
286 self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )
287
288 self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,
289 nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,
290 numTaus=1, line6Function=0, line5Function=0, fClock=None,
291 prePulseBefore=0, prePulseAfter=0,
292 codeType=14, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
293 flip1=0, flip2=0)
294
295 self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300,
296 dataBlocksPerFile=120, nWindows=1, processFlags=0, nCohInt=1,
297 nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,
298 deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,
299 code=0, nBaud=None, shif_fft=False, flag_dc=False,
300 flag_cspc=False, flag_decode=False, flag_deflip=False)
301
302 self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels)
303
304 self.incIntFactor = incIntFactor
305 self.nFFTPoints = nFFTPoints
306 self.FixPP_IncInt = FixPP_IncInt
307 self.FixRCP_IPP = FixRCP_IPP
308 self.FixPP_CohInt = FixPP_CohInt
309 self.Tau_0 = Tau_0
310 self.AcqH0_0 = AcqH0_0
311 self.H0 = AcqH0_0
312 self.AcqDH_0 = AcqDH_0
313 self.DH0 = AcqDH_0
314 self.Bauds = Bauds
315 self.FixRCP_TXA = FixRCP_TXA
316 self.FixRCP_TXB = FixRCP_TXB
317 self.fAngle = fAngle
318 self.DC_level = DC_level
319 self.stdev = stdev
320 self.Num_Codes = Num_Codes
321 self.Dyn_snCode = Dyn_snCode
322 self.samples = samples
323 self.channels = channels
324 self.profiles = None
325 self.m_nReference = None
326 self.Baudwidth = None
327 self.Fdoppler = Fdoppler
328 self.Hdoppler = Hdoppler
329
330 print("IPP ", self.FixRCP_IPP)
331 print("Tau_0 ",self.Tau_0)
332 print("AcqH0_0",self.AcqH0_0)
333 print("samples,window ",self.samples)
334 print("AcqDH_0",AcqDH_0)
335 print("FixRCP_TXA",self.FixRCP_TXA)
336 print("FixRCP_TXB",self.FixRCP_TXB)
337 print("Dyn_snCode",Dyn_snCode)
338 print("Fdoppler", Fdoppler)
339 print("Hdoppler",Hdoppler)
340
341 self.init_acquisition()
342 self.pulses,self.pulse_size=self.init_pulse(Num_Codes=self.Num_Codes,Bauds=self.Bauds,BaudWidth=self.BaudWidth,Dyn_snCode=Dyn_snCode)
343 print(" [ END ] - SETUP metodo")
344 return
345
346 def run(self,**kwargs): # metodo propio
347 if not(self.isConfig):
348 self.setup(**kwargs)
349 self.isConfig = True
350 self.getData()
351
352 ##################################################################
353 ###### Aqui ingresamos las clases y metodos propios del simulador
354 ##################################################################
355
356 #############################################
357 ############## INIT_ACQUISITION##############
358 #############################################
359 def init_acquisition(self):
360
361 if self.nFFTPoints != 0:
362 self.incIntFactor = m_nProfilesperBlock/self.nFFTPoints
363 if (self.FixPP_IncInt > self.incIntFactor):
364 self.incIntFactor = self.FixPP_IncInt/ self.incIntFactor
365 elif(self.FixPP_IncInt< self.incIntFactor):
366 print("False alert...")
367
368 ProfilesperBlock = self.processingHeaderObj.profilesPerBlock
369
370 self.timeperblock =int(((self.FixRCP_IPP
371 *ProfilesperBlock
372 *self.FixPP_CohInt
373 *self.incIntFactor)
374 /150.0)
375 *0.9
376 +0.5)
377 # para cada canal
378 self.profiles = ProfilesperBlock*self.FixPP_CohInt
379 self.profiles = ProfilesperBlock
380 self.Reference = int((self.Tau_0-self.AcqH0_0)/(self.AcqDH_0)+0.5)
381 self.BaudWidth = int((self.FixRCP_TXA/self.AcqDH_0)/self.Bauds + 0.5 )
382
383 if (self.BaudWidth==0):
384 self.BaudWidth=1
385 #################################################################
386 ####################### init_pulse ##############################
387 ################################################################
388
389 def init_pulse(self,Num_Codes=Num_Codes,Bauds=Bauds,BaudWidth=BaudWidth,Dyn_snCode=Dyn_snCode):
390
391 Num_Codes = Num_Codes
392 Bauds = Bauds
393 BaudWidth = BaudWidth
394 Dyn_snCode = Dyn_snCode
395
396 if Dyn_snCode:
397 print("EXISTE")
398 else:
399 print("No existe")
400
401 if Dyn_snCode: # if Bauds:
402 pulses = list(range(0,Num_Codes))
403 num_codes = Num_Codes
404 for i in range(num_codes):
405 pulse_size = Bauds*BaudWidth
406 pulses[i] = numpy.zeros(pulse_size)
407 for j in range(Bauds):
408 for k in range(BaudWidth):
409 pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600)
410 else:
411 print("sin code")
412 pulses = list(range(1))
413 pulse_size = int(self.FixRCP_TXB/0.15+0.5)
414 pulses[0] = numpy.ones(pulse_size)
415 pulses = 600*pulses[0]
416
417 return pulses,pulse_size
418
419 #################################################################
420 ##################### Generate block data
421 ################################################################
422
423 def jro_GenerateBlockOfData(self,Samples=Samples,DC_level= DC_level,stdev=stdev,
424 Reference= Reference,pulses= pulses,
425 Num_Codes= Num_Codes,pulse_size=pulse_size,
426 prof_gen= prof_gen,H0 = H0,DH0=DH0,Fdoppler= Fdoppler,Hdoppler=Hdoppler):
427 Samples = Samples
428 DC_level = DC_level
429 stdev = stdev
430 m_nR = Reference
431 pulses = pulses
432 num_codes = Num_Codes
433 ps = pulse_size
434 prof_gen = prof_gen
435 channels = self.channels
436 H0 = H0
437 DH0 = DH0
438 ippSec = self.radarControllerHeaderObj.ippSeconds
439 Fdoppler = self.Fdoppler
440 Hdoppler = self.Hdoppler
441
442 self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64)
443 for i in range(channels):
444 for k in range(prof_gen):
445 #·······················NOISE···············
446 Noise_r = numpy.random.normal(DC_level,stdev,Samples)
447 Noise_i = numpy.random.normal(DC_level,stdev,Samples)
448 Noise = numpy.zeros(Samples,dtype=complex)
449 Noise.real = Noise_r
450 Noise.imag = Noise_i
451 #·······················PULSOS··············
452 Pulso = numpy.zeros(pulse_size,dtype=complex)
453 Pulso.real = pulses[k%num_codes]
454 Pulso.imag = pulses[k%num_codes]
455 #····················· PULSES+NOISE··········
456 InBuffer = numpy.zeros(Samples,dtype=complex)
457 InBuffer[m_nR:m_nR+ps] = Pulso
458 InBuffer = Noise+ InBuffer
459 #····················· ANGLE ·······························
460
461
462
463
464 InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( self.fAngle)*5)
465 InBuffer=InBuffer
466 self.datablock[i][k]= InBuffer
467 #plot_cts(InBuffer,H0=H0,DH0=DH0
468
469
470 #wave_fft(x=InBuffer,plot_show=True)
471 #time.sleep(1)
472 #················DOPPLER SIGNAL...............................................
473 time_vec = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen
474 fd = Fdoppler #+(600.0/120)*self.nReadBlocks
475 d_signal = 650*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
476 #·················· DATABLOCK + DOPPLER············...........................
477 HD=int(Hdoppler/self.AcqDH_0)
478 self.datablock[0,:,HD]=self.datablock[0,:,HD]+ d_signal # RESULT
479 '''
480 a= numpy.zeros(10)
481 for i in range(10):
482 a[i]=i+self.nReadBlocks+20
483 for i in a:
484 self.datablock[0,:,int(i)]=self.datablock[0,:,int(i)]+ d_signal # RESULT
485 '''
Show file before | Show file after | Hide comments
@@ -0,0 +1,336
1 import numpy,math
2 import zmq
3 import tempfile
4 from io import StringIO
5 ########## 1 Heredamos JRODatareader
6 from schainpy.model.io.jroIO_base import *
7 ########## 2 Heredamos las propiedades de ProcessingUnit
8 from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator
9 ########## 3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader
10 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader
11 ########## 4 Importaremos el objeto Voltge
12 from schainpy.model.data.jrodata import Voltage
13
14 @MPDecorator
15 class SimulatorReader(JRODataReader, ProcessingUnit):
16 incIntFactor = 1
17 nFFTPoints = 0
18 FixPP_IncInt = 1
19 FixRCP_IPP = 1000
20 FixPP_CohInt = 1
21 Tau_0 = 250
22 AcqH0_0 = 70
23 H0 = AcqH0_0
24 AcqDH_0 = 1.25
25 DH0 = AcqDH_0
26 Bauds = 32
27 FixRCP_TXA = 40
28
29 fAngle = 2.0*math.pi*(1/16)
30 DC_level = 500
31 stdev = 8
32 Num_codes = 2
33 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])
34 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])
35 Dyn_sncode = numpy.array([Num_codes,Bauds])
36 samples = 200
37 channels = 1
38
39
40 def __init__(self):
41 """
42 Inicializador de la clases SimulatorReader para
43 generar datos de voltage simulados.
44 Input:
45 dataOut: Objeto de la clase Voltage.
46 Este Objeto sera utilizado apra almacenar
47 un perfil de datos cada vez qe se haga psiversho
48 un requerimiento (getData)
49 """
50 ProcessingUnit.__init__(self)
51 print(" [ START ] init - Metodo Simulator Reader")
52 self.isConfig = False
53 self.basicHeaderObj = BasicHeader(LOCALTIME)
54 self.systemHeaderObj = SystemHeader()
55 self.radarControlHeaderObj = RadarControllerHeader()
56 self.processingHeaderObj = ProcessingHeader()
57 self.profileIndex = 2**32-1
58 self.dataOut = Voltage()
59 #self.server = "simulate"
60 print(" [ END ] init - Metodo simulator Reader" )
61
62
63 def __hasNotDataInBuffer(self):
64 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:
65 return 1
66 return 0
67
68 def __setNewBlock(self):
69 if self.flagIsNewFile:
70 #self.lastUTTime = self.basicHeaderObj.utc
71 return 1
72
73 def readNextBlock(self):
74 while True:
75 self.__setNewBlock()
76 print (" [ START ] readNexBlock")
77 if not(self.readBlock()):
78 return 0
79 self.getBasicHeader()
80 break
81 if self.verbose:
82 print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlock,
83 self.processingHeaderObj.dataBlocksPerfile,
84 self.dataOut.datatime.ctime()) )
85 return 1
86
87 def getFirstHeader(self):
88 self.getBasicHeader()
89 self.dataOut.processingHeaderObj= self.processingHeaderObj.copy()
90
91 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
92
93 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
94
95 def getBasicHeader(self):
96 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
97 1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
98
99 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
100
101 self.dataOut.timeZone = self.basicHeaderObj.timeZone
102
103 self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
104
105 self.dataOut.errorCount = self.basicHeaderObj.errorCount
106
107 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
108
109 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
110
111 def reshapeData(self):
112 if self.nTxs==1:
113 return
114
115 def readBlock(self):
116 self.init_acquisition()
117 pulses, num_codes, pulse_size = self.init_pulse()
118 self.jro_GenerateBlockOfData()
119 self.profileIndex = 0
120
121 self.flagIsNewFile = 0
122 self.flagIsNewBlock = 1
123
124 self.nTotalBlocks += 1
125 self.nReadBlocks += 1
126
127 return 1
128
129
130 def getData(self): ### metodo propio de VoltageReader
131
132 if self.flagNoMoreFiles:
133 self.dataOut.flagNodata= True
134 self.flagDiscontinuousBlock=0
135 self.flagIsNewBlock = 0
136 if self.__hasNotDataInBuffer(): # aqui es verdad
137 if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header
138 return 0
139 self.getFirstHeader() # atributo
140 self.reshapeData() # nTxx1 =1 return , n
141
142 if not self.getByBlock:
143 self.dataOut.flagDataAsBlock = False
144 self.dataOut.data = self.datablock[:, self.profileIndex, :]
145 self.dataOut.profileIndex = self.profileIndex
146
147 self.profileIndex += 1
148 else:
149 pass
150 self.getBasicHeader()
151 self.dataOut.realtime = self.searchFilesOnline
152
153 return self.dataOut.data
154
155
156 def set_kwargs(self, **kwargs):
157
158 for key, value in kwargs.items():
159 print(" set_kwargs ",key,value)
160 setattr(self, key, value)
161
162
163 def setup(self,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=100,
164 FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,
165 FixRCP_TXA = 40, fAngle = 2.0*math.pi*(1/16),DC_level= 500, stdev= 8,
166 Num_codes = None , Dyn_snCode = None, samples=200,channels=1,
167 **kwargs):
168 print(" [ START ] - SETUP metodo")
169 self.set_kwargs(**kwargs)
170 self.processingHeaderObj.profilesPerBlock = 100
171 self.incIntFactor = incIntFactor
172 self.nFFTPoints = nFFTPoints
173 self.FixPP_IncInt = FixPP_IncInt
174 self.FixRCP_IPP = FixRCP_IPP
175 self.FixPP_CohInt = FixPP_CohInt
176 self.Tau_0 = Tau_0
177 self.AcqH0_0 = AcqH0_0
178 self.H0 = AcqH0_0
179 self.AcqDH_0 = AcqDH_0
180 self.DH0 = AcqDH_0
181 self.Bauds = Bauds
182 self.FixRCP_TXA = FixRCP_TXA
183
184 self.fAngle = fAngle
185 self.DC_level = DC_level
186 self.stdev = stdev
187 self.Num_codes = Num_codes
188 #self.code0 = code0
189 #self.code1 = code1
190 self.Dyn_snCode = Dyn_snCode
191 self.samples = samples
192 self.channels = channels
193
194 print(" [ END ] - SETUP metodo")
195 return
196
197 def run(self,**kwargs): # metodo propio
198
199 print(" [ START ] Metodo RUN: ", self.server)
200 if not(self.isConfig):
201 self.setup(**kwargs)
202 self.isConfig = True
203 import time
204 time.sleep(3)
205 #if self.server is None:
206 self.getData()
207 #else:
208 # self.getFromServer()
209 ##################################################################
210 ###### Aqui ingresamos las clases y metodos propios del simulador
211 ##################################################################
212
213 #############################################
214 ############## INIT_ACQUISITION##############
215 #############################################
216 def init_acquisition(self):
217
218 if self.nFFTPoints != 0:
219 self.incIntfactor = m_nProfilesperBlock/self.nFFTPoints
220 if (self.FixPP_IncInt > self.incIntfactor):
221 self.incIntfactor = self.FixPP_IncInt/ self.incIntfactor
222 elif(self.FixPP_IncInt< self.incIntfactor):
223 print("False alert...")
224
225 ProfilesperBLock = self.processingHeaderObj.profilesPerBlock
226
227 self.timeperblock =int(((self.FixRCP_m_fIPP
228 *m_nProfilesperBlock
229 *self.FixPP_CohInt
230 *self.incIntfactor)
231 /150.0)
232 *0.9
233 +0.5)
234 # para cada canal
235 prof_gen = m_nProfilesperBlock*FixPP_m_n_CoherentIntegrations
236 prof_gen = m_nProfilesperBlock
237
238
239 m_nReference = int((Dyn_sfTau_0-Dyn_sfAcqH0_0)/(Dyn_sfAcqDH_0)+0.5)
240 print(m_nReference)
241 BaudWidth = int((FixRCP_m_fTXA/Dyn_sfAcqDH_0)/m_nBauds + 0.5 )
242 print(BaudWidth)
243 if (BaudWidth==0):
244 BaudWidth=1
245
246
247 #################################################################
248 ##################### init_pulse
249 ################################################################
250
251 def init_pulse(m_nNum_Codes,m_nBauds,BaudWidth,Dyn_snCode):
252 fAngle = 2.0*math.pi*(1/16)
253 DC_level = 500
254 stdev = 8
255 m_nNum_Codes= m_nNum_Codes
256 m_nBauds = m_nBauds
257 BaudWidth = BaudWidth
258 Dyn_snCode = Dyn_snCode
259
260 if m_nBauds:
261 pulses = list(range(0,m_nNum_Codes))
262 num_codes = m_nNum_Codes
263 for i in range(num_codes):
264 pulse_size = m_nBauds*BaudWidth
265 pulses[i] = numpy.zeros(pulse_size)
266 for j in range(m_nBauds):
267 for k in range(BaudWidth):
268 pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600)
269 else:
270 pulses = list(range(1))
271 pulse_size = int(FixRCP_m_fTXB/0.15+0.5)
272 pulses[0] = numpy.ones(pulse_size)
273 pulses = 600*pulses[0]
274 return pulses,num_codes,pulse_size
275
276 #################################################################
277 ##################### Generate block data
278 ################################################################
279 # m_nChannels
280 # prof_gen
281 # fAngle = 2.0*math.pi*(1/16)
282 # DC_level = 500
283 # stdev
284 # num_codes
285 #fAngle = 2.0*math.pi*(1/16)
286 #num_codes = 8
287
288
289 def jro_GenerateBlockOfData(m_nSamples,DC_level,stdev,m_nReference,pulses,num_codes,pulse_size,prof_gen,H0,DH0):
290 m_nSamples = m_nSamples
291 DC_level = DC_level
292 stdev = stdev
293 m_nR = m_nReference
294 pulses = pulses
295 num_codes = num_codes
296 ps = pulse_size
297 prof_gen = prof_gen
298 H0 = H0
299 DH0 = DH0
300 fAngle = 2.0*math.pi*(1/16)
301
302 # NOISE
303 Seed_r=random.seed(2)
304 Noise_r = numpy.random.normal(DC_level,stdev,m_nSamples)
305 Seed_i=random.seed(3)
306 Noise_i = numpy.random.normal(DC_level,stdev,m_nSamples)
307 Noise = numpy.zeros(m_nSamples,dtype=complex)
308 Noise.real = Noise_r
309 Noise.imag = Noise_i
310 Pulso = numpy.zeros(pulse_size,dtype=complex)
311
312 #DOPPLER
313 x = m_nSamples
314 time_space = (DH0*numpy.linspace(0, x-1,num=x) +H0)
315 time_vec = time_space*(1.0e-3/150.0)
316 fd = 10
317 d_signal = numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
318
319
320
321 for i in range(m_nChannels):
322 for k in range(prof_gen):
323 Pulso.real = pulses[k%num_codes]
324 Pulso.imag = pulses[k%num_codes]
325 InBuffer = numpy.zeros(m_nSamples,dtype=complex)
326 InBuffer[m_nR:m_nR+ps] = Pulso
327 InBuffer = Noise+ InBuffer
328 InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps]*(math.cos( fAngle)*5)
329 InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( fAngle)*5)
330 InBuffer=InBuffer
331 #print(InBuffer[:10])
332 #print(InBuffer.shape)
333 plot_cts(InBuffer,H0=H0,DH0=DH0)
334 #wave_fft(x=InBuffer,plot_show=True)
335 #time.sleep(1)
336
Show file before | Show file after | Hide comments
@@ -677,9 +677,11 class ProcUnitConf():
677 '''
677 '''
678 Instancia de unidades de procesamiento.
678 Instancia de unidades de procesamiento.
679 '''
679 '''
680
680 #print(" [ CREATE OBJ ] :",self.name)
681 className = eval(self.name)
681 className = eval(self.name)
682
682 kwargs = self.getKwargs()
683 kwargs = self.getKwargs()
684 #print (" [ kwargs ] : ", kwargs)
683 procUnitObj = className(self.id, self.inputId, self.project_id, self.err_queue, self.lock, 'ProcUnit', **kwargs)
685 procUnitObj = className(self.id, self.inputId, self.project_id, self.err_queue, self.lock, 'ProcUnit', **kwargs)
684 log.success('creating process...', self.name)
686 log.success('creating process...', self.name)
685
687
@@ -747,6 +749,7 class ReadUnitConf(ProcUnitConf):
747 '''
749 '''
748
750
749 # Compatible with old signal chain version
751 # Compatible with old signal chain version
752 #print (" [INSIDE] : setup ReadUnit", kwargs)
750 if datatype == None and name == None:
753 if datatype == None and name == None:
751 raise ValueError('datatype or name should be defined')
754 raise ValueError('datatype or name should be defined')
752 if name == None:
755 if name == None:
@@ -822,6 +825,13 class ReadUnitConf(ProcUnitConf):
822 for key, value in list(kwargs.items()):
825 for key, value in list(kwargs.items()):
823 opObj.addParameter(name=key, value=value,
826 opObj.addParameter(name=key, value=value,
824 format=type(value).__name__)
827 format=type(value).__name__)
828 elif self.server== "simulate":
829 #print(" [ INSIDE ] : AROperation simulate -True simulate")
830 opObj.addParameter(
831 name='datatype', value=self.datatype, format='str')
832 for key, value in list(kwargs.items()):
833 opObj.addParameter(name=key, value=value,
834 format=type(value).__name__)
825 else:
835 else:
826 opObj.addParameter(name='server', value=self.server, format='str')
836 opObj.addParameter(name='server', value=self.server, format='str')
827
837
Show file before | Show file after | Hide comments
@@ -177,9 +177,10 class Scope_(Figure):
177 channelIndexList.append(dataOut.channelList.index(channel))
177 channelIndexList.append(dataOut.channelList.index(channel))
178
178
179 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
179 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
180 ### print("***************** PLOTEO **************************")
180 #print("***************** PLOTEO **************************")
181 ### print(dataOut.nProfiles)
181 #print(dataOut.nProfiles)
182 ### print(dataOut.heightList.shape)
182 #print(dataOut.heightList.shape)
183 #print(dataOut.data.shape)
183 if dataOut.flagDataAsBlock:
184 if dataOut.flagDataAsBlock:
184
185
185 for i in range(dataOut.nProfiles):
186 for i in range(dataOut.nProfiles):
Show file before | Show file after | Hide comments
@@ -21,3 +21,5 from .jroIO_mira35c import *
21 from .julIO_param import *
21 from .julIO_param import *
22
22
23 from .pxIO_param import *
23 from .pxIO_param import *
24
25 from .jroIO_simulator import *
Show file before | Show file after | Hide comments
@@ -755,6 +755,7 class JRODataReader(Reader):
755 """
755 """
756
756
757
757
758
758 if nextFile:
759 if nextFile:
759 self.set += 1
760 self.set += 1
760 if nextDay:
761 if nextDay:
@@ -859,6 +860,8 class JRODataReader(Reader):
859 if self.fp == None:
860 if self.fp == None:
860 return 0
861 return 0
861
862
863 #print("DIME COMO ARRANCA",self.flagIsNewFile)
864 #print("DIME COMO VA",self.nReadBlocks)
862 if self.flagIsNewFile:
865 if self.flagIsNewFile:
863 self.lastUTTime = self.basicHeaderObj.utc
866 self.lastUTTime = self.basicHeaderObj.utc
864 return 1
867 return 1
@@ -896,6 +899,7 class JRODataReader(Reader):
896 return 1
899 return 1
897
900
898 def readNextBlock(self):
901 def readNextBlock(self):
902 #print("nReadBlocks",self.nReadBlocks)
899
903
900 while True:
904 while True:
901 self.__setNewBlock()
905 self.__setNewBlock()
@@ -917,6 +921,7 class JRODataReader(Reader):
917 print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
921 print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
918 self.processingHeaderObj.dataBlocksPerFile,
922 self.processingHeaderObj.dataBlocksPerFile,
919 self.dataOut.datatime.ctime()))
923 self.dataOut.datatime.ctime()))
924
920 return 1
925 return 1
921
926
922 def readFirstHeader(self):
927 def readFirstHeader(self):
@@ -1168,9 +1173,16 class JRODataReader(Reader):
1168 return
1173 return
1169
1174
1170 def getBasicHeader(self):
1175 def getBasicHeader(self):
1171
1176 '''
1177 print("1",self.radarControllerHeaderObj.ippSeconds)
1178 print("2",self.profileIndex)
1179 print("3",self.basicHeaderObj.miliSecond)
1180 print("4",self.basicHeaderObj.utc)
1181 print("5",self.nTxs)
1182 '''
1172 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
1183 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
1173 1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
1184 1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
1185 #print(self.profileIndex,self.dataOut.utctime)
1174
1186
1175 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
1187 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
1176
1188
@@ -1435,7 +1447,7 class JRODataWriter(Reader):
1435
1447
1436 return 1
1448 return 1
1437
1449
1438 def setNextFile(self):
1450 def setNewxtFile(self):
1439 """Determina el siguiente file que sera escrito
1451 """Determina el siguiente file que sera escrito
1440
1452
1441 Affected:
1453 Affected:
Show file before | Show file after | Hide comments
@@ -65,7 +65,7 class VoltageReader(JRODataReader, ProcessingUnit):
65 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
65 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
66 almacenar un perfil de datos cada vez que se haga un requerimiento
66 almacenar un perfil de datos cada vez que se haga un requerimiento
67 (getData). El perfil sera obtenido a partir del buffer de datos,
67 (getData). El perfil sera obtenido a partir del buffer de datos,
68 si el buffer esta vacio se hara un nuevo proceso de lectura de un
68 si el buffer esta vacio se hara un nuevo proceso de lectura de unX
69 bloque de datos.
69 bloque de datos.
70 Si este parametro no es pasado se creara uno internamente.
70 Si este parametro no es pasado se creara uno internamente.
71
71
@@ -285,7 +285,7 class VoltageReader(JRODataReader, ProcessingUnit):
285 self.flagDiscontinuousBlock = 0
285 self.flagDiscontinuousBlock = 0
286 self.profileIndex = 0
286 self.profileIndex = 0
287 self.flagIsNewBlock = 1
287 self.flagIsNewBlock = 1
288 self.dataOut.flagNoData = False
288 self.dataOut.flagNoata = False
289 self.nTotalBlocks += 1
289 self.nTotalBlocks += 1
290 self.nReadBlocks += 1
290 self.nReadBlocks += 1
291 self.blockPointer = 0
291 self.blockPointer = 0
Show file before | Show file after | Hide comments
@@ -304,7 +304,6 def MPDecorator(BaseClass):
304 Run fuction for read units
304 Run fuction for read units
305 '''
305 '''
306 while True:
306 while True:
307
308 try:
307 try:
309 BaseClass.run(self, **self.kwargs)
308 BaseClass.run(self, **self.kwargs)
310 except:
309 except:
General Comments 0
You need to be logged in to leave comments. Login now