schain-jc Commit - r1092:57cb558a168b

formatting, template actualizado, decimation a 300

José Chávez -

r1092:57cb558a168b

parent child

Context file:

r1092:57cb558a168b

Collapse all files

schaincli/templates.py +1 -1

             rti.addParameter(name='exp_code', value='22', format='int')
-            controller.start()
+            project.start()
             '''
             multiprocess = '''from schainpy.controller import Project, MPProject

schainpy/model/data/jrodata.py +46 -22

                 return numpyDtype
             def getDataTypeCode(numpyDtype):
                 if numpyDtype == numpy.dtype([('real', '<i1'), ('imag', '<i1')]):
                 return datatype
             def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of the noise level in Doppler spectra. This
                     self.azimuthList = []
                     self.zenithList = []
             class GenericData(object):
                 flagNoData = True
                     return self.flagNoData
             class JROData(GenericData):
                 #    m_BasicHeader = BasicHeader()
                     return
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
-                channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
+                channelIndexList = property(
+                    getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 #noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nCode = property(get_ncode, set_ncode)
                 nBaud = property(get_nbaud, set_nbaud)
             class Voltage(JROData):
                 # data es un numpy array de 2 dmensiones (canales, alturas)
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Spectra(JROData):
                 # data spc es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                     self.noise_estimation = None
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
-                        daux = self.data_spc[channel,xmin_index:xmax_index,ymin_index:ymax_index]
+                        daux = self.data_spc[channel,
+                                             xmin_index:xmax_index, ymin_index:ymax_index]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation is not None:
-                        return self.noise_estimation #this was estimated by getNoise Operation defined in jroproc_spectra.py
+                        # this was estimated by getNoise Operation defined in jroproc_spectra.py
+                        return self.noise_estimation
                     else:
-                        noise = self.getNoisebyHildebrand(xmin_index, xmax_index, ymin_index, ymax_index)
+                        noise = self.getNoisebyHildebrand(
+                            xmin_index, xmax_index, ymin_index, ymax_index)
                         return noise
                 def getFreqRangeTimeResponse(self, extrapoints=0):
                     deltafreq = self.getFmaxTimeResponse() / (self.nFFTPoints * self.ippFactor)
-                    freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
+                    freqrange = deltafreq * \
+                        (numpy.arange(self.nFFTPoints + extrapoints) -
+                         self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getAcfRange(self, extrapoints=0):
                     deltafreq = 10. / (self.getFmax() / (self.nFFTPoints * self.ippFactor))
-                    freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
+                    freqrange = deltafreq * \
+                        (numpy.arange(self.nFFTPoints + extrapoints) -
+                         self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints * self.ippFactor)
-                    freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
+                    freqrange = deltafreq * \
+                        (numpy.arange(self.nFFTPoints + extrapoints) -
+                         self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints * self.ippFactor)
-                    velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) #- deltav/2
+                    velrange = deltav * (numpy.arange(self.nFFTPoints +
+                                                      extrapoints) - self.nFFTPoints / 2.)  # - deltav/2
                     return velrange
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
-                    normFactor = self.nProfiles*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
+                    normFactor = self.nProfiles * self.nIncohInt * \
+                        self.nCohInt * pwcode * self.windowOfFilter
                     return normFactor
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in self.pairsList:
-                                raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
+                                raise ValueError, "Pair %s is not in dataOut.pairsList" % (
+                                    pair)
                             pairsIndexList.append(self.pairsList.index(pair))
                     for i in range(len(pairsIndexList)):
                         pair = self.pairsList[pairsIndexList[i]]
-                        ccf = numpy.average(self.data_cspc[pairsIndexList[i], :, :], axis=0)
+                        ccf = numpy.average(
+                            self.data_cspc[pairsIndexList[i], :, :], axis=0)
                         powa = numpy.average(self.data_spc[pair[0], :, :], axis=0)
                         powb = numpy.average(self.data_spc[pair[1], :, :], axis=0)
                         avgcoherenceComplex = ccf / numpy.sqrt(powa * powb)
                     return
                 nPairs = property(getNPairs, setValue, "I'm the 'nPairs' property.")
-                pairsIndexList = property(getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
+                pairsIndexList = property(
-                normFactor = property(getNormFactor, setValue, "I'm the 'getNormFactor' property.")
+                    getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
+                normFactor = property(getNormFactor, setValue,
+                                      "I'm the 'getNormFactor' property.")
                 flag_cspc = property(getFlagCspc, setValue)
                 flag_dc = property(getFlagDc, setValue)
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
-                timeInterval = property(getTimeInterval, setValue, "I'm the 'timeInterval' property")
+                timeInterval = property(getTimeInterval, setValue,
+                                        "I'm the 'timeInterval' property")
             class SpectraHeis(Spectra):
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Fits(JROData):
                 heightList = None
                 realtime = False
                 def __init__(self):
                     self.type = "Fits"
             #         self.comments = ''
             #
                 def getltctime(self):
                     if self.useLocalTime:
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
-                channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
+                channelIndexList = property(
+                    getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 nAvg = None
                 def __init__(self):
                     '''
                     Constructor
                         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 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
                     noise = jspectra0[:, freq_dc, :] - jspectra[:, freq_dc, :]
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 normFactor = property(getNormFactor, "I'm the 'normFactor property'")
             class Parameters(Spectra):
                 experimentInfo = None  # Information about the experiment
                 GauSPC = None  # Fit gaussian SPC
                 def __init__(self):
                     '''
                     Constructor

schainpy/model/io/jroIO_digitalRF.py +101 -62

             import datetime
             import numpy
             import timeit
-            from profilehooks import coverage, profile
             from fractions import Fraction
             try:
             except:
                 print 'You should install "digital_rf" module if you want to read Digital RF data'
             class DigitalRFReader(ProcessingUnit):
                 '''
                 classdocs
                     nProfiles = 1.0 / ippSeconds  # Number of profiles in one second
                     try:
-                        self.dataOut.radarControllerHeaderObj = RadarControllerHeader(self.__radarControllerHeader)
+                        self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
+                            self.__radarControllerHeader)
                     except:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             txA=0,
                     except:
                         self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
                                                                     nProfiles=nProfiles,
-                                                                    nChannels=len(self.__channelList),
+                                                                    nChannels=len(
+                                                                        self.__channelList),
                                                                     adcResolution=14)
                     self.dataOut.type = "Voltage"
                     self.dataOut.nProfiles = int(nProfiles)
-                    self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
+                    self.dataOut.heightList = self.__firstHeigth + \
+                        numpy.arange(self.__nSamples, dtype=numpy.float) * \
+                        self.__deltaHeigth
                     self.dataOut.channelList = range(self.__num_subchannels)
                     self.dataOut.utctime = None
-                    self.dataOut.timeZone = self.__timezone/60  # timezone like jroheader, difference in minutes between UTC and localtime
+                    # 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', 1)
+                        self.dataOut.nCohInt = self.fixed_metadata_dict.get(
+                            'nCohInt', self.nCohInt)
-                        self.dataOut.flagDecodeData = self.fixed_metadata_dict['flagDecodeData'] # asumo que la data esta decodificada
+                        # asumo que la data esta decodificada
+                        self.dataOut.flagDecodeData = self.fixed_metadata_dict.get(
+                            'flagDecodeData', self.flagDecodeData)
-                        self.dataOut.flagDeflipData = self.fixed_metadata_dict['flagDeflipData'] # asumo que la data esta sin flip
+                        # asumo que la data esta sin flip
+                        self.dataOut.flagDeflipData = self.fixed_metadata_dict['flagDeflipData']
                         self.dataOut.flagShiftFFT = self.fixed_metadata_dict['flagShiftFFT']
                     except:
                         pass
                     self.dataOut.ippSeconds = ippSeconds
                     # Time interval between profiles
                         return []
                     try:
-                        digitalReadObj = digital_rf.DigitalRFReader(path, load_all_metadata=True)
+                        digitalReadObj = digital_rf.DigitalRFReader(
+                            path, load_all_metadata=True)
                     except:
                         digitalReadObj = digital_rf.DigitalRFReader(path)
                     except:
                         timezone = 0
-                    startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(channelNameList[0])/sample_rate - timezone
+                    startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(
+                        channelNameList[0]) / sample_rate - timezone
                     startDatetime = datetime.datetime.utcfromtimestamp(startUTCSecond)
                     endDatatime = datetime.datetime.utcfromtimestamp(endUTCSecond)
                           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.
                         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)
+                        self.digitalReadObj = digital_rf.DigitalRFReader(
+                            path, load_all_metadata=True)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(path)
                     if not channelList:
                         channelList = range(len(channelNameList))
                     ##########  Reading metadata ######################
-                    top_properties = self.digitalReadObj.get_properties(channelNameList[channelList[0]])
+                    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.__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?
+                    self.__deltaHeigth = 1e6 * 0.15 / self.__sample_rate  # why 0.15?
-                    this_metadata_file = self.digitalReadObj.get_digital_metadata(channelNameList[channelList[0]])
+                    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
+                    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']
                     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:
                     except:
                         codeType = 0
-                    nCode = 1
-                    nBaud = 1
-                    code = numpy.ones((nCode, nBaud), dtype=numpy.int)
                     try:
                         if codeType:
                             nCode = self.__radarControllerHeader['nCode']
                     except:
                         pass
                     if not ippKm:
                         try:
                             # seconds to km
                     if startDate:
                         startDatetime = datetime.datetime.combine(startDate, startTime)
-                        startUTCSecond = (startDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
+                        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,1)).total_seconds() + self.__timezone
+                        endUTCSecond = (endDatetime - datetime.datetime(1970,
+, 1)).total_seconds() + self.__timezone
-                    start_index, end_index = self.digitalReadObj.get_bounds(channelNameList[channelList[0]])
+                    start_index, end_index = self.digitalReadObj.get_bounds(
+                        channelNameList[channelList[0]])
                     if not startUTCSecond:
                         startUTCSecond = start_index / self.__sample_rate
                     for thisIndexChannel in channelList:
                         thisChannelName = channelNameList[thisIndexChannel]
-                        start_index, end_index = self.digitalReadObj.get_bounds(thisChannelName)
+                        start_index, end_index = self.digitalReadObj.get_bounds(
+                            thisChannelName)
                         channelBoundList.append((start_index, end_index))
                         channelNameListFiltered.append(thisChannelName)
                     self.__startUTCSecond = startUTCSecond
                     self.__endUTCSecond = endUTCSecond
-                    self.__timeInterval = 1.0 * self.__samples_to_read/self.__sample_rate # Time interval
+                    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)
-                    self.__thisUnixSample = long(startUTCSecond*self.__sample_rate) - self.__samples_to_read ## por que en el otro metodo lo primero q se hace es sumar samplestoread
+                    # 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.__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(
-                                                                  datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
+                            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)
+                                                                        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]" %(
                     except:
                         self.digitalReadObj.reload()
-                    start_index, end_index = self.digitalReadObj.get_bounds(self.__channelNameList[self.__channelList[0]])
+                    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
                         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(
-                                                                  datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
+                                self.__startUTCSecond - self.__timezone),
+                            datetime.datetime.utcfromtimestamp(
+                                self.__endUTCSecond - self.__timezone)
                         )
                         return True
                     t0 = time()
                     toExecute()
                     self.executionTime = time() - t0
-                    if self.oldAverage is None: self.oldAverage = self.executionTime
+                    if self.oldAverage is None:
-                    self.oldAverage = (self.executionTime + self.count*self.oldAverage) / (self.count + 1.0)
+                        self.oldAverage = self.executionTime
+                    self.oldAverage = (self.executionTime + self.count *
+                                       self.oldAverage) / (self.count + 1.0)
                     self.count = self.count + 1.0
                     return
                     indexChannel = 0
                     dataOk = False
-                    for thisChannelName in self.__channelNameList: ##TODO VARIOS CHANNELS?
+                    for thisChannelName in self.__channelNameList:  # TODO VARIOS CHANNELS?
                         for indexSubchannel in range(self.__num_subchannels):
                             try:
                                 t0 = time()
                                                                               self.__samples_to_read,
                                                                               thisChannelName, sub_channel=indexSubchannel)
                                 self.executionTime = time() - t0
-                                if self.oldAverage is None: self.oldAverage = self.executionTime
+                                if self.oldAverage is None:
-                                self.oldAverage = (self.executionTime + self.count*self.oldAverage) / (self.count + 1.0)
+                                    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:
                     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
                             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.data = self.__data_buffer[:,
-                    self.dataOut.utctime = (self.__thisUnixSample + self.__bufferIndex)/self.__sample_rate
+                                                           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
                     return
                     # print self.profileIndex
                 def run(self, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     return
             class DigitalRFWriter(Operation):
                 '''
                 classdocs
                     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)])
+                    self.arr_data = arr_data = numpy.ones((self.__nSamples, len(
+                        self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
-                    file_cadence_millisecs = long(1.0 * self.__blocks_per_file * self.__nProfiles * self.__nSamples / self.__sample_rate) * 1000
+                    file_cadence_millisecs = long(
+.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()
                     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
+                    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
                     print '[Writing] - Writing metadata'
                     start_idx = self.__sample_rate * self.dataOut.utctime
-                    self.metadata_dict['processingHeader'] = self.dataOut.processingHeaderObj.getAsDict()
+                    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.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
+                    if self.oldAverage is None:
-                    self.oldAverage = (self.executionTime + self.count*self.oldAverage) / (self.count + 1.0)
+                        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:
                     # print dataOut.__dict__
                     self.dataOut = dataOut
                     if not self.isConfig:
-                        self.setup(dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, **kwargs)
+                        self.setup(dataOut, path, frequency, fileCadence,
+                                   dirCadence, metadataCadence, **kwargs)
                         self.writeMetadata()
                     self.writeData()
                     ## self.currentSample += 1
-                    ## if self.dataOut.flagDataAsBlock or self.currentSample == 1:
+                    # if self.dataOut.flagDataAsBlock or self.currentSample == 1:
-                        ## self.writeMetadata()
+                    # self.writeMetadata()
                     ## if self.currentSample == self.__nProfiles: self.currentSample = 0
                 def close(self):

schainpy/model/proc/jroproc_voltage.py 0 -2

                 def __convolutionInTime(self, data):
                     code = self.code[self.__profIndex]
                     for i in range(self.__nChannels):
                         self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
                             code = dataOut.code
                         else:
                             code = numpy.array(code).reshape(nCode,nBaud)
                         self.setup(code, osamp, dataOut)
                         self.isConfig = True

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