From 65ae6ea47e4eef4beb6527d8f0c56fcfaa3f6dab 2012-09-18 15:08:01
From: Daniel Valdez <daniel.suarez@jro.igp.gob.pe>
Date: 2012-09-18 15:08:01
Subject: [PATCH] Hasta el momento se realiza la lectura de Rawdata

---

diff --git a/schainpy2/Data/Spectra.py b/schainpy2/Data/Spectra.py
new file mode 100644
index 0000000..81500fa
--- /dev/null
+++ b/schainpy2/Data/Spectra.py
@@ -0,0 +1,60 @@
+import os, sys
+import numpy
+
+path = os.path.split(os.getcwd())[0]
+sys.path.append(path)
+
+from JROData import JROData
+from IO.JROHeader import SystemHeader, RadarControllerHeader
+
+class Spectra(JROData):
+    data_spc = None
+    
+    data_cspc = None
+    
+    data_dc = None
+    
+    nFFTPoints = None
+    
+    nPairs = None
+    
+    pairsList = None
+    
+    nIncohInt = None
+    
+    def __init__(self):
+        '''
+        Constructor
+        '''
+        
+        self.m_RadarControllerHeader = RadarControllerHeader()
+    
+        self.m_SystemHeader = SystemHeader()
+        
+        self.type = "Spectra"
+        
+        #data es un numpy array de 2 dmensiones ( canales, alturas)
+#        self.data = None
+        
+        self.dtype = None
+        
+        self.nChannels = 0
+        
+        self.nHeights = 0
+        
+        self.nProfiles = None
+        
+        self.heightList = None
+        
+        self.channelList = None
+        
+        self.channelIndexList = None
+        
+        self.flagNoData = True
+        
+        self.flagTimeBlock = False
+        
+        self.dataUtcTime = None
+        
+        self.nIncohInt = None
+        
\ No newline at end of file
diff --git a/schainpy2/Data/Voltage.py b/schainpy2/Data/Voltage.py
index 5161637..4cd00fe 100644
--- a/schainpy2/Data/Voltage.py
+++ b/schainpy2/Data/Voltage.py
@@ -46,7 +46,3 @@ class Voltage(JROData):
         self.dataUtcTime = None
         
         self.nCohInt = None
-        
-        
-        
-        
\ No newline at end of file
diff --git a/schainpy2/IO/JRODataIO.py b/schainpy2/IO/JRODataIO.py
index 95b1c47..1c65d5a 100644
--- a/schainpy2/IO/JRODataIO.py
+++ b/schainpy2/IO/JRODataIO.py
@@ -11,6 +11,25 @@ sys.path.append(path)
 from JROHeader import *
 from Data.JROData import JROData
 
+def isNumber(str):
+    """
+    Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
+
+    Excepciones: 
+        Si un determinado string no puede ser convertido a numero
+    Input:
+        str, string al cual se le analiza para determinar si convertible a un numero o no
+        
+    Return:
+        True    :    si el string es uno numerico
+        False   :    no es un string numerico
+    """
+    try:
+        float( str )
+        return True
+    except:
+        return False
+
 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
     """
     Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
@@ -108,6 +127,10 @@ class JRODataIO:
     
     nTotalBlocks = None
     
+    maxTimeStep = 30
+    
+    lastUTTime = None
+    
     def __init__(self):
         pass
 
@@ -237,7 +260,7 @@ class JRODataReader(JRODataIO):
 
             return None
 
-        self.updateDataHeader()
+#        self.updateDataHeader()
 
         return self.dataOutObj
 
@@ -288,6 +311,43 @@ class JRODataReader(JRODataIO):
         self.nReadBlocks = 0
         return 1
 
+    def __setNewBlock(self):
+        if self.fp == None:
+            return 0
+
+        if self.flagIsNewFile:
+            return 1
+        
+        self.lastUTTime = self.basicHeaderObj.utc
+        currentSize = self.fileSize - self.fp.tell()
+        neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
+        
+        if (currentSize >= neededSize):
+            self.__rdBasicHeader()
+            return 1
+
+        if not(self.setNextFile()):
+            return 0
+
+        deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
+
+        self.flagTimeBlock = 0
+
+        if deltaTime > self.maxTimeStep:
+            self.flagTimeBlock = 1
+
+        return 1
+
+
+    def readNextBlock(self):
+        if not(self.__setNewBlock()):
+            return 0
+
+        if not(self.readBlock()):
+            return 0
+
+        return 1
+
     def __rdProcessingHeader(self, fp=None):
         if fp == None:
             fp = self.fp
diff --git a/schainpy2/IO/JROHeader.py b/schainpy2/IO/JROHeader.py
index d799ec6..48b784f 100644
--- a/schainpy2/IO/JROHeader.py
+++ b/schainpy2/IO/JROHeader.py
@@ -189,7 +189,7 @@ class RadarControllerHeader(Header):
         self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
         
         self.samplingWindow = None
-        self.numHeights = None
+        self.nHeights = None
         self.firstHeight = None
         self.deltaHeight = None
         self.samplesWin = None
@@ -232,7 +232,7 @@ class RadarControllerHeader(Header):
             fp.seek(backFp)
             
             self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
-            self.numHeights = numpy.sum(self.samplingWindow['nsa'])
+            self.nHeights = numpy.sum(self.samplingWindow['nsa'])
             self.firstHeight = self.samplingWindow['h0']
             self.deltaHeight = self.samplingWindow['dh']
             self.samplesWin = self.samplingWindow['nsa']
@@ -336,7 +336,7 @@ class ProcessingHeader(Header):
                                ])
         self.samplingWindow = 0
         self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
-        self.numHeights = 0
+        self.nHeights = 0
         self.firstHeight = 0
         self.deltaHeight = 0
         self.samplesWin = 0
@@ -362,9 +362,9 @@ class ProcessingHeader(Header):
             self.nIncohInt = header['nIncoherentIntegrations'][0]
             self.totalSpectra = header['nTotalSpectra'][0]
             self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
-            self.numHeights = numpy.sum(self.samplingWindow['nsa'])
-            self.firstHeight = self.samplingWindow['h0']
-            self.deltaHeight = self.samplingWindow['dh']
+            self.nHeights = numpy.sum(self.samplingWindow['nsa'])
+            self.firstHeight = self.samplingWindow['h0'][0]
+            self.deltaHeight = self.samplingWindow['dh'][0]
             self.samplesWin = self.samplingWindow['nsa']
             self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
             
diff --git a/schainpy2/IO/SpectraIO.py b/schainpy2/IO/SpectraIO.py
new file mode 100644
index 0000000..fc7e3f8
--- /dev/null
+++ b/schainpy2/IO/SpectraIO.py
@@ -0,0 +1,539 @@
+''' 
+File: SpectraIO.py
+Created on 20/02/2012
+
+@author $Author: dsuarez $
+@version $Id: SpectraIO.py 110 2012-07-19 15:18:18Z dsuarez $
+'''
+
+import os, sys
+import numpy
+import glob
+import fnmatch
+import time, datetime
+
+path = os.path.split(os.getcwd())[0]
+sys.path.append(path)
+
+from Model.JROHeader import *
+from Model.Spectra import Spectra
+
+from JRODataIO import JRODataReader
+from JRODataIO import JRODataWriter
+from JRODataIO import isNumber
+
+
+class SpectraReader(JRODataReader):
+    """ 
+    Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
+    de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones) 
+    son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
+
+                        paresCanalesIguales    * alturas * perfiles  (Self Spectra)
+                        paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
+                        canales * alturas                            (DC Channels)
+
+    Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, 
+    RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
+    cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque 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 = SpectraReader()
+        
+        readerObj.setup(dpath, startTime, endTime)
+        
+        while(True):
+            
+            readerObj.getData()
+            
+            print readerObj.dataOutObj.data
+            
+            if readerObj.flagNoMoreFiles:
+                break
+            
+    """
+    dataOutObj = None
+    
+    datablock = None
+
+    pts2read_SelfSpectra = 0
+    
+    pts2read_CrossSpectra = 0
+    
+    pts2read_DCchannels = 0
+    
+    ext = ".pdata"
+        
+    optchar = "P"
+    
+    flag_cspc = False
+    
+    def __init__(self, dataOutObj=None):
+        """ 
+        Inicializador de la clase SpectraReader para la lectura de datos de espectros.
+
+        Inputs: 
+            dataOutObj    :    Objeto de la clase Spectra. 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.
+         
+        Affected: 
+            self.dataOutObj
+
+        Return      : None
+        """
+
+        self.pts2read_SelfSpectra = 0
+        
+        self.pts2read_CrossSpectra = 0
+        
+        self.pts2read_DCs = 0
+        
+        self.datablock = None
+        
+        self.utc = None
+        
+        self.ext = ".pdata"
+        
+        self.optchar = "P"
+        
+        self.basicHeaderObj = BasicHeader()
+        
+        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.lastUTTime = 0
+        
+        self.maxTimeStep = 30
+            
+        self.flagNoMoreFiles = 0
+        
+        self.set = 0
+        
+        self.path = None
+
+        self.delay  = 3   #seconds
+        
+        self.nTries = 3  #quantity tries
+        
+        self.nFiles = 3   #number of files for searching
+        
+        self.nReadBlocks = 0
+        
+        self.flagIsNewFile = 1
+    
+        self.ippSeconds = 0
+    
+        self.flagTimeBlock = 0    
+    
+        self.flagIsNewBlock = 0
+        
+        self.nTotalBlocks = 0
+    
+        self.blocksize = 0
+
+
+    def createObjByDefault(self):
+        
+        dataObj = Spectra()
+        
+        return dataObj
+    
+    def __hasNotDataInBuffer(self):
+        return 1
+
+
+    def getBlockDimension(self):
+        """
+        Obtiene la cantidad de puntos a leer por cada bloque de datos
+        
+        Affected:
+            self.nChannels
+            self.nPairs
+            self.pts2read_SelfSpectra
+            self.pts2read_CrossSpectra
+            self.pts2read_DCchannels
+            self.blocksize
+            self.dataOutObj.nChannels
+            self.dataOutObj.nPairs
+
+        Return:
+            None
+        """
+        self.nChannels = 0
+        self.nPairs = 0
+        self.pairList = []
+        
+        for i in range( 0, self.processingHeaderObj.totalSpectra*2, 2 ):
+            if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
+                self.nChannels = self.nChannels + 1   #par de canales iguales 
+            else:
+                self.nPairs = self.nPairs + 1 #par de canales diferentes
+                self.pairList.append( (self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]) )
+
+        pts2read = self.processingHeaderObj.numHeights * self.processingHeaderObj.profilesPerBlock
+
+        self.pts2read_SelfSpectra = int(self.nChannels * pts2read)
+        self.blocksize = self.pts2read_SelfSpectra
+        
+        if self.processingHeaderObj.flag_cspc:
+            self.pts2read_CrossSpectra = int(self.nPairs * pts2read)
+            self.blocksize += self.pts2read_CrossSpectra
+            
+        if self.processingHeaderObj.flag_dc:
+            self.pts2read_DCchannels = int(self.systemHeaderObj.numChannels * self.processingHeaderObj.numHeights)
+            self.blocksize += self.pts2read_DCchannels
+            
+#        self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
+
+            
+    def readBlock(self):
+        """
+        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
+        
+        Return: None
+        
+        Variables afectadas:
+            self.datablockIndex
+            self.flagIsNewFile
+            self.flagIsNewBlock
+            self.nTotalBlocks
+            self.data_spc
+            self.data_cspc
+            self.data_dc
+
+        Exceptions: 
+            Si un bloque leido no es un bloque valido
+        """
+        blockOk_flag = False
+        fpointer = self.fp.tell()
+
+        spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
+        spc = spc.reshape( (self.nChannels, self.processingHeaderObj.numHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
+        
+        if self.flag_cspc:
+            cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
+            cspc = cspc.reshape( (self.nPairs, self.processingHeaderObj.numHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
+        
+        if self.processingHeaderObj.flag_dc:
+            dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.processingHeaderObj.numHeights*self.systemHeaderObj.numChannels) )
+            dc = dc.reshape( (self.systemHeaderObj.numChannels, self.processingHeaderObj.numHeights) ) #transforma a un arreglo 2D
+            
+        
+        if not(self.processingHeaderObj.shif_fft):
+            spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
+            
+            if self.flag_cspc:
+                cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
+        
+
+        spc = numpy.transpose( spc, (0,2,1) )
+        self.data_spc = spc
+        
+        if self.flag_cspc: 
+            cspc = numpy.transpose( cspc, (0,2,1) )
+            self.data_cspc = cspc['real'] + cspc['imag']*1j
+        else:
+            self.data_cspc = None
+        
+        if self.processingHeaderObj.flag_dc:
+            self.data_dc = dc['real'] + dc['imag']*1j
+        else:
+            self.data_dc = None
+
+        self.datablockIndex = 0
+        self.flagIsNewFile = 0
+        self.flagIsNewBlock = 1
+
+        self.nTotalBlocks += 1
+        self.nReadBlocks += 1
+
+        return 1
+    
+
+    def getData(self):
+        """
+        Copia el buffer de lectura a la clase "Spectra",
+        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"
+        
+        Return:
+            0    :    Si no hay mas archivos disponibles
+            1    :    Si hizo una buena copia del buffer
+            
+        Affected:
+            self.dataOutObj
+            self.datablockIndex
+            self.flagTimeBlock
+            self.flagIsNewBlock
+        """
+
+        if self.flagNoMoreFiles: return 0
+         
+        self.flagTimeBlock = 0
+        self.flagIsNewBlock = 0
+        
+        if self.__hasNotDataInBuffer():            
+
+            if not( self.readNextBlock() ):
+                return 0 
+            
+            self.updateDataHeader()
+        
+        if self.flagNoMoreFiles == 1:
+            print 'Process finished'
+            return 0
+        
+        #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
+
+        if self.data_dc == None:
+            self.dataOutObj.flagNoData = True
+            return 0
+
+        self.dataOutObj.flagNoData = False
+        self.dataOutObj.flagTimeBlock = self.flagTimeBlock
+        
+        self.dataOutObj.data_spc = self.data_spc
+        self.dataOutObj.data_cspc = self.data_cspc
+        self.dataOutObj.data_dc = self.data_dc
+
+        return 1
+
+
+class SpectraWriter(JRODataWriter):
+    
+    """ 
+    Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
+    de los datos siempre se realiza por bloques. 
+    """
+    
+    dataOutObj = None
+    
+    shape_spc_Buffer = None
+    shape_cspc_Buffer = None
+    shape_dc_Buffer = None
+    
+    data_spc = None
+    data_cspc = None
+    data_dc = None
+
+    
+    def __init__(self, dataOutObj=None):
+        """ 
+        Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
+         
+        Affected: 
+            self.dataOutObj
+            self.basicHeaderObj
+            self.systemHeaderObj
+            self.radarControllerHeaderObj
+            self.processingHeaderObj
+
+        Return: None
+        """
+        if dataOutObj == None:
+            dataOutObj = Spectra()    
+        
+        if not( isinstance(dataOutObj, Spectra) ):
+            raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
+
+        self.dataOutObj = dataOutObj
+
+        self.ext = ".pdata"
+        
+        self.optchar = "P"
+        
+        self.shape_spc_Buffer = None
+        self.shape_cspc_Buffer = None
+        self.shape_dc_Buffer = None
+
+        self.data_spc = None
+        self.data_cspc = None
+        self.data_dc = None
+
+        ####################################
+
+        self.fp = None
+        
+        self.nWriteBlocks = 0
+        
+        self.flagIsNewFile = 1
+        
+        self.nTotalBlocks = 0 
+        
+        self.flagIsNewBlock = 0
+        
+        self.flagNoMoreFiles = 0
+
+        self.setFile = None
+        
+        self.dataType = None
+        
+        self.path = None
+        
+        self.noMoreFiles = 0
+        
+        self.filename = None
+        
+        self.basicHeaderObj = BasicHeader()
+    
+        self.systemHeaderObj = SystemHeader()
+    
+        self.radarControllerHeaderObj = RadarControllerHeader()
+    
+        self.processingHeaderObj = ProcessingHeader()
+
+        
+    def hasAllDataInBuffer(self):
+        return 1
+
+    
+    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.shape_spc_Buffer = (self.dataOutObj.nChannels,
+                                 self.processingHeaderObj.numHeights,
+                                 self.processingHeaderObj.profilesPerBlock)
+
+        self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
+                                  self.processingHeaderObj.numHeights,
+                                  self.processingHeaderObj.profilesPerBlock)
+        
+        self.shape_dc_Buffer = (self.systemHeaderObj.numChannels,
+                                self.processingHeaderObj.numHeights)
+
+    
+    def writeBlock(self):
+        """
+        Escribe el buffer en el file designado
+            
+        Affected:
+            self.data_spc
+            self.data_cspc
+            self.data_dc
+            self.flagIsNewFile
+            self.flagIsNewBlock
+            self.nTotalBlocks
+            self.nWriteBlocks    
+            
+        Return: None
+        """
+        
+        spc = numpy.transpose( self.data_spc, (0,2,1) )
+        if not( self.processingHeaderObj.shif_fft ):
+            spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
+        data = spc.reshape((-1))
+        data.tofile(self.fp)
+
+        if self.data_cspc != None:
+            data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
+            cspc = numpy.transpose( self.data_cspc, (0,2,1) )
+            if not( self.processingHeaderObj.shif_fft ):
+                cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
+            data['real'] = cspc.real
+            data['imag'] = cspc.imag
+            data = data.reshape((-1))
+            data.tofile(self.fp)
+
+        data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
+        dc = self.data_dc
+        data['real'] = dc.real
+        data['imag'] = dc.imag
+        data = data.reshape((-1))
+        data.tofile(self.fp)
+
+        self.data_spc.fill(0)
+        self.data_dc.fill(0)
+        if self.data_cspc != None:
+            self.data_cspc.fill(0)
+        
+        self.flagIsNewFile = 0
+        self.flagIsNewBlock = 1
+        self.nTotalBlocks += 1
+        self.nWriteBlocks += 1
+        
+        
+    def putData(self):
+        """
+        Setea un bloque de datos y luego los escribe en un file 
+            
+        Affected:
+            self.data_spc
+            self.data_cspc
+            self.data_dc
+
+        Return: 
+            0    :    Si no hay data o no hay mas files que puedan escribirse 
+            1    :    Si se escribio la data de un bloque en un file
+        """
+        self.flagIsNewBlock = 0
+        
+        if self.dataOutObj.flagNoData:
+            return 0
+        
+        if self.dataOutObj.flagTimeBlock:
+            self.data_spc.fill(0)
+            self.data_cspc.fill(0)
+            self.data_dc.fill(0)
+            self.setNextFile()
+        
+        self.data_spc = self.dataOutObj.data_spc
+        self.data_cspc = self.dataOutObj.data_cspc
+        self.data_dc = self.dataOutObj.data_dc
+        
+        # #self.processingHeaderObj.dataBlocksPerFile)
+        if self.hasAllDataInBuffer():
+            self.getDataHeader()
+            self.writeNextBlock()
+        
+        if self.flagNoMoreFiles:
+            #print 'Process finished'
+            return 0
+        
+        return 1
\ No newline at end of file
diff --git a/schainpy2/IO/VoltageIO.py b/schainpy2/IO/VoltageIO.py
index f581c78..1522d64 100644
--- a/schainpy2/IO/VoltageIO.py
+++ b/schainpy2/IO/VoltageIO.py
@@ -110,10 +110,6 @@ class VoltageReader(JRODataReader):
         
         self.idFile = None
         
-        self.startDateTime = None
-        
-        self.endDateTime = None
-        
         self.dtype = None
         
         self.fileSizeByHeader = None
@@ -186,7 +182,7 @@ class VoltageReader(JRODataReader):
         Return:
             None
         """
-        pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.numHeights * self.systemHeaderObj.numChannels
+        pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
         self.blocksize = pts2read
 
             
@@ -217,7 +213,7 @@ class VoltageReader(JRODataReader):
         junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
         
         try:
-            junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.numHeights, self.systemHeaderObj.numChannels) )
+            junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
         except:
             print "The read block (%3d) has not enough data" %self.nReadBlocks
             return 0
@@ -268,7 +264,7 @@ class VoltageReader(JRODataReader):
             if not( self.readNextBlock() ):
                 return 0
             
-            self.updateDataHeader()
+#            self.updateDataHeader()
             
         if self.flagNoMoreFiles == 1:
             print 'Process finished'
@@ -284,19 +280,19 @@ class VoltageReader(JRODataReader):
         
         self.dataOutObj.dtype = self.dtype
         
-        self.dataOutObj.nChannels = self.systemHeaderObj.numChannels
+        self.dataOutObj.nChannels = self.systemHeaderObj.nChannels
         
-        self.dataOutObj.nHeights = self.processingHeaderObj.numHeights
+        self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
         
         self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
         
-        xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.numHeights*self.processingHeaderObj.deltaHeight
+        xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
 
-        self.dataOutObj.heightList = range(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight) 
+        self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight) 
         
-        self.dataOutObj.channelList = range(self.systemHeaderObj.numChannels)
+        self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
         
-        self.dataOutObj.channelIndexList = range(self.systemHeaderObj.numChannels)
+        self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
         
         self.dataOutObj.flagNoData = True
         
@@ -371,12 +367,12 @@ class VoltageWriter(JRODataWriter):
         Return: None
         """
         self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
-                            self.processingHeaderObj.numHeights,
-                            self.systemHeaderObj.numChannels )
+                            self.processingHeaderObj.nHeights,
+                            self.systemHeaderObj.nChannels )
             
-        self.datablock = numpy.zeros((self.systemHeaderObj.numChannels,
+        self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
                                      self.processingHeaderObj.profilesPerBlock,
-                                     self.processingHeaderObj.numHeights),
+                                     self.processingHeaderObj.nHeights),
                                      dtype=numpy.dtype('complex'))
 
         
diff --git a/schainpy2/testSchainExp.py b/schainpy2/testSchainExp.py
index 841f1e2..ff5e745 100644
--- a/schainpy2/testSchainExp.py
+++ b/schainpy2/testSchainExp.py
@@ -21,7 +21,7 @@ class TestSChain():
 
     def setValues(self):
         self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
-        self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
+#        self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING"
         
         self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
         
@@ -58,7 +58,7 @@ class TestSChain():
             
             if self.readerObj.flagIsNewBlock:
                 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
-                                                  datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
+                                                  datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
 
     
 if __name__ == '__main__':