diff --git a/schainpy2/Data/JROData.py b/schainpy2/Data/JROData.py
index 1cc63de..9e84a66 100644
--- a/schainpy2/Data/JROData.py
+++ b/schainpy2/Data/JROData.py
@@ -40,11 +40,13 @@ class JROData:
     
     channelIndexList = None
     
-    flagNoData = False
+    flagNoData = True
     
     flagTimeBlock = False
     
-    dataUtcTime = None
+    utctime = None
+    
+    blocksize = None
     
     nCode = None
     
@@ -115,9 +117,11 @@ class Voltage(JROData):
         
         self.flagTimeBlock = False
         
-        self.dataUtcTime = None
+        self.utctime = None
         
         self.nCohInt = None
+        
+        self.blocksize = None
 
 class Spectra(JROData):
     
@@ -169,10 +173,12 @@ class Spectra(JROData):
         
         self.flagTimeBlock = False
         
-        self.dataUtcTime = None
+        self.utctime = None
         
         self.nIncohInt = None
         
+        self.blocksize = None
+        
         
 class SpectraHeis(JROData):
     
@@ -217,3 +223,7 @@ class SpectraHeis(JROData):
         self.flagTimeBlock = False
                 
         self.nPairs = 0
+        
+        self.utctime = None
+        
+        self.blocksize = None
diff --git a/schainpy2/Graphics/schainPlot.py b/schainpy2/Graphics/schainPlot.py
index fc43b98..7bdc643 100644
--- a/schainpy2/Graphics/schainPlot.py
+++ b/schainpy2/Graphics/schainPlot.py
@@ -5,57 +5,80 @@ import os
 from schainPlotLib import Driver
 
 class Figure:
+    
     __isDriverOpen = False
     __isFigureOpen = False
     __isConfig = False
+    
     drvObj = None
+    driver = None
     idfigure = None
     nframes = None
     wintitle = None
     colormap = None
-    driver = None
     overplot = None
+    colorbar = None
+    
+    frameObjList = []
+    
+    xw = None
+    yw = None
+    
     xmin = None
     xmax = None
     ymin = None
     ymax = None
+    
     minvalue = None
     maxvalue = None
     deltax = None
     deltay = None
-    frameObjList = []
+    
+    
     figuretitle = ""
     xrangestep = None
     
     def __init__(self,idfigure, nframes, wintitle, xw=600, yw=800, overplot=0, driver='plplot', colormap=None, colorbar= True, *args):
         
+        self.__isDriverOpen = False
+        self.__isFigureOpen = False
+        self.__isConfig = False
+    
         self.drvObj = Driver(driver, idfigure, xw, yw, wintitle, overplot, colormap, colorbar)
         self.driver = driver
         self.idfigure = idfigure
-        self.xw = xw
-        self.yw = yw
         self.nframes = nframes
         self.wintitle = wintitle
         self.colormap = colormap
         self.overplot = overplot
         self.colorbar = colorbar
+        
+        self.xw = xw
+        self.yw = yw
+        
+        self.frameObjList = []
+        
 #        self.showGraph1 = args[0]
 #        self.showGraph2 = args[1]  
         
         self.drvObj.driver.setFigure()
         self.drvObj.driver.setColormap(colormap)
-        
-        
     
     def __openDriver(self):
+        
         self.drvObj.driver.openDriver()
         
     def __initFigure(self):
+        
         nrows, ncolumns = self.getSubplots()
         self.drvObj.driver.openFigure()
         self.drvObj.driver.setFigTitle(self.figuretitle)
         self.drvObj.driver.setSubPlots(nrows, ncolumns)
     
+    def selectFigure(self):
+        
+        self.drvObj.driver.selectFigure()
+        
     def __isOutOfXRange(self,x):
         try:
             if ((x>=self.xmin) and (x<self.xmax)):
@@ -76,6 +99,7 @@ class Figure:
         raise ValueError, "No implemented"
     
     def save(self,filename):
+        
         self.drvObj.driver.save(filename)
     
     def plot1DArray(self, data1D, x=None, channelList=None, xmin=None, xmax=None, minvalue=None, maxvalue=None, figuretitle=None, save=False, gpath='./'):
@@ -118,9 +142,9 @@ class Figure:
                 self.drvObj.driver.closePage()
                 self.__isFigureOpen = False
         
-        
+        self.selectFigure()
         self.__initFigure()
-
+        
         for channel in channelList:
             frameObj = self.frameObjList[channel]
             frameObj.init(xmin=self.xmin,
@@ -218,6 +242,7 @@ class Figure:
                               self.deltay,
                               self.colorbar,
                               value)
+        self.selectFigure()
         
         for channel in channelList:
             dataCh = data[channel,:]
@@ -232,13 +257,20 @@ class Figure:
 
     
 class Frame:
+    
+    drvObj = None
+    idFrame = None
     nplots = None
     plotObjList = []
     title = ""
     
     def __init__(self,drvObj, idframe):
+        
         self.drvObj = drvObj
         self.idframe = idframe
+        nplots = None
+        self.plotObjList = []
+        
         self.createPlots()
     
     def createPlots(self):
@@ -270,6 +302,15 @@ class Frame:
 
 
 class Plot:
+    
+    drvObj = None
+    idframe = None
+    idplot = None
+    xi = None
+    yi = None
+    xw = None
+    yw = None
+        
     title = ""
     xlabel = ""
     ylabel = ""
@@ -287,6 +328,7 @@ class Plot:
     cbypos = None
     
     def __init__(self, drvObj, idframe, idplot, xi, yi, xw, yw):
+        
         self.drvObj = drvObj
         self.idframe = idframe
         self.idplot = idplot
diff --git a/schainpy2/Graphics/schainPlotLib.py b/schainpy2/Graphics/schainPlotLib.py
index a06b311..36bdd3c 100644
--- a/schainpy2/Graphics/schainPlotLib.py
+++ b/schainpy2/Graphics/schainPlotLib.py
@@ -43,6 +43,9 @@ class PlplotDriver:
         plplot.plparseopts([self.wintitle],plplot.PL_PARSE_FULL)
         plplot.plsetopt("geometry", "%dx%d"%(self.xw, self.yw))
 
+    def selectFigure(self):
+        
+        plplot.plsstrm(self.idfigure)
         
     def openDriver(self, pldriver=None):
         if pldriver == None:
@@ -421,7 +424,7 @@ class PlplotDriver:
             rgb_lvl = [8,8,4]  #Levels for RGB colors
         
         if ncolor == None:
-            raise ValueError, "The colormap selected is not valid"
+            raise ValueError, "The colormap selected (%s) is not valid" %(colormap)
         
         plplot.plscmap1n(ncolor)
         plplot.plscmap1l(1, pos, r, g, b)
diff --git a/schainpy2/IO/JRODataIO.py b/schainpy2/IO/JRODataIO.py
index ce703a7..85c9888 100644
--- a/schainpy2/IO/JRODataIO.py
+++ b/schainpy2/IO/JRODataIO.py
@@ -254,7 +254,7 @@ class JRODataReader(JRODataIO):
             pass
 
         else:
-            print "Searching files in offline mode"
+            print "Searching files in offline mode ..."
             pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
             
             if not(pathList):
diff --git a/schainpy2/IO/SpectraIO.py b/schainpy2/IO/SpectraIO.py
index 25bb612..0fa8b25 100644
--- a/schainpy2/IO/SpectraIO.py
+++ b/schainpy2/IO/SpectraIO.py
@@ -367,7 +367,7 @@ class SpectraReader(JRODataReader):
         
         self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
         
-        self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
+        self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
         
         self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
         
@@ -695,8 +695,8 @@ class SpectraWriter(JRODataWriter):
         self.basicHeaderObj.version = self.versionFile
         self.basicHeaderObj.dataBlock = self.nTotalBlocks
         
-        utc = numpy.floor(self.dataOutObj.dataUtcTime)
-        milisecond  = (self.dataOutObj.dataUtcTime - utc)* 1000.0
+        utc = numpy.floor(self.dataOutObj.utctime)
+        milisecond  = (self.dataOutObj.utctime - utc)* 1000.0
         
         self.basicHeaderObj.utc = utc
         self.basicHeaderObj.miliSecond = milisecond
diff --git a/schainpy2/IO/VoltageIO.py b/schainpy2/IO/VoltageIO.py
index 16c3f3c..32690f4 100644
--- a/schainpy2/IO/VoltageIO.py
+++ b/schainpy2/IO/VoltageIO.py
@@ -293,7 +293,7 @@ class VoltageReader(JRODataReader):
         
         self.dataOutObj.flagTimeBlock = self.flagTimeBlock
         
-        self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
+        self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
         
         self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
         
@@ -526,8 +526,8 @@ class VoltageWriter(JRODataWriter):
         self.basicHeaderObj.version = self.versionFile
         self.basicHeaderObj.dataBlock = self.nTotalBlocks
         
-        utc = numpy.floor(self.dataOutObj.dataUtcTime)
-        milisecond  = (self.dataOutObj.dataUtcTime - utc)* 1000.0
+        utc = numpy.floor(self.dataOutObj.utctime)
+        milisecond  = (self.dataOutObj.utctime - utc)* 1000.0
         
         self.basicHeaderObj.utc = utc
         self.basicHeaderObj.miliSecond = milisecond
diff --git a/schainpy2/Processing/SpectraProcessor.py b/schainpy2/Processing/SpectraProcessor.py
index 661190f..b36f54e 100644
--- a/schainpy2/Processing/SpectraProcessor.py
+++ b/schainpy2/Processing/SpectraProcessor.py
@@ -11,7 +11,7 @@ import datetime
 path = os.path.split(os.getcwd())[0]
 sys.path.append(path)
 
-from Data.JROData import SpectraHeis
+from Data.JROData import Spectra, SpectraHeis
 from IO.SpectraIO import SpectraWriter
 from Graphics.schainPlotTypes import ScopeFigure, SpcFigure
 #from JRONoise import Noise
@@ -48,8 +48,8 @@ class SpectraProcessor:
         self.plotObjIndex = None
         self.integratorOst = []
         self.plotObjList = []
-        self.noiseObj = bjList = []
-        self.writerObjLiNone
+        self.noiseObj = []
+        self.writerObjList = []
         self.buffer = None
         self.profIndex = 0
         
@@ -59,10 +59,24 @@ class SpectraProcessor:
             raise ValueError, "This SpectraProcessor.setup() function needs dataInObj input variable"
         
         if dataInObj.type == "Voltage":
-            if nFFTPoints == None:
+            if nFFTPoints == None: 
                 raise ValueError, "This SpectraProcessor.setup() function needs nFFTPoints input variable"
-        else:
+            
+            
+        
+        if dataInObj.type == "Spectra":
+            if nFFTPoints != None: 
+                raise ValueError, "The nFFTPoints cannot be selected to this object type"
+            
             nFFTPoints = dataInObj.nFFTPoints
+            
+            if pairList == None:
+                pairList = self.dataInObj.pairList
+        
+        if pairList == None:
+            nPairs = 0
+        else:
+            nPairs = len(pairList)
         
         self.dataInObj = dataInObj        
         
@@ -70,44 +84,55 @@ class SpectraProcessor:
             dataOutObj = Spectra()
             
         self.dataOutObj = dataOutObj
+        self.dataOutObj.nFFTPoints = nFFTPoints
+        self.dataOutObj.pairList = pairList
+        self.dataOutObj.nPairs = nPairs
         
         return self.dataOutObj
     
     def init(self):
         
+        self.dataOutObj.flagNoData = True
+        
+        if self.dataInObj.flagNoData:
+            return 0
+        
         self.integratorObjIndex = 0
         self.writerObjIndex = 0
         self.plotObjIndex = 0
+        
+        
+        if self.dataInObj.type == "Spectra":
+            
+            self.dataOutObj.copy(self.dataInObj)
+            self.dataOutObj.flagNoData = False
+            return
+        
         if self.dataInObj.type == "Voltage":
             
             if self.buffer == None:
-                self.buffer = numpy.zeros((self.nChannels,
-                                           self.nFFTPoints,
+                self.buffer = numpy.zeros((self.dataInObj.nChannels,
+                                           self.dataOutObj.nFFTPoints,
                                            self.dataInObj.nHeights), 
                                           dtype='complex')
             
             self.buffer[:,self.profIndex,:] = self.dataInObj.data
             self.profIndex += 1
             
-            if self.profIndex == self.nFFTPoints:
+            if self.profIndex == self.dataOutObj.nFFTPoints:
+                
+                self.__updateObjFromInput()
                 self.__getFft()
+                
                 self.dataOutObj.flagNoData = False
                 
                 self.buffer = None
                 self.profIndex = 0
-                return
             
-            self.dataOutObj.flagNoData = True
-            
-            return
-        
-        #Other kind of data
-        if self.dataInObj.type == "Spectra":
-            self.dataOutObj.copy(self.dataInObj)
-            self.dataOutObj.flagNoData = False
             return
         
-        raise ValueError, "The dtype is not valid"
+        #Other kind of data        
+        raise ValueError, "The type object %(s) is not valid " %(self.dataOutObj.type)
 
     def __getFft(self):
         """
@@ -136,9 +161,6 @@ class SpectraProcessor:
             self.dataOutObj.m_ProcessingHeader.spectraComb
             self.dataOutObj.m_ProcessingHeader.shif_fft
         """
-        
-        if self.dataInObj.flagNoData:
-            return 0
             
         fft_volt = numpy.fft.fft(self.buffer,axis=1)
         dc = fft_volt[:,0,:]
@@ -154,9 +176,9 @@ class SpectraProcessor:
         
         cspc = None
         pairIndex = 0
-        if self.pairList != None:
+        if self.dataOutObj.pairList != None:
             #calculo de cross-spectra
-            cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
+            cspc = numpy.zeros((self.dataOutObj.nPairs, self.dataOutObj.nFFTPoints, self.dataOutObj.nHeights), dtype='complex')
             for pair in self.pairList:
                 cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
                 pairIndex += 1
@@ -165,12 +187,33 @@ class SpectraProcessor:
         self.dataOutObj.data_spc = spc
         self.dataOutObj.data_cspc = cspc
         self.dataOutObj.data_dc = dc
-        self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
-        self.dataOutObj.m_BasicHeader.utc = self.dataInObj.m_BasicHeader.utc
+        self.dataOutObj.blockSize = blocksize
         
 #        self.getNoise()
+
+    def __updateObjFromInput(self):
+        
+        self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
+        self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
+        self.dataOutObj.channelList = self.dataInObj.channelList
+        self.dataOutObj.heightList = self.dataInObj.heightList
+        self.dataOutObj.dtype = self.dataInObj.dtype
+        self.dataOutObj.nHeights = self.dataInObj.nHeights
+        self.dataOutObj.nChannels = self.dataInObj.nChannels
+        self.dataOutObj.nBaud = self.dataInObj.nBaud
+        self.dataOutObj.nCode = self.dataInObj.nCode
+        self.dataOutObj.code = self.dataInObj.code
+        self.dataOutObj.nProfiles = self.dataOutObj.nFFTPoints
+        self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
+        self.dataOutObj.flagTimeBlock = self.dataInObj.flagTimeBlock
+        self.dataOutObj.utctime = self.dataInObj.utctime
+        self.dataOutObj.flagDecodeData = self.dataInObj.flagDecodeData #asumo q la data esta decodificada
+        self.dataOutObj.flagDeflipData = self.dataInObj.flagDeflipData #asumo q la data esta sin flip
+        self.dataOutObj.flagShiftFFT = self.dataInObj.flagShiftFFT
+        self.dataOutObj.nIncohInt = 1
         
     def addWriter(self, wrpath, blocksPerFile):
+        
         objWriter = SpectraWriter(self.dataOutObj)
         objWriter.setup(wrpath, blocksPerFile)
         self.writerObjList.append(objWriter)
@@ -181,6 +224,7 @@ class SpectraProcessor:
         self.integratorObjList.append(objIncohInt)
     
     def addSpc(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
+        
         spcObj = SpcFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
         self.plotObjList.append(spcObj)
     
@@ -193,16 +237,20 @@ class SpectraProcessor:
                     maxvalue=None,
                     wintitle='',
                     driver='plplot',
-                    colormap='br_greeen',
+                    colormap='br_green',
                     colorbar=True,
                     showprofile=False,
                     save=False,
-                    gpath=None):
+                    gpath=None,
+                    channelList = None):
         
         if self.dataOutObj.flagNoData:
             return 0
         
-        nframes = len(self.dataOutObj.channelList)
+        if channelList == None:
+            channelList = self.dataOutObj.channelList
+        
+        nframes = len(channelList)
         
         if len(self.plotObjList) <= self.plotObjIndex:
             self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
@@ -211,8 +259,6 @@ class SpectraProcessor:
                 
         y = self.dataOutObj.heightList
         
-        channelList = self.dataOutObj.channelList
-        
         data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])    
 #        noisedB = 10.*numpy.log10(noise)
         noisedB = numpy.arange(len(channelList)+1)
@@ -222,7 +268,7 @@ class SpectraProcessor:
             title = "%.2f"%noisedB[i]
             titleList.append(title)
         
-        thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+        thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
         dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
         figuretitle = "Spc Radar Data: %s"%dateTime
         
@@ -251,8 +297,9 @@ class SpectraProcessor:
     
     
     def writeData(self, wrpath, blocksPerFile):
+        
         if self.dataOutObj.flagNoData:
-                return 0
+            return 0
             
         if len(self.writerObjList) <= self.writerObjIndex:
             self.addWriter(wrpath, blocksPerFile)
@@ -313,13 +360,19 @@ class SpectraHeisProcessor:
         return self.dataOutObj
     
     def init(self):
+        
+        self.dataOutObj.flagNoData = True
+        
+        if self.dataInObj.flagNoData:
+            return 0
+        
         self.integratorObjIndex = 0
         self.writerObjIndex = 0
         self.plotObjIndex = 0
         
         if self.dataInObj.type == "Voltage":
+            self.__updateObjFromInput()
             self.__getFft()
-            self.__updateFromObj()
             self.dataOutObj.flagNoData = False
             return
             
@@ -331,7 +384,8 @@ class SpectraHeisProcessor:
         
         raise ValueError, "The type is not valid"
     
-    def __updateFromObj(self):
+    def __updateObjFromInput(self):
+        
         self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
         self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
         self.dataOutObj.channelList = self.dataInObj.channelList
@@ -347,15 +401,13 @@ class SpectraHeisProcessor:
         self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
         self.dataOutObj.flagNoData = self.dataInObj.flagNoData
         self.dataOutObj.flagTimeBlock = self.dataInObj.flagTimeBlock
-        self.dataOutObj.dataUtcTime = self.dataInObj.dataUtcTime
+        self.dataOutObj.utctime = self.dataInObj.utctime
         self.dataOutObj.flagDecodeData = self.dataInObj.flagDecodeData #asumo q la data esta decodificada
         self.dataOutObj.flagDeflipData = self.dataInObj.flagDeflipData #asumo q la data esta sin flip
         self.dataOutObj.flagShiftFFT = self.dataInObj.flagShiftFFT
         self.dataOutObj.nIncohInt = 1
     
     def __getFft(self):
-        if self.dataInObj.flagNoData:
-           return 0
            
         fft_volt = numpy.fft.fft(self.dataInObj.data, axis=1)        
         #print fft_volt
@@ -375,10 +427,12 @@ class SpectraHeisProcessor:
         return numpy.arange(int(self.nFFTPoints))
     
     def addIntegrator(self,N,timeInterval):
+        
         objIncohInt = IncoherentIntegration(N,timeInterval)
         self.integratorObjList.append(objIncohInt)
     
     def integrator(self, N=None, timeInterval=None):
+        
         if self.dataOutObj.flagNoData:
                 return 0
         
@@ -386,7 +440,7 @@ class SpectraHeisProcessor:
             self.addIntegrator(N,timeInterval)
         
         myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
-        myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.dataUtcTime)
+        myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.utctime)
         
         if myIncohIntObj.isReady:
             self.dataOutObj.data_spc = myIncohIntObj.data
@@ -403,6 +457,7 @@ class SpectraHeisProcessor:
 
         
     def addScope(self, idfigure, nframes, wintitle, driver):
+        
         if idfigure==None:
             idfigure = self.plotObjIndex
             
@@ -436,7 +491,7 @@ class SpectraHeisProcessor:
         
         x = numpy.arange(self.dataOutObj.nHeights)
         
-        thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+        thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
         
         dateTime = "%s"%(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
         date = "%s"%(thisDatetime.strftime("%d-%b-%Y"))
diff --git a/schainpy2/Processing/VoltageProcessor.py b/schainpy2/Processing/VoltageProcessor.py
index cc1513a..66c9328 100644
--- a/schainpy2/Processing/VoltageProcessor.py
+++ b/schainpy2/Processing/VoltageProcessor.py
@@ -85,15 +85,15 @@ class VoltageProcessor:
         data = self.dataOutObj.data * numpy.conjugate(self.dataOutObj.data)
         data = 10*numpy.log10(data.real)
         
-#        currenttime = self.dataOutObj.dataUtcTime
+#        currenttime = self.dataOutObj.utctime
 #        if timezone == "lt":
-        currenttime = self.dataOutObj.dataUtcTime - time.timezone
+        currenttime = self.dataOutObj.utctime - time.timezone
         
         range = self.dataOutObj.heightList
         
         channelList = self.dataOutObj.channelList
         
-        thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+        thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
         dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
         date = "%s"%(thisdatetime.strftime("%d-%b-%Y"))
         
@@ -159,7 +159,7 @@ class VoltageProcessor:
         if type =="iq":
             data1D = self.dataOutObj.data
         
-        thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+        thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
         
         dateTime = "%s"%(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
         date = "%s"%(thisDatetime.strftime("%d-%b-%Y"))