| @@ -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 | ''' | |
| @@ -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 | ||
| @@ -677,9 +677,11 class ProcUnitConf(): | |||
|
|
677 | 677 | ''' |
|
|
678 | 678 | Instancia de unidades de procesamiento. |
|
|
679 | 679 | ''' |
|
|
680 | ||
|
|
680 | #print(" [ CREATE OBJ ] :",self.name) | |
|
|
681 | 681 | className = eval(self.name) |
|
|
682 | ||
|
|
682 | 683 | kwargs = self.getKwargs() |
|
|
684 | #print (" [ kwargs ] : ", kwargs) | |
|
|
683 | 685 | procUnitObj = className(self.id, self.inputId, self.project_id, self.err_queue, self.lock, 'ProcUnit', **kwargs) |
|
|
684 | 686 | log.success('creating process...', self.name) |
|
|
685 | 687 | |
| @@ -747,6 +749,7 class ReadUnitConf(ProcUnitConf): | |||
|
|
747 | 749 | ''' |
|
|
748 | 750 | |
|
|
749 | 751 | # Compatible with old signal chain version |
|
|
752 | #print (" [INSIDE] : setup ReadUnit", kwargs) | |
|
|
750 | 753 | if datatype == None and name == None: |
|
|
751 | 754 | raise ValueError('datatype or name should be defined') |
|
|
752 | 755 | if name == None: |
| @@ -822,6 +825,13 class ReadUnitConf(ProcUnitConf): | |||
|
|
822 | 825 | for key, value in list(kwargs.items()): |
|
|
823 | 826 | opObj.addParameter(name=key, value=value, |
|
|
824 | 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 | 835 | else: |
|
|
826 | 836 | opObj.addParameter(name='server', value=self.server, format='str') |
|
|
827 | 837 | |
| @@ -177,9 +177,10 class Scope_(Figure): | |||
|
|
177 | 177 | channelIndexList.append(dataOut.channelList.index(channel)) |
|
|
178 | 178 | |
|
|
179 | 179 | thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0]) |
|
|
180 |
# |
|
|
|
181 |
# |
|
|
|
182 |
# |
|
|
|
180 | #print("***************** PLOTEO **************************") | |
|
|
181 | #print(dataOut.nProfiles) | |
|
|
182 | #print(dataOut.heightList.shape) | |
|
|
183 | #print(dataOut.data.shape) | |
|
|
183 | 184 | if dataOut.flagDataAsBlock: |
|
|
184 | 185 | |
|
|
185 | 186 | for i in range(dataOut.nProfiles): |
| @@ -21,3 +21,5 from .jroIO_mira35c import * | |||
|
|
21 | 21 | from .julIO_param import * |
|
|
22 | 22 | |
|
|
23 | 23 | from .pxIO_param import * |
|
|
24 | ||
|
|
25 | from .jroIO_simulator import * | |
| @@ -755,6 +755,7 class JRODataReader(Reader): | |||
|
|
755 | 755 | """ |
|
|
756 | 756 | |
|
|
757 | 757 | |
|
|
758 | ||
|
|
758 | 759 | if nextFile: |
|
|
759 | 760 | self.set += 1 |
|
|
760 | 761 | if nextDay: |
| @@ -859,6 +860,8 class JRODataReader(Reader): | |||
|
|
859 | 860 | if self.fp == None: |
|
|
860 | 861 |
return 0 |
|
|
861 | 862 | |
|
|
863 | #print("DIME COMO ARRANCA",self.flagIsNewFile) | |
|
|
864 | #print("DIME COMO VA",self.nReadBlocks) | |
|
|
862 | 865 |
if self.flagIsNewFile: |
|
|
863 | 866 | self.lastUTTime = self.basicHeaderObj.utc |
|
|
864 | 867 | return 1 |
| @@ -896,6 +899,7 class JRODataReader(Reader): | |||
|
|
896 | 899 | return 1 |
|
|
897 | 900 | |
|
|
898 | 901 | def readNextBlock(self): |
|
|
902 | #print("nReadBlocks",self.nReadBlocks) | |
|
|
899 | 903 | |
|
|
900 | 904 | while True: |
|
|
901 | 905 | self.__setNewBlock() |
| @@ -917,6 +921,7 class JRODataReader(Reader): | |||
|
|
917 | 921 | print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks, |
|
|
918 | 922 | self.processingHeaderObj.dataBlocksPerFile, |
|
|
919 | 923 | self.dataOut.datatime.ctime())) |
|
|
924 | ||
|
|
920 | 925 | return 1 |
|
|
921 | 926 | |
|
|
922 | 927 | def readFirstHeader(self): |
| @@ -1168,9 +1173,16 class JRODataReader(Reader): | |||
|
|
1168 | 1173 | return |
|
|
1169 | 1174 | |
|
|
1170 | 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 | 1183 | self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \ |
|
|
1173 | 1184 | 1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds |
|
|
1185 | #print(self.profileIndex,self.dataOut.utctime) | |
|
|
1174 | 1186 | |
|
|
1175 | 1187 | self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock |
|
|
1176 | 1188 | |
| @@ -1435,7 +1447,7 class JRODataWriter(Reader): | |||
|
|
1435 | 1447 | |
|
|
1436 | 1448 | return 1 |
|
|
1437 | 1449 | |
|
|
1438 | def setNextFile(self): | |
|
|
1450 | def setNewxtFile(self): | |
|
|
1439 | 1451 | """Determina el siguiente file que sera escrito |
|
|
1440 | 1452 | |
|
|
1441 | 1453 | Affected: |
| @@ -65,7 +65,7 class VoltageReader(JRODataReader, ProcessingUnit): | |||
|
|
65 | 65 | dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para |
|
|
66 | 66 | almacenar un perfil de datos cada vez que se haga un requerimiento |
|
|
67 | 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 | 69 | bloque de datos. |
|
|
70 | 70 | Si este parametro no es pasado se creara uno internamente. |
|
|
71 | 71 | |
| @@ -285,7 +285,7 class VoltageReader(JRODataReader, ProcessingUnit): | |||
|
|
285 | 285 | self.flagDiscontinuousBlock = 0 |
|
|
286 | 286 | self.profileIndex = 0 |
|
|
287 | 287 | self.flagIsNewBlock = 1 |
|
|
288 |
self.dataOut.flagNo |
|
|
|
288 | self.dataOut.flagNoata = False | |
|
|
289 | 289 | self.nTotalBlocks += 1 |
|
|
290 | 290 | self.nReadBlocks += 1 |
|
|
291 | 291 | self.blockPointer = 0 |
General Comments 0
You need to be logged in to leave comments.
Login now