schain Commit - r981:289bbc0a74a0 · Jicamarca Repository

setting all headers all the time

Jose Chavez -

r981:289bbc0a74a0

parent child

Context file:

r981:289bbc0a74a0

Collapse all files

schainpy/model/data/jroheaderIO.py +25 -10

                     raise NotImplementedError
                 def getAllowedArgs(self):
-                    return inspect.getargspec(self.__init__).args
+                    args = inspect.getargspec(self.__init__).args
+                    try:
+                        args.remove('self')
+                    except:
+                        pass
+                    return args
+                def getAsDict(self):
+                    args = self.getAllowedArgs()
+                    asDict = {}
+                    for x in args:
+                        asDict[x] = self[x]
+                    return asDict
+                def __getitem__(self, name):
+                    return getattr(self, name)
                 def printInfo(self):
                 pciDioBusWidth = None
                 structure = SYSTEM_STRUCTURE
-                def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWith=0):
+                def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
                     self.size = 24
                     self.nSamples = nSamples
                     self.nProfiles = nProfiles
                     self.nChannels = nChannels
                     self.adcResolution = adcResolution
-                    self.pciDioBusWidth = pciDioBusWith
+                    self.pciDioBusWidth = pciDioBusWidth
                 def read(self, fp):
                     self.length = 0
                 line5Function = None
                 fClock = None
                 prePulseBefore = None
-                prePulserAfter = None
+                prePulseAfter = None
                 rangeIpp = None
                 rangeTxA = None
                 rangeTxB = None
                 __size = None
                 def __init__(self, expType=2, nTx=1,
-                             ippKm=None, txA=0, txB=0,
+                             ipp=None, txA=0, txB=0,
                              nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
                              numTaus=0, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
             #         self.size = 116
                     self.expType = expType
                     self.nTx = nTx
-                    self.ipp = ippKm
+                    self.ipp = ipp
                     self.txA = txA
                     self.txB = txB
-                    self.rangeIpp = ippKm
+                    self.rangeIpp = ipp
                     self.rangeTxA = txA
                     self.rangeTxB = txB
                     self.line5Function = line5Function
                     self.fClock = fClock
                     self.prePulseBefore = prePulseBefore
-                    self.prePulserAfter = prePulseAfter
+                    self.prePulseAfter = prePulseAfter
                     self.nHeights = nHeights
                     self.firstHeight = firstHeight
                     self.line5Function = int(header['nLine5Function'][0])
                     self.fClock = float(header['fClock'][0])
                     self.prePulseBefore = int(header['nPrePulseBefore'][0])
-                    self.prePulserAfter = int(header['nPrePulseAfter'][0])
+                    self.prePulseAfter = int(header['nPrePulseAfter'][0])
                     self.rangeIpp = header['sRangeIPP'][0]
                     self.rangeTxA = header['sRangeTxA'][0]
                     self.rangeTxB = header['sRangeTxB'][0]
                                    self.line5Function,
                                    self.fClock,
                                    self.prePulseBefore,
-                                   self.prePulserAfter,
+                                   self.prePulseAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)

schainpy/model/io/jroIO_digitalRF.py +73 -65

             import os
             import datetime
             import numpy
-            from profilehooks import coverage
+            from profilehooks import coverage, profile
             from fractions import Fraction
             try:
             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:
                     self.__printInfo = True
                     self.__flagDiscontinuousBlock = False
                     self.__bufferIndex = 9999999
                     self.__ippKm = None
                     self.__codeType = 0
                     self.__nCode = None
                     nProfiles = 1.0/ippSeconds  # Number of profiles in one second
-                    self.dataOut.radarControllerHeaderObj = RadarControllerHeader(ippKm=self.__ippKm,
+                    self.dataOut.radarControllerHeaderObj = RadarControllerHeader(self.__radarControllerHeader)
-                                                                                  txA=0,
-                                                                                  txB=0,
+                    self.dataOut.systemHeaderObj = SystemHeader(self.__systemHeader)
-                                                                                  nWindows=1,
-                                                                                  nHeights=self.__nSamples,
-                                                                                  firstHeight=self.__firstHeigth,
-                                                                                  deltaHeight=self.__deltaHeigth,
-                                                                                  codeType=self.__codeType,
-                                                                                  nCode=self.__nCode, nBaud=self.__nBaud,
-                                                                                  code = self.__code)
-                    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 = numpy.dtype([('real','<i8'),('imag','<i8')])
+                    self.dataOut.dtype = self.dtype
                     # self.dataOut.nChannels = 0
                     # self.dataOut.channelIndexList = None
                     self.dataOut.flagNoData = True
+                    self.dataOut.flagDataAsBlock = False
                     # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     if not channelList:
                         channelList = range(len(channelNameList))
                     ##########  Reading metadata ######################
-                    metadata_dict = self.digitalReadObj.get_properties(channelNameList[channelList[0]])
+                    top_properties = self.digitalReadObj.get_properties(channelNameList[channelList[0]])
-                    self.__sample_rate = metadata_dict['sample_rate_numerator'] / metadata_dict['sample_rate_denominator']
+                    self.__sample_rate = 1.0 * top_properties['sample_rate_numerator'] / top_properties['sample_rate_denominator']
-            #         self.__samples_per_file = metadata_dict['samples_per_file'][0]
+                    # 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
+                    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'])
                     self.__frequency = None
                     try:
                         self.__frequency = self.fixed_metadata_dict['frequency']
                     except:
                     except:
                         self.__timezone = 0
+                    try:
+                        nSamples = self.__systemHeader['nSamples']
+                    except:
+                        nSamples = None
                     self.__firstHeigth = 0
                     try:
-                        codeType = self.fixed_metadata_dict['codeType']
+                        codeType = self.__radarControllerHeader['codeType']
                     except:
                         codeType = 0
                     code = numpy.ones((nCode, nBaud), dtype=numpy.int)
                     if codeType:
-                        nCode = self.fixed_metadata_dict['nCode']
+                        nCode = self.__radarControllerHeader['nCode']
-                        nBaud = self.fixed_metadata_dict['nBaud']
+                        nBaud = self.__radarControllerHeader['nBaud']
-                        code = self.fixed_metadata_dict['code']
+                        code = self.__radarControllerHeader['code']
                     if not ippKm:
                         try:
                             # seconds to km
-                            ippKm = 1e6*0.15*self.fixed_metadata_dict['ipp']
+                            ippKm = 1e6*0.15*self.__radarControllerHeader['ipp']
                         except:
                             ippKm = None
                     ####################################################
                         channelNameListFiltered.append(thisChannelName)
                     self.profileIndex = 0
+                    self.i= 0
                     self.__delay = delay
                     self.__ippKm = ippKm
                     self.__codeType = codeType
                     self.__channelNameList = channelNameListFiltered
                     self.__channelBoundList = channelBoundList
                     self.__nSamples = nSamples
-                    self.__samples_to_read = long(buffer_size*nSamples) #FIJO: AHORA 40
+                    self.__samples_to_read = long(nSamples) # FIJO: AHORA 40
                     self.__nChannels = len(self.__channelList)
                     self.__startUTCSecond = startUTCSecond
                     indexChannel = 0
                     dataOk = False
                     for thisChannelName in self.__channelNameList: ##TODO VARIOS CHANNELS?
                         try:
                             result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
                                                                           self.__samples_to_read,
                     self.dataOut.flagNoData = True
                     if self.__isBufferEmpty():
                         self.__flagDiscontinuousBlock = False
                         while True:
                     return
                     # print self.profileIndex
+                ##@profile
                 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)
+                    print self.dataOut.dtype
+                    self.i = self.i+1
                     self.getData(seconds=self.__delay)
                     return
                     Constructor
                     '''
                     Operation.__init__(self, **kwargs)
+                    self.metadata_dict = {}
                     self.dataOut = None
-                def setup(self, dataOut, path, set=0, metadataFile='metadata', ext='.h5'):
+                def setup(self, dataOut, path, frequency, 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.metadata_dict['frequency'] = frequency
+                    self.metadata_dict['timezone'] = -5 * 60 * 60
+                    self.metadata_dict['dtype'] = cPickle.dumps(dataOut.dtype)
                     self.__ippSeconds = dataOut.ippSeconds
                     self.__deltaH = dataOut.getDeltaH()
                     self.__blocks_per_file = dataOut.processingHeaderObj.dataBlocksPerFile
                     self.arr_data = arr_data = numpy.ones((self.__nSamples, 1), 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(1.0 * self.__blocks_per_file * self.__nProfiles * self.__nSamples / self.__sample_rate) * 1000
-                    sub_cadence_secs = file_cadence_millisecs
+                    sub_cadence_secs = file_cadence_millisecs / 500
-                    #print file_cadence_millisecs
+                    print file_cadence_millisecs
-                    #print sub_cadence_secs
+                    print sub_cadence_secs
                     sample_rate_fraction = Fraction(self.__sample_rate).limit_denominator()
                     sample_rate_numerator = long(sample_rate_fraction.numerator)
                     is_continuous = True
                     marching_periods = False
-                    self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, sub_cadence_secs,
+                    self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, 100,
-                                                            file_cadence_millisecs, start_global_index,
+, 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, 236, file_cadence_millisecs / 1000,
+                    self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, 100, 1, ##236, file_cadence_millisecs / 1000
                                                             sample_rate_numerator, sample_rate_denominator,
                                                             metadataFile)
                     self.currentSample = 0
                     return
-                @coverage
+                def writeMetadata(self):
-                def run(self, dataOut, path=None, **kwargs):
+                    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 writeData(self):
+                    for i in range(self.dataOut.systemHeaderObj.nSamples):
+                        self.arr_data[i]['r'] = self.dataOut.data[0][i].real
+                        self.arr_data[i]['i'] = self.dataOut.data[0][i].imag
+                    self.digitalWriteObj.rf_write(self.arr_data)
+                    return
+                def run(self, dataOut, frequency=49.92e6, path=None, **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, **kwargs)
+                        self.setup(dataOut, path, frequency, **kwargs)
-                    samples = len(self.dataOut.data[0])
+                    self.writeData()
-                    for i in range(samples):
-                        self.arr_data[i]['r'] = dataOut.data[0][i].real
-                        self.arr_data[i]['i'] = dataOut.data[0][i].imag
-                    self.digitalWriteObj.rf_write(self.arr_data)
-                    start_idx = self.__sample_rate * dataOut.utctime
-                    metadata_dict = {}
-                    metadata_dict['frequency'] = 49.92e6
-                    metadata_dict['blablabla'] = 49.92e6
                     self.currentSample += 1
-                    if self.dataOut.flagDataAsBlock:
+                    if self.dataOut.flagDataAsBlock or self.currentSample == 1:
-                        self.digitalMetadataWriteObj.write(start_idx, metadata_dict)
+                        self.writeMetadata()
-                    elif self.currentSample == 1:
-                        print '[Writing] - Writing metadata'
-                        self.digitalMetadataWriteObj.write(start_idx, metadata_dict)
                     if self.currentSample == self.__nProfiles: self.currentSample = 0
                 def close(self):
                     print '[Writing] - Closing files '
+                    try:
                         self.digitalWriteObj.close()
+                    except:
+                        pass
                     # raise
             if __name__ == '__main__':

schainpy/scripts/schain.xml +1 -1

	@@ -1,1 +1,1
	1	<Project description="Segundo Test" id="191" name="test01"><ReadUnit datatype="VoltageReader" id="1911" inputId="0" name="VoltageReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="datatype" value="VoltageReader" /><Parameter format="str" id="191112" name="path" value="/home/jchavez/jicamarca/jro_data/rawdata" /><Parameter format="date" id="191113" name="startDate" value="2010/10/28" /><Parameter format="date" id="191114" name="endDate" value="2017/10/28" /><Parameter format="time" id="191115" name="startTime" value="00:00:00" /><Parameter format="time" id="191116" name="endTime" value="23:59:59" /><Parameter format="int" id="191118" name="online" value="0" /><Parameter format="int" id="191119" name="walk" value="0" /></Operation><Operation id="19112" name="printNumberOfBlock" priority="2" type="self" /></ReadUnit><ProcUnit datatype="VoltageProc" id="1912" inputId="1911" name="VoltageProc"><Operation id="19121" name="run" priority="1" type="self" /><Operation id="19122" name="DigitalRFWriter" priority="2" type="other"><Parameter format="str" id="191221" name="path" value="/home/jchavez/jicamarca/mocked_data/voltage" /></Operation></ProcUnit></Project> No newline at end of file		1	<Project description="Testing USRP data reader" id="191" name="test01"><ReadUnit datatype="DigitalRF" id="1911" inputId="0" name="DigitalRFReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="datatype" value="DigitalRF" /><Parameter format="str" id="191112" name="path" value="/home/jchavez/jicamarca/mocked_data" /><Parameter format="date" id="191113" name="startDate" value="2000/07/03" /><Parameter format="date" id="191114" name="endDate" value="2017/07/03" /><Parameter format="time" id="191115" name="startTime" value="00:00:00" /><Parameter format="time" id="191116" name="endTime" value="23:59:59" /><Parameter format="int" id="191118" name="online" value="0" /></Operation></ReadUnit><ProcUnit datatype="Voltage" id="1912" inputId="1911" name="VoltageProc"><Operation id="19121" name="run" priority="1" type="self" /></ProcUnit></Project> No newline at end of file

schainpy/scripts/testDigitalRF.py +6 -7

                                                             endDate='2017/07/03',
                                                             startTime='00:00:00',
                                                             endTime='23:59:59',
-                                                            online=0,
+                                                            online=0)
-                                                            ippKm = 60)
                 procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage',
                                                              inputId=readUnitConfObj.getId())
             #     opObj10.addParameter(name='nCode', value='2', format='float')
             #     opObj10.addParameter(name='nBaud', value='1', format='float')
-                opObj10 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
+                # opObj10 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
-                opObj10.addParameter(name='n', value='1', format='float')
+                # opObj10.addParameter(name='n', value='1', format='float')
-                opObj11 = procUnitConfObj0.addOperation(name='Scope', optype='external')
+                # opObj11 = procUnitConfObj0.addOperation(name='Scope', optype='external')
-                opObj11.addParameter(name='id', value='121', format='int')
+                # opObj11.addParameter(name='id', value='121', format='int')
-                opObj11.addParameter(name='wintitle', value='Scope', format='str')
+                # opObj11.addParameter(name='wintitle', value='Scope', format='str')
                 # procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra',
                 #                                              inputId=procUnitConfObj0.getId())

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