schain-jc Commit - r1103:5c36aee43db5

digital rf fixes

José Chávez -

r1103:5c36aee43db5

parent child

Context file:

r1103:5c36aee43db5

Collapse all files

schainpy/model/io/jroIO_digitalRF.py +6 -5

             '''
             Created on Jul 3, 2014
             @author: roj-idl71
             '''
             # SUBCHANNELS EN VEZ DE CHANNELS
             # BENCHMARKS -> PROBLEMAS CON ARCHIVOS GRANDES -> INCONSTANTE EN EL TIEMPO
             # ACTUALIZACION DE VERSION
             # HEADERS
             # MODULO DE ESCRITURA
             # METADATA
             import os
             import datetime
             import numpy
             import timeit
             from fractions import Fraction
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
             from schainpy.model.data.jrodata import Voltage
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from time import time
             import cPickle
             try:
                 import digital_rf
             except:
                 print 'You should install "digital_rf" module if you want to read Digital RF data'
             class DigitalRFReader(ProcessingUnit):
                 '''
                 classdocs
                 '''
                 def __init__(self, **kwargs):
                     '''
                     Constructor
                     '''
                     ProcessingUnit.__init__(self, **kwargs)
                     self.dataOut = Voltage()
                     self.__printInfo = True
                     self.__flagDiscontinuousBlock = False
                     self.__bufferIndex = 9999999
                     self.__ippKm = None
                     self.__codeType = 0
                     self.__nCode = None
                     self.__nBaud = None
                     self.__code = None
                     self.dtype = None
+                    self.oldAverage = None
                 def close(self):
                     print 'Average of writing to digital rf format is ', self.oldAverage * 1000
                     return
                 def __getCurrentSecond(self):
                     return self.__thisUnixSample / self.__sample_rate
                 thisSecond = property(__getCurrentSecond, "I'm the 'thisSecond' property.")
                 def __setFileHeader(self):
                     '''
                     In this method will be initialized every parameter of dataOut object (header, no data)
                     '''
                     ippSeconds = 1.0 * self.__nSamples / self.__sample_rate
                     nProfiles = 1.0 / ippSeconds  # Number of profiles in one second
                     try:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             self.__radarControllerHeader)
                     except:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             txA=0,
                             txB=0,
                             nWindows=1,
                             nHeights=self.__nSamples,
                             firstHeight=self.__firstHeigth,
                             deltaHeight=self.__deltaHeigth,
                             codeType=self.__codeType,
                             nCode=self.__nCode, nBaud=self.__nBaud,
                             code=self.__code)
                     try:
                         self.dataOut.systemHeaderObj = SystemHeader(self.__systemHeader)
                     except:
                         self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
                                                                     nProfiles=nProfiles,
                                                                     nChannels=len(
                                                                         self.__channelList),
                                                                     adcResolution=14)
                     self.dataOut.type = "Voltage"
                     self.dataOut.data = None
                     self.dataOut.dtype = self.dtype
                     # self.dataOut.nChannels = 0
                     # self.dataOut.nHeights = 0
                     self.dataOut.nProfiles = int(nProfiles)
                     self.dataOut.heightList = self.__firstHeigth + \
                         numpy.arange(self.__nSamples, dtype=numpy.float) * \
                         self.__deltaHeigth
                     self.dataOut.channelList = range(self.__num_subchannels)
                     self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
                     # self.dataOut.channelIndexList = None
                     self.dataOut.flagNoData = True
                     self.dataOut.flagDataAsBlock = False
                     # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     self.dataOut.utctime = None
                     # timezone like jroheader, difference in minutes between UTC and localtime
                     self.dataOut.timeZone = self.__timezone / 60
                     self.dataOut.dstFlag = 0
                     self.dataOut.errorCount = 0
                     try:
                         self.dataOut.nCohInt = self.fixed_metadata_dict.get(
                             'nCohInt', self.nCohInt)
                         # asumo que la data esta decodificada
                         self.dataOut.flagDecodeData = self.fixed_metadata_dict.get(
                             'flagDecodeData', self.flagDecodeData)
                         # asumo que la data esta sin flip
                         self.dataOut.flagDeflipData = self.fixed_metadata_dict['flagDeflipData']
                         self.dataOut.flagShiftFFT = self.fixed_metadata_dict['flagShiftFFT']
                         self.dataOut.useLocalTime = self.fixed_metadata_dict['useLocalTime']
                     except:
                         pass
                     self.dataOut.ippSeconds = ippSeconds
                     # Time interval between profiles
                     # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency = self.__frequency
                     self.dataOut.realtime = self.__online
                 def findDatafiles(self, path, startDate=None, endDate=None):
                     if not os.path.isdir(path):
                         return []
                     try:
                         digitalReadObj = digital_rf.DigitalRFReader(
                             path, load_all_metadata=True)
                     except:
                         digitalReadObj = digital_rf.DigitalRFReader(path)
                     channelNameList = digitalReadObj.get_channels()
                     if not channelNameList:
                         return []
                     metadata_dict = digitalReadObj.get_rf_file_metadata(channelNameList[0])
                     sample_rate = metadata_dict['sample_rate'][0]
                     this_metadata_file = digitalReadObj.get_metadata(channelNameList[0])
                     try:
                         timezone = this_metadata_file['timezone'].value
                     except:
                         timezone = 0
                     startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(
                         channelNameList[0]) / sample_rate - timezone
                     startDatetime = datetime.datetime.utcfromtimestamp(startUTCSecond)
                     endDatatime = datetime.datetime.utcfromtimestamp(endUTCSecond)
                     if not startDate:
                         startDate = startDatetime.date()
                     if not endDate:
                         endDate = endDatatime.date()
                     dateList = []
                     thisDatetime = startDatetime
                     while(thisDatetime <= endDatatime):
                         thisDate = thisDatetime.date()
                         if thisDate < startDate:
                             continue
                         if thisDate > endDate:
                             break
                         dateList.append(thisDate)
                         thisDatetime += datetime.timedelta(1)
                     return dateList
                 def setup(self, path=None,
                           startDate=None,
                           endDate=None,
                           startTime=datetime.time(0, 0, 0),
                           endTime=datetime.time(23, 59, 59),
                           channelList=None,
                           nSamples=None,
                           online=False,
                           delay=60,
                           buffer_size=1024,
                           ippKm=None,
                           nCohInt=1,
                           nCode=1,
                           nBaud=1,
                           flagDecodeData=False,
                           code=numpy.ones((1, 1), dtype=numpy.int),
                           **kwargs):
                     '''
                     In this method we should set all initial parameters.
                     Inputs:
                         path
                         startDate
                         endDate
                         startTime
                         endTime
                         set
                         expLabel
                         ext
                         online
                         delay
                     '''
                     self.nCohInt = nCohInt
                     self.flagDecodeData = flagDecodeData
                     self.i = 0
                     if not os.path.isdir(path):
                         raise ValueError, "[Reading] Directory %s does not exist" % path
                     try:
                         self.digitalReadObj = digital_rf.DigitalRFReader(
                             path, load_all_metadata=True)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(path)
                     channelNameList = self.digitalReadObj.get_channels()
                     if not channelNameList:
                         raise ValueError, "[Reading] Directory %s does not have any files" % path
                     if not channelList:
                         channelList = range(len(channelNameList))
                     ##########  Reading metadata ######################
                     top_properties = self.digitalReadObj.get_properties(
                         channelNameList[channelList[0]])
                     self.__num_subchannels = top_properties['num_subchannels']
                     self.__sample_rate = 1.0 * \
                         top_properties['sample_rate_numerator'] / \
                         top_properties['sample_rate_denominator']
                     # self.__samples_per_file = top_properties['samples_per_file'][0]
                     self.__deltaHeigth = 1e6 * 0.15 / self.__sample_rate  # why 0.15?
                     this_metadata_file = self.digitalReadObj.get_digital_metadata(
                         channelNameList[channelList[0]])
                     metadata_bounds = this_metadata_file.get_bounds()
                     self.fixed_metadata_dict = this_metadata_file.read(
                         metadata_bounds[0])[metadata_bounds[0]]  # GET FIRST HEADER
                     try:
                         self.__processingHeader = self.fixed_metadata_dict['processingHeader']
                         self.__radarControllerHeader = self.fixed_metadata_dict['radarControllerHeader']
                         self.__systemHeader = self.fixed_metadata_dict['systemHeader']
                         self.dtype = cPickle.loads(self.fixed_metadata_dict['dtype'])
                     except:
                         pass
                     self.__frequency = None
                     self.__frequency = self.fixed_metadata_dict.get('frequency', 1)
                     self.__timezone = self.fixed_metadata_dict.get('timezone', 300)
                     try:
                         nSamples = self.fixed_metadata_dict['nSamples']
                     except:
                         nSamples = None
                     self.__firstHeigth = 0
                     try:
                         codeType = self.__radarControllerHeader['codeType']
                     except:
                         codeType = 0
                     try:
                         if codeType:
                             nCode = self.__radarControllerHeader['nCode']
                             nBaud = self.__radarControllerHeader['nBaud']
                             code = self.__radarControllerHeader['code']
                     except:
                         pass
                     if not ippKm:
                         try:
                             # seconds to km
                             ippKm = self.__radarControllerHeader['ipp']
                         except:
                             ippKm = None
                     ####################################################
                     self.__ippKm = ippKm
                     startUTCSecond = None
                     endUTCSecond = None
                     if startDate:
                         startDatetime = datetime.datetime.combine(startDate, startTime)
                         startUTCSecond = (
                             startDatetime - datetime.datetime(1970, 1, 1)).total_seconds() + self.__timezone
                     if endDate:
                         endDatetime = datetime.datetime.combine(endDate, endTime)
                         endUTCSecond = (endDatetime - datetime.datetime(1970,
 , 1)).total_seconds() + self.__timezone
                     start_index, end_index = self.digitalReadObj.get_bounds(
                         channelNameList[channelList[0]])
                     if not startUTCSecond:
                         startUTCSecond = start_index / self.__sample_rate
                     if start_index > startUTCSecond * self.__sample_rate:
                         startUTCSecond = start_index / self.__sample_rate
                     if not endUTCSecond:
                         endUTCSecond = end_index / self.__sample_rate
                     if end_index < endUTCSecond * self.__sample_rate:
                         endUTCSecond = end_index / self.__sample_rate
                     if not nSamples:
                         if not ippKm:
                             raise ValueError, "[Reading] nSamples or ippKm should be defined"
                         nSamples = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
                     channelBoundList = []
                     channelNameListFiltered = []
                     for thisIndexChannel in channelList:
                         thisChannelName = channelNameList[thisIndexChannel]
                         start_index, end_index = self.digitalReadObj.get_bounds(
                             thisChannelName)
                         channelBoundList.append((start_index, end_index))
                         channelNameListFiltered.append(thisChannelName)
                     self.profileIndex = 0
                     self.i = 0
                     self.__delay = delay
                     self.__codeType = codeType
                     self.__nCode = nCode
                     self.__nBaud = nBaud
                     self.__code = code
                     self.__datapath = path
                     self.__online = online
                     self.__channelList = channelList
                     self.__channelNameList = channelNameListFiltered
                     self.__channelBoundList = channelBoundList
                     self.__nSamples = nSamples
                     self.__samples_to_read = long(nSamples)  # FIJO: AHORA 40
                     self.__nChannels = len(self.__channelList)
                     self.__startUTCSecond = startUTCSecond
                     self.__endUTCSecond = endUTCSecond
                     self.__timeInterval = 1.0 * self.__samples_to_read / \
                         self.__sample_rate  # Time interval
                     if online:
                         # self.__thisUnixSample = int(endUTCSecond*self.__sample_rate - 4*self.__samples_to_read)
                         startUTCSecond = numpy.floor(endUTCSecond)
                     # por que en el otro metodo lo primero q se hace es sumar samplestoread
                     self.__thisUnixSample = long(
                         startUTCSecond * self.__sample_rate) - self.__samples_to_read
                     self.__data_buffer = numpy.zeros(
                         (self.__num_subchannels, self.__samples_to_read), dtype=numpy.complex)
                     self.__setFileHeader()
                     self.isConfig = True
                     print "[Reading] Digital RF Data was found from %s to %s " % (
                         datetime.datetime.utcfromtimestamp(
                             self.__startUTCSecond - self.__timezone),
                         datetime.datetime.utcfromtimestamp(
                             self.__endUTCSecond - self.__timezone)
                     )
                     print "[Reading] Starting process from %s to %s" % (datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
                                                                         datetime.datetime.utcfromtimestamp(
                         endUTCSecond - self.__timezone)
                     )
                     self.oldAverage = None
                     self.count = 0
                     self.executionTime = 0
                 def __reload(self):
                     #         print
                     #         print "%s not in range [%s, %s]" %(
                     #                                           datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
                     #                                           )
                     print "[Reading] reloading metadata ..."
                     try:
                         self.digitalReadObj.reload(complete_update=True)
                     except:
                         self.digitalReadObj.reload()
                     start_index, end_index = self.digitalReadObj.get_bounds(
                         self.__channelNameList[self.__channelList[0]])
                     if start_index > self.__startUTCSecond * self.__sample_rate:
                         self.__startUTCSecond = 1.0 * start_index / self.__sample_rate
                     if end_index > self.__endUTCSecond * self.__sample_rate:
                         self.__endUTCSecond = 1.0 * end_index / self.__sample_rate
                         print
                         print "[Reading] New timerange found [%s, %s] " % (
                             datetime.datetime.utcfromtimestamp(
                                 self.__startUTCSecond - self.__timezone),
                             datetime.datetime.utcfromtimestamp(
                                 self.__endUTCSecond - self.__timezone)
                         )
                         return True
                     return False
                 def timeit(self, toExecute):
                     t0 = time()
                     toExecute()
                     self.executionTime = time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
                     self.oldAverage = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
                     self.count = self.count + 1.0
                     return
                 def __readNextBlock(self, seconds=30, volt_scale=1):
                     '''
                     '''
                     # Set the next data
                     self.__flagDiscontinuousBlock = False
                     self.__thisUnixSample += self.__samples_to_read
                     if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                         print "[Reading] There are no more data into selected time-range"
                         if self.__online:
                             self.__reload()
                         else:
                             return False
                         if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                             return False
                             self.__thisUnixSample -= self.__samples_to_read
                     indexChannel = 0
                     dataOk = False
                     for thisChannelName in self.__channelNameList:  # TODO VARIOS CHANNELS?
                         for indexSubchannel in range(self.__num_subchannels):
                             try:
                                 t0 = time()
                                 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
                                                                               self.__samples_to_read,
                                                                               thisChannelName, sub_channel=indexSubchannel)
                                 self.executionTime = time() - t0
                                 if self.oldAverage is None:
                                     self.oldAverage = self.executionTime
                                 self.oldAverage = (
                                     self.executionTime + self.count * self.oldAverage) / (self.count + 1.0)
                                 self.count = self.count + 1.0
                             except IOError, e:
                                 # read next profile
                                 self.__flagDiscontinuousBlock = True
                                 print "[Reading] %s" % datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e
                                 break
                             if result.shape[0] != self.__samples_to_read:
                                 self.__flagDiscontinuousBlock = True
                                 print "[Reading] %s: Too few samples were found, just %d/%d  samples" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                                                          result.shape[0],
                                                                                                          self.__samples_to_read)
                                 break
                             self.__data_buffer[indexSubchannel, :] = result * volt_scale
                             indexChannel += 1
                             dataOk = True
                     self.__utctime = self.__thisUnixSample / self.__sample_rate
                     if not dataOk:
                         return False
                     print "[Reading] %s: %d samples <> %f sec" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                   self.__samples_to_read,
                                                                   self.__timeInterval)
                     self.__bufferIndex = 0
                     return True
                 def __isBufferEmpty(self):
                     return self.__bufferIndex > self.__samples_to_read - self.__nSamples  # 40960 - 40
                 def getData(self, seconds=30, nTries=5):
                     '''
                         This method gets the data from files and put the data into the dataOut object
                         In addition, increase el the buffer counter in one.
                         Return:
                             data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                         buffer. Si no hay mas archivos a leer retorna None.
                         Affected:
                             self.dataOut
                             self.profileIndex
                             self.flagDiscontinuousBlock
                             self.flagIsNewBlock
                     '''
                     err_counter = 0
                     self.dataOut.flagNoData = True
                     if self.__isBufferEmpty():
                         self.__flagDiscontinuousBlock = False
                         while True:
                             if self.__readNextBlock():
                                 break
                             if self.__thisUnixSample > self.__endUTCSecond * self.__sample_rate:
                                 return False
                             if self.__flagDiscontinuousBlock:
                                 print '[Reading] discontinuous block found ... continue with the next block'
                                 continue
                             if not self.__online:
                                 return False
                             err_counter += 1
                             if err_counter > nTries:
                                 return False
                             print '[Reading] waiting %d seconds to read a new block' % seconds
                             sleep(seconds)
                     self.dataOut.data = self.__data_buffer[:,
                                                            self.__bufferIndex:self.__bufferIndex + self.__nSamples]
                     self.dataOut.utctime = (
                         self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
                     self.dataOut.flagNoData = False
                     self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
                     self.dataOut.profileIndex = self.profileIndex
                     self.__bufferIndex += self.__nSamples
                     self.profileIndex += 1
                     if self.profileIndex == self.dataOut.nProfiles:
                         self.profileIndex = 0
                     return True
                 def printInfo(self):
                     '''
                     '''
                     if self.__printInfo == False:
                         return
                     # self.systemHeaderObj.printInfo()
                     # self.radarControllerHeaderObj.printInfo()
                     self.__printInfo = False
                 def printNumberOfBlock(self):
                     '''
                     '''
                     return
                     # print self.profileIndex
                 def run(self, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                     #self.i = self.i+1
                     self.getData(seconds=self.__delay)
                     return
             class DigitalRFWriter(Operation):
                 '''
                 classdocs
                 '''
                 def __init__(self, **kwargs):
                     '''
                     Constructor
                     '''
                     Operation.__init__(self, **kwargs)
                     self.metadata_dict = {}
                     self.dataOut = None
                     self.dtype = None
+                    self.oldAverage = 0
                 def setHeader(self):
                     self.metadata_dict['frequency'] = self.dataOut.frequency
                     self.metadata_dict['timezone'] = self.dataOut.timeZone
                     self.metadata_dict['dtype'] = cPickle.dumps(self.dataOut.dtype)
                     self.metadata_dict['nProfiles'] = self.dataOut.nProfiles
                     self.metadata_dict['heightList'] = self.dataOut.heightList
                     self.metadata_dict['channelList'] = self.dataOut.channelList
                     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
                     return
                 def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
                     '''
                     In this method we should set all initial parameters.
                     Input:
                         dataOut: Input data will also be outputa data
                     '''
                     self.setHeader()
                     self.__ippSeconds = dataOut.ippSeconds
                     self.__deltaH = dataOut.getDeltaH()
                     self.__sample_rate = 1e6 * 0.15 / self.__deltaH
                     self.__dtype = dataOut.dtype
                     if len(dataOut.dtype) == 2:
                         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(
                         self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
-                    file_cadence_millisecs = long(
+                    file_cadence_millisecs = 1000
-.0 * self.__blocks_per_file * self.__nProfiles * self.__nSamples / self.__sample_rate) * 1000
-                    sub_cadence_secs = file_cadence_millisecs / 500
                     sample_rate_fraction = Fraction(self.__sample_rate).limit_denominator()
                     sample_rate_numerator = long(sample_rate_fraction.numerator)
                     sample_rate_denominator = long(sample_rate_fraction.denominator)
                     start_global_index = dataOut.utctime * self.__sample_rate
                     uuid = 'prueba'
-                    compression_level = 1
+                    compression_level = 0
                     checksum = False
                     is_complex = True
                     num_subchannels = len(dataOut.channelList)
                     is_continuous = True
                     marching_periods = False
                     self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, dirCadence,
                                                                       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
                     self.count = 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(
                     )
                     self.metadata_dict['radarControllerHeader'] = self.dataOut.radarControllerHeaderObj.getAsDict(
                     )
                     self.metadata_dict['systemHeader'] = self.dataOut.systemHeaderObj.getAsDict(
                     )
                     self.digitalMetadataWriteObj.write(start_idx, self.metadata_dict)
                     return
                 def timeit(self, toExecute):
                     t0 = time()
                     toExecute()
                     self.executionTime = time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
                     self.oldAverage = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
                     self.count = self.count + 1.0
                     return
                 def writeData(self):
                     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
                             self.arr_data[i][channel]['i'] = self.dataOut.data[channel][i].imag
                     def f(): return self.digitalWriteObj.rf_write(self.arr_data)
                     self.timeit(f)
                     return
-                def run(self, dataOut, frequency=49.92e6, path=None, fileCadence=100, dirCadence=25, metadataCadence=1, **kwargs):
+                def run(self, dataOut, frequency=49.92e6, path=None, fileCadence=1000, dirCadence=36000, metadataCadence=1, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     Inputs:
                         dataOut: object with the data
                     '''
                     # print dataOut.__dict__
                     self.dataOut = dataOut
                     if not self.isConfig:
                         self.setup(dataOut, path, frequency, fileCadence,
                                    dirCadence, metadataCadence, **kwargs)
                         self.writeMetadata()
                     self.writeData()
                     ## self.currentSample += 1
                     # if self.dataOut.flagDataAsBlock or self.currentSample == 1:
                     # self.writeMetadata()
                     ## if self.currentSample == self.__nProfiles: self.currentSample = 0
                 def close(self):
                     print '[Writing] - Closing files '
                     print 'Average of writing to digital rf format is ', self.oldAverage * 1000
                     try:
                         self.digitalWriteObj.close()
                     except:
                         pass
                     # raise
             if __name__ == '__main__':
                 readObj = DigitalRFReader()
                 while True:
                     readObj.run(path='/home/jchavez/jicamarca/mocked_data/')
                     # readObj.printInfo()
                     # readObj.printNumberOfBlock()

schainpy/model/io/jroIO_voltage.py +2 0

             '''
             Created on Jul 2, 2014
             @author: roj-idl71
             '''
             import numpy
             from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jrodata import Voltage
             import zmq
             import tempfile
             from StringIO import StringIO
             # from _sha import blocksize
             class VoltageReader(JRODataReader, ProcessingUnit):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 ext = ".r"
                 optchar = "D"
                 dataOut = None
                 def __init__(self, **kwargs):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         dataOut    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
                         self.dataOut
                     Return:
                         None
                     """
                     ProcessingUnit.__init__(self, **kwargs)
                     self.isConfig = False
                     self.datablock = None
                     self.utc = 0
                     self.ext = ".r"
                     self.optchar = "D"
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.filenameList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.profileIndex = 2**32 - 1
                     self.delay = 3  # seconds
                     self.nTries = 3  # quantity tries
                     self.nFiles = 3  # number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.__isFirstTimeOnline = 1
             #         self.ippSeconds = 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                     self.dataOut = self.createObjByDefault()
                     self.nTxs = 1
                     self.txIndex = 0
                 def createObjByDefault(self):
                     dataObj = Voltage()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock * self.nTxs:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                         Obtiene la cantidad de puntos a leer por cada bloque de datos
                         Affected:
                             self.blocksize
                         Return:
                             None
                     """
                     pts2read = self.processingHeaderObj.profilesPerBlock * \
                         self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                         readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                         (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                         (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                         es seteado a 0
                         Inputs:
                             None
                         Return:
                             None
                         Affected:
                             self.profileIndex
                             self.datablock
                             self.flagIsNewFile
                             self.flagIsNewBlock
                             self.nTotalBlocks
                         Exceptions:
                             Si un bloque leido no es un bloque valido
                     """
                     # if self.server is not None:
                     #     self.zBlock = self.receiver.recv()
                     #     self.zHeader = self.zBlock[:24]
                     #     self.zDataBlock = self.zBlock[24:]
                     #     junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')]))
                     #     self.processingHeaderObj.profilesPerBlock = 240
                     #     self.processingHeaderObj.nHeights = 248
                     #     self.systemHeaderObj.nChannels
                     # else:
                     current_pointer_location = self.fp.tell()
                     junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
                     try:
                         junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
                                              self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     except:
                         # print "The read block (%3d) has not enough data" %self.nReadBlocks
                         if self.waitDataBlock(pointer_location=current_pointer_location):
                             junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
                             junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
                                                  self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     #             return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     junk = numpy.transpose(junk, (2, 0, 1))
                     self.datablock = junk['real'] + junk['imag'] * 1j
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getFirstHeader(self):
                     self.getBasicHeader()
+                    self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     if self.nTxs > 1:
                         self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                     # Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj.
                     #         self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt
                     #
                     #         if self.radarControllerHeaderObj.code is not None:
                     #
                     #             self.dataOut.nCode = self.radarControllerHeaderObj.nCode
                     #
                     #             self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
                     #
                     #             self.dataOut.code = self.radarControllerHeaderObj.code
                     self.dataOut.dtype = self.dtype
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.heightList = numpy.arange(
                         self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                     # asumo q la data no esta decodificada
                     self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode
                     # asumo q la data no esta sin flip
                     self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip
                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
                 def reshapeData(self):
                     if self.nTxs < 0:
                         return
                     if self.nTxs == 1:
                         return
                     if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1. / self.nTxs) != 0:
                         raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" % (
 . / self.nTxs, self.processingHeaderObj.profilesPerBlock)
                     if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
                         raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" % (
                             self.nTxs, self.processingHeaderObj.nHeights)
                     self.datablock = self.datablock.reshape(
                         (self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock * self.nTxs, self.processingHeaderObj.nHeights / self.nTxs))
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock * self.nTxs
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights / self.nTxs) * \
                         self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                     return
                 def readFirstHeaderFromServer(self):
                     self.getFirstHeader()
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
                                                PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
                         raise ValueError, 'Data type was not defined'
                     self.dtype = datatype_str
                     #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
                         self.firstHeaderSize + self.basicHeaderSize * \
                         (self.processingHeaderObj.dataBlocksPerFile - 1)
                     #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
                     #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def getFromServer(self):
                     self.flagDiscontinuousBlock = 0
                     self.profileIndex = 0
                     self.flagIsNewBlock = 1
                     self.dataOut.flagNoData = False
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     self.blockPointer = 0
                     block = self.receiver.recv()
                     self.basicHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.basicHeaderObj.length
                     self.systemHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.systemHeaderObj.length
                     self.radarControllerHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.radarControllerHeaderObj.length
                     self.processingHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.processingHeaderObj.length
                     self.readFirstHeaderFromServer()
                     timestamp = self.basicHeaderObj.get_datatime()
                     print '[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp)
                     current_pointer_location = self.blockPointer
                     junk = numpy.fromstring(
                         block[self.blockPointer:], self.dtype, self.blocksize)
                     try:
                         junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
                                              self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     except:
                         # print "The read block (%3d) has not enough data" %self.nReadBlocks
                         if self.waitDataBlock(pointer_location=current_pointer_location):
                             junk = numpy.fromstring(
                                 block[self.blockPointer:], self.dtype, self.blocksize)
                             junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
                                                  self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     #               return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     junk = numpy.transpose(junk, (2, 0, 1))
                     self.datablock = junk['real'] + junk['imag'] * 1j
                     self.profileIndex = 0
                     if self.selBlocksize == None:
                         self.selBlocksize = self.dataOut.nProfiles
                     if self.selBlocktime != None:
                         if self.dataOut.nCohInt is not None:
                             nCohInt = self.dataOut.nCohInt
                         else:
                             nCohInt = 1
                         self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / (
                             nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles)))
                     self.dataOut.data = self.datablock[:,
                                                        self.profileIndex:self.profileIndex + self.selBlocksize, :]
                     datasize = self.dataOut.data.shape[1]
                     if datasize < self.selBlocksize:
                         buffer = numpy.zeros(
                             (self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex')
                         buffer[:, :datasize, :] = self.dataOut.data
                         self.dataOut.data = buffer
                         self.profileIndex = blockIndex
                     self.dataOut.flagDataAsBlock = True
                     self.flagIsNewBlock = 1
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
                 def getData(self):
                     """
                         getData obtiene una unidad de datos del buffer de lectura, un perfil,  y la copia al objeto self.dataOut
                         del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos
                         en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando
                         "readNextBlock"
                         Ademas incrementa el contador del buffer "self.profileIndex" en 1.
                         Return:
                             Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex
                             es igual al total de perfiles leidos desde el archivo.
                             Si self.getByBlock == False:
                                 self.dataOut.data = buffer[:, thisProfile, :]
                                 shape = [nChannels, nHeis]
                             Si self.getByBlock == True:
                                 self.dataOut.data = buffer[:, :, :]
                                 shape = [nChannels, nProfiles, nHeis]
                         Variables afectadas:
                             self.dataOut
                             self.profileIndex
                         Affected:
                             self.dataOut
                             self.profileIndex
                             self.flagDiscontinuousBlock
                             self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         print 'Process finished'
                         return 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not(self.readNextBlock()):
                             return 0
                         self.getFirstHeader()
                         self.reshapeData()
                     if self.datablock is None:
                         self.dataOut.flagNoData = True
                         return 0
                     if not self.getByBlock:
                         """
                             Return profile by profile
                             If nTxs > 1 then one profile is divided by nTxs and number of total
                             blocks is increased by nTxs (nProfiles *= nTxs)
                         """
                         self.dataOut.flagDataAsBlock = False
                         self.dataOut.data = self.datablock[:, self.profileIndex, :]
                         self.dataOut.profileIndex = self.profileIndex
                         self.profileIndex += 1
                         #         elif self.selBlocksize==None or self.selBlocksize==self.dataOut.nProfiles:
                         #             """
                         #             Return all block
                         #             """
                         #             self.dataOut.flagDataAsBlock = True
                         #             self.dataOut.data = self.datablock
                         #             self.dataOut.profileIndex = self.dataOut.nProfiles - 1
                         #
                         #             self.profileIndex = self.dataOut.nProfiles
                     else:
                         """
                             Return a block
                         """
                         if self.selBlocksize == None:
                             self.selBlocksize = self.dataOut.nProfiles
                         if self.selBlocktime != None:
                             if self.dataOut.nCohInt is not None:
                                 nCohInt = self.dataOut.nCohInt
                             else:
                                 nCohInt = 1
                             self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / (
                                 nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles)))
                         self.dataOut.data = self.datablock[:,
                                                            self.profileIndex:self.profileIndex + self.selBlocksize, :]
                         self.profileIndex += self.selBlocksize
                         datasize = self.dataOut.data.shape[1]
                         if datasize < self.selBlocksize:
                             buffer = numpy.zeros(
                                 (self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex')
                             buffer[:, :datasize, :] = self.dataOut.data
                             while datasize < self.selBlocksize:  # Not enough profiles to fill the block
                                 if not(self.readNextBlock()):
                                     return 0
                                 self.getFirstHeader()
                                 self.reshapeData()
                                 if self.datablock is None:
                                     self.dataOut.flagNoData = True
                                     return 0
                                 # stack data
                                 blockIndex = self.selBlocksize - datasize
                                 datablock1 = self.datablock[:, :blockIndex, :]
                                 buffer[:, datasize:datasize +
                                        datablock1.shape[1], :] = datablock1
                                 datasize += datablock1.shape[1]
                             self.dataOut.data = buffer
                             self.profileIndex = blockIndex
                         self.dataOut.flagDataAsBlock = True
                         self.dataOut.nProfiles = self.dataOut.data.shape[1]
                     self.dataOut.flagNoData = False
                     self.getBasicHeader()
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
             class VoltageWriter(JRODataWriter, Operation):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".r"
                 optchar = "D"
                 shapeBuffer = None
                 def __init__(self, **kwargs):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                     Return: None
                     """
                     Operation.__init__(self, **kwargs)
                     self.nTotalBlocks = 0
                     self.profileIndex = 0
                     self.isConfig = False
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.blockIndex = 0
                     self.flagIsNewBlock = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.filename = None
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
                                         self.processingHeaderObj.nHeights,
                                         self.systemHeaderObj.nChannels)
                     self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
                                                   self.processingHeaderObj.profilesPerBlock,
                                                   self.processingHeaderObj.nHeights),
                                                  dtype=numpy.dtype('complex64'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.blockIndex
                     Return: None
                     """
                     data = numpy.zeros(self.shapeBuffer, self.dtype)
                     junk = numpy.transpose(self.datablock, (1, 2, 0))
                     data['real'] = junk.real
                     data['imag'] = junk.imag
                     data = data.reshape((-1))
                     data.tofile(self.fp)
                     self.datablock.fill(0)
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
             #         print "[Writing] Block = %04d" %self.blockIndex
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.profileIndex
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagDiscontinuousBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
                     if self.profileIndex == 0:
                         self.setBasicHeader()
                     self.datablock[:, self.profileIndex, :] = self.dataOut.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         # if self.flagIsNewFile:
                         self.writeNextBlock()
             #            self.setFirstHeader()
                     return 1
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
                     '''
                     dtype_width = self.getDtypeWidth()
                     blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels *
                                     self.profilesPerBlock * dtype_width * 2)
                     return blocksize
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.processingHeaderObj.dtype = 0  # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     # podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.nWindows = 1
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
                     # Cuando la data de origen es de tipo Voltage
                     self.processingHeaderObj.nIncohInt = 1
                     # Cuando la data de origen es de tipo Voltage
                     self.processingHeaderObj.totalSpectra = 0
                     if self.dataOut.code is not None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - \
                             self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                     self.processingHeaderObj.processFlags = self.getProcessFlags()
                     self.setBasicHeader()

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