From bfb6b8219d8f80255f4c1572f0b1110e858b4db3 2012-03-28 14:57:11
From: Miguel Valdez <miguel.urco@jro.igp.gob.pe>
Date: 2012-03-28 14:57:11
Subject: [PATCH] El modelo de datos ha sido actualizado para trabajar con clases absolutas padres de donde se derivan las demas clases.

---

diff --git a/schainpy/Model/Correlation.py b/schainpy/Model/Correlation.py
index 82bc119..4b1e6c8 100644
--- a/schainpy/Model/Correlation.py
+++ b/schainpy/Model/Correlation.py
@@ -15,7 +15,4 @@ class Correlation(Data):
         '''
         Constructor
         '''
-        pass
-
-    def copy(self):
         pass
\ No newline at end of file
diff --git a/schainpy/Model/Data.py b/schainpy/Model/Data.py
deleted file mode 100644
index 2262489..0000000
--- a/schainpy/Model/Data.py
+++ /dev/null
@@ -1,22 +0,0 @@
-'''
-Created on Feb 7, 2012
-
-@author $Author$
-@version $Id$
-'''
-
-class Data:
-    '''
-    classdocs
-    '''
-
-
-    def __init__(self):
-        '''
-        Constructor
-        '''
-        pass
-
-    def copy(self):
-        pass
-        
\ No newline at end of file
diff --git a/schainpy/Model/JROData.py b/schainpy/Model/JROData.py
new file mode 100644
index 0000000..36f7fa4
--- /dev/null
+++ b/schainpy/Model/JROData.py
@@ -0,0 +1,63 @@
+'''
+Created on Feb 7, 2012
+
+@author $Author$
+@version $Id$
+'''
+import copy
+from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
+
+class Data:
+    '''
+    classdocs
+    '''
+    __type = None
+    
+    def __init__(self):
+        '''
+        Constructor
+        '''
+        raise ValueError, "This class has not been implemented"
+    
+    def copy(self):
+        
+        return copy.deepcopy(self)
+
+class Noise(Data):
+    '''
+    classdocs
+    '''
+
+    def __init__(self):
+        '''
+        Constructor
+        '''
+        pass
+
+class JROData(Data):
+    '''
+    classdocs
+    '''
+    m_RadarControllerHeader = RadarControllerHeader()
+    m_ProcessingHeader = ProcessingHeader()
+    m_SystemHeader = SystemHeader()
+    m_BasicHeader = BasicHeader()
+    m_Noise = Noise()
+    
+    data = None
+    dataType = None
+
+    nProfiles = None
+    nHeights = None
+    nChannels = None    
+    
+    heights = None
+    
+    flagNoData = False
+    flagResetProcessing = False
+            
+    def __init__(self):
+        '''
+        Constructor
+        '''
+        raise ValueError, "This class has not been implemented"
\ No newline at end of file
diff --git a/schainpy/Model/JROHeader.py b/schainpy/Model/JROHeader.py
new file mode 100644
index 0000000..5162bf8
--- /dev/null
+++ b/schainpy/Model/JROHeader.py
@@ -0,0 +1,396 @@
+'''
+Created on 23/01/2012
+
+@author $Author: vsarmiento $
+@version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
+'''
+
+import numpy
+import copy
+
+class Header:
+    
+    def __init__(self):
+        raise
+    
+    def copy(self):
+        return copy.deepcopy(self)
+
+    def read():
+        pass
+
+    def write():
+        pass
+
+class BasicHeader(Header):
+    
+    size = None
+    version = None
+    dataBlock = None
+    utc = None
+    miliSecond = None
+    timeZone = None
+    dstFlag = None
+    errorCount = None
+    struct = None
+        
+    def __init__(self):
+        self.size = 0
+        self.version = 0
+        self.dataBlock = 0
+        self.utc = 0
+        self.miliSecond = 0
+        self.timeZone = 0
+        self.dstFlag = 0
+        self.errorCount = 0
+        self.struct = numpy.dtype([
+                              ('nSize','<u4'),
+                              ('nVersion','<u2'),
+                              ('nDataBlockId','<u4'),
+                              ('nUtime','<u4'),
+                              ('nMilsec','<u2'),     
+                              ('nTimezone','<i2'),
+                              ('nDstflag','<i2'),
+                              ('nErrorCount','<u4')
+                              ])   
+        pass
+    
+    def read(self, fp):
+        
+        header = numpy.fromfile(fp, self.struct,1)
+        self.size = header['nSize'][0]
+        self.version = header['nVersion'][0]
+        self.dataBlock = header['nDataBlockId'][0]
+        self.utc = header['nUtime'][0]
+        self.miliSecond = header['nMilsec'][0]
+        self.timeZone = header['nTimezone'][0]
+        self.dstFlag = header['nDstflag'][0]
+        self.errorCount = header['nErrorCount'][0]
+        
+        return 1
+    
+    def write(self, fp):
+        headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
+        header = numpy.array(headerTuple,self.struct)        
+        header.tofile(fp)
+        
+        return 1
+
+class SystemHeader(Header):
+    
+    size = None
+    numSamples = None
+    numProfiles = None
+    numChannels = None
+    adcResolution = None
+    pciDioBusWidth = None
+    struct = None
+        
+    def __init__(self):
+        self.size = 0 
+        self.numSamples = 0
+        self.numProfiles = 0
+        self.numChannels = 0
+        self.adcResolution = 0
+        self.pciDioBusWidth = 0
+        self.struct = numpy.dtype([
+                            ('nSize','<u4'),
+                            ('nNumSamples','<u4'),
+                            ('nNumProfiles','<u4'),
+                            ('nNumChannels','<u4'),
+                            ('nADCResolution','<u4'),
+                            ('nPCDIOBusWidth','<u4'),
+                            ])
+    
+
+    def read(self, fp):
+        header = numpy.fromfile(fp,self.struct,1)
+        self.size = header['nSize'][0]
+        self.numSamples = header['nNumSamples'][0]
+        self.numProfiles = header['nNumProfiles'][0]
+        self.numChannels = header['nNumChannels'][0]
+        self.adcResolution = header['nADCResolution'][0]
+        self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
+        
+        
+        return 1
+    
+    def write(self, fp):
+        headerTuple = (self.size,self.numSamples,self.numProfiles,self.numChannels,self.adcResolution,self.pciDioBusWidth)
+        header = numpy.array(headerTuple,self.struct)
+        header.tofile(fp)
+        
+        return 1
+    
+class RadarControllerHeader(Header):
+    
+    size = None
+    expType = None
+    nTx = None
+    ipp = None
+    txA = None
+    txB = None
+    numWindows = None
+    numTaus = None
+    codeType = None
+    line6Function = None
+    line5Function = None
+    fClock = None
+    prePulseBefore = None
+    prePulserAfter = None
+    rangeIpp = None
+    rangeTxA = None
+    rangeTxB = None
+    struct = None
+        
+    def __init__(self):
+        self.size = 0
+        self.expType = 0
+        self.nTx = 0
+        self.ipp = 0
+        self.txA = 0
+        self.txB = 0
+        self.numWindows = 0
+        self.numTaus = 0
+        self.codeType = 0
+        self.line6Function = 0
+        self.line5Function = 0
+        self.fClock = 0
+        self.prePulseBefore = 0
+        self.prePulserAfter = 0
+        self.rangeIpp = 0
+        self.rangeTxA = 0
+        self.rangeTxB = 0
+        self.struct = numpy.dtype([
+                             ('nSize','<u4'),
+                             ('nExpType','<u4'),
+                             ('nNTx','<u4'),
+                             ('fIpp','<f4'),
+                             ('fTxA','<f4'),
+                             ('fTxB','<f4'),
+                             ('nNumWindows','<u4'),
+                             ('nNumTaus','<u4'),
+                             ('nCodeType','<u4'),
+                             ('nLine6Function','<u4'),
+                             ('nLine5Function','<u4'),
+                             ('fClock','<f4'),
+                             ('nPrePulseBefore','<u4'),
+                             ('nPrePulseAfter','<u4'),
+                             ('sRangeIPP','<a20'),
+                             ('sRangeTxA','<a20'),
+                             ('sRangeTxB','<a20'),
+                             ])
+        self.dynamic = numpy.array([],numpy.dtype('byte'))
+        
+
+    def read(self, fp):
+        header = numpy.fromfile(fp,self.struct,1)
+        self.size = header['nSize'][0]
+        self.expType = header['nExpType'][0]
+        self.nTx = header['nNTx'][0]
+        self.ipp = header['fIpp'][0]
+        self.txA = header['fTxA'][0]
+        self.txB = header['fTxB'][0]
+        self.numWindows = header['nNumWindows'][0]
+        self.numTaus = header['nNumTaus'][0]
+        self.codeType = header['nCodeType'][0]
+        self.line6Function = header['nLine6Function'][0]
+        self.line5Function = header['nLine5Function'][0]
+        self.fClock = header['fClock'][0]
+        self.prePulseBefore = header['nPrePulseBefore'][0]
+        self.prePulserAfter = header['nPrePulseAfter'][0]
+        self.rangeIpp = header['sRangeIPP'][0]
+        self.rangeTxA = header['sRangeTxA'][0]
+        self.rangeTxB = header['sRangeTxB'][0]
+        # jump Dynamic Radar Controller Header
+        jumpHeader = self.size - 116
+        self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpHeader)
+        
+        return 1
+    
+    def write(self, fp):
+        headerTuple = (self.size,
+                       self.expType,
+                       self.nTx,
+                       self.ipp,
+                       self.txA,
+                       self.txB,
+                       self.numWindows,
+                       self.numTaus,
+                       self.codeType,
+                       self.line6Function,
+                       self.line5Function,
+                       self.fClock,
+                       self.prePulseBefore,
+                       self.prePulserAfter,
+                       self.rangeIpp,
+                       self.rangeTxA,
+                       self.rangeTxB)
+        
+        header = numpy.array(headerTuple,self.struct)
+        header.tofile(fp)
+        
+        dynamic = self.dynamic
+        dynamic.tofile(fp)
+        
+        return 1
+
+    
+    
+class ProcessingHeader(Header):
+    
+    size = None
+    dataType = None
+    blockSize = None
+    profilesPerBlock = None
+    dataBlocksPerFile = None
+    numWindows = None
+    processFlags = None
+    coherentInt = None
+    incoherentInt = None
+    totalSpectra = None
+    struct = None
+        
+    def __init__(self):
+        self.size = 0
+        self.dataType = 0
+        self.blockSize = 0
+        self.profilesPerBlock = 0
+        self.dataBlocksPerFile = 0
+        self.numWindows = 0
+        self.processFlags = 0
+        self.coherentInt = 0
+        self.incoherentInt = 0
+        self.totalSpectra = 0
+        self.struct = numpy.dtype([
+                               ('nSize','<u4'),
+                               ('nDataType','<u4'),
+                               ('nSizeOfDataBlock','<u4'),
+                               ('nProfilesperBlock','<u4'),
+                               ('nDataBlocksperFile','<u4'),
+                               ('nNumWindows','<u4'),
+                               ('nProcessFlags','<u4'),
+                               ('nCoherentIntegrations','<u4'),
+                               ('nIncoherentIntegrations','<u4'),
+                               ('nTotalSpectra','<u4')
+                               ])
+        self.samplingWindow = 0
+        self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
+        self.numHeights = 0
+        self.firstHeight = 0
+        self.deltaHeight = 0
+        self.samplesWin = 0
+        self.spectraComb = 0
+        self.numCode = 0
+        self.codes = 0
+        self.numBaud = 0
+        self.shif_fft = False
+    
+    def read(self, fp):
+        header = numpy.fromfile(fp,self.struct,1)
+        self.size = header['nSize'][0]
+        self.dataType = header['nDataType'][0]
+        self.blockSize = header['nSizeOfDataBlock'][0]
+        self.profilesPerBlock = header['nProfilesperBlock'][0]
+        self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
+        self.numWindows = header['nNumWindows'][0]
+        self.processFlags = header['nProcessFlags']
+        self.coherentInt = header['nCoherentIntegrations'][0]
+        self.incoherentInt = header['nIncoherentIntegrations'][0]
+        self.totalSpectra = header['nTotalSpectra'][0]
+        self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.numWindows)
+        self.numHeights = numpy.sum(self.samplingWindow['nsa'])
+        self.firstHeight = self.samplingWindow['h0']
+        self.deltaHeight = self.samplingWindow['dh']
+        self.samplesWin = self.samplingWindow['nsa']
+        self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
+        
+        if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
+            self.numCode = numpy.fromfile(fp,'<u4',1)
+            self.numBaud = numpy.fromfile(fp,'<u4',1)
+            self.codes = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
+        
+        if self.processFlags & PROCFLAG.SHIFT_FFT_DATA == PROCFLAG.SHIFT_FFT_DATA:
+            self.shif_fft = True
+        else:
+            self.shif_fft = False
+            
+        
+        return 1
+    
+    def write(self, fp):
+        headerTuple = (self.size,
+                       self.dataType,
+                       self.blockSize,
+                       self.profilesPerBlock,
+                       self.dataBlocksPerFile,
+                       self.numWindows,
+                       self.processFlags,
+                       self.coherentInt,
+                       self.incoherentInt,
+                       self.totalSpectra)
+        
+        header = numpy.array(headerTuple,self.struct)  
+        header.tofile(fp)
+        
+        if self.numWindows != 0:
+            sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
+            samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
+            samplingWindow.tofile(fp)
+
+            
+        if self.totalSpectra != 0:
+            spectraComb = numpy.array([],numpy.dtype('u1'))
+            spectraComb = self.spectraComb
+            spectraComb.tofile(fp)
+
+            
+        if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
+            numCode = self.numCode
+            numCode.tofile(fp)
+
+            numBaud = self.numBaud
+            numBaud.tofile(fp)
+
+            codes = self.codes.reshape(numCode*numBaud)
+            codes.tofile(fp)
+            
+        return 1
+
+
+class PROCFLAG:    
+    COHERENT_INTEGRATION = numpy.uint32(0x00000001)
+    DECODE_DATA = numpy.uint32(0x00000002) 
+    SPECTRA_CALC = numpy.uint32(0x00000004)
+    INCOHERENT_INTEGRATION = numpy.uint32(0x00000008) 
+    POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
+    SHIFT_FFT_DATA = numpy.uint32(0x00000020)
+    
+    DATATYPE_CHAR = numpy.uint32(0x00000040)
+    DATATYPE_SHORT = numpy.uint32(0x00000080)
+    DATATYPE_LONG = numpy.uint32(0x00000100)
+    DATATYPE_INT64 = numpy.uint32(0x00000200)
+    DATATYPE_FLOAT = numpy.uint32(0x00000400)
+    DATATYPE_DOUBLE = numpy.uint32(0x00000800)
+    
+    DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000) 
+    DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000) 
+    DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000) 
+    
+    SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
+    DEFLIP_DATA = numpy.uint32(0x00010000)    
+    DEFINE_PROCESS_CODE = numpy.uint32(0x00020000) 
+     
+    ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
+    ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
+    ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
+    ACQ_SYS_JULIA = numpy.uint32(0x00100000)
+    ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
+    
+    EXP_NAME_ESP = numpy.uint32(0x00200000)
+    CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
+        
+    OPERATION_MASK = numpy.uint32(0x0000003F)
+    DATATYPE_MASK = numpy.uint32(0x00000FC0)
+    DATAARRANGE_MASK = numpy.uint32(0x00007000)
+    ACQ_SYS_MASK = numpy.uint32(0x001C0000)
\ No newline at end of file
diff --git a/schainpy/Model/Noise.py b/schainpy/Model/Noise.py
deleted file mode 100644
index a3066fa..0000000
--- a/schainpy/Model/Noise.py
+++ /dev/null
@@ -1,19 +0,0 @@
-'''
-Created on Feb 7, 2012
-
-@author $Author$
-@version $Id$
-'''
-
-class Noise:
-    '''
-    classdocs
-    '''
-
-
-    def __init__(self):
-        '''
-        Constructor
-        '''
-        pass
-        
\ No newline at end of file
diff --git a/schainpy/Model/Spectra.py b/schainpy/Model/Spectra.py
index bcebb8a..7acd7c7 100644
--- a/schainpy/Model/Spectra.py
+++ b/schainpy/Model/Spectra.py
@@ -1,83 +1,54 @@
-'''
-Created on Feb 7, 2012
-
-@author $Author$
-@version $Id$
-'''
-import os, sys
-
-path = os.path.split(os.getcwd())[0]
-sys.path.append(path)
-
-from Model.Data import Data
-from IO.HeaderIO import *
-
-
-class Spectra(Data):
-    '''
-    classdocs
-    '''
-        
-
-    def __init__(self):
-        '''
-        Constructor
-        '''
-        
-        self.m_RadarControllerHeader = RadarControllerHeader()
-        
-        self.m_ProcessingHeader = ProcessingHeader()
-    
-        self.m_SystemHeader = SystemHeader()
-    
-        self.m_BasicHeader = BasicHeader()
-        
-        #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
-        self.data_spc = None
-        self.data_cspc = None
-        self.data_dc = None
-        """
-        self.datablock_spc = None
-        self.datablock_cspc = None
-        self.datablock_dc = None
-        """
-          
-        self.heights  = None
-        
-        self.flagNoData = True
-        
-        self.nProfiles = None
-        
-        self.dataType = None
-        
-        self.flagResetProcessing = False
-
-        self.noise = None
-        
-        self.nPairs = 0
-
-        self.nChannels = 0
-
-
-    def copy(self):
-        obj = Spectra()
-        obj.m_BasicHeader = self.m_BasicHeader.copy()
-        obj.m_SystemHeader = self.m_SystemHeader.copy()
-        obj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
-        obj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
-        
-        obj.data_spc = self.data_spc
-        obj.data_cspc = self.data_cspc
-        obj.data_dc = self.data_dc
-        
-        obj.heights = self.heights
-        obj.flagNoData = self.flagNoData
-        
-        obj.nProfiles = self.nProfiles
-        
-        obj.noise = self.noise
-
-        obj.dataType = self.dataType
-
-        return obj
-        
\ No newline at end of file
+'''
+Created on Feb 7, 2012
+
+@author $Author$
+@version $Id$
+'''
+
+from JROData import JROData, Noise
+from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
+
+class Spectra(JROData):
+    '''
+    classdocs
+    '''
+    
+    data_spc = None
+    data_cspc = None
+    data_dc = None
+    nPairs = 0
+    
+
+    def __init__(self):
+        '''
+        Constructor
+        '''
+        
+        self.m_RadarControllerHeader = RadarControllerHeader()
+        
+        self.m_ProcessingHeader = ProcessingHeader()
+    
+        self.m_SystemHeader = SystemHeader()
+    
+        self.m_BasicHeader = BasicHeader()
+        
+        self.noise = Noise()
+        
+        #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
+        self.data_spc = None
+        self.data_cspc = None
+        self.data_dc = None
+          
+        self.heights  = None
+        
+        self.flagNoData = True
+        
+        self.nProfiles = None
+        
+        self.dataType = None
+        
+        self.flagResetProcessing = False
+        
+        self.nPairs = 0
+
+        self.nChannels = 0
\ No newline at end of file
diff --git a/schainpy/Model/Voltage.py b/schainpy/Model/Voltage.py
index 517d7c8..337c2d2 100644
--- a/schainpy/Model/Voltage.py
+++ b/schainpy/Model/Voltage.py
@@ -4,19 +4,18 @@ Created on Feb 7, 2012
 @author $Author$
 @version $Id$
 '''
-import os, sys
 
-path = os.path.split(os.getcwd())[0]
-sys.path.append(path)
+from JROData import JROData, Noise
+from JROHeader import RadarControllerHeader, ProcessingHeader, SystemHeader, BasicHeader
 
-from Model.Data import Data
-from IO.HeaderIO import *
-
-class Voltage(Data):
+class Voltage(JROData):
     '''
     classdocs
     '''
     
+    data = None
+    profileIndex = None
+    
     def __init__(self):
         '''
         Constructor
@@ -30,40 +29,20 @@ class Voltage(Data):
     
         self.m_BasicHeader= BasicHeader()
         
+        self.noise = Noise()
+        
         #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
         self.data = None
         
+        self.dataType = None
+        
         self.heights = None
         
-        self.flagNoData = True
+        self.profileIndex = None
         
         self.nProfiles = None
         
-        self.idProfile = None
-        
-        self.dataType = None
+        self.flagNoData = True
         
         self.flagResetProcessing = False
-        
-        self.noise = 0 #noise
-        
-    def copy(self):
-        obj = Voltage()
-        obj.m_BasicHeader = self.m_BasicHeader.copy()
-        obj.m_SystemHeader = self.m_SystemHeader.copy()
-        obj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
-        obj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
-        
-        obj.data = self.data
-        obj.heights = self.heights
-        obj.flagNoData = self.flagNoData
-        
-        obj.nProfiles = self.nProfiles
-        obj.idProfile = self.idProfile
-        obj.dataType = self.dataType
-        obj.flagResetProcessing = self.flagResetProcessing
-        
-        obj.noise = self.noise
-        
-        return obj
         
\ No newline at end of file