From 777f5fd367a9ab9c71a8cb641253fe4cd13975ce 2012-09-17 21:10:48
From: Miguel Valdez <miguel.urco@jro.igp.gob.pe>
Date: 2012-09-17 21:10:48
Subject: [PATCH] Modificaciones realizadas para mejoras en el Modelo, Funciones de Lectura y Escritura de Voltage

---

diff --git a/schainpy2/Data/JROData.py b/schainpy2/Data/JROData.py
index 1ef2c1b..59ccfb0 100644
--- a/schainpy2/Data/JROData.py
+++ b/schainpy2/Data/JROData.py
@@ -1,48 +1,57 @@
-
+import os, sys
 import copy
 import numpy
-from JROHeader import BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
 
-class Data:
-    def __init__(self):
-        pass
+path = os.path.split(os.getcwd())[0]
+sys.path.append(path)
 
-    def copy(self, inputObj=None):
-        if inputObj == None:
-            return copy.deepcopy(self)
+from IO.JROHeader import SystemHeader, RadarControllerHeader
 
-        for key in inputObj.__dict__.keys():
-            self.__dict__[key] = inputObj.__dict__[key]
+class JROData():
+    
+#    m_BasicHeader = BasicHeader()
+#    m_ProcessingHeader = ProcessingHeader()
 
-    def deepcopy(self):
-        return copy.deepcopy(self)
+    systemHeaderObj = SystemHeader()
+    
+    radarControllerHeaderObj = RadarControllerHeader()
 
-class JROData(Data):
     data = None
-#    m_BasicHeader = BasicHeader()
-#    m_SystemHeader = SystemHeader()
-#    m_RadarControllerHeader = RadarControllerHeader()
-#    m_ProcessingHeader = ProcessingHeader()
+    
     type = None
-    dataType = None
-    heightList = None
-    channelIndexList = None
-    channelList = None
+    
+    dtype = None
+    
+    nChannels = None
+    
     nHeights = None
+    
     nProfiles = None
-    nBlocksPerFile = None
-    nChannels = None
+    
+    heightList = None
+    
+    channelList = None
+    
+    channelIndexList = None
+    
     flagNoData = False
-    flagResetProcessing = False
+    
+    flagTimeBlock = False
+    
+    dataUtcTime = None
 
     def __init__(self):
+        
         raise ValueError, "This class has not been implemented"
-
-#    def updateHeaderFromObj(self):
-#        pass
-#        
-#
-#    def updateObjFromHeader(self):
-#        pass
         
+    def copy(self, inputObj=None):
+        
+        if inputObj == None:
+            return copy.deepcopy(self)
+
+        for key in inputObj.__dict__.keys():
+            self.__dict__[key] = inputObj.__dict__[key]
+
+    def deepcopy(self):
         
+        return copy.deepcopy(self)
\ No newline at end of file
diff --git a/schainpy2/Data/Voltage.py b/schainpy2/Data/Voltage.py
index 3f5f5f5..5161637 100644
--- a/schainpy2/Data/Voltage.py
+++ b/schainpy2/Data/Voltage.py
@@ -1,27 +1,52 @@
+import os, sys
 import numpy
+
+path = os.path.split(os.getcwd())[0]
+sys.path.append(path)
+
 from JROData import JROData
-# No deberia importar los Headers
+from IO.JROHeader import SystemHeader, RadarControllerHeader
+
 class Voltage(JROData):
-    data = None
+    
     nCohInt = None
     
     def __init__(self):
-        self.type = "Voltage"
-
-    def updateObjFromHeader(self):
-        xi = self.m_ProcessingHeader.firstHeight
-        step = self.m_ProcessingHeader.deltaHeight
-        xf = xi + self.m_ProcessingHeader.numHeights*step
-
-        self.heightList = numpy.arange(xi, xf, step)
-        self.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
-        self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
-
-        self.nHeights = len(self.heightList)
-        self.nChannels = len(self.channelList)
-        self.nProfiles = self.m_ProcessingHeader.profilesPerBlock
-        self.nBlocksPerFile = self.m_ProcessingHeader.dataBlocksPerFile
-        self.nCohInt = self.m_ProcessingHeader.coherentInt
+        '''
+        Constructor
+        '''
+        
+        self.m_RadarControllerHeader = RadarControllerHeader()
     
-    def updateHeaderFromObj(self):
-        pass
\ No newline at end of file
+        self.m_SystemHeader = SystemHeader()
+        
+        self.type = "Voltage"
+        
+        #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.nCohInt = None
+        
+        
+        
+        
\ No newline at end of file
diff --git a/schainpy2/IO/JRODataIO.py b/schainpy2/IO/JRODataIO.py
index 2903c91..95b1c47 100644
--- a/schainpy2/IO/JRODataIO.py
+++ b/schainpy2/IO/JRODataIO.py
@@ -8,8 +8,8 @@ import time, datetime
 path = os.path.split(os.getcwd())[0]
 sys.path.append(path)
 
-from Model.JROHeader import *
-from Model.JROData import JROData
+from JROHeader import *
+from Data.JROData import JROData
 
 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
     """
@@ -32,21 +32,21 @@ def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
         Si la cabecera no puede ser leida.
         
     """
-    m_BasicHeader = BasicHeader()
+    basicHeaderObj = BasicHeader()
     
     try:
         fp = open(filename,'rb')
     except:
         raise IOError, "The file %s can't be opened" %(filename)
     
-    sts = m_BasicHeader.read(fp)
+    sts = basicHeaderObj.read(fp)
     fp.close()
     
     if not(sts):
         print "Skipping the file %s because it has not a valid header" %(filename)
         return 0
     
-    if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds > m_BasicHeader.utc)):
+    if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
         return 0
     
     return 1
@@ -55,28 +55,59 @@ def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
 
 
 class JRODataIO:
+    
     c = 3E8
-    m_BasicHeader = BasicHeader()
-    m_SystemHeader = SystemHeader()
-    m_RadarControllerHeader = RadarControllerHeader()
-    m_ProcessingHeader = ProcessingHeader()
+    
+    basicHeaderObj = BasicHeader()
+    
+    systemHeaderObj = SystemHeader()
+    
+    radarControllerHeaderObj = RadarControllerHeader()
+    
+    processingHeaderObj = ProcessingHeader()
+    
     online = 0
-    dataType = None
+    
+    dtype = None
+    
     pathList = []
+    
     filenameList = []
+    
     filename = None
+    
     ext = None
-    fileIndex = None
+    
     flagNoMoreFiles = 0
+    
     flagIsNewFile = 1
-    flagResetProcessing = 0
+    
+    flagTimeBlock = 0
+    
     flagIsNewBlock = 0
+    
     fp = None
+    
     firstHeaderSize = 0
+    
     basicHeaderSize = 24
+    
+    versionFile = 1103
+    
     fileSize = None
+    
     ippSeconds = None
+    
     fileSizeByHeader = None
+    
+    fileIndex = None
+    
+    profileIndex = None
+    
+    blockIndex = None
+    
+    nTotalBlocks = None
+    
     def __init__(self):
         pass
 
@@ -261,25 +292,25 @@ class JRODataReader(JRODataIO):
         if fp == None:
             fp = self.fp
 
-        self.m_ProcessingHeader.read(fp)
+        self.processingHeaderObj.read(fp)
 
     def __rdRadarControllerHeader(self, fp=None):
         if fp == None:
             fp = self.fp
 
-        self.m_RadarControllerHeader.read(fp)
+        self.radarControllerHeaderObj.read(fp)
 
     def __rdSystemHeader(self, fp=None):
         if fp == None:
             fp = self.fp
 
-        self.m_SystemHeader.read(fp)
+        self.systemHeaderObj.read(fp)
 
     def __rdBasicHeader(self, fp=None):
         if fp == None:
             fp = self.fp
 
-        self.m_BasicHeader.read(fp)
+        self.basicHeaderObj.read(fp)
         
 
     def __readFirstHeader(self):
@@ -288,9 +319,9 @@ class JRODataReader(JRODataIO):
         self.__rdRadarControllerHeader()
         self.__rdProcessingHeader()
 
-        self.firstHeaderSize = self.m_BasicHeader.size
+        self.firstHeaderSize = self.basicHeaderObj.size
 
-        datatype = int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
+        datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
         if datatype == 0:
             datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
         elif datatype == 1:
@@ -306,11 +337,11 @@ class JRODataReader(JRODataIO):
         else:
             raise ValueError, 'Data type was not defined'
 
-        self.dataType = datatype_str
-        self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
-        self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
-#        self.dataOutObj.channelList = numpy.arange(self.m_SystemHeader.numChannels)
-#        self.dataOutObj.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
+        self.dtype = datatype_str
+        self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
+        self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
+#        self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
+#        self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
         self.getBlockDimension()
 
 
@@ -324,22 +355,22 @@ class JRODataReader(JRODataIO):
                 print "The file %s can't be opened" % (filename)
             return False
 
-        neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
+        neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
 
         if neededSize == 0:
-            m_BasicHeader = BasicHeader()
-            m_SystemHeader = SystemHeader()
-            m_RadarControllerHeader = RadarControllerHeader()
-            m_ProcessingHeader = ProcessingHeader()
+            basicHeaderObj = BasicHeader()
+            systemHeaderObj = SystemHeader()
+            radarControllerHeaderObj = RadarControllerHeader()
+            processingHeaderObj = ProcessingHeader()
 
             try:
-                if not( m_BasicHeader.read(fp) ): raise ValueError
-                if not( m_SystemHeader.read(fp) ): raise ValueError
-                if not( m_RadarControllerHeader.read(fp) ): raise ValueError
-                if not( m_ProcessingHeader.read(fp) ): raise ValueError
-                data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
+                if not( basicHeaderObj.read(fp) ): raise ValueError
+                if not( systemHeaderObj.read(fp) ): raise ValueError
+                if not( radarControllerHeaderObj.read(fp) ): raise ValueError
+                if not( processingHeaderObj.read(fp) ): raise ValueError
+                data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
 
-                neededSize = m_ProcessingHeader.blockSize + m_BasicHeader.size
+                neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
 
             except:
                 if msgFlag:
@@ -360,16 +391,274 @@ class JRODataReader(JRODataIO):
 
         return True
 
+class JRODataWriter(JRODataIO):
+
+    """ 
+    Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
+    de los datos siempre se realiza por bloques. 
+    """
+    
+    blockIndex = 0 
+
+    setFile = None
+    
+    
+    def __init__(self, dataOutObj=None):
+        raise ValueError, "Not implemented"
+
+
+    def hasAllDataInBuffer(self):
+        raise ValueError, "Not implemented"
+
+
+    def setBlockDimension(self):
+        raise ValueError, "Not implemented"
+
+    
+    def writeBlock(self):
+        raise ValueError, "No implemented"
+
+
+    def putData(self):
+        raise ValueError, "No implemented"
+
+    
+    def __writeFirstHeader(self):
+        """
+        Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
+        
+        Affected:
+            __dataType
+            
+        Return:
+            None
+        """
+        
+#        CALCULAR PARAMETROS
+        
+        sizeLongHeader = 0#XXXX
+        self.basicHeaderObj.size = 24 + sizeLongHeader
+        
+        self.__writeBasicHeader()
+        self.__wrSystemHeader()
+        self.__wrRadarControllerHeader()
+        self.__wrProcessingHeader()
+        self.dtype = self.dataOutObj.dtype
+            
+            
+    def __writeBasicHeader(self, fp=None):
+        """
+        Escribe solo el Basic header en el file creado
+
+        Return:
+            None
+        """
+        if fp == None:
+            fp = self.fp
+            
+        self.dataOutObj.basicHeaderObj.write(fp)
+
+    
+    def __wrSystemHeader(self, fp=None):
+        """
+        Escribe solo el System header en el file creado
+
+        Return:
+            None
+        """
+        if fp == None:
+            fp = self.fp
+            
+        self.dataOutObj.systemHeaderObj.write(fp)
+
+    
+    def __wrRadarControllerHeader(self, fp=None):
+        """
+        Escribe solo el RadarController header en el file creado
+
+        Return:
+            None
+        """
+        if fp == None:
+            fp = self.fp
+        
+        self.dataOutObj.radarControllerHeaderObj.write(fp)
+
+        
+    def __wrProcessingHeader(self, fp=None):
+        """
+        Escribe solo el Processing header en el file creado
+
+        Return:
+            None
+        """
+        if fp == None:
+            fp = self.fp
+            
+        self.dataOutObj.processingHeaderObj.write(fp)
+    
+    
+    def setNextFile(self):
+        """ 
+        Determina el siguiente file que sera escrito
+
+        Affected: 
+            self.filename
+            self.subfolder
+            self.fp
+            self.setFile
+            self.flagIsNewFile
+
+        Return:
+            0    :    Si el archivo no puede ser escrito
+            1    :    Si el archivo esta listo para ser escrito
+        """
+        ext = self.ext
+        path = self.path
+        
+        if self.fp != None:
+            self.fp.close()
+        
+        timeTuple = time.localtime( self.dataOutObj.dataUtcTime)
+        subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
+
+        doypath = os.path.join( path, subfolder )
+        if not( os.path.exists(doypath) ):
+            os.mkdir(doypath)
+            self.setFile = -1 #inicializo mi contador de seteo
+        else:
+            filesList = os.listdir( doypath )
+            if len( filesList ) > 0:
+                filesList = sorted( filesList, key=str.lower )
+                filen = filesList[-1]
+                # el filename debera tener el siguiente formato
+                # 0 1234 567 89A BCDE (hex)
+                # x YYYY DDD SSS .ext
+                if isNumber( filen[8:11] ):
+                    self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
+                else:    
+                    self.setFile = -1
+            else:
+                self.setFile = -1 #inicializo mi contador de seteo
+                
+        setFile = self.setFile
+        setFile += 1
+                
+        file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
+                                        timeTuple.tm_year,
+                                        timeTuple.tm_yday,
+                                        setFile,
+                                        ext )
+
+        filename = os.path.join( path, subfolder, file )
+
+        fp = open( filename,'wb' )
+        
+        self.blockIndex = 0
+        
+        #guardando atributos 
+        self.filename = filename
+        self.subfolder = subfolder
+        self.fp = fp
+        self.setFile = setFile
+        self.flagIsNewFile = 1
+        
+        print 'Writing the file: %s'%self.filename
+        
+        self.__writeFirstHeader()
+        
+        return 1
+
 
+    def __setNewBlock(self):
+        """
+        Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
+        
+        Return:
+            0    :    si no pudo escribir nada
+            1    :    Si escribio el Basic el First Header
+        """        
+        if self.fp == None:
+            self.setNextFile()
+        
+        if self.flagIsNewFile:
+            return 1
+        
+        if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
+            self.__writeBasicHeader()
+            return 1
+        
+        if not( self.setNextFile() ):
+            return 0
+        
+        return 1
 
-    def updateDataHeader(self):
-        self.dataOutObj.m_BasicHeader = self.m_BasicHeader.copy()
-        self.dataOutObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
-        self.dataOutObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
-        self.dataOutObj.m_SystemHeader = self.m_SystemHeader.copy()
-        self.dataOutObj.dataType = self.dataType
-        self.dataOutObj.updateObjFromHeader() # actualiza los atributos del objeto de salida de la clase JROData
 
+    def writeNextBlock(self):
+        """
+        Selecciona el bloque siguiente de datos y los escribe en un file
+            
+        Return: 
+            0    :    Si no hizo pudo escribir el bloque de datos 
+            1    :    Si no pudo escribir el bloque de datos
+        """
+        if not( self.__setNewBlock() ):
+            return 0
+        
+        self.writeBlock()
+
+        return 1
+    
+
+    def getDataHeader(self):
+        """
+        Obtiene una copia del First Header
+         
+        Affected:
+            self.basicHeaderObj
+            self.systemHeaderObj
+            self.radarControllerHeaderObj
+            self.processingHeaderObj
+            self.dtype
+
+        Return: 
+            None
+        """
+        
+        raise ValueError, "No implemented"        
+    
+    def setup(self, path, set=0, ext=None):
+        """
+        Setea el tipo de formato en la cual sera guardada la data y escribe el First Header 
+            
+        Inputs:
+            path      :    el path destino en el cual se escribiran los files a crear
+            format    :    formato en el cual sera salvado un file
+            set       :    el setebo del file
+            
+        Return:
+            0    :    Si no realizo un buen seteo
+            1    :    Si realizo un buen seteo 
+        """
+        
+        if ext == None:
+            ext = self.ext
+        
+        ext = ext.lower()
+
+        self.path = path
+        self.setFile = set - 1
+        self.ext = ext
+        #self.format = format
+        self.getDataHeader()
+
+        self.setBlockDimension()
+        
+        if not( self.setNextFile() ):
+            print "There isn't a next file"
+            return 0
+
+        return 1
 
 
 
diff --git a/schainpy2/IO/JROHeader.py b/schainpy2/IO/JROHeader.py
index 96de6eb..d799ec6 100644
--- a/schainpy2/IO/JROHeader.py
+++ b/schainpy2/IO/JROHeader.py
@@ -35,6 +35,7 @@ class BasicHeader(Header):
     struct = None
         
     def __init__(self):
+        
         self.size = 0
         self.version = 0
         self.dataBlock = 0
@@ -81,18 +82,18 @@ class BasicHeader(Header):
 class SystemHeader(Header):
     
     size = None
-    numSamples = None
-    numProfiles = None
-    numChannels = None
+    nSamples = None
+    nProfiles = None
+    nChannels = None
     adcResolution = None
     pciDioBusWidth = None
     struct = None
         
     def __init__(self):
         self.size = 0 
-        self.numSamples = 0
-        self.numProfiles = 0
-        self.numChannels = 0
+        self.nSamples = 0
+        self.nProfiles = 0
+        self.nChannels = 0
         self.adcResolution = 0
         self.pciDioBusWidth = 0
         self.struct = numpy.dtype([
@@ -109,9 +110,9 @@ class SystemHeader(Header):
         try:
             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.nSamples = header['nNumSamples'][0]
+            self.nProfiles = header['nNumProfiles'][0]
+            self.nChannels = header['nNumChannels'][0]
             self.adcResolution = header['nADCResolution'][0]
             self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
         except:
@@ -120,7 +121,7 @@ class SystemHeader(Header):
         return 1
     
     def write(self, fp):
-        headerTuple = (self.size,self.numSamples,self.numProfiles,self.numChannels,self.adcResolution,self.pciDioBusWidth)
+        headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
         header = numpy.array(headerTuple,self.struct)
         header.tofile(fp)
         
@@ -134,7 +135,7 @@ class RadarControllerHeader(Header):
     ipp = None
     txA = None
     txB = None
-    numWindows = None
+    nWindows = None
     numTaus = None
     codeType = None
     line6Function = None
@@ -154,7 +155,7 @@ class RadarControllerHeader(Header):
         self.ipp = 0
         self.txA = 0
         self.txB = 0
-        self.numWindows = 0
+        self.nWindows = 0
         self.numTaus = 0
         self.codeType = 0
         self.line6Function = 0
@@ -212,7 +213,7 @@ class RadarControllerHeader(Header):
             self.ipp = header['fIpp'][0]
             self.txA = header['fTxA'][0]
             self.txB = header['fTxB'][0]
-            self.numWindows = header['nNumWindows'][0]
+            self.nWindows = header['nNumWindows'][0]
             self.numTaus = header['nNumTaus'][0]
             self.codeType = header['nCodeType'][0]
             self.line6Function = header['nLine6Function'][0]
@@ -230,7 +231,7 @@ class RadarControllerHeader(Header):
             backFp = fp.tell() - jumpFp
             fp.seek(backFp)
             
-            self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.numWindows)
+            self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
             self.numHeights = numpy.sum(self.samplingWindow['nsa'])
             self.firstHeight = self.samplingWindow['h0']
             self.deltaHeight = self.samplingWindow['dh']
@@ -272,7 +273,7 @@ class RadarControllerHeader(Header):
                        self.ipp,
                        self.txA,
                        self.txB,
-                       self.numWindows,
+                       self.nWindows,
                        self.numTaus,
                        self.codeType,
                        self.line6Function,
@@ -297,14 +298,14 @@ class RadarControllerHeader(Header):
 class ProcessingHeader(Header):
     
     size = None
-    dataType = None
+    dtype = None
     blockSize = None
     profilesPerBlock = None
     dataBlocksPerFile = None
-    numWindows = None
+    nWindows = None
     processFlags = None
-    coherentInt = None
-    incoherentInt = None
+    nCohInt = None
+    nIncohInt = None
     totalSpectra = None
     struct = None
     flag_dc = None
@@ -316,10 +317,10 @@ class ProcessingHeader(Header):
         self.blockSize = 0
         self.profilesPerBlock = 0
         self.dataBlocksPerFile = 0
-        self.numWindows = 0
+        self.nWindows = 0
         self.processFlags = 0
-        self.coherentInt = 0
-        self.incoherentInt = 0
+        self.nCohInt = 0
+        self.nIncohInt = 0
         self.totalSpectra = 0
         self.struct = numpy.dtype([
                                ('nSize','<u4'),
@@ -355,12 +356,12 @@ class ProcessingHeader(Header):
             self.blockSize = header['nSizeOfDataBlock'][0]
             self.profilesPerBlock = header['nProfilesperBlock'][0]
             self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
-            self.numWindows = header['nNumWindows'][0]
+            self.nWindows = header['nNumWindows'][0]
             self.processFlags = header['nProcessFlags']
-            self.coherentInt = header['nCoherentIntegrations'][0]
-            self.incoherentInt = header['nIncoherentIntegrations'][0]
+            self.nCohInt = header['nCoherentIntegrations'][0]
+            self.nIncohInt = header['nIncoherentIntegrations'][0]
             self.totalSpectra = header['nTotalSpectra'][0]
-            self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.numWindows)
+            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']
@@ -406,16 +407,16 @@ class ProcessingHeader(Header):
                        self.blockSize,
                        self.profilesPerBlock,
                        self.dataBlocksPerFile,
-                       self.numWindows,
+                       self.nWindows,
                        self.processFlags,
-                       self.coherentInt,
-                       self.incoherentInt,
+                       self.nCohInt,
+                       self.nIncohInt,
                        self.totalSpectra)
         
         header = numpy.array(headerTuple,self.struct)  
         header.tofile(fp)
         
-        if self.numWindows != 0:
+        if self.nWindows != 0:
             sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
             samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
             samplingWindow.tofile(fp)
diff --git a/schainpy2/IO/VoltageIO.py b/schainpy2/IO/VoltageIO.py
index 9495b0d..f581c78 100644
--- a/schainpy2/IO/VoltageIO.py
+++ b/schainpy2/IO/VoltageIO.py
@@ -1,3 +1,9 @@
+'''
+Created on 23/01/2012
+
+@author $Author: dsuarez $
+@version $Id: VoltageIO.py 110 2012-07-19 15:18:18Z dsuarez $
+'''
 
 import os, sys
 import numpy
@@ -8,34 +14,481 @@ import time, datetime
 path = os.path.split(os.getcwd())[0]
 sys.path.append(path)
 
-from Model.JROHeader import *
-from Model.Voltage import Voltage
-
-from IO.JRODataIO import JRODataReader
+from JROHeader import *
+from JRODataIO import JRODataReader
+from JRODataIO import JRODataWriter
 
+from Data.Voltage import Voltage
 
 class VoltageReader(JRODataReader):
+    """
+    Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
+    de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones: 
+    perfiles*alturas*canales) son almacenados en la variable "buffer".
+     
+                             perfiles * alturas * canales  
+
+    Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, 
+    RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
+    cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
+    datos desde el "buffer" cada vez que se ejecute el metodo "getData".
+    
+    Example:
+    
+        dpath = "/home/myuser/data"
+        
+        startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
+        
+        endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
+        
+        readerObj = VoltageReader()
+        
+        readerObj.setup(dpath, startTime, endTime)
+        
+        while(True):
+            
+            #to get one profile 
+            profile =  readerObj.getData()
+             
+            #print the profile
+            print profile
+            
+            #If you want to see all datablock
+            print readerObj.datablock
+            
+            if readerObj.flagNoMoreFiles:
+                break
+            
+    """
     dataOutObj = None
+    
     datablock = None
+
     ext = ".r"
+    
     optchar = "D"
-
+    
+    
     def __init__(self, dataOutObj=None):
+        """
+        Inicializador de la clase VoltageReader para la lectura de datos de voltage.
+        
+        Input:
+            dataOutObj    :    Objeto de la clase Voltage. Este objeto sera utilizado para
+                              almacenar un perfil de datos cada vez que se haga un requerimiento
+                              (getData). El perfil sera obtenido a partir del buffer de datos,
+                              si el buffer esta vacio se hara un nuevo proceso de lectura de un
+                              bloque de datos.
+                              Si este parametro no es pasado se creara uno internamente.
+        
+        Variables afectadas:
+            self.dataOutObj
+        
+        Return:
+            None
+        """
+        
         self.datablock = None
-        #Por herencia no necesito instanciar nuevamente estos objetos
-        #self.m_BasicHeader = BasicHeader()
-        #self.m_SystemHeader = SystemHeader()
-        #self.m_RadarControllerHeader = RadarControllerHeader()
-        #self.m_ProcessingHeader = ProcessingHeader()
+        
+        self.utc = 0
+    
+        self.ext = ".r"
+        
+        self.optchar = "D"
+
+        self.basicHeaderObj = BasicHeader()
+        
+        self.systemHeaderObj = SystemHeader()
+        
+        self.radarControllerHeaderObj = RadarControllerHeader()
+        
+        self.processingHeaderObj = ProcessingHeader()
+        
         self.online = 0
+        
+        self.fp = None
+        
+        self.idFile = None
+        
+        self.startDateTime = None
+        
+        self.endDateTime = None
+        
+        self.dtype = None
+        
+        self.fileSizeByHeader = None
+        
+        self.filenameList = []
+        
+        self.filename = None
+        
+        self.fileSize = None
+        
+        self.firstHeaderSize = 0
+        
+        self.basicHeaderSize = 24
+        
+        self.pathList = []
+        
+        self.filenameList = []
+        
+        self.lastUTTime = 0
+        
+        self.maxTimeStep = 30
+            
+        self.flagNoMoreFiles = 0
+        
+        self.set = 0
+        
+        self.path = None
+        
+        self.profileIndex = 9999
 
+        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 = Voltage()
-
+        
         return dataObj
+    
+    def __hasNotDataInBuffer(self):
+        if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
+            return 1
+        return 0
+
 
     def getBlockDimension(self):
-        pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
+        """
+        Obtiene la cantidad de puntos a leer por cada bloque de datos
+        
+        Affected:
+            self.blocksize
+
+        Return:
+            None
+        """
+        pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.numHeights * self.systemHeaderObj.numChannels
         self.blocksize = pts2read
+
+            
+    def readBlock(self):
+        """
+        readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
+        (self.fp) y actualiza todos los parametros relacionados al bloque de datos
+        (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
+        es seteado a 0
+        
+        Inputs:
+            None
+            
+        Return:
+            None
+        
+        Affected:
+            self.profileIndex
+            self.datablock
+            self.flagIsNewFile
+            self.flagIsNewBlock
+            self.nTotalBlocks
+            
+        Exceptions: 
+            Si un bloque leido no es un bloque valido
+        """
+        
+        junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
         
+        try:
+            junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.numHeights, self.systemHeaderObj.numChannels) )
+        except:
+            print "The read block (%3d) has not enough data" %self.nReadBlocks
+            return 0
+        
+        junk = numpy.transpose(junk, (2,0,1))
+        self.datablock = junk['real'] + junk['imag']*1j
+        
+        self.profileIndex = 0
+        
+        self.flagIsNewFile = 0
+        self.flagIsNewBlock = 1
+
+        self.nTotalBlocks += 1
+        self.nReadBlocks += 1
+          
+        return 1
 
+    
+    def getData(self):
+        """
+        getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
+        con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
+        lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
+        
+        Ademas incrementa el contador del buffer en 1.
+        
+        Return:
+            data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
+                         buffer. Si no hay mas archivos a leer retorna None.
+            
+        Variables afectadas:
+            self.dataOutObj
+            self.profileIndex
+            
+        Affected:
+            self.dataOutObj
+            self.profileIndex
+            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.datablock == None:
+            self.dataOutObj.flagNoData = True
+            return 0
+        
+        self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
+        
+        self.dataOutObj.dtype = self.dtype
+        
+        self.dataOutObj.nChannels = self.systemHeaderObj.numChannels
+        
+        self.dataOutObj.nHeights = self.processingHeaderObj.numHeights
+        
+        self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
+        
+        xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.numHeights*self.processingHeaderObj.deltaHeight
+
+        self.dataOutObj.heightList = range(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight) 
+        
+        self.dataOutObj.channelList = range(self.systemHeaderObj.numChannels)
+        
+        self.dataOutObj.channelIndexList = range(self.systemHeaderObj.numChannels)
+        
+        self.dataOutObj.flagNoData = True
+        
+        self.dataOutObj.flagTimeBlock = self.flagTimeBlock
+        
+        self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.profileIndex * self.ippSeconds
+        
+        self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
+        
+        self.profileIndex += 1
+        
+        self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
+        
+        self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+    
+        return 1
+
+
+class VoltageWriter(JRODataWriter):
+    """ 
+    Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
+    de los datos siempre se realiza por bloques. 
+    """
+    __configHeaderFile = 'wrSetHeadet.txt'
+    
+    dataOutObj = None
+    
+    ext = ".r"
+    
+    optchar = "D"
+    
+    datablock = None
+    
+    profileIndex = 0
+    
+    shapeBuffer = None
+    
+
+    def __init__(self, dataOutObj=None):
+        """ 
+        Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
+         
+        Affected: 
+            self.dataOutObj
+
+        Return: None
+        """
+        if dataOutObj == None:
+            dataOutObj = Voltage()    
+        
+        if not( isinstance(dataOutObj, Voltage) ):
+            raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
+
+        self.dataOutObj = dataOutObj
+
+
+    def hasAllDataInBuffer(self):
+        if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
+            return 1
+        return 0
+
+
+    def setBlockDimension(self):
+        """
+        Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
+
+        Affected:
+            self.shape_spc_Buffer
+            self.shape_cspc_Buffer
+            self.shape_dc_Buffer
+
+        Return: None
+        """
+        self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
+                            self.processingHeaderObj.numHeights,
+                            self.systemHeaderObj.numChannels )
+            
+        self.datablock = numpy.zeros((self.systemHeaderObj.numChannels,
+                                     self.processingHeaderObj.profilesPerBlock,
+                                     self.processingHeaderObj.numHeights),
+                                     dtype=numpy.dtype('complex'))
+
+        
+    def writeBlock(self):
+        """
+        Escribe el buffer en el file designado
+            
+        Affected:
+            self.profileIndex 
+            self.flagIsNewFile
+            self.flagIsNewBlock
+            self.nTotalBlocks
+            self.blockIndex    
+            
+        Return: None
+        """
+        data = numpy.zeros( self.shapeBuffer, self.dtype )
+        
+        junk = numpy.transpose(self.datablock, (1,2,0))
+        
+        data['real'] = junk.real
+        data['imag'] = junk.imag
+        
+        data = data.reshape( (-1) )
+            
+        data.tofile( self.fp )
+        
+        self.datablock.fill(0)
+        
+        self.profileIndex = 0 
+        self.flagIsNewFile = 0
+        self.flagIsNewBlock = 1
+        
+        self.blockIndex += 1
+        self.nTotalBlocks += 1
+        
+    def putData(self):
+        """
+        Setea un bloque de datos y luego los escribe en un file 
+            
+        Affected:
+            self.flagIsNewBlock
+            self.profileIndex
+
+        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.datablock.fill(0)
+            self.profileIndex = 0
+            self.setNextFile()
+        
+        self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
+        
+        self.profileIndex += 1
+        
+        if self.hasAllDataInBuffer():
+            #if self.flagIsNewFile: 
+            self.getDataHeader()
+            self.writeNextBlock()
+        
+        if self.flagNoMoreFiles:
+            #print 'Process finished'
+            return 0
+        
+        return 1
+    
+    def getDataHeader(self):
+        
+        """
+        Obtiene una copia del First Header
+         
+        Affected:
+            self.systemHeaderObj
+            self.radarControllerHeaderObj
+            self.dtype
+
+        Return: 
+            None
+        """
+        
+#        CALCULAR PARAMETROS
+        
+        self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
+        self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
+        
+        self.basicHeaderObj.size = self.basicHeaderSize
+        self.basicHeaderObj.version = self.versionFile
+        self.basicHeaderObj.dataBlock = self.nTotalBlocks
+        self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
+        self.basicHeaderObj.miliSecond = 0
+        self.basicHeaderObj.timeZone = 0
+        self.basicHeaderObj.dstFlag = 0
+        self.basicHeaderObj.errorCount = 0
+        
+        self.processingHeaderObj.size = 0
+        self.processingHeaderObj.dtype = self.dataOutObj.dtype
+        self.processingHeaderObj.blockSize = 0
+        self.processingHeaderObj.profilesPerBlock = 0
+        self.processingHeaderObj.dataBlocksPerFile = 0
+        self.processingHeaderObj.numWindows = 0
+        self.processingHeaderObj.processFlags = 0
+        self.processingHeaderObj.coherentInt = 0
+        self.processingHeaderObj.incoherentInt = 0
+        self.processingHeaderObj.totalSpectra = 0
+        
+        self.dtype = self.dataOutObj.dtype
+        
\ No newline at end of file
diff --git a/schainpy2/Processing/VoltageProcessor.py b/schainpy2/Processing/VoltageProcessor.py
index 5eb7191..19e10fe 100644
--- a/schainpy2/Processing/VoltageProcessor.py
+++ b/schainpy2/Processing/VoltageProcessor.py
@@ -5,7 +5,7 @@ import numpy
 path = os.path.split(os.getcwd())[0]
 sys.path.append(path)
 
-from Model.Voltage import Voltage
+from Data.Voltage import Voltage
 
 
 class VoltageProcessor:
diff --git a/schainpy2/testSchainExp.py b/schainpy2/testSchainExp.py
index 8ac9164..841f1e2 100644
--- a/schainpy2/testSchainExp.py
+++ b/schainpy2/testSchainExp.py
@@ -21,6 +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.wrpath = "/Users/jro/Documents/RadarData/wr_data"
         
@@ -31,8 +32,8 @@ class TestSChain():
         self.endTime = datetime.time(14,1,1)
     
     def createObjects(self):        
+        
         self.readerObj = VoltageReader()
-        self.voltProcObj = VoltageProcessor()
 
         self.voltObj1 = self.readerObj.setup(
                                    path = self.path,