schain-jc Commit - r1120:4cb1c6729a0e

formatting y raise cuando digitalrf recibe spectra

José Chávez -

r1120:4cb1c6729a0e

parent child

Context file:

r1120:4cb1c6729a0e

Collapse all files

schainpy/model/data/jroheaderIO.py +63 -34

                                          ('sRangeTxB', '<a20'),
             ])
-            SAMPLING_STRUCTURE = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
+            SAMPLING_STRUCTURE = numpy.dtype(
+                [('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')])
             PROCESSING_STRUCTURE = numpy.dtype([
                 ('nTotalSpectra', '<u4')
             ])
             class Header(object):
                 def __init__(self):
                     print message
             class BasicHeader(Header):
                 size = None
                 def write(self, fp):
-                    headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
+                    headerTuple = (self.size, self.version, self.dataBlock, self.utc,
+                                   self.miliSecond, self.timeZone, self.dstFlag, self.errorCount)
                     header = numpy.array(headerTuple, BASIC_STRUCTURE)
                     header.tofile(fp)
                 ltc = property(get_ltc, set_ltc)
                 datatime = property(get_datatime)
             class SystemHeader(Header):
                 size = None
                     self.adcResolution = header['nADCResolution'][0]
                     self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
                     if startFp is not None:
                         endFp = self.size + startFp
                         if fp.tell() > endFp:
-                            sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
+                            sys.stderr.write(
+                                "Warning %s: Size value read from System Header is lower than it has to be\n" % fp.name)
                             return 0
                         if fp.tell() < endFp:
-                            sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
+                            sys.stderr.write(
+                                "Warning %s: Size value read from System Header size is greater than it has to be\n" % fp.name)
                             return 0
                     self.length = header.nbytes
                 def write(self, fp):
-                    headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
+                    headerTuple = (self.size, self.nSamples, self.nProfiles,
+                                   self.nChannels, self.adcResolution, self.pciDioBusWidth)
                     header = numpy.array(headerTuple, SYSTEM_STRUCTURE)
                     header.tofile(fp)
                     return 1
             class RadarControllerHeader(Header):
                 expType = None
                     try:
                         if hasattr(fp, 'read'):
-                            samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
+                            samplingWindow = numpy.fromfile(
+                                fp, SAMPLING_STRUCTURE, self.nWindows)
                         else:
-                            samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
+                            samplingWindow = numpy.fromstring(
+                                fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
                     except Exception, e:
                         print "RadarControllerHeader: " + str(e)
                     self.deltaHeight = samplingWindow['dh']
                     self.samplesWin = samplingWindow['nsa']
                     try:
                         if hasattr(fp, 'read'):
                             self.Taus = numpy.fromfile(fp, '<f4', self.numTaus)
                         else:
-                            self.Taus = numpy.fromstring(fp[self.length:], '<f4', self.numTaus)
+                            self.Taus = numpy.fromstring(
+                                fp[self.length:], '<f4', self.numTaus)
                         self.length += self.Taus.nbytes
                     except Exception, e:
                         print "RadarControllerHeader: " + str(e)
                         return 0
                     self.code_size = 0
                     if self.codeType != 0:
                                 self.nBaud = numpy.fromfile(fp, '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
                             else:
-                                self.nCode = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
+                                self.nCode = numpy.fromstring(
+                                    fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nCode.nbytes
-                                self.nBaud = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
+                                self.nBaud = numpy.fromstring(
+                                    fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
                         except Exception, e:
                             print "RadarControllerHeader: " + str(e)
                         for ic in range(self.nCode):
                             try:
                                 if hasattr(fp, 'read'):
-                                    temp = numpy.fromfile(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
+                                    temp = numpy.fromfile(fp, 'u4', int(
+                                        numpy.ceil(self.nBaud / 32.)))
                                 else:
-                                    temp = numpy.fromstring(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
+                                    temp = numpy.fromstring(
+                                        fp, 'u4', int(numpy.ceil(self.nBaud / 32.)))
                                 self.length += temp.nbytes
                             except Exception, e:
                                 print "RadarControllerHeader: " + str(e)
                 #             return 0
                         if fp.tell() > endFp:
-                            sys.stderr.write("Warning %s: Size value read from Radar Controller header is lower than it has to be\n" %fp.name)
+                            sys.stderr.write(
+                                "Warning %s: Size value read from Radar Controller header is lower than it has to be\n" % fp.name)
                 #             return 0
                         if fp.tell() < endFp:
-                            sys.stderr.write("Warning %s: Size value read from Radar Controller header is greater than it has to be\n" %fp.name)
+                            sys.stderr.write(
+                                "Warning %s: Size value read from Radar Controller header is greater than it has to be\n" % fp.name)
                     return 1
                     header = numpy.array(headerTuple, RADAR_STRUCTURE)
                     header.tofile(fp)
-                    sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
+                    sampleWindowTuple = (
+                        self.firstHeight, self.deltaHeight, self.samplesWin)
                     samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE)
                     samplingWindow.tofile(fp)
                                 code_selected = code1[ic, start:end]
                                 for j in range(len(code_selected) - 1, -1, -1):
                                     if code_selected[j] == 1:
-                                        tempx[i] = tempx[i] + 2**(len(code_selected)-1-j)
+                                        tempx[i] = tempx[i] + \
+**(len(code_selected) - 1 - j)
                                 start = start + 32
                                 end = end + 32
                     self.__size = 116 + 12 * self.nWindows + 4 * self.numTaus
                     if self.codeType != 0:
-                        self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
+                        self.__size += 4 + 4 + 4 * self.nCode * \
+                            numpy.ceil(self.nBaud / 32.)
                     return self.__size
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 size = property(get_size, set_size)
             class ProcessingHeader(Header):
                 #     size = None
                     try:
                         if hasattr(fp, 'read'):
-                            samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
+                            samplingWindow = numpy.fromfile(
+                                fp, SAMPLING_STRUCTURE, self.nWindows)
                         else:
-                            samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
+                            samplingWindow = numpy.fromstring(
+                                fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
                     except Exception, e:
                         print "ProcessingHeader: " + str(e)
                     self.deltaHeight = float(samplingWindow['dh'][0])
                     self.samplesWin = samplingWindow['nsa'][0]
                     try:
                         if hasattr(fp, 'read'):
-                            self.spectraComb = numpy.fromfile(fp, 'u1', 2*self.totalSpectra)
+                            self.spectraComb = numpy.fromfile(
+                                fp, 'u1', 2 * self.totalSpectra)
                         else:
-                            self.spectraComb = numpy.fromstring(fp[self.length:], 'u1', 2*self.totalSpectra)
+                            self.spectraComb = numpy.fromstring(
+                                fp[self.length:], 'u1', 2 * self.totalSpectra)
                         self.length += self.spectraComb.nbytes
                     except Exception, e:
                         print "ProcessingHeader: " + str(e)
                     if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
                         self.nCode = int(numpy.fromfile(fp, '<u4', 1))
                         self.nBaud = int(numpy.fromfile(fp, '<u4', 1))
-                        self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nCode,self.nBaud)
+                        self.code = numpy.fromfile(
+                            fp, '<f4', self.nCode * self.nBaud).reshape(self.nCode, self.nBaud)
                     if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP):
                         exp_name_len = int(numpy.fromfile(fp, '<u4', 1))
                     if nPairs > 0:
                         self.flag_cspc = True
                     if startFp is not None:
                         endFp = size + startFp
                         if fp.tell() > endFp:
-                            sys.stderr.write("Warning: Processing header size is lower than it has to be")
+                            sys.stderr.write(
+                                "Warning: Processing header size is lower than it has to be")
                             return 0
                         if fp.tell() < endFp:
-                            sys.stderr.write("Warning: Processing header size is greater than it is considered")
+                            sys.stderr.write(
+                                "Warning: Processing header size is greater than it is considered")
                     return 1
                     header.tofile(fp)
                     if self.nWindows != 0:
-                        sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
+                        sampleWindowTuple = (
+                            self.firstHeight, self.deltaHeight, self.samplesWin)
                         samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE)
                         samplingWindow.tofile(fp)
                 size = property(get_size, set_size)
             class RCfunction:
                 NONE = 0
                 FLIP = 1
                 LIN6DIV256 = 4
                 SYNCHRO = 5
             class nCodeType:
                 NONE = 0
                 USERDEFINE = 1
                 COMPLEMENTARYCODE128 = 16
                 CODE_BINARY28 = 17
             class PROCFLAG:
                 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
                 DATAARRANGE_MASK = numpy.uint32(0x00007000)
                 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
             dtype0 = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
             dtype1 = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
             dtype2 = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
             DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
             def get_dtype_index(numpy_dtype):
                 index = None
                 return index
             def get_numpy_dtype(index):
                 return NUMPY_DTYPE_LIST[index]
             def get_procflag_dtype(index):
                 return PROCFLAG_DTYPE_LIST[index]
             def get_dtype_width(index):
                 return DTYPE_WIDTH[index]

schainpy/model/io/jroIO_digitalRF.py +18 -9

                     self.metadata_dict['flagDecodeData'] = self.dataOut.flagDecodeData
                     self.metadata_dict['flagDeflipData'] = self.dataOut.flagDeflipData
                     self.metadata_dict['flagShiftFFT'] = self.dataOut.flagShiftFFT
-                    self.metadata_dict['flagDataAsBlock'] = self.dataOut.flagDataAsBlock
                     self.metadata_dict['useLocalTime'] = self.dataOut.useLocalTime
                     self.metadata_dict['nCohInt'] = self.dataOut.nCohInt
+                    self.metadata_dict['type'] = self.dataOut.type
-                    return
+                    self.metadata_dict['flagDataAsBlock'] = getattr(
+                        self.dataOut, 'flagDataAsBlock', None)  # chequear
                 def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
                     '''
                         self.__dtype = dataOut.dtype[0]
                     self.__nSamples = dataOut.systemHeaderObj.nSamples
                     self.__nProfiles = dataOut.nProfiles
-                    self.__blocks_per_file = dataOut.processingHeaderObj.dataBlocksPerFile
-                    self.arr_data = arr_data = numpy.ones((self.__nSamples, len(
+                    if self.dataOut.type != 'Voltage':
+                        raise 'Digital RF cannot be used with this data type'
+                        self.arr_data = numpy.ones((1, dataOut.nFFTPoints * len(
+                            self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
+                    else:
+                        self.arr_data = numpy.ones((self.__nSamples, len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
                     file_cadence_millisecs = 1000
                                                                       fileCadence, start_global_index,
                                                                       sample_rate_numerator, sample_rate_denominator, uuid, compression_level, checksum,
                                                                       is_complex, num_subchannels, is_continuous, marching_periods)
                     metadata_dir = os.path.join(path, 'metadata')
                     os.system('mkdir %s' % (metadata_dir))
                     self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, dirCadence, 1,  # 236, file_cadence_millisecs / 1000
                                                                                     sample_rate_numerator, sample_rate_denominator,
                                                                                     metadataFile)
                     self.isConfig = True
                     self.currentSample = 0
                     self.oldAverage = 0
                     return
                 def writeMetadata(self):
-                    print '[Writing] - Writing metadata'
                     start_idx = self.__sample_rate * self.dataOut.utctime
                     self.metadata_dict['processingHeader'] = self.dataOut.processingHeaderObj.getAsDict(
                     return
                 def writeData(self):
+                    if self.dataOut.type != 'Voltage':
+                        raise 'Digital RF cannot be used with this data type'
+                        for channel in self.dataOut.channelList:
+                            for i in range(self.dataOut.nFFTPoints):
+                                self.arr_data[1][channel * self.dataOut.nFFTPoints +
+                                                 i]['r'] = self.dataOut.data[channel][i].real
+                                self.arr_data[1][channel * self.dataOut.nFFTPoints +
+                                                 i]['i'] = self.dataOut.data[channel][i].imag
+                    else:
                         for i in range(self.dataOut.systemHeaderObj.nSamples):
                             for channel in self.dataOut.channelList:
                                 self.arr_data[i][channel]['r'] = self.dataOut.data[channel][i].real

schainpy/model/proc/jroproc_spectra.py +101 -59

             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.data.jrodata import hildebrand_sekhon
             class SpectraProc(ProcessingUnit):
                 def __init__(self, **kwargs):
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
+                    try:
+                        self.dataOut.processingHeaderObj = self.dataIn.processingHeaderObj.copy()
+                    except:
+                        pass
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.firstdatatime
-                    self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
+                    # asumo q la data esta decodificada
-                    self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
+                    self.dataOut.flagDecodeData = self.dataIn.flagDecodeData
+                    # asumo q la data esta sin flip
+                    self.dataOut.flagDeflipData = self.dataIn.flagDeflipData
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                         self.buffer
                         self.dataOut.flagNoData
                     """
-                    fft_volt = numpy.fft.fft(self.buffer,n=self.dataOut.nFFTPoints,axis=1)
+                    fft_volt = numpy.fft.fft(
+                        self.buffer, n=self.dataOut.nFFTPoints, axis=1)
                     fft_volt = fft_volt.astype(numpy.dtype('complex'))
                     dc = fft_volt[:, 0, :]
                     pairIndex = 0
                     if self.dataOut.pairsList != None:
                         # calculo de cross-spectra
-                        cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
+                        cspc = numpy.zeros(
+                            (self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             if pair[0] not in self.dataOut.channelList:
-                                raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
+                                raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" % (
+                                    str(pair), str(self.dataOut.channelList))
                             if pair[1] not in self.dataOut.channelList:
-                                raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
+                                raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" % (
+                                    str(pair), str(self.dataOut.channelList))
-                            cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
+                            cspc[pairIndex, :, :] = fft_volt[pair[0], :, :] * \
+                                numpy.conjugate(fft_volt[pair[1], :, :])
                             pairIndex += 1
                         blocksize += cspc.size
                                     self.id_min = 0
                                     self.id_max = nVoltProfiles
-                                self.buffer[:,self.id_min:self.id_max,:] = self.dataIn.data
+                                self.buffer[:, self.id_min:self.id_max,
+                                            :] = self.dataIn.data
                                 self.profIndex += nVoltProfiles
                                 self.id_min += nVoltProfiles
                                 self.id_max += nVoltProfiles
                             else:
-                                raise ValueError, "The type object %s has %d profiles, it should just has %d profiles"%(self.dataIn.type,self.dataIn.data.shape[1],nProfiles)
+                                raise ValueError, "The type object %s has %d profiles, it should just has %d profiles" % (
+                                    self.dataIn.type, self.dataIn.data.shape[1], nProfiles)
                                 self.dataOut.flagNoData = True
                                 return 0
                         else:
                         return True
-                    raise ValueError, "The type of input object '%s' is not valid"%(self.dataIn.type)
+                    raise ValueError, "The type of input object '%s' is not valid" % (
+                        self.dataIn.type)
                 def __selectPairs(self, pairsList):
                         return
                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
-                    self.dataOut.pairsList = [self.dataOut.pairsList[i] for i in pairsIndexListSelected]
+                    self.dataOut.pairsList = [self.dataOut.pairsList[i]
+                                              for i in pairsIndexListSelected]
                     return
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
-                            raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList))
+                            raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" % (
+                                channel, str(self.dataOut.channelList))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList)
+                            raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " % (
+                                channelIndex, self.dataOut.channelIndexList)
             #         nChannels = len(channelIndexList)
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_dc = data_dc
-                    self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
+                    self.dataOut.channelList = [
+                        self.dataOut.channelList[i] for i in channelIndexList]
             #        self.dataOut.nChannels = nChannels
                     self.__selectPairsByChannel(self.dataOut.channelList)
                     """
                     if (minHei > maxHei):
-                        raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei)
+                        raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (
+                            minHei, maxHei)
                     if (minHei < self.dataOut.heightList[0]):
                         minHei = self.dataOut.heightList[0]
                     return 1
                 def getBeaconSignal(self, tauindex=0, channelindex=0, hei_ref=None):
-                    newheis = numpy.where(self.dataOut.heightList>self.dataOut.radarControllerHeaderObj.Taus[tauindex])
+                    newheis = numpy.where(
+                        self.dataOut.heightList > self.dataOut.radarControllerHeaderObj.Taus[tauindex])
                     if hei_ref != None:
                         newheis = numpy.where(self.dataOut.heightList > hei_ref)
                     heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
                     # determina indices
-                    nheis = int(self.dataOut.radarControllerHeaderObj.txB/(self.dataOut.heightList[1]-self.dataOut.heightList[0]))
+                    nheis = int(self.dataOut.radarControllerHeaderObj.txB /
-                    avg_dB = 10*numpy.log10(numpy.sum(data_spc[channelindex,:,:],axis=0))
+                                (self.dataOut.heightList[1] - self.dataOut.heightList[0]))
+                    avg_dB = 10 * \
+                        numpy.log10(numpy.sum(data_spc[channelindex, :, :], axis=0))
                     beacon_dB = numpy.sort(avg_dB)[-nheis:]
                     beacon_heiIndexList = []
                     for val in avg_dB.tolist():
                     return 1
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex)
+                        raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (
+                            minIndex, maxIndex)
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights - 1
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     if jcspectra is not None:
                         jcspectraExist = True
                         num_pairs = jcspectra.shape[0]
-                    else:   jcspectraExist = False
+                    else:
+                        jcspectraExist = False
                     freq_dc = jspectra.shape[1] / 2
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                         ind_vel[range(0, 1)] = ind_vel[range(0, 1)] + self.num_prof
                     if mode == 1:
-                        jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
+                        jspectra[:, freq_dc, :] = (
+                            jspectra[:, ind_vel[1], :] + jspectra[:, ind_vel[2], :]) / 2  # CORRECCION
                         if jcspectraExist:
-                            jcspectra[:,freq_dc,:] = (jcspectra[:,ind_vel[1],:] + jcspectra[:,ind_vel[2],:])/2
+                            jcspectra[:, freq_dc, :] = (
+                                jcspectra[:, ind_vel[1], :] + jcspectra[:, ind_vel[2], :]) / 2
                     if mode == 2:
                             cjunkid = sum(junkid)
                             if cjunkid.any():
-                                jspectra[ich,freq_dc,junkid.nonzero()] = (jspectra[ich,ind_vel[1],junkid] + jspectra[ich,ind_vel[2],junkid])/2
+                                jspectra[ich, freq_dc, junkid.nonzero()] = (
+                                    jspectra[ich, ind_vel[1], junkid] + jspectra[ich, ind_vel[2], junkid]) / 2
                         if jcspectraExist:
                             for ip in range(num_pairs):
                                 yy = jcspectra[ip, ind_vel, :]
                                 jcspectra[ip, freq_dc, :] = numpy.dot(xx_aux, yy)
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     num_mask_prof = mask_prof.size
                     comp_mask_prof = [0, num_prof / 2]
                     # noise_exist:    Determina si la variable jnoise ha sido definida y contiene la informacion del ruido de cada canal
                     if (jnoise.size < num_channel or numpy.isnan(jnoise).any()):
                         jnoise = numpy.nan
                         psort = power.ravel().argsort()
                         # Se estima la interferencia promedio en los Espectros de Potencia empleando
-                        junkspc_interf = jspectra[ich,:,hei_interf[psort[range(offhei_interf, nhei_interf + offhei_interf)]]]
+                        junkspc_interf = jspectra[ich, :, hei_interf[psort[range(
+                            offhei_interf, nhei_interf + offhei_interf)]]]
                         if noise_exist:
                             #    tmp_noise = jnoise[ich] / num_prof
                         jspc_interf = junkspc_interf.sum(axis=0) / nhei_interf
                         jspc_interf = jspc_interf.transpose()
                         # Calculando el espectro de interferencia promedio
-                        noiseid =  numpy.where(jspc_interf <= tmp_noise/ numpy.sqrt(num_incoh))
+                        noiseid = numpy.where(
+                            jspc_interf <= tmp_noise / numpy.sqrt(num_incoh))
                         noiseid = noiseid[0]
                         cnoiseid = noiseid.size
-                        interfid = numpy.where(jspc_interf > tmp_noise/ numpy.sqrt(num_incoh))
+                        interfid = numpy.where(
+                            jspc_interf > tmp_noise / numpy.sqrt(num_incoh))
                         interfid = interfid[0]
                         cinterfid = interfid.size
-                        if (cnoiseid > 0):   jspc_interf[noiseid] = 0
+                        if (cnoiseid > 0):
+                            jspc_interf[noiseid] = 0
                         # Expandiendo los perfiles a limpiar
                         if (cinterfid > 0):
-                            new_interfid = (numpy.r_[interfid - 1, interfid, interfid + 1] + num_prof)%num_prof
+                            new_interfid = (
+                                numpy.r_[interfid - 1, interfid, interfid + 1] + num_prof) % num_prof
                             new_interfid = numpy.asarray(new_interfid)
                             new_interfid = {x for x in new_interfid}
                             new_interfid = numpy.array(list(new_interfid))
                             new_cinterfid = new_interfid.size
-                        else: new_cinterfid = 0
+                        else:
+                            new_cinterfid = 0
                         for ip in range(new_cinterfid):
                             ind = junkspc_interf[:, new_interfid[ip]].ravel().argsort()
-                            jspc_interf[new_interfid[ip]] = junkspc_interf[ind[nhei_interf/2],new_interfid[ip]]
+                            jspc_interf[new_interfid[ip]
+                                        ] = junkspc_interf[ind[nhei_interf / 2], new_interfid[ip]]
-                        jspectra[ich,:,ind_hei] = jspectra[ich,:,ind_hei] - jspc_interf #Corregir indices
+                        jspectra[ich, :, ind_hei] = jspectra[ich, :,
+                                                             ind_hei] - jspc_interf  # Corregir indices
                         # Removiendo la interferencia del punto de mayor interferencia
                         ListAux = jspc_interf[mask_prof].tolist()
                         maxid = ListAux.index(max(ListAux))
                         if cinterfid > 0:
                             for ip in range(cinterfid * (interf == 2) - 1):
-                                ind = (jspectra[ich,interfid[ip],:] < tmp_noise*(1 + 1/numpy.sqrt(num_incoh))).nonzero()
+                                ind = (jspectra[ich, interfid[ip], :] < tmp_noise *
+                                       (1 + 1 / numpy.sqrt(num_incoh))).nonzero()
                                 cind = len(ind)
                                 if (cind > 0):
-                                    jspectra[ich,interfid[ip],ind] = tmp_noise*(1 + (numpy.random.uniform(cind) - 0.5)/numpy.sqrt(num_incoh))
+                                    jspectra[ich, interfid[ip], ind] = tmp_noise * \
+                                        (1 + (numpy.random.uniform(cind) - 0.5) /
+                                         numpy.sqrt(num_incoh))
                             ind = numpy.array([-2, -1, 1, 2])
                             xx = numpy.zeros([4, 4])
                             xx = xx_inv[:, 0]
                             ind = (ind + maxid + num_mask_prof) % num_mask_prof
                             yy = jspectra[ich, mask_prof[ind], :]
-                            jspectra[ich,mask_prof[maxid],:] = numpy.dot(yy.transpose(),xx)
+                            jspectra[ich, mask_prof[maxid], :] = numpy.dot(
+                                yy.transpose(), xx)
+                        indAux = (jspectra[ich, :, :] < tmp_noise *
-                        indAux = (jspectra[ich,:,:] < tmp_noise*(1-1/numpy.sqrt(num_incoh))).nonzero()
+                                  (1 - 1 / numpy.sqrt(num_incoh))).nonzero()
-                        jspectra[ich,indAux[0],indAux[1]] = tmp_noise * (1 - 1/numpy.sqrt(num_incoh))
+                        jspectra[ich, indAux[0], indAux[1]] = tmp_noise * \
+                            (1 - 1 / numpy.sqrt(num_incoh))
                     # Remocion de Interferencia en el Cross Spectra
-                    if jcspectra is None: return jspectra, jcspectra
+                    if jcspectra is None:
+                        return jspectra, jcspectra
                     num_pairs = jcspectra.size / (num_prof * num_hei)
                     jcspectra = jcspectra.reshape(num_pairs, num_prof, num_hei)
                         cspower = cspower.sum(axis=0)
                         cspsort = cspower.ravel().argsort()
-                        junkcspc_interf = jcspectra[ip,:,hei_interf[cspsort[range(offhei_interf, nhei_interf + offhei_interf)]]]
+                        junkcspc_interf = jcspectra[ip, :, hei_interf[cspsort[range(
+                            offhei_interf, nhei_interf + offhei_interf)]]]
                         junkcspc_interf = junkcspc_interf.transpose()
                         jcspc_interf = junkcspc_interf.sum(axis=1) / nhei_interf
                         ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
-                        median_real = numpy.median(numpy.real(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
+                        median_real = numpy.median(numpy.real(
-                        median_imag = numpy.median(numpy.imag(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
+                            junkcspc_interf[mask_prof[ind[range(3 * num_prof / 4)]], :]))
-                        junkcspc_interf[comp_mask_prof,:] = numpy.complex(median_real, median_imag)
+                        median_imag = numpy.median(numpy.imag(
+                            junkcspc_interf[mask_prof[ind[range(3 * num_prof / 4)]], :]))
+                        junkcspc_interf[comp_mask_prof, :] = numpy.complex(
+                            median_real, median_imag)
                         for iprof in range(num_prof):
                             ind = numpy.abs(junkcspc_interf[iprof, :]).ravel().argsort()
-                            jcspc_interf[iprof] = junkcspc_interf[iprof, ind[nhei_interf/2]]
+                            jcspc_interf[iprof] = junkcspc_interf[iprof,
+                                                                  ind[nhei_interf / 2]]
                         # Removiendo la Interferencia
-                        jcspectra[ip,:,ind_hei] = jcspectra[ip,:,ind_hei] - jcspc_interf
+                        jcspectra[ip, :, ind_hei] = jcspectra[ip,
+                                                              :, ind_hei] - jcspc_interf
                         ListAux = numpy.abs(jcspc_interf[mask_prof]).tolist()
                         maxid = ListAux.index(max(ListAux))
                         maxIndex = len(heights)
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
+                        raise ValueError, "some value in (%d,%d) is not valid" % (
+                            minIndex, maxIndex)
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights - 1
                         maxIndexVel = len(velrange)
                     # seleccion del espectro
-                    data_spc = self.dataOut.data_spc[:,minIndexVel:maxIndexVel+1,minIndex:maxIndex+1]
+                    data_spc = self.dataOut.data_spc[:,
+                                                     minIndexVel:maxIndexVel + 1, minIndex:maxIndex + 1]
                     # estimacion de ruido
                     noise = numpy.zeros(self.dataOut.nChannels)
                     return 1
-            class IncohInt(Operation):
+            class IncohInt(Operation):
                 __profIndex = 0
                 __withOverapping = False
                 n = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     if n is not None:
                         self.n = int(n)
                     else:
-                        self.__integrationtime = int(timeInterval) #if (type(timeInterval)!=integer) -> change this line
+                        # if (type(timeInterval)!=integer) -> change this line
+                        self.__integrationtime = int(timeInterval)
                         self.n = None
                         self.__byTime = True
                 def putData(self, data_spc, data_cspc, data_dc):
                     """
                     Add a profile to the __buffer_spc and increase in one the __profileIndex
                         self.__initime = datatime
                     if self.__byTime:
-                        avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
+                        avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(
+                            datatime, *args)
                     else:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages