##// END OF EJS Templates
schain
RSS
adicion de escritura de datos, calculo de ancho espectral y graficos pulsepair
avaldez -
r1303:ddb038395553
parent child
Show More
Side by Side Unified
Context file:
r1303:ddb038395553 Loading diff...:
Show file before | Show file after | Hide comments
@@ -362,6 +362,7 class Voltage(JROData):
362 data = None
362 data = None
363 data_intensity = None
363 data_intensity = None
364 data_velocity = None
364 data_velocity = None
365 data_specwidth = None
365 def __init__(self):
366 def __init__(self):
366 '''
367 '''
367 Constructor
368 Constructor
@@ -1268,6 +1269,10 class PlotterData(object):
1268 buffer = dataOut.data_velocity
1269 buffer = dataOut.data_velocity
1269 self.flagDataAsBlock = dataOut.flagDataAsBlock
1270 self.flagDataAsBlock = dataOut.flagDataAsBlock
1270 self.nProfiles = dataOut.nProfiles
1271 self.nProfiles = dataOut.nProfiles
1272 if plot == 'pp_specwidth':
1273 buffer = dataOut.data_specwidth
1274 self.flagDataAsBlock = dataOut.flagDataAsBlock
1275 self.nProfiles = dataOut.nProfiles
1271
1276
1272 if plot == 'spc':
1277 if plot == 'spc':
1273 self.data['spc'] = buffer
1278 self.data['spc'] = buffer
Show file before | Show file after | Hide comments
@@ -32,7 +32,7 class SimulatorReader(JRODataReader, ProcessingUnit):
32 #Dyn_snCode = numpy.array([Num_Codes,Bauds])
32 #Dyn_snCode = numpy.array([Num_Codes,Bauds])
33 Dyn_snCode = None
33 Dyn_snCode = None
34 Samples = 200
34 Samples = 200
35 channels = 5
35 channels = 2
36 pulses = None
36 pulses = None
37 Reference = None
37 Reference = None
38 pulse_size = None
38 pulse_size = None
@@ -91,12 +91,14 class SimulatorReader(JRODataReader, ProcessingUnit):
91
91
92 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
92 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
93 self.nReadFiles=self.nReadFiles+1
93 self.nReadFiles=self.nReadFiles+1
94 if self.nReadFiles ==self.nTotalReadFiles:
94 if self.nReadFiles > self.nTotalReadFiles:
95 self.flagNoMoreFiles=1
95 self.flagNoMoreFiles=1
96 raise schainpy.admin.SchainWarning('No more files to read')
96 raise schainpy.admin.SchainWarning('No more files to read')
97
97
98 print('------------------- [Opening file] ------------------------------',self.nReadFiles)
98 print('------------------- [Opening file] ------------------------------',self.nReadFiles)
99 self.nReadBlocks = 0
99 self.nReadBlocks = 0
100 #if self.nReadBlocks==0:
101 # self.readFirstHeader()
100
102
101 def __setNewBlock(self):
103 def __setNewBlock(self):
102 self.setNextFile()
104 self.setNextFile()
@@ -121,6 +123,7 class SimulatorReader(JRODataReader, ProcessingUnit):
121 self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
123 self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
122 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
124 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
123 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
125 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
126 self.dataOut.dtype = self.dtype
124
127
125 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
128 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
126 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
129 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
@@ -144,20 +147,42 class SimulatorReader(JRODataReader, ProcessingUnit):
144 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
147 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
145 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
148 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
146
149
150 def readFirstHeader(self):
151
152 datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
153 PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
154 if datatype == 0:
155 datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
156 elif datatype == 1:
157 datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
158 elif datatype == 2:
159 datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
160 elif datatype == 3:
161 datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
162 elif datatype == 4:
163 datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
164 elif datatype == 5:
165 datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
166 else:
167 raise ValueError('Data type was not defined')
168
169 self.dtype = datatype_str
170
171
147 def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,
172 def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,
148 nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
173 nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
149 numTaus=0, line6Function=0, line5Function=0, fClock=None,
174 numTaus=0, line6Function=0, line5Function=0, fClock=None,
150 prePulseBefore=0, prePulseAfter=0,
175 prePulseBefore=0, prePulseAfter=0,
151 codeType=0, nCode=0, nBaud=0, code=None,
176 codeType=0, nCode=0, nBaud=0, code=None,
152 flip1=0, flip2=0):
177 flip1=0, flip2=0,Taus=0):
153 self.radarControllerHeaderObj.expType = expType
178 self.radarControllerHeaderObj.expType = expType
154 self.radarControllerHeaderObj.nTx = nTx
179 self.radarControllerHeaderObj.nTx = nTx
155 self.radarControllerHeaderObj.ipp = float(ipp)
180 self.radarControllerHeaderObj.ipp = float(ipp)
156 self.radarControllerHeaderObj.txA = float(txA)
181 self.radarControllerHeaderObj.txA = float(txA)
157 self.radarControllerHeaderObj.txB = float(txB)
182 self.radarControllerHeaderObj.txB = float(txB)
158 self.radarControllerHeaderObj.rangeIPP = ipp
183 self.radarControllerHeaderObj.rangeIpp = b'A\n'#ipp
159 self.radarControllerHeaderObj.rangeTxA = txA
184 self.radarControllerHeaderObj.rangeTxA = b''
160 self.radarControllerHeaderObj.rangeTxB = txB
185 self.radarControllerHeaderObj.rangeTxB = b''
161
186
162 self.radarControllerHeaderObj.nHeights = int(nHeights)
187 self.radarControllerHeaderObj.nHeights = int(nHeights)
163 self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight])
188 self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight])
@@ -170,20 +195,27 class SimulatorReader(JRODataReader, ProcessingUnit):
170 self.radarControllerHeaderObj.codeType = codeType
195 self.radarControllerHeaderObj.codeType = codeType
171 self.radarControllerHeaderObj.line6Function = line6Function
196 self.radarControllerHeaderObj.line6Function = line6Function
172 self.radarControllerHeaderObj.line5Function = line5Function
197 self.radarControllerHeaderObj.line5Function = line5Function
173 self.radarControllerHeaderObj.fclock = fClock
198 #self.radarControllerHeaderObj.fClock = fClock
174 self.radarControllerHeaderObj.prePulseBefore= prePulseBefore
199 self.radarControllerHeaderObj.prePulseBefore= prePulseBefore
175 self.radarControllerHeaderObj.prePulseAfter = prePulseAfter
200 self.radarControllerHeaderObj.prePulseAfter = prePulseAfter
176
201
177 self.radarControllerHeaderObj.nCode = nCode
178 self.radarControllerHeaderObj.nBaud = nBaud
179 self.radarControllerHeaderObj.code = code
180 self.radarControllerHeaderObj.flip1 = flip1
202 self.radarControllerHeaderObj.flip1 = flip1
181 self.radarControllerHeaderObj.flip2 = flip2
203 self.radarControllerHeaderObj.flip2 = flip2
182
204
183 self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4
205 self.radarControllerHeaderObj.code_size = 0
206 if self.radarControllerHeaderObj.codeType != 0:
207 self.radarControllerHeaderObj.nCode = nCode
208 self.radarControllerHeaderObj.nBaud = nBaud
209 self.radarControllerHeaderObj.code = code
210 self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4
184
211
185 if fClock is None and deltaHeight is not None:
212 if fClock is None and deltaHeight is not None:
186 self.fClock = 0.15 / (deltaHeight * 1e-6)
213 self.fClock = 0.15 / (deltaHeight * 1e-6)
214 self.radarControllerHeaderObj.fClock = self.fClock
215 if numTaus==0:
216 self.radarControllerHeaderObj.Taus = numpy.array(0,'<f4')
217 else:
218 self.radarControllerHeaderObj.Taus = numpy.array(Taus,'<f4')
187
219
188 def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,
220 def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,
189 dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
221 dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
@@ -192,23 +224,27 class SimulatorReader(JRODataReader, ProcessingUnit):
192 code=0, nBaud=None, shif_fft=False, flag_dc=False,
224 code=0, nBaud=None, shif_fft=False, flag_dc=False,
193 flag_cspc=False, flag_decode=False, flag_deflip=False):
225 flag_cspc=False, flag_decode=False, flag_deflip=False):
194
226
227 self.processingHeaderObj.dtype = dtype
195 self.processingHeaderObj.profilesPerBlock = profilesPerBlock
228 self.processingHeaderObj.profilesPerBlock = profilesPerBlock
196 self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile
229 self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile
197 self.processingHeaderObj.nWindows = nWindows
230 self.processingHeaderObj.nWindows = nWindows
231 self.processingHeaderObj.processFlags = processFlags
198 self.processingHeaderObj.nCohInt = nCohInt
232 self.processingHeaderObj.nCohInt = nCohInt
199 self.processingHeaderObj.nIncohInt = nIncohInt
233 self.processingHeaderObj.nIncohInt = nIncohInt
200 self.processingHeaderObj.totalSpectra = totalSpectra
234 self.processingHeaderObj.totalSpectra = totalSpectra
235
201 self.processingHeaderObj.nHeights = int(nHeights)
236 self.processingHeaderObj.nHeights = int(nHeights)
202 self.processingHeaderObj.firstHeight = firstHeight
237 self.processingHeaderObj.firstHeight = firstHeight#numpy.array([firstHeight])#firstHeight
203 self.processingHeaderObj.deltaHeight = deltaHeight
238 self.processingHeaderObj.deltaHeight = deltaHeight#numpy.array([deltaHeight])#deltaHeight
204 self.processingHeaderObj.samplesWin = nHeights
239 self.processingHeaderObj.samplesWin = nHeights#numpy.array([nHeights])#nHeights
205
240
206 def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):
241 def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):
207 self.basicHeaderObj.utc = utc
242 self.basicHeaderObj.utc = utc
208 self.basicHeaderObj.miliSecond = miliSecond
243 self.basicHeaderObj.miliSecond = miliSecond
209 self.basicHeaderObj.timeZone = timeZone
244 self.basicHeaderObj.timeZone = timeZone
210
245
211 def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
246 def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=32):
247 #self.systemHeaderObj.size = size
212 self.systemHeaderObj.nSamples = nSamples
248 self.systemHeaderObj.nSamples = nSamples
213 self.systemHeaderObj.nProfiles = nProfiles
249 self.systemHeaderObj.nProfiles = nProfiles
214 self.systemHeaderObj.nChannels = nChannels
250 self.systemHeaderObj.nChannels = nChannels
@@ -325,10 +361,27 class SimulatorReader(JRODataReader, ProcessingUnit):
325 time_vec = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen+(self.nReadFiles-1)*ippSec*prof_gen
361 time_vec = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen+(self.nReadFiles-1)*ippSec*prof_gen
326 fd = Fdoppler #+(600.0/120)*self.nReadBlocks
362 fd = Fdoppler #+(600.0/120)*self.nReadBlocks
327 d_signal = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
363 d_signal = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
328 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· DATABLOCK + DOPPLERΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·...........................
364 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·SeΓ±al con ancho espectralΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
365 #specw_sig = numpy.zeros(int(prof_gen),dtype=complex)
366 #specw_sig.real[200:200+100] = 1*numpy.ones(100)
367 #specw_sig.imag[200:200+100] = 1*numpy.ones(100)
368 # w=2
369 specw_sig = numpy.linspace(-149,150,300)
370 w = 3
371 A = 10
372 specw_sig = specw_sig/w
373 specw_sig = numpy.sinc(specw_sig)
374 specw_sig = A*numpy.array(specw_sig,dtype=numpy.complex64)
375 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· DATABLOCK + DOPPLERΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
329 HD=int(Hdoppler/self.AcqDH_0)
376 HD=int(Hdoppler/self.AcqDH_0)
330 for i in range(12):
377 for i in range(12):
331 self.datablock[:,:,HD+i]=self.datablock[:,:,HD+i]+ d_signal # RESULT
378 self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT
379
380 HD=int(Hdoppler/self.AcqDH_0)
381 HD=int(HD/2)
382 for i in range(12):
383 self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT
384
332 '''
385 '''
333 a= numpy.zeros(10)
386 a= numpy.zeros(10)
334 for i in range(10):
387 for i in range(10):
@@ -401,16 +454,15 class SimulatorReader(JRODataReader, ProcessingUnit):
401
454
402
455
403 self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )
456 self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )
404
405 self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,
457 self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,
406 nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,
458 nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,
407 numTaus=1, line6Function=0, line5Function=0, fClock=None,
459 numTaus=1, line6Function=0, line5Function=0, fClock=None,
408 prePulseBefore=0, prePulseAfter=0,
460 prePulseBefore=0, prePulseAfter=0,
409 codeType=14, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
461 codeType=0, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
410 flip1=0, flip2=0)
462 flip1=0, flip2=0,Taus=Tau_0)
411
463
412 self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300,
464 self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300,
413 dataBlocksPerFile=120, nWindows=1, processFlags=0, nCohInt=1,
465 dataBlocksPerFile=120, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,
414 nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,
466 nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,
415 deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,
467 deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,
416 code=0, nBaud=None, shif_fft=False, flag_dc=False,
468 code=0, nBaud=None, shif_fft=False, flag_dc=False,
@@ -418,6 +470,7 class SimulatorReader(JRODataReader, ProcessingUnit):
418
470
419 self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels)
471 self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels)
420
472
473 self.readFirstHeader()
421
474
422 self.frequency = frequency
475 self.frequency = frequency
423 self.incIntFactor = incIntFactor
476 self.incIntFactor = incIntFactor
Show file before | Show file after | Hide comments
@@ -1293,8 +1293,7 class PulsePairVoltage(Operation):
1293 __initime = None
1293 __initime = None
1294 __lastdatatime = None
1294 __lastdatatime = None
1295 __buffer = None
1295 __buffer = None
1296 __buffer2 = []
1296 noise = None
1297 __buffer3 = None
1298 __dataReady = False
1297 __dataReady = False
1299 n = None
1298 n = None
1300 __nch = 0
1299 __nch = 0
@@ -1314,10 +1313,8 class PulsePairVoltage(Operation):
1314 self.__lastdatatime = 0
1313 self.__lastdatatime = 0
1315 self.__dataReady = False
1314 self.__dataReady = False
1316 self.__buffer = 0
1315 self.__buffer = 0
1317 self.__buffer2 = []
1318 self.__buffer3 = 0
1319 self.__profIndex = 0
1316 self.__profIndex = 0
1320
1317 self.noise = None
1321 self.__nch = dataOut.nChannels
1318 self.__nch = dataOut.nChannels
1322 self.__nHeis = dataOut.nHeights
1319 self.__nHeis = dataOut.nHeights
1323 self.removeDC = removeDC
1320 self.removeDC = removeDC
@@ -1341,6 +1338,9 class PulsePairVoltage(Operation):
1341 n,
1338 n,
1342 dataOut.nHeights),
1339 dataOut.nHeights),
1343 dtype='complex')
1340 dtype='complex')
1341 self.noise = numpy.zeros([self.__nch,self.__nHeis])
1342 for i in range(self.__nch):
1343 self.noise[i]=dataOut.getNoise(channel=i)
1344
1344
1345 def putData(self,data):
1345 def putData(self,data):
1346 '''
1346 '''
@@ -1362,58 +1362,82 class PulsePairVoltage(Operation):
1362 dc= numpy.tile(tmp,[1,self.__nProf,1])
1362 dc= numpy.tile(tmp,[1,self.__nProf,1])
1363 self.__buffer = self.__buffer - dc
1363 self.__buffer = self.__buffer - dc
1364
1364
1365 data_intensity = numpy.sum(self.__buffer*numpy.conj(self.__buffer),1)/(self.n*self.nCohInt)#*self.nCohInt)
1365 lag_0 = numpy.sum(self.__buffer*numpy.conj(self.__buffer),1)
1366 pair1 = self.__buffer[:,1:,:]*numpy.conjugate(self.__buffer[:,:-1,:])
1366 data_intensity = lag_0/(self.n*self.nCohInt)#*self.nCohInt)
1367 angle = numpy.angle(numpy.sum(pair1,1))*180/(math.pi)
1367
1368 #print(angle.shape)#print("__ANGLE__") #print("angle",angle[:,:10])
1368 pair1 = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
1369 data_velocity = (self.lambda_/(4*math.pi*self.ippSec))*numpy.angle(numpy.sum(pair1,1))#self.ippSec*self.nCohInt
1369 lag_1 = numpy.sum(pair1,1)
1370 #angle = numpy.angle(numpy.sum(pair1,1))*180/(math.pi)
1371 data_velocity = (-1.0*self.lambda_/(4*math.pi*self.ippSec))*numpy.angle(lag_1)#self.ippSec*self.nCohInt
1372
1373 lag_0 = lag_0.real/(self.n)
1374 lag_1 = lag_1/(self.n-1)
1375 R1 = numpy.abs(lag_1)
1376 S = (lag_0-self.noise)
1377 #k = R1/S
1378 #k = 1-k
1379 #k =numpy.absolute(k)
1380 #k =numpy.sqrt(k)
1381 L = S/R1
1382 #print("L",L[0])
1383 L = numpy.where(L<0,1,L)
1384 L = numpy.log(L)
1385 tmp = numpy.sqrt(numpy.absolute(L))
1386 data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec))*tmp*numpy.sign(L)
1387 #data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec))*k
1370 n = self.__profIndex
1388 n = self.__profIndex
1371
1389
1372 self.__buffer = numpy.zeros((self.__nch, self.__nProf,self.__nHeis), dtype='complex')
1390 self.__buffer = numpy.zeros((self.__nch, self.__nProf,self.__nHeis), dtype='complex')
1373 self.__profIndex = 0
1391 self.__profIndex = 0
1374 return data_intensity,data_velocity,n
1392 return data_intensity,data_velocity,data_specwidth,n
1375
1393
1376 def pulsePairbyProfiles(self,data):
1394 def pulsePairbyProfiles(self,data):
1377
1395
1378 self.__dataReady = False
1396 self.__dataReady = False
1379 data_intensity = None
1397 data_intensity = None
1380 data_velocity = None
1398 data_velocity = None
1399 data_specwidth = None
1381 self.putData(data)
1400 self.putData(data)
1382 if self.__profIndex == self.n:
1401 if self.__profIndex == self.n:
1383 data_intensity, data_velocity, n = self.pushData()
1402 #self.noise = numpy.zeros([self.__nch,self.__nHeis])
1403 #for i in range(self.__nch):
1404 # self.noise[i]=data.getNoise(channel=i)
1405 #print(self.noise.shape)
1406 data_intensity, data_velocity,data_specwidth, n = self.pushData()
1384 self.__dataReady = True
1407 self.__dataReady = True
1385
1408
1386 return data_intensity, data_velocity
1409 return data_intensity, data_velocity,data_specwidth
1387
1410
1388 def pulsePairOp(self, data, datatime= None):
1411 def pulsePairOp(self, data, datatime= None):
1389
1412
1390 if self.__initime == None:
1413 if self.__initime == None:
1391 self.__initime = datatime
1414 self.__initime = datatime
1392
1415
1393 data_intensity, data_velocity = self.pulsePairbyProfiles(data)
1416 data_intensity, data_velocity,data_specwidth = self.pulsePairbyProfiles(data)
1394 self.__lastdatatime = datatime
1417 self.__lastdatatime = datatime
1395
1418
1396 if data_intensity is None:
1419 if data_intensity is None:
1397 return None, None, None
1420 return None, None,None, None
1398
1421
1399 avgdatatime = self.__initime
1422 avgdatatime = self.__initime
1400 deltatime = datatime - self.__lastdatatime
1423 deltatime = datatime - self.__lastdatatime
1401 self.__initime = datatime
1424 self.__initime = datatime
1402
1425
1403 return data_intensity, data_velocity, avgdatatime
1426 return data_intensity, data_velocity,data_specwidth,avgdatatime
1404
1427
1405 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1428 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1406
1429
1407 if not self.isConfig:
1430 if not self.isConfig:
1408 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1431 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1409 self.isConfig = True
1432 self.isConfig = True
1410 data_intensity, data_velocity, avgdatatime = self.pulsePairOp(dataOut.data, dataOut.utctime)
1433 data_intensity, data_velocity,data_specwidth, avgdatatime = self.pulsePairOp(dataOut.data, dataOut.utctime)
1411 dataOut.flagNoData = True
1434 dataOut.flagNoData = True
1412
1435
1413 if self.__dataReady:
1436 if self.__dataReady:
1414 dataOut.nCohInt *= self.n
1437 dataOut.nCohInt *= self.n
1415 dataOut.data_intensity = data_intensity #valor para intensidad
1438 dataOut.data_intensity = data_intensity #valor para intensidad
1416 dataOut.data_velocity = data_velocity #valor para velocidad
1439 dataOut.data_velocity = data_velocity #valor para velocidad
1440 dataOut.data_specwidth = data_specwidth
1417 dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo.
1441 dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo.
1418 dataOut.utctime = avgdatatime
1442 dataOut.utctime = avgdatatime
1419 dataOut.flagNoData = False
1443 dataOut.flagNoData = False
General Comments 0
You need to be logged in to leave comments. Login now