schain Commit - r1383:3e971ac8dea1 · Jicamarca Repository

Update2 for EW-Drifts

Percy Condor -

r1383:3e971ac8dea1

parent child

Context file:

r1383:3e971ac8dea1

Expand all files

The requested changes are too big and content was truncated. Show full diff

schainpy/admin.py +13 -13

             """
             The admin module contains all administrative classes relating to the schain python api.
             The main role of this module is to send some reports. It contains a
             notification class and a standard error handing class.
             $Id: admin.py 3966 2015-12-01 14:32:29Z miguel.urco $
             """
             import os
             import sys
             import time
             import traceback
             import smtplib
             if sys.version[0] == '3':
                 from configparser import ConfigParser
             else:
                 from ConfigParser import ConfigParser
             import io
             from threading import Thread
             from multiprocessing import Process
             from email.mime.text import MIMEText
             from email.mime.application import MIMEApplication
             from email.mime.multipart import MIMEMultipart
             import schainpy
             from schainpy.utils import log
             from schainpy.model.graphics.jroplot_base import popup
             def get_path():
                 '''
                 Return schainpy path
                 '''
                 try:
                     root = __file__
                     if os.path.islink(root):
                         root = os.path.realpath(root)
                     return os.path.dirname(os.path.abspath(root))
                 except:
                     log.error('I am sorry, but something is wrong... __file__ not found')
             class Alarm(Process):
                 '''
                 modes:
 - All
 - Send email
 - Popup message
 - Sound alarm
 - Send to alarm system TODO
                 '''
                 def __init__(self, modes=[], **kwargs):
                     Process.__init__(self)
                     self.modes = modes
                     self.kwargs = kwargs
                 @staticmethod
                 def play_sound():
                     sound = os.path.join(get_path(), 'alarm1.oga')
                     if os.path.exists(sound):
                         for __ in range(2):
                             os.system('paplay {}'.format(sound))
                             time.sleep(0.5)
                     else:
                         log.warning('Unable to play alarm, sound file not found', 'ADMIN')
                 @staticmethod
                 def send_email(**kwargs):
                     notifier = SchainNotify()
                     notifier.notify(**kwargs)
                 @staticmethod
                 def show_popup(message):
                     if isinstance(message, list):
                         message = message[-1]
                     popup(message)
                 @staticmethod
                 def send_alarm():
                     pass
                 @staticmethod
                 def get_kwargs(kwargs, keys):
                     ret = {}
                     for key in keys:
                         ret[key] = kwargs[key]
                     return ret
                 def run(self):
                     tasks = {
 : self.send_email,
 : self.show_popup,
 : self.play_sound,
 : self.send_alarm,
                     }
                     tasks_args = {
 : ['email', 'message', 'subject', 'subtitle', 'filename'],
 : ['message'],
 : [],
 : [],
                     }
                     procs = []
                     for mode in self.modes:
                         if 0 in self.modes:
                             for x in tasks:
                                 t = Thread(target=tasks[x], kwargs=self.get_kwargs(self.kwargs, tasks_args[x]))
                                 t.start()
                                 procs.append(t)
                             break
                         else:
                             t = Thread(target=tasks[mode], kwargs=self.get_kwargs(self.kwargs, tasks_args[mode]))
                             t.start()
                             procs.append(t)
                     for t in procs:
                         t.join()
             class SchainConfigure():
                 __DEFAULT_ADMINISTRATOR_EMAIL = "juan.espinoza@jro.igp.gob.pe"
                 __DEFAULT_EMAIL_SERVER = "jro-zimbra.igp.gob.pe"
                 __DEFAULT_SENDER_EMAIL = "notifier-schain@jro.igp.gob.pe"
                 __DEFAULT_SENDER_PASS = ""
                 __SCHAIN_ADMINISTRATOR_EMAIL = "CONTACT"
                 __SCHAIN_EMAIL_SERVER = "MAILSERVER"
                 __SCHAIN_SENDER_EMAIL = "MAILSERVER_ACCOUNT"
                 __SCHAIN_SENDER_PASS = "MAILSERVER_PASSWORD"
-                def __init__(self, initFile = None):
+                def __init__(self, initFile=None):
                     # Set configuration file
                     if (initFile == None):
                         self.__confFilePath = "/etc/schain.conf"
                     else:
                         self.__confFilePath = initFile
                     # open configuration file
                     try:
                         self.__confFile = open(self.__confFilePath, "r")
                     except IOError:
                         # can't read from file - use all hard-coded values
                         self.__initFromHardCode()
                         return
                     # create Parser using standard module ConfigParser
                     self.__parser = ConfigParser()
                     # read conf file into a StringIO with "[madrigal]\n" section heading prepended
                     strConfFile = io.StringIO("[schain]\n" + self.__confFile.read())
                     # parse StringIO configuration file
                     self.__parser.readfp(strConfFile)
                     # read information from configuration file
                     self.__readConfFile()
                     # close conf file
                     self.__confFile.close()
                 def __initFromHardCode(self):
                     self.__sender_email = self.__DEFAULT_SENDER_EMAIL
                     self.__sender_pass = self.__DEFAULT_SENDER_PASS
                     self.__admin_email = self.__DEFAULT_ADMINISTRATOR_EMAIL
                     self.__email_server = self.__DEFAULT_EMAIL_SERVER
                 def __readConfFile(self):
                     """__readConfFile is a private helper function that reads information from the parsed config file.
                     Inputs: None
                     Returns: Void.
                     Affects: Initializes class member variables that are found in the config file.
                     Exceptions: MadrigalError thrown if any key not found.
                     """
                     # get the sender email
                     try:
                         self.__sender_email = self.__parser.get("schain", self.__SCHAIN_SENDER_EMAIL)
                     except:
                         self.__sender_email = self.__DEFAULT_SENDER_EMAIL
                     # get the sender password
                     try:
                         self.__sender_pass = self.__parser.get("schain", self.__SCHAIN_SENDER_PASS)
                     except:
                         self.__sender_pass = self.__DEFAULT_SENDER_PASS
                     # get the administrator email
                     try:
                         self.__admin_email = self.__parser.get("schain", self.__SCHAIN_ADMINISTRATOR_EMAIL)
                     except:
                         self.__admin_email = self.__DEFAULT_ADMINISTRATOR_EMAIL
                     # get the server email
                     try:
                         self.__email_server = self.__parser.get("schain", self.__SCHAIN_EMAIL_SERVER)
                     except:
                         self.__email_server = self.__DEFAULT_EMAIL_SERVER
                 def getEmailServer(self):
                     return self.__email_server
                 def getSenderEmail(self):
                     return self.__sender_email
                 def getSenderPass(self):
                     return self.__sender_pass
                 def getAdminEmail(self):
                     return self.__admin_email
             class SchainNotify:
                 """SchainNotify is an object used to send messages to an administrator about a Schain software.
                 This object provides functions needed to send messages to an administrator about a Schain , for now
                 only sendAlert, which sends an email to the site administrator found is ADMIN_EMAIL
                 Usage example:
                     import schainpy.admin
                     try:
                         adminObj =  schainpy.admin.SchainNotify()
                         adminObj.sendAlert('This is important!', 'Important Message')
                     except schainpy.admin.SchainError, e:
                         print e.getExceptionStr()
                 Non-standard Python modules used:
                 None
                 Exceptions thrown: None - Note that SchainNotify tries every trick it knows to avoid
                 throwing exceptions, since this is the class that will generally be called when there is a problem.
                 Change history:
                 Written by "Miguel Urco":mailto:miguel.urco@jro.igp.gob.pe  Dec. 1, 2015
                 """
-                #constants
+                # constants
                 def __init__(self):
                     """__init__ initializes SchainNotify by getting some basic information from SchainDB and SchainSite.
                     Note that SchainNotify tries every trick it knows to avoid throwing exceptions, since
                     this is the class that will generally be called when there is a problem.
                     Inputs: Existing SchainDB object, by default = None.
                     Returns: void
                     Affects: Initializes self.__binDir.
                     Exceptions: None.
                     """
                     # note that the main configuration file is unavailable
                     # the best that can be done is send an email to root using localhost mailserver
                     confObj = SchainConfigure()
                     self.__emailFromAddress = confObj.getSenderEmail()
                     self.__emailPass = confObj.getSenderPass()
                     self.__emailToAddress = confObj.getAdminEmail()
-                    self.__emailServer  = confObj.getEmailServer()
+                    self.__emailServer = confObj.getEmailServer()
                 def sendEmail(self, email_from, email_to, subject='Error running ...', message="", subtitle="", filename="", html_format=True):
                     if not email_to:
                         return 0
                     if not self.__emailServer:
                         return 0
                     log.success('Sending email to {}...'.format(email_to), 'System')
                     msg = MIMEMultipart()
                     msg['Subject'] = subject
                     msg['From'] = "SChain API (v{}) <{}>".format(schainpy.__version__, email_from)
                     msg['Reply-to'] = email_from
                     msg['To'] = email_to
                     # That is what u see if dont have an email reader:
                     msg.preamble = 'SChainPy'
                     if html_format:
-                        message = "<h1> %s </h1>" %subject + "<h3>" + subtitle.replace("\n", "</h3><h3>\n") + "</h3>" + message.replace("\n", "<br>\n")
+                        message = "<h1> %s </h1>" % subject + "<h3>" + subtitle.replace("\n", "</h3><h3>\n") + "</h3>" + message.replace("\n", "<br>\n")
                         message = "<html>\n" + message + '</html>'
                         # This is the textual part:
                         part = MIMEText(message, "html")
                     else:
                         message = subject + "\n" + subtitle + "\n" + message
                         part = MIMEText(message)
                     msg.attach(part)
                     if filename and os.path.isfile(filename):
                         # This is the binary part(The Attachment):
-                        part = MIMEApplication(open(filename,"rb").read())
+                        part = MIMEApplication(open(filename, "rb").read())
                         part.add_header('Content-Disposition',
                                         'attachment',
                                         filename=os.path.basename(filename))
                         msg.attach(part)
                     # Create an instance in SMTP server
                     try:
                         smtp = smtplib.SMTP(self.__emailServer)
                     except:
                         log.error('Could not connect to server {}'.format(self.__emailServer), 'System')
                         return 0
                     # Start the server:
                 #         smtp.ehlo()
                     if self.__emailPass:
                         smtp.login(self.__emailFromAddress, self.__emailPass)
                     # Send the email
                     try:
                         smtp.sendmail(msg['From'], msg['To'], msg.as_string())
                     except:
                         log.error('Could not send the email to {}'.format(msg['To']), 'System')
                         smtp.quit()
                         return 0
                     smtp.quit()
                     log.success('Email sent ', 'System')
                     return 1
-                def sendAlert(self, message, subject = "", subtitle="", filename=""):
+                def sendAlert(self, message, subject="", subtitle="", filename=""):
                     """sendAlert sends an email with the given message and optional title.
                     Inputs: message (string), and optional title (string)
                     Returns: void
                     Affects: none
                     Exceptions: None.
                     """
                     if not self.__emailToAddress:
                         return 0
-                    print("***** Sending alert to %s *****" %self.__emailToAddress)
+                    print("***** Sending alert to %s *****" % self.__emailToAddress)
                     # set up message
-                    sent=self.sendEmail(email_from=self.__emailFromAddress,
+                    sent = self.sendEmail(email_from=self.__emailFromAddress,
                                        email_to=self.__emailToAddress,
                                        subject=subject,
                                        message=message,
                                        subtitle=subtitle,
                                        filename=filename)
                     if not sent:
                         return 0
                     return 1
-                def notify(self, email, message, subject = "", subtitle="", filename=""):
+                def notify(self, email, message, subject="", subtitle="", filename=""):
                     """notify sends an email with the given message and title to email.
                     Inputs: email (string), message (string), and subject (string)
                     Returns: void
                     Affects: none
                     Exceptions: None.
                     """
                     if email is None:
                         email = self.__emailToAddress
                     self.sendEmail(
                         email_from=self.__emailFromAddress,
                         email_to=email,
                         subject=subject,
                         message=message,
                         subtitle=subtitle,
                         filename=filename
                         )
             class SchainError(Exception):
                 """SchainError is an exception class that is thrown for all known errors using Schain Py lib.
                 Usage example:
                     import sys, traceback
                     import schainpy.admin
                     try:
                         test = open('ImportantFile.txt', 'r')
                     except:
                         raise schainpy.admin.SchainError('ImportantFile.txt not opened!',
                                                             traceback.format_exception(sys.exc_info()[0],
                                                                                     sys.exc_info()[1],
                                                                                     sys.exc_info()[2]))
                 """
                 def __init__(self, strInterpretation, exceptionList=None):
                     """ __init__ gathers the interpretation string along with all information from sys.exc_info().
                     Inputs:
                             strIntepretation - A string representing the programmer's interpretation of
                             why the exception occurred
                             exceptionList - a list of strings completely describing the exception.
                             Generated by traceback.format_exception(sys.exc_info()[0],
                                                                     sys.exc_info()[1],
                                                                     sys.exc_info()[2])
                     Returns: Void.
                     Affects: Initializes class member variables _strInterp, _strExcList.
                     Exceptions: None.
                     """
                     if not exceptionList:
                         exceptionList = traceback.format_exception(sys.exc_info()[0],
                                                                     sys.exc_info()[1],
                                                                     sys.exc_info()[2])
                     self._strInterp = strInterpretation
                     self._strExcList = exceptionList
                 def getExceptionStr(self):
                     """ getExceptionStr returns a formatted string ready for printing completely describing the exception.
                     Inputs: None
                     Returns: A formatted string ready for printing completely describing the exception.
                     Affects: None
                     Exceptions: None.
                     """
                     excStr = ''
                     excStr = excStr + self._strInterp + '\n\n'
                     if self._strExcList != None:
                         for item in self._strExcList:
                             excStr = excStr + str(item) + '\n'
                     return excStr
                 def __str__(self):
                     return(self.getExceptionStr())
                 def getExceptionHtml(self):
                     """ getExceptionHtml returns an Html formatted string completely describing the exception.
                     Inputs: None
                     Returns: A formatted string ready for printing completely describing the exception.
                     Affects: None
                     Exceptions: None.
                     """
                     excStr = '<BR>The following Schain Python exception has occurred:\n<BR>'
                     excStr = excStr + self._strInterp + '\n<BR>\n'
                     if self._strExcList != None:
                         for item in self._strExcList:
                             excStr = excStr + str(item) + '\n<BR>'
                     return excStr
             class SchainWarning(Exception):
                 pass
             if __name__ == '__main__':
                 test = SchainNotify()
                 test.sendAlert('This is a message from the python module SchainNotify', 'Test from SchainNotify')
-                print('Hopefully message sent - check.')
  No newline at end of file
+                print('Hopefully message sent - check.')

schainpy/cli/cli.py +1 -1

             import click
             import subprocess
             import os
             import sys
             import glob
             import schainpy
             from schainpy.controller import Project
             from schainpy.model import Operation, ProcessingUnit
             from schainpy.utils import log
             from importlib import import_module
             from pydoc import locate
             from fuzzywuzzy import process
             from schainpy.cli import templates
             import inspect
             try:
                 from queue import Queue
             except:
                 from Queue import Queue
             def getProcs():
                 modules = dir(schainpy.model)
                 procs = check_module(modules, 'processing')
                 try:
                     procs.remove('ProcessingUnit')
                 except Exception as e:
                     pass
                 return procs
             def getOperations():
                 module = dir(schainpy.model)
                 noProcs = [x for x in module if not x.endswith('Proc')]
                 operations = check_module(noProcs, 'operation')
                 try:
                     operations.remove('Operation')
                     operations.remove('Figure')
                     operations.remove('Plot')
                 except Exception as e:
                     pass
                 return operations
             def getArgs(op):
                 module = locate('schainpy.model.{}'.format(op))
                 try:
                     obj = module(1, 2, 3, Queue())
                 except:
                     obj = module()
                 if hasattr(obj, '__attrs__'):
                     args = obj.__attrs__
                 else:
                     if hasattr(obj, 'myrun'):
                         args = inspect.getfullargspec(obj.myrun).args
                     else:
                         args = inspect.getfullargspec(obj.run).args
                 try:
                     args.remove('self')
                 except Exception as e:
                     pass
                 try:
                     args.remove('dataOut')
                 except Exception as e:
                     pass
                 return args
             def getDoc(obj):
                 module = locate('schainpy.model.{}'.format(obj))
                 try:
                     obj = module(1, 2, 3, Queue())
                 except:
                     obj = module()
                 return obj.__doc__
             def getAll():
                 modules = getOperations()
                 modules.extend(getProcs())
                 return modules
             def print_version(ctx, param, value):
                 if not value or ctx.resilient_parsing:
                     return
                 click.echo(schainpy.__version__)
                 ctx.exit()
             PREFIX = 'experiment'
             @click.command()
             @click.option('--version', '-v', is_flag=True, callback=print_version, help='SChain version', type=str)
             @click.argument('command', default='run', required=True)
             @click.argument('nextcommand', default=None, required=False, type=str)
             def main(command, nextcommand, version):
                 """COMMAND LINE INTERFACE FOR SIGNAL CHAIN - JICAMARCA RADIO OBSERVATORY V3.0\n
                     Available commands:\n
                     xml: runs a schain XML generated file\n
                     run: runs any python script'\n
                     generate: generates a template schain script\n
                     list: return a list of available procs and operations\n
                     search: return avilable operations, procs or arguments of the given
                             operation/proc\n"""
                 if command == 'xml':
                     runFromXML(nextcommand)
                 elif command == 'generate':
                     generate()
                 elif command == 'test':
                     test()
                 elif command == 'run':
                     runschain(nextcommand)
                 elif command == 'search':
                     search(nextcommand)
                 elif command == 'list':
                     cmdlist(nextcommand)
                 else:
                     log.error('Command {} is not defined'.format(command))
             def check_module(possible, instance):
                 def check(x):
                     try:
                         instancia = locate('schainpy.model.{}'.format(x))
                         ret = instancia.proc_type == instance
                         return ret
                     except Exception as e:
                         return False
                 clean = clean_modules(possible)
                 return [x for x in clean if check(x)]
             def clean_modules(module):
                 noEndsUnder = [x for x in module if not x.endswith('__')]
                 noStartUnder = [x for x in noEndsUnder if not x.startswith('__')]
                 noFullUpper = [x for x in noStartUnder if not x.isupper()]
                 return noFullUpper
             def cmdlist(nextcommand):
                 if nextcommand is None:
                     log.error('Missing argument, available arguments: procs, operations', '')
                 elif nextcommand == 'procs':
                     procs = getProcs()
                     log.success(
                         'Current ProcessingUnits are:\n  {}'.format('\n  '.join(procs)), '')
                 elif nextcommand == 'operations':
                     operations = getOperations()
                     log.success('Current Operations are:\n  {}'.format(
                         '\n  '.join(operations)), '')
                 else:
                     log.error('Wrong argument', '')
             def search(nextcommand):
                 if nextcommand is None:
                     log.error('There is no Operation/ProcessingUnit to search', '')
                 else:
                     try:
                         args = getArgs(nextcommand)
                         doc = getDoc(nextcommand)
                         log.success('{}\n{}\n\nparameters:\n  {}'.format(
                             nextcommand, doc, ', '.join(args)), ''
                             )
                     except Exception as e:
                         log.error('Module `{}` does not exists'.format(nextcommand), '')
                         allModules = getAll()
-                        similar = [t[0] for t in process.extract(nextcommand, allModules, limit=12) if t[1]>80]
+                        similar = [t[0] for t in process.extract(nextcommand, allModules, limit=12) if t[1] > 80]
                         log.success('Possible modules are: {}'.format(', '.join(similar)), '')
             def runschain(nextcommand):
                 if nextcommand is None:
                     currentfiles = glob.glob('./{}_*.py'.format(PREFIX))
                     numberfiles = len(currentfiles)
                     if numberfiles > 1:
                         log.error('There is more than one file to run')
                     elif numberfiles == 1:
                         subprocess.call(['python ' + currentfiles[0]], shell=True)
                     else:
                         log.error('There is no file to run')
                 else:
                     try:
                         subprocess.call(['python ' + nextcommand], shell=True)
                     except Exception as e:
                         log.error("I cannot run the file. Does it exists?")
             def basicInputs():
                 inputs = {}
                 inputs['name'] = click.prompt(
                     'Name of the project', default="project", type=str)
                 inputs['desc'] = click.prompt(
                     'Enter a description', default="A schain project", type=str)
                 inputs['multiprocess'] = click.prompt(
                     '''Select data type:
                 - Voltage (*.r):                [1]
                 - Spectra (*.pdata):            [2]
                 - Voltage and Spectra (*.r):    [3]
                 -->''', type=int)
                 inputs['path'] = click.prompt('Data path', default=os.getcwd(
                 ), type=click.Path(exists=True, resolve_path=True))
                 inputs['startDate'] = click.prompt(
                     'Start date', default='1970/01/01', type=str)
                 inputs['endDate'] = click.prompt(
                     'End date', default='2018/12/31', type=str)
                 inputs['startHour'] = click.prompt(
                     'Start hour', default='00:00:00', type=str)
                 inputs['endHour'] = click.prompt('End hour', default='23:59:59', type=str)
                 inputs['figpath'] = inputs['path'] + '/figs'
                 return inputs
             def generate():
                 inputs = basicInputs()
                 if inputs['multiprocess'] == 1:
                     current = templates.voltage.format(**inputs)
                 elif inputs['multiprocess'] == 2:
                     current = templates.spectra.format(**inputs)
                 elif inputs['multiprocess'] == 3:
                     current = templates.voltagespectra.format(**inputs)
                 scriptname = '{}_{}.py'.format(PREFIX, inputs['name'])
                 script = open(scriptname, 'w')
                 try:
                     script.write(current)
                     log.success('Script {} generated'.format(scriptname))
                 except Exception as e:
                     log.error('I cannot create the file. Do you have writing permissions?')
             def test():
                 log.warning('testing')
             def runFromXML(filename):
                 controller = Project()
                 if not controller.readXml(filename):
                     return
                 controller.start()
                 return

schainpy/controller.py +6 -6

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """API to create signal chain projects
             The API is provide through class: Project
             """
             import re
             import sys
             import ast
             import datetime
             import traceback
             import time
             import multiprocessing
             from multiprocessing import Process, Queue
             from threading import Thread
             from xml.etree.ElementTree import ElementTree, Element, SubElement
             from schainpy.admin import Alarm, SchainWarning
             from schainpy.model import *
             from schainpy.utils import log
             if 'darwin' in sys.platform and sys.version_info[0] == 3 and sys.version_info[1] > 7:
                 multiprocessing.set_start_method('fork')
             class ConfBase():
                 def __init__(self):
                     self.id = '0'
                     self.name = None
                     self.priority = None
                     self.parameters = {}
                     self.object = None
                     self.operations = []
                 def getId(self):
                     return self.id
                 def getNewId(self):
                     return int(self.id) * 10 + len(self.operations) + 1
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     n = 1
                     for conf in self.operations:
                         conf_id = str(int(new_id) * 10 + n)
                         conf.updateId(conf_id)
                         n += 1
                 def getKwargs(self):
                     params = {}
                     for key, value in self.parameters.items():
                         if value not in (None, '', ' '):
                             params[key] = value
                     return params
                 def update(self, **kwargs):
                     for key, value in kwargs.items():
                         self.addParameter(name=key, value=value)
                 def addParameter(self, name, value, format=None):
                     '''
                     '''
                     if isinstance(value, str) and re.search(r'(\d+/\d+/\d+)', value):
                         self.parameters[name] = datetime.date(*[int(x) for x in value.split('/')])
                     elif isinstance(value, str) and re.search(r'(\d+:\d+:\d+)', value):
                         self.parameters[name] = datetime.time(*[int(x) for x in value.split(':')])
                     else:
                         try:
                             self.parameters[name] = ast.literal_eval(value)
                         except:
                             if isinstance(value, str) and ',' in value:
                                 self.parameters[name] = value.split(',')
                             else:
                                 self.parameters[name] = value
                 def getParameters(self):
                     params = {}
                     for key, value in self.parameters.items():
                         s = type(value).__name__
                         if s == 'date':
                             params[key] = value.strftime('%Y/%m/%d')
                         elif s == 'time':
                             params[key] = value.strftime('%H:%M:%S')
                         else:
                             params[key] = str(value)
                     return params
                 def makeXml(self, element):
                     xml = SubElement(element, self.ELEMENTNAME)
                     for label in self.xml_labels:
                         xml.set(label, str(getattr(self, label)))
                     for key, value in self.getParameters().items():
                         xml_param = SubElement(xml, 'Parameter')
                         xml_param.set('name', key)
                         xml_param.set('value', value)
                     for conf in self.operations:
                         conf.makeXml(xml)
                 def __str__(self):
                     if self.ELEMENTNAME == 'Operation':
                         s = '  {}[id={}]\n'.format(self.name, self.id)
                     else:
                         s = '{}[id={}, inputId={}]\n'.format(self.name, self.id, self.inputId)
                     for key, value in self.parameters.items():
                         if self.ELEMENTNAME == 'Operation':
                             s += '    {}: {}\n'.format(key, value)
                         else:
                             s += '  {}: {}\n'.format(key, value)
                     for conf in self.operations:
                         s += str(conf)
                     return s
             class OperationConf(ConfBase):
                 ELEMENTNAME = 'Operation'
                 xml_labels = ['id', 'name']
                 def setup(self, id, name, priority, project_id, err_queue):
                     self.id = str(id)
                     self.project_id = project_id
                     self.name = name
                     self.type = 'other'
                     self.err_queue = err_queue
                 def readXml(self, element, project_id, err_queue):
                     self.id = element.get('id')
                     self.name = element.get('name')
                     self.type = 'other'
                     self.project_id = str(project_id)
                     self.err_queue = err_queue
                     for elm in element.iter('Parameter'):
                         self.addParameter(elm.get('name'), elm.get('value'))
                 def createObject(self):
                     className = eval(self.name)
                     if 'Plot' in self.name or 'Writer' in self.name or 'Send' in self.name or 'print' in self.name:
                         kwargs = self.getKwargs()
                         opObj = className(self.id, self.id, self.project_id, self.err_queue, **kwargs)
                         opObj.start()
                         self.type = 'external'
                     else:
                         opObj = className()
                     self.object = opObj
                     return opObj
             class ProcUnitConf(ConfBase):
                 ELEMENTNAME = 'ProcUnit'
                 xml_labels = ['id', 'inputId', 'name']
                 def setup(self, project_id, id, name, datatype, inputId, err_queue):
                     '''
                     '''
                     if datatype == None and name == None:
                         raise ValueError('datatype or name should be defined')
                     if name == None:
                         if 'Proc' in datatype:
                             name = datatype
                         else:
                             name = '%sProc' % (datatype)
                     if datatype == None:
                         datatype = name.replace('Proc', '')
                     self.id = str(id)
                     self.project_id = project_id
                     self.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.err_queue = err_queue
                     self.operations = []
                     self.parameters = {}
                 def removeOperation(self, id):
-                    i = [1 if x.id==id else 0 for x in self.operations]
+                    i = [1 if x.id == id else 0 for x in self.operations]
                     self.operations.pop(i.index(1))
                 def getOperation(self, id):
                     for conf in self.operations:
                         if conf.id == id:
                             return conf
                 def addOperation(self, name, optype='self'):
                     '''
                     '''
                     id = self.getNewId()
                     conf = OperationConf()
                     conf.setup(id, name=name, priority='0', project_id=self.project_id, err_queue=self.err_queue)
                     self.operations.append(conf)
                     return conf
                 def readXml(self, element, project_id, err_queue):
                     self.id = element.get('id')
                     self.name = element.get('name')
                     self.inputId = None if element.get('inputId') == 'None' else element.get('inputId')
                     self.datatype = element.get('datatype', self.name.replace(self.ELEMENTNAME.replace('Unit', ''), ''))
                     self.project_id = str(project_id)
                     self.err_queue = err_queue
                     self.operations = []
                     self.parameters = {}
                     for elm in element:
                         if elm.tag == 'Parameter':
                             self.addParameter(elm.get('name'), elm.get('value'))
                         elif elm.tag == 'Operation':
                             conf = OperationConf()
                             conf.readXml(elm, project_id, err_queue)
                             self.operations.append(conf)
                 def createObjects(self):
                     '''
                     Instancia de unidades de procesamiento.
                     '''
                     className = eval(self.name)
                     kwargs = self.getKwargs()
                     procUnitObj = className()
                     procUnitObj.name = self.name
                     log.success('creating process...', self.name)
                     for conf in self.operations:
                         opObj = conf.createObject()
                         log.success('adding operation: {}, type:{}'.format(
                             conf.name,
                             conf.type), self.name)
                         procUnitObj.addOperation(conf, opObj)
                     self.object = procUnitObj
                 def run(self):
                     '''
                     '''
                     return self.object.call(**self.getKwargs())
             class ReadUnitConf(ProcUnitConf):
                 ELEMENTNAME = 'ReadUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.operations = []
                     self.parameters = {}
                 def setup(self, project_id, id, name, datatype, err_queue, path='', startDate='', endDate='',
                           startTime='', endTime='', server=None, **kwargs):
                     if datatype == None and name == None:
                         raise ValueError('datatype or name should be defined')
                     if name == None:
                         if 'Reader' in datatype:
                             name = datatype
-                            datatype = name.replace('Reader','')
+                            datatype = name.replace('Reader', '')
                         else:
                             name = '{}Reader'.format(datatype)
                     if datatype == None:
                         if 'Reader' in name:
-                            datatype = name.replace('Reader','')
+                            datatype = name.replace('Reader', '')
                         else:
                             datatype = name
                             name = '{}Reader'.format(name)
                     self.id = id
                     self.project_id = project_id
                     self.name = name
                     self.datatype = datatype
                     self.err_queue = err_queue
                     self.addParameter(name='path', value=path)
                     self.addParameter(name='startDate', value=startDate)
                     self.addParameter(name='endDate', value=endDate)
                     self.addParameter(name='startTime', value=startTime)
                     self.addParameter(name='endTime', value=endTime)
                     for key, value in kwargs.items():
                         self.addParameter(name=key, value=value)
             class Project(Process):
                 """API to create signal chain projects"""
                 ELEMENTNAME = 'Project'
                 def __init__(self, name=''):
                     Process.__init__(self)
                     self.id = '1'
                     if name:
                         self.name = '{} ({})'.format(Process.__name__, name)
                     self.filename = None
                     self.description = None
                     self.email = None
                     self.alarm = []
                     self.configurations = {}
                     # self.err_queue = Queue()
                     self.err_queue = None
                     self.started = False
                 def getNewId(self):
                     idList = list(self.configurations.keys())
                     id = int(self.id) * 10
                     while True:
                         id += 1
                         if str(id) in idList:
                             continue
                         break
                     return str(id)
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     keyList = list(self.configurations.keys())
                     keyList.sort()
                     n = 1
                     new_confs = {}
                     for procKey in keyList:
                         conf = self.configurations[procKey]
                         idProcUnit = str(int(self.id) * 10 + n)
                         conf.updateId(idProcUnit)
                         new_confs[idProcUnit] = conf
                         n += 1
                     self.configurations = new_confs
                 def setup(self, id=1, name='', description='', email=None, alarm=[]):
                     self.id = str(id)
                     self.description = description
                     self.email = email
                     self.alarm = alarm
                     if name:
                         self.name = '{} ({})'.format(Process.__name__, name)
                 def update(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def clone(self):
                     p = Project()
                     p.id = self.id
                     p.name = self.name
                     p.description = self.description
                     p.configurations = self.configurations.copy()
                     return p
                 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
                     '''
                     '''
                     if id is None:
                         idReadUnit = self.getNewId()
                     else:
                         idReadUnit = str(id)
                     conf = ReadUnitConf()
                     conf.setup(self.id, idReadUnit, name, datatype, self.err_queue, **kwargs)
                     self.configurations[conf.id] = conf
                     return conf
                 def addProcUnit(self, id=None, inputId='0', datatype=None, name=None):
                     '''
                     '''
                     if id is None:
                         idProcUnit = self.getNewId()
                     else:
                         idProcUnit = id
                     conf = ProcUnitConf()
                     conf.setup(self.id, idProcUnit, name, datatype, inputId, self.err_queue)
                     self.configurations[conf.id] = conf
                     return conf
                 def removeProcUnit(self, id):
                     if id in self.configurations:
                         self.configurations.pop(id)
                 def getReadUnit(self):
                     for obj in list(self.configurations.values()):
                         if obj.ELEMENTNAME == 'ReadUnit':
                             return obj
                     return None
                 def getProcUnit(self, id):
                     return self.configurations[id]
                 def getUnits(self):
                     keys = list(self.configurations)
                     keys.sort()
                     for key in keys:
                         yield self.configurations[key]
                 def updateUnit(self, id, **kwargs):
                     conf = self.configurations[id].update(**kwargs)
                 def makeXml(self):
                     xml = Element('Project')
                     xml.set('id', str(self.id))
                     xml.set('name', self.name)
                     xml.set('description', self.description)
                     for conf in self.configurations.values():
                         conf.makeXml(xml)
                     self.xml = xml
                 def writeXml(self, filename=None):
                     if filename == None:
                         if self.filename:
                             filename = self.filename
                         else:
                             filename = 'schain.xml'
                     if not filename:
                         print('filename has not been defined. Use setFilename(filename) for do it.')
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.access(os.path.dirname(abs_file), os.W_OK):
                         print('No write permission on %s' % os.path.dirname(abs_file))
                         return 0
                     if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
                         print('File %s already exists and it could not be overwriten' % abs_file)
                         return 0
                     self.makeXml()
                     ElementTree(self.xml).write(abs_file, method='xml')
                     self.filename = abs_file
                     return 1
                 def readXml(self, filename):
                     abs_file = os.path.abspath(filename)
                     self.configurations = {}
                     try:
                         self.xml = ElementTree().parse(abs_file)
                     except:
                         log.error('Error reading %s, verify file format' % filename)
                         return 0
                     self.id = self.xml.get('id')
                     self.name = self.xml.get('name')
                     self.description = self.xml.get('description')
                     for element in self.xml:
                         if element.tag == 'ReadUnit':
                             conf = ReadUnitConf()
                             conf.readXml(element, self.id, self.err_queue)
                             self.configurations[conf.id] = conf
                         elif element.tag == 'ProcUnit':
                             conf = ProcUnitConf()
                             input_proc = self.configurations[element.get('inputId')]
                             conf.readXml(element, self.id, self.err_queue)
                             self.configurations[conf.id] = conf
                     self.filename = abs_file
                     return 1
                 def __str__(self):
                     text = '\nProject[id=%s, name=%s, description=%s]\n\n' % (
                         self.id,
                         self.name,
                         self.description,
                         )
                     for conf in self.configurations.values():
                         text += '{}'.format(conf)
                     return text
                 def createObjects(self):
                     keys = list(self.configurations.keys())
                     keys.sort()
                     for key in keys:
                         conf = self.configurations[key]
                         conf.createObjects()
                         if conf.inputId is not None:
                             conf.object.setInput(self.configurations[conf.inputId].object)
                 def monitor(self):
                     t = Thread(target=self._monitor, args=(self.err_queue, self.ctx))
                     t.start()
                 def _monitor(self, queue, ctx):
                     import socket
                     procs = 0
                     err_msg = ''
                     while True:
                         msg = queue.get()
                         if '#_start_#' in msg:
                             procs += 1
                         elif '#_end_#' in msg:
-                            procs -=1
+                            procs -= 1
                         else:
                             err_msg = msg
                         if procs == 0 or 'Traceback' in err_msg:
                             break
                         time.sleep(0.1)
                     if '|' in err_msg:
                         name, err = err_msg.split('|')
                         if 'SchainWarning' in err:
                             log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), name)
                         elif 'SchainError' in err:
                             log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), name)
                         else:
                             log.error(err, name)
                     else:
                         name, err = self.name, err_msg
                     time.sleep(1)
                     ctx.term()
                     message = ''.join(err)
                     if err_msg:
                         subject = 'SChain v%s: Error running %s\n' % (
                             schainpy.__version__, self.name)
                         subtitle = 'Hostname: %s\n' % socket.gethostbyname(
                             socket.gethostname())
                         subtitle += 'Working directory: %s\n' % os.path.abspath('./')
                         subtitle += 'Configuration file: %s\n' % self.filename
                         subtitle += 'Time: %s\n' % str(datetime.datetime.now())
                         readUnitConfObj = self.getReadUnit()
                         if readUnitConfObj:
                             subtitle += '\nInput parameters:\n'
                             subtitle += '[Data path = %s]\n' % readUnitConfObj.parameters['path']
                             subtitle += '[Start date = %s]\n' % readUnitConfObj.parameters['startDate']
                             subtitle += '[End date = %s]\n' % readUnitConfObj.parameters['endDate']
                             subtitle += '[Start time = %s]\n' % readUnitConfObj.parameters['startTime']
                             subtitle += '[End time = %s]\n' % readUnitConfObj.parameters['endTime']
                         a = Alarm(
                             modes=self.alarm,
                             email=self.email,
                             message=message,
                             subject=subject,
                             subtitle=subtitle,
                             filename=self.filename
                         )
                         a.start()
                 def setFilename(self, filename):
                     self.filename = filename
                 def runProcs(self):
                     err = False
                     n = len(self.configurations)
                     while not err:
                         for conf in self.getUnits():
                             ok = conf.run()
                             if ok == 'Error':
                                 n -= 1
                                 continue
                             elif not ok:
                                 break
                         if n == 0:
                             err = True
                 def run(self):
                     log.success('\nStarting Project {} [id={}]'.format(self.name, self.id), tag='')
                     self.started = True
                     self.start_time = time.time()
                     self.createObjects()
                     self.runProcs()
                     log.success('{} Done (Time: {:4.2f}s)'.format(
                         self.name,
-                        time.time()-self.start_time), '')
+                        time.time() - self.start_time), '')

schainpy/model/data/BLTRheaderIO.py +146 -146

             '''
             $Author: murco $
             $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
             '''
             import sys
             import numpy
             import copy
             import datetime
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
-            FILE_STRUCTURE = numpy.dtype([          #HEADER 48bytes
+            FILE_STRUCTURE = numpy.dtype([  # HEADER 48bytes
-                                      ('FileMgcNumber','<u4'),      #0x23020100
+                                      ('FileMgcNumber', '<u4'),  # 0x23020100
-                                      ('nFDTdataRecors','<u4'),     #No Of FDT data records in this file (0 or more)
+                                      ('nFDTdataRecors', '<u4'),  # No Of FDT data records in this file (0 or more)
-                                      ('RadarUnitId','<u4'),
+                                      ('RadarUnitId', '<u4'),
-                                      ('SiteName','<s32'),          #Null terminated
+                                      ('SiteName', '<s32'),  # Null terminated
                                       ])
-            RECORD_STRUCTURE = numpy.dtype([         #RECORD HEADER 180+20N bytes
+            RECORD_STRUCTURE = numpy.dtype([  # RECORD HEADER 180+20N bytes
-                                        ('RecMgcNumber','<u4'),     #0x23030001
+                                        ('RecMgcNumber', '<u4'),  # 0x23030001
-                                        ('RecCounter','<u4'),       #Record counter(0,1, ...)
+                                        ('RecCounter', '<u4'),  # Record counter(0,1, ...)
-                                        ('Off2StartNxtRec','<u4'),  #Offset to start of next record form start of this record
+                                        ('Off2StartNxtRec', '<u4'),  # Offset to start of next record form start of this record
-                                        ('Off2StartData','<u4'),    #Offset to start of data from start of this record
+                                        ('Off2StartData', '<u4'),  # Offset to start of data from start of this record
-                                        ('EpTimeStamp','<i4'),      #Epoch time stamp of start of acquisition (seconds)
+                                        ('EpTimeStamp', '<i4'),  # Epoch time stamp of start of acquisition (seconds)
-                                        ('msCompTimeStamp','<u4'),  #Millisecond component of time stamp (0,...,999)
+                                        ('msCompTimeStamp', '<u4'),  # Millisecond component of time stamp (0,...,999)
-                                        ('ExpTagName','<s32'),      #Experiment tag name (null terminated)
+                                        ('ExpTagName', '<s32'),  # Experiment tag name (null terminated)
-                                        ('ExpComment','<s32'),      #Experiment comment (null terminated)
+                                        ('ExpComment', '<s32'),  # Experiment comment (null terminated)
-                                        ('SiteLatDegrees','<f4'),   #Site latitude (from GPS) in degrees (positive implies North)
+                                        ('SiteLatDegrees', '<f4'),  # Site latitude (from GPS) in degrees (positive implies North)
-                                        ('SiteLongDegrees','<f4'),  #Site longitude (from GPS) in degrees (positive implies East)
+                                        ('SiteLongDegrees', '<f4'),  # Site longitude (from GPS) in degrees (positive implies East)
-                                        ('RTCgpsStatus','<u4'),     #RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
+                                        ('RTCgpsStatus', '<u4'),  # RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
-                                        ('TransmitFrec','<u4'),     #Transmit frequency (Hz)
+                                        ('TransmitFrec', '<u4'),  # Transmit frequency (Hz)
-                                        ('ReceiveFrec','<u4'),      #Receive frequency
+                                        ('ReceiveFrec', '<u4'),  # Receive frequency
-                                        ('FirstOsciFrec','<u4'),    #First local oscillator frequency (Hz)
+                                        ('FirstOsciFrec', '<u4'),  # First local oscillator frequency (Hz)
-                                        ('Polarisation','<u4'),     #(0="O", 1="E", 2="linear 1", 3="linear2")
+                                        ('Polarisation', '<u4'),  # (0="O", 1="E", 2="linear 1", 3="linear2")
-                                        ('ReceiverFiltSett','<u4'), #Receiver filter settings (0,1,2,3)
+                                        ('ReceiverFiltSett', '<u4'),  # Receiver filter settings (0,1,2,3)
-                                        ('nModesInUse','<u4'),      #Number of modes in use (1 or 2)
+                                        ('nModesInUse', '<u4'),  # Number of modes in use (1 or 2)
-                                        ('DualModeIndex','<u4'),    #Dual Mode index number for these data (0 or 1)
+                                        ('DualModeIndex', '<u4'),  # Dual Mode index number for these data (0 or 1)
-                                        ('DualModeRange','<u4'),    #Dual Mode range correction for these data (m)
+                                        ('DualModeRange', '<u4'),  # Dual Mode range correction for these data (m)
-                                        ('nDigChannels','<u4'),     #Number of digital channels acquired (2*N)
+                                        ('nDigChannels', '<u4'),  # Number of digital channels acquired (2*N)
-                                        ('SampResolution','<u4'),   #Sampling resolution (meters)
+                                        ('SampResolution', '<u4'),  # Sampling resolution (meters)
-                                        ('nRangeGatesSamp','<u4'),  #Number of range gates sampled
+                                        ('nRangeGatesSamp', '<u4'),  # Number of range gates sampled
-                                        ('StartRangeSamp','<u4'),   #Start range of sampling (meters)
+                                        ('StartRangeSamp', '<u4'),  # Start range of sampling (meters)
-                                        ('PRFhz','<u4'),            #PRF (Hz)
+                                        ('PRFhz', '<u4'),  # PRF (Hz)
-                                        ('Integrations','<u4'),     #Integrations
+                                        ('Integrations', '<u4'),  # Integrations
-                                        ('nDataPointsTrsf','<u4'),  #Number of data points transformed
+                                        ('nDataPointsTrsf', '<u4'),  # Number of data points transformed
-                                        ('nReceiveBeams','<u4'),    #Number of receive beams stored in file (1 or N)
+                                        ('nReceiveBeams', '<u4'),  # Number of receive beams stored in file (1 or N)
-                                        ('nSpectAverages','<u4'),   #Number of spectral averages
+                                        ('nSpectAverages', '<u4'),  # Number of spectral averages
-                                        ('FFTwindowingInd','<u4'),  #FFT windowing index (0 = no window)
+                                        ('FFTwindowingInd', '<u4'),  # FFT windowing index (0 = no window)
-                                        ('BeamAngleAzim','<f4'),    #Beam steer angle (azimuth) in degrees (clockwise from true North)
+                                        ('BeamAngleAzim', '<f4'),  # Beam steer angle (azimuth) in degrees (clockwise from true North)
-                                        ('BeamAngleZen','<f4'),     #Beam steer angle (zenith) in degrees (0=> vertical)
+                                        ('BeamAngleZen', '<f4'),  # Beam steer angle (zenith) in degrees (0=> vertical)
-                                        ('AntennaCoord','<f24'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                                        ('AntennaCoord', '<f24'),  # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                                        ('RecPhaseCalibr','<f12'),   #Receiver phase calibration (degrees) - N values
+                                        ('RecPhaseCalibr', '<f12'),  # Receiver phase calibration (degrees) - N values
-                                        ('RecAmpCalibr','<f12'),     #Receiver amplitude calibration (ratio relative to receiver one) - N values
+                                        ('RecAmpCalibr', '<f12'),  # Receiver amplitude calibration (ratio relative to receiver one) - N values
-                                        ('ReceiverGaindB','<u12'),   #Receiver gains in dB - N values
+                                        ('ReceiverGaindB', '<u12'),  # Receiver gains in dB - N values
                                         ])
             class Header(object):
                 def __init__(self):
                     raise NotImplementedError
                 def read(self):
                     raise NotImplementedError
                 def write(self):
                     raise NotImplementedError
                 def printInfo(self):
                     message = "#"*50 + "\n"
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#"*50 + "\n"
                     keyList = list(self.__dict__.keys())
                     keyList.sort()
                     for key in keyList:
-                        message += "%s = %s" %(key, self.__dict__[key]) + "\n"
+                        message += "%s = %s" % (key, self.__dict__[key]) + "\n"
                     if "size" not in keyList:
                         attr = getattr(self, "size")
                         if attr:
-                            message += "%s = %s" %("size", attr) + "\n"
+                            message += "%s = %s" % ("size", attr) + "\n"
                     print(message)
             class FileHeader(Header):
-                FileMgcNumber= None
+                FileMgcNumber = None
-                nFDTdataRecors=None     #No Of FDT data records in this file (0 or more)
+                nFDTdataRecors = None  # No Of FDT data records in this file (0 or more)
-                RadarUnitId= None
+                RadarUnitId = None
-                SiteName= None
+                SiteName = None
-                #__LOCALTIME = None
+                # __LOCALTIME = None
                 def __init__(self, useLocalTime=True):
-                    self.FileMgcNumber= 0     #0x23020100
+                    self.FileMgcNumber = 0  # 0x23020100
-                    self.nFDTdataRecors=0     #No Of FDT data records in this file (0 or more)
+                    self.nFDTdataRecors = 0  # No Of FDT data records in this file (0 or more)
-                    self.RadarUnitId= 0
+                    self.RadarUnitId = 0
-                    self.SiteName= ""
+                    self.SiteName = ""
                     self.size = 48
-                    #self.useLocalTime = useLocalTime
+                    # self.useLocalTime = useLocalTime
                 def read(self, fp):
                     try:
-                        header = numpy.fromfile(fp, FILE_STRUCTURE,1)
+                        header = numpy.fromfile(fp, FILE_STRUCTURE, 1)
                         '''      numpy.fromfile(file, dtype, count, sep='')
                         file : file or str
                         Open file object or filename.
                         dtype : data-type
                         Data type of the returned array. For binary files, it is used to determine
                         the size and byte-order of the items in the file.
                         count : int
                         Number of items to read. -1 means all items (i.e., the complete file).
                         sep : str
                         Separator between items if file is a text file. Empty (“”) separator means
                         the file should be treated as binary. Spaces (” ”) in the separator match zero
                         or more whitespace characters. A separator consisting only of spaces must match
                         at least one whitespace.
                         '''
                     except Exception as e:
                         print("FileHeader: ")
                         print(eBasicHeader)
                         return 0
-                    self.FileMgcNumber= byte(header['FileMgcNumber'][0])
+                    self.FileMgcNumber = byte(header['FileMgcNumber'][0])
-                    self.nFDTdataRecors=int(header['nFDTdataRecors'][0])     #No Of FDT data records in this file (0 or more)
+                    self.nFDTdataRecors = int(header['nFDTdataRecors'][0])  # No Of FDT data records in this file (0 or more)
-                    self.RadarUnitId= int(header['RadarUnitId'][0])
+                    self.RadarUnitId = int(header['RadarUnitId'][0])
-                    self.SiteName= char(header['SiteName'][0])
+                    self.SiteName = char(header['SiteName'][0])
-                    if self.size <48:
+                    if self.size < 48:
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.FileMgcNumber,
                                    self.nFDTdataRecors,
                                    self.RadarUnitId,
                                    self.SiteName,
                                    self.size)
                     header = numpy.array(headerTuple, FILE_STRUCTURE)
                     #        numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
                     header.tofile(fp)
                     ''' ndarray.tofile(fid, sep, format)    Write array to a file as text or binary (default).
                     fid : file or str
                     An open file object, or a string containing a filename.
                     sep : str
                     Separator between array items for text output. If “” (empty), a binary file is written,
                     equivalent to file.write(a.tobytes()).
                     format : str
                     Format string for text file output. Each entry in the array is formatted to text by
                     first converting it to the closest Python type, and then using “format” % item.
                     '''
                     return 1
             class RecordHeader(Header):
-                RecMgcNumber=None     #0x23030001
+                RecMgcNumber = None  # 0x23030001
-                RecCounter= None
+                RecCounter = None
-                Off2StartNxtRec= None
+                Off2StartNxtRec = None
-                EpTimeStamp= None
+                EpTimeStamp = None
-                msCompTimeStamp= None
+                msCompTimeStamp = None
-                ExpTagName= None
+                ExpTagName = None
-                ExpComment=None
+                ExpComment = None
-                SiteLatDegrees=None
+                SiteLatDegrees = None
-                SiteLongDegrees= None
+                SiteLongDegrees = None
-                RTCgpsStatus= None
+                RTCgpsStatus = None
-                TransmitFrec= None
+                TransmitFrec = None
-                ReceiveFrec= None
+                ReceiveFrec = None
-                FirstOsciFrec= None
+                FirstOsciFrec = None
-                Polarisation= None
+                Polarisation = None
-                ReceiverFiltSett= None
+                ReceiverFiltSett = None
-                nModesInUse= None
+                nModesInUse = None
-                DualModeIndex= None
+                DualModeIndex = None
-                DualModeRange= None
+                DualModeRange = None
-                nDigChannels= None
+                nDigChannels = None
-                SampResolution= None
+                SampResolution = None
-                nRangeGatesSamp= None
+                nRangeGatesSamp = None
-                StartRangeSamp= None
+                StartRangeSamp = None
-                PRFhz= None
+                PRFhz = None
-                Integrations= None
+                Integrations = None
-                nDataPointsTrsf= None
+                nDataPointsTrsf = None
-                nReceiveBeams= None
+                nReceiveBeams = None
-                nSpectAverages= None
+                nSpectAverages = None
-                FFTwindowingInd= None
+                FFTwindowingInd = None
-                BeamAngleAzim= None
+                BeamAngleAzim = None
-                BeamAngleZen= None
+                BeamAngleZen = None
-                AntennaCoord= None
+                AntennaCoord = None
-                RecPhaseCalibr= None
+                RecPhaseCalibr = None
-                RecAmpCalibr= None
+                RecAmpCalibr = None
-                ReceiverGaindB= None
+                ReceiverGaindB = None
                 '''size = None
                 nSamples = None
                 nProfiles = None
                 nChannels = None
                 adcResolution = None
                 pciDioBusWidth = None'''
-                def __init__(self,      RecMgcNumber=None,    RecCounter= 0,       Off2StartNxtRec= 0,
+                def __init__(self, RecMgcNumber=None, RecCounter=0, Off2StartNxtRec=0,
-                                        EpTimeStamp= 0,    msCompTimeStamp= 0,  ExpTagName= None,
+                                        EpTimeStamp=0, msCompTimeStamp=0, ExpTagName=None,
-                                        ExpComment=None,      SiteLatDegrees=0,    SiteLongDegrees= 0,
+                                        ExpComment=None, SiteLatDegrees=0, SiteLongDegrees=0,
-                                        RTCgpsStatus= 0,   TransmitFrec= 0,     ReceiveFrec= 0,
+                                        RTCgpsStatus=0, TransmitFrec=0, ReceiveFrec=0,
-                                        FirstOsciFrec= 0,  Polarisation= 0,     ReceiverFiltSett= 0,
+                                        FirstOsciFrec=0, Polarisation=0, ReceiverFiltSett=0,
-                                        nModesInUse= 0,    DualModeIndex= 0,    DualModeRange= 0,
+                                        nModesInUse=0, DualModeIndex=0, DualModeRange=0,
-                                        nDigChannels= 0,   SampResolution= 0,   nRangeGatesSamp= 0,
+                                        nDigChannels=0, SampResolution=0, nRangeGatesSamp=0,
-                                        StartRangeSamp= 0, PRFhz= 0,            Integrations= 0,
+                                        StartRangeSamp=0, PRFhz=0, Integrations=0,
-                                        nDataPointsTrsf= 0,  nReceiveBeams= 0,  nSpectAverages= 0,
+                                        nDataPointsTrsf=0, nReceiveBeams=0, nSpectAverages=0,
-                                        FFTwindowingInd= 0,  BeamAngleAzim= 0,  BeamAngleZen= 0,
+                                        FFTwindowingInd=0, BeamAngleAzim=0, BeamAngleZen=0,
-                                        AntennaCoord= 0,   RecPhaseCalibr= 0,   RecAmpCalibr= 0,
+                                        AntennaCoord=0, RecPhaseCalibr=0, RecAmpCalibr=0,
-                                        ReceiverGaindB= 0):
+                                        ReceiverGaindB=0):
-                    self.RecMgcNumber = RecMgcNumber     #0x23030001
+                    self.RecMgcNumber = RecMgcNumber  # 0x23030001
                     self.RecCounter = RecCounter
                     self.Off2StartNxtRec = Off2StartNxtRec
                     self.EpTimeStamp = EpTimeStamp
                     self.msCompTimeStamp = msCompTimeStamp
                     self.ExpTagName = ExpTagName
                     self.ExpComment = ExpComment
                     self.SiteLatDegrees = SiteLatDegrees
                     self.SiteLongDegrees = SiteLongDegrees
                     self.RTCgpsStatus = RTCgpsStatus
                     self.TransmitFrec = TransmitFrec
                     self.ReceiveFrec = ReceiveFrec
                     self.FirstOsciFrec = FirstOsciFrec
                     self.Polarisation = Polarisation
                     self.ReceiverFiltSett = ReceiverFiltSett
                     self.nModesInUse = nModesInUse
                     self.DualModeIndex = DualModeIndex
                     self.DualModeRange = DualModeRange
                     self.nDigChannels = nDigChannels
                     self.SampResolution = SampResolution
                     self.nRangeGatesSamp = nRangeGatesSamp
                     self.StartRangeSamp = StartRangeSamp
                     self.PRFhz = PRFhz
                     self.Integrations = Integrations
                     self.nDataPointsTrsf = nDataPointsTrsf
                     self.nReceiveBeams = nReceiveBeams
                     self.nSpectAverages = nSpectAverages
                     self.FFTwindowingInd = FFTwindowingInd
                     self.BeamAngleAzim = BeamAngleAzim
                     self.BeamAngleZen = BeamAngleZen
                     self.AntennaCoord = AntennaCoord
                     self.RecPhaseCalibr = RecPhaseCalibr
                     self.RecAmpCalibr = RecAmpCalibr
                     self.ReceiverGaindB = ReceiverGaindB
                 def read(self, fp):
-                    startFp = fp.tell() #The method tell() returns the current position of the file read/write pointer within the file.
+                    startFp = fp.tell()  # The method tell() returns the current position of the file read/write pointer within the file.
                     try:
-                        header = numpy.fromfile(fp,RECORD_STRUCTURE,1)
+                        header = numpy.fromfile(fp, RECORD_STRUCTURE, 1)
                     except Exception as e:
                         print("System Header: " + e)
                         return 0
-                    self.RecMgcNumber = header['RecMgcNumber'][0]     #0x23030001
+                    self.RecMgcNumber = header['RecMgcNumber'][0]  # 0x23030001
                     self.RecCounter = header['RecCounter'][0]
                     self.Off2StartNxtRec = header['Off2StartNxtRec'][0]
                     self.EpTimeStamp = header['EpTimeStamp'][0]
                     self.msCompTimeStamp = header['msCompTimeStamp'][0]
                     self.ExpTagName = header['ExpTagName'][0]
                     self.ExpComment = header['ExpComment'][0]
                     self.SiteLatDegrees = header['SiteLatDegrees'][0]
                     self.SiteLongDegrees = header['SiteLongDegrees'][0]
                     self.RTCgpsStatus = header['RTCgpsStatus'][0]
                     self.TransmitFrec = header['TransmitFrec'][0]
                     self.ReceiveFrec = header['ReceiveFrec'][0]
                     self.FirstOsciFrec = header['FirstOsciFrec'][0]
                     self.Polarisation = header['Polarisation'][0]
                     self.ReceiverFiltSett = header['ReceiverFiltSett'][0]
                     self.nModesInUse = header['nModesInUse'][0]
                     self.DualModeIndex = header['DualModeIndex'][0]
                     self.DualModeRange = header['DualModeRange'][0]
                     self.nDigChannels = header['nDigChannels'][0]
                     self.SampResolution = header['SampResolution'][0]
                     self.nRangeGatesSamp = header['nRangeGatesSamp'][0]
                     self.StartRangeSamp = header['StartRangeSamp'][0]
                     self.PRFhz = header['PRFhz'][0]
                     self.Integrations = header['Integrations'][0]
                     self.nDataPointsTrsf = header['nDataPointsTrsf'][0]
                     self.nReceiveBeams = header['nReceiveBeams'][0]
                     self.nSpectAverages = header['nSpectAverages'][0]
                     self.FFTwindowingInd = header['FFTwindowingInd'][0]
                     self.BeamAngleAzim = header['BeamAngleAzim'][0]
                     self.BeamAngleZen = header['BeamAngleZen'][0]
                     self.AntennaCoord = header['AntennaCoord'][0]
                     self.RecPhaseCalibr = header['RecPhaseCalibr'][0]
                     self.RecAmpCalibr = header['RecAmpCalibr'][0]
                     self.ReceiverGaindB = header['ReceiverGaindB'][0]
-                    Self.size = 180+20*3
+                    Self.size = 180 + 20 * 3
                     endFp = self.size + startFp
                     if fp.tell() > endFp:
-                        sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
+                        sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" % fp.name)
                         return 0
                     if fp.tell() < endFp:
-                        sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
+                        sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" % fp.name)
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.RecMgcNumber,
                                    self.RecCounter,
                                    self.Off2StartNxtRec,
                                    self.EpTimeStamp,
                                    self.msCompTimeStamp,
                                    self.ExpTagName,
                                    self.ExpComment,
                                    self.SiteLatDegrees,
                                    self.SiteLongDegrees,
                                    self.RTCgpsStatus,
                                    self.TransmitFrec,
                                    self.ReceiveFrec,
                                    self.FirstOsciFrec,
                                    self.Polarisation,
                                    self.ReceiverFiltSett,
                                    self.nModesInUse,
                                    self.DualModeIndex,
                                    self.DualModeRange,
                                    self.nDigChannels,
                                    self.SampResolution,
                                    self.nRangeGatesSamp,
                                    self.StartRangeSamp,
                                    self.PRFhz,
                                    self.Integrations,
                                    self.nDataPointsTrsf,
                                    self.nReceiveBeams,
                                    self.nSpectAverages,
                                    self.FFTwindowingInd,
                                    self.BeamAngleAzim,
                                    self.BeamAngleZen,
                                    self.AntennaCoord,
                                    self.RecPhaseCalibr,
                                    self.RecAmpCalibr,
                                    self.ReceiverGaindB)
             #                        self.size,self.nSamples,
             #                        self.nProfiles,
             #                        self.nChannels,
             #                        self.adcResolution,
             #                        self.pciDioBusWidth
-                    header = numpy.array(headerTuple,RECORD_STRUCTURE)
+                    header = numpy.array(headerTuple, RECORD_STRUCTURE)
                     header.tofile(fp)
                     return 1
             def get_dtype_index(numpy_dtype):
                 index = None
                 for i in range(len(NUMPY_DTYPE_LIST)):
                     if numpy_dtype == NUMPY_DTYPE_LIST[i]:
                         index = i
                         break
                 return index
             def get_numpy_dtype(index):
-                #dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
+                # dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                 return NUMPY_DTYPE_LIST[index]
             def get_dtype_width(index):
-                return DTYPE_WIDTH[index]
  No newline at end of file
+                return DTYPE_WIDTH[index]

schainpy/model/data/__init__.py +1 -1

             from .jrodata import *
             from .jroheaderIO import *
-            from .jroamisr import *
  No newline at end of file
+            from .jroamisr import *

schainpy/model/data/jroamisr.py +26 -26

             import numpy
             import copy
             class Beam:
                 def __init__(self):
                     self.codeList = []
                     self.azimuthList = []
                     self.zenithList = []
             class AMISR:
                 def __init__(self):
                     self.flagNoData = True
                     self.data = None
                     self.utctime = None
                     self.type = "AMISR"
-                    #propiedades para compatibilidad con Voltages
+                    # propiedades para compatibilidad con Voltages
-                    self.timeZone = 0#timezone like jroheader, difference in minutes between UTC and localtime
+                    self.timeZone = 0  # timezone like jroheader, difference in minutes between UTC and localtime
-                    self.dstFlag = 0#self.dataIn.dstFlag
+                    self.dstFlag = 0  # self.dataIn.dstFlag
-                    self.errorCount = 0#self.dataIn.errorCount
+                    self.errorCount = 0  # self.dataIn.errorCount
-                    self.useLocalTime = True#self.dataIn.useLocalTime
+                    self.useLocalTime = True  # self.dataIn.useLocalTime
-                    self.radarControllerHeaderObj = None#self.dataIn.radarControllerHeaderObj.copy()
+                    self.radarControllerHeaderObj = None  # self.dataIn.radarControllerHeaderObj.copy()
-                    self.systemHeaderObj = None#self.dataIn.systemHeaderObj.copy()
+                    self.systemHeaderObj = None  # self.dataIn.systemHeaderObj.copy()
-                    self.channelList = [0]#self.dataIn.channelList esto solo aplica para el caso de AMISR
+                    self.channelList = [0]  # self.dataIn.channelList esto solo aplica para el caso de AMISR
-                    self.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
+                    self.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
-                    self.flagDiscontinuousBlock = None#self.dataIn.flagDiscontinuousBlock
+                    self.flagDiscontinuousBlock = None  # self.dataIn.flagDiscontinuousBlock
-                    #self.utctime = #self.firstdatatime
+                    # self.utctime = #self.firstdatatime
-                    self.flagDecodeData = None#self.dataIn.flagDecodeData #asumo q la data esta decodificada
+                    self.flagDecodeData = None  # self.dataIn.flagDecodeData #asumo q la data esta decodificada
-                    self.flagDeflipData = None#self.dataIn.flagDeflipData #asumo q la data esta sin flip
+                    self.flagDeflipData = None  # self.dataIn.flagDeflipData #asumo q la data esta sin flip
-                    self.nCohInt = 1#self.dataIn.nCohInt
+                    self.nCohInt = 1  # self.dataIn.nCohInt
                     self.nIncohInt = 1
-                    self.ippSeconds = None#self.dataIn.ippSeconds, segun el filename/Setup/Tufile
+                    self.ippSeconds = None  # self.dataIn.ippSeconds, segun el filename/Setup/Tufile
-                    self.windowOfFilter = None#self.dataIn.windowOfFilter
+                    self.windowOfFilter = None  # self.dataIn.windowOfFilter
-                    self.timeInterval = None#self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
+                    self.timeInterval = None  # self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
-                    self.frequency = None#self.dataIn.frequency
+                    self.frequency = None  # self.dataIn.frequency
-                    self.realtime = 0#self.dataIn.realtime
+                    self.realtime = 0  # self.dataIn.realtime
-                    #actualizar en la lectura de datos
+                    # actualizar en la lectura de datos
-                    self.heightList = None#self.dataIn.heightList
+                    self.heightList = None  # self.dataIn.heightList
-                    self.nProfiles = None#Number of samples or nFFTPoints
+                    self.nProfiles = None  # Number of samples or nFFTPoints
                     self.nRecords = None
                     self.nBeams = None
-                    self.nBaud = None#self.dataIn.nBaud
+                    self.nBaud = None  # self.dataIn.nBaud
-                    self.nCode = None#self.dataIn.nCode
+                    self.nCode = None  # self.dataIn.nCode
-                    self.code = None#self.dataIn.code
+                    self.code = None  # self.dataIn.code
-                    #consideracion para los Beams
+                    # consideracion para los Beams
                     self.beamCodeDict = None
                     self.beamRangeDict = None
                     self.beamcode = None
                     self.azimuth = None
                     self.zenith = None
                     self.gain = None
                     self.npulseByFrame = None
                     self.profileIndex = None
                     self.beam = Beam()
                 def copy(self, inputObj=None):
                     if inputObj is None:
                         return copy.deepcopy(self)
                     for key in list(inputObj.__dict__.keys()):
                         self.__dict__[key] = inputObj.__dict__[key]
                 @property
                 def nHeights(self):
                     return len(self.heightList)
                 def isEmpty(self):
                     return self.flagNoData
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt

schainpy/model/data/jrodata.py +17 -17

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Definition of diferent Data objects for different types of data
             Here you will find the diferent data objects for the different types
             of data, this data objects must be used as dataIn or dataOut objects in
             processing units and operations. Currently the supported data objects are:
             Voltage, Spectra, SpectraHeis, Fits, Correlation and Parameters
             """
             import copy
             import numpy
             import datetime
             import json
             import schainpy.admin
             from schainpy.utils import log
             from .jroheaderIO import SystemHeader, RadarControllerHeader
             from schainpy.model.data import _noise
             def getNumpyDtype(dataTypeCode):
                 if dataTypeCode == 0:
                     numpyDtype = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                 elif dataTypeCode == 1:
                     numpyDtype = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                 elif dataTypeCode == 2:
                     numpyDtype = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                 elif dataTypeCode == 3:
                     numpyDtype = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                 elif dataTypeCode == 4:
                     numpyDtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                 elif dataTypeCode == 5:
                     numpyDtype = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                 else:
                     raise ValueError('dataTypeCode was not defined')
                 return numpyDtype
             def getDataTypeCode(numpyDtype):
                 if numpyDtype == numpy.dtype([('real', '<i1'), ('imag', '<i1')]):
                     datatype = 0
                 elif numpyDtype == numpy.dtype([('real', '<i2'), ('imag', '<i2')]):
                     datatype = 1
                 elif numpyDtype == numpy.dtype([('real', '<i4'), ('imag', '<i4')]):
                     datatype = 2
                 elif numpyDtype == numpy.dtype([('real', '<i8'), ('imag', '<i8')]):
                     datatype = 3
                 elif numpyDtype == numpy.dtype([('real', '<f4'), ('imag', '<f4')]):
                     datatype = 4
                 elif numpyDtype == numpy.dtype([('real', '<f8'), ('imag', '<f8')]):
                     datatype = 5
                 else:
                     datatype = None
                 return datatype
             def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of the noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     mean    :    noise's level
                 """
                 sortdata = numpy.sort(data, axis=None)
                 '''
                 lenOfData = len(sortdata)
                 nums_min = lenOfData*0.2
                 if nums_min <= 5:
                     nums_min = 5
                 sump = 0.
                 sumq = 0.
                 j = 0
                 cont = 1
                 while((cont == 1)and(j < lenOfData)):
                     sump += sortdata[j]
                     sumq += sortdata[j]**2
                     if j > nums_min:
                         rtest = float(j)/(j-1) + 1.0/navg
                         if ((sumq*j) > (rtest*sump**2)):
                             j = j - 1
                             sump = sump - sortdata[j]
                             sumq = sumq - sortdata[j]**2
                             cont = 0
                     j += 1
                 lnoise = sump / j
                 '''
                 return _noise.hildebrand_sekhon(sortdata, navg)
             class Beam:
                 def __init__(self):
                     self.codeList = []
                     self.azimuthList = []
                     self.zenithList = []
             class GenericData(object):
                 flagNoData = True
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in list(inputObj.__dict__.keys()):
                         attribute = inputObj.__dict__[key]
                         # If this attribute is a tuple or list
                         if type(inputObj.__dict__[key]) in (tuple, list):
                             self.__dict__[key] = attribute[:]
                             continue
                         # If this attribute is another object or instance
                         if hasattr(attribute, '__dict__'):
                             self.__dict__[key] = attribute.copy()
                             continue
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
                 def isReady(self):
                     return not self.flagNoData
             class JROData(GenericData):
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 type = None
                 datatype = None  # dtype but in string
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
                 flagDecodeData = False  # asumo q la data no esta decodificada
                 flagDeflipData = False  # asumo q la data no esta sin flip
                 flagShiftFFT = False
                 nCohInt = None
                 windowOfFilter = 1
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 error = None
                 data = None
                 nmodes = None
                 metadata_list = ['heightList', 'timeZone', 'type']
                 def __str__(self):
                     return '{} - {}'.format(self.type, self.datatime())
                 def getNoise(self):
                     raise NotImplementedError
                 @property
                 def nChannels(self):
                     return len(self.channelList)
                 @property
                 def channelIndexList(self):
                     return list(range(self.nChannels))
                 @property
                 def nHeights(self):
                     return len(self.heightList)
                 def getDeltaH(self):
                     return self.heightList[1] - self.heightList[0]
                 @property
                 def ltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
                 @property
                 def datatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval + 1)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmaxTimeResponse(self):
-                    period = (10**-6) * self.getDeltaH() / (0.15)
+                    period = (10 ** -6) * self.getDeltaH() / (0.15)
                     PRF = 1. / (period * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getFmax(self):
                     PRF = 1. / (self.ippSeconds * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getVmax(self):
                     _lambda = self.C / self.frequency
                     vmax = self.getFmax() * _lambda / 2
                     return vmax
                 @property
                 def ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 @ippSeconds.setter
                 def ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                 @property
                 def code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 @code.setter
                 def code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                 @property
                 def nCode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 @nCode.setter
                 def nCode(self, ncode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = ncode
                 @property
                 def nBaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 @nBaud.setter
                 def nBaud(self, nbaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nbaud
                 @property
                 def ipp(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ipp
                 @ipp.setter
                 def ipp(self, ipp):
                     '''
                     '''
                     self.radarControllerHeaderObj.ipp = ipp
                 @property
                 def metadata(self):
                     '''
                     '''
                     return {attr: getattr(self, attr) for attr in self.metadata_list}
             class Voltage(JROData):
-                dataPP_POW   = None
+                dataPP_POW = None
-                dataPP_DOP   = None
+                dataPP_DOP = None
                 dataPP_WIDTH = None
-                dataPP_SNR   = None
+                dataPP_SNR = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = 0
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagCohInt = False
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False  # Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'nProfiles', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp']
                 def getNoisebyHildebrand(self, channel=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     if channel != None:
                         data = self.data[channel]
                         nChannels = 1
                     else:
                         data = self.data
                         nChannels = self.nChannels
                     noise = numpy.zeros(nChannels)
                     power = data * numpy.conjugate(data)
                     for thisChannel in range(nChannels):
                         if nChannels == 1:
                             daux = power[:].real
                         else:
                             daux = power[thisChannel, :].real
                         noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
                     return noise
                 def getNoise(self, type=1, channel=None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel)
                     return noise
                 def getPower(self, channel=None):
                     if channel != None:
                         data = self.data[channel]
                     else:
                         data = self.data
                     power = data * numpy.conjugate(data)
                     powerdB = 10 * numpy.log10(power.real)
                     powerdB = numpy.squeeze(powerdB)
                     return powerdB
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt
                 noise = property(getNoise, "I'm the 'nHeights' property.")
             class Spectra(JROData):
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
                     self.timeZone = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'pairsList', 'channelList', 'nCohInt',
-                        'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp','nIncohInt', 'nFFTPoints', 'nProfiles']
+                        'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp', 'nIncohInt', 'nFFTPoints', 'nProfiles']
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,
                                              xmin_index:xmax_index, ymin_index:ymax_index]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation is not None:
                         # this was estimated by getNoise Operation defined in jroproc_spectra.py
                         return self.noise_estimation
                     else:
                         noise = self.getNoisebyHildebrand(
                             xmin_index, xmax_index, ymin_index, ymax_index)
                         return noise
                 def getFreqRangeTimeResponse(self, extrapoints=0):
                     deltafreq = self.getFmaxTimeResponse() / (self.nFFTPoints * self.ippFactor)
                     freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getAcfRange(self, extrapoints=0):
                     deltafreq = 10. / (self.getFmax() / (self.nFFTPoints * self.ippFactor))
-                    freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) -self.nFFTPoints / 2.) - deltafreq / 2
+                    freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints * self.ippFactor)
-                    freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) -self.nFFTPoints / 2.) - deltafreq / 2
+                    freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints * self.ippFactor)
                     velrange = deltav * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.)
                     if self.nmodes:
-                        return velrange/self.nmodes
+                        return velrange / self.nmodes
                     else:
                         return velrange
                 @property
                 def nPairs(self):
                     return len(self.pairsList)
                 @property
                 def pairsIndexList(self):
                     return list(range(self.nPairs))
                 @property
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
-                        pwcode = numpy.sum(self.code[0]**2)
+                        pwcode = numpy.sum(self.code[0] ** 2)
-                    #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
+                    # normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles * self.nIncohInt * self.nCohInt * pwcode * self.windowOfFilter
                     return normFactor
                 @property
                 def flag_cspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 @property
                 def flag_dc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 @property
                 def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles * self.ippFactor
                     if self.nmodes:
-                        return self.nmodes*timeInterval
+                        return self.nmodes * timeInterval
                     else:
                         return timeInterval
                 def getPower(self):
                     factor = self.normFactor
                     z = self.data_spc / factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     return 10 * numpy.log10(avg)
                 def getCoherence(self, pairsList=None, phase=False):
                     z = []
                     if pairsList is None:
                         pairsIndexList = self.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in self.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" % (
                                     pair))
                             pairsIndexList.append(self.pairsList.index(pair))
                     for i in range(len(pairsIndexList)):
                         pair = self.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(self.data_cspc[pairsIndexList[i], :, :], axis=0)
                         powa = numpy.average(self.data_spc[pair[0], :, :], axis=0)
                         powb = numpy.average(self.data_spc[pair[1], :, :], axis=0)
                         avgcoherenceComplex = ccf / numpy.sqrt(powa * powb)
                         if phase:
                             data = numpy.arctan2(avgcoherenceComplex.imag,
                                                  avgcoherenceComplex.real) * 180 / numpy.pi
                         else:
                             data = numpy.abs(avgcoherenceComplex)
                         z.append(data)
                     return numpy.array(z)
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
             class SpectraHeis(Spectra):
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 @property
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
-                        pwcode = numpy.sum(self.code[0]**2)
+                        pwcode = numpy.sum(self.code[0] ** 2)
                     normFactor = self.nIncohInt * self.nCohInt * pwcode
                     return normFactor
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt * self.nIncohInt
             class Fits(JROData):
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
                     self.timeZone = 0
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNoise(self, type=1):
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 @property
                 def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 @property
                 def ippSeconds(self):
                     '''
                     '''
                     return self.ipp_sec
                 noise = property(getNoise, "I'm the 'nHeights' property.")
             class Correlation(JROData):
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = 0
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getPairsList(self):
                     return self.pairsList
                 def getNoise(self, mode=2):
                     indR = numpy.where(self.lagR == 0)[0][0]
                     indT = numpy.where(self.lagT == 0)[0][0]
                     jspectra0 = self.data_corr[:, :, indR, :]
                     jspectra = copy.copy(jspectra0)
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = jspectra.shape[1] / 2
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     if ind_vel[0] < 0:
                         ind_vel[list(range(0, 1))] = ind_vel[list(
                             range(0, 1))] + self.num_prof
                     if mode == 1:
                         jspectra[:, freq_dc, :] = (
                             jspectra[:, ind_vel[1], :] + jspectra[:, ind_vel[2], :]) / 2  # CORRECCION
                     if mode == 2:
                         vel = numpy.array([-2, -1, 1, 2])
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
-                            xx[fil, :] = vel[fil]**numpy.asarray(list(range(4)))
+                            xx[fil, :] = vel[fil] ** numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                         for ich in range(num_chan):
                             yy = jspectra[ich, ind_vel, :]
                             jspectra[ich, freq_dc, :] = numpy.dot(xx_aux, yy)
                             junkid = jspectra[ich, freq_dc, :] <= 0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich, freq_dc, junkid.nonzero()] = (
                                     jspectra[ich, ind_vel[1], junkid] + jspectra[ich, ind_vel[2], junkid]) / 2
                     noise = jspectra0[:, freq_dc, :] - jspectra[:, freq_dc, :]
                     return noise
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt * self.nProfiles
                 def splitFunctions(self):
                     pairsList = self.pairsList
                     ccf_pairs = []
                     acf_pairs = []
                     ccf_ind = []
                     acf_ind = []
                     for l in range(len(pairsList)):
                         chan0 = pairsList[l][0]
                         chan1 = pairsList[l][1]
                         # Obteniendo pares de Autocorrelacion
                         if chan0 == chan1:
                             acf_pairs.append(chan0)
                             acf_ind.append(l)
                         else:
                             ccf_pairs.append(pairsList[l])
                             ccf_ind.append(l)
                     data_acf = self.data_cf[acf_ind]
                     data_ccf = self.data_cf[ccf_ind]
                     return acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf
                 @property
                 def normFactor(self):
                     acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.splitFunctions()
                     acf_pairs = numpy.array(acf_pairs)
                     normFactor = numpy.zeros((self.nPairs, self.nHeights))
                     for p in range(self.nPairs):
                         pair = self.pairsList[p]
                         ch0 = pair[0]
                         ch1 = pair[1]
                         ch0_max = numpy.max(data_acf[acf_pairs == ch0, :, :], axis=1)
                         ch1_max = numpy.max(data_acf[acf_pairs == ch1, :, :], axis=1)
                         normFactor[p, :] = numpy.sqrt(ch0_max * ch1_max)
                     return normFactor
             class Parameters(Spectra):
                 groupList = None  # List of Pairs, Groups, etc
                 data_param = None  # Parameters obtained
                 data_pre = None  # Data Pre Parametrization
                 data_SNR = None  # Signal to Noise Ratio
                 abscissaList = None  # Abscissa, can be velocities, lags or time
                 utctimeInit = None  # Initial UTC time
                 paramInterval = None  # Time interval to calculate Parameters in seconds
                 useLocalTime = True
                 # Fitting
                 data_error = None  # Error of the estimation
                 constants = None
                 library = None
                 # Output signal
                 outputInterval = None  # Time interval to calculate output signal in seconds
                 data_output = None  # Out signal
                 nAvg = None
                 noise_estimation = None
                 GauSPC = None  # Fit gaussian SPC
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                     self.timeZone = 0
                 def getTimeRange1(self, interval):
                     datatime = []
                     if self.useLocalTime:
                         time1 = self.utctimeInit - self.timeZone * 60
                     else:
                         time1 = self.utctimeInit
                     datatime.append(time1)
                     datatime.append(time1 + interval)
                     datatime = numpy.array(datatime)
                     return datatime
                 @property
                 def timeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                         return self.paramInterval
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 def getNoise(self):
                     return self.spc_noise
                 noise = property(getNoise, setValue, "I'm the 'Noise' property.")
             class PlotterData(object):
                 '''
                 Object to hold data to be plotted
                 '''
                 MAXNUMX = 200
                 MAXNUMY = 200
                 def __init__(self, code, exp_code, localtime=True):
                     self.key = code
                     self.exp_code = exp_code
                     self.ready = False
                     self.flagNoData = False
                     self.localtime = localtime
                     self.data = {}
                     self.meta = {}
                     self.__heights = []
                 def __str__(self):
                     dum = ['{}{}'.format(key, self.shape(key)) for key in self.data]
                     return 'Data[{}][{}]'.format(';'.join(dum), len(self.times))
                 def __len__(self):
                     return len(self.data)
                 def __getitem__(self, key):
                     if isinstance(key, int):
                         return self.data[self.times[key]]
                     elif isinstance(key, str):
                         ret = numpy.array([self.data[x][key] for x in self.times])
                         if ret.ndim > 1:
                             ret = numpy.swapaxes(ret, 0, 1)
                         return ret
                 def __contains__(self, key):
                     return key in self.data[self.min_time]
                 def setup(self):
                     '''
                     Configure object
                     '''
                     self.type = ''
                     self.ready = False
                     del self.data
                     self.data = {}
                     self.__heights = []
                     self.__all_heights = set()
                 def shape(self, key):
                     '''
                     Get the shape of the one-element data for the given key
                     '''
                     if len(self.data[self.min_time][key]):
                         return self.data[self.min_time][key].shape
                     return (0,)
                 def update(self, data, tm, meta={}):
                     '''
                     Update data object with new dataOut
                     '''
                     self.data[tm] = data
                     for key, value in meta.items():
                         setattr(self, key, value)
                 def normalize_heights(self):
                     '''
                     Ensure same-dimension of the data for different heighList
                     '''
                     H = numpy.array(list(self.__all_heights))
                     H.sort()
                     for key in self.data:
                         shape = self.shape(key)[:-1] + H.shape
                         for tm, obj in list(self.data[key].items()):
                             h = self.__heights[self.times.tolist().index(tm)]
                             if H.size == h.size:
                                 continue
                             index = numpy.where(numpy.in1d(H, h))[0]
                             dummy = numpy.zeros(shape) + numpy.nan
                             if len(shape) == 2:
                                 dummy[:, index] = obj
                             else:
                                 dummy[index] = obj
                             self.data[key][tm] = dummy
                     self.__heights = [H for tm in self.times]
                 def jsonify(self, tm, plot_name, plot_type, decimate=False):
                     '''
                     Convert data to json
                     '''
                     meta = {}
                     meta['xrange'] = []
-                    dy = int(len(self.yrange)/self.MAXNUMY) + 1
+                    dy = int(len(self.yrange) / self.MAXNUMY) + 1
                     tmp = self.data[tm][self.key]
                     shape = tmp.shape
                     if len(shape) == 2:
                         data = self.roundFloats(self.data[tm][self.key][::, ::dy].tolist())
                     elif len(shape) == 3:
-                        dx = int(self.data[tm][self.key].shape[1]/self.MAXNUMX) + 1
+                        dx = int(self.data[tm][self.key].shape[1] / self.MAXNUMX) + 1
                         data = self.roundFloats(
                             self.data[tm][self.key][::, ::dx, ::dy].tolist())
                         meta['xrange'] = self.roundFloats(self.xrange[2][::dx].tolist())
                     else:
                         data = self.roundFloats(self.data[tm][self.key].tolist())
                     ret = {
                         'plot': plot_name,
                         'code': self.exp_code,
                         'time': float(tm),
                         'data': data,
                         }
                     meta['type'] = plot_type
                     meta['interval'] = float(self.interval)
                     meta['localtime'] = self.localtime
                     meta['yrange'] = self.roundFloats(self.yrange[::dy].tolist())
                     meta.update(self.meta)
                     ret['metadata'] = meta
                     return json.dumps(ret)
                 @property
                 def times(self):
                     '''
                     Return the list of times of the current data
                     '''
                     ret = [t for t in self.data]
                     ret.sort()
                     return numpy.array(ret)
                 @property
                 def min_time(self):
                     '''
                     Return the minimun time value
                     '''
                     return self.times[0]
                 @property
                 def max_time(self):
                     '''
                     Return the maximun time value
                     '''
                     return self.times[-1]
                 # @property
                 # def heights(self):
                 #     '''
                 #     Return the list of heights of the current data
                 #     '''
                 #     return numpy.array(self.__heights[-1])
                 @staticmethod
                 def roundFloats(obj):
                     if isinstance(obj, list):
                         return list(map(PlotterData.roundFloats, obj))
                     elif isinstance(obj, float):
                         return round(obj, 2)

schainpy/model/data/jroheaderIO.py +2 -2

             '''
             $Author: murco $
             $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
             '''
             import sys
             import numpy
             import copy
             import datetime
             import inspect
             from schainpy.utils import log
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             BASIC_STRUCTURE = numpy.dtype([
                 ('nSize', '<u4'),
                 ('nVersion', '<u2'),
                 ('nDataBlockId', '<u4'),
                 ('nUtime', '<u4'),
                 ('nMilsec', '<u2'),
                 ('nTimezone', '<i2'),
                 ('nDstflag', '<i2'),
                 ('nErrorCount', '<u4')
             ])
             SYSTEM_STRUCTURE = numpy.dtype([
                 ('nSize', '<u4'),
                 ('nNumSamples', '<u4'),
                 ('nNumProfiles', '<u4'),
                 ('nNumChannels', '<u4'),
                 ('nADCResolution', '<u4'),
                 ('nPCDIOBusWidth', '<u4'),
             ])
             RADAR_STRUCTURE = numpy.dtype([
                                          ('nSize', '<u4'),
                                          ('nExpType', '<u4'),
                                          ('nNTx', '<u4'),
                                          ('fIpp', '<f4'),
                                          ('fTxA', '<f4'),
                                          ('fTxB', '<f4'),
                                          ('nNumWindows', '<u4'),
                                          ('nNumTaus', '<u4'),
                                          ('nCodeType', '<u4'),
                                          ('nLine6Function', '<u4'),
                                          ('nLine5Function', '<u4'),
                                          ('fClock', '<f4'),
                                          ('nPrePulseBefore', '<u4'),
                                          ('nPrePulseAfter', '<u4'),
                                          ('sRangeIPP', '<a20'),
                                          ('sRangeTxA', '<a20'),
                                          ('sRangeTxB', '<a20'),
             ])
             SAMPLING_STRUCTURE = numpy.dtype(
                 [('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')])
             PROCESSING_STRUCTURE = numpy.dtype([
                 ('nSize', '<u4'),
                 ('nDataType', '<u4'),
                 ('nSizeOfDataBlock', '<u4'),
                 ('nProfilesperBlock', '<u4'),
                 ('nDataBlocksperFile', '<u4'),
                 ('nNumWindows', '<u4'),
                 ('nProcessFlags', '<u4'),
                 ('nCoherentIntegrations', '<u4'),
                 ('nIncoherentIntegrations', '<u4'),
                 ('nTotalSpectra', '<u4')
             ])
             class Header(object):
                 def __init__(self):
                     raise NotImplementedError
                 def copy(self):
                     return copy.deepcopy(self)
                 def read(self):
                     raise NotImplementedError
                 def write(self):
                     raise NotImplementedError
                 def getAllowedArgs(self):
                     args = inspect.getargspec(self.__init__).args
                     try:
                         args.remove('self')
                     except:
                         pass
                     return args
                 def getAsDict(self):
                     args = self.getAllowedArgs()
                     asDict = {}
                     for x in args:
                         asDict[x] = self[x]
                     return asDict
                 def __getitem__(self, name):
                     return getattr(self, name)
                 def printInfo(self):
                     message = "#" * 50 + "\n"
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#" * 50 + "\n"
                     keyList = list(self.__dict__.keys())
                     keyList.sort()
                     for key in keyList:
                         message += "%s = %s" % (key, self.__dict__[key]) + "\n"
                     if "size" not in keyList:
                         attr = getattr(self, "size")
                         if attr:
                             message += "%s = %s" % ("size", attr) + "\n"
                     print(message)
             class BasicHeader(Header):
                 size = None
                 version = None
                 dataBlock = None
                 utc = None
                 ltc = None
                 miliSecond = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 datatime = None
                 structure = BASIC_STRUCTURE
                 __LOCALTIME = None
                 def __init__(self, useLocalTime=True):
                     self.size = 24
                     self.version = 0
                     self.dataBlock = 0
                     self.utc = 0
                     self.miliSecond = 0
                     self.timeZone = 0
                     self.dstFlag = 0
                     self.errorCount = 0
                     self.useLocalTime = useLocalTime
                 def read(self, fp):
                     self.length = 0
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, BASIC_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, BASIC_STRUCTURE, 1)
                     except Exception as e:
                         print("BasicHeader: ")
                         print(e)
                         return 0
                     self.size = int(header['nSize'][0])
                     self.version = int(header['nVersion'][0])
                     self.dataBlock = int(header['nDataBlockId'][0])
                     self.utc = int(header['nUtime'][0])
                     self.miliSecond = int(header['nMilsec'][0])
                     self.timeZone = int(header['nTimezone'][0])
                     self.dstFlag = int(header['nDstflag'][0])
                     self.errorCount = int(header['nErrorCount'][0])
                     if self.size < 24:
                         return 0
                     self.length = header.nbytes
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size, self.version, self.dataBlock, self.utc,
                                    self.miliSecond, self.timeZone, self.dstFlag, self.errorCount)
                     header = numpy.array(headerTuple, BASIC_STRUCTURE)
                     header.tofile(fp)
                     return 1
                 def get_ltc(self):
                     return self.utc - self.timeZone * 60
                 def set_ltc(self, value):
                     self.utc = value + self.timeZone * 60
                 def get_datatime(self):
                     return datetime.datetime.utcfromtimestamp(self.ltc)
                 ltc = property(get_ltc, set_ltc)
                 datatime = property(get_datatime)
             class SystemHeader(Header):
                 size = None
                 nSamples = None
                 nProfiles = None
                 nChannels = None
                 adcResolution = None
                 pciDioBusWidth = None
                 structure = SYSTEM_STRUCTURE
                 def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
                     self.size = 24
                     self.nSamples = nSamples
                     self.nProfiles = nProfiles
                     self.nChannels = nChannels
                     self.adcResolution = adcResolution
                     self.pciDioBusWidth = pciDioBusWidth
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception as e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, SYSTEM_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, SYSTEM_STRUCTURE, 1)
                     except Exception as e:
                         print("System Header: " + str(e))
                         return 0
                     self.size = header['nSize'][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]
                     if startFp is not None:
                         endFp = self.size + startFp
                         if fp.tell() > endFp:
                             sys.stderr.write(
                                 "Warning %s: Size value read from System Header is lower than it has to be\n" % fp.name)
                             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write(
                                 "Warning %s: Size value read from System Header size is greater than it has to be\n" % fp.name)
                             return 0
                     self.length = header.nbytes
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size, self.nSamples, self.nProfiles,
                                    self.nChannels, self.adcResolution, self.pciDioBusWidth)
                     header = numpy.array(headerTuple, SYSTEM_STRUCTURE)
                     header.tofile(fp)
                     return 1
             class RadarControllerHeader(Header):
                 expType = None
                 nTx = None
                 ipp = None
                 txA = None
                 txB = None
                 nWindows = None
                 numTaus = None
                 codeType = None
                 line6Function = None
                 line5Function = None
                 fClock = None
                 prePulseBefore = None
                 prePulseAfter = None
                 rangeIpp = None
                 rangeTxA = None
                 rangeTxB = None
                 structure = RADAR_STRUCTURE
                 __size = None
                 def __init__(self, expType=2, nTx=1,
                              ipp=None, txA=0, txB=0,
                              nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
                              numTaus=0, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
                              codeType=0, nCode=0, nBaud=0, code=[],
                              flip1=0, flip2=0):
                     #         self.size = 116
                     self.expType = expType
                     self.nTx = nTx
                     self.ipp = ipp
                     self.txA = txA
                     self.txB = txB
                     self.rangeIpp = ipp
                     self.rangeTxA = txA
                     self.rangeTxB = txB
                     self.nWindows = nWindows
                     self.numTaus = numTaus
                     self.codeType = codeType
                     self.line6Function = line6Function
                     self.line5Function = line5Function
                     self.fClock = fClock
                     self.prePulseBefore = prePulseBefore
                     self.prePulseAfter = prePulseAfter
                     self.nHeights = nHeights
                     self.firstHeight = firstHeight
                     self.deltaHeight = deltaHeight
                     self.samplesWin = nHeights
                     self.nCode = nCode
                     self.nBaud = nBaud
                     self.code = code
                     self.flip1 = flip1
                     self.flip2 = flip2
                     self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4
             #         self.dynamic = numpy.array([],numpy.dtype('byte'))
                     if self.fClock is None and self.deltaHeight is not None:
                         self.fClock = 0.15 / (deltaHeight * 1e-6)  # 0.15Km / (height * 1u)
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception as e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, RADAR_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, RADAR_STRUCTURE, 1)
                         self.length += header.nbytes
                     except Exception as e:
                         print("RadarControllerHeader: " + str(e))
                         return 0
                     size = int(header['nSize'][0])
                     self.expType = int(header['nExpType'][0])
                     self.nTx = int(header['nNTx'][0])
                     self.ipp = float(header['fIpp'][0])
                     self.txA = float(header['fTxA'][0])
                     self.txB = float(header['fTxB'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.numTaus = int(header['nNumTaus'][0])
                     self.codeType = int(header['nCodeType'][0])
                     self.line6Function = int(header['nLine6Function'][0])
                     self.line5Function = int(header['nLine5Function'][0])
                     self.fClock = float(header['fClock'][0])
                     self.prePulseBefore = int(header['nPrePulseBefore'][0])
                     self.prePulseAfter = int(header['nPrePulseAfter'][0])
                     self.rangeIpp = header['sRangeIPP'][0]
                     self.rangeTxA = header['sRangeTxA'][0]
                     self.rangeTxB = header['sRangeTxB'][0]
                     try:
                         if hasattr(fp, 'read'):
                             samplingWindow = numpy.fromfile(
                                 fp, SAMPLING_STRUCTURE, self.nWindows)
                         else:
                             samplingWindow = numpy.fromstring(
                                 fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
                     except Exception as e:
                         print("RadarControllerHeader: " + str(e))
                         return 0
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = samplingWindow['h0']
                     self.deltaHeight = samplingWindow['dh']
                     self.samplesWin = samplingWindow['nsa']
                     try:
                         if hasattr(fp, 'read'):
                             self.Taus = numpy.fromfile(fp, '<f4', self.numTaus)
                         else:
                             self.Taus = numpy.fromstring(
                                 fp[self.length:], '<f4', self.numTaus)
                         self.length += self.Taus.nbytes
                     except Exception as e:
                         print("RadarControllerHeader: " + str(e))
                         return 0
                     self.code_size = 0
                     if self.codeType != 0:
                         try:
                             if hasattr(fp, 'read'):
                                 self.nCode = numpy.fromfile(fp, '<u4', 1)[0]
                                 self.length += self.nCode.nbytes
                                 self.nBaud = numpy.fromfile(fp, '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
                             else:
                                 self.nCode = numpy.fromstring(
                                     fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nCode.nbytes
                                 self.nBaud = numpy.fromstring(
                                     fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
                         except Exception as e:
                             print("RadarControllerHeader: " + str(e))
                             return 0
                         code = numpy.empty([self.nCode, self.nBaud], dtype='i1')
                         for ic in range(self.nCode):
                             try:
                                 if hasattr(fp, 'read'):
                                     temp = numpy.fromfile(fp, 'u4', int(
                                         numpy.ceil(self.nBaud / 32.)))
                                 else:
                                     temp = numpy.fromstring(
                                         fp, 'u4', int(numpy.ceil(self.nBaud / 32.)))
                                 self.length += temp.nbytes
                             except Exception as e:
                                 print("RadarControllerHeader: " + str(e))
                                 return 0
                             for ib in range(self.nBaud - 1, -1, -1):
                                 code[ic, ib] = temp[int(ib / 32)] % 2
                                 temp[int(ib / 32)] = temp[int(ib / 32)] / 2
                         self.code = 2.0 * code - 1.0
                         self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4
             #             if self.line5Function == RCfunction.FLIP:
             #                 self.flip1 = numpy.fromfile(fp,'<u4',1)
             #
             #             if self.line6Function == RCfunction.FLIP:
             #                 self.flip2 = numpy.fromfile(fp,'<u4',1)
                     if startFp is not None:
                         endFp = size + startFp
                         if fp.tell() != endFp:
                             #             fp.seek(endFp)
                             print("%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" % (fp.name, fp.tell() - startFp, size))
                 #             return 0
                         if fp.tell() > endFp:
                             sys.stderr.write(
                                 "Warning %s: Size value read from Radar Controller header is lower than it has to be\n" % fp.name)
                 #             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write(
                                 "Warning %s: Size value read from Radar Controller header is greater than it has to be\n" % fp.name)
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
                                    self.expType,
                                    self.nTx,
                                    self.ipp,
                                    self.txA,
                                    self.txB,
                                    self.nWindows,
                                    self.numTaus,
                                    self.codeType,
                                    self.line6Function,
                                    self.line5Function,
                                    self.fClock,
                                    self.prePulseBefore,
                                    self.prePulseAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)
                     header = numpy.array(headerTuple, RADAR_STRUCTURE)
                     header.tofile(fp)
                     sampleWindowTuple = (
                         self.firstHeight, self.deltaHeight, self.samplesWin)
                     samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE)
                     samplingWindow.tofile(fp)
                     if self.numTaus > 0:
                         self.Taus.tofile(fp)
                     if self.codeType != 0:
                         nCode = numpy.array(self.nCode, '<u4')
                         nCode.tofile(fp)
                         nBaud = numpy.array(self.nBaud, '<u4')
                         nBaud.tofile(fp)
                         code1 = (self.code + 1.0) / 2.
                         for ic in range(self.nCode):
                             tempx = numpy.zeros(int(numpy.ceil(self.nBaud / 32.)))
                             start = 0
                             end = 32
                             for i in range(len(tempx)):
                                 code_selected = code1[ic, start:end]
                                 for j in range(len(code_selected) - 1, -1, -1):
                                     if code_selected[j] == 1:
                                         tempx[i] = tempx[i] + \
-**(len(code_selected) - 1 - j)
+** (len(code_selected) - 1 - j)
                                 start = start + 32
                                 end = end + 32
                             tempx = tempx.astype('u4')
                             tempx.tofile(fp)
             #         if self.line5Function == RCfunction.FLIP:
             #             self.flip1.tofile(fp)
             #
             #         if self.line6Function == RCfunction.FLIP:
             #             self.flip2.tofile(fp)
                     return 1
                 def get_ippSeconds(self):
                     '''
                     '''
                     ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT
                     return ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0 * 1000)
                     return
                 def get_size(self):
                     self.__size = 116 + 12 * self.nWindows + 4 * self.numTaus
                     if self.codeType != 0:
                         self.__size += 4 + 4 + 4 * self.nCode * \
                             numpy.ceil(self.nBaud / 32.)
                     return self.__size
                 def set_size(self, value):
                     raise IOError("size is a property and it cannot be set, just read")
                     return
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 size = property(get_size, set_size)
             class ProcessingHeader(Header):
                 #     size = None
                 dtype = None
                 blockSize = None
                 profilesPerBlock = None
                 dataBlocksPerFile = None
                 nWindows = None
                 processFlags = None
                 nCohInt = None
                 nIncohInt = None
                 totalSpectra = None
                 structure = PROCESSING_STRUCTURE
                 flag_dc = None
                 flag_cspc = None
                 def __init__(self, dtype=0, blockSize=0, profilesPerBlock=0, dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
                              nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0, deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
                              code=0, nBaud=None, shif_fft=False, flag_dc=False, flag_cspc=False, flag_decode=False, flag_deflip=False
                              ):
                     #         self.size = 0
                     self.dtype = dtype
                     self.blockSize = blockSize
                     self.profilesPerBlock = 0
                     self.dataBlocksPerFile = 0
                     self.nWindows = 0
                     self.processFlags = 0
                     self.nCohInt = 0
                     self.nIncohInt = 0
                     self.totalSpectra = 0
                     self.nHeights = 0
                     self.firstHeight = 0
                     self.deltaHeight = 0
                     self.samplesWin = 0
                     self.spectraComb = 0
                     self.nCode = None
                     self.code = None
                     self.nBaud = None
                     self.shif_fft = False
                     self.flag_dc = False
                     self.flag_cspc = False
                     self.flag_decode = False
                     self.flag_deflip = False
                     self.length = 0
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception as e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, PROCESSING_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, PROCESSING_STRUCTURE, 1)
                         self.length += header.nbytes
                     except Exception as e:
                         print("ProcessingHeader: " + str(e))
                         return 0
                     size = int(header['nSize'][0])
                     self.dtype = int(header['nDataType'][0])
                     self.blockSize = int(header['nSizeOfDataBlock'][0])
                     self.profilesPerBlock = int(header['nProfilesperBlock'][0])
                     self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.processFlags = header['nProcessFlags']
                     self.nCohInt = int(header['nCoherentIntegrations'][0])
                     self.nIncohInt = int(header['nIncoherentIntegrations'][0])
                     self.totalSpectra = int(header['nTotalSpectra'][0])
                     try:
                         if hasattr(fp, 'read'):
                             samplingWindow = numpy.fromfile(
                                 fp, SAMPLING_STRUCTURE, self.nWindows)
                         else:
                             samplingWindow = numpy.fromstring(
                                 fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
                     except Exception as e:
                         print("ProcessingHeader: " + str(e))
                         return 0
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = float(samplingWindow['h0'][0])
                     self.deltaHeight = float(samplingWindow['dh'][0])
                     self.samplesWin = samplingWindow['nsa'][0]
                     try:
                         if hasattr(fp, 'read'):
                             self.spectraComb = numpy.fromfile(
                                 fp, 'u1', 2 * self.totalSpectra)
                         else:
                             self.spectraComb = numpy.fromstring(
                                 fp[self.length:], 'u1', 2 * self.totalSpectra)
                         self.length += self.spectraComb.nbytes
                     except Exception as e:
                         print("ProcessingHeader: " + str(e))
                         return 0
                     if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
                         self.nCode = int(numpy.fromfile(fp, '<u4', 1))
                         self.nBaud = int(numpy.fromfile(fp, '<u4', 1))
                         self.code = numpy.fromfile(
                             fp, '<f4', self.nCode * self.nBaud).reshape(self.nCode, self.nBaud)
                     if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP):
                         exp_name_len = int(numpy.fromfile(fp, '<u4', 1))
                         exp_name = numpy.fromfile(fp, 'u1', exp_name_len + 1)
                     if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
                         self.shif_fft = True
                     else:
                         self.shif_fft = False
                     if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
                         self.flag_dc = True
                     else:
                         self.flag_dc = False
                     if ((self.processFlags & PROCFLAG.DECODE_DATA) == PROCFLAG.DECODE_DATA):
                         self.flag_decode = True
                     else:
                         self.flag_decode = False
                     if ((self.processFlags & PROCFLAG.DEFLIP_DATA) == PROCFLAG.DEFLIP_DATA):
                         self.flag_deflip = True
                     else:
                         self.flag_deflip = False
                     nChannels = 0
                     nPairs = 0
                     pairList = []
                     for i in range(0, self.totalSpectra * 2, 2):
                         if self.spectraComb[i] == self.spectraComb[i + 1]:
                             nChannels = nChannels + 1  # par de canales iguales
                         else:
                             nPairs = nPairs + 1  # par de canales diferentes
                             pairList.append((self.spectraComb[i], self.spectraComb[i + 1]))
                     self.flag_cspc = False
                     if nPairs > 0:
                         self.flag_cspc = True
                     if startFp is not None:
                         endFp = size + startFp
                         if fp.tell() > endFp:
                             sys.stderr.write(
                                 "Warning: Processing header size is lower than it has to be")
                             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write(
                                 "Warning: Processing header size is greater than it is considered")
                     return 1
                 def write(self, fp):
                     # Clear DEFINE_PROCESS_CODE
                     self.processFlags = self.processFlags & (~PROCFLAG.DEFINE_PROCESS_CODE)
                     headerTuple = (self.size,
                                    self.dtype,
                                    self.blockSize,
                                    self.profilesPerBlock,
                                    self.dataBlocksPerFile,
                                    self.nWindows,
                                    self.processFlags,
                                    self.nCohInt,
                                    self.nIncohInt,
                                    self.totalSpectra)
                     header = numpy.array(headerTuple, PROCESSING_STRUCTURE)
                     header.tofile(fp)
                     if self.nWindows != 0:
                         sampleWindowTuple = (
                             self.firstHeight, self.deltaHeight, self.samplesWin)
                         samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE)
                         samplingWindow.tofile(fp)
                     if self.totalSpectra != 0:
                         #             spectraComb = numpy.array([],numpy.dtype('u1'))
                         spectraComb = self.spectraComb
                         spectraComb.tofile(fp)
             #         if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
             #             nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
             #             nCode.tofile(fp)
             #
             #             nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
             #             nBaud.tofile(fp)
             #
             #             code = self.code.reshape(self.nCode*self.nBaud)
             #             code = code.astype(numpy.dtype('<f4'))
             #             code.tofile(fp)
                     return 1
                 def get_size(self):
                     self.__size = 40 + 12 * self.nWindows + 2 * self.totalSpectra
             #         if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
             #             self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
             #             self.__size += 4 + 4 + 4 * self.nCode * self.nBaud
                     return self.__size
                 def set_size(self, value):
                     raise IOError("size is a property and it cannot be set, just read")
                     return
                 size = property(get_size, set_size)
             class RCfunction:
                 NONE = 0
                 FLIP = 1
                 CODE = 2
                 SAMPLING = 3
                 LIN6DIV256 = 4
                 SYNCHRO = 5
             class nCodeType:
                 NONE = 0
                 USERDEFINE = 1
                 BARKER2 = 2
                 BARKER3 = 3
                 BARKER4 = 4
                 BARKER5 = 5
                 BARKER7 = 6
                 BARKER11 = 7
                 BARKER13 = 8
                 AC128 = 9
                 COMPLEMENTARYCODE2 = 10
                 COMPLEMENTARYCODE4 = 11
                 COMPLEMENTARYCODE8 = 12
                 COMPLEMENTARYCODE16 = 13
                 COMPLEMENTARYCODE32 = 14
                 COMPLEMENTARYCODE64 = 15
                 COMPLEMENTARYCODE128 = 16
                 CODE_BINARY28 = 17
             class PROCFLAG:
                 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
                 DECODE_DATA = numpy.uint32(0x00000002)
                 SPECTRA_CALC = numpy.uint32(0x00000004)
                 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
                 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
                 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
                 DATATYPE_CHAR = numpy.uint32(0x00000040)
                 DATATYPE_SHORT = numpy.uint32(0x00000080)
                 DATATYPE_LONG = numpy.uint32(0x00000100)
                 DATATYPE_INT64 = numpy.uint32(0x00000200)
                 DATATYPE_FLOAT = numpy.uint32(0x00000400)
                 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
                 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
                 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
                 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
                 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
                 DEFLIP_DATA = numpy.uint32(0x00010000)
                 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
                 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
                 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
                 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
                 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
                 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
                 EXP_NAME_ESP = numpy.uint32(0x00200000)
                 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
                 OPERATION_MASK = numpy.uint32(0x0000003F)
                 DATATYPE_MASK = numpy.uint32(0x00000FC0)
                 DATAARRANGE_MASK = numpy.uint32(0x00007000)
                 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
             dtype0 = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
             dtype1 = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
             dtype2 = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
             dtype3 = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
             dtype4 = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
             dtype5 = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
             NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
             PROCFLAG_DTYPE_LIST = [PROCFLAG.DATATYPE_CHAR,
                                    PROCFLAG.DATATYPE_SHORT,
                                    PROCFLAG.DATATYPE_LONG,
                                    PROCFLAG.DATATYPE_INT64,
                                    PROCFLAG.DATATYPE_FLOAT,
                                    PROCFLAG.DATATYPE_DOUBLE]
             DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
             def get_dtype_index(numpy_dtype):
                 index = None
                 for i in range(len(NUMPY_DTYPE_LIST)):
                     if numpy_dtype == NUMPY_DTYPE_LIST[i]:
                         index = i
                         break
                 return index
             def get_numpy_dtype(index):
                 return NUMPY_DTYPE_LIST[index]
             def get_procflag_dtype(index):
                 return PROCFLAG_DTYPE_LIST[index]
             def get_dtype_width(index):
-                return DTYPE_WIDTH[index]
  No newline at end of file
+                return DTYPE_WIDTH[index]

schainpy/model/graphics/jroplot_base.py +16 -16

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Base class to create plot operations
             """
             import os
             import sys
             import zmq
             import time
             import numpy
             import datetime
             from collections import deque
             from functools import wraps
             from threading import Thread
             import matplotlib
             if 'BACKEND' in os.environ:
                 matplotlib.use(os.environ['BACKEND'])
             elif 'linux' in sys.platform:
                 matplotlib.use("TkAgg")
             elif 'darwin' in sys.platform:
                 matplotlib.use('MacOSX')
             else:
                 from schainpy.utils import log
                 log.warning('Using default Backend="Agg"', 'INFO')
                 matplotlib.use('Agg')
             import matplotlib.pyplot as plt
             from matplotlib.patches import Polygon
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
             from schainpy.model.data.jrodata import PlotterData
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.utils import log
             jet_values = matplotlib.pyplot.get_cmap('jet', 100)(numpy.arange(100))[10:90]
             blu_values = matplotlib.pyplot.get_cmap(
                 'seismic_r', 20)(numpy.arange(20))[10:15]
             ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
                 'jro', numpy.vstack((blu_values, jet_values)))
             matplotlib.pyplot.register_cmap(cmap=ncmap)
             CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'viridis',
                                                'plasma', 'inferno', 'Greys', 'seismic', 'bwr', 'coolwarm')]
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
-                a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
+                a = 0.5 - numpy.cos((lat2 - lat1) * p) / 2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
-                theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
+                theta = numpy.arctan2(numpy.sin((lon2 - lon1) * p) * numpy.cos(lat2 * p), numpy.cos(lat1 * p)
-                                      * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
+                                      * numpy.sin(lat2 * p) - numpy.sin(lat1 * p) * numpy.cos(lat2 * p) * numpy.cos((lon2 - lon1) * p))
-                theta = -theta + numpy.pi/2
+                theta = -theta + numpy.pi / 2
-                return r*numpy.cos(theta), r*numpy.sin(theta)
+                return r * numpy.cos(theta), r * numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
-                return numpy.rad2deg(km/EARTH_RADIUS)
+                return numpy.rad2deg(km / EARTH_RADIUS)
             def figpause(interval):
                 backend = plt.rcParams['backend']
                 if backend in matplotlib.rcsetup.interactive_bk:
                     figManager = matplotlib._pylab_helpers.Gcf.get_active()
                     if figManager is not None:
                         canvas = figManager.canvas
                         if canvas.figure.stale:
                             canvas.draw()
                         try:
                             canvas.start_event_loop(interval)
                         except:
                             pass
                         return
             def popup(message):
                 '''
                 '''
                 fig = plt.figure(figsize=(12, 8), facecolor='r')
                 text = '\n'.join([s.strip() for s in message.split(':')])
                 fig.text(0.01, 0.5, text, ha='left', va='center',
                          size='20', weight='heavy', color='w')
                 fig.show()
                 figpause(1000)
             class Throttle(object):
                 '''
                 Decorator that prevents a function from being called more than once every
                 time period.
                 To create a function that cannot be called more than once a minute, but
                 will sleep until it can be called:
                 @Throttle(minutes=1)
                 def foo():
                   pass
                 for i in range(10):
                   foo()
                   print "This function has run %s times." % i
                 '''
                 def __init__(self, seconds=0, minutes=0, hours=0):
                     self.throttle_period = datetime.timedelta(
                         seconds=seconds, minutes=minutes, hours=hours
                     )
                     self.time_of_last_call = datetime.datetime.min
                 def __call__(self, fn):
                     @wraps(fn)
                     def wrapper(*args, **kwargs):
                         coerce = kwargs.pop('coerce', None)
                         if coerce:
                             self.time_of_last_call = datetime.datetime.now()
                             return fn(*args, **kwargs)
                         else:
                             now = datetime.datetime.now()
                             time_since_last_call = now - self.time_of_last_call
                             time_left = self.throttle_period - time_since_last_call
                             if time_left > datetime.timedelta(seconds=0):
                                 return
                         self.time_of_last_call = datetime.datetime.now()
                         return fn(*args, **kwargs)
                     return wrapper
             def apply_throttle(value):
                 @Throttle(seconds=value)
                 def fnThrottled(fn):
                     fn()
                 return fnThrottled
             @MPDecorator
             class Plot(Operation):
                 """Base class for Schain plotting operations
                 This class should never be use directtly you must subclass a new operation,
                 children classes must be defined as follow:
                 ExamplePlot(Plot):
                     CODE = 'code'
                     colormap = 'jet'
                     plot_type = 'pcolor' # options are ('pcolor', 'pcolorbuffer', 'scatter', 'scatterbuffer')
                     def setup(self):
                         pass
                     def plot(self):
                         pass
                 """
                 CODE = 'Figure'
                 colormap = 'jet'
                 bgcolor = 'white'
                 buffering = True
                 __missing = 1E30
                 __attrs__ = ['show', 'save', 'ymin', 'ymax', 'zmin', 'zmax', 'title',
                              'showprofile']
                 def __init__(self):
                     Operation.__init__(self)
                     self.isConfig = False
                     self.isPlotConfig = False
                     self.save_time = 0
                     self.sender_time = 0
                     self.data = None
                     self.firsttime = True
                     self.sender_queue = deque(maxlen=10)
                     self.plots_adjust = {'left': 0.125, 'right': 0.9, 'bottom': 0.15, 'top': 0.9, 'wspace': 0.2, 'hspace': 0.2}
                 def __fmtTime(self, x, pos):
                     '''
                     '''
                     return '{}'.format(self.getDateTime(x).strftime('%H:%M'))
                 def __setup(self, **kwargs):
                     '''
                     Initialize variables
                     '''
                     self.figures = []
                     self.axes = []
                     self.cb_axes = []
                     self.localtime = kwargs.pop('localtime', True)
                     self.show = kwargs.get('show', True)
                     self.save = kwargs.get('save', False)
                     self.save_period = kwargs.get('save_period', 0)
                     self.colormap = kwargs.get('colormap', self.colormap)
                     self.colormap_coh = kwargs.get('colormap_coh', 'jet')
                     self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
                     self.colormaps = kwargs.get('colormaps', None)
                     self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
                     self.showprofile = kwargs.get('showprofile', False)
                     self.title = kwargs.get('wintitle', self.CODE.upper())
                     self.cb_label = kwargs.get('cb_label', None)
                     self.cb_labels = kwargs.get('cb_labels', None)
                     self.labels = kwargs.get('labels', None)
                     self.xaxis = kwargs.get('xaxis', 'frequency')
                     self.zmin = kwargs.get('zmin', None)
                     self.zmax = kwargs.get('zmax', None)
                     self.zlimits = kwargs.get('zlimits', None)
                     self.xmin = kwargs.get('xmin', None)
                     self.xmax = kwargs.get('xmax', None)
                     self.xrange = kwargs.get('xrange', 12)
                     self.xscale = kwargs.get('xscale', None)
                     self.ymin = kwargs.get('ymin', None)
                     self.ymax = kwargs.get('ymax', None)
                     self.yscale = kwargs.get('yscale', None)
                     self.xlabel = kwargs.get('xlabel', None)
                     self.attr_time = kwargs.get('attr_time', 'utctime')
                     self.attr_data = kwargs.get('attr_data', 'data_param')
                     self.decimation = kwargs.get('decimation', None)
                     self.oneFigure = kwargs.get('oneFigure', True)
                     self.width = kwargs.get('width', None)
                     self.height = kwargs.get('height', None)
                     self.colorbar = kwargs.get('colorbar', True)
                     self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
                     self.channels = kwargs.get('channels', None)
                     self.titles = kwargs.get('titles', [])
                     self.polar = False
                     self.type = kwargs.get('type', 'iq')
                     self.grid = kwargs.get('grid', False)
                     self.pause = kwargs.get('pause', False)
                     self.save_code = kwargs.get('save_code', self.CODE)
                     self.throttle = kwargs.get('throttle', 0)
                     self.exp_code = kwargs.get('exp_code', None)
                     self.server = kwargs.get('server', False)
                     self.sender_period = kwargs.get('sender_period', 60)
                     self.tag = kwargs.get('tag', '')
                     self.height_index = kwargs.get('height_index', None)
                     self.__throttle_plot = apply_throttle(self.throttle)
                     code = self.attr_data if self.attr_data else self.CODE
                     self.data = PlotterData(self.CODE, self.exp_code, self.localtime)
                     if self.server:
                         if not self.server.startswith('tcp://'):
                             self.server = 'tcp://{}'.format(self.server)
                         log.success(
                             'Sending to server: {}'.format(self.server),
                             self.name
                         )
                     if isinstance(self.attr_data, str):
                         self.attr_data = [self.attr_data]
                 def __setup_plot(self):
                     '''
                     Common setup for all figures, here figures and axes are created
                     '''
                     self.setup()
                     self.time_label = 'LT' if self.localtime else 'UTC'
                     if self.width is None:
                         self.width = 8
                     self.figures = []
                     self.axes = []
                     self.cb_axes = []
                     self.pf_axes = []
                     self.cmaps = []
                     size = '15%' if self.ncols == 1 else '30%'
                     pad = '4%' if self.ncols == 1 else '8%'
                     if self.oneFigure:
                         if self.height is None:
                             self.height = 1.4 * self.nrows + 1
                         fig = plt.figure(figsize=(self.width, self.height),
                                          edgecolor='k',
                                          facecolor='w')
                         self.figures.append(fig)
                         for n in range(self.nplots):
                             ax = fig.add_subplot(self.nrows, self.ncols,
                                                  n + 1, polar=self.polar)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             ax.press = None
                             self.axes.append(ax)
                             if self.showprofile:
                                 cax = self.__add_axes(ax, size=size, pad=pad)
                                 cax.tick_params(labelsize=8)
                                 self.pf_axes.append(cax)
                     else:
                         if self.height is None:
                             self.height = 3
                         for n in range(self.nplots):
                             fig = plt.figure(figsize=(self.width, self.height),
                                              edgecolor='k',
                                              facecolor='w')
                             ax = fig.add_subplot(1, 1, 1, polar=self.polar)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             ax.press = None
                             self.figures.append(fig)
                             self.axes.append(ax)
                             if self.showprofile:
                                 cax = self.__add_axes(ax, size=size, pad=pad)
                                 cax.tick_params(labelsize=8)
                                 self.pf_axes.append(cax)
                     for n in range(self.nrows):
                         print(self.nrows)
                         if self.colormaps is not None:
                             cmap = plt.get_cmap(self.colormaps[n])
                         else:
                             cmap = plt.get_cmap(self.colormap)
                         cmap.set_bad(self.bgcolor, 1.)
                         self.cmaps.append(cmap)
                 def __add_axes(self, ax, size='30%', pad='8%'):
                     '''
                     Add new axes to the given figure
                     '''
                     divider = make_axes_locatable(ax)
                     nax = divider.new_horizontal(size=size, pad=pad)
                     ax.figure.add_axes(nax)
                     return nax
                 def fill_gaps(self, x_buffer, y_buffer, z_buffer):
                     '''
                     Create a masked array for missing data
                     '''
                     if x_buffer.shape[0] < 2:
                         return x_buffer, y_buffer, z_buffer
                     deltas = x_buffer[1:] - x_buffer[0:-1]
                     x_median = numpy.median(deltas)
                     index = numpy.where(deltas > 5 * x_median)
                     if len(index[0]) != 0:
                         z_buffer[::, index[0], ::] = self.__missing
                         z_buffer = numpy.ma.masked_inside(z_buffer,
 .99 * self.__missing,
 .01 * self.__missing)
                     return x_buffer, y_buffer, z_buffer
                 def decimate(self):
                     # dx = int(len(self.x)/self.__MAXNUMX) + 1
                     dy = int(len(self.y) / self.decimation) + 1
                     # x = self.x[::dx]
                     x = self.x
                     y = self.y[::dy]
                     z = self.z[::, ::, ::dy]
                     return x, y, z
                 def format(self):
                     '''
                     Set min and max values, labels, ticks and titles
                     '''
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             if self.xaxis != 'time':
                                 xmin = self.xmin
                                 xmax = self.xmax
                             else:
                                 xmin = self.tmin
-                                xmax = self.tmin + self.xrange*60*60
+                                xmax = self.tmin + self.xrange * 60 * 60
                                 ax.xaxis.set_major_formatter(FuncFormatter(self.__fmtTime))
                                 ax.xaxis.set_major_locator(LinearLocator(9))
                             ymin = self.ymin if self.ymin is not None else numpy.nanmin(self.y[numpy.isfinite(self.y)])
                             ymax = self.ymax if self.ymax is not None else numpy.nanmax(self.y[numpy.isfinite(self.y)])
                             ax.set_facecolor(self.bgcolor)
                             if self.xscale:
                                 ax.xaxis.set_major_formatter(FuncFormatter(
-                                    lambda x, pos: '{0:g}'.format(x*self.xscale)))
+                                    lambda x, pos: '{0:g}'.format(x * self.xscale)))
                             if self.yscale:
                                 ax.yaxis.set_major_formatter(FuncFormatter(
-                                    lambda x, pos: '{0:g}'.format(x*self.yscale)))
+                                    lambda x, pos: '{0:g}'.format(x * self.yscale)))
                             if self.xlabel is not None:
                                 ax.set_xlabel(self.xlabel)
                             if self.ylabel is not None:
                                 ax.set_ylabel(self.ylabel)
                             if self.showprofile:
                                 self.pf_axes[n].set_ylim(ymin, ymax)
                                 self.pf_axes[n].set_xlim(self.zmin, self.zmax)
                                 self.pf_axes[n].set_xlabel('dB')
                                 self.pf_axes[n].grid(b=True, axis='x')
                                 [tick.set_visible(False)
                                  for tick in self.pf_axes[n].get_yticklabels()]
                             if self.colorbar:
                                 ax.cbar = plt.colorbar(
                                     ax.plt, ax=ax, fraction=0.05, pad=0.02, aspect=10)
                                 ax.cbar.ax.tick_params(labelsize=8)
                                 ax.cbar.ax.press = None
                                 if self.cb_label:
                                     ax.cbar.set_label(self.cb_label, size=8)
                                 elif self.cb_labels:
                                     ax.cbar.set_label(self.cb_labels[n], size=8)
                             else:
                                 ax.cbar = None
                             ax.set_xlim(xmin, xmax)
                             ax.set_ylim(ymin, ymax)
                             ax.firsttime = False
                             if self.grid:
                                 ax.grid(True)
                         if not self.polar:
                             ax.set_title('{} {} {}'.format(
                                 self.titles[n],
                                 self.getDateTime(self.data.max_time).strftime(
                                     '%Y-%m-%d %H:%M:%S'),
                                 self.time_label),
                                 size=8)
                         else:
                             ax.set_title('{}'.format(self.titles[n]), size=8)
                             ax.set_ylim(0, 90)
                             ax.set_yticks(numpy.arange(0, 90, 20))
                             ax.yaxis.labelpad = 40
                     if self.firsttime:
                         for n, fig in enumerate(self.figures):
                             fig.subplots_adjust(**self.plots_adjust)
                         self.firsttime = False
                 def clear_figures(self):
                     '''
                     Reset axes for redraw plots
                     '''
-                    for ax in self.axes+self.pf_axes+self.cb_axes:
+                    for ax in self.axes + self.pf_axes + self.cb_axes:
                         ax.clear()
                         ax.firsttime = True
                         if hasattr(ax, 'cbar') and ax.cbar:
                             ax.cbar.remove()
                 def __plot(self):
                     '''
                     Main function to plot, format and save figures
                     '''
                     self.plot()
                     self.format()
                     for n, fig in enumerate(self.figures):
                         if self.nrows == 0 or self.nplots == 0:
                             log.warning('No data', self.name)
                             fig.text(0.5, 0.5, 'No Data', fontsize='large', ha='center')
                             fig.canvas.manager.set_window_title(self.CODE)
                             continue
                         fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
                                                                              self.getDateTime(self.data.max_time).strftime('%Y/%m/%d')))
                         fig.canvas.draw()
                         if self.show:
                             fig.show()
                             figpause(0.01)
                         if self.save:
                             self.save_figure(n)
                     if self.server:
                         self.send_to_server()
                 def __update(self, dataOut, timestamp):
                     '''
                     '''
                     metadata = {
                         'yrange': dataOut.heightList,
                         'interval': dataOut.timeInterval,
                         'channels': dataOut.channelList
                     }
                     data, meta = self.update(dataOut)
                     metadata.update(meta)
                     self.data.update(data, timestamp, metadata)
                 def save_figure(self, n):
                     '''
                     '''
                     if (self.data.max_time - self.save_time) <= self.save_period:
                         return
                     self.save_time = self.data.max_time
                     fig = self.figures[n]
                     if self.throttle == 0:
                         figname = os.path.join(
                             self.save,
                             self.save_code,
                             '{}_{}.png'.format(
                                 self.save_code,
                                 self.getDateTime(self.data.max_time).strftime(
                                     '%Y%m%d_%H%M%S'
                                     ),
                                 )
                             )
                         log.log('Saving figure: {}'.format(figname), self.name)
                         if not os.path.isdir(os.path.dirname(figname)):
                             os.makedirs(os.path.dirname(figname))
                         fig.savefig(figname)
                     figname = os.path.join(
                         self.save,
                         '{}_{}.png'.format(
                             self.save_code,
                             self.getDateTime(self.data.min_time).strftime(
                                 '%Y%m%d'
                                 ),
                             )
                         )
                     fig.savefig(figname)
                 def send_to_server(self):
                     '''
                     '''
                     if self.exp_code == None:
                         log.warning('Missing `exp_code` skipping sending to server...')
                     last_time = self.data.max_time
                     interval = last_time - self.sender_time
                     if interval < self.sender_period:
                         return
                     self.sender_time = last_time
                     attrs = ['titles', 'zmin', 'zmax', 'tag', 'ymin', 'ymax']
                     for attr in attrs:
                         value = getattr(self, attr)
                         if value:
                             if isinstance(value, (numpy.float32, numpy.float64)):
                                 value = round(float(value), 2)
                             self.data.meta[attr] = value
                     if self.colormap == 'jet':
                         self.data.meta['colormap'] = 'Jet'
                     elif 'RdBu' in self.colormap:
                         self.data.meta['colormap'] = 'RdBu'
                     else:
                         self.data.meta['colormap'] = 'Viridis'
                     self.data.meta['interval'] = int(interval)
                     self.sender_queue.append(last_time)
                     while True:
                         try:
                             tm = self.sender_queue.popleft()
                         except IndexError:
                             break
                         msg = self.data.jsonify(tm, self.save_code, self.plot_type)
                         self.socket.send_string(msg)
                         socks = dict(self.poll.poll(2000))
                         if socks.get(self.socket) == zmq.POLLIN:
                             reply = self.socket.recv_string()
                             if reply == 'ok':
                                 log.log("Response from server ok", self.name)
                                 time.sleep(0.1)
                                 continue
                             else:
                                 log.warning(
                                     "Malformed reply from server: {}".format(reply), self.name)
                         else:
                             log.warning(
                                 "No response from server, retrying...", self.name)
                         self.sender_queue.appendleft(tm)
                         self.socket.setsockopt(zmq.LINGER, 0)
                         self.socket.close()
                         self.poll.unregister(self.socket)
                         self.socket = self.context.socket(zmq.REQ)
                         self.socket.connect(self.server)
                         self.poll.register(self.socket, zmq.POLLIN)
                         break
                 def setup(self):
                     '''
                     This method should be implemented in the child class, the following
                     attributes should be set:
                     self.nrows: number of rows
                     self.ncols: number of cols
                     self.nplots: number of plots (channels or pairs)
                     self.ylabel: label for Y axes
                     self.titles: list of axes title
                     '''
                     raise NotImplementedError
                 def plot(self):
                     '''
                     Must be defined in the child class, the actual plotting method
                     '''
                     raise NotImplementedError
                 def update(self, dataOut):
                     '''
                     Must be defined in the child class, update self.data with new data
                     '''
                     data = {
                         self.CODE: getattr(dataOut, 'data_{}'.format(self.CODE))
                     }
                     meta = {}
                     return data, meta
                 def run(self, dataOut, **kwargs):
                     '''
                     Main plotting routine
                     '''
                     if self.isConfig is False:
                         self.__setup(**kwargs)
                         if self.localtime:
                             self.getDateTime = datetime.datetime.fromtimestamp
                         else:
                             self.getDateTime = datetime.datetime.utcfromtimestamp
                         self.data.setup()
                         self.isConfig = True
                         if self.server:
                             self.context = zmq.Context()
                             self.socket = self.context.socket(zmq.REQ)
                             self.socket.connect(self.server)
                             self.poll = zmq.Poller()
                             self.poll.register(self.socket, zmq.POLLIN)
                     tm = getattr(dataOut, self.attr_time)
-                    if self.data and 'time' in self.xaxis and (tm - self.tmin) >= self.xrange*60*60:
+                    if self.data and 'time' in self.xaxis and (tm - self.tmin) >= self.xrange * 60 * 60:
                         self.save_time = tm
                         self.__plot()
-                        self.tmin += self.xrange*60*60
+                        self.tmin += self.xrange * 60 * 60
                         self.data.setup()
                         self.clear_figures()
                     self.__update(dataOut, tm)
                     if self.isPlotConfig is False:
                         self.__setup_plot()
                         self.isPlotConfig = True
                         if self.xaxis == 'time':
                             dt = self.getDateTime(tm)
                             if self.xmin is None:
                                 self.tmin = tm
                                 self.xmin = dt.hour
-                            minutes = (self.xmin-int(self.xmin)) * 60
+                            minutes = (self.xmin - int(self.xmin)) * 60
                             seconds = (minutes - int(minutes)) * 60
                             self.tmin = (dt.replace(hour=int(self.xmin), minute=int(minutes), second=int(seconds)) -
                                     datetime.datetime(1970, 1, 1)).total_seconds()
                             if self.localtime:
                                 self.tmin += time.timezone
                             if self.xmin is not None and self.xmax is not None:
                                 self.xrange = self.xmax - self.xmin
                     if self.throttle == 0:
                         self.__plot()
                     else:
-                        self.__throttle_plot(self.__plot)#, coerce=coerce)
+                        self.__throttle_plot(self.__plot)  # , coerce=coerce)
                 def close(self):
                     if self.data and not self.data.flagNoData:
                         self.save_time = self.data.max_time
                         self.__plot()
                     if self.data and not self.data.flagNoData and self.pause:
                         figpause(10)

schainpy/model/graphics/jroplot_correlation.py +17 -17

             import os
             import datetime
             import numpy
             import copy
             from schainpy.model.graphics.jroplot_base import Plot
             class CorrelationPlot(Plot):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'corr'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 280
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = 1
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
-                    ncol = int(numpy.sqrt(self.nplots)+0.9)
+                    ncol = int(numpy.sqrt(self.nplots) + 0.9)
-                    nrow = int(self.nplots*1./ncol + 0.9)
+                    nrow = int(self.nplots * 1. / ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
                     showprofile = False
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
-                    self.createFigure(id = id,
+                    self.createFigure(id=id,
-                                      wintitle = wintitle,
+                                      wintitle=wintitle,
-                                      widthplot = self.WIDTH + self.WIDTHPROF,
+                                      widthplot=self.WIDTH + self.WIDTHPROF,
-                                      heightplot = self.HEIGHT + self.HEIGHTPROF,
+                                      heightplot=self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
-                            self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
+                            self.addAxes(nrow, ncol * ncolspan, y, x * ncolspan, colspan, 1)
                             if showprofile:
-                                self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
+                                self.addAxes(nrow, ncol * ncolspan, y, x * ncolspan + colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return None
                     if realtime:
-                        if not(isRealtime(utcdatatime = dataOut.utctime)):
+                        if not(isRealtime(utcdatatime=dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     lenfactor = factor.shape[1]
                     x = dataOut.getLagTRange(1)
                     y = dataOut.heightList
-                    z = copy.copy(dataOut.data_corr[:,:,0,:])
+                    z = copy.copy(dataOut.data_corr[:, :, 0, :])
                     for i in range(dataOut.data_corr.shape[0]):
-                        z[i,:,:] = z[i,:,:]/factor[i,:]
+                        z[i, :, :] = z[i, :, :] / factor[i, :]
                     zdB = numpy.abs(z)
                     avg = numpy.average(z, axis=1)
             #         avg = numpy.nanmean(z, axis=1)
             #         noise = dataOut.noise/factor
-                    #thisDatetime = dataOut.datatime
+                    # thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Correlation"
                     xlabel = "Lag T (s)"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = dataOut.data_corr.shape[0]
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = 0
                         if zmax == None: zmax = 1
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
-                        str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
+                        str_datetime = '%s %s' % (thisDatetime.strftime("%Y/%m/%d"), thisDatetime.strftime("%H:%M:%S"))
-                        title = "Channel %d and %d: : %s" %(dataOut.pairsList[i][0],dataOut.pairsList[i][1] , str_datetime)
+                        title = "Channel %d and %d: : %s" % (dataOut.pairsList[i][0], dataOut.pairsList[i][1] , str_datetime)
-                        axes = self.axesList[i*self.__nsubplots]
+                        axes = self.axesList[i * self.__nsubplots]
-                        axes.pcolor(x, y, zdB[i,:,:],
+                        axes.pcolor(x, y, zdB[i, :, :],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
             #             if self.__showprofile:
             #                 axes = self.axesList[i*self.__nsubplots +1]
             #                 axes.pline(avgdB[i], y,
             #                         xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
             #                         xlabel='dB', ylabel='', title='',
             #                         ytick_visible=False,
             #                         grid='x')
             #
             #                 noiseline = numpy.repeat(noisedB[i], len(y))
             #                 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
-                              thisDatetime=thisDatetime)
  No newline at end of file
+                              thisDatetime=thisDatetime)

schainpy/model/graphics/jroplot_heispectra.py +4 -4

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Classes to plo Specra Heis data
             """
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             class SpectraHeisPlot(Plot):
                 CODE = 'spc_heis'
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.95, 'bottom': 0.08})
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Frequency [KHz]'
                     self.colorbar = False
                 def update(self, dataOut):
                     data = {}
                     meta = {}
-                    spc = 10*numpy.log10(dataOut.data_spc / dataOut.normFactor)
+                    spc = 10 * numpy.log10(dataOut.data_spc / dataOut.normFactor)
                     data['spc_heis'] = spc
                     return data, meta
                 def plot(self):
                     c = 3E8
                     deltaHeight = self.data.yrange[1] - self.data.yrange[0]
-                    x = numpy.arange(-1*len(self.data.yrange)/2., len(self.data.yrange)/2.)*(c/(2*deltaHeight*len(self.data.yrange)*1000))
+                    x = numpy.arange(-1 * len(self.data.yrange) / 2., len(self.data.yrange) / 2.) * (c / (2 * deltaHeight * len(self.data.yrange) * 1000))
                     self.y = self.data[-1]['spc_heis']
                     self.titles = []
                     for n, ax in enumerate(self.axes):
-                        ychannel = self.y[n,:]
+                        ychannel = self.y[n, :]
                         if ax.firsttime:
                             self.xmin = min(x) if self.xmin is None else self.xmin
                             self.xmax = max(x) if self.xmax is None else self.xmax
                             ax.plt = ax.plot(x, ychannel, lw=1, color='b')[0]
                         else:
                             ax.plt.set_data(x, ychannel)
                         self.titles.append("Channel {}: {:4.2f}dB".format(n, numpy.max(ychannel)))
             class RTIHeisPlot(Plot):
                 CODE = 'rti_heis'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Time'
                     self.titles = ['RTI']
                     self.colorbar = False
                     self.height = 4
                     self.plots_adjust.update({'right': 0.85 })
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = dataOut.data_spc / dataOut.normFactor
-                    spc = 10*numpy.log10(numpy.average(spc, axis=1))
+                    spc = 10 * numpy.log10(numpy.average(spc, axis=1))
                     data['rti_heis'] = spc
                     return data, meta
                 def plot(self):
                     x = self.data.times
                     Y = self.data['rti_heis']
                     if self.axes[0].firsttime:
                         self.ymin = numpy.nanmin(Y) - 5 if self.ymin == None else self.ymin
                         self.ymax = numpy.nanmax(Y) + 5 if self.ymax == None else self.ymax
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend(bbox_to_anchor=(1.18, 1.0))
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)

schainpy/model/graphics/jroplot_parameters.py +17 -17

             import os
             import datetime
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot
             from schainpy.utils import log
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
-                a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
+                a = 0.5 - numpy.cos((lat2 - lat1) * p) / 2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
-                theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
+                theta = numpy.arctan2(numpy.sin((lon2 - lon1) * p) * numpy.cos(lat2 * p), numpy.cos(lat1 * p)
-                                      * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
+                                      * numpy.sin(lat2 * p) - numpy.sin(lat1 * p) * numpy.cos(lat2 * p) * numpy.cos((lon2 - lon1) * p))
-                theta = -theta + numpy.pi/2
+                theta = -theta + numpy.pi / 2
-                return r*numpy.cos(theta), r*numpy.sin(theta)
+                return r * numpy.cos(theta), r * numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
-                return numpy.rad2deg(km/EARTH_RADIUS)
+                return numpy.rad2deg(km / EARTH_RADIUS)
             class SpectralMomentsPlot(SpectraPlot):
                 '''
                 Plot for Spectral Moments
                 '''
                 CODE = 'spc_moments'
                 colormap = 'jet'
                 plot_type = 'pcolor'
             class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
-                        'snr': 10*numpy.log10(dataOut.data_snr)
+                        'snr': 10 * numpy.log10(dataOut.data_snr)
                     }
                     return data, {}
             class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data (1st moment)
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
-                        'dop': 10*numpy.log10(dataOut.data_dop)
+                        'dop': 10 * numpy.log10(dataOut.data_dop)
                     }
                     return data, {}
             class PowerPlot(RTIPlot):
                 '''
                 Plot for Power Data (0 moment)
                 '''
                 CODE = 'pow'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
-                        'pow': 10*numpy.log10(dataOut.data_pow)
+                        'pow': 10 * numpy.log10(dataOut.data_pow)
                     }
                     return data, {}
             class SpectralWidthPlot(RTIPlot):
                 '''
                 Plot for Spectral Width Data (2nd moment)
                 '''
                 CODE = 'width'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'width': dataOut.data_width
                     }
                     return data, {}
             class SkyMapPlot(Plot):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'param'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.nplots = 1
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     self.polar = True
                     self.ymin = -180
                     self.ymax = 180
                     self.colorbar = False
                 def plot(self):
                     arrayParameters = numpy.concatenate(self.data['param'])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     finalAzimuth = finalMeteor[:, 3]
                     finalZenith = finalMeteor[:, 4]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
                     else:
                         ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.titles[0] = title
             class GenericRTIPlot(Plot):
                 '''
                 Plot for data_xxxx object
                 '''
                 CODE = 'param'
                 colormap = 'viridis'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape('param')[0]
                     self.nplots = self.nrows
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
                     if not self.xlabel:
                         self.xlabel = 'Time'
                     self.ylabel = 'Height [km]'
                     if not self.titles:
                         self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {
                         'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
                     }
                     meta = {}
                     return data, meta
                 def plot(self):
                     # self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['param']
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class PolarMapPlot(Plot):
                 '''
                 Plot for weather radar
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 9
                     self.height = 8
                     self.mode = self.data.meta['mode']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'
                     else:
                         self.xlabel = 'Range (km)'
                         self.ylabel = 'Height (km)'
                     self.bgcolor = 'white'
                     self.cb_labels = self.data.meta['units']
                     self.lat = self.data.meta['latitude']
                     self.lon = self.data.meta['longitude']
                     self.xmin, self.xmax = float(
                         km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
                     self.ymin, self.ymax = float(
                         km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
                     #  self.polar = True
                 def plot(self):
                     for n, ax in enumerate(self.axes):
                         data = self.data['param'][self.channels[n]]
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
-                            azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
+                            azimuths = -numpy.radians(self.data.yrange) + numpy.pi / 2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
-                            x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
+                            x, y = r * numpy.cos(theta) * numpy.cos(numpy.radians(self.data.meta['elevation'])), r * numpy.sin(
-                                theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
+                                theta) * numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.yrange)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
-                            x, y = r*numpy.cos(theta), r*numpy.sin(theta)
+                            x, y = r * numpy.cos(theta), r * numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
-                            ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
+                            ax.plt = ax.pcolormesh(# r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
-                            ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
+                            ax.plt = ax.pcolormesh(# r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         if self.mode == 'A':
                             continue
                         # plot district names
                         f = open('/data/workspace/schain_scripts/distrito.csv')
                         for line in f:
                             label, lon, lat = [s.strip() for s in line.split(',') if s]
                             lat = float(lat)
                             lon = float(lon)
                             # ax.plot(lon, lat, '.b', ms=2)
                             ax.text(lon, lat, label.decode('utf8'), ha='center',
                                     va='bottom', size='8', color='black')
                         # plot limites
                         limites = []
                         tmp = []
                         for line in open('/data/workspace/schain_scripts/lima.csv'):
                             if '#' in line:
                                 if tmp:
                                     limites.append(tmp)
                                 tmp = []
                                 continue
                             values = line.strip().split(',')
                             tmp.append((float(values[0]), float(values[1])))
                         for points in limites:
                             ax.add_patch(
                                 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
                         # plot Cuencas
                         for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
                             f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
                             values = [line.strip().split(',') for line in f]
                             points = [(float(s[0]), float(s[1])) for s in values]
                             ax.add_patch(Polygon(points, ec='b', fc='none'))
                         # plot grid
                         for r in (15, 30, 45, 60):
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
-                                self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
+                                self.lon + (km2deg(r)) * numpy.cos(60 * numpy.pi / 180),
-                                self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
+                                self.lat + (km2deg(r)) * numpy.sin(60 * numpy.pi / 180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
                     if self.mode == 'E':
                         title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
                         label = 'E{:02d}'.format(int(self.data.meta['elevation']))
                     else:
                         title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
                         label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     self.titles = ['{} {}'.format(
                         self.data.parameters[x], title) for x in self.channels]

schainpy/model/graphics/jroplot_spectra.py +47 -46

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Classes to plot Spectra data
             """
             import os
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt, log
             class SpectraPlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
-                CODE = 'spc'
+                CODE = 'spc_moments'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 buffering = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 4 * self.ncols
                     else:
                         self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.ylabel = 'Range [km]'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
-                    spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
+                    spc = 10 * numpy.log10(dataOut.data_spc / dataOut.normFactor)
                     data['spc'] = spc
                     data['rti'] = dataOut.getPower()
-                    data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
+                    data['noise'] = 10 * numpy.log10(dataOut.getNoise() / dataOut.normFactor)
-                    meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
+                    meta['xrange'] = (dataOut.getFreqRange(1) / 1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     if self.CODE == 'spc_moments':
                         data['moments'] = dataOut.moments
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if self.CODE == 'spc_moments':
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
+                    #self.CODE = 'spc_moments'
                     for n, ax in enumerate(self.axes):
                         noise = data['noise'][n]
+                        print(n,self.CODE)
                         if self.CODE == 'spc_moments':
-                            mean = data['moments'][n, 1]
+                            mean = data['moments'][n,1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     data['rti'][n], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean = ax.plot(mean, y, color='k')[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(data['rti'][n], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean.set_data(mean, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
             class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nplots = len(self.data.pairs) * 2
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.1 * self.ncols
                     self.height = 2.6 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = dataOut.data_spc
                     cspc = dataOut.data_cspc
-                    meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
+                    meta['xrange'] = (dataOut.getFreqRange(1) / 1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     meta['pairs'] = dataOut.pairsList
                     tmp = []
                     for n, pair in enumerate(meta['pairs']):
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         tmp.append(coh)
                         tmp.append(phase)
                     data['cspc'] = numpy.array(tmp)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     cspc = data['cspc']
                     for n in range(len(self.data.pairs)):
                         pair = self.data.pairs[n]
-                        coh = cspc[n*2]
+                        coh = cspc[n * 2]
-                        phase = cspc[n*2+1]
+                        phase = cspc[n * 2 + 1]
                         ax = self.axes[2 * n]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[2 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
             class RTIPlot(Plot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jet'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.cb_label = 'dB'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.getPower()
-                    data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
+                    data['noise'] = 10 * numpy.log10(dataOut.getNoise() / dataOut.normFactor)
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         data = self.data[-1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(
                                     data['rti'][n], self.y)[0]
                                 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(data['noise'][n], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(data['rti'][n], self.y)
                                 ax.plot_noise.set_data(numpy.repeat(
                                     data['noise'][n], len(self.y)), self.y)
             class CoherencePlot(RTIPlot):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
-                    self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95})
+                    self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                             'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
                         self.titles = [
                             'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['coh'] = dataOut.getCoherence()
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class PhasePlot(CoherencePlot):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['phase'] = dataOut.getCoherence(phase=True)
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Time'
                     self.titles = ['Noise']
                     self.colorbar = False
                     self.plots_adjust.update({'right': 0.85 })
                 def update(self, dataOut):
                     data = {}
                     meta = {}
-                    data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor).reshape(dataOut.nChannels, 1)
+                    data['noise'] = 10 * numpy.log10(dataOut.getNoise() / dataOut.normFactor).reshape(dataOut.nChannels, 1)
                     meta['yrange'] = numpy.array([])
                     return data, meta
                 def plot(self):
                     x = self.data.times
                     xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data['noise']
                     if self.axes[0].firsttime:
                         self.ymin = numpy.nanmin(Y) - 5
                         self.ymax = numpy.nanmax(Y) + 5
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend(bbox_to_anchor=(1.18, 1.0))
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
             class PowerProfilePlot(Plot):
                 CODE = 'pow_profile'
                 plot_type = 'scatter'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.height = 4
                     self.width = 3
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Intensity [dB]'
                     self.titles = ['Power Profile']
                     self.colorbar = False
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data[self.CODE] = dataOut.getPower()
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     self.y = y
                     x = self.data[-1][self.CODE]
-                    if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
+                    if self.xmin is None: self.xmin = numpy.nanmin(x) * 0.9
-                    if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
+                    if self.xmax is None: self.xmax = numpy.nanmax(x) * 1.1
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             self.axes[0].lines[ch].set_data(x[ch], y)
             class SpectraCutPlot(Plot):
                 CODE = 'spc_cut'
                 plot_type = 'scatter'
                 buffering = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.4 * self.ncols + 1.5
                     self.height = 3 * self.nrows
                     self.ylabel = 'Power [dB]'
                     self.colorbar = False
                     self.plots_adjust.update({'left':0.1, 'hspace':0.3, 'right': 0.75, 'bottom':0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
-                    spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
+                    spc = 10 * numpy.log10(dataOut.data_spc / dataOut.normFactor)
                     data['spc'] = spc
-                    meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
+                    meta['xrange'] = (dataOut.getFreqRange(1) / 1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0][1:]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     z = self.data[-1]['spc']
                     if self.height_index:
                         index = numpy.array(self.height_index)
                     else:
-                        index = numpy.arange(0, len(y), int((len(y))/9))
+                        index = numpy.arange(0, len(y), int((len(y)) / 9))
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.ymin = self.ymin if self.ymin else numpy.nanmin(z)
                             self.ymax = self.ymax if self.ymax else numpy.nanmax(z)
                             ax.plt = ax.plot(x, z[n, :, index].T)
                             labels = ['Range = {:2.1f}km'.format(y[i]) for i in index]
                             self.figures[0].legend(ax.plt, labels, loc='center right')
                         else:
                             for i, line in enumerate(ax.plt):
                                 line.set_data(x, z[n, :, index[i]])
                         self.titles.append('CH {}'.format(n))
             class BeaconPhase(Plot):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     Plot.__init__(self)
-                    self.timerange = 24*60*60
+                    self.timerange = 24 * 60 * 60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
-                    self.createFigure(id = id,
+                    self.createFigure(id=id,
-                                      wintitle = wintitle,
+                                      wintitle=wintitle,
-                                      widthplot = self.WIDTH+self.WIDTHPROF,
+                                      widthplot=self.WIDTH + self.WIDTHPROF,
-                                      heightplot = self.HEIGHT+self.HEIGHTPROF,
+                                      heightplot=self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
-                    self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
+                    self.addAxes(nrow, ncol * ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
-                    f = open(filename_phase,'w+')
+                    f = open(filename_phase, 'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
-                    f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
+                    f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n')
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
-                    f=open(filename_phase,'a')
+                    f = open(filename_phase, 'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
-                    f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
+                    f.write(day + ' ' + month + ' ' + year + '  ' + hour + ' ' + minute + ' ' + second + '   ' + str(data[0]) + '   ' + str(data[1]) + '   ' + str(data[2]) + '   ' + str(data[3]) + '\n')
                     f.close()
                 def plot(self):
                     log.warning('TODO: Not yet implemented...')
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
-                                raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
+                                raise ValueError("Pair %s is not in dataOut.pairsList" % (pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
              #         if len(pairsIndexList) > 4:
              #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
-                            hmax_index = hmax_list[-1]+1
+                            hmax_index = hmax_list[-1] + 1
                     x = dataOut.getTimeRange()
                     thisDatetime = dataOut.datatime
-                    title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
+                    title = wintitle + " Signal Phase"  # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
-                    #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
+                    # phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
-                        avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
+                        avgcoherenceComplex = ccf / numpy.sqrt(powa * powb)
-                        phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
+                        phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real) * 180 / numpy.pi
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
-                        #open file beacon phase
+                        # open file beacon phase
-                        path = '%s%03d' %(self.PREFIX, self.id)
+                        path = '%s%03d' % (self.PREFIX, self.id)
-                        beacon_file = os.path.join(path,'%s.txt'%self.name)
+                        beacon_file = os.path.join(path, '%s.txt' % self.name)
-                        self.filename_phase = os.path.join(figpath,beacon_file)
+                        self.filename_phase = os.path.join(figpath, beacon_file)
-                        #self.save_phase(self.filename_phase)
+                        # self.save_phase(self.filename_phase)
-                    #store data beacon phase
+                    # store data beacon phase
-                    #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
+                    # self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
-                    title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
+                    title = "Phase Plot %s" % (thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
-                    legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
+                    legendlabels = ["Pair (%d,%d)" % (pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
-                    if len(self.ydata)==0:
+                    if len(self.ydata) == 0:
-                        self.ydata = phase_beacon.reshape(-1,1)
+                        self.ydata = phase_beacon.reshape(-1, 1)
                     else:
-                        self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
+                        self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1, 1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
-                    return dataOut
  No newline at end of file
+                    return dataOut

schainpy/model/graphics/jroplot_voltage.py +64 -64

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             class ScopePlot(Plot):
                 '''
                    Plot for Scope
                 '''
                 CODE = 'scope'
                 plot_type = 'scatter'
                 def setup(self):
                     self.xaxis = 'Range (Km)'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.titles = ['Scope']
                     self.colorbar = False
                     self.width = 6
                     self.height = 4
                 def update(self, dataOut):
                     data = {}
                     meta = {
                         'nProfiles': dataOut.nProfiles,
                         'flagDataAsBlock': dataOut.flagDataAsBlock,
                         'profileIndex': dataOut.profileIndex,
                     }
                     if self.CODE == 'scope':
                         data[self.CODE] = dataOut.data
                     elif self.CODE == 'pp_power':
                         data[self.CODE] = dataOut.dataPP_POWER
                     elif self.CODE == 'pp_signal':
                         data[self.CODE] = dataOut.dataPP_POW
                     elif self.CODE == 'pp_velocity':
                         data[self.CODE] = dataOut.dataPP_DOP
                     elif self.CODE == 'pp_specwidth':
                         data[self.CODE] = dataOut.dataPP_WIDTH
                     return data, meta
                 def plot_iq(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    yreal = y[channelIndexList,:].real
+                    yreal = y[channelIndexList, :].real
-                    yimag = y[channelIndexList,:].imag
+                    yimag = y[channelIndexList, :].imag
-                    title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y"))
+                    title = wintitle + " Scope: %s" % (thisDatetime.strftime("%d-%b-%Y"))
                     self.xlabel = "Range (Km)"
                     self.ylabel = "Intensity - IQ"
                     self.y = yreal
                     self.x = x
                     self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
                         if ax.firsttime:
                             self.xmin = min(x)
                             self.xmax = max(x)
-                            ax.plt_r = ax.plot(x, yreal[i,:], color='b')[0]
+                            ax.plt_r = ax.plot(x, yreal[i, :], color='b')[0]
-                            ax.plt_i = ax.plot(x, yimag[i,:], color='r')[0]
+                            ax.plt_i = ax.plot(x, yimag[i, :], color='r')[0]
                         else:
-                            ax.plt_r.set_data(x, yreal[i,:])
+                            ax.plt_r.set_data(x, yreal[i, :])
-                            ax.plt_i.set_data(x, yimag[i,:])
+                            ax.plt_i.set_data(x, yimag[i, :])
                 def plot_power(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
+                    y = y[channelIndexList, :] * numpy.conjugate(y[channelIndexList, :])
                     yreal = y.real
-                    yreal = 10*numpy.log10(yreal)
+                    yreal = 10 * numpy.log10(yreal)
                     self.y = yreal
-                    title = wintitle + " Power: %s" %(thisDatetime.strftime("%d-%b-%Y"))
+                    title = wintitle + " Power: %s" % (thisDatetime.strftime("%d-%b-%Y"))
                     self.xlabel = "Range (Km)"
                     self.ylabel = "Intensity [dB]"
                     self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
-                        ychannel = yreal[i,:]
+                        ychannel = yreal[i, :]
                         if ax.firsttime:
                             self.xmin = min(x)
                             self.xmax = max(x)
                             ax.plt_r = ax.plot(x, ychannel)[0]
                         else:
                             ax.plt_r.set_data(x, ychannel)
                 def plot_weatherpower(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    y      = y[channelIndexList,:]
+                    y = y[channelIndexList, :]
-                    yreal  = y.real
+                    yreal = y.real
-                    yreal  = 10*numpy.log10(yreal)
+                    yreal = 10 * numpy.log10(yreal)
                     self.y = yreal
-                    title  = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
+                    title = wintitle + " Scope: %s" % (thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     self.xlabel = "Range (Km)"
                     self.ylabel = "Intensity"
-                    self.xmin   = min(x)
+                    self.xmin = min(x)
-                    self.xmax   = max(x)
+                    self.xmax = max(x)
-                    self.titles[0] =title
+                    self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title    = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
-                        ychannel = yreal[i,:]
+                        ychannel = yreal[i, :]
                         if ax.firsttime:
                             ax.plt_r = ax.plot(x, ychannel)[0]
                         else:
-                            #pass
+                            # pass
                             ax.plt_r.set_data(x, ychannel)
                 def plot_weathervelocity(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    x = x[channelIndexList,:]
+                    x = x[channelIndexList, :]
-                    yreal  = y
+                    yreal = y
                     self.y = yreal
-                    title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
+                    title = wintitle + " Scope: %s" % (thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     self.xlabel = "Velocity (m/s)"
                     self.ylabel = "Range (Km)"
-                    self.xmin   = numpy.min(x)
+                    self.xmin = numpy.min(x)
-                    self.xmax   = numpy.max(x)
+                    self.xmax = numpy.max(x)
-                    self.titles[0] =title
+                    self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title    = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
-                        xchannel    = x[i,:]
+                        xchannel = x[i, :]
                         if ax.firsttime:
                             ax.plt_r = ax.plot(xchannel, yreal)[0]
                         else:
-                            #pass
+                            # pass
                             ax.plt_r.set_data(xchannel, yreal)
                 def plot_weatherspecwidth(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    x = x[channelIndexList,:]
+                    x = x[channelIndexList, :]
-                    yreal  = y
+                    yreal = y
                     self.y = yreal
-                    title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
+                    title = wintitle + " Scope: %s" % (thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     self.xlabel = "width "
                     self.ylabel = "Range (Km)"
-                    self.xmin   = numpy.min(x)
+                    self.xmin = numpy.min(x)
-                    self.xmax   = numpy.max(x)
+                    self.xmax = numpy.max(x)
-                    self.titles[0] =title
+                    self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title    = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
-                        xchannel    = x[i,:]
+                        xchannel = x[i, :]
                         if ax.firsttime:
                             ax.plt_r = ax.plot(xchannel, yreal)[0]
                         else:
-                            #pass
+                            # pass
                             ax.plt_r.set_data(xchannel, yreal)
                 def plot(self):
                     if self.channels:
                         channels = self.channels
                     else:
                         channels = self.data.channels
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
                     scope = self.data[-1][self.CODE]
                     if self.data.flagDataAsBlock:
                         for i in range(self.data.nProfiles):
-                            wintitle1 = " [Profile = %d] " %i
+                            wintitle1 = " [Profile = %d] " % i
-                            if self.CODE =="scope":
+                            if self.CODE == "scope":
                                 if self.type == "power":
                                     self.plot_power(self.data.yrange,
-                                                    scope[:,i,:],
+                                                    scope[:, i, :],
                                                     channels,
                                                     thisDatetime,
                                                     wintitle1
                                                     )
                                 if self.type == "iq":
                                     self.plot_iq(self.data.yrange,
-                                                 scope[:,i,:],
+                                                 scope[:, i, :],
                                                  channels,
                                                  thisDatetime,
                                                  wintitle1
                                                 )
-                            if self.CODE=="pp_power":
+                            if self.CODE == "pp_power":
                                 self.plot_weatherpower(self.data.yrange,
-                                           scope[:,i,:],
+                                           scope[:, i, :],
                                            channels,
                                            thisDatetime,
                                            wintitle
                                            )
-                            if self.CODE=="pp_signal":
+                            if self.CODE == "pp_signal":
                                 self.plot_weatherpower(self.data.yrange,
-                                           scope[:,i,:],
+                                           scope[:, i, :],
                                            channels,
                                            thisDatetime,
                                            wintitle
                                            )
-                            if self.CODE=="pp_velocity":
+                            if self.CODE == "pp_velocity":
-                                self.plot_weathervelocity(scope[:,i,:],
+                                self.plot_weathervelocity(scope[:, i, :],
                                            self.data.yrange,
                                            channels,
                                            thisDatetime,
                                            wintitle
                                            )
-                            if self.CODE=="pp_spcwidth":
+                            if self.CODE == "pp_spcwidth":
-                                self.plot_weatherspecwidth(scope[:,i,:],
+                                self.plot_weatherspecwidth(scope[:, i, :],
                                            self.data.yrange,
                                            channels,
                                            thisDatetime,
                                            wintitle
                                            )
                     else:
-                        wintitle = " [Profile = %d] " %self.data.profileIndex
+                        wintitle = " [Profile = %d] " % self.data.profileIndex
-                        if self.CODE== "scope":
+                        if self.CODE == "scope":
                             if self.type == "power":
                                  self.plot_power(self.data.yrange,
                                             scope,
                                             channels,
                                             thisDatetime,
                                             wintitle
                                             )
                             if self.type == "iq":
                                 self.plot_iq(self.data.yrange,
                                             scope,
                                             channels,
                                             thisDatetime,
                                             wintitle
                                             )
-                        if self.CODE=="pp_power":
+                        if self.CODE == "pp_power":
                             self.plot_weatherpower(self.data.yrange,
                                                 scope,
                                                 channels,
                                                 thisDatetime,
                                                 wintitle
                                                    )
-                        if self.CODE=="pp_signal":
+                        if self.CODE == "pp_signal":
                             self.plot_weatherpower(self.data.yrange,
                                                 scope,
                                                 channels,
                                                 thisDatetime,
                                                 wintitle
                                                    )
-                        if self.CODE=="pp_velocity":
+                        if self.CODE == "pp_velocity":
                             self.plot_weathervelocity(scope,
                                                    self.data.yrange,
                                                    channels,
                                                    thisDatetime,
                                                    wintitle
                                                    )
-                        if self.CODE=="pp_specwidth":
+                        if self.CODE == "pp_specwidth":
                             self.plot_weatherspecwidth(scope,
                                                    self.data.yrange,
                                                    channels,
                                                    thisDatetime,
                                                    wintitle
                                                    )
             class PulsepairPowerPlot(ScopePlot):
                 '''
                 Plot for  P= S+N
                 '''
                 CODE = 'pp_power'
                 plot_type = 'scatter'
             class PulsepairVelocityPlot(ScopePlot):
                 '''
                 Plot for VELOCITY
                 '''
                 CODE = 'pp_velocity'
                 plot_type = 'scatter'
             class PulsepairSpecwidthPlot(ScopePlot):
                 '''
                 Plot for WIDTH
                 '''
                 CODE = 'pp_specwidth'
                 plot_type = 'scatter'
             class PulsepairSignalPlot(ScopePlot):
                 '''
                 Plot for S
                 '''
                 CODE = 'pp_signal'
                 plot_type = 'scatter'

schainpy/model/graphics/plotting_codes.py +12 -12

             '''
             @author: roj-idl71
             '''
-            #USED IN jroplot_spectra.py
+            # USED IN jroplot_spectra.py
-            RTI_CODE = 0            #Range time intensity (RTI).
+            RTI_CODE = 0  # Range time intensity (RTI).
-            SPEC_CODE = 1           #Spectra (and Cross-spectra) information.
+            SPEC_CODE = 1  # Spectra (and Cross-spectra) information.
-            CROSS_CODE = 2          #Cross-Correlation information.
+            CROSS_CODE = 2  # Cross-Correlation information.
-            COH_CODE = 3            #Coherence map.
+            COH_CODE = 3  # Coherence map.
-            BASE_CODE = 4           #Base lines graphic.
+            BASE_CODE = 4  # Base lines graphic.
-            ROW_CODE = 5            #Row Spectra.
+            ROW_CODE = 5  # Row Spectra.
-            TOTAL_CODE = 6          #Total Power.
+            TOTAL_CODE = 6  # Total Power.
-            DRIFT_CODE = 7          #Drifts graphics.
+            DRIFT_CODE = 7  # Drifts graphics.
-            HEIGHT_CODE = 8         #Height profile.
+            HEIGHT_CODE = 8  # Height profile.
-            PHASE_CODE = 9          #Signal Phase.
+            PHASE_CODE = 9  # Signal Phase.
             POWER_CODE = 16
             NOISE_CODE = 17
             BEACON_CODE = 18
-            #USED IN jroplot_parameters.py
+            # USED IN jroplot_parameters.py
             WIND_CODE = 22
             MSKYMAP_CODE = 23
             MPHASE_CODE = 24
             MOMENTS_CODE = 25
             PARMS_CODE = 26
             SPECFIT_CODE = 27
             EWDRIFT_CODE = 28

schainpy/model/io/MIRAtest.py +42 -42

             import os
             import sys
             import glob
             import fnmatch
             import datetime
             import time
             import re
             import h5py
             import numpy
             from scipy.optimize import curve_fit
             from scipy import asarray as ar, exp
             from scipy import stats
             from duplicity.path import Path
             from numpy.ma.core import getdata
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jrodata import Spectra
-            #from schainpy.model.data.BLTRheaderIO import FileHeader, RecordHeader
+            # from schainpy.model.data.BLTRheaderIO import FileHeader, RecordHeader
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
-            #from schainpy.model.io.jroIO_bltr import BLTRReader
+            # from schainpy.model.io.jroIO_bltr import BLTRReader
             from numpy import imag, shape, NaN
             startFp = open(
                 '/home/erick/Documents/MIRA35C/20160117/20160117_0000.zspc', "rb")
             FILE_HEADER = numpy.dtype([  # HEADER 1024bytes
                                       ('Hname', numpy.str_, 32),  # Original file name
                                       # Date and time when the file was created
                                       ('Htime', numpy.str_, 32),
                                       # Name of operator who created the file
                                       ('Hoper', numpy.str_, 64),
                                       # Place where the measurements was carried out
                                       ('Hplace', numpy.str_, 128),
                                       # Description of measurements
                                       ('Hdescr', numpy.str_, 256),
                                       ('Hdummy', numpy.str_, 512),  # Reserved space
                                       # Main chunk
                                       ('Msign', '<i4'),  # Main chunk signature FZKF or NUIG
                                       ('MsizeData', '<i4'),  # Size of data block main chunk
                                       # Processing DSP parameters
                                       ('PPARsign', '<i4'),  # PPAR signature
                                       ('PPARsize', '<i4'),  # PPAR size of block
                                       ('PPARprf', '<i4'),  # Pulse repetition frequency
                                       ('PPARpdr', '<i4'),  # Pulse duration
                                       ('PPARsft', '<i4'),  # FFT length
                                       # Number of spectral (in-coherent) averages
                                       ('PPARavc', '<i4'),
                                       # Number of lowest range gate for moment estimation
                                       ('PPARihp', '<i4'),
                                       # Count for gates for moment estimation
                                       ('PPARchg', '<i4'),
                                       # switch on/off polarimetric measurements. Should be 1.
                                       ('PPARpol', '<i4'),
                                       # Service DSP parameters
                                       # STC attenuation on the lowest ranges on/off
                                       ('SPARatt', '<i4'),
                                       ('SPARtx', '<i4'),  # OBSOLETE
                                       ('SPARaddGain0', '<f4'),  # OBSOLETE
                                       ('SPARaddGain1', '<f4'),  # OBSOLETE
                                       # Debug only. It normal mode it is 0.
                                       ('SPARwnd', '<i4'),
                                       # Delay between sync pulse and tx pulse for phase corr, ns
                                       ('SPARpos', '<i4'),
                                       # "add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
                                       ('SPARadd', '<i4'),
                                       # Time for measuring txn pulse phase. OBSOLETE
                                       ('SPARlen', '<i4'),
                                       ('SPARcal', '<i4'),  # OBSOLETE
                                       ('SPARnos', '<i4'),  # OBSOLETE
                                       ('SPARof0', '<i4'),  # detection threshold
                                       ('SPARof1', '<i4'),  # OBSOLETE
                                       ('SPARswt', '<i4'),  # 2nd moment estimation threshold
                                       ('SPARsum', '<i4'),  # OBSOLETE
                                       ('SPARosc', '<i4'),  # flag Oscillosgram mode
                                       ('SPARtst', '<i4'),  # OBSOLETE
                                       ('SPARcor', '<i4'),  # OBSOLETE
                                       ('SPARofs', '<i4'),  # OBSOLETE
                                       # Hildebrand div noise detection on noise gate
                                       ('SPARhsn', '<i4'),
                                       # Hildebrand div noise detection on all gates
                                       ('SPARhsa', '<f4'),
                                       ('SPARcalibPow_M', '<f4'),  # OBSOLETE
                                       ('SPARcalibSNR_M', '<f4'),  # OBSOLETE
                                       ('SPARcalibPow_S', '<f4'),  # OBSOLETE
                                       ('SPARcalibSNR_S', '<f4'),  # OBSOLETE
                                       # Lowest range gate for spectra saving Raw_Gate1 >=5
                                       ('SPARrawGate1', '<i4'),
                                       # Number of range gates with atmospheric signal
                                       ('SPARrawGate2', '<i4'),
                                       # flag - IQ or spectra saving on/off
                                       ('SPARraw', '<i4'),
                                       ('SPARprc', '<i4'), ])  # flag - Moment estimation switched on/off
             self.Hname = None
             self.Htime = None
             self.Hoper = None
             self.Hplace = None
             self.Hdescr = None
             self.Hdummy = None
             self.Msign = None
             self.MsizeData = None
             self.PPARsign = None
             self.PPARsize = None
             self.PPARprf = None
             self.PPARpdr = None
             self.PPARsft = None
             self.PPARavc = None
             self.PPARihp = None
             self.PPARchg = None
             self.PPARpol = None
             # Service DSP parameters
             self.SPARatt = None
             self.SPARtx = None
             self.SPARaddGain0 = None
             self.SPARaddGain1 = None
             self.SPARwnd = None
             self.SPARpos = None
             self.SPARadd = None
             self.SPARlen = None
             self.SPARcal = None
             self.SPARnos = None
             self.SPARof0 = None
             self.SPARof1 = None
             self.SPARswt = None
             self.SPARsum = None
             self.SPARosc = None
             self.SPARtst = None
             self.SPARcor = None
             self.SPARofs = None
             self.SPARhsn = None
             self.SPARhsa = None
             self.SPARcalibPow_M = None
             self.SPARcalibSNR_M = None
             self.SPARcalibPow_S = None
             self.SPARcalibSNR_S = None
             self.SPARrawGate1 = None
             self.SPARrawGate2 = None
             self.SPARraw = None
             self.SPARprc = None
             header = numpy.fromfile(fp, FILE_HEADER, 1)
             '''      numpy.fromfile(file, dtype, count, sep='')
                 file : file or str
                 Open file object or filename.
                 dtype : data-type
                 Data type of the returned array. For binary files, it is used to determine
                 the size and byte-order of the items in the file.
                 count : int
                 Number of items to read. -1 means all items (i.e., the complete file).
                 sep : str
                 Separator between items if file is a text file. Empty ("") separator means
                 the file should be treated as binary. Spaces (" ") in the separator match zero
                 or more whitespace characters. A separator consisting only of spaces must match
                 at least one whitespace.
             '''
             Hname = str(header['Hname'][0])
             Htime = str(header['Htime'][0])
             Hoper = str(header['Hoper'][0])
             Hplace = str(header['Hplace'][0])
             Hdescr = str(header['Hdescr'][0])
             Hdummy = str(header['Hdummy'][0])
             Msign = header['Msign'][0]
             MsizeData = header['MsizeData'][0]
             PPARsign = header['PPARsign'][0]
             PPARsize = header['PPARsize'][0]
             PPARprf = header['PPARprf'][0]
             PPARpdr = header['PPARpdr'][0]
             PPARsft = header['PPARsft'][0]
             PPARavc = header['PPARavc'][0]
             PPARihp = header['PPARihp'][0]
             PPARchg = header['PPARchg'][0]
             PPARpol = header['PPARpol'][0]
             # Service DSP parameters
             SPARatt = header['SPARatt'][0]
             SPARtx = header['SPARtx'][0]
             SPARaddGain0 = header['SPARaddGain0'][0]
             SPARaddGain1 = header['SPARaddGain1'][0]
             SPARwnd = header['SPARwnd'][0]
             SPARpos = header['SPARpos'][0]
             SPARadd = header['SPARadd'][0]
             SPARlen = header['SPARlen'][0]
             SPARcal = header['SPARcal'][0]
             SPARnos = header['SPARnos'][0]
             SPARof0 = header['SPARof0'][0]
             SPARof1 = header['SPARof1'][0]
             SPARswt = header['SPARswt'][0]
             SPARsum = header['SPARsum'][0]
             SPARosc = header['SPARosc'][0]
             SPARtst = header['SPARtst'][0]
             SPARcor = header['SPARcor'][0]
             SPARofs = header['SPARofs'][0]
             SPARhsn = header['SPARhsn'][0]
             SPARhsa = header['SPARhsa'][0]
             SPARcalibPow_M = header['SPARcalibPow_M'][0]
             SPARcalibSNR_M = header['SPARcalibSNR_M'][0]
             SPARcalibPow_S = header['SPARcalibPow_S'][0]
             SPARcalibSNR_S = header['SPARcalibSNR_S'][0]
             SPARrawGate1 = header['SPARrawGate1'][0]
             SPARrawGate2 = header['SPARrawGate2'][0]
             SPARraw = header['SPARraw'][0]
             SPARprc = header['SPARprc'][0]
             SRVI_STRUCTURE = numpy.dtype([
                                         ('frame_cnt', '<u4'),
-                                        ('time_t', '<u4'),   #
+                                        ('time_t', '<u4'),  #
-                                        ('tpow', '<f4'),     #
+                                        ('tpow', '<f4'),  #
-                                        ('npw1', '<f4'),     #
+                                        ('npw1', '<f4'),  #
-                                        ('npw2', '<f4'),     #
+                                        ('npw2', '<f4'),  #
-                                        ('cpw1', '<f4'),     #
+                                        ('cpw1', '<f4'),  #
-                                        ('pcw2', '<f4'),     #
+                                        ('pcw2', '<f4'),  #
-                                        ('ps_err', '<u4'),   #
+                                        ('ps_err', '<u4'),  #
-                                        ('te_err', '<u4'),   #
+                                        ('te_err', '<u4'),  #
-                                        ('rc_err', '<u4'),   #
+                                        ('rc_err', '<u4'),  #
-                                        ('grs1', '<u4'),     #
+                                        ('grs1', '<u4'),  #
-                                        ('grs2', '<u4'),     #
+                                        ('grs2', '<u4'),  #
-                                        ('azipos', '<f4'),     #
+                                        ('azipos', '<f4'),  #
-                                        ('azivel', '<f4'),     #
+                                        ('azivel', '<f4'),  #
-                                        ('elvpos', '<f4'),     #
+                                        ('elvpos', '<f4'),  #
-                                        ('elvvel', '<f4'),     #
+                                        ('elvvel', '<f4'),  #
                                         ('northAngle', '<f4'),
-                                        ('microsec', '<u4'),   #
+                                        ('microsec', '<u4'),  #
                                         ('azisetvel', '<f4'),  #
                                         ('elvsetpos', '<f4'),  #
-                                        ('RadarConst', '<f4'), ])   #
+                                        ('RadarConst', '<f4'), ])  #
             JUMP_STRUCTURE = numpy.dtype([
                                         ('jump', '<u140'),
                                         ('SizeOfDataBlock1', numpy.str_, 32),
                                         ('jump', '<i4'),
                                         ('DataBlockTitleSRVI1', numpy.str_, 32),
                                         ('SizeOfSRVI1', '<i4'), ])
             # frame_cnt=0,  time_t= 0,  tpow=0,   npw1=0,   npw2=0,
             # cpw1=0,   pcw2=0,       ps_err=0,   te_err=0,   rc_err=0,   grs1=0,
             # grs2=0,   azipos=0,   azivel=0,   elvpos=0,   elvvel=0,   northangle=0,
             # microsec=0,   azisetvel=0,   elvsetpos=0,   RadarConst=0
             frame_cnt = frame_cnt
             dwell = time_t
             tpow = tpow
             npw1 = npw1
             npw2 = npw2
             cpw1 = cpw1
             pcw2 = pcw2
             ps_err = ps_err
             te_err = te_err
             rc_err = rc_err
             grs1 = grs1
             grs2 = grs2
             azipos = azipos
             azivel = azivel
             elvpos = elvpos
             elvvel = elvvel
             northAngle = northAngle
             microsec = microsec
             azisetvel = azisetvel
             elvsetpos = elvsetpos
             RadarConst5 = RadarConst
             # print fp
             # startFp = open('/home/erick/Documents/Data/huancayo.20161019.22.fdt',"rb") #The method tell() returns the current position of the file read/write pointer within the file.
             # startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
             # RecCounter=0
             # Off2StartNxtRec=811248
             # print 'OffsetStartHeader ',self.OffsetStartHeader,'RecCounter ', self.RecCounter, 'Off2StartNxtRec ' , self.Off2StartNxtRec
-            #OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
+            # OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
-            #startFp.seek(OffRHeader, os.SEEK_SET)
+            # startFp.seek(OffRHeader, os.SEEK_SET)
             print('debe ser 48, RecCounter*811248', self.OffsetStartHeader, self.RecCounter, self.Off2StartNxtRec)
             print('Posicion del bloque:        ', OffRHeader)
             header = numpy.fromfile(startFp, SRVI_STRUCTURE, 1)
             self.frame_cnt = header['frame_cnt'][0]
-            self.time_t = header['frame_cnt'][0]   #
+            self.time_t = header['frame_cnt'][0]  #
-            self.tpow = header['frame_cnt'][0]     #
+            self.tpow = header['frame_cnt'][0]  #
-            self.npw1 = header['frame_cnt'][0]     #
+            self.npw1 = header['frame_cnt'][0]  #
-            self.npw2 = header['frame_cnt'][0]     #
+            self.npw2 = header['frame_cnt'][0]  #
-            self.cpw1 = header['frame_cnt'][0]     #
+            self.cpw1 = header['frame_cnt'][0]  #
-            self.pcw2 = header['frame_cnt'][0]     #
+            self.pcw2 = header['frame_cnt'][0]  #
-            self.ps_err = header['frame_cnt'][0]    #
+            self.ps_err = header['frame_cnt'][0]  #
-            self.te_err = header['frame_cnt'][0]    #
+            self.te_err = header['frame_cnt'][0]  #
-            self.rc_err = header['frame_cnt'][0]    #
+            self.rc_err = header['frame_cnt'][0]  #
-            self.grs1 = header['frame_cnt'][0]      #
+            self.grs1 = header['frame_cnt'][0]  #
-            self.grs2 = header['frame_cnt'][0]      #
+            self.grs2 = header['frame_cnt'][0]  #
-            self.azipos = header['frame_cnt'][0]     #
+            self.azipos = header['frame_cnt'][0]  #
-            self.azivel = header['frame_cnt'][0]     #
+            self.azivel = header['frame_cnt'][0]  #
-            self.elvpos = header['frame_cnt'][0]     #
+            self.elvpos = header['frame_cnt'][0]  #
-            self.elvvel = header['frame_cnt'][0]     #
+            self.elvvel = header['frame_cnt'][0]  #
-            self.northAngle = header['frame_cnt'][0]    #
+            self.northAngle = header['frame_cnt'][0]  #
-            self.microsec = header['frame_cnt'][0]      #
+            self.microsec = header['frame_cnt'][0]  #
-            self.azisetvel = header['frame_cnt'][0]     #
+            self.azisetvel = header['frame_cnt'][0]  #
-            self.elvsetpos = header['frame_cnt'][0]     #
+            self.elvsetpos = header['frame_cnt'][0]  #
-            self.RadarConst = header['frame_cnt'][0]    #
+            self.RadarConst = header['frame_cnt'][0]  #
             self.ipp = 0.5 * (SPEED_OF_LIGHT / self.PRFhz)
             self.RHsize = 180 + 20 * self.nChannels
             self.Datasize = self.nProfiles * self.nChannels * self.nHeights * 2 * 4
             # print 'Datasize',self.Datasize
             endFp = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
             print('==============================================')
-            print('==============================================')
  No newline at end of file
+            print('==============================================')

schainpy/model/io/__init__.py +1 -1

             '''
             $Author: murco $
             $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
             '''
             from .jroIO_voltage import *
             from .jroIO_spectra import *
             from .jroIO_heispectra import *
             from .jroIO_usrp import *
             from .jroIO_digitalRF import *
             from .jroIO_kamisr import *
             from .jroIO_param import *
             from .jroIO_hf import *
             from .jroIO_madrigal import *
             from .bltrIO_param import *
             from .bltrIO_spectra import *
             from .jroIO_mira35c import *
             from .julIO_param import *
             from .pxIO_param import *
-            from .jroIO_simulator import *
  No newline at end of file
+            from .jroIO_simulator import *

schainpy/model/io/bltrIO_param.py +6 -6

             '''
             Created on Nov 9, 2016
             @author: roj- LouVD
             '''
             import os
             import sys
             import time
             import glob
             import datetime
             import numpy
             import schainpy.admin
             from schainpy.model.proc.jroproc_base import ProcessingUnit, MPDecorator
             from schainpy.model.data.jrodata import Parameters
             from schainpy.model.io.jroIO_base import Reader
             from schainpy.utils import log
             FILE_HEADER_STRUCTURE = numpy.dtype([
                 ('FMN', '<u4'),
                 ('nrec', '<u4'),
                 ('fr_offset', '<u4'),
                 ('id', '<u4'),
                 ('site', 'u1', (32,))
             ])
             REC_HEADER_STRUCTURE = numpy.dtype([
                 ('rmn', '<u4'),
                 ('rcounter', '<u4'),
                 ('nr_offset', '<u4'),
                 ('tr_offset', '<u4'),
                 ('time', '<u4'),
                 ('time_msec', '<u4'),
                 ('tag', 'u1', (32,)),
                 ('comments', 'u1', (32,)),
                 ('lat', '<f4'),
                 ('lon', '<f4'),
                 ('gps_status', '<u4'),
                 ('freq', '<u4'),
                 ('freq0', '<u4'),
                 ('nchan', '<u4'),
                 ('delta_r', '<u4'),
                 ('nranges', '<u4'),
                 ('r0', '<u4'),
                 ('prf', '<u4'),
                 ('ncoh', '<u4'),
                 ('npoints', '<u4'),
                 ('polarization', '<i4'),
                 ('rx_filter', '<u4'),
                 ('nmodes', '<u4'),
                 ('dmode_index', '<u4'),
                 ('dmode_rngcorr', '<u4'),
                 ('nrxs', '<u4'),
                 ('acf_length', '<u4'),
                 ('acf_lags', '<u4'),
                 ('sea_to_atmos', '<f4'),
                 ('sea_notch', '<u4'),
                 ('lh_sea', '<u4'),
                 ('hh_sea', '<u4'),
                 ('nbins_sea', '<u4'),
                 ('min_snr', '<f4'),
                 ('min_cc', '<f4'),
                 ('max_time_diff', '<f4')
             ])
             DATA_STRUCTURE = numpy.dtype([
                 ('range', '<u4'),
                 ('status', '<u4'),
                 ('zonal', '<f4'),
                 ('meridional', '<f4'),
                 ('vertical', '<f4'),
                 ('zonal_a', '<f4'),
                 ('meridional_a', '<f4'),
                 ('corrected_fading', '<f4'),  # seconds
                 ('uncorrected_fading', '<f4'),  # seconds
                 ('time_diff', '<f4'),
                 ('major_axis', '<f4'),
                 ('axial_ratio', '<f4'),
                 ('orientation', '<f4'),
                 ('sea_power', '<u4'),
                 ('sea_algorithm', '<u4')
             ])
             class BLTRParamReader(Reader, ProcessingUnit):
                 '''
                 Boundary Layer and Tropospheric Radar (BLTR) reader, Wind velocities and SNR
                 from *.sswma files
                 '''
                 ext = '.sswma'
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.dataOut = Parameters()
                     self.dataOut.timezone = 300
                     self.counter_records = 0
                     self.flagNoMoreFiles = 0
                     self.isConfig = False
                     self.filename = None
                     self.status_value = 0
-                    self.datatime = datetime.datetime(1900,1,1)
+                    self.datatime = datetime.datetime(1900, 1, 1)
                     self.filefmt = "*********%Y%m%d******"
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if self.path is None:
                         raise ValueError("The path is not valid")
                     if self.online:
                         log.log("Searching files in online mode...", self.name)
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             except:
                                 fullpath = None
                             if fullpath:
                                 self.fileSize = os.path.getsize(fullpath)
                                 self.filename = fullpath
                                 self.flagIsNewFile = 1
                                 if self.fp != None:
                                     self.fp.close()
                                 self.fp = self.open_file(fullpath, self.open_mode)
                                 self.flagNoMoreFiles = 0
                                 break
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         if not(fullpath):
                             raise schainpy.admin.SchainError(
                                 'There isn\'t any valid file in {}'.format(self.path))
                         self.readFirstHeader()
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                         self.setNextFile()
                 def checkForRealPath(self, nextFile, nextDay):
                     '''
                     '''
                     dt = self.datatime + datetime.timedelta(1)
                     filename = '{}.{}{}'.format(self.siteFile, dt.strftime('%Y%m%d'), self.ext)
                     fullfilename = os.path.join(self.path, filename)
                     if os.path.exists(fullfilename):
                         return fullfilename, filename
                     return None, filename
                 def readFirstHeader(self):
                     '''
                     '''
                     # 'peru2' ---> Piura  -   'peru1' ---> Huancayo or Porcuya
                     self.siteFile = self.filename.split('/')[-1].split('.')[0]
                     self.header_file = numpy.fromfile(self.fp, FILE_HEADER_STRUCTURE, 1)
                     self.nrecords = self.header_file['nrec'][0]
                     self.counter_records = 0
                     self.flagIsNewFile = 0
                     self.fileIndex += 1
                 def readNextBlock(self):
                     while True:
                         if not self.online and self.counter_records == self.nrecords:
                             self.flagIsNewFile = 1
                             if not self.setNextFile():
                                 return 0
                         try:
                             pointer = self.fp.tell()
                             self.readBlock()
                         except:
                             if self.online and self.waitDataBlock(pointer, 38512) == 1:
                                 continue
                             else:
                                 if not self.setNextFile():
                                     return 0
                         if (self.datatime < datetime.datetime.combine(self.startDate, self.startTime)) or \
                            (self.datatime > datetime.datetime.combine(self.endDate, self.endTime)):
                             log.warning(
                                 'Reading Record No. {}/{} -> {} [Skipping]'.format(
                                     self.counter_records,
                                     self.nrecords,
                                     self.datatime.ctime()),
                                 'BLTRParamReader')
                             continue
                         break
                     log.log('Reading Record No. {} -> {}'.format(
                         self.counter_records,
                         self.datatime.ctime()), 'BLTRParamReader')
                     return 1
                 def readBlock(self):
                     pointer = self.fp.tell()
                     header_rec = numpy.fromfile(self.fp, REC_HEADER_STRUCTURE, 1)
                     self.nchannels = int(header_rec['nchan'][0] / 2)
                     self.kchan = header_rec['nrxs'][0]
                     self.nmodes = header_rec['nmodes'][0]
                     self.nranges = header_rec['nranges'][0]
                     self.fp.seek(pointer)
                     self.height = numpy.empty((self.nmodes, self.nranges))
                     self.snr = numpy.empty((self.nmodes, int(self.nchannels), self.nranges))
                     self.buffer = numpy.empty((self.nmodes, 3, self.nranges))
                     self.flagDiscontinuousBlock = 0
                     for mode in range(self.nmodes):
                         self.readHeader()
                         data = self.readData()
                         self.height[mode] = (data[0] - self.correction) / 1000.
                         self.buffer[mode] = data[1]
                         self.snr[mode] = data[2]
                     self.counter_records = self.counter_records + self.nmodes
                     return
                 def readHeader(self):
                     '''
                     RecordHeader of BLTR rawdata file
                     '''
                     header_structure = numpy.dtype(
                         REC_HEADER_STRUCTURE.descr + [
                             ('antenna_coord', 'f4', (2, int(self.nchannels))),
                             ('rx_gains', 'u4', (int(self.nchannels),)),
                             ('rx_analysis', 'u4', (int(self.nchannels),))
                         ]
                     )
                     self.header_rec = numpy.fromfile(self.fp, header_structure, 1)
                     self.lat = self.header_rec['lat'][0]
                     self.lon = self.header_rec['lon'][0]
                     self.delta = self.header_rec['delta_r'][0]
                     self.correction = self.header_rec['dmode_rngcorr'][0]
                     self.imode = self.header_rec['dmode_index'][0]
                     self.antenna = self.header_rec['antenna_coord']
                     self.rx_gains = self.header_rec['rx_gains']
                     self.time = self.header_rec['time'][0]
                     dt = datetime.datetime.utcfromtimestamp(self.time)
-                    if dt.date()>self.datatime.date():
+                    if dt.date() > self.datatime.date():
                         self.flagDiscontinuousBlock = 1
                     self.datatime = dt
                 def readData(self):
                     '''
                     Reading and filtering data block record of BLTR rawdata file,
                     filtering is according to status_value.
                     Input:
                         status_value - Array data is set to NAN for values that are not
                         equal to status_value
                     '''
                     self.nchannels = int(self.nchannels)
                     data_structure = numpy.dtype(
                         DATA_STRUCTURE.descr + [
                             ('rx_saturation', 'u4', (self.nchannels,)),
                             ('chan_offset', 'u4', (2 * self.nchannels,)),
                             ('rx_amp', 'u4', (self.nchannels,)),
                             ('rx_snr', 'f4', (self.nchannels,)),
                             ('cross_snr', 'f4', (self.kchan,)),
                             ('sea_power_relative', 'f4', (self.kchan,))]
                     )
                     data = numpy.fromfile(self.fp, data_structure, self.nranges)
                     height = data['range']
                     winds = numpy.array(
                         (data['zonal'], data['meridional'], data['vertical']))
                     snr = data['rx_snr'].T
                     winds[numpy.where(winds == -9999.)] = numpy.nan
                     winds[:, numpy.where(data['status'] != self.status_value)] = numpy.nan
                     snr[numpy.where(snr == -9999.)] = numpy.nan
                     snr[:, numpy.where(data['status'] != self.status_value)] = numpy.nan
                     snr = numpy.power(10, snr / 10)
                     return height, winds, snr
                 def set_output(self):
                     '''
                     Storing data from databuffer to dataOut object
                     '''
                     self.dataOut.data_snr = self.snr
                     self.dataOut.height = self.height
                     self.dataOut.data = self.buffer
                     self.dataOut.utctimeInit = self.time
                     self.dataOut.utctime = self.dataOut.utctimeInit
                     self.dataOut.useLocalTime = False
                     self.dataOut.paramInterval = 157
                     self.dataOut.site = self.siteFile
                     self.dataOut.nrecords = self.nrecords / self.nmodes
                     self.dataOut.lat = self.lat
                     self.dataOut.lon = self.lon
                     self.dataOut.channelList = list(range(self.nchannels))
                     self.dataOut.kchan = self.kchan
                     self.dataOut.delta = self.delta
                     self.dataOut.correction = self.correction
                     self.dataOut.nmodes = self.nmodes
                     self.dataOut.imode = self.imode
                     self.dataOut.antenna = self.antenna
                     self.dataOut.rx_gains = self.rx_gains
                     self.dataOut.flagNoData = False
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                 def getData(self):
                     '''
                     Storing data from databuffer to dataOut object
                     '''
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         return 0
                     if not self.readNextBlock():
                         self.dataOut.flagNoData = True
                         return 0
                     self.set_output()
                     return 1
                 def run(self, **kwargs):
                     '''
                     '''
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
-                    return
  No newline at end of file
+                    return

schainpy/model/io/bltrIO_spectra.py +15 -15

             import os
             import sys
             import glob
             import numpy
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             from .utils import folder_in_range
             import schainpy.admin
             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.proc.jroproc_base import ProcessingUnit
             from schainpy.utils import log
             def pol2cart(rho, phi):
                 x = rho * numpy.cos(phi)
                 y = rho * numpy.sin(phi)
                 return(x, y)
             FILE_STRUCTURE = numpy.dtype([  # HEADER 48bytes
                 ('FileMgcNumber', '<u4'),  # 0x23020100
                 ('nFDTdataRecors', '<u4'),
                 ('OffsetStartHeader', '<u4'),
                 ('RadarUnitId', '<u4'),
                 ('SiteName', 'S32'),  # Null terminated
             ])
             class FileHeaderBLTR():
                 def __init__(self, fo):
                     self.fo = fo
                     self.size = 48
                     self.read()
                 def read(self):
                     header = numpy.fromfile(self.fo, FILE_STRUCTURE, 1)
                     self.FileMgcNumber = hex(header['FileMgcNumber'][0])
                     self.nFDTdataRecors = int(header['nFDTdataRecors'][0])
                     self.RadarUnitId = int(header['RadarUnitId'][0])
                     self.OffsetStartHeader = int(header['OffsetStartHeader'][0])
                     self.SiteName = header['SiteName'][0]
                 def write(self, fp):
                     headerTuple = (self.FileMgcNumber,
                                    self.nFDTdataRecors,
                                    self.RadarUnitId,
                                    self.SiteName,
                                    self.size)
                     header = numpy.array(headerTuple, FILE_STRUCTURE)
                     header.tofile(fp)
                     ''' ndarray.tofile(fid, sep, format)    Write array to a file as text or binary (default).
                     fid : file or str
                     An open file object, or a string containing a filename.
                     sep : str
                     Separator between array items for text output. If "" (empty), a binary file is written,
                     equivalent to file.write(a.tobytes()).
                     format : str
                     Format string for text file output. Each entry in the array is formatted to text by
                     first converting it to the closest Python type, and then using "format" % item.
                     '''
                     return 1
             RECORD_STRUCTURE = numpy.dtype([  # RECORD HEADER 180+20N bytes
                 ('RecMgcNumber', '<u4'),  # 0x23030001
                 ('RecCounter', '<u4'),  # Record counter(0,1, ...)
                 # Offset to start of next record form start of this record
                                         ('Off2StartNxtRec', '<u4'),
                                         # Offset to start of data from start of this record
                                         ('Off2StartData', '<u4'),
                                         # Epoch time stamp of start of acquisition (seconds)
                                         ('nUtime', '<i4'),
                                         # Millisecond component of time stamp (0,...,999)
                                         ('nMilisec', '<u4'),
                                         # Experiment tag name (null terminated)
                                         ('ExpTagName', 'S32'),
                                         # Experiment comment (null terminated)
                                         ('ExpComment', 'S32'),
                                         # Site latitude (from GPS) in degrees (positive implies North)
                                         ('SiteLatDegrees', '<f4'),
                                         # Site longitude (from GPS) in degrees (positive implies East)
                                         ('SiteLongDegrees', '<f4'),
                                         # RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
                                         ('RTCgpsStatus', '<u4'),
                                         ('TransmitFrec', '<u4'),  # Transmit frequency (Hz)
                                         ('ReceiveFrec', '<u4'),  # Receive frequency
                                         # First local oscillator frequency (Hz)
                                         ('FirstOsciFrec', '<u4'),
                                         # (0="O", 1="E", 2="linear 1", 3="linear2")
                                         ('Polarisation', '<u4'),
                                         # Receiver filter settings (0,1,2,3)
                                         ('ReceiverFiltSett', '<u4'),
                                         # Number of modes in use (1 or 2)
                                         ('nModesInUse', '<u4'),
                                         # Dual Mode index number for these data (0 or 1)
                                         ('DualModeIndex', '<u4'),
                                         # Dual Mode range correction for these data (m)
                                         ('DualModeRange', '<u4'),
                                         # Number of digital channels acquired (2*N)
                                         ('nDigChannels', '<u4'),
                                         # Sampling resolution (meters)
                                         ('SampResolution', '<u4'),
                                         # Number of range gates sampled
                                         ('nHeights', '<u4'),
                                         # Start range of sampling (meters)
                                         ('StartRangeSamp', '<u4'),
                                         ('PRFhz', '<u4'),  # PRF (Hz)
                                         ('nCohInt', '<u4'),  # Integrations
                                         # Number of data points transformed
                                         ('nProfiles', '<u4'),
                                         # Number of receive beams stored in file (1 or N)
                                         ('nChannels', '<u4'),
                                         ('nIncohInt', '<u4'),  # Number of spectral averages
                                         # FFT windowing index (0 = no window)
                                         ('FFTwindowingInd', '<u4'),
                                         # Beam steer angle (azimuth) in degrees (clockwise from true North)
                                         ('BeamAngleAzim', '<f4'),
                                         # Beam steer angle (zenith) in degrees (0=> vertical)
                                         ('BeamAngleZen', '<f4'),
                                         # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaCoord0', '<f4'),
                                         # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaAngl0', '<f4'),
                                         # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaCoord1', '<f4'),
                                         # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaAngl1', '<f4'),
                                         # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaCoord2', '<f4'),
                                         # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaAngl2', '<f4'),
                                         # Receiver phase calibration (degrees) - N values
                                         ('RecPhaseCalibr0', '<f4'),
                                         # Receiver phase calibration (degrees) - N values
                                         ('RecPhaseCalibr1', '<f4'),
                                         # Receiver phase calibration (degrees) - N values
                                         ('RecPhaseCalibr2', '<f4'),
                                         # Receiver amplitude calibration (ratio relative to receiver one) - N values
                                         ('RecAmpCalibr0', '<f4'),
                                         # Receiver amplitude calibration (ratio relative to receiver one) - N values
                                         ('RecAmpCalibr1', '<f4'),
                                         # Receiver amplitude calibration (ratio relative to receiver one) - N values
                                         ('RecAmpCalibr2', '<f4'),
                                         # Receiver gains in dB - N values
                                         ('ReceiverGaindB0', '<i4'),
                                         # Receiver gains in dB - N values
                                         ('ReceiverGaindB1', '<i4'),
                                         # Receiver gains in dB - N values
                                         ('ReceiverGaindB2', '<i4'),
             ])
             class RecordHeaderBLTR():
                 def __init__(self, fo):
                     self.fo = fo
                     self.OffsetStartHeader = 48
                     self.Off2StartNxtRec = 811248
                 def read(self, block):
                     OffRHeader = self.OffsetStartHeader + block * self.Off2StartNxtRec
                     self.fo.seek(OffRHeader, os.SEEK_SET)
                     header = numpy.fromfile(self.fo, RECORD_STRUCTURE, 1)
                     self.RecMgcNumber = hex(header['RecMgcNumber'][0])  # 0x23030001
                     self.RecCounter = int(header['RecCounter'][0])
                     self.Off2StartNxtRec = int(header['Off2StartNxtRec'][0])
                     self.Off2StartData = int(header['Off2StartData'][0])
                     self.nUtime = header['nUtime'][0]
                     self.nMilisec = header['nMilisec'][0]
-                    self.ExpTagName = '' # str(header['ExpTagName'][0])
+                    self.ExpTagName = ''  # str(header['ExpTagName'][0])
-                    self.ExpComment = '' # str(header['ExpComment'][0])
+                    self.ExpComment = ''  # str(header['ExpComment'][0])
                     self.SiteLatDegrees = header['SiteLatDegrees'][0]
                     self.SiteLongDegrees = header['SiteLongDegrees'][0]
                     self.RTCgpsStatus = header['RTCgpsStatus'][0]
                     self.TransmitFrec = header['TransmitFrec'][0]
                     self.ReceiveFrec = header['ReceiveFrec'][0]
                     self.FirstOsciFrec = header['FirstOsciFrec'][0]
                     self.Polarisation = header['Polarisation'][0]
                     self.ReceiverFiltSett = header['ReceiverFiltSett'][0]
                     self.nModesInUse = header['nModesInUse'][0]
                     self.DualModeIndex = header['DualModeIndex'][0]
                     self.DualModeRange = header['DualModeRange'][0]
                     self.nDigChannels = header['nDigChannels'][0]
                     self.SampResolution = header['SampResolution'][0]
                     self.nHeights = header['nHeights'][0]
                     self.StartRangeSamp = header['StartRangeSamp'][0]
                     self.PRFhz = header['PRFhz'][0]
                     self.nCohInt = header['nCohInt'][0]
                     self.nProfiles = header['nProfiles'][0]
                     self.nChannels = header['nChannels'][0]
                     self.nIncohInt = header['nIncohInt'][0]
                     self.FFTwindowingInd = header['FFTwindowingInd'][0]
                     self.BeamAngleAzim = header['BeamAngleAzim'][0]
                     self.BeamAngleZen = header['BeamAngleZen'][0]
                     self.AntennaCoord0 = header['AntennaCoord0'][0]
                     self.AntennaAngl0 = header['AntennaAngl0'][0]
                     self.AntennaCoord1 = header['AntennaCoord1'][0]
                     self.AntennaAngl1 = header['AntennaAngl1'][0]
                     self.AntennaCoord2 = header['AntennaCoord2'][0]
                     self.AntennaAngl2 = header['AntennaAngl2'][0]
                     self.RecPhaseCalibr0 = header['RecPhaseCalibr0'][0]
                     self.RecPhaseCalibr1 = header['RecPhaseCalibr1'][0]
                     self.RecPhaseCalibr2 = header['RecPhaseCalibr2'][0]
                     self.RecAmpCalibr0 = header['RecAmpCalibr0'][0]
                     self.RecAmpCalibr1 = header['RecAmpCalibr1'][0]
                     self.RecAmpCalibr2 = header['RecAmpCalibr2'][0]
                     self.ReceiverGaindB0 = header['ReceiverGaindB0'][0]
                     self.ReceiverGaindB1 = header['ReceiverGaindB1'][0]
                     self.ReceiverGaindB2 = header['ReceiverGaindB2'][0]
                     self.ipp = 0.5 * (SPEED_OF_LIGHT / self.PRFhz)
                     self.RHsize = 180 + 20 * self.nChannels
                     self.Datasize = self.nProfiles * self.nChannels * self.nHeights * 2 * 4
                     endFp = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
                     if OffRHeader > endFp:
                         sys.stderr.write(
                             "Warning %s: Size value read from System Header is lower than it has to be\n" % fp)
                         return 0
                     if OffRHeader < endFp:
                         sys.stderr.write(
                             "Warning %s: Size value read from System Header size is greater than it has to be\n" % fp)
                         return 0
                     return 1
             class BLTRSpectraReader (ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.ext = ".fdt"
                     self.optchar = "P"
                     self.fpFile = None
                     self.fp = None
                     self.BlockCounter = 0
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.fileSelector = 0
                     self.Off2StartNxtRec = 0
                     self.RecCounter = 0
                     self.flagNoMoreFiles = 0
                     self.data_spc = None
                     self.data_cspc = None
                     self.path = None
                     self.OffsetStartHeader = 0
                     self.Off2StartData = 0
                     self.ipp = 0
                     self.nFDTdataRecors = 0
                     self.blocksize = 0
                     self.dataOut = Spectra()
                     self.dataOut.flagNoData = False
                 def search_files(self):
                     '''
                     Function that indicates the number of .fdt files that exist in the folder to be read.
                     It also creates an organized list with the names of the files to read.
                     '''
                     files = glob.glob(os.path.join(self.path, '*{}'.format(self.ext)))
                     files = sorted(files)
                     for f in files:
                         filename = f.split('/')[-1]
                         if folder_in_range(filename.split('.')[1], self.startDate, self.endDate, '%Y%m%d'):
                             self.filenameList.append(f)
                 def run(self, **kwargs):
                     '''
                     This method will be the one that will initiate the data entry, will be called constantly.
                     You should first verify that your Setup () is set up and then continue to acquire
                     the data to be processed with getData ().
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
                 def setup(self,
                           path=None,
                           startDate=None,
                           endDate=None,
                           startTime=None,
                           endTime=None,
                           walk=True,
                           code=None,
                           online=False,
                           mode=None,
                           **kwargs):
                     self.isConfig = True
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.walk = walk
                     self.mode = int(mode)
                     self.search_files()
                     if self.filenameList:
                         self.readFile()
                 def getData(self):
                     '''
                     Before starting this function, you should check that there is still an unread file,
                     If there are still blocks to read or if the data block is empty.
                     You should call the file "read".
                     '''
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         raise schainpy.admin.SchainError('No more files')
                     self.readBlock()
                 def readFile(self):
                     '''
                     You must indicate if you are reading in Online or Offline mode and load the
                     The parameters for this file reading mode.
                     Then you must do 2 actions:
 . Get the BLTR FileHeader.
 . Start reading the first block.
                     '''
                     if self.fileSelector < len(self.filenameList):
                         log.success('Opening file: {}'.format(self.filenameList[self.fileSelector]), self.name)
                         self.fp = open(self.filenameList[self.fileSelector])
                         self.fheader = FileHeaderBLTR(self.fp)
                         self.rheader = RecordHeaderBLTR(self.fp)
                         self.nFDTdataRecors = self.fheader.nFDTdataRecors
                         self.fileSelector += 1
                         self.BlockCounter = 0
                         return 1
                     else:
                         self.flagNoMoreFiles = True
                         self.dataOut.flagNoData = True
                         return 0
                 def readBlock(self):
                     '''
                     It should be checked if the block has data, if it is not passed to the next file.
                     Then the following is done:
 . Read the RecordHeader
 . Fill the buffer with the current block number.
                     '''
                     if self.BlockCounter == self.nFDTdataRecors:
                         if not self.readFile():
                             return
                     if self.mode == 1:
-                        self.rheader.read(self.BlockCounter+1)
+                        self.rheader.read(self.BlockCounter + 1)
                     elif self.mode == 0:
                         self.rheader.read(self.BlockCounter)
                     self.RecCounter = self.rheader.RecCounter
                     self.OffsetStartHeader = self.rheader.OffsetStartHeader
                     self.Off2StartNxtRec = self.rheader.Off2StartNxtRec
                     self.Off2StartData = self.rheader.Off2StartData
                     self.nProfiles = self.rheader.nProfiles
                     self.nChannels = self.rheader.nChannels
                     self.nHeights = self.rheader.nHeights
                     self.frequency = self.rheader.TransmitFrec
                     self.DualModeIndex = self.rheader.DualModeIndex
                     self.pairsList = [(0, 1), (0, 2), (1, 2)]
                     self.dataOut.pairsList = self.pairsList
                     self.nRdPairs = len(self.dataOut.pairsList)
                     self.dataOut.nRdPairs = self.nRdPairs
                     self.dataOut.heightList = (self.rheader.StartRangeSamp + numpy.arange(self.nHeights) * self.rheader.SampResolution) / 1000.
                     self.dataOut.channelList = range(self.nChannels)
-                    self.dataOut.nProfiles=self.rheader.nProfiles
+                    self.dataOut.nProfiles = self.rheader.nProfiles
-                    self.dataOut.nIncohInt=self.rheader.nIncohInt
+                    self.dataOut.nIncohInt = self.rheader.nIncohInt
-                    self.dataOut.nCohInt=self.rheader.nCohInt
+                    self.dataOut.nCohInt = self.rheader.nCohInt
-                    self.dataOut.ippSeconds= 1/float(self.rheader.PRFhz)
+                    self.dataOut.ippSeconds = 1 / float(self.rheader.PRFhz)
-                    self.dataOut.PRF=self.rheader.PRFhz
+                    self.dataOut.PRF = self.rheader.PRFhz
-                    self.dataOut.nFFTPoints=self.rheader.nProfiles
+                    self.dataOut.nFFTPoints = self.rheader.nProfiles
-                    self.dataOut.utctime = self.rheader.nUtime + self.rheader.nMilisec/1000.
+                    self.dataOut.utctime = self.rheader.nUtime + self.rheader.nMilisec / 1000.
                     self.dataOut.timeZone = 0
                     self.dataOut.useLocalTime = False
                     self.dataOut.nmodes = 2
                     log.log('Reading block {} - {}'.format(self.BlockCounter, self.dataOut.datatime), self.name)
                     OffDATA = self.OffsetStartHeader + self.RecCounter * \
                         self.Off2StartNxtRec + self.Off2StartData
                     self.fp.seek(OffDATA, os.SEEK_SET)
-                    self.data_fft = numpy.fromfile(self.fp, [('complex','<c8')], self.nProfiles*self.nChannels*self.nHeights )
+                    self.data_fft = numpy.fromfile(self.fp, [('complex', '<c8')], self.nProfiles * self.nChannels * self.nHeights)
                     self.data_fft = self.data_fft.astype(numpy.dtype('complex'))
-                    self.data_block = numpy.reshape(self.data_fft,(self.nHeights, self.nChannels, self.nProfiles))
+                    self.data_block = numpy.reshape(self.data_fft, (self.nHeights, self.nChannels, self.nProfiles))
-                    self.data_block = numpy.transpose(self.data_block, (1,2,0))
+                    self.data_block = numpy.transpose(self.data_block, (1, 2, 0))
                     copy = self.data_block.copy()
                     spc = copy * numpy.conjugate(copy)
                     self.data_spc = numpy.absolute(spc)  # valor absoluto o magnitud
                     cspc = self.data_block.copy()
                     self.data_cspc = self.data_block.copy()
                     for i in range(self.nRdPairs):
                         chan_index0 = self.dataOut.pairsList[i][0]
                         chan_index1 = self.dataOut.pairsList[i][1]
                         self.data_cspc[i, :, :] = cspc[chan_index0, :, :] * numpy.conjugate(cspc[chan_index1, :, :])
                     '''Getting Eij and Nij'''
                     (AntennaX0, AntennaY0) = pol2cart(
                         self.rheader.AntennaCoord0, self.rheader.AntennaAngl0 * numpy.pi / 180)
                     (AntennaX1, AntennaY1) = pol2cart(
                         self.rheader.AntennaCoord1, self.rheader.AntennaAngl1 * numpy.pi / 180)
                     (AntennaX2, AntennaY2) = pol2cart(
                         self.rheader.AntennaCoord2, self.rheader.AntennaAngl2 * numpy.pi / 180)
                     E01 = AntennaX0 - AntennaX1
                     N01 = AntennaY0 - AntennaY1
                     E02 = AntennaX0 - AntennaX2
                     N02 = AntennaY0 - AntennaY2
                     E12 = AntennaX1 - AntennaX2
                     N12 = AntennaY1 - AntennaY2
                     self.ChanDist = numpy.array(
                         [[E01, N01], [E02, N02], [E12, N12]])
                     self.dataOut.ChanDist = self.ChanDist
                     self.BlockCounter += 2
                     self.dataOut.data_spc = self.data_spc
-                    self.dataOut.data_cspc =self.data_cspc
+                    self.dataOut.data_cspc = self.data_cspc

schainpy/model/io/jroIO_amisr.py +117 -117

             '''
             @author: Daniel Suarez
             '''
             import os
             import sys
             import glob
             import fnmatch
             import datetime
             import time
             import re
             import h5py
             import numpy
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jroamisr import AMISR
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             class RadacHeader():
                 def __init__(self, fp):
                     header = 'Raw11/Data/RadacHeader'
-                    self.beamCodeByPulse = fp.get(header+'/BeamCode')
+                    self.beamCodeByPulse = fp.get(header + '/BeamCode')
                     self.beamCode = fp.get('Raw11/Data/Beamcodes')
-                    self.code = fp.get(header+'/Code')
+                    self.code = fp.get(header + '/Code')
-                    self.frameCount = fp.get(header+'/FrameCount')
+                    self.frameCount = fp.get(header + '/FrameCount')
-                    self.modeGroup = fp.get(header+'/ModeGroup')
+                    self.modeGroup = fp.get(header + '/ModeGroup')
-                    self.nsamplesPulse = fp.get(header+'/NSamplesPulse')
+                    self.nsamplesPulse = fp.get(header + '/NSamplesPulse')
-                    self.pulseCount = fp.get(header+'/PulseCount')
+                    self.pulseCount = fp.get(header + '/PulseCount')
-                    self.radacTime = fp.get(header+'/RadacTime')
+                    self.radacTime = fp.get(header + '/RadacTime')
-                    self.timeCount = fp.get(header+'/TimeCount')
+                    self.timeCount = fp.get(header + '/TimeCount')
-                    self.timeStatus = fp.get(header+'/TimeStatus')
+                    self.timeStatus = fp.get(header + '/TimeStatus')
-                    self.nrecords = self.pulseCount.shape[0] #nblocks
+                    self.nrecords = self.pulseCount.shape[0]  # nblocks
-                    self.npulses = self.pulseCount.shape[1] #nprofile
+                    self.npulses = self.pulseCount.shape[1]  # nprofile
-                    self.nsamples = self.nsamplesPulse[0,0] #ngates
+                    self.nsamples = self.nsamplesPulse[0, 0]  # ngates
                     self.nbeams = self.beamCode.shape[1]
                 def getIndexRangeToPulse(self, idrecord=0):
-                    #indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
+                    # indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
-                    #startPulseCountId = indexToZero[0][0]
+                    # startPulseCountId = indexToZero[0][0]
-                    #endPulseCountId = startPulseCountId - 1
+                    # endPulseCountId = startPulseCountId - 1
-                    #range1 = numpy.arange(startPulseCountId,self.npulses,1)
+                    # range1 = numpy.arange(startPulseCountId,self.npulses,1)
-                    #range2 = numpy.arange(0,startPulseCountId,1)
+                    # range2 = numpy.arange(0,startPulseCountId,1)
-                    #return range1, range2
+                    # return range1, range2
                     zero = 0
-                    npulse = max(self.pulseCount[0,:]+1)-1
+                    npulse = max(self.pulseCount[0, :] + 1) - 1
-                    looking_index = numpy.where(self.pulseCount.value[idrecord,:]==npulse)[0]
+                    looking_index = numpy.where(self.pulseCount.value[idrecord, :] == npulse)[0]
                     getLastIndex = looking_index[-1]
-                    index_data = numpy.arange(0,getLastIndex+1,1)
+                    index_data = numpy.arange(0, getLastIndex + 1, 1)
-                    index_buffer = numpy.arange(getLastIndex+1,self.npulses,1)
+                    index_buffer = numpy.arange(getLastIndex + 1, self.npulses, 1)
                     return index_data, index_buffer
             class AMISRReader(ProcessingUnit):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 walk = None
                 isConfig = False
                 def __init__(self):
                     self.set = None
                     self.subset = None
                     self.extension_file = '.h5'
                     self.dtc_str = 'dtc'
                     self.dtc_id = 0
                     self.status = True
                     self.isConfig = False
                     self.dirnameList = []
                     self.filenameList = []
                     self.fileIndex = None
                     self.flagNoMoreFiles = False
                     self.flagIsNewFile = 0
                     self.filename = ''
                     self.amisrFilePointer = None
                     self.radacHeaderObj = None
                     self.dataOut = self.__createObjByDefault()
                     self.datablock = None
                     self.rest_datablock = None
                     self.range = None
                     self.idrecord_count = 0
                     self.profileIndex = 0
                     self.index_amisr_sample = None
                     self.index_amisr_buffer = None
                     self.beamCodeByFrame = None
                     self.radacTimeByFrame = None
-                    #atributos originales tal y como esta en el archivo de datos
+                    # atributos originales tal y como esta en el archivo de datos
                     self.beamCodesFromFile = None
                     self.radacTimeFromFile = None
                     self.rangeFromFile = None
                     self.dataByFrame = None
                     self.dataset = None
                     self.beamCodeDict = {}
                     self.beamRangeDict = {}
-                    #experiment cgf file
+                    # experiment cgf file
                     self.npulsesint_fromfile = None
                     self.recordsperfile_fromfile = None
                     self.nbeamcodes_fromfile = None
                     self.ngates_fromfile = None
                     self.ippSeconds_fromfile = None
                     self.frequency_h5file = None
                     self.__firstFile = True
                     self.buffer_radactime = None
                     self.index4_schain_datablock = None
                     self.index4_buffer = None
                     self.schain_datablock = None
                     self.buffer = None
                     self.linear_pulseCount = None
                     self.npulseByFrame = None
                     self.profileIndex_offset = None
                     self.timezone = 'ut'
                     self.__waitForNewFile = 20
                     self.__filename_online = None
                 def __createObjByDefault(self):
                     dataObj = AMISR()
                     return dataObj
-                def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
+                def __setParameters(self, path='', startDate='', endDate='', startTime='', endTime='', walk=''):
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.walk = walk
                 def __checkPath(self):
                     if os.path.exists(self.path):
                         self.status = 1
                     else:
                         self.status = 0
-                        print('Path:%s does not exists'%self.path)
+                        print('Path:%s does not exists' % self.path)
                     return
                 def __selDates(self, amisr_dirname_format):
                     try:
                         year = int(amisr_dirname_format[0:4])
                         month = int(amisr_dirname_format[4:6])
                         dom = int(amisr_dirname_format[6:8])
-                        thisDate = datetime.date(year,month,dom)
+                        thisDate = datetime.date(year, month, dom)
-                        if (thisDate>=self.startDate and thisDate <= self.endDate):
+                        if (thisDate >= self.startDate and thisDate <= self.endDate):
                             return amisr_dirname_format
                     except:
                         return None
-                def __findDataForDates(self,online=False):
+                def __findDataForDates(self, online=False):
                     if not(self.status):
                         return None
                     pat = '\d+.\d+'
-                    dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
+                    dirnameList = [re.search(pat, x) for x in os.listdir(self.path)]
-                    dirnameList = [x for x in dirnameList if x!=None]
+                    dirnameList = [x for x in dirnameList if x != None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = [x for x in dirnameList if x!=None]
+                        dirnameList = [x for x in dirnameList if x != None]
-                    if len(dirnameList)>0:
+                    if len(dirnameList) > 0:
                         self.status = 1
                         self.dirnameList = dirnameList
                         self.dirnameList.sort()
                     else:
                         self.status = 0
                         return None
                 def __getTimeFromData(self):
-                    startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
+                    startDateTime_Reader = datetime.datetime.combine(self.startDate, self.startTime)
-                    endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
+                    endDateTime_Reader = datetime.datetime.combine(self.endDate, self.endTime)
-                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
+                    print('Filtering Files from %s to %s' % (startDateTime_Reader, endDateTime_Reader))
                     print('........................................')
                     filter_filenameList = []
                     self.filenameList.sort()
-                    for i in range(len(self.filenameList)-1):
+                    for i in range(len(self.filenameList) - 1):
                         filename = self.filenameList[i]
-                        fp = h5py.File(filename,'r')
+                        fp = h5py.File(filename, 'r')
                         time_str = fp.get('Time/RadacTimeString')
                         startDateTimeStr_File = time_str[0][0].split('.')[0]
                         junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                        startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                        startDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                         endDateTimeStr_File = time_str[-1][-1].split('.')[0]
                         junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                        endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                        endDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                         fp.close()
                         if self.timezone == 'lt':
-                            startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
+                            startDateTime_File = startDateTime_File - datetime.timedelta(minutes=300)
-                            endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300)
+                            endDateTime_File = endDateTime_File - datetime.timedelta(minutes=300)
-                        if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader):
+                        if (endDateTime_File >= startDateTime_Reader and endDateTime_File < endDateTime_Reader):
-                            #self.filenameList.remove(filename)
+                            # self.filenameList.remove(filename)
                             filter_filenameList.append(filename)
                     filter_filenameList.sort()
                     self.filenameList = filter_filenameList
                     return 1
                 def __filterByGlob1(self, dirName):
-                    filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
+                    filter_files = glob.glob1(dirName, '*.*%s' % self.extension_file)
                     filterDict = {}
                     filterDict.setdefault(dirName)
                     filterDict[dirName] = filter_files
                     return filterDict
                 def __getFilenameList(self, fileListInKeys, dirList):
                     for value in fileListInKeys:
                         dirName = list(value.keys())[0]
                         for file in value[dirName]:
                             filename = os.path.join(dirName, file)
                             self.filenameList.append(filename)
                 def __selectDataForTimes(self, online=False):
-                    #aun no esta implementado el filtro for tiempo
+                    # aun no esta implementado el filtro for tiempo
                     if not(self.status):
                         return None
-                    dirList = [os.path.join(self.path,x) for x in self.dirnameList]
+                    dirList = [os.path.join(self.path, x) for x in self.dirnameList]
                     fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
                     self.__getFilenameList(fileListInKeys, dirList)
                     if not(online):
-                        #filtro por tiempo
+                        # filtro por tiempo
                         if not(self.all):
                             self.__getTimeFromData()
-                        if len(self.filenameList)>0:
+                        if len(self.filenameList) > 0:
                             self.status = 1
                             self.filenameList.sort()
                         else:
                             self.status = 0
                             return None
                     else:
-                        #get the last file - 1
+                        # get the last file - 1
                         self.filenameList = [self.filenameList[-2]]
                     new_dirnameList = []
                     for dirname in self.dirnameList:
                         junk = numpy.array([dirname in x for x in self.filenameList])
                         junk_sum = junk.sum()
                         if junk_sum > 0:
                             new_dirnameList.append(dirname)
                     self.dirnameList = new_dirnameList
                     return 1
                 def searchFilesOnLine(self,
                                         path,
                                         walk=True):
                     startDate = datetime.datetime.utcnow().date()
                     endDate = datetime.datetime.utcnow().date()
                     self.__setParameters(path=path, startDate=startDate, endDate=endDate, walk=walk)
                     self.__checkPath()
                     self.__findDataForDates(online=True)
                     self.dirnameList = [self.dirnameList[-1]]
                     self.__selectDataForTimes(online=True)
                     return
                 def searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
-                                        startTime=datetime.time(0,0,0),
+                                        startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),
+                                        endTime=datetime.time(23, 59, 59),
                                         walk=True):
                     self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
                     self.__checkPath()
                     self.__findDataForDates()
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print("%s" %(self.filenameList[i]))
+                        print("%s" % (self.filenameList[i]))
                     return
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
-                        amisrFilePointer = h5py.File(filename,'r')
+                        amisrFilePointer = h5py.File(filename, 'r')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.amisrFilePointer = amisrFilePointer
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __setNextFileOnline(self):
                     filename = self.filenameList[0]
                     if self.__filename_online != None:
                         self.__selectDataForTimes(online=True)
                         filename = self.filenameList[0]
                         while self.__filename_online == filename:
-                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
+                            print('waiting %d seconds to get a new file...' % (self.__waitForNewFile))
                             sleep(self.__waitForNewFile)
                             self.__selectDataForTimes(online=True)
                             filename = self.filenameList[0]
                     self.__filename_online = filename
-                    self.amisrFilePointer = h5py.File(filename,'r')
+                    self.amisrFilePointer = h5py.File(filename, 'r')
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __readHeader(self):
                     self.radacHeaderObj = RadacHeader(self.amisrFilePointer)
-                    #update values from experiment cfg file
+                    # update values from experiment cfg file
                     if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile:
                         self.radacHeaderObj.nrecords = self.recordsperfile_fromfile
                     self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile
                     self.radacHeaderObj.npulses = self.npulsesint_fromfile
                     self.radacHeaderObj.nsamples = self.ngates_fromfile
-                    #looking index list for data
+                    # looking index list for data
-                    start_index = self.radacHeaderObj.pulseCount[0,:][0]
+                    start_index = self.radacHeaderObj.pulseCount[0, :][0]
                     end_index = self.radacHeaderObj.npulses
                     range4data = list(range(start_index, end_index))
                     self.index4_schain_datablock = numpy.array(range4data)
                     buffer_start_index = 0
-                    buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0]
+                    buffer_end_index = self.radacHeaderObj.pulseCount[0, :][0]
                     range4buffer = list(range(buffer_start_index, buffer_end_index))
                     self.index4_buffer = numpy.array(range4buffer)
                     self.linear_pulseCount = numpy.array(range4data + range4buffer)
-                    self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0,:]+1)
+                    self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0, :] + 1)
-                    #get tuning frequency
+                    # get tuning frequency
-                    frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')
+                    frequency_h5file_dataset = self.amisrFilePointer.get('Rx' + '/TuningFrequency')
-                    self.frequency_h5file = frequency_h5file_dataset[0,0]
+                    self.frequency_h5file = frequency_h5file_dataset[0, 0]
                     self.flagIsNewFile = 1
                 def __getBeamCode(self):
                     self.beamCodeDict = {}
                     self.beamRangeDict = {}
                     beamCodeMap = self.amisrFilePointer.get('Setup/BeamcodeMap')
-                    for i in range(len(self.radacHeaderObj.beamCode[0,:])):
+                    for i in range(len(self.radacHeaderObj.beamCode[0, :])):
                         self.beamCodeDict.setdefault(i)
                         self.beamRangeDict.setdefault(i)
-                        beamcodeValue = self.radacHeaderObj.beamCode[0,i]
+                        beamcodeValue = self.radacHeaderObj.beamCode[0, i]
-                        beamcodeIndex = numpy.where(beamCodeMap[:,0] == beamcodeValue)[0][0]
+                        beamcodeIndex = numpy.where(beamCodeMap[:, 0] == beamcodeValue)[0][0]
                         x = beamCodeMap[beamcodeIndex][1]
                         y = beamCodeMap[beamcodeIndex][2]
                         z = beamCodeMap[beamcodeIndex][3]
                         self.beamCodeDict[i] = [beamcodeValue, x, y, z]
-                    just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]
+                    just4record0 = self.radacHeaderObj.beamCodeByPulse[0, :]
                     for i in range(len(list(self.beamCodeDict.values()))):
-                        xx = numpy.where(just4record0==list(self.beamCodeDict.values())[i][0])
+                        xx = numpy.where(just4record0 == list(self.beamCodeDict.values())[i][0])
                         indexPulseByBeam = self.linear_pulseCount[xx[0]]
                         self.beamRangeDict[i] = indexPulseByBeam
                 def __getExpParameters(self):
                     if not(self.status):
                         return None
                     experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')
-                    expFinder = glob.glob1(experimentCfgPath,'*.exp')
+                    expFinder = glob.glob1(experimentCfgPath, '*.exp')
-                    if len(expFinder)== 0:
+                    if len(expFinder) == 0:
                         self.status = 0
                         return None
-                    experimentFilename = os.path.join(experimentCfgPath,expFinder[0])
+                    experimentFilename = os.path.join(experimentCfgPath, expFinder[0])
                     f = open(experimentFilename)
                     lines = f.readlines()
                     f.close()
-                    parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']
+                    parmsList = ['npulsesint*', 'recordsperfile*', 'nbeamcodes*', 'ngates*']
                     filterList = [fnmatch.filter(lines, x) for x in parmsList]
-                    values = [re.sub(r'\D',"",x[0]) for x in filterList]
+                    values = [re.sub(r'\D', "", x[0]) for x in filterList]
                     self.npulsesint_fromfile = int(values[0])
                     self.recordsperfile_fromfile = int(values[1])
                     self.nbeamcodes_fromfile = int(values[2])
                     self.ngates_fromfile = int(values[3])
                     tufileFinder = fnmatch.filter(lines, 'tufile=*')
                     tufile = tufileFinder[0].split('=')[1].split('\n')[0]
                     tufile = tufile.split('\r')[0]
-                    tufilename = os.path.join(experimentCfgPath,tufile)
+                    tufilename = os.path.join(experimentCfgPath, tufile)
                     f = open(tufilename)
                     lines = f.readlines()
                     f.close()
-                    self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6
+                    self.ippSeconds_fromfile = float(lines[1].split()[2]) / 1E6
                     self.status = 1
                 def __setIdsAndArrays(self):
                     self.dataByFrame = self.__setDataByFrame()
                     self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :]
                     self.readRanges()
                     self.index_amisr_sample, self.index_amisr_buffer = self.radacHeaderObj.getIndexRangeToPulse(0)
                     self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses)
                     if len(self.index_amisr_buffer) > 0:
                         self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame)
-                def __setNextFile(self,online=False):
+                def __setNextFile(self, online=False):
                     if not(online):
                         newFile = self.__setNextFileOffline()
                     else:
                         newFile = self.__setNextFileOnline()
                     if not(newFile):
                         return 0
                     self.__readHeader()
                     if self.__firstFile:
                         self.__setIdsAndArrays()
                         self.__firstFile = False
                     self.__getBeamCode()
                     self.readDataBlock()
-                def setup(self,path=None,
+                def setup(self, path=None,
                                 startDate=None,
                                 endDate=None,
-                                startTime=datetime.time(0,0,0),
+                                startTime=datetime.time(0, 0, 0),
-                                endTime=datetime.time(23,59,59),
+                                endTime=datetime.time(23, 59, 59),
                                 walk=True,
                                 timezone='ut',
                                 all=0,
                                 online=False):
                     self.timezone = timezone
                     self.all = all
                     self.online = online
                     if not(online):
-                        #Busqueda de archivos offline
+                        # Busqueda de archivos offline
                         self.searchFilesOffLine(path, startDate, endDate, startTime, endTime, walk)
                     else:
                         self.searchFilesOnLine(path, walk)
                     if not(self.filenameList):
-                        print("There is no files into the folder: %s"%(path))
+                        print("There is no files into the folder: %s" % (path))
                         sys.exit(-1)
                     self.__getExpParameters()
                     self.fileIndex = -1
                     self.__setNextFile(online)
             #         first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0]
             #         index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0]
-                    self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][0]
+                    self.profileIndex_offset = self.radacHeaderObj.pulseCount[0, :][0]
                     self.profileIndex = self.profileIndex_offset
                 def readRanges(self):
                     dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')
-                    self.rangeFromFile = numpy.reshape(dataset.value,(-1))
+                    self.rangeFromFile = numpy.reshape(dataset.value, (-1))
                     return self.rangeFromFile
-                def readRadacTime(self,idrecord, range1, range2):
+                def readRadacTime(self, idrecord, range1, range2):
                     self.radacTimeFromFile = self.radacHeaderObj.radacTime.value
                     radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
-                    #radacTimeByFrame = dataset[idrecord - 1,range1]
+                    # radacTimeByFrame = dataset[idrecord - 1,range1]
-                    #radacTimeByFrame = dataset[idrecord,range2]
+                    # radacTimeByFrame = dataset[idrecord,range2]
                     return radacTimeByFrame
                 def readBeamCode(self, idrecord, range1, range2):
                     dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode')
                     beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
                     self.beamCodesFromFile = dataset.value
-                    #beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
+                    # beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
-                    #beamcodeByFrame[range2] = dataset[idrecord, range2]
+                    # beamcodeByFrame[range2] = dataset[idrecord, range2]
                     beamcodeByFrame[range1] = dataset[idrecord, range1]
                     beamcodeByFrame[range2] = dataset[idrecord, range2]
                     return beamcodeByFrame
                 def __setDataByFrame(self):
-                    ndata = 2 # porque es complejo
+                    ndata = 2  # porque es complejo
                     dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))
                     return dataByFrame
                 def __readDataSet(self):
                     dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
                     return dataset
                 def __setDataBlock(self,):
-                    real = self.dataByFrame[:,:,0] #asumo que 0 es real
+                    real = self.dataByFrame[:, :, 0]  # asumo que 0 es real
-                    imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario
+                    imag = self.dataByFrame[:, :, 1]  # asumo que 1 es imaginario
-                    datablock = real + imag*1j #armo el complejo
+                    datablock = real + imag * 1j  # armo el complejo
                     return datablock
-                def readSamples_version1(self,idrecord):
+                def readSamples_version1(self, idrecord):
-                    #estas tres primeras lineas solo se deben ejecutar una vez
+                    # estas tres primeras lineas solo se deben ejecutar una vez
                     if self.flagIsNewFile:
-                        #reading dataset
+                        # reading dataset
                         self.dataset = self.__readDataSet()
                         self.flagIsNewFile = 0
                     if idrecord == 0:
-                        self.dataByFrame[self.index4_schain_datablock, : ,:] = self.dataset[0, self.index_amisr_sample,:,:]
+                        self.dataByFrame[self.index4_schain_datablock, : , :] = self.dataset[0, self.index_amisr_sample, :, :]
                         self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[0, self.index_amisr_sample]
                         datablock = self.__setDataBlock()
                         if len(self.index_amisr_buffer) > 0:
-                            self.buffer = self.dataset[0, self.index_amisr_buffer,:,:]
+                            self.buffer = self.dataset[0, self.index_amisr_buffer, :, :]
                             self.buffer_radactime = self.radacHeaderObj.radacTime[0, self.index_amisr_buffer]
                         return datablock
                     if len(self.index_amisr_buffer) > 0:
-                        self.dataByFrame[self.index4_buffer,:,:] = self.buffer.copy()
+                        self.dataByFrame[self.index4_buffer, :, :] = self.buffer.copy()
                         self.radacTimeByFrame[self.index4_buffer] = self.buffer_radactime.copy()
-                    self.dataByFrame[self.index4_schain_datablock,:,:] = self.dataset[idrecord, self.index_amisr_sample,:,:]
+                    self.dataByFrame[self.index4_schain_datablock, :, :] = self.dataset[idrecord, self.index_amisr_sample, :, :]
                     self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_sample]
                     datablock = self.__setDataBlock()
                     if len(self.index_amisr_buffer) > 0:
                         self.buffer = self.dataset[idrecord, self.index_amisr_buffer, :, :]
                         self.buffer_radactime = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_buffer]
                     return datablock
-                def readSamples(self,idrecord):
+                def readSamples(self, idrecord):
                     if self.flagIsNewFile:
                         self.dataByFrame = self.__setDataByFrame()
                         self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]
-                        #reading ranges
+                        # reading ranges
                         self.readRanges()
-                        #reading dataset
+                        # reading dataset
                         self.dataset = self.__readDataSet()
                     self.flagIsNewFile = 0
                     self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :]
                     self.dataByFrame = self.dataset[idrecord, :, :, :]
                     datablock = self.__setDataBlock()
                     return datablock
                 def readDataBlock(self):
                     self.datablock = self.readSamples_version1(self.idrecord_count)
-                    #self.datablock = self.readSamples(self.idrecord_count)
+                    # self.datablock = self.readSamples(self.idrecord_count)
-                    #print 'record:', self.idrecord_count
+                    # print 'record:', self.idrecord_count
                     self.idrecord_count += 1
                     self.profileIndex = 0
                     if self.idrecord_count >= self.radacHeaderObj.nrecords:
                         self.idrecord_count = 0
                         self.flagIsNewFile = 1
                 def readNextBlock(self):
                     self.readDataBlock()
                     if self.flagIsNewFile:
                         self.__setNextFile(self.online)
                     pass
                 def __hasNotDataInBuffer(self):
-                    #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
+                    # self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
                     if self.profileIndex >= self.radacHeaderObj.npulses:
                         return 1
                     return 0
                 def printUTC(self):
                     print(self.dataOut.utctime)
                     print('')
                 def setObjProperties(self):
-                    self.dataOut.heightList = self.rangeFromFile/1000.0 #km
+                    self.dataOut.heightList = self.rangeFromFile / 1000.0  # km
                     self.dataOut.nProfiles = self.radacHeaderObj.npulses
                     self.dataOut.nRecords = self.radacHeaderObj.nrecords
                     self.dataOut.nBeams = self.radacHeaderObj.nbeams
                     self.dataOut.ippSeconds = self.ippSeconds_fromfile
             #         self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency = self.frequency_h5file
                     self.dataOut.npulseByFrame = self.npulseByFrame
                     self.dataOut.nBaud = None
                     self.dataOut.nCode = None
                     self.dataOut.code = None
                     self.dataOut.beamCodeDict = self.beamCodeDict
                     self.dataOut.beamRangeDict = self.beamRangeDict
                     if self.timezone == 'lt':
-                        self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes
+                        self.dataOut.timeZone = time.timezone / 60.  # get the timezone in minutes
                     else:
-                        self.dataOut.timeZone = 0 #by default time is UTC
+                        self.dataOut.timeZone = 0  # by default time is UTC
                 def getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         return 0
                     if self.__hasNotDataInBuffer():
                         self.readNextBlock()
-                    if self.datablock is None: # setear esta condicion cuando no hayan datos por leers
+                    if self.datablock is None:  # setear esta condicion cuando no hayan datos por leers
                         self.dataOut.flagNoData = True
                         return 0
-                    self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))
+                    self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex, :], (1, -1))
                     self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]
                     self.dataOut.profileIndex = self.profileIndex
                     self.dataOut.flagNoData = False
                     self.profileIndex += 1
                     return self.dataOut.data
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.setObjProperties()
                         self.isConfig = True
-                    self.getData()
  No newline at end of file
+                    self.getData()

schainpy/model/io/jroIO_base.py +17 -17

             """
             Created on Jul 2, 2014
             @author: roj-idl71
             """
             import os
             import sys
             import glob
             import time
             import numpy
             import fnmatch
             import inspect
             import time
             import datetime
             import zmq
             from schainpy.model.proc.jroproc_base import Operation, MPDecorator
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
             from schainpy.utils import log
             import schainpy.admin
             LOCALTIME = True
             DT_DIRECTIVES = {
                 '%Y': 4,
                 '%y': 2,
                 '%m': 2,
                 '%d': 2,
                 '%j': 3,
                 '%H': 2,
                 '%M': 2,
                 '%S': 2,
                 '%f': 6
             }
             def isNumber(cad):
                 """
                 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(cad)
                     return True
                 except:
                     return False
             def isFileInEpoch(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                     print("The file %s can't be opened" % (filename))
                     return 0
                 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 <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
             def isTimeInRange(thisTime, startTime, endTime):
                 if endTime >= startTime:
                     if (thisTime < startTime) or (thisTime > endTime):
                         return 0
                     return 1
                 else:
                     if (thisTime < startTime) and (thisTime > endTime):
                         return 0
                     return 1
             def isFileInTimeRange(filename, startDate, endDate, startTime, endTime):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                     startTime          :    tiempo inicial del rango seleccionado en formato datetime.time
                     endTime            :    tiempo final del rango seleccionado en formato datetime.time
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                     print("The file %s can't be opened" % (filename))
                     return None
                 firstBasicHeaderObj = BasicHeader(LOCALTIME)
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 lastBasicHeaderObj = BasicHeader(LOCALTIME)
                 sts = firstBasicHeaderObj.read(fp)
                 if not(sts):
                     print("[Reading] Skipping the file %s because it has not a valid header" % (filename))
                     return None
                 if not systemHeaderObj.read(fp):
                     return None
                 if not radarControllerHeaderObj.read(fp):
                     return None
                 if not processingHeaderObj.read(fp):
                     return None
                 filesize = os.path.getsize(filename)
                 offset = processingHeaderObj.blockSize + 24  # header size
                 if filesize <= offset:
                     print("[Reading] %s: This file has not enough data" % filename)
                     return None
                 fp.seek(-offset, 2)
                 sts = lastBasicHeaderObj.read(fp)
                 fp.close()
                 thisDatetime = lastBasicHeaderObj.datatime
                 thisTime_last_block = thisDatetime.time()
                 thisDatetime = firstBasicHeaderObj.datatime
                 thisDate = thisDatetime.date()
                 thisTime_first_block = thisDatetime.time()
                 # General case
                 #           o>>>>>>>>>>>>>><<<<<<<<<<<<<<o
                 #-----------o----------------------------o-----------
                 #       startTime                     endTime
                 if endTime >= startTime:
                     if (thisTime_last_block < startTime) or (thisTime_first_block > endTime):
                         return None
                     return thisDatetime
                 # If endTime < startTime then endTime belongs to the next day
-                #<<<<<<<<<<<o                            o>>>>>>>>>>>
+                # <<<<<<<<<<<o                            o>>>>>>>>>>>
                 #-----------o----------------------------o-----------
                 #        endTime                    startTime
                 if (thisDate == startDate) and (thisTime_last_block < startTime):
                     return None
                 if (thisDate == endDate) and (thisTime_first_block > endTime):
                     return None
                 if (thisTime_last_block < startTime) and (thisTime_first_block > endTime):
                     return None
                 return thisDatetime
             def isFolderInDateRange(folder, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     folder            :    nombre completo del directorio.
                                            Su formato deberia ser "/path_root/?YYYYDDD"
                                             siendo:
                                                 YYYY    :    Anio         (ejemplo 2015)
                                                 DDD     :    Dia del anio (ejemplo 305)
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el directorio no tiene el formato adecuado
                 """
                 basename = os.path.basename(folder)
                 if not isRadarFolder(basename):
                     print("The folder %s has not the rigth format" % folder)
                     return 0
                 if startDate and endDate:
                     thisDate = getDateFromRadarFolder(basename)
                     if thisDate < startDate:
                         return 0
                     if thisDate > endDate:
                         return 0
                 return 1
             def isFileInDateRange(filename, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                                            Su formato deberia ser "?YYYYDDDsss"
                                             siendo:
                                                 YYYY    :    Anio         (ejemplo 2015)
                                                 DDD     :    Dia del anio (ejemplo 305)
                                                 sss     :    set
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no tiene el formato adecuado
                 """
                 basename = os.path.basename(filename)
                 if not isRadarFile(basename):
                     print("The filename %s has not the rigth format" % filename)
                     return 0
                 if startDate and endDate:
                     thisDate = getDateFromRadarFile(basename)
                     if thisDate < startDate:
                         return 0
                     if thisDate > endDate:
                         return 0
                 return 1
             def getFileFromSet(path, ext, set):
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     try:
                         year = int(thisFile[1:5])
                         doy = int(thisFile[5:8])
                     except:
                         continue
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 myfile = fnmatch.filter(
                     validFilelist, '*%4.4d%3.3d%3.3d*' % (year, doy, set))
                 if len(myfile) != 0:
                     return myfile[0]
                 else:
                     filename = '*%4.4d%3.3d%3.3d%s' % (year, doy, set, ext.lower())
                     print('the filename %s does not exist' % filename)
                     print('...going to the last file: ')
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     year = thisFile[1:5]
                     if not isNumber(year):
                         continue
                     doy = thisFile[5:8]
                     if not isNumber(doy):
                         continue
                     year = int(year)
                     doy = int(doy)
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def isRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                     doy = int(folder[5:8])
                 except:
                     return 0
                 return 1
             def isRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return 0
                 return 1
             def getDateFromRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return None
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             def getDateFromRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                     doy = int(folder[5:8])
                 except:
                     return None
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             def parse_format(s, fmt):
                 for i in range(fmt.count('%')):
                     x = fmt.index('%')
-                    d = DT_DIRECTIVES[fmt[x:x+2]]
+                    d = DT_DIRECTIVES[fmt[x:x + 2]]
-                    fmt = fmt.replace(fmt[x:x+2], s[x:x+d])
+                    fmt = fmt.replace(fmt[x:x + 2], s[x:x + d])
                 return fmt
             class Reader(object):
                 c = 3E8
                 isConfig = False
                 dtype = None
                 pathList = []
                 filenameList = []
                 datetimeList = []
                 filename = None
                 ext = None
                 flagIsNewFile = 1
                 flagDiscontinuousBlock = 0
                 flagIsNewBlock = 0
                 flagNoMoreFiles = 0
                 fp = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 versionFile = 1103
                 fileSize = None
                 fileSizeByHeader = None
                 fileIndex = -1
                 profileIndex = None
                 blockIndex = 0
                 nTotalBlocks = 0
                 maxTimeStep = 30
                 lastUTTime = None
                 datablock = None
                 dataOut = None
                 getByBlock = False
                 path = None
                 startDate = None
                 endDate = None
                 startTime = datetime.time(0, 0, 0)
                 endTime = datetime.time(23, 59, 59)
                 set = None
                 expLabel = ""
                 online = False
                 delay = 60
                 nTries = 3  # quantity tries
                 nFiles = 3  # number of files for searching
                 walk = True
                 getblock = False
                 nTxs = 1
                 realtime = False
                 blocksize = 0
                 blocktime = None
                 warnings = True
                 verbose = True
                 server = None
                 format = None
                 oneDDict = None
                 twoDDict = None
                 independentParam = None
                 filefmt = None
                 folderfmt = None
                 open_file = open
                 open_mode = 'rb'
                 def run(self):
                     raise NotImplementedError
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def set_kwargs(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def find_folders(self, path, startDate, endDate, folderfmt, last=False):
                     folders = [x for f in path.split(',')
                                for x in os.listdir(f) if os.path.isdir(os.path.join(f, x))]
                     folders.sort()
                     if last:
                         folders = [folders[-1]]
                     for folder in folders:
                         try:
                             dt = datetime.datetime.strptime(parse_format(folder, folderfmt), folderfmt).date()
                             if dt >= startDate and dt <= endDate:
                                 yield os.path.join(path, folder)
                             else:
                                 log.log('Skiping folder {}'.format(folder), self.name)
                         except Exception as e:
                             log.log('Skiping folder {}'.format(folder), self.name)
                             continue
                     return
                 def find_files(self, folders, ext, filefmt, startDate=None, endDate=None,
                                expLabel='', last=False):
                     for path in folders:
                         files = glob.glob1(path, '*{}'.format(ext))
                         files.sort()
                         if last:
                             if files:
                                 fo = files[-1]
                                 try:
                                     dt = datetime.datetime.strptime(parse_format(fo, filefmt), filefmt).date()
                                     yield os.path.join(path, expLabel, fo)
                                 except Exception as e:
                                     pass
                                 return
                             else:
                                 return
                         for fo in files:
                             try:
                                 dt = datetime.datetime.strptime(parse_format(fo, filefmt), filefmt).date()
                                 if dt >= startDate and dt <= endDate:
                                     yield os.path.join(path, expLabel, fo)
                                 else:
                                     log.log('Skiping file {}'.format(fo), self.name)
                             except Exception as e:
                                 log.log('Skiping file {}'.format(fo), self.name)
                                 continue
                 def searchFilesOffLine(self, path, startDate, endDate,
                                        expLabel, ext, walk,
                                        filefmt, folderfmt):
                     """Search files in offline mode for the given arguments
                     Return:
                         Generator of files
                     """
                     if walk:
                         folders = self.find_folders(
                             path, startDate, endDate, folderfmt)
                     else:
                         folders = path.split(',')
                     return self.find_files(
                         folders, ext, filefmt, startDate, endDate, expLabel)
                 def searchFilesOnLine(self, path, startDate, endDate,
                                       expLabel, ext, walk,
                                       filefmt, folderfmt):
                     """Search for the last file of the last folder
                     Arguments:
                         path        :    carpeta donde estan contenidos los files que contiene data
                         expLabel    :    Nombre del subexperimento (subfolder)
                         ext         :    extension de los files
                         walk        :    Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
                     Return:
                         generator with the full path of last filename
                     """
                     if walk:
                         folders = self.find_folders(
                             path, startDate, endDate, folderfmt, last=True)
                     else:
                         folders = path.split(',')
                     return self.find_files(
                         folders, ext, filefmt, startDate, endDate, expLabel, last=True)
                 def setNextFile(self):
                     """Set the next file to be readed open it and parse de file header"""
                     while True:
                         if self.fp != None:
                             self.fp.close()
                         if self.online:
                             newFile = self.setNextFileOnline()
                         else:
                             newFile = self.setNextFileOffline()
                         if not(newFile):
                             if self.online:
                                 raise schainpy.admin.SchainError('Time to wait for new files reach')
                             else:
                                 if self.fileIndex == -1:
                                     raise schainpy.admin.SchainWarning('No files found in the given path')
                                 else:
                                     raise schainpy.admin.SchainWarning('No more files to read')
                         if self.verifyFile(self.filename):
                             break
                     log.log('Opening file: %s' % self.filename, self.name)
                     self.readFirstHeader()
                     self.nReadBlocks = 0
                 def setNextFileOnline(self):
                     """Check for the next file to be readed in online mode.
                     Set:
                         self.filename
                         self.fp
                         self.filesize
                     Return:
                         boolean
                     """
                     nextFile = True
                     nextDay = False
-                    for nFiles in range(self.nFiles+1):
+                    for nFiles in range(self.nFiles + 1):
                         for nTries in range(self.nTries):
                             fullfilename, filename = self.checkForRealPath(nextFile, nextDay)
                             if fullfilename is not None:
                                 break
                             log.warning(
                                 "Waiting %0.2f sec for the next file: \"%s\" , try %02d ..." % (self.delay, filename, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                             nextFile = False
                             continue
                         if fullfilename is not None:
                             break
                         self.nTries = 1
                         nextFile = True
                         if nFiles == (self.nFiles - 1):
                             log.log('Trying with next day...', self.name)
                             nextDay = True
                             self.nTries = 3
                     if fullfilename:
                         self.fileSize = os.path.getsize(fullfilename)
                         self.filename = fullfilename
                         self.flagIsNewFile = 1
                         if self.fp != None:
                             self.fp.close()
                         self.fp = self.open_file(fullfilename, self.open_mode)
                         self.flagNoMoreFiles = 0
                         self.fileIndex += 1
                         return 1
                     else:
                         return 0
                 def setNextFileOffline(self):
                     """Open the next file to be readed in offline mode"""
                     try:
                         filename = next(self.filenameList)
-                        self.fileIndex +=1
+                        self.fileIndex += 1
                     except StopIteration:
                         self.flagNoMoreFiles = 1
                         return 0
                     self.filename = filename
                     self.fileSize = os.path.getsize(filename)
                     self.fp = self.open_file(filename, self.open_mode)
                     self.flagIsNewFile = 1
                     return 1
                 @staticmethod
                 def isDateTimeInRange(dt, startDate, endDate, startTime, endTime):
                     """Check if the given datetime is in range"""
                     if startDate <= dt.date() <= endDate:
                         if startTime <= dt.time() <= endTime:
                             return True
                     return False
                 def verifyFile(self, filename):
                     """Check for a valid file
                     Arguments:
                         filename -- full path filename
                     Return:
                         boolean
                     """
                     return True
                 def checkForRealPath(self, nextFile, nextDay):
                     """Check if the next file to be readed exists"""
                     raise NotImplementedError
                 def readFirstHeader(self):
                     """Parse the file header"""
                     pass
                 def waitDataBlock(self, pointer_location, blocksize=None):
                     """
                     """
                     currentPointer = pointer_location
                     if blocksize is None:
                         neededSize = self.processingHeaderObj.blockSize  # + self.basicHeaderSize
                     else:
                         neededSize = blocksize
                     for nTries in range(self.nTries):
                         self.fp.close()
                         self.fp = open(self.filename, 'rb')
                         self.fp.seek(currentPointer)
                         self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
                         if (currentSize >= neededSize):
                             return 1
                         log.warning(
                             "Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1),
                             self.name
                             )
                         time.sleep(self.delay)
                     return 0
             class JRODataReader(Reader):
                 utc = 0
                 nReadBlocks = 0
                 foldercounter = 0
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 __isFirstTimeOnline = 1
                 filefmt = "*%Y%j***"
                 folderfmt = "*%Y%j"
                 __attrs__ = ['path', 'startDate', 'endDate', 'startTime', 'endTime', 'online', 'delay', 'walk']
                 def getDtypeWidth(self):
                     dtype_index = get_dtype_index(self.dtype)
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def checkForRealPath(self, nextFile, nextDay):
                     """Check if the next file to be readed exists.
                     Example    :
                         nombre correcto del file es  .../.../D2009307/P2009307367.ext
                         Entonces la funcion prueba con las siguientes combinaciones
                             .../.../y2009307367.ext
                             .../.../Y2009307367.ext
                             .../.../x2009307/y2009307367.ext
                             .../.../x2009307/Y2009307367.ext
                             .../.../X2009307/y2009307367.ext
                             .../.../X2009307/Y2009307367.ext
                         siendo para este caso, la ultima combinacion de letras, identica al file buscado
                     Return:
                         str -- fullpath of the file
                     """
                     if nextFile:
                         self.set += 1
                     if nextDay:
                         self.set = 0
                         self.doy += 1
                     foldercounter = 0
                     prefixDirList = [None, 'd', 'D']
                     if self.ext.lower() == ".r":  # voltage
                         prefixFileList = ['d', 'D']
                     elif self.ext.lower() == ".pdata":  # spectra
                         prefixFileList = ['p', 'P']
                     # barrido por las combinaciones posibles
                     for prefixDir in prefixDirList:
                         thispath = self.path
                         if prefixDir != None:
                             # formo el nombre del directorio xYYYYDDD (x=d o x=D)
                             if foldercounter == 0:
                                 thispath = os.path.join(self.path, "%s%04d%03d" %
                                                         (prefixDir, self.year, self.doy))
                             else:
                                 thispath = os.path.join(self.path, "%s%04d%03d_%02d" % (
                                     prefixDir, self.year, self.doy, foldercounter))
                         for prefixFile in prefixFileList:  # barrido por las dos combinaciones posibles de "D"
                             # formo el nombre del file xYYYYDDDSSS.ext
                             filename = "%s%04d%03d%03d%s" % (prefixFile, self.year, self.doy, self.set, self.ext)
                             fullfilename = os.path.join(
                                 thispath, filename)
                             if os.path.exists(fullfilename):
                                 return fullfilename, filename
                     return None, filename
                 def __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                     Si el modo de lectura es OffLine siempre retorn 0
                     """
                     if not self.online:
                         return 0
                     if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     for nTries in range(self.nTries):
                         self.fp.close()
                         self.fp = open(self.filename, 'rb')
                         self.fp.seek(currentPointer)
                         self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
                         if (currentSize >= neededSize):
                             self.basicHeaderObj.read(self.fp)
                             return 1
                         if self.fileSize == self.fileSizeByHeader:
                             #                self.flagEoF = True
                             return 0
                         print("[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1))
                         time.sleep(self.delay)
                     return 0
                 def __setNewBlock(self):
                     if self.fp == None:
                         return 0
                     if self.flagIsNewFile:
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if self.realtime:
                         self.flagDiscontinuousBlock = 1
                         if not(self.setNextFile()):
                             return 0
                         else:
                             return 1
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.basicHeaderObj.read(self.fp)
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if self.__waitNewBlock():
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.basicHeaderObj.utc - self.lastUTTime
                     self.lastUTTime = self.basicHeaderObj.utc
                     self.flagDiscontinuousBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagDiscontinuousBlock = 1
                     return 1
                 def readNextBlock(self):
                     while True:
                         if not(self.__setNewBlock()):
                             continue
                         if not(self.readBlock()):
                             return 0
                         self.getBasicHeader()
                         if not self.isDateTimeInRange(self.dataOut.datatime, self.startDate, self.endDate, self.startTime, self.endTime):
                             print("[Reading] Block No. %d/%d -> %s [Skipping]" % (self.nReadBlocks,
                                                                                   self.processingHeaderObj.dataBlocksPerFile,
                                                                                   self.dataOut.datatime.ctime()))
                             continue
                         break
                     if self.verbose:
                         print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
                                                                    self.processingHeaderObj.dataBlocksPerFile,
                                                                    self.dataOut.datatime.ctime()))
                     return 1
                 def readFirstHeader(self):
                     self.basicHeaderObj.read(self.fp)
                     self.systemHeaderObj.read(self.fp)
                     self.radarControllerHeaderObj.read(self.fp)
                     self.processingHeaderObj.read(self.fp)
                     self.firstHeaderSize = self.basicHeaderObj.size
                     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:
                         datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
                         raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
-                    #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
+                    # 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.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
                     #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def verifyFile(self, filename):
                     flag = True
                     try:
                         fp = open(filename, 'rb')
                     except IOError:
                         log.error("File {} can't be opened".format(filename), self.name)
                         return False
                     if self.online and self.waitDataBlock(0):
                         pass
                     basicHeaderObj = BasicHeader(LOCALTIME)
                     systemHeaderObj = SystemHeader()
                     radarControllerHeaderObj = RadarControllerHeader()
                     processingHeaderObj = ProcessingHeader()
                     if not(basicHeaderObj.read(fp)):
                         flag = False
                     if not(systemHeaderObj.read(fp)):
                         flag = False
                     if not(radarControllerHeaderObj.read(fp)):
                         flag = False
                     if not(processingHeaderObj.read(fp)):
                         flag = False
                     if not self.online:
                         dt1 = basicHeaderObj.datatime
-                        pos = self.fileSize-processingHeaderObj.blockSize-24
+                        pos = self.fileSize - processingHeaderObj.blockSize - 24
-                        if pos<0:
+                        if pos < 0:
                             flag = False
                             log.error('Invalid size for file: {}'.format(self.filename), self.name)
                         else:
                             fp.seek(pos)
                             if not(basicHeaderObj.read(fp)):
                                 flag = False
                         dt2 = basicHeaderObj.datatime
                         if not self.isDateTimeInRange(dt1, self.startDate, self.endDate, self.startTime, self.endTime) and not \
                                 self.isDateTimeInRange(dt2, self.startDate, self.endDate, self.startTime, self.endTime):
                             flag = False
                     fp.close()
                     return flag
                 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False):
                     path_empty = True
                     dateList = []
                     pathList = []
                     multi_path = path.split(',')
                     if not walk:
                         for single_path in multi_path:
                             if not os.path.isdir(single_path):
                                 continue
                             fileList = glob.glob1(single_path, "*" + ext)
                             if not fileList:
                                 continue
                             path_empty = False
                             fileList.sort()
                             for thisFile in fileList:
                                 if not os.path.isfile(os.path.join(single_path, thisFile)):
                                     continue
                                 if not isRadarFile(thisFile):
                                     continue
                                 if not isFileInDateRange(thisFile, startDate, endDate):
                                     continue
                                 thisDate = getDateFromRadarFile(thisFile)
                                 if thisDate in dateList or single_path in pathList:
                                     continue
                                 dateList.append(thisDate)
                                 pathList.append(single_path)
                     else:
                         for single_path in multi_path:
                             if not os.path.isdir(single_path):
                                 continue
                             dirList = []
                             for thisPath in os.listdir(single_path):
                                 if not os.path.isdir(os.path.join(single_path, thisPath)):
                                     continue
                                 if not isRadarFolder(thisPath):
                                     continue
                                 if not isFolderInDateRange(thisPath, startDate, endDate):
                                     continue
                                 dirList.append(thisPath)
                             if not dirList:
                                 continue
                             dirList.sort()
                             for thisDir in dirList:
                                 datapath = os.path.join(single_path, thisDir, expLabel)
                                 fileList = glob.glob1(datapath, "*" + ext)
                                 if not fileList:
                                     continue
                                 path_empty = False
                                 thisDate = getDateFromRadarFolder(thisDir)
                                 pathList.append(datapath)
                                 dateList.append(thisDate)
                     dateList.sort()
                     if walk:
                         pattern_path = os.path.join(multi_path[0], "[dYYYYDDD]", expLabel)
                     else:
                         pattern_path = multi_path[0]
                     if path_empty:
                         raise schainpy.admin.SchainError("[Reading] No *%s files in %s for %s to %s" % (ext, pattern_path, startDate, endDate))
                     else:
                         if not dateList:
                             raise schainpy.admin.SchainError("[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" % (startDate, endDate, ext, path))
                     if include_path:
                         return dateList, pathList
                     return dateList
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.server is not None:
                         if 'tcp://' in self.server:
                             address = server
                         else:
                             address = 'ipc:///tmp/%s' % self.server
                         self.server = address
                         self.context = zmq.Context()
                         self.receiver = self.context.socket(zmq.PULL)
                         self.receiver.connect(self.server)
                         time.sleep(0.5)
                         print('[Starting] ReceiverData from {}'.format(self.server))
                     else:
                         self.server = None
                         if self.path == None:
                             raise ValueError("[Reading] The path is not valid")
                         if self.online:
                             log.log("[Reading] Searching files in online mode...", self.name)
                             for nTries in range(self.nTries):
                                 fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                     self.endDate, self.expLabel, self.ext, self.walk,
                                     self.filefmt, self.folderfmt)
                                 try:
                                     fullpath = next(fullpath)
                                 except:
                                     fullpath = None
                                 if fullpath:
                                     break
                                 log.warning(
                                     'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                         self.delay, self.path, nTries + 1),
                                     self.name)
                                 time.sleep(self.delay)
                             if not(fullpath):
                                 raise schainpy.admin.SchainError(
                                     'There isn\'t any valid file in {}'.format(self.path))
                             pathname, filename = os.path.split(fullpath)
                             self.year = int(filename[1:5])
                             self.doy = int(filename[5:8])
                             self.set = int(filename[8:11]) - 1
                         else:
                             log.log("Searching files in {}".format(self.path), self.name)
                             self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                         self.setNextFile()
                     return
                 def getBasicHeader(self):
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
 . + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                     self.dataOut.timeZone = self.basicHeaderObj.timeZone
                     self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
                     self.dataOut.errorCount = self.basicHeaderObj.errorCount
                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
                     self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                 def getFirstHeader(self):
                     raise NotImplementedError
                 def getData(self):
                     raise NotImplementedError
                 def hasNotDataInBuffer(self):
                     raise NotImplementedError
                 def readBlock(self):
                     raise NotImplementedError
                 def isEndProcess(self):
                     return self.flagNoMoreFiles
                 def printReadBlocks(self):
                     print("[Reading] Number of read blocks per file %04d" % self.nReadBlocks)
                 def printTotalBlocks(self):
                     print("[Reading] Number of read blocks %04d" % self.nTotalBlocks)
                 def run(self, **kwargs):
                     """
                     Arguments:
                         path        :
                         startDate   :
                         endDate     :
                         startTime   :
                         endTime     :
                         set         :
                         expLabel    :
                         ext         :
                         online      :
                         delay       :
                         walk        :
                         getblock    :
                         nTxs        :
                         realtime    :
                         blocksize   :
                         blocktime   :
                         skip        :
                         cursor      :
                         warnings    :
                         server      :
                         verbose     :
                         format      :
                         oneDDict    :
                         twoDDict    :
                         independentParam    :
                     """
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     if self.server is None:
                         self.getData()
                     else:
                         self.getFromServer()
             class JRODataWriter(Reader):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
                 nWriteBlocks = 0
                 fileDate = None
                 def __init__(self, dataOut=None):
                     raise NotImplementedError
                 def hasAllDataInBuffer(self):
                     raise NotImplementedError
                 def setBlockDimension(self):
                     raise NotImplementedError
                 def writeBlock(self):
                     raise NotImplementedError
                 def putData(self):
                     raise NotImplementedError
                 def getDtypeWidth(self):
                     dtype_index = get_dtype_index(self.dtype)
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def getProcessFlags(self):
                     processFlags = 0
                     dtype_index = get_dtype_index(self.dtype)
                     procflag_dtype = get_procflag_dtype(dtype_index)
                     processFlags += procflag_dtype
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code is not None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
                     if self.dataOut.type == "Spectra":
                         if self.dataOut.nIncohInt > 1:
                             processFlags += PROCFLAG.INCOHERENT_INTEGRATION
                         if self.dataOut.data_dc is not None:
                             processFlags += PROCFLAG.SAVE_CHANNELS_DC
                         if self.dataOut.flagShiftFFT:
                             processFlags += PROCFLAG.SHIFT_FFT_DATA
                     return processFlags
                 def setBasicHeader(self):
                     self.basicHeaderObj.size = self.basicHeaderSize  # bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
                     utc = numpy.floor(self.dataOut.utctime)
                     milisecond = (self.dataOut.utctime - utc) * 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = self.dataOut.timeZone
                     self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
                     self.basicHeaderObj.errorCount = self.dataOut.errorCount
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj self.
                     Return:
                         None
                     """
                     raise NotImplementedError
                 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 = self.systemHeaderObj.size + \
                         self.radarControllerHeaderObj.size + self.processingHeaderObj.size
                     self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
                     self.basicHeaderObj.write(self.fp)
                     self.systemHeaderObj.write(self.fp)
                     self.radarControllerHeaderObj.write(self.fp)
                     self.processingHeaderObj.write(self.fp)
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    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.basicHeaderObj.write(self.fp)
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not(self.__setNewBlock()):
                         return 0
                     self.writeBlock()
                     print("[Writing] Block No. %d/%d" % (self.blockIndex,
                                                          self.processingHeaderObj.dataBlocksPerFile))
                     return 1
                 def setNextFile(self):
                     """Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
                     if not os.path.exists(path):
                         os.mkdir(path)
                     timeTuple = time.localtime(self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year, timeTuple.tm_yday)
                     fullpath = os.path.join(path, subfolder)
                     setFile = self.setFile
                     if not(os.path.exists(fullpath)):
                         os.mkdir(fullpath)
                         setFile = -1  # inicializo mi contador de seteo
                     else:
                         filesList = os.listdir(fullpath)
                         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]):
                                 # inicializo mi contador de seteo al seteo del ultimo file
                                 setFile = int(filen[8:11])
                             else:
                                 setFile = -1
                         else:
                             setFile = -1  # inicializo mi contador de seteo
                     setFile += 1
                     # If this is a new day it resets some values
                     if self.dataOut.datatime.date() > self.fileDate:
                         setFile = 0
                         self.nTotalBlocks = 0
                     filen = '{}{:04d}{:03d}{:03d}{}'.format(
                             self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext)
                     filename = os.path.join(path, subfolder, filen)
                     fp = open(filename, 'wb')
                     self.blockIndex = 0
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     self.fileDate = self.dataOut.datatime.date()
                     self.setFirstHeader()
                     print('[Writing] Opening file: %s' % self.filename)
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path                :    directory where data will be saved
                         profilesPerBlock    :    number of profiles per block
                         set                 :    initial file set
                         datatype            :    An integer number that defines data type:
 : int8  (1 byte)
 : int16 (2 bytes)
 : int32 (4 bytes)
 : int64 (8 bytes)
 : float32 (4 bytes)
 : double64 (8 bytes)
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     self.ext = ext.lower()
                     self.path = path
                     if set is None:
                         self.setFile = -1
                     else:
                         self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock
                     self.dataOut = dataOut
                     self.fileDate = self.dataOut.datatime.date()
                     self.dtype = self.dataOut.dtype
                     if datatype is not None:
                         self.dtype = get_numpy_dtype(datatype)
                     if not(self.setNextFile()):
                         print("[Writing] There isn't a next file")
                         return 0
                     self.setBlockDimension()
                     return 1
                 def run(self, dataOut, path, blocksPerFile=100, profilesPerBlock=64, set=None, ext=None, datatype=4, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, path, blocksPerFile, profilesPerBlock=profilesPerBlock,
                                    set=set, ext=ext, datatype=datatype, **kwargs)
                         self.isConfig = True
                     self.dataOut = dataOut
                     self.putData()
                     return self.dataOut
             @MPDecorator
             class printInfo(Operation):
                 def __init__(self):
                     Operation.__init__(self)
                     self.__printInfo = True
-                def run(self, dataOut, headers = ['systemHeaderObj', 'radarControllerHeaderObj', 'processingHeaderObj']):
+                def run(self, dataOut, headers=['systemHeaderObj', 'radarControllerHeaderObj', 'processingHeaderObj']):
                     if self.__printInfo == False:
                         return
                     for header in headers:
                         if hasattr(dataOut, header):
                             obj = getattr(dataOut, header)
                             if hasattr(obj, 'printInfo'):
                                 obj.printInfo()
                             else:
                                 print(obj)
                         else:
                             log.warning('Header {} Not found in object'.format(header))
                     self.__printInfo = False

schainpy/model/io/jroIO_digitalRF.py +154 -154

             '''
             Created on Jul 3, 2014
             @author: roj-idl71
             '''
             # SUBCHANNELS EN VEZ DE CHANNELS
             # BENCHMARKS -> PROBLEMAS CON ARCHIVOS GRANDES -> INCONSTANTE EN EL TIEMPO
             # ACTUALIZACION DE VERSION
             # HEADERS
             # MODULO DE ESCRITURA
             # METADATA
             import os
             import time
             import datetime
             import numpy
             import timeit
             from fractions import Fraction
             from time import time
             from time import sleep
             import schainpy.admin
             from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
             from schainpy.model.data.jrodata import Voltage
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             import pickle
             try:
                 import digital_rf
             except:
                 pass
             class DigitalRFReader(ProcessingUnit):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     ProcessingUnit.__init__(self)
-                    self.dataOut                  = Voltage()
+                    self.dataOut = Voltage()
-                    self.__printInfo              = True
+                    self.__printInfo = True
                     self.__flagDiscontinuousBlock = False
                     self.__bufferIndex = 9999999
-                    self.__codeType    = 0
+                    self.__codeType = 0
-                    self.__ippKm       = None
+                    self.__ippKm = None
-                    self.__nCode       = None
+                    self.__nCode = None
-                    self.__nBaud       = None
+                    self.__nBaud = None
-                    self.__code        = None
+                    self.__code = None
-                    self.dtype         = None
+                    self.dtype = None
-                    self.oldAverage    = None
+                    self.oldAverage = None
-                    self.path          = None
+                    self.path = None
                 def close(self):
                     print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     return
                 def __getCurrentSecond(self):
                     return self.__thisUnixSample / self.__sample_rate
                 thisSecond = property(__getCurrentSecond, "I'm the 'thisSecond' property.")
                 def __setFileHeader(self):
                     '''
                     In this method will be initialized every parameter of dataOut object (header, no data)
                     '''
                     ippSeconds = 1.0 * self.__nSamples / self.__sample_rate
                     nProfiles = 1.0 / ippSeconds  # Number of profiles in one second
                     try:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             self.__radarControllerHeader)
                     except:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             txA=0,
                             txB=0,
                             nWindows=1,
                             nHeights=self.__nSamples,
                             firstHeight=self.__firstHeigth,
                             deltaHeight=self.__deltaHeigth,
                             codeType=self.__codeType,
                             nCode=self.__nCode, nBaud=self.__nBaud,
                             code=self.__code)
                     try:
                         self.dataOut.systemHeaderObj = SystemHeader(self.__systemHeader)
                     except:
                         self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
                                                                     nProfiles=nProfiles,
                                                                     nChannels=len(
                                                                         self.__channelList),
                                                                     adcResolution=14)
-                    self.dataOut.type  = "Voltage"
+                    self.dataOut.type = "Voltage"
-                    self.dataOut.data  = None
+                    self.dataOut.data = None
                     self.dataOut.dtype = self.dtype
                     # self.dataOut.nChannels = 0
                     # self.dataOut.nHeights = 0
-                    self.dataOut.nProfiles   = int(nProfiles)
+                    self.dataOut.nProfiles = int(nProfiles)
-                    self.dataOut.heightList  = self.__firstHeigth + \
+                    self.dataOut.heightList = self.__firstHeigth + \
                         numpy.arange(self.__nSamples, dtype=numpy.float) * \
                         self.__deltaHeigth
                     self.dataOut.channelList = list(range(self.__num_subchannels))
-                    self.dataOut.blocksize   = self.dataOut.nChannels * self.dataOut.nHeights
+                    self.dataOut.blocksize = self.dataOut.nChannels * self.dataOut.nHeights
                     # self.dataOut.channelIndexList = None
-                    self.dataOut.flagNoData      = True
+                    self.dataOut.flagNoData = True
                     self.dataOut.flagDataAsBlock = False
                     # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
-                    self.dataOut.utctime     = None
+                    self.dataOut.utctime = None
                     # timezone like jroheader, difference in minutes between UTC and localtime
-                    self.dataOut.timeZone    = self.__timezone / 60
+                    self.dataOut.timeZone = self.__timezone / 60
-                    self.dataOut.dstFlag     = 0
+                    self.dataOut.dstFlag = 0
-                    self.dataOut.errorCount  = 0
+                    self.dataOut.errorCount = 0
                     try:
                         self.dataOut.nCohInt = self.fixed_metadata_dict.get(
                             'nCohInt', self.nCohInt)
                         # asumo que la data esta decodificada
                         self.dataOut.flagDecodeData = self.fixed_metadata_dict.get(
                             'flagDecodeData', self.flagDecodeData)
                         # asumo que la data esta sin flip
                         self.dataOut.flagDeflipData = self.fixed_metadata_dict['flagDeflipData']
-                        self.dataOut.flagShiftFFT   = self.fixed_metadata_dict['flagShiftFFT']
+                        self.dataOut.flagShiftFFT = self.fixed_metadata_dict['flagShiftFFT']
-                        self.dataOut.useLocalTime   = self.fixed_metadata_dict['useLocalTime']
+                        self.dataOut.useLocalTime = self.fixed_metadata_dict['useLocalTime']
                     except:
                         pass
                     self.dataOut.ippSeconds = ippSeconds
                     # Time interval between profiles
                     # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
-                    self.dataOut.frequency  = self.__frequency
+                    self.dataOut.frequency = self.__frequency
-                    self.dataOut.realtime   = self.__online
+                    self.dataOut.realtime = self.__online
                 def findDatafiles(self, path, startDate=None, endDate=None):
                     if not os.path.isdir(path):
                         return []
                     try:
                         digitalReadObj = digital_rf.DigitalRFReader(
                             path, load_all_metadata=True)
                     except:
                         digitalReadObj = digital_rf.DigitalRFReader(path)
-                    channelNameList    = digitalReadObj.get_channels()
+                    channelNameList = digitalReadObj.get_channels()
                     if not channelNameList:
                         return []
-                    metadata_dict      = digitalReadObj.get_rf_file_metadata(channelNameList[0])
+                    metadata_dict = digitalReadObj.get_rf_file_metadata(channelNameList[0])
-                    sample_rate        = metadata_dict['sample_rate'][0]
+                    sample_rate = metadata_dict['sample_rate'][0]
                     this_metadata_file = digitalReadObj.get_metadata(channelNameList[0])
                     try:
-                        timezone       = this_metadata_file['timezone'].value
+                        timezone = this_metadata_file['timezone'].value
                     except:
-                        timezone       = 0
+                        timezone = 0
                     startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(
                         channelNameList[0]) / sample_rate - timezone
-                    startDatetime      = datetime.datetime.utcfromtimestamp(startUTCSecond)
+                    startDatetime = datetime.datetime.utcfromtimestamp(startUTCSecond)
-                    endDatatime        = datetime.datetime.utcfromtimestamp(endUTCSecond)
+                    endDatatime = datetime.datetime.utcfromtimestamp(endUTCSecond)
                     if not startDate:
-                        startDate      = startDatetime.date()
+                        startDate = startDatetime.date()
                     if not endDate:
-                        endDate        = endDatatime.date()
+                        endDate = endDatatime.date()
-                    dateList           = []
+                    dateList = []
-                    thisDatetime       = startDatetime
+                    thisDatetime = startDatetime
                     while(thisDatetime <= endDatatime):
-                        thisDate        = thisDatetime.date()
+                        thisDate = thisDatetime.date()
-                        if thisDate     < startDate:
+                        if thisDate < startDate:
                             continue
-                        if thisDate     > endDate:
+                        if thisDate > endDate:
                             break
                         dateList.append(thisDate)
                         thisDatetime += datetime.timedelta(1)
                     return dateList
                 def setup(self, path=None,
                           startDate=None,
                           endDate=None,
                           startTime=datetime.time(0, 0, 0),
                           endTime=datetime.time(23, 59, 59),
                           channelList=None,
                           nSamples=None,
                           online=False,
                           delay=60,
                           buffer_size=1024,
                           ippKm=None,
                           nCohInt=1,
                           nCode=1,
                           nBaud=1,
                           flagDecodeData=False,
                           code=numpy.ones((1, 1), dtype=numpy.int),
                           **kwargs):
                     '''
                     In this method we should set all initial parameters.
                     Inputs:
                         path
                         startDate
                         endDate
                         startTime
                         endTime
                         set
                         expLabel
                         ext
                         online
                         delay
                     '''
-                    self.path           = path
+                    self.path = path
-                    self.nCohInt        = nCohInt
+                    self.nCohInt = nCohInt
                     self.flagDecodeData = flagDecodeData
-                    self.i              = 0
+                    self.i = 0
                     if not os.path.isdir(path):
                         raise ValueError("[Reading] Directory %s does not exist" % path)
                     try:
                         self.digitalReadObj = digital_rf.DigitalRFReader(
                             path, load_all_metadata=True)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(path)
-                    channelNameList         = self.digitalReadObj.get_channels()
+                    channelNameList = self.digitalReadObj.get_channels()
                     if not channelNameList:
                         raise ValueError("[Reading] Directory %s does not have any files" % path)
                     if not channelList:
                         channelList = list(range(len(channelNameList)))
                     ##########  Reading metadata ######################
-                    top_properties           = self.digitalReadObj.get_properties(
+                    top_properties = self.digitalReadObj.get_properties(
                         channelNameList[channelList[0]])
-                    self.__num_subchannels   = top_properties['num_subchannels']
+                    self.__num_subchannels = top_properties['num_subchannels']
-                    self.__sample_rate       = 1.0 * \
+                    self.__sample_rate = 1.0 * \
                         top_properties['sample_rate_numerator'] / \
                         top_properties['sample_rate_denominator']
                     # self.__samples_per_file = top_properties['samples_per_file'][0]
-                    self.__deltaHeigth       = 1e6 * 0.15 / self.__sample_rate  # why 0.15?
+                    self.__deltaHeigth = 1e6 * 0.15 / self.__sample_rate  # why 0.15?
-                    this_metadata_file       = self.digitalReadObj.get_digital_metadata(
+                    this_metadata_file = self.digitalReadObj.get_digital_metadata(
                         channelNameList[channelList[0]])
-                    metadata_bounds          = this_metadata_file.get_bounds()
+                    metadata_bounds = this_metadata_file.get_bounds()
                     self.fixed_metadata_dict = this_metadata_file.read(
                         metadata_bounds[0])[metadata_bounds[0]]  # GET FIRST HEADER
                     try:
-                        self.__processingHeader      = self.fixed_metadata_dict['processingHeader']
+                        self.__processingHeader = self.fixed_metadata_dict['processingHeader']
                         self.__radarControllerHeader = self.fixed_metadata_dict['radarControllerHeader']
-                        self.__systemHeader          = self.fixed_metadata_dict['systemHeader']
+                        self.__systemHeader = self.fixed_metadata_dict['systemHeader']
-                        self.dtype                   = pickle.loads(self.fixed_metadata_dict['dtype'])
+                        self.dtype = pickle.loads(self.fixed_metadata_dict['dtype'])
                     except:
                         pass
                     self.__frequency = None
                     self.__frequency = self.fixed_metadata_dict.get('frequency', 1)
                     self.__timezone = self.fixed_metadata_dict.get('timezone', 18000)
                     try:
                         nSamples = self.fixed_metadata_dict['nSamples']
                     except:
                         nSamples = None
                     self.__firstHeigth = 0
                     try:
-                        codeType       = self.__radarControllerHeader['codeType']
+                        codeType = self.__radarControllerHeader['codeType']
                     except:
-                        codeType       = 0
+                        codeType = 0
                     try:
                         if codeType:
                             nCode = self.__radarControllerHeader['nCode']
                             nBaud = self.__radarControllerHeader['nBaud']
-                            code  = self.__radarControllerHeader['code']
+                            code = self.__radarControllerHeader['code']
                     except:
                         pass
                     if not ippKm:
                         try:
                             # seconds to km
                             ippKm = self.__radarControllerHeader['ipp']
                         except:
                             ippKm = None
                     ####################################################
-                    self.__ippKm   = ippKm
+                    self.__ippKm = ippKm
                     startUTCSecond = None
-                    endUTCSecond   = None
+                    endUTCSecond = None
                     if startDate:
-                        startDatetime  = datetime.datetime.combine(startDate, startTime)
+                        startDatetime = datetime.datetime.combine(startDate, startTime)
                         startUTCSecond = (
                             startDatetime - datetime.datetime(1970, 1, 1)).total_seconds() + self.__timezone
                     if endDate:
-                        endDatetime   = datetime.datetime.combine(endDate, endTime)
+                        endDatetime = datetime.datetime.combine(endDate, endTime)
-                        endUTCSecond  = (endDatetime - datetime.datetime(1970,
+                        endUTCSecond = (endDatetime - datetime.datetime(1970,
 , 1)).total_seconds() + self.__timezone
                     start_index, end_index = self.digitalReadObj.get_bounds(
                         channelNameList[channelList[0]])
                     if not startUTCSecond:
                         startUTCSecond = start_index / self.__sample_rate
-                    if start_index     > startUTCSecond * self.__sample_rate:
+                    if start_index > startUTCSecond * self.__sample_rate:
                         startUTCSecond = start_index / self.__sample_rate
                     if not endUTCSecond:
-                        endUTCSecond   = end_index / self.__sample_rate
+                        endUTCSecond = end_index / self.__sample_rate
-                    if end_index       < endUTCSecond * self.__sample_rate:
+                    if end_index < endUTCSecond * self.__sample_rate:
-                        endUTCSecond   = end_index / self.__sample_rate
+                        endUTCSecond = end_index / self.__sample_rate
                     if not nSamples:
                         if not ippKm:
                             raise ValueError("[Reading] nSamples or ippKm should be defined")
-                        nSamples            = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
+                        nSamples = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
-                    channelBoundList        = []
+                    channelBoundList = []
                     channelNameListFiltered = []
                     for thisIndexChannel in channelList:
-                        thisChannelName        = channelNameList[thisIndexChannel]
+                        thisChannelName = channelNameList[thisIndexChannel]
                         start_index, end_index = self.digitalReadObj.get_bounds(
                             thisChannelName)
                         channelBoundList.append((start_index, end_index))
                         channelNameListFiltered.append(thisChannelName)
                     self.profileIndex = 0
-                    self.i            = 0
+                    self.i = 0
-                    self.__delay      = delay
+                    self.__delay = delay
-                    self.__codeType   = codeType
+                    self.__codeType = codeType
-                    self.__nCode      = nCode
+                    self.__nCode = nCode
-                    self.__nBaud      = nBaud
+                    self.__nBaud = nBaud
-                    self.__code       = code
+                    self.__code = code
-                    self.__datapath         = path
+                    self.__datapath = path
-                    self.__online           = online
+                    self.__online = online
-                    self.__channelList      = channelList
+                    self.__channelList = channelList
-                    self.__channelNameList  = channelNameListFiltered
+                    self.__channelNameList = channelNameListFiltered
                     self.__channelBoundList = channelBoundList
-                    self.__nSamples         = nSamples
+                    self.__nSamples = nSamples
-                    self.__samples_to_read  = int(nSamples)  # FIJO: AHORA 40
+                    self.__samples_to_read = int(nSamples)  # FIJO: AHORA 40
-                    self.__nChannels        = len(self.__channelList)
+                    self.__nChannels = len(self.__channelList)
-                    self.__startUTCSecond   = startUTCSecond
+                    self.__startUTCSecond = startUTCSecond
-                    self.__endUTCSecond     = endUTCSecond
+                    self.__endUTCSecond = endUTCSecond
-                    self.__timeInterval     = 1.0 * self.__samples_to_read / \
+                    self.__timeInterval = 1.0 * self.__samples_to_read / \
                         self.__sample_rate  # Time interval
                     if online:
                         # self.__thisUnixSample = int(endUTCSecond*self.__sample_rate - 4*self.__samples_to_read)
                         startUTCSecond = numpy.floor(endUTCSecond)
                     # por que en el otro metodo lo primero q se hace es sumar samplestoread
                     self.__thisUnixSample = int(startUTCSecond * self.__sample_rate) - self.__samples_to_read
-                    self.__data_buffer    = numpy.zeros(
+                    self.__data_buffer = numpy.zeros(
                         (self.__num_subchannels, self.__samples_to_read), dtype=numpy.complex)
                     self.__setFileHeader()
                     self.isConfig = True
                     print("[Reading] Digital RF Data was found from %s to %s " % (
                         datetime.datetime.utcfromtimestamp(
                             self.__startUTCSecond - self.__timezone),
                         datetime.datetime.utcfromtimestamp(
                             self.__endUTCSecond - self.__timezone)
                     ))
                     print("[Reading] Starting process from %s to %s" % (datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
                                                                         datetime.datetime.utcfromtimestamp(
                         endUTCSecond - self.__timezone)
                     ))
-                    self.oldAverage    = None
+                    self.oldAverage = None
-                    self.count         = 0
+                    self.count = 0
                     self.executionTime = 0
                 def __reload(self):
                     #         print
                     #         print "%s not in range [%s, %s]" %(
                     #                                           datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
                     #                                           )
                     print("[Reading] reloading metadata ...")
                     try:
                         self.digitalReadObj.reload(complete_update=True)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(self.path)
-                    start_index, end_index  = self.digitalReadObj.get_bounds(
+                    start_index, end_index = self.digitalReadObj.get_bounds(
                         self.__channelNameList[self.__channelList[0]])
-                    if start_index          > self.__startUTCSecond * self.__sample_rate:
+                    if start_index > self.__startUTCSecond * self.__sample_rate:
                         self.__startUTCSecond = 1.0 * start_index / self.__sample_rate
-                    if end_index            > self.__endUTCSecond * self.__sample_rate:
+                    if end_index > self.__endUTCSecond * self.__sample_rate:
                         self.__endUTCSecond = 1.0 * end_index / self.__sample_rate
                         print()
                         print("[Reading] New timerange found [%s, %s] " % (
                             datetime.datetime.utcfromtimestamp(
                                 self.__startUTCSecond - self.__timezone),
                             datetime.datetime.utcfromtimestamp(
                                 self.__endUTCSecond - self.__timezone)
                         ))
                         return True
                     return False
                 def timeit(self, toExecute):
-                    t0                  = time.time()
+                    t0 = time.time()
                     toExecute()
-                    self.executionTime  = time.time() - t0
+                    self.executionTime = time.time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
-                    self.oldAverage     = (self.executionTime + self.count *
+                    self.oldAverage = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
-                    self.count          = self.count + 1.0
+                    self.count = self.count + 1.0
                     return
                 def __readNextBlock(self, seconds=30, volt_scale=1):
                     '''
                     '''
                     # Set the next data
                     self.__flagDiscontinuousBlock = False
-                    self.__thisUnixSample        += self.__samples_to_read
+                    self.__thisUnixSample += self.__samples_to_read
                     if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                         print ("[Reading] There are no more data into selected time-range")
                         if self.__online:
                             sleep(3)
                             self.__reload()
                         else:
                             return False
                         if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                             return False
                             self.__thisUnixSample -= self.__samples_to_read
                     indexChannel = 0
                     dataOk = False
                     for thisChannelName in self.__channelNameList:  # TODO VARIOS CHANNELS?
                         for indexSubchannel in range(self.__num_subchannels):
                             try:
-                                t0     = time()
+                                t0 = time()
                                 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
                                                                               self.__samples_to_read,
                                                                               thisChannelName, sub_channel=indexSubchannel)
-                                self.executionTime  = time() - t0
+                                self.executionTime = time() - t0
                                 if self.oldAverage is None:
                                     self.oldAverage = self.executionTime
-                                self.oldAverage     = (
+                                self.oldAverage = (
                                     self.executionTime + self.count * self.oldAverage) / (self.count + 1.0)
                                 self.count = self.count + 1.0
                             except IOError as e:
                                 # read next profile
                                 self.__flagDiscontinuousBlock = True
                                 print("[Reading] %s" % datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e)
                                 break
                             if result.shape[0] != self.__samples_to_read:
                                 self.__flagDiscontinuousBlock = True
                                 print("[Reading] %s: Too few samples were found, just %d/%d  samples" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                                                          result.shape[0],
                                                                                                          self.__samples_to_read))
                                 break
                             self.__data_buffer[indexSubchannel, :] = result * volt_scale
-                            indexChannel+=1
+                            indexChannel += 1
-                            dataOk       = True
+                            dataOk = True
-                    self.__utctime       = self.__thisUnixSample / self.__sample_rate
+                    self.__utctime = self.__thisUnixSample / self.__sample_rate
                     if not dataOk:
                         return False
                     print("[Reading] %s: %d samples <> %f sec" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                   self.__samples_to_read,
                                                                   self.__timeInterval))
-                    self.__bufferIndex   = 0
+                    self.__bufferIndex = 0
                     return True
                 def __isBufferEmpty(self):
                     return self.__bufferIndex > self.__samples_to_read - self.__nSamples  # 40960 - 40
                 def getData(self, seconds=30, nTries=5):
                     '''
                         This method gets the data from files and put the data into the dataOut object
                         In addition, increase el the buffer counter in one.
                         Return:
                             data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                         buffer. Si no hay mas archivos a leer retorna None.
                         Affected:
                             self.dataOut
                             self.profileIndex
                             self.flagDiscontinuousBlock
                             self.flagIsNewBlock
                     '''
-                    #print("getdata")
+                    # print("getdata")
                     err_counter = 0
                     self.dataOut.flagNoData = True
                     if self.__isBufferEmpty():
-                        #print("hi")
+                        # print("hi")
                         self.__flagDiscontinuousBlock = False
                         while True:
-                            #print ("q ha pasado")
+                            # print ("q ha pasado")
                             if self.__readNextBlock():
                                 break
                             if self.__thisUnixSample > self.__endUTCSecond * self.__sample_rate:
                                 raise schainpy.admin.SchainError('Error')
                                 return
                             if self.__flagDiscontinuousBlock:
                                 raise schainpy.admin.SchainError('discontinuous block found')
                                 return
                             if not self.__online:
                                 raise schainpy.admin.SchainError('Online?')
                                 return
                             err_counter += 1
                             if err_counter > nTries:
                                 raise schainpy.admin.SchainError('Max retrys reach')
                                 return
                             print('[Reading] waiting %d seconds to read a new block' % seconds)
                             time.sleep(seconds)
-                    self.dataOut.data                   = self.__data_buffer[:, self.__bufferIndex:self.__bufferIndex + self.__nSamples]
+                    self.dataOut.data = self.__data_buffer[:, self.__bufferIndex:self.__bufferIndex + self.__nSamples]
-                    self.dataOut.utctime                = ( self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
+                    self.dataOut.utctime = (self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
-                    self.dataOut.flagNoData             = False
+                    self.dataOut.flagNoData = False
                     self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
-                    self.dataOut.profileIndex           = self.profileIndex
+                    self.dataOut.profileIndex = self.profileIndex
                     self.__bufferIndex += self.__nSamples
-                    self.profileIndex  += 1
+                    self.profileIndex += 1
                     if self.profileIndex == self.dataOut.nProfiles:
                         self.profileIndex = 0
                     return True
                 def printInfo(self):
                     '''
                     '''
                     if self.__printInfo == False:
                         return
                     # self.systemHeaderObj.printInfo()
                     # self.radarControllerHeaderObj.printInfo()
                     self.__printInfo = False
                 def printNumberOfBlock(self):
                     '''
                     '''
                     return
                     # print self.profileIndex
                 def run(self, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
-                    #self.i = self.i+1
+                    # self.i = self.i+1
                     self.getData(seconds=self.__delay)
                     return
             @MPDecorator
             class DigitalRFWriter(Operation):
                 '''
                 classdocs
                 '''
                 def __init__(self, **kwargs):
                     '''
                     Constructor
                     '''
                     Operation.__init__(self, **kwargs)
                     self.metadata_dict = {}
-                    self.dataOut       = None
+                    self.dataOut = None
-                    self.dtype         = None
+                    self.dtype = None
-                    self.oldAverage    = 0
+                    self.oldAverage = 0
                 def setHeader(self):
-                    self.metadata_dict['frequency']      = self.dataOut.frequency
+                    self.metadata_dict['frequency'] = self.dataOut.frequency
-                    self.metadata_dict['timezone']       = self.dataOut.timeZone
+                    self.metadata_dict['timezone'] = self.dataOut.timeZone
-                    self.metadata_dict['dtype']          = pickle.dumps(self.dataOut.dtype)
+                    self.metadata_dict['dtype'] = pickle.dumps(self.dataOut.dtype)
-                    self.metadata_dict['nProfiles']      = self.dataOut.nProfiles
+                    self.metadata_dict['nProfiles'] = self.dataOut.nProfiles
-                    self.metadata_dict['heightList']     = self.dataOut.heightList
+                    self.metadata_dict['heightList'] = self.dataOut.heightList
-                    self.metadata_dict['channelList']    = self.dataOut.channelList
+                    self.metadata_dict['channelList'] = self.dataOut.channelList
                     self.metadata_dict['flagDecodeData'] = self.dataOut.flagDecodeData
                     self.metadata_dict['flagDeflipData'] = self.dataOut.flagDeflipData
-                    self.metadata_dict['flagShiftFFT']   = self.dataOut.flagShiftFFT
+                    self.metadata_dict['flagShiftFFT'] = self.dataOut.flagShiftFFT
-                    self.metadata_dict['useLocalTime']   = self.dataOut.useLocalTime
+                    self.metadata_dict['useLocalTime'] = self.dataOut.useLocalTime
-                    self.metadata_dict['nCohInt']        = self.dataOut.nCohInt
+                    self.metadata_dict['nCohInt'] = self.dataOut.nCohInt
-                    self.metadata_dict['type']           = self.dataOut.type
+                    self.metadata_dict['type'] = self.dataOut.type
-                    self.metadata_dict['flagDataAsBlock']= getattr(
+                    self.metadata_dict['flagDataAsBlock'] = getattr(
                         self.dataOut, 'flagDataAsBlock', None)  # chequear
                 def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
                     '''
                     In this method we should set all initial parameters.
                     Input:
                         dataOut: Input data will also be outputa data
                     '''
                     self.setHeader()
-                    self.__ippSeconds  = dataOut.ippSeconds
+                    self.__ippSeconds = dataOut.ippSeconds
-                    self.__deltaH      = dataOut.getDeltaH()
+                    self.__deltaH = dataOut.getDeltaH()
                     self.__sample_rate = 1e6 * 0.15 / self.__deltaH
-                    self.__dtype       = dataOut.dtype
+                    self.__dtype = dataOut.dtype
                     if len(dataOut.dtype) == 2:
                         self.__dtype = dataOut.dtype[0]
-                    self.__nSamples  = dataOut.systemHeaderObj.nSamples
+                    self.__nSamples = dataOut.systemHeaderObj.nSamples
                     self.__nProfiles = dataOut.nProfiles
                     if self.dataOut.type != 'Voltage':
                         raise 'Digital RF cannot be used with this data type'
                         self.arr_data = numpy.ones((1, dataOut.nFFTPoints * len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
                     else:
                         self.arr_data = numpy.ones((self.__nSamples, len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
-                    file_cadence_millisecs  = 1000
+                    file_cadence_millisecs = 1000
-                    sample_rate_fraction    = Fraction(self.__sample_rate).limit_denominator()
+                    sample_rate_fraction = Fraction(self.__sample_rate).limit_denominator()
-                    sample_rate_numerator   = int(sample_rate_fraction.numerator)
+                    sample_rate_numerator = int(sample_rate_fraction.numerator)
                     sample_rate_denominator = int(sample_rate_fraction.denominator)
-                    start_global_index      = dataOut.utctime * self.__sample_rate
+                    start_global_index = dataOut.utctime * self.__sample_rate
-                    uuid              = 'prueba'
+                    uuid = 'prueba'
                     compression_level = 0
-                    checksum          = False
+                    checksum = False
-                    is_complex        = True
+                    is_complex = True
-                    num_subchannels   = len(dataOut.channelList)
+                    num_subchannels = len(dataOut.channelList)
-                    is_continuous     = True
+                    is_continuous = True
-                    marching_periods  = False
+                    marching_periods = False
                     self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, dirCadence,
                                                                       fileCadence, start_global_index,
                                                                       sample_rate_numerator, sample_rate_denominator, uuid, compression_level, checksum,
                                                                       is_complex, num_subchannels, is_continuous, marching_periods)
-                    metadata_dir         = os.path.join(path, 'metadata')
+                    metadata_dir = os.path.join(path, 'metadata')
                     os.system('mkdir %s' % (metadata_dir))
                     self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, dirCadence, 1,  # 236, file_cadence_millisecs / 1000
                                                                                     sample_rate_numerator, sample_rate_denominator,
                                                                                     metadataFile)
-                    self.isConfig      = True
+                    self.isConfig = True
                     self.currentSample = 0
-                    self.oldAverage    = 0
+                    self.oldAverage = 0
-                    self.count         = 0
+                    self.count = 0
                     return
                 def writeMetadata(self):
-                    start_idx                                   = self.__sample_rate * self.dataOut.utctime
+                    start_idx = self.__sample_rate * self.dataOut.utctime
-                    self.metadata_dict['processingHeader']      = self.dataOut.processingHeaderObj.getAsDict(
+                    self.metadata_dict['processingHeader'] = self.dataOut.processingHeaderObj.getAsDict(
                     )
                     self.metadata_dict['radarControllerHeader'] = self.dataOut.radarControllerHeaderObj.getAsDict(
                     )
-                    self.metadata_dict['systemHeader']          = self.dataOut.systemHeaderObj.getAsDict(
+                    self.metadata_dict['systemHeader'] = self.dataOut.systemHeaderObj.getAsDict(
                     )
                     self.digitalMetadataWriteObj.write(start_idx, self.metadata_dict)
                     return
                 def timeit(self, toExecute):
                     t0 = time()
                     toExecute()
-                    self.executionTime  = time() - t0
+                    self.executionTime = time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
-                    self.oldAverage     = (self.executionTime + self.count *
+                    self.oldAverage = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
-                    self.count          = self.count + 1.0
+                    self.count = self.count + 1.0
                     return
                 def writeData(self):
                     if self.dataOut.type != 'Voltage':
                         raise 'Digital RF cannot be used with this data type'
                         for channel in self.dataOut.channelList:
                             for i in range(self.dataOut.nFFTPoints):
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['i'] = self.dataOut.data[channel][i].imag
                     else:
                         for i in range(self.dataOut.systemHeaderObj.nSamples):
                             for channel in self.dataOut.channelList:
                                 self.arr_data[i][channel]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[i][channel]['i'] = self.dataOut.data[channel][i].imag
                     def f(): return self.digitalWriteObj.rf_write(self.arr_data)
                     self.timeit(f)
                     return
                 def run(self, dataOut, frequency=49.92e6, path=None, fileCadence=1000, dirCadence=36000, metadataCadence=1, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     Inputs:
                         dataOut: object with the data
                     '''
                     # print dataOut.__dict__
                     self.dataOut = dataOut
                     if not self.isConfig:
                         self.setup(dataOut, path, frequency, fileCadence,
                                    dirCadence, metadataCadence, **kwargs)
                         self.writeMetadata()
                     self.writeData()
-                    ## self.currentSample += 1
+                    # # self.currentSample += 1
                     # if self.dataOut.flagDataAsBlock or self.currentSample == 1:
                     # self.writeMetadata()
-                    ## if self.currentSample == self.__nProfiles: self.currentSample = 0
+                    # # if self.currentSample == self.__nProfiles: self.currentSample = 0
-                    return dataOut# en la version 2.7 no aparece este return
+                    return dataOut  # en la version 2.7 no aparece este return
                 def close(self):
                     print('[Writing] - Closing files ')
                     print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     try:
                         self.digitalWriteObj.close()
                     except:
                         pass

schainpy/model/io/jroIO_heispectra.py +114 -114

             '''
             Created on Jul 3, 2014
             @author: roj-idl71
             '''
             import os, sys
             import time, datetime
             import numpy
             import fnmatch
             import glob
             from time import sleep
             try:
                 import pyfits
             except ImportError as e:
                 pass
             from xml.etree.ElementTree import ElementTree
             from .jroIO_base import isRadarFolder, isNumber
             from schainpy.model.data.jrodata import Fits
             from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit, MPDecorator
             from schainpy.utils import log
             class PyFits(object):
-                name=None
+                name = None
-                format=None
+                format = None
-                array =None
+                array = None
-                data =None
+                data = None
-                thdulist=None
+                thdulist = None
-                prihdr=None
+                prihdr = None
-                hdu=None
+                hdu = None
                 def __init__(self):
                     pass
-                def setColF(self,name,format,array):
+                def setColF(self, name, format, array):
-                    self.name=name
+                    self.name = name
-                    self.format=format
+                    self.format = format
-                    self.array=array
+                    self.array = array
-                    a1=numpy.array([self.array],dtype=numpy.float32)
+                    a1 = numpy.array([self.array], dtype=numpy.float32)
                     self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
                     return self.col1
             #    def setColP(self,name,format,data):
             #        self.name=name
             #        self.format=format
             #        self.data=data
             #        a2=numpy.array([self.data],dtype=numpy.float32)
             #        self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
             #        return self.col2
-                def writeData(self,name,format,data):
+                def writeData(self, name, format, data):
-                    self.name=name
+                    self.name = name
-                    self.format=format
+                    self.format = format
-                    self.data=data
+                    self.data = data
-                    a2=numpy.array([self.data],dtype=numpy.float32)
+                    a2 = numpy.array([self.data], dtype=numpy.float32)
                     self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
                     return self.col2
-                def cFImage(self,idblock,year,month,day,hour,minute,second):
+                def cFImage(self, idblock, year, month, day, hour, minute, second):
-                    self.hdu= pyfits.PrimaryHDU(idblock)
+                    self.hdu = pyfits.PrimaryHDU(idblock)
-                    self.hdu.header.set("Year",year)
+                    self.hdu.header.set("Year", year)
-                    self.hdu.header.set("Month",month)
+                    self.hdu.header.set("Month", month)
-                    self.hdu.header.set("Day",day)
+                    self.hdu.header.set("Day", day)
-                    self.hdu.header.set("Hour",hour)
+                    self.hdu.header.set("Hour", hour)
-                    self.hdu.header.set("Minute",minute)
+                    self.hdu.header.set("Minute", minute)
-                    self.hdu.header.set("Second",second)
+                    self.hdu.header.set("Second", second)
                     return self.hdu
-                def Ctable(self,colList):
+                def Ctable(self, colList):
-                    self.cols=pyfits.ColDefs(colList)
+                    self.cols = pyfits.ColDefs(colList)
                     self.tbhdu = pyfits.new_table(self.cols)
                     return self.tbhdu
-                def CFile(self,hdu,tbhdu):
+                def CFile(self, hdu, tbhdu):
-                    self.thdulist=pyfits.HDUList([hdu,tbhdu])
+                    self.thdulist = pyfits.HDUList([hdu, tbhdu])
-                def wFile(self,filename):
+                def wFile(self, filename):
                     if os.path.isfile(filename):
                         os.remove(filename)
                     self.thdulist.writeto(filename)
             class ParameterConf:
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.name = ''
                     self.value = ''
                 def readXml(self, parmElement):
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                 def getElementName(self):
                     return self.ELEMENTNAME
             class Metadata(object):
                 def __init__(self, filename):
                     self.parmConfObjList = []
                     self.readXml(filename)
                 def readXml(self, filename):
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     self.projectElement = ElementTree().parse(filename)
                     self.project = self.projectElement.tag
                     parmElementList = self.projectElement.getiterator(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         self.parmConfObjList.append(parmConfObj)
             @MPDecorator
             class FitsWriter(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.isConfig = False
                     self.dataBlocksPerFile = None
                     self.blockIndex = 0
                     self.flagIsNewFile = 1
                     self.fitsObj = None
                     self.optchar = 'P'
                     self.ext = '.fits'
                     self.setFile = 0
                 def setFitsHeader(self, dataOut, metadatafile=None):
                     header_data = pyfits.PrimaryHDU()
                     header_data.header['EXPNAME'] = "RADAR DATA"
                     header_data.header['DATATYPE'] = "SPECTRA"
                     header_data.header['COMMENT'] = ""
                     if metadatafile:
                         metadata4fits = Metadata(metadatafile)
                         for parameter in metadata4fits.parmConfObjList:
                             parm_name = parameter.name
                             parm_value = parameter.value
                             header_data.header[parm_name] = parm_value
                     header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
                     header_data.header['CHANNELLIST'] = str(dataOut.channelList)
                     header_data.header['NCHANNELS'] = dataOut.nChannels
-                    #header_data.header['HEIGHTS'] = dataOut.heightList
+                    # header_data.header['HEIGHTS'] = dataOut.heightList
                     header_data.header['NHEIGHTS'] = dataOut.nHeights
                     header_data.header['IPPSECONDS'] = dataOut.ippSeconds
                     header_data.header['NCOHINT'] = dataOut.nCohInt
                     header_data.header['NINCOHINT'] = dataOut.nIncohInt
                     header_data.header['TIMEZONE'] = dataOut.timeZone
                     header_data.header['NBLOCK'] = self.blockIndex
                     header_data.writeto(self.filename)
-                    self.addExtension(dataOut.heightList,'HEIGHTLIST')
+                    self.addExtension(dataOut.heightList, 'HEIGHTLIST')
                 def setup(self, dataOut, path, dataBlocksPerFile=100, metadatafile=None):
                     self.path = path
                     self.dataOut = dataOut
                     self.metadatafile = metadatafile
                     self.dataBlocksPerFile = dataBlocksPerFile
                 def open(self):
                     self.fitsObj = pyfits.open(self.filename, mode='update')
                 def addExtension(self, data, tagname):
                     self.open()
                     extension = pyfits.ImageHDU(data=data, name=tagname)
-                    #extension.header['TAG'] = tagname
+                    # extension.header['TAG'] = tagname
                     self.fitsObj.append(extension)
                     self.write()
                 def addData(self, data):
                     self.open()
                     extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])
                     extension.header['UTCTIME'] = self.dataOut.utctime
                     self.fitsObj.append(extension)
                     self.blockIndex += 1
                     self.fitsObj[0].header['NBLOCK'] = self.blockIndex
                     self.write()
                 def write(self):
                     self.fitsObj.flush(verbose=True)
                     self.fitsObj.close()
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
-                    timeTuple = time.localtime( self.dataOut.utctime)
+                    timeTuple = time.localtime(self.dataOut.utctime)
-                    subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
+                    subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year, timeTuple.tm_yday)
-                    fullpath = os.path.join( path, subfolder )
+                    fullpath = os.path.join(path, subfolder)
-                    if not( os.path.exists(fullpath) ):
+                    if not(os.path.exists(fullpath)):
                         os.mkdir(fullpath)
-                        self.setFile = -1 #inicializo mi contador de seteo
+                        self.setFile = -1  # inicializo mi contador de seteo
                     else:
-                        filesList = os.listdir( fullpath )
+                        filesList = os.listdir(fullpath)
-                        if len( filesList ) > 0:
+                        if len(filesList) > 0:
-                            filesList = sorted( filesList, key=str.lower )
+                            filesList = sorted(filesList, key=str.lower)
                             filen = filesList[-1]
-                            if isNumber( filen[8:11] ):
+                            if isNumber(filen[8:11]):
-                                self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
+                                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
+                            self.setFile = -1  # inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                     thisFile = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
-                                                    ext )
+                                                    ext)
-                    filename = os.path.join( path, subfolder, thisFile )
+                    filename = os.path.join(path, subfolder, thisFile)
                     self.blockIndex = 0
                     self.filename = filename
                     self.setFile = setFile
                     self.flagIsNewFile = 1
-                    print('Writing the file: %s'%self.filename)
+                    print('Writing the file: %s' % self.filename)
                     self.setFitsHeader(self.dataOut, self.metadatafile)
                     return 1
                 def writeBlock(self):
                     self.addData(self.dataOut.data_spc)
                     self.flagIsNewFile = 0
                 def __setNewBlock(self):
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.dataBlocksPerFile:
                         return 1
-                    if not( self.setNextFile() ):
+                    if not(self.setNextFile()):
                         return 0
                     return 1
                 def writeNextBlock(self):
-                    if not( self.__setNewBlock() ):
+                    if not(self.__setNewBlock()):
                         return 0
                     self.writeBlock()
                     return 1
                 def putData(self):
                     if self.flagIsNewFile:
                         self.setNextFile()
                     self.writeNextBlock()
                 def run(self, dataOut, path, dataBlocksPerFile=100, metadatafile=None, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, path, dataBlocksPerFile=dataBlocksPerFile, metadatafile=metadatafile, **kwargs)
                         self.isConfig = True
                     self.putData()
             class FitsReader(ProcessingUnit):
             #     __TIMEZONE = time.timezone
                 expName = None
                 datetimestr = None
                 utc = None
                 nChannels = None
                 nSamples = None
                 dataBlocksPerFile = None
                 comments = None
                 lastUTTime = None
                 header_dict = None
                 data = None
                 data_header_dict = None
-                def __init__(self):#, **kwargs):
+                def __init__(self):  # , **kwargs):
-                    ProcessingUnit.__init__(self)#, **kwargs)
+                    ProcessingUnit.__init__(self)  # , **kwargs)
                     self.isConfig = False
                     self.ext = '.fits'
                     self.setFile = 0
                     self.flagNoMoreFiles = 0
                     self.flagIsNewFile = 1
                     self.flagDiscontinuousBlock = None
                     self.fileIndex = None
                     self.filename = None
                     self.fileSize = None
                     self.fitsObj = None
                     self.timeZone = None
                     self.nReadBlocks = 0
                     self.nTotalBlocks = 0
                     self.dataOut = self.createObjByDefault()
-                    self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()
+                    self.maxTimeStep = 10  # deberia ser definido por el usuario usando el metodo setup()
                     self.blockIndex = 1
                 def createObjByDefault(self):
                     dataObj = Fits()
                     return dataObj
                 def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):
                     try:
-                        fitsObj = pyfits.open(filename,'readonly')
+                        fitsObj = pyfits.open(filename, 'readonly')
                     except:
-                        print("File %s can't be opened" %(filename))
+                        print("File %s can't be opened" % (filename))
                         return None
                     header = fitsObj[0].header
                     struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")
-                    utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS
+                    utc = time.mktime(struct_time) - time.timezone  # TIMEZONE debe ser un parametro del header FITS
                     ltc = utc
                     if useLocalTime:
                         ltc -= time.timezone
                     thisDatetime = datetime.datetime.utcfromtimestamp(ltc)
                     thisTime = thisDatetime.time()
                     if not ((startTime <= thisTime) and (endTime > thisTime)):
                         return None
                     return thisDatetime
                 def __setNextFileOnline(self):
                     raise NotImplementedError
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
             #            if not(self.__verifyFile(filename)):
             #                continue
                         fileSize = os.path.getsize(filename)
-                        fitsObj = pyfits.open(filename,'readonly')
+                        fitsObj = pyfits.open(filename, 'readonly')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fitsObj = fitsObj
                     self.blockIndex = 0
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __setValuesFromHeader(self):
                     self.dataOut.header = self.header_dict
                     self.dataOut.expName = self.expName
                     self.dataOut.timeZone = self.timeZone
                     self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
                     self.dataOut.comments = self.comments
             #         self.dataOut.timeInterval = self.timeInterval
                     self.dataOut.channelList = self.channelList
                     self.dataOut.heightList = self.heightList
                     self.dataOut.nCohInt = self.nCohInt
                     self.dataOut.nIncohInt = self.nIncohInt
                     self.dataOut.ipp_sec = self.ippSeconds
                 def readHeader(self):
                     headerObj = self.fitsObj[0]
                     self.header_dict = headerObj.header
                     if 'EXPNAME' in list(headerObj.header.keys()):
                         self.expName = headerObj.header['EXPNAME']
                     if 'DATATYPE' in list(headerObj.header.keys()):
                         self.dataType = headerObj.header['DATATYPE']
                     self.datetimestr = headerObj.header['DATETIME']
                     channelList = headerObj.header['CHANNELLIST']
                     channelList = channelList.split('[')
                     channelList = channelList[1].split(']')
                     channelList = channelList[0].split(',')
                     channelList = [int(ch) for ch in channelList]
                     self.channelList = channelList
                     self.nChannels = headerObj.header['NCHANNELS']
                     self.nHeights = headerObj.header['NHEIGHTS']
                     self.ippSeconds = headerObj.header['IPPSECONDS']
                     self.nCohInt = headerObj.header['NCOHINT']
                     self.nIncohInt = headerObj.header['NINCOHINT']
                     self.dataBlocksPerFile = headerObj.header['NBLOCK']
                     self.timeZone = headerObj.header['TIMEZONE']
             #         self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     if 'COMMENT' in list(headerObj.header.keys()):
                         self.comments = headerObj.header['COMMENT']
                     self.readHeightList()
                 def readHeightList(self):
                     self.blockIndex = self.blockIndex + 1
                     obj = self.fitsObj[self.blockIndex]
                     self.heightList = obj.data
                     self.blockIndex = self.blockIndex + 1
                 def readExtension(self):
                     obj = self.fitsObj[self.blockIndex]
                     self.heightList = obj.data
                     self.blockIndex = self.blockIndex + 1
                 def setNextFile(self):
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.readHeader()
                     self.__setValuesFromHeader()
                     self.nReadBlocks = 0
             #         self.blockIndex = 1
                     return 1
                 def searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
-                                        startTime=datetime.time(0,0,0),
+                                        startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),
+                                        endTime=datetime.time(23, 59, 59),
                                         set=None,
                                         expLabel='',
                                         ext='.fits',
                                         walk=True):
                     pathList = []
                     if not walk:
                         pathList.append(path)
                     else:
                         dirList = []
                         for thisPath in os.listdir(path):
-                            if not os.path.isdir(os.path.join(path,thisPath)):
+                            if not os.path.isdir(os.path.join(path, thisPath)):
                                 continue
                             if not isRadarFolder(thisPath):
                                 continue
                             dirList.append(thisPath)
                         if not(dirList):
                             return None, None
                         thisDate = startDate
                         while(thisDate <= endDate):
                             year = thisDate.timetuple().tm_year
                             doy = thisDate.timetuple().tm_yday
-                            matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
+                            matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year, doy) + '*')
                             if len(matchlist) == 0:
                                 thisDate += datetime.timedelta(1)
                                 continue
                             for match in matchlist:
-                                pathList.append(os.path.join(path,match,expLabel))
+                                pathList.append(os.path.join(path, match, expLabel))
                             thisDate += datetime.timedelta(1)
                     if pathList == []:
-                        print("Any folder was found for the date range: %s-%s" %(startDate, endDate))
+                        print("Any folder was found for the date range: %s-%s" % (startDate, endDate))
                         return None, None
-                    print("%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate))
+                    print("%d folder(s) was(were) found for the date range: %s - %s" % (len(pathList), startDate, endDate))
                     filenameList = []
                     datetimeList = []
                     for i in range(len(pathList)):
                         thisPath = pathList[i]
-                        fileList = glob.glob1(thisPath, "*%s" %ext)
+                        fileList = glob.glob1(thisPath, "*%s" % ext)
                         fileList.sort()
                         for thisFile in fileList:
-                            filename = os.path.join(thisPath,thisFile)
+                            filename = os.path.join(thisPath, thisFile)
                             thisDatetime = self.isFileinThisTime(filename, startTime, endTime)
                             if not(thisDatetime):
                                 continue
                             filenameList.append(filename)
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
-                        print("Any file was found for the time range %s - %s" %(startTime, endTime))
+                        print("Any file was found for the time range %s - %s" % (startTime, endTime))
                         return None, None
-                    print("%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime))
+                    print("%d file(s) was(were) found for the time range: %s - %s" % (len(filenameList), startTime, endTime))
                     print()
                     for i in range(len(filenameList)):
-                        print("%s -> [%s]" %(filenameList[i], datetimeList[i].ctime()))
+                        print("%s -> [%s]" % (filenameList[i], datetimeList[i].ctime()))
                     self.filenameList = filenameList
                     self.datetimeList = datetimeList
                     return pathList, filenameList
                 def setup(self, path=None,
                             startDate=None,
                             endDate=None,
-                            startTime=datetime.time(0,0,0),
+                            startTime=datetime.time(0, 0, 0),
-                            endTime=datetime.time(23,59,59),
+                            endTime=datetime.time(23, 59, 59),
                             set=0,
-                            expLabel = "",
+                            expLabel="",
-                            ext = None,
+                            ext=None,
-                            online = False,
+                            online=False,
-                            delay = 60,
+                            delay=60,
-                            walk = True):
+                            walk=True):
                     if path == None:
                         raise ValueError("The path is not valid")
                     if ext == None:
                         ext = self.ext
                     if not(online):
                         print("Searching files in offline mode ...")
                         pathList, filenameList = self.searchFilesOffLine(path, startDate=startDate, endDate=endDate,
                                                                            startTime=startTime, endTime=endTime,
                                                                            set=set, expLabel=expLabel, ext=ext,
                                                                            walk=walk)
                         if not(pathList):
-                            print("No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
+                            print("No *%s files into the folder %s \nfor the range: %s - %s" % (ext, path,
-                                                                    datetime.datetime.combine(startDate,startTime).ctime(),
+                                                                    datetime.datetime.combine(startDate, startTime).ctime(),
-                                                                    datetime.datetime.combine(endDate,endTime).ctime()))
+                                                                    datetime.datetime.combine(endDate, endTime).ctime()))
                             sys.exit(-1)
                         self.fileIndex = -1
                         self.pathList = pathList
                         self.filenameList = filenameList
                     self.online = online
                     self.delay = delay
                     ext = ext.lower()
                     self.ext = ext
                     if not(self.setNextFile()):
-                        if (startDate!=None) and (endDate!=None):
+                        if (startDate != None) and (endDate != None):
-                            print("No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime()))
+                            print("No files in range: %s - %s" % (datetime.datetime.combine(startDate, startTime).ctime(), datetime.datetime.combine(endDate, endTime).ctime()))
                         elif startDate != None:
-                            print("No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime()))
+                            print("No files in range: %s" % (datetime.datetime.combine(startDate, startTime).ctime()))
                         else:
                             print("No files")
                         sys.exit(-1)
                 def readBlock(self):
                     dataObj = self.fitsObj[self.blockIndex]
                     self.data = dataObj.data
                     self.data_header_dict = dataObj.header
                     self.utc = self.data_header_dict['UTCTIME']
                     self.flagIsNewFile = 0
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def __jumpToLastBlock(self):
                     raise NotImplementedError
                 def __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                     Si el modo de lectura es OffLine siempre retorn 0
                     """
                     if not self.online:
                         return 0
                     if (self.nReadBlocks >= self.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
-                    for nTries in range( self.nTries ):
+                    for nTries in range(self.nTries):
                         self.fp.close()
-                        self.fp = open( self.filename, 'rb' )
+                        self.fp = open(self.filename, 'rb')
-                        self.fp.seek( currentPointer )
+                        self.fp.seek(currentPointer)
-                        self.fileSize = os.path.getsize( self.filename )
+                        self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
-                        if ( currentSize >= neededSize ):
+                        if (currentSize >= neededSize):
                             self.__rdBasicHeader()
                             return 1
-                        print("\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1))
+                        print("\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1))
-                        sleep( self.delay )
+                        sleep(self.delay)
                     return 0
                 def __setNewBlock(self):
                     if self.online:
                         self.__jumpToLastBlock()
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.utc
                     if self.online:
                         if self.__waitNewBlock():
                             return 1
                     if self.nReadBlocks < self.dataBlocksPerFile:
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.utc - self.lastUTTime
                     self.flagDiscontinuousBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagDiscontinuousBlock = 1
                     return 1
                 def readNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
                 def printInfo(self):
                     pass
                 def getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         return (0, 'No more files')
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     if not(self.readNextBlock()):
                         return (1, 'Error reading data')
                     if self.data is None:
                         self.dataOut.flagNoData = True
                         return (0, 'No more data')
                     self.dataOut.data = self.data
                     self.dataOut.data_header = self.data_header_dict
                     self.dataOut.utctime = self.utc
             #         self.dataOut.header = self.header_dict
             #         self.dataOut.expName = self.expName
             #         self.dataOut.nChannels = self.nChannels
             #         self.dataOut.timeZone = self.timeZone
             #         self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
             #         self.dataOut.comments = self.comments
             # #         self.dataOut.timeInterval = self.timeInterval
             #         self.dataOut.channelList = self.channelList
             #         self.dataOut.heightList = self.heightList
                     self.dataOut.flagNoData = False
                     # return self.dataOut.data
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
             @MPDecorator
             class SpectraHeisWriter(Operation):
             #    set = None
                 setFile = None
                 idblock = None
                 doypath = None
                 subfolder = None
-                def __init__(self):#, **kwargs):
+                def __init__(self):  # , **kwargs):
-                    Operation.__init__(self)#, **kwargs)
+                    Operation.__init__(self)  # , **kwargs)
                     self.wrObj = PyFits()
             #        self.dataOut = dataOut
-                    self.nTotalBlocks=0
+                    self.nTotalBlocks = 0
             #        self.set = None
                     self.setFile = None
                     self.idblock = 0
                     self.wrpath = None
                     self.doypath = None
                     self.subfolder = None
                     self.isConfig = False
                 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 )
+                        float(str)
                         return True
                     except:
                         return False
                 def setup(self, dataOut, wrpath):
                     if not(os.path.exists(wrpath)):
                         os.mkdir(wrpath)
                     self.wrpath = wrpath
             #        self.setFile = 0
                     self.dataOut = dataOut
                 def putData(self):
-                    name= time.localtime( self.dataOut.utctime)
+                    name = time.localtime(self.dataOut.utctime)
-                    ext=".fits"
+                    ext = ".fits"
                     if self.doypath == None:
-                       self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))
+                       self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year, name.tm_yday, time.mktime(datetime.datetime.now().timetuple()))
-                       self.doypath = os.path.join( self.wrpath, self.subfolder )
+                       self.doypath = os.path.join(self.wrpath, self.subfolder)
                        os.mkdir(self.doypath)
                     if self.setFile == None:
             #           self.set = self.dataOut.set
                        self.setFile = 0
             #        if self.set != self.dataOut.set:
-            ##            self.set = self.dataOut.set
+            # #            self.set = self.dataOut.set
             #            self.setFile = 0
-                    #make the filename
+                    # make the filename
-                    thisFile = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
+                    thisFile = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year, name.tm_yday, self.setFile, ext)
-                    filename = os.path.join(self.wrpath,self.subfolder, thisFile)
+                    filename = os.path.join(self.wrpath, self.subfolder, thisFile)
-                    idblock = numpy.array([self.idblock],dtype="int64")
+                    idblock = numpy.array([self.idblock], dtype="int64")
-                    header=self.wrObj.cFImage(idblock=idblock,
+                    header = self.wrObj.cFImage(idblock=idblock,
                                             year=time.gmtime(self.dataOut.utctime).tm_year,
                                             month=time.gmtime(self.dataOut.utctime).tm_mon,
                                             day=time.gmtime(self.dataOut.utctime).tm_mday,
                                             hour=time.gmtime(self.dataOut.utctime).tm_hour,
                                             minute=time.gmtime(self.dataOut.utctime).tm_min,
                                             second=time.gmtime(self.dataOut.utctime).tm_sec)
-                    c=3E8
+                    c = 3E8
                     deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
-                    freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)*(c/(2*deltaHeight*1000))
+                    freq = numpy.arange(-1 * self.dataOut.nHeights / 2., self.dataOut.nHeights / 2.) * (c / (2 * deltaHeight * 1000))
                     colList = []
-                    colFreq=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
+                    colFreq = self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints) + 'E', array=freq)
                     colList.append(colFreq)
-                    nchannel=self.dataOut.nChannels
+                    nchannel = self.dataOut.nChannels
                     for i in range(nchannel):
-                        col = self.wrObj.writeData(name="PCh"+str(i+1),
+                        col = self.wrObj.writeData(name="PCh" + str(i + 1),
-                                                     format=str(self.dataOut.nFFTPoints)+'E',
+                                                     format=str(self.dataOut.nFFTPoints) + 'E',
-                                                      data=10*numpy.log10(self.dataOut.data_spc[i,:]))
+                                                      data=10 * numpy.log10(self.dataOut.data_spc[i, :]))
                         colList.append(col)
-                    data=self.wrObj.Ctable(colList=colList)
+                    data = self.wrObj.Ctable(colList=colList)
-                    self.wrObj.CFile(header,data)
+                    self.wrObj.CFile(header, data)
                     self.wrObj.wFile(filename)
-                    #update the setFile
+                    # update the setFile
                     self.setFile += 1
                     self.idblock += 1
                     return 1
                 def run(self, dataOut, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, **kwargs)
                         self.isConfig = True
                     self.putData()
-                    return dataOut
  No newline at end of file
+                    return dataOut

schainpy/model/io/jroIO_hf.py +253 -253

             '''
             Created on Jul 3, 2014
             @author: roj-com0419
             '''
-            import os,sys
+            import os, sys
-            import time,datetime
+            import time, datetime
             import h5py
             import numpy
             import fnmatch
             import re
             from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
             from schainpy.model.data.jrodata import Voltage
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             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 )
+                    float(str)
                     return True
                 except:
                     return False
             def getFileFromSet(path, ext, set=None):
                 validFilelist = []
                 fileList = os.listdir(path)
                 if len(fileList) < 1:
                     return None
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     try:
-                        number= int(thisFile[6:16])
+                        number = int(thisFile[6:16])
                  #       year = int(thisFile[1:5])
                  #       doy  = int(thisFile[5:8])
                     except:
                         continue
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 if len(validFilelist) < 1:
                     return None
-                validFilelist = sorted( validFilelist, key=str.lower )
+                validFilelist = sorted(validFilelist, key=str.lower)
                 if set == None:
                     return validFilelist[-1]
-                print("set =" ,set)
+                print("set =" , set)
                 for thisFile in validFilelist:
                     if set <= int(thisFile[6:16]):
-                        print(thisFile,int(thisFile[6:16]))
+                        print(thisFile, int(thisFile[6:16]))
                         return thisFile
                 return validFilelist[-1]
-                myfile = fnmatch.filter(validFilelist,'*%10d*'%(set))
+                myfile = fnmatch.filter(validFilelist, '*%10d*' % (set))
-                #myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
+                # myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
-                if len(myfile)!= 0:
+                if len(myfile) != 0:
                     return myfile[0]
                 else:
-                    filename = '*%10.10d%s'%(set,ext.lower())
+                    filename = '*%10.10d%s' % (set, ext.lower())
-                    print('the filename %s does not exist'%filename)
+                    print('the filename %s does not exist' % filename)
                     print('...going to the last file: ')
                 if validFilelist:
-                    validFilelist = sorted( validFilelist, key=str.lower )
+                    validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def getlastFileFromPath(path, ext):
                 """
             Depura el fileList dejando solo los que cumplan el formato de "res-xxxxxx.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     try:
-                        number= int(thisFile[6:16])
+                        number = int(thisFile[6:16])
                     except:
                         print("There is a file or folder with different format")
                     if not isNumber(number):
                         continue
             #        year = thisFile[1:5]
             #        if not isNumber(year):
             #            continue
             #       doy = thisFile[5:8]
             #        if not isNumber(doy):
             #            continue
-                    number= int(number)
+                    number = int(number)
             #        year = int(year)
             #        doy = int(doy)
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 if validFilelist:
-                    validFilelist = sorted( validFilelist, key=str.lower )
+                    validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             class HFReader(ProcessingUnit):
                 '''
                 classdocs
                 '''
-                path     = None
+                path = None
-                startDate= None
+                startDate = None
-                endDate  = None
+                endDate = None
-                startTime= None
+                startTime = None
-                endTime  = None
+                endTime = None
-                walk     = None
+                walk = None
                 isConfig = False
-                dataOut=None
+                dataOut = None
                 nTries = 3
-                ext      = ".hdf5"
+                ext = ".hdf5"
                 def __init__(self, **kwargs):
                     '''
                     Constructor
                     '''
                     ProcessingUnit.__init__(self, **kwargs)
-                    self.isConfig =False
+                    self.isConfig = False
                     self.datablock = None
-                    self.filename_current=None
+                    self.filename_current = None
                     self.utc = 0
-                    self.ext='.hdf5'
+                    self.ext = '.hdf5'
                     self.flagIsNewFile = 1
                     #-------------------------------------------------
-                    self.fileIndex=None
+                    self.fileIndex = None
-                    self.profileIndex_offset=None
+                    self.profileIndex_offset = None
-                    self.filenameList=[]
+                    self.filenameList = []
-                    self.hfFilePointer= None
+                    self.hfFilePointer = None
                     self.filename_online = None
-                    self.status=True
+                    self.status = True
-                    self.flagNoMoreFiles= False
+                    self.flagNoMoreFiles = False
                     self.__waitForNewFile = 20
                     #--------------------------------------------------
                     self.dataOut = self.createObjByDefault()
                 def createObjByDefault(self):
                     dataObj = Voltage()
                     return dataObj
                 def setObjProperties(self):
                     pass
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.blocksize
                     Return:
                         None
                     """
-                    pts2read =self.nChannels*self.nHeights*self.nProfiles
+                    pts2read = self.nChannels * self.nHeights * self.nProfiles
                     self.blocksize = pts2read
                 def __readHeader(self):
                     self.nProfiles = 100
                     self.nHeights = 1000
                     self.nChannels = 2
-                    self.__firstHeigth=0
+                    self.__firstHeigth = 0
-                    self.__nSamples=1000
+                    self.__nSamples = 1000
-                    self.__deltaHeigth=1.5
+                    self.__deltaHeigth = 1.5
-                    self.__sample_rate=1e5
+                    self.__sample_rate = 1e5
-                    #self.__frequency=2.72e6
+                    # self.__frequency=2.72e6
-                    #self.__frequency=3.64e6
+                    # self.__frequency=3.64e6
-                    self.__frequency=None
+                    self.__frequency = None
                     self.__online = False
-                    self.filename_next_set=None
+                    self.filename_next_set = None
-                    #print "Frequency of Operation:", self.__frequency
+                    # print "Frequency of Operation:", self.__frequency
-                def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
+                def __setParameters(self, path='', startDate='', endDate='', startTime='', endTime='', walk=''):
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.walk = walk
                 def __checkPath(self):
                     if os.path.exists(self.path):
-                        self.status=1
+                        self.status = 1
                     else:
-                        self.status=0
+                        self.status = 0
-                        print('Path %s does not exits'%self.path)
+                        print('Path %s does not exits' % self.path)
                         return
                     return
                 def __selDates(self, hf_dirname_format):
                     try:
-                        dir_hf_filename= self.path+"/"+hf_dirname_format
+                        dir_hf_filename = self.path + "/" + hf_dirname_format
-                        fp= h5py.File(dir_hf_filename,'r')
+                        fp = h5py.File(dir_hf_filename, 'r')
-                        hipoc=fp['t'].value
+                        hipoc = fp['t'].value
                         fp.close()
-                        date_time=datetime.datetime.utcfromtimestamp(hipoc)
+                        date_time = datetime.datetime.utcfromtimestamp(hipoc)
-                        year =int(date_time[0:4])
+                        year = int(date_time[0:4])
-                        month=int(date_time[5:7])
+                        month = int(date_time[5:7])
-                        dom  =int(date_time[8:10])
+                        dom = int(date_time[8:10])
-                        thisDate= datetime.date(year,month,dom)
+                        thisDate = datetime.date(year, month, dom)
-                        if (thisDate>=self.startDate and thisDate <= self.endDate):
+                        if (thisDate >= self.startDate and thisDate <= self.endDate):
                             return hf_dirname_format
                     except:
                         return None
-                def __findDataForDates(self,online=False):
+                def __findDataForDates(self, online=False):
                     if not(self.status):
                         return None
                     pat = '\d+.\d+'
-                    dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
+                    dirnameList = [re.search(pat, x) for x in os.listdir(self.path)]
-                    dirnameList = [x for x in dirnameList if x!=None]
+                    dirnameList = [x for x in dirnameList if x != None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = [x for x in dirnameList if x!=None]
+                        dirnameList = [x for x in dirnameList if x != None]
-                    if len(dirnameList)>0:
+                    if len(dirnameList) > 0:
                             self.status = 1
                             self.dirnameList = dirnameList
                             self.dirnameList.sort()
                     else:
                         self.status = 0
                         return None
                 def __getTimeFromData(self):
-                    startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
+                    startDateTime_Reader = datetime.datetime.combine(self.startDate, self.startTime)
-                    endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
+                    endDateTime_Reader = datetime.datetime.combine(self.endDate, self.endTime)
-                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
+                    print('Filtering Files from %s to %s' % (startDateTime_Reader, endDateTime_Reader))
                     print('........................................')
-                    filter_filenameList=[]
+                    filter_filenameList = []
                     self.filenameList.sort()
-                    for i in range(len(self.filenameList)-1):
+                    for i in range(len(self.filenameList) - 1):
-                        filename=self.filenameList[i]
+                        filename = self.filenameList[i]
-                        dir_hf_filename= filename
+                        dir_hf_filename = filename
-                        fp= h5py.File(dir_hf_filename,'r')
+                        fp = h5py.File(dir_hf_filename, 'r')
-                        hipoc=fp['t'].value
+                        hipoc = fp['t'].value
-                        hipoc=hipoc+self.timezone
+                        hipoc = hipoc + self.timezone
-                        date_time=datetime.datetime.utcfromtimestamp(hipoc)
+                        date_time = datetime.datetime.utcfromtimestamp(hipoc)
                         fp.close()
-                        year =int(date_time[0:4])
+                        year = int(date_time[0:4])
-                        month=int(date_time[5:7])
+                        month = int(date_time[5:7])
-                        dom  =int(date_time[8:10])
+                        dom = int(date_time[8:10])
-                        hour =int(date_time[11:13])
+                        hour = int(date_time[11:13])
-                        min  =int(date_time[14:16])
+                        min = int(date_time[14:16])
-                        sec  =int(date_time[17:19])
+                        sec = int(date_time[17:19])
-                        this_time=datetime.datetime(year,month,dom,hour,min,sec)
+                        this_time = datetime.datetime(year, month, dom, hour, min, sec)
-                        if (this_time>=startDateTime_Reader and this_time <= endDateTime_Reader):
+                        if (this_time >= startDateTime_Reader and this_time <= endDateTime_Reader):
                             filter_filenameList.append(filename)
                     filter_filenameList.sort()
                     self.filenameList = filter_filenameList
                     return 1
                 def __getFilenameList(self):
-                    #print "hola"
+                    # print "hola"
-                    #print self.dirnameList
+                    # print self.dirnameList
-                    dirList = [os.path.join(self.path,x) for x in self.dirnameList]
+                    dirList = [os.path.join(self.path, x) for x in self.dirnameList]
-                    self.filenameList= dirList
+                    self.filenameList = dirList
-                    #print self.filenameList
+                    # print self.filenameList
-                    #print "pase",len(self.filenameList)
+                    # print "pase",len(self.filenameList)
                 def __selectDataForTimes(self, online=False):
                     if not(self.status):
                         return None
                     #----------------
                     self.__getFilenameList()
                     #----------------
                     if not(online):
                         if not(self.all):
                             self.__getTimeFromData()
-                        if len(self.filenameList)>0:
+                        if len(self.filenameList) > 0:
-                            self.status=1
+                            self.status = 1
                             self.filenameList.sort()
                         else:
-                            self.status=0
+                            self.status = 0
                             return None
                     else:
                         if self.set != None:
-                            filename=getFileFromSet(self.path,self.ext,self.set)
+                            filename = getFileFromSet(self.path, self.ext, self.set)
-                            if self.flag_nextfile==True:
+                            if self.flag_nextfile == True:
-                                self.dirnameList=[filename]
+                                self.dirnameList = [filename]
-                                fullfilename=self.path+"/"+filename
+                                fullfilename = self.path + "/" + filename
-                                self.filenameList=[fullfilename]
+                                self.filenameList = [fullfilename]
-                                self.filename_next_set=int(filename[6:16])+10
+                                self.filename_next_set = int(filename[6:16]) + 10
-                                self.flag_nextfile=False
+                                self.flag_nextfile = False
                             else:
                                 print(filename)
                                 print("PRIMERA CONDICION")
-                                #if self.filename_next_set== int(filename[6:16]):
+                                # if self.filename_next_set== int(filename[6:16]):
                                 print("TODO BIEN")
                                 if filename == None:
                                     raise ValueError("corregir")
-                                self.dirnameList=[filename]
+                                self.dirnameList = [filename]
-                                fullfilename=self.path+"/"+filename
+                                fullfilename = self.path + "/" + filename
-                                self.filenameList=[fullfilename]
+                                self.filenameList = [fullfilename]
-                                self.filename_next_set=int(filename[6:16])+10
+                                self.filename_next_set = int(filename[6:16]) + 10
-                                print("Setting next file",self.filename_next_set)
+                                print("Setting next file", self.filename_next_set)
-                                self.set=int(filename[6:16])
+                                self.set = int(filename[6:16])
                                 if True:
                                     pass
                                 else:
                                     print("ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO")
                         else:
-                            filename =getlastFileFromPath(self.path,self.ext)
+                            filename = getlastFileFromPath(self.path, self.ext)
-                            if self.flag_nextfile==True:
+                            if self.flag_nextfile == True:
-                                self.dirnameList=[filename]
+                                self.dirnameList = [filename]
-                                fullfilename=self.path+"/"+filename
+                                fullfilename = self.path + "/" + filename
-                                self.filenameList=[self.filenameList[-1]]
+                                self.filenameList = [self.filenameList[-1]]
-                                self.filename_next_set=int(filename[6:16])+10
+                                self.filename_next_set = int(filename[6:16]) + 10
-                                self.flag_nextfile=False
+                                self.flag_nextfile = False
                             else:
-                               filename=getFileFromSet(self.path,self.ext,self.set)
+                               filename = getFileFromSet(self.path, self.ext, self.set)
                                print(filename)
                                print("PRIMERA CONDICION")
-                                #if self.filename_next_set== int(filename[6:16]):
+                                # if self.filename_next_set== int(filename[6:16]):
                                print("TODO BIEN")
                                if filename == None:
                                    raise ValueError("corregir")
-                               self.dirnameList=[filename]
+                               self.dirnameList = [filename]
-                               fullfilename=self.path+"/"+filename
+                               fullfilename = self.path + "/" + filename
-                               self.filenameList=[fullfilename]
+                               self.filenameList = [fullfilename]
-                               self.filename_next_set=int(filename[6:16])+10
+                               self.filename_next_set = int(filename[6:16]) + 10
-                               print("Setting next file",self.filename_next_set)
+                               print("Setting next file", self.filename_next_set)
-                               self.set=int(filename[6:16])
+                               self.set = int(filename[6:16])
                                if True:
                                    pass
                                else:
                                    print("ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO")
                 def searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
                                         ext,
-                                        startTime=datetime.time(0,0,0),
+                                        startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),
+                                        endTime=datetime.time(23, 59, 59),
                                         walk=True):
                     self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
                     self.__checkPath()
                     self.__findDataForDates()
-                    #print self.dirnameList
+                    # print self.dirnameList
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print("%s"% (self.filenameList[i]))
+                        print("%s" % (self.filenameList[i]))
                     return
                 def searchFilesOnLine(self,
                                         path,
-                                        expLabel= "",
+                                        expLabel="",
                                         ext=None,
                                         startDate=None,
                                         endDate=None,
                                         walk=True,
                                         set=None):
                     startDate = datetime.datetime.utcnow().date()
                     endDate = datetime.datetime.utcnow().date()
-                    self.__setParameters(path=path,startDate=startDate,endDate=endDate,walk=walk)
+                    self.__setParameters(path=path, startDate=startDate, endDate=endDate, walk=walk)
                     self.__checkPath()
-                    fullpath=path
+                    fullpath = path
-                    print("%s folder was found: " %(fullpath ))
+                    print("%s folder was found: " % (fullpath))
                     if set == None:
-                        self.set=None
+                        self.set = None
-                        filename =getlastFileFromPath(fullpath,ext)
+                        filename = getlastFileFromPath(fullpath, ext)
-                        startDate= datetime.datetime.utcnow().date
+                        startDate = datetime.datetime.utcnow().date
-                        endDate= datetime.datetime.utcnow().date()
+                        endDate = datetime.datetime.utcnow().date()
             #
                     else:
-                        filename= getFileFromSet(fullpath,ext,set)
+                        filename = getFileFromSet(fullpath, ext, set)
-                        startDate=None
+                        startDate = None
-                        endDate=None
+                        endDate = None
             #
                     if not (filename):
-                        return None,None,None,None,None
+                        return None, None, None, None, None
-                    #print "%s file was found" %(filename)
+                    # print "%s file was found" %(filename)
             #
             #         dir_hf_filename= self.path+"/"+filename
             #         fp= h5py.File(dir_hf_filename,'r')
             #         hipoc=fp['t'].value
             #         fp.close()
             #         date_time=datetime.datetime.utcfromtimestamp(hipoc)
             #
             #         year =int(date_time[0:4])
             #         month=int(date_time[5:7])
             #         dom  =int(date_time[8:10])
             #         set= int(filename[4:10])
             #         self.set=set-1
-                    #self.dirnameList=[filename]
+                    # self.dirnameList=[filename]
-                    filenameList= fullpath+"/"+filename
+                    filenameList = fullpath + "/" + filename
-                    self.dirnameList=[filename]
+                    self.dirnameList = [filename]
-                    self.filenameList=[filenameList]
+                    self.filenameList = [filenameList]
-                    self.flag_nextfile=True
+                    self.flag_nextfile = True
-                    #self.__findDataForDates(online=True)
+                    # self.__findDataForDates(online=True)
-                    #self.dirnameList=[self.dirnameList[-1]]
+                    # self.dirnameList=[self.dirnameList[-1]]
-                    #print self.dirnameList
+                    # print self.dirnameList
-                    #self.__selectDataForTimes(online=True)
+                    # self.__selectDataForTimes(online=True)
-                    #return fullpath,filename,year,month,dom,set
+                    # return fullpath,filename,year,month,dom,set
                     return
-                def __setNextFile(self,online=False):
+                def __setNextFile(self, online=False):
                     """
                     """
                     if not(online):
                         newFile = self.__setNextFileOffline()
                     else:
                         newFile = self.__setNextFileOnline()
                     if not(newFile):
                         return 0
                     return 1
                 def __setNextFileOffline(self):
                     """
                     """
-                    idFile= self.fileIndex
+                    idFile = self.fileIndex
                     while(True):
                         idFile += 1
                         if not (idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
-                        hfFilePointer =h5py.File(filename,'r')
+                        hfFilePointer = h5py.File(filename, 'r')
-                        epoc=hfFilePointer['t'].value
+                        epoc = hfFilePointer['t'].value
-                        #this_time=datetime.datetime(year,month,dom,hour,min,sec)
+                        # this_time=datetime.datetime(year,month,dom,hour,min,sec)
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.hfFilePointer = hfFilePointer
                     hfFilePointer.close()
-                    self.__t0=epoc
+                    self.__t0 = epoc
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __setNextFileOnline(self):
                     """
                     """
-                    print("SOY NONE",self.set)
+                    print("SOY NONE", self.set)
-                    if self.set==None:
+                    if self.set == None:
                         pass
                     else:
-                        self.set +=10
+                        self.set += 10
-                    filename = self.filenameList[0]#fullfilename
+                    filename = self.filenameList[0]  # fullfilename
                     if self.filename_online != None:
                         self.__selectDataForTimes(online=True)
                         filename = self.filenameList[0]
                         while self.filename_online == filename:
-                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
+                            print('waiting %d seconds to get a new file...' % (self.__waitForNewFile))
                             time.sleep(self.__waitForNewFile)
-                            #self.__findDataForDates(online=True)
+                            # self.__findDataForDates(online=True)
-                            self.set=self.filename_next_set
+                            self.set = self.filename_next_set
                             self.__selectDataForTimes(online=True)
                             filename = self.filenameList[0]
-                            sizeoffile=os.path.getsize(filename)
+                            sizeoffile = os.path.getsize(filename)
-                    #print filename
+                    # print filename
-                    sizeoffile=os.path.getsize(filename)
+                    sizeoffile = os.path.getsize(filename)
-                    if sizeoffile<1670240:
+                    if sizeoffile < 1670240:
-                        print("%s is not the rigth  size"%filename)
+                        print("%s is not the rigth  size" % filename)
-                        delay=50
+                        delay = 50
-                        print('waiting %d seconds for delay...'%(delay))
+                        print('waiting %d seconds for delay...' % (delay))
                         time.sleep(delay)
-                    sizeoffile=os.path.getsize(filename)
+                    sizeoffile = os.path.getsize(filename)
-                    if sizeoffile<1670240:
+                    if sizeoffile < 1670240:
-                        delay=50
+                        delay = 50
-                        print('waiting %d  more seconds for delay...'%(delay))
+                        print('waiting %d  more seconds for delay...' % (delay))
                         time.sleep(delay)
-                    sizeoffile=os.path.getsize(filename)
+                    sizeoffile = os.path.getsize(filename)
-                    if sizeoffile<1670240:
+                    if sizeoffile < 1670240:
-                        delay=50
+                        delay = 50
-                        print('waiting %d  more seconds for delay...'%(delay))
+                        print('waiting %d  more seconds for delay...' % (delay))
                         time.sleep(delay)
                     try:
-                        hfFilePointer=h5py.File(filename,'r')
+                        hfFilePointer = h5py.File(filename, 'r')
                     except:
-                        print("Error reading file %s"%filename)
+                        print("Error reading file %s" % filename)
-                    self.filename_online=filename
+                    self.filename_online = filename
-                    epoc=hfFilePointer['t'].value
+                    epoc = hfFilePointer['t'].value
-                    self.hfFilePointer=hfFilePointer
+                    self.hfFilePointer = hfFilePointer
                     hfFilePointer.close()
-                    self.__t0=epoc
+                    self.__t0 = epoc
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __getExpParameters(self):
                     if not(self.status):
                         return None
                 def setup(self,
-                           path = None,
+                           path=None,
-                           startDate = None,
+                           startDate=None,
-                           endDate = None,
+                           endDate=None,
-                           startTime = datetime.time(0,0,0),
+                           startTime=datetime.time(0, 0, 0),
-                           endTime = datetime.time(23,59,59),
+                           endTime=datetime.time(23, 59, 59),
-                           set = None,
+                           set=None,
-                           expLabel = "",
+                           expLabel="",
-                           ext = None,
+                           ext=None,
                            all=0,
                            timezone=0,
-                           online = False,
+                           online=False,
-                           delay = 60,
+                           delay=60,
-                           walk = True):
+                           walk=True):
                     '''
                     In this method we should set all initial parameters.
                     '''
-                    if path==None:
+                    if path == None:
                         raise ValueError("The path is not valid")
-                    if ext==None:
+                    if ext == None:
                         ext = self.ext
-                    self.timezone= timezone
+                    self.timezone = timezone
-                    self.online= online
+                    self.online = online
-                    self.all=all
+                    self.all = all
-                    #if set==None:
+                    # if set==None:
-                    #print set
+                    # print set
                     if not(online):
                         print("Searching files in offline mode...")
                         self.searchFilesOffLine(path, startDate, endDate, ext, startTime, endTime, walk)
                     else:
                         print("Searching files in online mode...")
-                        self.searchFilesOnLine(path, walk,ext,set=set)
+                        self.searchFilesOnLine(path, walk, ext, set=set)
-                        if set==None:
+                        if set == None:
                             pass
                         else:
-                            self.set=set-10
+                            self.set = set - 10
             #             for nTries in range(self.nTries):
             #
             #                 fullpath,file,year,month,day,set = self.searchFilesOnLine(path=path,expLabel=expLabel,ext=ext, walk=walk,set=set)
             #
             #                 if fullpath:
             #                     break
             #                 print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
             #                 time.sleep(self.delay)
             #             if not(fullpath):
             #                 print "There ins't valid files in %s" % path
             #                 return None
                     if not(self.filenameList):
-                        print("There  is no files into the folder: %s"%(path))
+                        print("There  is no files into the folder: %s" % (path))
                         sys.exit(-1)
                     self.__getExpParameters()
                     self.fileIndex = -1
                     self.__setNextFile(online)
                     self.__readMetadata()
                     self.__setLocalVariables()
                     self.__setHeaderDO()
-                    #self.profileIndex_offset= 0
+                    # self.profileIndex_offset= 0
-                    #self.profileIndex = self.profileIndex_offset
+                    # self.profileIndex = self.profileIndex_offset
                     self.isConfig = True
                 def __readMetadata(self):
                     self.__readHeader()
                 def __setLocalVariables(self):
-                    self.datablock = numpy.zeros((self.nChannels, self.nHeights,self.nProfiles), dtype = numpy.complex)
+                    self.datablock = numpy.zeros((self.nChannels, self.nHeights, self.nProfiles), dtype=numpy.complex)
                     #
                     self.profileIndex = 9999
                 def __setHeaderDO(self):
                     self.dataOut.radarControllerHeaderObj = RadarControllerHeader()
                     self.dataOut.systemHeaderObj = SystemHeader()
                     #---------------------------------------------------------
-                    self.dataOut.systemHeaderObj.nProfiles=100
+                    self.dataOut.systemHeaderObj.nProfiles = 100
-                    self.dataOut.systemHeaderObj.nSamples=1000
+                    self.dataOut.systemHeaderObj.nSamples = 1000
-                    SAMPLING_STRUCTURE=[('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')]
+                    SAMPLING_STRUCTURE = [('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')]
-                    self.dataOut.radarControllerHeaderObj.samplingWindow=numpy.zeros((1,),SAMPLING_STRUCTURE)
+                    self.dataOut.radarControllerHeaderObj.samplingWindow = numpy.zeros((1,), SAMPLING_STRUCTURE)
-                    self.dataOut.radarControllerHeaderObj.samplingWindow['h0']=0
+                    self.dataOut.radarControllerHeaderObj.samplingWindow['h0'] = 0
-                    self.dataOut.radarControllerHeaderObj.samplingWindow['dh']=1.5
+                    self.dataOut.radarControllerHeaderObj.samplingWindow['dh'] = 1.5
-                    self.dataOut.radarControllerHeaderObj.samplingWindow['nsa']=1000
+                    self.dataOut.radarControllerHeaderObj.samplingWindow['nsa'] = 1000
-                    self.dataOut.radarControllerHeaderObj.nHeights=int(self.dataOut.radarControllerHeaderObj.samplingWindow['nsa'])
+                    self.dataOut.radarControllerHeaderObj.nHeights = int(self.dataOut.radarControllerHeaderObj.samplingWindow['nsa'])
                     self.dataOut.radarControllerHeaderObj.firstHeight = self.dataOut.radarControllerHeaderObj.samplingWindow['h0']
                     self.dataOut.radarControllerHeaderObj.deltaHeight = self.dataOut.radarControllerHeaderObj.samplingWindow['dh']
                     self.dataOut.radarControllerHeaderObj.samplesWin = self.dataOut.radarControllerHeaderObj.samplingWindow['nsa']
-                    self.dataOut.radarControllerHeaderObj.nWindows=1
+                    self.dataOut.radarControllerHeaderObj.nWindows = 1
-                    self.dataOut.radarControllerHeaderObj.codetype=0
+                    self.dataOut.radarControllerHeaderObj.codetype = 0
-                    self.dataOut.radarControllerHeaderObj.numTaus=0
+                    self.dataOut.radarControllerHeaderObj.numTaus = 0
-                    #self.dataOut.radarControllerHeaderObj.Taus = numpy.zeros((1,),'<f4')
+                    # self.dataOut.radarControllerHeaderObj.Taus = numpy.zeros((1,),'<f4')
-                    #self.dataOut.radarControllerHeaderObj.nCode=numpy.zeros((1,), '<u4')
+                    # self.dataOut.radarControllerHeaderObj.nCode=numpy.zeros((1,), '<u4')
-                    #self.dataOut.radarControllerHeaderObj.nBaud=numpy.zeros((1,), '<u4')
+                    # self.dataOut.radarControllerHeaderObj.nBaud=numpy.zeros((1,), '<u4')
-                    #self.dataOut.radarControllerHeaderObj.code=numpy.zeros(0)
+                    # self.dataOut.radarControllerHeaderObj.code=numpy.zeros(0)
-                    self.dataOut.radarControllerHeaderObj.code_size=0
+                    self.dataOut.radarControllerHeaderObj.code_size = 0
-                    self.dataOut.nBaud=0
+                    self.dataOut.nBaud = 0
-                    self.dataOut.nCode=0
+                    self.dataOut.nCode = 0
-                    self.dataOut.nPairs=0
+                    self.dataOut.nPairs = 0
                     #---------------------------------------------------------
                     self.dataOut.type = "Voltage"
                     self.dataOut.data = None
-                    self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
+                    self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     self.dataOut.nProfiles = 1
-                    self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
+                    self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype=numpy.float) * self.__deltaHeigth
                     self.dataOut.channelList = list(range(self.nChannels))
-                    #self.dataOut.channelIndexList = None
+                    # self.dataOut.channelIndexList = None
                     self.dataOut.flagNoData = True
-                    #Set to TRUE if the data is discontinuous
+                    # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     self.dataOut.utctime = None
                     self.dataOut.timeZone = self.timezone
                     self.dataOut.dstFlag = 0
                     self.dataOut.errorCount = 0
                     self.dataOut.nCohInt = 1
                     self.dataOut.blocksize = self.dataOut.nChannels * self.dataOut.nHeights
-                    self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
+                    self.dataOut.flagDecodeData = False  # asumo que la data esta decodificada
-                    self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
+                    self.dataOut.flagDeflipData = False  # asumo que la data esta sin flip
                     self.dataOut.flagShiftFFT = False
-                    self.dataOut.ippSeconds = 1.0*self.__nSamples/self.__sample_rate
+                    self.dataOut.ippSeconds = 1.0 * self.__nSamples / self.__sample_rate
-                    #Time interval between profiles
+                    # Time interval between profiles
-                    #self.dataOut.timeInterval =self.dataOut.ippSeconds * self.dataOut.nCohInt
+                    # self.dataOut.timeInterval =self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency = self.__frequency
                     self.dataOut.realtime = self.__online
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.nProfiles:
                         return 1
                     return 0
                 def readNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
                 def __setNewBlock(self):
-                    if self.hfFilePointer==None:
+                    if self.hfFilePointer == None:
                         return 0
                     if self.flagIsNewFile:
                         return 1
                     if self.profileIndex < self.nProfiles:
                         return 1
                     self.__setNextFile(self.online)
                     return 1
                 def readBlock(self):
-                    fp=h5py.File(self.filename,'r')
+                    fp = h5py.File(self.filename, 'r')
-                                  #Puntero que apunta al archivo hdf5
+                                  # Puntero que apunta al archivo hdf5
-                    ch0=(fp['ch0']).value    #Primer canal (100,1000)--(perfiles,alturas)
+                    ch0 = (fp['ch0']).value  # Primer canal (100,1000)--(perfiles,alturas)
-                    ch1=(fp['ch1']).value    #Segundo canal (100,1000)--(perfiles,alturas)
+                    ch1 = (fp['ch1']).value  # Segundo canal (100,1000)--(perfiles,alturas)
                     fp.close()
-                    ch0= ch0.swapaxes(0,1)   #Primer canal (100,1000)--(alturas,perfiles)
+                    ch0 = ch0.swapaxes(0, 1)  # Primer canal (100,1000)--(alturas,perfiles)
-                    ch1= ch1.swapaxes(0,1)   #Segundo canal (100,1000)--(alturas,perfiles)
+                    ch1 = ch1.swapaxes(0, 1)  # Segundo canal (100,1000)--(alturas,perfiles)
-                    self.datablock = numpy.array([ch0,ch1])
+                    self.datablock = numpy.array([ch0, ch1])
-                    self.flagIsNewFile=0
+                    self.flagIsNewFile = 0
-                    self.profileIndex=0
+                    self.profileIndex = 0
                     return 1
                 def getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         return 0
                     if self.__hasNotDataInBuffer():
                         if not(self.readNextBlock()):
-                            self.dataOut.flagNodata=True
+                            self.dataOut.flagNodata = True
                             return 0
                     ##############################
                     ##############################
-                    self.dataOut.data = self.datablock[:,:,self.profileIndex]
+                    self.dataOut.data = self.datablock[:, :, self.profileIndex]
-                    self.dataOut.utctime = self.__t0 + self.dataOut.ippSeconds*self.profileIndex
+                    self.dataOut.utctime = self.__t0 + self.dataOut.ippSeconds * self.profileIndex
-                    self.dataOut.profileIndex= self.profileIndex
+                    self.dataOut.profileIndex = self.profileIndex
-                    self.dataOut.flagNoData=False
+                    self.dataOut.flagNoData = False
-                    self.profileIndex +=1
+                    self.profileIndex += 1
                     return self.dataOut.data
                 def run(self, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
-                    self.getData()
  No newline at end of file
+                    self.getData()

schainpy/model/io/jroIO_kamisr.py +126 -126

             '''
             Created on Set 9, 2015
             @author: roj-idl71 Karim Kuyeng
             '''
             import os
             import sys
             import glob
             import fnmatch
             import datetime
             import time
             import re
             import h5py
             import numpy
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
             from schainpy.model.data.jrodata import Voltage
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from numpy import imag
             class AMISRReader(ProcessingUnit):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     ProcessingUnit.__init__(self)
                     self.set = None
                     self.subset = None
                     self.extension_file = '.h5'
                     self.dtc_str = 'dtc'
                     self.dtc_id = 0
                     self.status = True
                     self.isConfig = False
                     self.dirnameList = []
                     self.filenameList = []
                     self.fileIndex = None
                     self.flagNoMoreFiles = False
                     self.flagIsNewFile = 0
                     self.filename = ''
                     self.amisrFilePointer = None
                     self.dataset = None
                     self.profileIndex = 0
                     self.beamCodeByFrame = None
                     self.radacTimeByFrame = None
                     self.dataset = None
                     self.__firstFile = True
                     self.buffer = None
                     self.timezone = 'ut'
                     self.__waitForNewFile = 20
                     self.__filename_online = None
-                    #Is really necessary create the output object in the initializer
+                    # Is really necessary create the output object in the initializer
                     self.dataOut = Voltage()
-                def setup(self,path=None,
+                def setup(self, path=None,
                                 startDate=None,
                                 endDate=None,
                                 startTime=None,
                                 endTime=None,
                                 walk=True,
                                 timezone='ut',
                                 all=0,
-                                code = None,
+                                code=None,
-                                nCode = 0,
+                                nCode=0,
-                                nBaud = 0,
+                                nBaud=0,
                                 online=False):
                     self.timezone = timezone
                     self.all = all
                     self.online = online
                     self.code = code
                     self.nCode = int(nCode)
                     self.nBaud = int(nBaud)
-                    #self.findFiles()
+                    # self.findFiles()
                     if not(online):
-                        #Busqueda de archivos offline
+                        # Busqueda de archivos offline
                         self.searchFilesOffLine(path, startDate, endDate, startTime, endTime, walk)
                     else:
-                        self.searchFilesOnLine(path, startDate, endDate, startTime,endTime,walk)
+                        self.searchFilesOnLine(path, startDate, endDate, startTime, endTime, walk)
                     if not(self.filenameList):
-                        print("There is no files into the folder: %s"%(path))
+                        print("There is no files into the folder: %s" % (path))
                         sys.exit(-1)
                     self.fileIndex = -1
                     self.readNextFile(online)
                     '''
                     Add code
                     '''
                     self.isConfig = True
                     pass
-                def readAMISRHeader(self,fp):
+                def readAMISRHeader(self, fp):
                     header = 'Raw11/Data/RadacHeader'
-                    self.beamCodeByPulse = fp.get(header+'/BeamCode') # LIST OF BEAMS PER PROFILE, TO BE USED ON REARRANGE
+                    self.beamCodeByPulse = fp.get(header + '/BeamCode')  # LIST OF BEAMS PER PROFILE, TO BE USED ON REARRANGE
-                    self.beamCode = fp.get('Raw11/Data/Beamcodes') # NUMBER OF CHANNELS AND IDENTIFY POSITION TO CREATE A FILE WITH THAT INFO
+                    self.beamCode = fp.get('Raw11/Data/Beamcodes')  # NUMBER OF CHANNELS AND IDENTIFY POSITION TO CREATE A FILE WITH THAT INFO
-                    #self.code = fp.get(header+'/Code') # NOT USE FOR THIS
+                    # self.code = fp.get(header+'/Code') # NOT USE FOR THIS
-                    self.frameCount = fp.get(header+'/FrameCount')# NOT USE FOR THIS
+                    self.frameCount = fp.get(header + '/FrameCount')  # NOT USE FOR THIS
-                    self.modeGroup = fp.get(header+'/ModeGroup')# NOT USE FOR THIS
+                    self.modeGroup = fp.get(header + '/ModeGroup')  # NOT USE FOR THIS
-                    self.nsamplesPulse = fp.get(header+'/NSamplesPulse')# TO GET NSA OR USING DATA FOR THAT
+                    self.nsamplesPulse = fp.get(header + '/NSamplesPulse')  # TO GET NSA OR USING DATA FOR THAT
-                    self.pulseCount = fp.get(header+'/PulseCount')# NOT USE FOR THIS
+                    self.pulseCount = fp.get(header + '/PulseCount')  # NOT USE FOR THIS
-                    self.radacTime = fp.get(header+'/RadacTime')# 1st TIME ON FILE ANDE CALCULATE THE REST WITH IPP*nindexprofile
+                    self.radacTime = fp.get(header + '/RadacTime')  # 1st TIME ON FILE ANDE CALCULATE THE REST WITH IPP*nindexprofile
-                    self.timeCount = fp.get(header+'/TimeCount')# NOT USE FOR THIS
+                    self.timeCount = fp.get(header + '/TimeCount')  # NOT USE FOR THIS
-                    self.timeStatus = fp.get(header+'/TimeStatus')# NOT USE FOR THIS
+                    self.timeStatus = fp.get(header + '/TimeStatus')  # NOT USE FOR THIS
                     self.rangeFromFile = fp.get('Raw11/Data/Samples/Range')
-                    self.frequency =  fp.get('Rx/Frequency')
+                    self.frequency = fp.get('Rx/Frequency')
                     txAus = fp.get('Raw11/Data/Pulsewidth')
-                    self.nblocks = self.pulseCount.shape[0] #nblocks
+                    self.nblocks = self.pulseCount.shape[0]  # nblocks
-                    self.nprofiles = self.pulseCount.shape[1] #nprofile
+                    self.nprofiles = self.pulseCount.shape[1]  # nprofile
-                    self.nsa = self.nsamplesPulse[0,0] #ngates
+                    self.nsa = self.nsamplesPulse[0, 0]  # ngates
                     self.nchannels = self.beamCode.shape[1]
-                    self.ippSeconds = (self.radacTime[0][1] -self.radacTime[0][0]) #Ipp in seconds
+                    self.ippSeconds = (self.radacTime[0][1] - self.radacTime[0][0])  # Ipp in seconds
-                    #self.__waitForNewFile = self.nblocks  # wait depending on the number of blocks since each block is 1 sec
+                    # self.__waitForNewFile = self.nblocks  # wait depending on the number of blocks since each block is 1 sec
-                    self.__waitForNewFile = self.nblocks * self.nprofiles * self.ippSeconds # wait until new file is created
+                    self.__waitForNewFile = self.nblocks * self.nprofiles * self.ippSeconds  # wait until new file is created
-                    #filling radar controller header parameters
+                    # filling radar controller header parameters
-                    self.__ippKm = self.ippSeconds *.15*1e6 # in km
+                    self.__ippKm = self.ippSeconds * .15 * 1e6  # in km
-                    self.__txA = (txAus.value)*.15 #(ipp[us]*.15km/1us) in km
+                    self.__txA = (txAus.value) * .15  # (ipp[us]*.15km/1us) in km
                     self.__txB = 0
-                    nWindows=1
+                    nWindows = 1
                     self.__nSamples = self.nsa
-                    self.__firstHeight = self.rangeFromFile[0][0]/1000 #in km
+                    self.__firstHeight = self.rangeFromFile[0][0] / 1000  # in km
-                    self.__deltaHeight = (self.rangeFromFile[0][1] - self.rangeFromFile[0][0])/1000
+                    self.__deltaHeight = (self.rangeFromFile[0][1] - self.rangeFromFile[0][0]) / 1000
-                    #for now until understand why the code saved is different (code included even though code not in tuf file)
+                    # for now until understand why the code saved is different (code included even though code not in tuf file)
-                    #self.__codeType = 0
+                    # self.__codeType = 0
                    # self.__nCode = None
                    # self.__nBaud = None
                     self.__code = self.code
                     self.__codeType = 0
                     if self.code != None:
                         self.__codeType = 1
                     self.__nCode = self.nCode
                     self.__nBaud = self.nBaud
-                    #self.__code = 0
+                    # self.__code = 0
-                    #filling system header parameters
+                    # filling system header parameters
                     self.__nSamples = self.nsa
-                    self.newProfiles = self.nprofiles/self.nchannels
+                    self.newProfiles = self.nprofiles / self.nchannels
                     self.__channelList = list(range(self.nchannels))
                     self.__frequency = self.frequency[0][0]
                 def createBuffers(self):
                     pass
-                def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
+                def __setParameters(self, path='', startDate='', endDate='', startTime='', endTime='', walk=''):
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.walk = walk
                 def __checkPath(self):
                     if os.path.exists(self.path):
                         self.status = 1
                     else:
                         self.status = 0
-                        print('Path:%s does not exists'%self.path)
+                        print('Path:%s does not exists' % self.path)
                     return
                 def __selDates(self, amisr_dirname_format):
                     try:
                         year = int(amisr_dirname_format[0:4])
                         month = int(amisr_dirname_format[4:6])
                         dom = int(amisr_dirname_format[6:8])
-                        thisDate = datetime.date(year,month,dom)
+                        thisDate = datetime.date(year, month, dom)
-                        if (thisDate>=self.startDate and thisDate <= self.endDate):
+                        if (thisDate >= self.startDate and thisDate <= self.endDate):
                             return amisr_dirname_format
                     except:
                         return None
-                def __findDataForDates(self,online=False):
+                def __findDataForDates(self, online=False):
                     if not(self.status):
                         return None
                     pat = '\d+.\d+'
-                    dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
+                    dirnameList = [re.search(pat, x) for x in os.listdir(self.path)]
-                    dirnameList = [x for x in dirnameList if x!=None]
+                    dirnameList = [x for x in dirnameList if x != None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = [x for x in dirnameList if x!=None]
+                        dirnameList = [x for x in dirnameList if x != None]
-                    if len(dirnameList)>0:
+                    if len(dirnameList) > 0:
                         self.status = 1
                         self.dirnameList = dirnameList
                         self.dirnameList.sort()
                     else:
                         self.status = 0
                         return None
                 def __getTimeFromData(self):
-                    startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
+                    startDateTime_Reader = datetime.datetime.combine(self.startDate, self.startTime)
-                    endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
+                    endDateTime_Reader = datetime.datetime.combine(self.endDate, self.endTime)
-                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
+                    print('Filtering Files from %s to %s' % (startDateTime_Reader, endDateTime_Reader))
                     print('........................................')
                     filter_filenameList = []
                     self.filenameList.sort()
-                    #for i in range(len(self.filenameList)-1):
+                    # for i in range(len(self.filenameList)-1):
                     for i in range(len(self.filenameList)):
                         filename = self.filenameList[i]
-                        fp = h5py.File(filename,'r')
+                        fp = h5py.File(filename, 'r')
                         time_str = fp.get('Time/RadacTimeString')
                         startDateTimeStr_File = time_str[0][0].split('.')[0]
                         junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                        startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                        startDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                         endDateTimeStr_File = time_str[-1][-1].split('.')[0]
                         junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                        endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                        endDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                         fp.close()
                         if self.timezone == 'lt':
-                            startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
+                            startDateTime_File = startDateTime_File - datetime.timedelta(minutes=300)
-                            endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300)
+                            endDateTime_File = endDateTime_File - datetime.timedelta(minutes=300)
-                        if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader):
+                        if (endDateTime_File >= startDateTime_Reader and endDateTime_File < endDateTime_Reader):
-                            #self.filenameList.remove(filename)
+                            # self.filenameList.remove(filename)
                             filter_filenameList.append(filename)
-                        if (endDateTime_File>=endDateTime_Reader):
+                        if (endDateTime_File >= endDateTime_Reader):
                             break
                     filter_filenameList.sort()
                     self.filenameList = filter_filenameList
                     return 1
                 def __filterByGlob1(self, dirName):
-                    filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
+                    filter_files = glob.glob1(dirName, '*.*%s' % self.extension_file)
                     filter_files.sort()
                     filterDict = {}
                     filterDict.setdefault(dirName)
                     filterDict[dirName] = filter_files
                     return filterDict
                 def __getFilenameList(self, fileListInKeys, dirList):
                     for value in fileListInKeys:
                         dirName = list(value.keys())[0]
                         for file in value[dirName]:
                             filename = os.path.join(dirName, file)
                             self.filenameList.append(filename)
                 def __selectDataForTimes(self, online=False):
-                    #aun no esta implementado el filtro for tiempo
+                    # aun no esta implementado el filtro for tiempo
                     if not(self.status):
                         return None
-                    dirList = [os.path.join(self.path,x) for x in self.dirnameList]
+                    dirList = [os.path.join(self.path, x) for x in self.dirnameList]
                     fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
                     self.__getFilenameList(fileListInKeys, dirList)
                     if not(online):
-                        #filtro por tiempo
+                        # filtro por tiempo
                         if not(self.all):
                             self.__getTimeFromData()
-                        if len(self.filenameList)>0:
+                        if len(self.filenameList) > 0:
                             self.status = 1
                             self.filenameList.sort()
                         else:
                             self.status = 0
                             return None
                     else:
-                        #get the last file - 1
+                        # get the last file - 1
                         self.filenameList = [self.filenameList[-2]]
                     new_dirnameList = []
                     for dirname in self.dirnameList:
                         junk = numpy.array([dirname in x for x in self.filenameList])
                         junk_sum = junk.sum()
                         if junk_sum > 0:
                             new_dirnameList.append(dirname)
                     self.dirnameList = new_dirnameList
                     return 1
-                def searchFilesOnLine(self, path, startDate, endDate, startTime=datetime.time(0,0,0),
+                def searchFilesOnLine(self, path, startDate, endDate, startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),walk=True):
+                                        endTime=datetime.time(23, 59, 59), walk=True):
-                    if endDate ==None:
+                    if endDate == None:
                      startDate = datetime.datetime.utcnow().date()
                      endDate = datetime.datetime.utcnow().date()
-                    self.__setParameters(path=path, startDate=startDate, endDate=endDate,startTime = startTime,endTime=endTime, walk=walk)
+                    self.__setParameters(path=path, startDate=startDate, endDate=endDate, startTime=startTime, endTime=endTime, walk=walk)
                     self.__checkPath()
                     self.__findDataForDates(online=True)
                     self.dirnameList = [self.dirnameList[-1]]
                     self.__selectDataForTimes(online=True)
                     return
                 def searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
-                                        startTime=datetime.time(0,0,0),
+                                        startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),
+                                        endTime=datetime.time(23, 59, 59),
                                         walk=True):
                     self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
                     self.__checkPath()
                     self.__findDataForDates()
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print("%s" %(self.filenameList[i]))
+                        print("%s" % (self.filenameList[i]))
                     return
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
-                        amisrFilePointer = h5py.File(filename,'r')
+                        amisrFilePointer = h5py.File(filename, 'r')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.amisrFilePointer = amisrFilePointer
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __setNextFileOnline(self):
                     filename = self.filenameList[0]
                     if self.__filename_online != None:
                         self.__selectDataForTimes(online=True)
                         filename = self.filenameList[0]
                         wait = 0
                         while self.__filename_online == filename:
-                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
+                            print('waiting %d seconds to get a new file...' % (self.__waitForNewFile))
                             if wait == 5:
                                 return 0
                             sleep(self.__waitForNewFile)
                             self.__selectDataForTimes(online=True)
                             filename = self.filenameList[0]
                             wait += 1
                     self.__filename_online = filename
-                    self.amisrFilePointer = h5py.File(filename,'r')
+                    self.amisrFilePointer = h5py.File(filename, 'r')
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def readData(self):
                     buffer = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
-                    re = buffer[:,:,:,0]
+                    re = buffer[:, :, :, 0]
-                    im = buffer[:,:,:,1]
+                    im = buffer[:, :, :, 1]
-                    dataset = re + im*1j
+                    dataset = re + im * 1j
                     self.radacTime = self.amisrFilePointer.get('Raw11/Data/RadacHeader/RadacTime')
-                    timeset = self.radacTime[:,0]
+                    timeset = self.radacTime[:, 0]
-                    return dataset,timeset
+                    return dataset, timeset
                 def reshapeData(self):
-                #self.beamCodeByPulse, self.beamCode, self.nblocks, self.nprofiles, self.nsa,
+                # self.beamCodeByPulse, self.beamCode, self.nblocks, self.nprofiles, self.nsa,
-                    channels = self.beamCodeByPulse[0,:]
+                    channels = self.beamCodeByPulse[0, :]
                     nchan = self.nchannels
-                    #self.newProfiles = self.nprofiles/nchan #must be defined on filljroheader
+                    # self.newProfiles = self.nprofiles/nchan #must be defined on filljroheader
                     nblocks = self.nblocks
                     nsamples = self.nsa
-                    #Dimensions : nChannels, nProfiles, nSamples
+                    # Dimensions : nChannels, nProfiles, nSamples
                     new_block = numpy.empty((nblocks, nchan, self.newProfiles, nsamples), dtype="complex64")
                     ############################################
                     for thisChannel in range(nchan):
-                        new_block[:,thisChannel,:,:] = self.dataset[:,numpy.where(channels==self.beamCode[0][thisChannel])[0],:]
+                        new_block[:, thisChannel, :, :] = self.dataset[:, numpy.where(channels == self.beamCode[0][thisChannel])[0], :]
-                    new_block = numpy.transpose(new_block, (1,0,2,3))
+                    new_block = numpy.transpose(new_block, (1, 0, 2, 3))
-                    new_block = numpy.reshape(new_block, (nchan,-1, nsamples))
+                    new_block = numpy.reshape(new_block, (nchan, -1, nsamples))
                     return new_block
                 def updateIndexes(self):
                     pass
                 def fillJROHeader(self):
-                    #fill radar controller header
+                    # fill radar controller header
                     self.dataOut.radarControllerHeaderObj = RadarControllerHeader(ippKm=self.__ippKm,
                                                                                   txA=self.__txA,
                                                                                   txB=0,
                                                                                   nWindows=1,
                                                                                   nHeights=self.__nSamples,
                                                                                   firstHeight=self.__firstHeight,
                                                                                   deltaHeight=self.__deltaHeight,
                                                                                   codeType=self.__codeType,
                                                                                   nCode=self.__nCode, nBaud=self.__nBaud,
-                                                                                  code = self.__code,
+                                                                                  code=self.__code,
                                                                                   fClock=1)
-                    #fill system header
+                    # fill system header
                     self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
                                                                 nProfiles=self.newProfiles,
                                                                 nChannels=len(self.__channelList),
                                                                 adcResolution=14,
                                                                 pciDioBusWith=32)
                     self.dataOut.type = "Voltage"
                     self.dataOut.data = None
-                    self.dataOut.dtype = numpy.dtype([('real','<i8'),('imag','<i8')])
+                    self.dataOut.dtype = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
             #        self.dataOut.nChannels = 0
             #        self.dataOut.nHeights = 0
-                    self.dataOut.nProfiles = self.newProfiles*self.nblocks
+                    self.dataOut.nProfiles = self.newProfiles * self.nblocks
-                    #self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
+                    # self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
-                    ranges = numpy.reshape(self.rangeFromFile.value,(-1))
+                    ranges = numpy.reshape(self.rangeFromFile.value, (-1))
-                    self.dataOut.heightList =  ranges/1000.0 #km
+                    self.dataOut.heightList = ranges / 1000.0  # km
                     self.dataOut.channelList = self.__channelList
                     self.dataOut.blocksize = self.dataOut.nChannels * self.dataOut.nHeights
             #        self.dataOut.channelIndexList = None
                     self.dataOut.flagNoData = True
-                    #Set to TRUE if the data is discontinuous
+                    # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     self.dataOut.utctime = None
-                    #self.dataOut.timeZone = -5 #self.__timezone/60  #timezone like jroheader, difference in minutes between UTC and localtime
+                    # self.dataOut.timeZone = -5 #self.__timezone/60  #timezone like jroheader, difference in minutes between UTC and localtime
                     if self.timezone == 'lt':
-                        self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes
+                        self.dataOut.timeZone = time.timezone / 60.  # get the timezone in minutes
                     else:
-                        self.dataOut.timeZone = 0 #by default time is UTC
+                        self.dataOut.timeZone = 0  # by default time is UTC
                     self.dataOut.dstFlag = 0
                     self.dataOut.errorCount = 0
                     self.dataOut.nCohInt = 1
-                    self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
+                    self.dataOut.flagDecodeData = False  # asumo que la data esta decodificada
-                    self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
+                    self.dataOut.flagDeflipData = False  # asumo que la data esta sin flip
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.ippSeconds = self.ippSeconds
-                    #Time interval between profiles
+                    # Time interval between profiles
-                    #self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
+                    # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency = self.__frequency
                     self.dataOut.realtime = self.online
                     pass
-                def readNextFile(self,online=False):
+                def readNextFile(self, online=False):
                     if not(online):
                         newFile = self.__setNextFileOffline()
                     else:
                         newFile = self.__setNextFileOnline()
                     if not(newFile):
                         return 0
-                    #if self.__firstFile:
+                    # if self.__firstFile:
                     self.readAMISRHeader(self.amisrFilePointer)
                     self.createBuffers()
                     self.fillJROHeader()
-                    #self.__firstFile = False
+                    # self.__firstFile = False
-                    self.dataset,self.timeset = self.readData()
+                    self.dataset, self.timeset = self.readData()
-                    if self.endDate!=None:
+                    if self.endDate != None:
-                     endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
+                     endDateTime_Reader = datetime.datetime.combine(self.endDate, self.endTime)
                      time_str = self.amisrFilePointer.get('Time/RadacTimeString')
                      startDateTimeStr_File = time_str[0][0].split('.')[0]
                      junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                     startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                     startDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                      if self.timezone == 'lt':
-                      startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
+                      startDateTime_File = startDateTime_File - datetime.timedelta(minutes=300)
-                     if (startDateTime_File>endDateTime_Reader):
+                     if (startDateTime_File > endDateTime_Reader):
                          return 0
                     self.jrodataset = self.reshapeData()
                     #----self.updateIndexes()
                     self.profileIndex = 0
                     return 1
                 def __hasNotDataInBuffer(self):
-                    if self.profileIndex >= (self.newProfiles*self.nblocks):
+                    if self.profileIndex >= (self.newProfiles * self.nblocks):
                         return 1
                     return 0
                 def getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         return 0
                     if self.__hasNotDataInBuffer():
                         if not (self.readNextFile(self.online)):
                             return 0
-                    if self.dataset is None: # setear esta condicion cuando no hayan datos por leers
+                    if self.dataset is None:  # setear esta condicion cuando no hayan datos por leers
                         self.dataOut.flagNoData = True
                         return 0
-                    #self.dataOut.data = numpy.reshape(self.jrodataset[self.profileIndex,:],(1,-1))
+                    # self.dataOut.data = numpy.reshape(self.jrodataset[self.profileIndex,:],(1,-1))
-                    self.dataOut.data = self.jrodataset[:,self.profileIndex,:]
+                    self.dataOut.data = self.jrodataset[:, self.profileIndex, :]
-                    #self.dataOut.utctime = self.jrotimeset[self.profileIndex]
+                    # self.dataOut.utctime = self.jrotimeset[self.profileIndex]
-                    #verificar basic header de jro data y ver si es compatible con este valor
+                    # verificar basic header de jro data y ver si es compatible con este valor
-                    #self.dataOut.utctime = self.timeset + (self.profileIndex * self.ippSeconds * self.nchannels)
+                    # self.dataOut.utctime = self.timeset + (self.profileIndex * self.ippSeconds * self.nchannels)
                     indexprof = numpy.mod(self.profileIndex, self.newProfiles)
-                    indexblock = self.profileIndex/self.newProfiles
+                    indexblock = self.profileIndex / self.newProfiles
-                    #print indexblock, indexprof
+                    # print indexblock, indexprof
                     self.dataOut.utctime = self.timeset[indexblock] + (indexprof * self.ippSeconds * self.nchannels)
                     self.dataOut.profileIndex = self.profileIndex
                     self.dataOut.flagNoData = False
             #         if indexprof == 0:
             #             print self.dataOut.utctime
                     self.profileIndex += 1
                     return self.dataOut.data
                 def run(self, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()

schainpy/model/io/jroIO_madrigal.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/jroIO_matlab.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/jroIO_mira35c.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/jroIO_param.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/jroIO_simulator.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/jroIO_spectra.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/jroIO_usrp.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/jroIO_usrp_api.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/jroIO_voltage.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/julIO_param.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/io/pxIO_param.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/bltrproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_amisr.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_base.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_correlation.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_heispectra.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_spectra.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_spectra_acf.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_spectra_lags.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_voltage.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/pxproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/utils/jroutils_ftp.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/utils/jroutils_publish.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/utils/scp.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/JASMET30_MetDet.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/JASMET30_PhaseCal.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/JASMET30_Winds.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/PPD.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/USRP_PLOT_THOR.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/julia_mp.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/optimun_offset.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/pedestal_client.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/pedestal_server.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_001.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_002.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0001.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim00010.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0002.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0003.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0004.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0005.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0006.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0007.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0008.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0009.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/wr_integrador.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

setup.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages