schain-jc Commit - r1063:ecbe1f26c35b

merge with v2.3

jespinoza -

r1063:ecbe1f26c35b

parent child

Context file:

r1063:ecbe1f26c35b

Expand all files

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

schainpy/CHANGELOG.md created 644 +109 0

@@ -0,0 +1,109
	1	## CHANGELOG:
	2
	3	### 2.3
	4	* Added high order function `multiSchain` for multiprocessing scripts.
	5	* Added two new Processing Units `PublishData` and `ReceiverData` for receiving and sending dataOut through multiple ways (tcp, ipc, inproc).
	6	* Added a new graphics Processing Unit `PlotterReceiver`. It is decoupled from normal processing sequence with support for data generated by multiprocessing scripts.
	7	* Added support for sending realtime graphic to web server.
	8	* GUI command `schain` is now `schainGUI`.
	9	* Added a CLI tool named `schain`.
	10	* Scripts templates can be now generated with `schain generate`.
	11	* Now it is possible to search Processing Units and Operations with `schain search [module]` to get the right name and its allowed parameters.
	12	* `schain xml` to run xml scripts.
	13	* Added suggestions when parameters are poorly written.
	14	* `Controller.start()` now runs in a different process than the process calling it.
	15	* Added `schainpy.utils.log` for log standarization.
	16	* Running script on online mode no longer ignores date and hour. Issue #1109.
	17	* Added support for receving voltage data directly from JARS (tcp, ipc).
	18	* Updated README for MAC OS GUI installation.
	19	* Setup now installs numpy.
	20
	21	### 2.2.6
	22	* Graphics generated by the GUI are now the same as generated by scripts. Issue #1074.
	23	* Added support for C extensions.
	24	* function `hildebrand_sehkon` optimized with a C wrapper.
	25	* Numpy version updated.
	26	* Migration to GIT.
	27
	28	### 2.2.5:
	29	* splitProfiles and combineProfiles modules were added to VoltageProc and Signal Chain GUI.
	30	* nProfiles of USRP data (hdf5) is the number of profiles thera are in one second.
	31	* jroPlotter works directly with data objects instead of dictionaries
	32	* script "schain" was added to Signal Chain installer
	33
	34	### 2.2.4.1:
	35	* jroIO_usrp.py is update to read Sandra's data
	36	* decimation in Spectra and RTI plots is always enabled.
	37	* time* window option added to GUI
	38
	39	### 2.2.4:
	40	* jroproc_spectra_lags.py added to schainpy
	41	* Bug fixed in schainGUI: ProcUnit was created with the same id in some cases.
	42	* Bug fixed in jroHeaderIO: Header size validation.
	43
	44	### 2.2.3.1:
	45	* Filtering block by time has been added.
	46	* Bug fixed plotting RTI, CoherenceMap and others using xmin and xmax parameters. The first day worked
	47	properly but the next days did not.
	48
	49	### 2.2.3:
	50	* Bug fixed in GUI: Error getting(reading) Code value
	51	* Bug fixed in GUI: Flip option always needs channelList field
	52	* Bug fixed in jrodata: when one branch modified a value in "dataOut" (example: dataOut.code) this value
	53	was modified for every branch (because this was a reference). It was modified in data.copy()
	54	* Bug fixed in jroproc_voltage.profileSelector(): rangeList replaces to profileRangeList.
	55
	56	### 2.2.2:
	57	* VoltageProc: ProfileSelector, Reshape, Decoder with nTxs!=1 and getblock=True was tested
	58	* Rawdata and testRawdata.py added to Signal Chain project
	59
	60	### 2.2.1:
	61	* Bugs fixed in GUI
	62	* Views were improved in GUI
	63	* Support to MST* ISR experiments
	64	* Bug fixed getting noise using hyldebrant. (minimum number of points > 20%)
	65	* handleError added to jroplotter.py
	66
	67	### 2.2.0:
	68	* GUI: use of external plotter
	69	* Compatible with matplotlib 1.5.0
	70
	71	### 2.1.5:
	72	* serializer module added to Signal Chain
	73	* jroplotter.py added to Signal Chain
	74
	75	### 2.1.4.2:
	76	* A new Plotter Class was added
	77	* Project.start() does not accept filename as a parameter anymore
	78
	79	### 2.1.4.1:
	80	* Send notifications when an error different to ValueError is detected
	81
	82	### 2.1.4:
	83	* Sending error notifications to signal chain administrator
	84	* Login to email server added
	85
	86	### 2.1.3.3:
	87	* Colored Button Icons were added to GUI
	88
	89	### 2.1.3.2:
	90	* GUI: user interaction enhanced
	91	* controller_api.py: Safe access to ControllerThead
	92
	93	### 2.1.3.1:
	94	* GUI: every icon were resized
	95	* jroproc_voltage.py: Print a message when "Read from code" option is selected and the code is not defined inside data file
	96
	97	### 2.1.3:
	98	* jroplot_heispectra.py: SpectraHeisScope was not showing the right channels
	99	* jroproc_voltage.py: Bug fixed selecting profiles (self.nProfiles took a wrong value),
	100	Bug fixed selecting heights by block (selecting profiles instead heights)
	101	* jroproc_voltage.py: New feature added: decoding data by block using FFT.
	102	* jroIO_heispectra.py: Bug fixed in FitsReader. Using local Fits instance instead schainpy.mode.data.jrodata.Fits.
	103	* jroIO_heispectra.py: Channel index list does not exist.
	104
	105	### 2.1.2:
	106	* jroutils_ftp.py: Bug fixed, Any error sending file stopped the Server Thread
	107	Server thread opens and closes remote server each time file list is sent
	108	* jroplot_spectra.py: Noise path was not being created when noise data is saved.
	109	* jroIO_base.py: startTime can be greater than endTime. Example: SpreadF [18:00 * 07:00] No newline at end of file

schainpy/scripts/JASMET30_MetDet.py created 644 0 0

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

schainpy/scripts/JASMET30_PhaseCal.py created 644 0 0

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

schainpy/scripts/JASMET30_Winds.py created 644 0 0

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

schainpy/scripts/PPD.py created 644 0 0

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

schainpy/scripts/julia_mp.py created 644 0 0

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

schainpy/scripts/schain.xml created 644 0 0

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

schainpy/utils/paramsFinder.py created 644 0 0

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

.gitignore +5 -3

             # Byte-compiled / optimized / DLL files
             __pycache__/
             *.py[cod]
             *$py.class
             # C extensions
             *.so
             # Distribution / packaging
             .Python
             env/
             build/
             develop-eggs/
             dist/
             downloads/
             eggs/
             .eggs/
             lib/
             lib64/
             parts/
             sdist/
             var/
             wheels/
             *.egg-info/
             .installed.cfg
             *.egg
             # PyInstaller
             #  Usually these files are written by a python script from a template
             #  before PyInstaller builds the exe, so as to inject date/other infos into it.
             *.manifest
             *.spec
             # Installer logs
             pip-log.txt
             pip-delete-this-directory.txt
             # Unit test / coverage reports
             htmlcov/
             .tox/
             .coverage
             .coverage.*
             .cache
             nosetests.xml
             coverage.xml
             *,cover
             .hypothesis/
             # Translations
             *.mo
             *.pot
             # Django stuff:
             *.log
             local_settings.py
             # Flask stuff:
             instance/
             .webassets-cache
             # Scrapy stuff:
             .scrapy
             # Sphinx documentation
             docs/_build/
             # PyBuilder
             target/
             # Jupyter Notebook
             .ipynb_checkpoints
             # pyenv
             .python-version
             # celery beat schedule file
             celerybeat-schedule
             # SageMath parsed files
             *.sage.py
             # dotenv
             .env
             # virtualenv
             .venv
             venv/
             ENV/
             # Spyder project settings
             .spyderproject
             .spyproject
             # Rope project settings
             .ropeproject
             # mkdocs documentation
             /site
             # eclipse
             .project
             .pydevproject
             # vscode
             .vscode
+            schainpy/scripts/
+            schaingui/node_modules/
             .svn/
             *.png
             *.pyc
-            schainpy/scripts
+            *.xml
+            *.log
-            schaingui/node_modules
+            trash
  No newline at end of file

README.md +18 -3

             # Signal Chain
             ## Introduction
             Signal Chain (SCh) is a radar data processing library developed using [Python](www.python.org) at JRO. SCh provides modules to read, write, process and plot data.
             ## Installation
             Install system dependencies, clone the latest version from [git](http://jro-dev.igp.gob.pe/rhodecode/schain/) and install it as a normal python package.
+            ### Linux based system
             ```
             $ sudo apt-get install python-pip python-dev gfortran libpng-dev freetype* libblas-dev liblapack-dev libatlas-base-dev python-qt4 python-tk libssl-dev libhdf5-dev
             $ sudo pip install numpy
             $ git clone http://jro-dev.igp.gob.pe/rhodecode/schain/
             $ cd schain
             $ sudo pip install ./
-            ```
-            **Its recommended to install schain in a virtual environment**
             ```
+            **It is recommended to install schain in a virtual environment**
+            ```
             $ sudo pip install virtualenv
             $ virtualenv /path/to/virtual --system-site-packages
             $ source /path/to/virtual/bin/activate
             (virtual) $ cd schain
             (virtual) $ pip install ./
             ```
+            ### MAC Os
+            ```
+            $ brew install cartr/qt4/pyqt
+            $ git clone http://jro-dev.igp.gob.pe/rhodecode/schain/
+            $ cd schain
+            $ pip install ./
+            ```
+            if ```pip install ./``` does not work, install a proper python enviroment, and repeat the steps.
+            ```
+            $ brew install python
+            ```
             ## First Script
             Read Spectra data (.pdata) - remove dc - plot spectra & RTI
             Import SCh and creating a project
             ```python
             #!/usr/bin/python
             from schainpy.controller import Project
             controller = Project()
             controller.setup(id = '100',
                              name='test',
                              description='Basic experiment')
             ```
             Adding read unit and operations
             ```python
             read_unit = controller.addReadUnit(datatype='Spectra',
                                                path='/path/to/pdata/',
                                                startDate='2014/01/31',
                                                endDate='2014/03/31',
                                                startTime='00:00:00',
                                                endTime='23:59:59',
                                                online=0,
                                                walk=0)
             proc_unit = controller.addProcUnit(datatype='Spectra',
                                                inputId=read_unit.getId())
             op = proc_unit.addOperation(name='selectChannels')
             op.addParameter(name='channelList', value='0,1', format='intlist')
             op = proc_unit.addOperation(name='selectHeights')
             op.addParameter(name='minHei', value='80', format='float')
             op.addParameter(name='maxHei', value='200', format='float')
             op = proc_unit.addOperation(name='removeDC')
             ```
             Plotting data & start project
             ```python
             op = proc_unit.addOperation(name='SpectraPlot', optype='other')
             op.addParameter(name='id', value='1', format='int')
             op.addParameter(name='wintitle', value='Spectra', format='str')
             op = procUnitConfObj1.addOperation(name='RTIPlot', optype='other')
             op.addParameter(name='id', value='2', format='int')
             op.addParameter(name='wintitle', value='RTI', format='str')
             controller.start()
             ```
             Full script
             ```python
             #!/usr/bin/python
             from schainpy.controller import Project
             controller = Project()
             controller.setup(id = '100',
                              name='test',
                              description='Basic experiment')
             read_unit = controller.addReadUnit(datatype='Spectra',
                                                path='/path/to/pdata/',
                                                startDate='2014/01/31',
                                                endDate='2014/03/31',
                                                startTime='00:00:00',
                                                endTime='23:59:59',
                                                online=0,
                                                walk=0)
             proc_unit = controller.addProcUnit(datatype='Spectra',
                                                inputId=read_unit.getId())
             op = proc_unit.addOperation(name='selectChannels')
             op.addParameter(name='channelList', value='0,1', format='intlist')
             op = proc_unit.addOperation(name='selectHeights')
             op.addParameter(name='minHei', value='80', format='float')
             op.addParameter(name='maxHei', value='200', format='float')
             op = proc_unit.addOperation(name='removeDC')
             op = proc_unit.addOperation(name='SpectraPlot', optype='other')
             op.addParameter(name='id', value='6', format='int')
             op.addParameter(name='wintitle', value='Spectra', format='str')
             op = procUnitConfObj1.addOperation(name='RTIPlot', optype='other')
             op.addParameter(name='id', value='2', format='int')
             op.addParameter(name='wintitle', value='RTI', format='str')
             controller.start()
             ```

schaincli/cli.py +9 -40

             import click
             import schainpy
             import subprocess
             import os
             import sys
             import glob
             save_stdout = sys.stdout
             sys.stdout = open('trash', 'w')
             from multiprocessing import cpu_count
             from schaincli import templates
-            from schainpy import controller_api
+            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.utils import paramsFinder
             sys.stdout = save_stdout
             def print_version(ctx, param, value):
                 if not value or ctx.resilient_parsing:
                     return
                 click.echo(schainpy.__version__)
                 ctx.exit()
             cliLogger = log.makelogger('schain cli')
             PREFIX = 'experiment'
             @click.command()
             @click.option('--version', '-v', is_flag=True, callback=print_version, help='SChain version', type=str)
             @click.option('--xml', '-x', default=None, help='run an XML file', type=click.Path(exists=True, resolve_path=True))
             @click.argument('command', default='run', required=True)
             @click.argument('nextcommand', default=None, required=False, type=str)
             def main(command, nextcommand, version, xml):
                 """COMMAND LINE INTERFACE FOR SIGNAL CHAIN - JICAMARCA RADIO OBSERVATORY \n
                     Available commands.\n
                     --xml: runs a schain XML generated file\n
                     run: runs any python script starting 'experiment_'\n
                     generate: generates a template schain script\n
                     search: return avilable operations, procs or arguments of the give operation/proc\n"""
                 if xml is not None:
                     runFromXML(xml)
                 elif command == 'generate':
                     generate()
                 elif command == 'test':
                     test()
                 elif command == 'run':
                     runschain(nextcommand)
                 elif command == 'search':
                     search(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))
                         return isinstance(instancia(), instance)
                     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 search(nextcommand):
                 if nextcommand is None:
                     log.error('There is no Operation/ProcessingUnit to search')
                 elif nextcommand == 'procs':
-                    module = dir(import_module('schainpy.model'))
+                    procs = paramsFinder.getProcs()
-                    procs = check_module(module, ProcessingUnit)
-                    try:
-                        procs.remove('ProcessingUnit')
-                    except Exception as e:
-                        pass
                     log.success('Current ProcessingUnits are:\n\033[1m{}\033[0m'.format('\n'.join(procs)))
                 elif nextcommand == 'operations':
-                    module = dir(import_module('schainpy.model'))
+                    operations = paramsFinder.getOperations()
-                    noProcs = [x for x in module if not x.endswith('Proc')]
-                    operations = check_module(noProcs, Operation)
-                    try:
-                        operations.remove('Operation')
-                    except Exception as e:
-                        pass
                     log.success('Current Operations are:\n\033[1m{}\033[0m'.format('\n'.join(operations)))
                 else:
                     try:
-                        module = locate('schainpy.model.{}'.format(nextcommand))
+                        args = paramsFinder.getArgs(nextcommand)
-                        args = module().getAllowedArgs()
                         log.warning('Use this feature with caution. It may not return all the allowed arguments')
-                        try:
-                            args.remove('self')
-                        except Exception as e:
-                            pass
-                        try:
-                            args.remove('dataOut')
-                        except Exception as e:
-                            pass
                         if len(args) == 0:
                             log.success('{} has no arguments'.format(nextcommand))
                         else:
                             log.success('Showing arguments of {} are:\n\033[1m{}\033[0m'.format(nextcommand, '\n'.join(args)))
                     except Exception as e:
                         log.error('Module {} does not exists'.format(nextcommand))
-                        allModules = dir(import_module('schainpy.model'))
+                        allModules = paramsFinder.getAll()
-                        module = check_module(allModules, Operation)
+                        similar = process.extractOne(nextcommand, allModules)[0]
-                        module.extend(check_module(allModules, ProcessingUnit))
+                        log.success('Showing {} instead'.format(similar))
-                        similar = process.extractOne(nextcommand, module)[0]
-                        log.success('Searching {} instead'.format(similar))
                         search(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['desc'] = click.prompt('Enter a description', default="A schain project", type=str)
                 inputs['name'] = click.prompt('Name of the project', default="project", type=str)
                 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='2017/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()
                 inputs['multiprocess'] = click.confirm('Is this a multiprocess script?')
                 if inputs['multiprocess']:
                     inputs['nProcess'] = click.prompt('How many process?', default=cpu_count(), type=int)
                     current = templates.multiprocess.format(**inputs)
                 else:
                     current = templates.basic.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 = controller_api.ControllerThread()
+                controller = Project()
                 if not controller.readXml(filename):
                     return
-                plotterObj = controller.useExternalPlotter()
                 controller.start()
-                plotterObj.start()
-                cliLogger("Finishing all processes")
-                controller.join(5)
-                cliLogger("End of script")
                 return

schainpy/__init__.py +1 -1

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
-            __version__ = "2.3"
  No newline at end of file
+            __version__ = "2.3"

schainpy/controller.py +154 -176

             '''
             Created on September , 2012
             @author:
             '''
             import sys
             import ast
             import datetime
             import traceback
             import math
             import time
-            from multiprocessing import Process, Queue, cpu_count
+            from multiprocessing import Process, cpu_count
-            import schainpy
-            import schainpy.admin
             from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
             from xml.dom import minidom
+            import schainpy
+            import schainpy.admin
             from schainpy.model import *
-            from time import sleep
+            from schainpy.utils import log
-            def prettify(elem):
+            DTYPES = {
-                """Return a pretty-printed XML string for the Element.
+                'Voltage': '.r',
-                """
+                'Spectra': '.pdata'
-                rough_string = tostring(elem, 'utf-8')
-                reparsed = minidom.parseString(rough_string)
-                return reparsed.toprettyxml(indent="  ")
+            def MPProject(project, n=cpu_count()):
+                '''
-            def multiSchain(child, nProcess=cpu_count(), startDate=None, endDate=None, by_day=False):
+                Project wrapper to run schain in n processes
-                skip = 0
+                '''
-                cursor = 0
-                nFiles = None
+                rconf = project.getReadUnitObj()
-                processes = []
+                op = rconf.getOperationObj('run')
-                dt1 = datetime.datetime.strptime(startDate, '%Y/%m/%d')
+                dt1 = op.getParameterValue('startDate')
-                dt2 = datetime.datetime.strptime(endDate, '%Y/%m/%d')
+                dt2 = op.getParameterValue('endDate')
                 days = (dt2 - dt1).days
                 for day in range(days+1):
                     skip = 0
                     cursor = 0
-                    q = Queue()
                     processes = []
-                    dt = (dt1 + datetime.timedelta(day)).strftime('%Y/%m/%d')
+                    dt = dt1 + datetime.timedelta(day)
-                    firstProcess = Process(target=child, args=(cursor, skip, q, dt))
+                    dt_str = dt.strftime('%Y/%m/%d')
-                    firstProcess.start()
+                    reader = JRODataReader()
-                    if by_day:
+                    paths, files = reader.searchFilesOffLine(path=rconf.path,
-                        continue
+                        startDate=dt,
-                    nFiles = q.get()
+                        endDate=dt,
-                    if nFiles==0:
+                        ext=DTYPES[rconf.datatype])
+                    nFiles = len(files)
+                    if nFiles == 0:
                         continue
-                    firstProcess.terminate()
+                    skip = int(math.ceil(nFiles/n))
-                    skip = int(math.ceil(nFiles/nProcess))
+                    while nFiles > cursor*skip:
-                    while True:
+                        rconf.update(startDate=dt_str, endDate=dt_str, cursor=cursor,
-                        processes.append(Process(target=child, args=(cursor, skip, q, dt)))
+                            skip=skip)
-                        processes[cursor].start()
+                        p = project.clone()
-                        if nFiles < cursor*skip:
+                        p.start()
-                            break
+                        processes.append(p)
                         cursor += 1
                     def beforeExit(exctype, value, trace):
                         for process in processes:
                             process.terminate()
                             process.join()
                         print traceback.print_tb(trace)
                     sys.excepthook = beforeExit
                     for process in processes:
                         process.join()
                         process.terminate()
                     time.sleep(3)
             class ParameterConf():
                 id = None
                 name = None
                 value = None
                 format = None
                 __formated_value = None
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.format = 'str'
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getValue(self):
                     value = self.value
                     format = self.format
                     if self.__formated_value != None:
                         return self.__formated_value
                     if format == 'obj':
                         return value
                     if format == 'str':
                         self.__formated_value = str(value)
                         return self.__formated_value
                     if value == '':
-                        raise ValueError, "%s: This parameter value is empty" %self.name
+                        raise ValueError, '%s: This parameter value is empty' %self.name
                     if format == 'list':
                         strList = value.split(',')
                         self.__formated_value = strList
                         return self.__formated_value
                     if format == 'intlist':
-                        """
+                        '''
                         Example:
                             value = (0,1,2)
-                        """
+                        '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             new_value = [int(new_value)]
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'floatlist':
-                        """
+                        '''
                         Example:
                             value = (0.5, 1.4, 2.7)
-                        """
+                        '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             new_value = [float(new_value)]
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'date':
                         strList = value.split('/')
                         intList = [int(x) for x in strList]
                         date = datetime.date(intList[0], intList[1], intList[2])
                         self.__formated_value = date
                         return self.__formated_value
                     if format == 'time':
                         strList = value.split(':')
                         intList = [int(x) for x in strList]
                         time = datetime.time(intList[0], intList[1], intList[2])
                         self.__formated_value = time
                         return self.__formated_value
                     if format == 'pairslist':
-                        """
+                        '''
                         Example:
                             value = (0,1),(1,2)
-                        """
+                        '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
-                            raise ValueError, "%s has to be a tuple or list of pairs" %value
+                            raise ValueError, '%s has to be a tuple or list of pairs' %value
                         if type(new_value[0]) not in (tuple, list):
                             if len(new_value) != 2:
-                                raise ValueError, "%s has to be a tuple or list of pairs" %value
+                                raise ValueError, '%s has to be a tuple or list of pairs' %value
                             new_value = [new_value]
                         for thisPair in new_value:
                             if len(thisPair) != 2:
-                                raise ValueError, "%s has to be a tuple or list of pairs" %value
+                                raise ValueError, '%s has to be a tuple or list of pairs' %value
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'multilist':
-                        """
+                        '''
                         Example:
                             value = (0,1,2),(3,4,5)
-                        """
+                        '''
                         multiList = ast.literal_eval(value)
                         if type(multiList[0]) == int:
-                            multiList = ast.literal_eval("(" + value + ")")
+                            multiList = ast.literal_eval('(' + value + ')')
                         self.__formated_value = multiList
                         return self.__formated_value
                     if format == 'bool':
                         value = int(value)
                     if format == 'int':
                         value = float(value)
                     format_func = eval(format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def updateId(self, new_id):
                     self.id = str(new_id)
                 def setup(self, id, name, value, format='str'):
                     self.id = str(id)
                     self.name = name
                     if format == 'obj':
                         self.value = value
                     else:
                         self.value = str(value)
                     self.format = str.lower(format)
                     self.getValue()
                     return 1
                 def update(self, name, value, format='str'):
                     self.name = name
                     self.value = str(value)
                     self.format = format
                 def makeXml(self, opElement):
                     if self.name not in ('queue',):
                         parmElement = SubElement(opElement, self.ELEMENTNAME)
                         parmElement.set('id', str(self.id))
                         parmElement.set('name', self.name)
                         parmElement.set('value', self.value)
                         parmElement.set('format', self.format)
                 def readXml(self, parmElement):
                     self.id = parmElement.get('id')
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                     self.format = str.lower(parmElement.get('format'))
                     #Compatible with old signal chain version
                     if self.format == 'int' and self.name == 'idfigure':
                         self.name = 'id'
                 def printattr(self):
-                    print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
+                    print 'Parameter[%s]: name = %s, value = %s, format = %s' %(self.id, self.name, self.value, self.format)
             class OperationConf():
                 id = None
                 name = None
                 priority = None
                 type = None
                 parmConfObjList = []
                 ELEMENTNAME = 'Operation'
                 def __init__(self):
                     self.id = '0'
                     self.name = None
                     self.priority = None
                     self.type = 'self'
                 def __getNewId(self):
                     return int(self.id)*10 + len(self.parmConfObjList) + 1
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     n = 1
                     for parmObj in self.parmConfObjList:
                         idParm = str(int(new_id)*10 + n)
                         parmObj.updateId(idParm)
                         n += 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getParameterObjList(self):
                     return self.parmConfObjList
                 def getParameterObj(self, parameterName):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.name != parameterName:
                             continue
                         return parmConfObj
                     return None
                 def getParameterObjfromValue(self, parameterValue):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.getValue() != parameterValue:
                             continue
                         return parmConfObj.getValue()
                     return None
                 def getParameterValue(self, parameterName):
                     parameterObj = self.getParameterObj(parameterName)
                 #         if not parameterObj:
                 #             return None
                     value = parameterObj.getValue()
                     return value
                 def getKwargs(self):
                     kwargs = {}
                     for parmConfObj in self.parmConfObjList:
                         if self.name == 'run' and parmConfObj.name == 'datatype':
                             continue
                         kwargs[parmConfObj.name] = parmConfObj.getValue()
                     return kwargs
                 def setup(self, id, name, priority, type):
                     self.id = str(id)
                     self.name = name
                     self.type = type
                     self.priority = priority
                     self.parmConfObjList = []
                 def removeParameters(self):
                     for obj in self.parmConfObjList:
                         del obj
                     self.parmConfObjList = []
                 def addParameter(self, name, value, format='str'):
+                    if value is None:
+                        return None
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
                     if not parmConfObj.setup(id, name, value, format):
                         return None
                     self.parmConfObjList.append(parmConfObj)
                     return parmConfObj
                 def changeParameter(self, name, value, format='str'):
                     parmConfObj = self.getParameterObj(name)
                     parmConfObj.update(name, value, format)
                     return parmConfObj
                 def makeXml(self, procUnitElement):
                     opElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     opElement.set('id', str(self.id))
                     opElement.set('name', self.name)
                     opElement.set('type', self.type)
                     opElement.set('priority', str(self.priority))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.makeXml(opElement)
                 def readXml(self, opElement):
                     self.id = opElement.get('id')
                     self.name = opElement.get('name')
                     self.type = opElement.get('type')
                     self.priority = opElement.get('priority')
                     #Compatible with old signal chain version
                     #Use of 'run' method instead 'init'
                     if self.type == 'self' and self.name == 'init':
                         self.name = 'run'
                     self.parmConfObjList = []
                     parmElementList = opElement.iter(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         #Compatible with old signal chain version
                         #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
                         if self.type != 'self' and self.name == 'Plot':
                             if parmConfObj.format == 'str' and parmConfObj.name == 'type':
                                 self.name = parmConfObj.value
                                 continue
                         self.parmConfObjList.append(parmConfObj)
                 def printattr(self):
-                    print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
+                    print '%s[%s]: name = %s, type = %s, priority = %s' %(self.ELEMENTNAME,
                                                                           self.id,
                                                                           self.name,
                                                                           self.type,
                                                                           self.priority)
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self, plotter_queue=None):
                     if self.type == 'self':
-                        raise ValueError, "This operation type cannot be created"
+                        raise ValueError, 'This operation type cannot be created'
                     if self.type == 'plotter':
-                        #Plotter(plotter_name)
                         if not plotter_queue:
-                            raise ValueError, "plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)"
+                            raise ValueError, 'plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)'
                         opObj = Plotter(self.name, plotter_queue)
                     if self.type == 'external' or self.type == 'other':
                         className = eval(self.name)
                         kwargs = self.getKwargs()
                         opObj = className(**kwargs)
                     return opObj
             class ProcUnitConf():
                 id = None
                 name = None
                 datatype = None
                 inputId = None
                 parentId = None
                 opConfObjList = []
                 procUnitObj = None
                 opObjList = []
                 ELEMENTNAME = 'ProcUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.procUnitObj = None
                     self.opObjDict = {}
                 def __getPriority(self):
                     return len(self.opConfObjList)+1
                 def __getNewId(self):
                     return int(self.id)*10 + len(self.opConfObjList) + 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id, parentId=parentId):
                     new_id = int(parentId)*10 + (int(self.id) % 10)
                     new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
                     #If this proc unit has not inputs
                     if self.inputId == '0':
                         new_inputId = 0
                     n = 1
                     for opConfObj in self.opConfObjList:
                         idOp = str(int(new_id)*10 + n)
                         opConfObj.updateId(idOp)
                         n += 1
                     self.parentId = str(parentId)
                     self.id = str(new_id)
                     self.inputId = str(new_inputId)
                 def getInputId(self):
                     return self.inputId
                 def getOperationObjList(self):
                     return self.opConfObjList
                 def getOperationObj(self, name=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.name != name:
                             continue
                         return opConfObj
                     return None
                 def getOpObjfromParamValue(self, value=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
                             continue
                         return opConfObj
                     return None
                 def getProcUnitObj(self):
                     return self.procUnitObj
                 def setup(self, id, name, datatype, inputId, parentId=None):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
-                        raise ValueError, "datatype or name should be defined"
+                        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.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.parentId = parentId
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                     self.addOperation(name='run')
                 def addParameter(self, **kwargs):
                     '''
-                    Add parameters to "run" operation
+                    Add parameters to 'run' operation
                     '''
                     opObj = self.opConfObjList[0]
                     opObj.addParameter(**kwargs)
                     return opObj
                 def addOperation(self, name, optype='self'):
                     id = self.__getNewId()
                     priority = self.__getPriority()
                     opConfObj = OperationConf()
                     opConfObj.setup(id, name=name, priority=priority, type=optype)
                     self.opConfObjList.append(opConfObj)
                     return opConfObj
                 def makeXml(self, projectElement):
                     procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
                     procUnitElement.set('id', str(self.id))
                     procUnitElement.set('name', self.name)
                     procUnitElement.set('datatype', self.datatype)
                     procUnitElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
                         opConfObj.makeXml(procUnitElement)
                 def readXml(self, upElement):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
-                    if self.ELEMENTNAME == "ReadUnit":
+                    if self.ELEMENTNAME == 'ReadUnit':
-                        self.datatype = self.datatype.replace("Reader", "")
+                        self.datatype = self.datatype.replace('Reader', '')
-                    if self.ELEMENTNAME == "ProcUnit":
+                    if self.ELEMENTNAME == 'ProcUnit':
-                        self.datatype = self.datatype.replace("Proc", "")
+                        self.datatype = self.datatype.replace('Proc', '')
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.iter(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement)
                         self.opConfObjList.append(opConfObj)
                 def printattr(self):
-                    print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
+                    print '%s[%s]: name = %s, datatype = %s, inputId = %s' %(self.ELEMENTNAME,
                                                                             self.id,
                                                                             self.name,
                                                                             self.datatype,
                                                                             self.inputId)
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def getKwargs(self):
                     opObj = self.opConfObjList[0]
                     kwargs = opObj.getKwargs()
                     return kwargs
                 def createObjects(self, plotter_queue=None):
                     className = eval(self.name)
                     kwargs = self.getKwargs()
                     procUnitObj = className(**kwargs)
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type=='self' and self.name=='run':
                             continue
                         elif opConfObj.type=='self':
                             procUnitObj.addOperationKwargs(opConfObj.id, **opConfObj.getKwargs())
                             continue
                         opObj = opConfObj.createObject(plotter_queue)
                         self.opObjDict[opConfObj.id] = opObj
                         procUnitObj.addOperation(opObj, opConfObj.id)
                     self.procUnitObj = procUnitObj
                     return procUnitObj
                 def run(self):
                     is_ok = False
                     for opConfObj in self.opConfObjList:
                         kwargs = {}
                         for parmConfObj in opConfObj.getParameterObjList():
                             if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
                                 continue
                             kwargs[parmConfObj.name] = parmConfObj.getValue()
                         sts = self.procUnitObj.call(opType = opConfObj.type,
                                                     opName = opConfObj.name,
                                                     opId = opConfObj.id)
                         is_ok = is_ok or sts
                     return is_ok
                 def close(self):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = self.procUnitObj.getOperationObj(opConfObj.id)
                         opObj.close()
                     self.procUnitObj.close()
                     return
             class ReadUnitConf(ProcUnitConf):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 ELEMENTNAME = 'ReadUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.parentId = None
                     self.opConfObjList = []
                     self.opObjList = []
                 def getElementName(self):
                     return self.ELEMENTNAME
-                def setup(self, id, name, datatype, path='', startDate="", endDate="", startTime="",
+                def setup(self, id, name, datatype, path='', startDate='', endDate='',
-                          endTime="", parentId=None, queue=None, server=None, **kwargs):
+                          startTime='', endTime='', parentId=None, server=None, **kwargs):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
-                        raise ValueError, "datatype or name should be defined"
+                        raise ValueError, 'datatype or name should be defined'
                     if name==None:
                         if 'Reader' in datatype:
                             name = datatype
                         else:
                             name = '%sReader' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Reader','')
                     self.id = id
                     self.name = name
                     self.datatype = datatype
                     if path != '':
                         self.path = os.path.abspath(path)
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.inputId = '0'
                     self.parentId = parentId
-                    self.queue = queue
                     self.server = server
                     self.addRunOperation(**kwargs)
-                def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
+                def update(self, **kwargs):
-                    #Compatible with old signal chain version
+                    if 'datatype' in kwargs:
-                    if datatype==None and name==None:
+                        datatype = kwargs.pop('datatype')
-                        raise ValueError, "datatype or name should be defined"
-                    if name==None:
                         if 'Reader' in datatype:
-                            name = datatype
+                            self.name = datatype
                         else:
-                            name = '%sReader' %(datatype)
+                            self.name = '%sReader' %(datatype)
+                        self.datatype = self.name.replace('Reader', '')
-                    if datatype==None:
-                        datatype = name.replace('Reader','')
-                    self.datatype = datatype
-                    self.name = name
-                    self.path = path
-                    self.startDate = startDate
-                    self.endDate = endDate
-                    self.startTime = startTime
-                    self.endTime = endTime
+                    attrs = ('path', 'startDate', 'endDate', 'startTime', 'endTime', 'parentId')
+                    for attr in attrs:
+                        if attr in kwargs:
+                            setattr(self, attr, kwargs.pop(attr))
                     self.inputId = '0'
-                    self.parentId = parentId
                     self.updateRunOperation(**kwargs)
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name = 'run', optype = 'self')
                     if self.server is None:
-                        opObj.addParameter(name='datatype' , value=self.datatype, format='str')
+                        opObj.addParameter(name='datatype', value=self.datatype, format='str')
-                        opObj.addParameter(name='path'     , value=self.path, format='str')
+                        opObj.addParameter(name='path', value=self.path, format='str')
-                        opObj.addParameter(name='startDate' , value=self.startDate, format='date')
+                        opObj.addParameter(name='startDate', value=self.startDate, format='date')
-                        opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
+                        opObj.addParameter(name='endDate', value=self.endDate, format='date')
-                        opObj.addParameter(name='startTime' , value=self.startTime, format='time')
+                        opObj.addParameter(name='startTime', value=self.startTime, format='time')
-                        opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
+                        opObj.addParameter(name='endTime', value=self.endTime, format='time')
-                        opObj.addParameter(name='queue'   , value=self.queue, format='obj')
                         for key, value in kwargs.items():
                             opObj.addParameter(name=key, value=value, format=type(value).__name__)
                     else:
                         opObj.addParameter(name='server' , value=self.server, format='str')
                     return opObj
                 def updateRunOperation(self, **kwargs):
-                    opObj = self.getOperationObj(name = 'run')
+                    opObj = self.getOperationObj(name='run')
                     opObj.removeParameters()
-                    opObj.addParameter(name='datatype' , value=self.datatype, format='str')
+                    opObj.addParameter(name='datatype', value=self.datatype, format='str')
-                    opObj.addParameter(name='path'     , value=self.path, format='str')
+                    opObj.addParameter(name='path', value=self.path, format='str')
-                    opObj.addParameter(name='startDate' , value=self.startDate, format='date')
+                    opObj.addParameter(name='startDate', value=self.startDate, format='date')
-                    opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
+                    opObj.addParameter(name='endDate', value=self.endDate, format='date')
-                    opObj.addParameter(name='startTime' , value=self.startTime, format='time')
+                    opObj.addParameter(name='startTime', value=self.startTime, format='time')
-                    opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
+                    opObj.addParameter(name='endTime', value=self.endTime, format='time')
                     for key, value in kwargs.items():
                         opObj.addParameter(name=key, value=value, format=type(value).__name__)
                     return opObj
-                    #     def makeXml(self, projectElement):
-                    #         procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
-                    #         procUnitElement.set('id', str(self.id))
-                    #         procUnitElement.set('name', self.name)
-                    #         procUnitElement.set('datatype', self.datatype)
-                    #         procUnitElement.set('inputId', str(self.inputId))
-                    #         for opConfObj in self.opConfObjList:
-                    #             opConfObj.makeXml(procUnitElement)
                 def readXml(self, upElement):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
-                    if self.ELEMENTNAME == "ReadUnit":
+                    if self.ELEMENTNAME == 'ReadUnit':
-                        self.datatype = self.datatype.replace("Reader", "")
+                        self.datatype = self.datatype.replace('Reader', '')
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.iter(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement)
                         self.opConfObjList.append(opConfObj)
                         if opConfObj.name == 'run':
                             self.path = opConfObj.getParameterValue('path')
                             self.startDate = opConfObj.getParameterValue('startDate')
                             self.endDate = opConfObj.getParameterValue('endDate')
                             self.startTime = opConfObj.getParameterValue('startTime')
                             self.endTime = opConfObj.getParameterValue('endTime')
-            class Project():
+            class Project(Process):
                 id = None
-                name = None
+                # name = None
                 description = None
                 filename = None
                 procUnitConfObjDict = None
                 ELEMENTNAME = 'Project'
                 plotterQueue = None
                 def __init__(self, plotter_queue=None):
+                    Process.__init__(self)
                     self.id = None
-                    self.name = None
+                    # self.name = None
                     self.description = None
                     self.plotterQueue = plotter_queue
                     self.procUnitConfObjDict = {}
                 def __getNewId(self):
                     idList = self.procUnitConfObjDict.keys()
                     id = int(self.id)*10
                     while True:
                         id += 1
                         if str(id) in idList:
                             continue
                         break
                     return str(id)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     n = 1
                     newProcUnitConfObjDict = {}
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         idProcUnit = str(int(self.id)*10 + n)
                         procUnitConfObj.updateId(idProcUnit, parentId = self.id)
                         newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
                         n += 1
                     self.procUnitConfObjDict = newProcUnitConfObjDict
-                def setup(self, id, name, description):
+                def setup(self, id, name='', description=''):
+                    print
+                    print '*'*60
+                    print '   Starting SIGNAL CHAIN PROCESSING v%s ' % schainpy.__version__
+                    print '*'*60
+                    print
                     self.id = str(id)
-                    self.name = name
                     self.description = description
                 def update(self, name, description):
-                    self.name = name
                     self.description = description
+                def clone(self):
+                    p = Project()
+                    p.procUnitConfObjDict = self.procUnitConfObjDict
+                    return p
                 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
                     if id is None:
                         idReadUnit = self.__getNewId()
                     else:
                         idReadUnit = str(id)
                     readUnitConfObj = ReadUnitConf()
                     readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
                 def addProcUnit(self, inputId='0', datatype=None, name=None):
                     idProcUnit = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
                     procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def removeProcUnit(self, id):
                     if id in self.procUnitConfObjDict.keys():
                         self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                     readUnitConfObj = self.getReadUnitObj()
                     return readUnitConfObj.id
                 def getReadUnitObj(self):
                     for obj in self.procUnitConfObjDict.values():
-                        if obj.getElementName() == "ReadUnit":
+                        if obj.getElementName() == 'ReadUnit':
                             return obj
                     return None
                 def getProcUnitObj(self, id=None, name=None):
                     if id != None:
                         return self.procUnitConfObjDict[id]
                     if name != None:
                         return self.getProcUnitObjByName(name)
                     return None
                 def getProcUnitObjByName(self, name):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.name == name:
                             return obj
                     return None
                 def procUnitItems(self):
                     return self.procUnitConfObjDict.items()
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename=None):
                     if filename == None:
                         if self.filename:
                             filename = self.filename
                         else:
-                            filename = "schain.xml"
+                            filename = 'schain.xml'
                     if not filename:
-                        print "filename has not been defined. Use setFilename(filename) for do it."
+                        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)
+                        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
+                        print 'File %s already exists and it could not be overwriten' %abs_file
                         return 0
                     self.makeXml()
                     ElementTree(self.projectElement).write(abs_file, method='xml')
                     self.filename = abs_file
                     return 1
                 def readXml(self, filename = None):
                     if not filename:
-                        print "filename is not defined"
+                        print 'filename is not defined'
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.path.isfile(abs_file):
-                        print "%s file does not exist" %abs_file
+                        print '%s file does not exist' %abs_file
                         return 0
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     try:
                         self.projectElement = ElementTree().parse(abs_file)
                     except:
-                        print "Error reading %s, verify file format" %filename
+                        print 'Error reading %s, verify file format' %filename
                         return 0
                     self.project = self.projectElement.tag
                     self.id = self.projectElement.get('id')
                     self.name = self.projectElement.get('name')
                     self.description = self.projectElement.get('description')
                     readUnitElementList = self.projectElement.iter(ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         readUnitConfObj.readXml(readUnitElement)
                         if readUnitConfObj.parentId == None:
                             readUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     procUnitElementList = self.projectElement.iter(ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement)
                         if procUnitConfObj.parentId == None:
                             procUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     self.filename = abs_file
                     return 1
                 def printattr(self):
-                    print "Project[%s]: name = %s, description = %s" %(self.id,
+                    print 'Project[%s]: name = %s, description = %s' %(self.id,
                                                                     self.name,
                                                                     self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.printattr()
                 def createObjects(self):
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.createObjects(self.plotterQueue)
                 def __connect(self, objIN, thisObj):
                     thisObj.setInput(objIN.getOutputObj())
                 def connectObjects(self):
                     for thisPUConfObj in self.procUnitConfObjDict.values():
                         inputId = thisPUConfObj.getInputId()
                         if int(inputId) == 0:
                             continue
                         #Get input object
                         puConfINObj = self.procUnitConfObjDict[inputId]
                         puObjIN = puConfINObj.getProcUnitObj()
                         #Get current object
                         thisPUObj = thisPUConfObj.getProcUnitObj()
                         self.__connect(puObjIN, thisPUObj)
-                def __handleError(self, procUnitConfObj, send_email=True):
+                def __handleError(self, procUnitConfObj, send_email=False):
                     import socket
                     err = traceback.format_exception(sys.exc_info()[0],
                                                     sys.exc_info()[1],
                                                     sys.exc_info()[2])
-                    print "***** Error occurred in %s *****" %(procUnitConfObj.name)
+                    print '***** Error occurred in %s *****' %(procUnitConfObj.name)
-                    print "***** %s" %err[-1]
+                    print '***** %s' %err[-1]
-                    message = "".join(err)
+                    message = ''.join(err)
                     sys.stderr.write(message)
                     if not send_email:
                         return
-                    subject =  "SChain v%s: Error running %s\n" %(schainpy.__version__, procUnitConfObj.name)
+                    subject =  'SChain v%s: Error running %s\n' %(schainpy.__version__, procUnitConfObj.name)
-                    subtitle = "%s: %s\n" %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
+                    subtitle = '%s: %s\n' %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
-                    subtitle += "Hostname: %s\n" %socket.gethostbyname(socket.gethostname())
+                    subtitle += 'Hostname: %s\n' %socket.gethostbyname(socket.gethostname())
-                    subtitle += "Working directory: %s\n" %os.path.abspath("./")
+                    subtitle += 'Working directory: %s\n' %os.path.abspath('./')
-                    subtitle += "Configuration file: %s\n" %self.filename
+                    subtitle += 'Configuration file: %s\n' %self.filename
-                    subtitle += "Time: %s\n" %str(datetime.datetime.now())
+                    subtitle += 'Time: %s\n' %str(datetime.datetime.now())
                     readUnitConfObj = self.getReadUnitObj()
                     if readUnitConfObj:
-                        subtitle += "\nInput parameters:\n"
+                        subtitle += '\nInput parameters:\n'
-                        subtitle += "[Data path = %s]\n" %readUnitConfObj.path
+                        subtitle += '[Data path = %s]\n' %readUnitConfObj.path
-                        subtitle += "[Data type = %s]\n" %readUnitConfObj.datatype
+                        subtitle += '[Data type = %s]\n' %readUnitConfObj.datatype
-                        subtitle += "[Start date = %s]\n" %readUnitConfObj.startDate
+                        subtitle += '[Start date = %s]\n' %readUnitConfObj.startDate
-                        subtitle += "[End date = %s]\n" %readUnitConfObj.endDate
+                        subtitle += '[End date = %s]\n' %readUnitConfObj.endDate
-                        subtitle += "[Start time = %s]\n" %readUnitConfObj.startTime
+                        subtitle += '[Start time = %s]\n' %readUnitConfObj.startTime
-                        subtitle += "[End time = %s]\n" %readUnitConfObj.endTime
+                        subtitle += '[End time = %s]\n' %readUnitConfObj.endTime
                     adminObj = schainpy.admin.SchainNotify()
                     adminObj.sendAlert(message=message,
                                     subject=subject,
                                     subtitle=subtitle,
                                     filename=self.filename)
                 def isPaused(self):
                     return 0
                 def isStopped(self):
                     return 0
                 def runController(self):
-                    """
+                    '''
                     returns 0 when this process has been stopped, 1 otherwise
-                    """
+                    '''
                     if self.isPaused():
-                        print "Process suspended"
+                        print 'Process suspended'
                         while True:
-                            sleep(0.1)
+                            time.sleep(0.1)
                             if not self.isPaused():
                                 break
                             if self.isStopped():
                                 break
-                        print "Process reinitialized"
+                        print 'Process reinitialized'
                     if self.isStopped():
-                        print "Process stopped"
+                        print 'Process stopped'
                         return 0
                     return 1
                 def setFilename(self, filename):
                     self.filename = filename
                 def setPlotterQueue(self, plotter_queue):
-                    raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
+                    raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
                 def getPlotterQueue(self):
-                    raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
+                    raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
                 def useExternalPlotter(self):
-                    raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
+                    raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
                 def run(self):
-                    print
+                    log.success('Starting {}'.format(self.name))
-                    print "*"*60
-                    print "   Starting SIGNAL CHAIN PROCESSING v%s " %schainpy.__version__
+                    self.createObjects()
-                    print "*"*60
+                    self.connectObjects()
-                    print
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     while(True):
                         is_ok = False
                         for procKey in keyList:
-            #                 print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
                             procUnitConfObj = self.procUnitConfObjDict[procKey]
                             try:
                                 sts = procUnitConfObj.run()
                                 is_ok = is_ok or sts
                             except KeyboardInterrupt:
                                 is_ok = False
                                 break
                             except ValueError, e:
-                                sleep(0.5)
+                                time.sleep(0.5)
                                 self.__handleError(procUnitConfObj, send_email=True)
                                 is_ok = False
                                 break
                             except:
-                                sleep(0.5)
+                                time.sleep(0.5)
                                 self.__handleError(procUnitConfObj)
                                 is_ok = False
                                 break
                         #If every process unit finished so end process
                         if not(is_ok):
-            #                 print "Every process unit have finished"
                             break
                         if not self.runController():
                             break
                     #Closing every process
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         procUnitConfObj.close()
-                    print "Process finished"
+                    log.success('{} finished'.format(self.name))
-                def start(self, filename=None):
-                    self.writeXml(filename)
-                    self.createObjects()
-                    self.connectObjects()
-                    self.run()

schainpy/controller_api.py +2 -2

             import threading
             from Queue import Queue
             from schainpy.controller import Project
             from schainpy.model.graphics.jroplotter import PlotManager
             class ControllerThread(threading.Thread, Project):
                 def __init__(self, plotter_queue=None):
                     threading.Thread.__init__(self)
                     Project.__init__(self, plotter_queue)
                     self.setDaemon(True)
                     self.lock = threading.Lock()
-                    self.control = {'stop':False, 'pause':False}
+                    self.control = { 'stop':False, 'pause':False }
                 def __del__(self):
                     self.control['stop'] = True
                 def stop(self):
                     self.lock.acquire()
                     self.control['stop'] = True
                     self.lock.release()
                 def pause(self):
                     self.lock.acquire()
                     self.control['pause'] = not(self.control['pause'])
                     paused = self.control['pause']
                     self.lock.release()
                     return paused
                 def isPaused(self):
                     self.lock.acquire()
                     paused = self.control['pause']
                     self.lock.release()
                     return paused
                 def isStopped(self):
                     self.lock.acquire()
                     stopped = self.control['stop']
                     self.lock.release()
                     return stopped
                 def run(self):
                     self.control['stop'] = False
                     self.control['pause'] = False
                     self.writeXml()
                     self.createObjects()
                     self.connectObjects()
                     Project.run(self)
                 def isRunning(self):
                     return self.is_alive()
                 def isFinished(self):
                     return not self.is_alive()
                 def setPlotters(self):
                     plotterList = PlotManager.plotterList
                     for thisPUConfObj in self.procUnitConfObjDict.values():
                         inputId = thisPUConfObj.getInputId()
                         if int(inputId) == 0:
                             continue
                         for thisOpObj in thisPUConfObj.getOperationObjList():
                             if thisOpObj.type == "self":
                                 continue
                             if thisOpObj.name in plotterList:
                                 thisOpObj.type = "other"
                 def setPlotterQueue(self, plotter_queue):
                     self.plotterQueue = plotter_queue
                 def getPlotterQueue(self):
                     return self.plotterQueue
                 def useExternalPlotter(self):
                     self.plotterQueue = Queue(10)
                     self.setPlotters()
                     plotManagerObj = PlotManager(self.plotterQueue)
                     plotManagerObj.setController(self)
                     return plotManagerObj
             # from PyQt4 import QtCore
             # from PyQt4.QtCore import SIGNAL
             #
             # class ControllerQThread(QtCore.QThread, Project):
             #
             #     def __init__(self, filename):
             #
             #         QtCore.QThread.__init__(self)
             #         Project.__init__(self)
             #
             #         self.filename = filename
             #
             #         self.lock = threading.Lock()
             #         self.control = {'stop':False, 'pause':False}
             #
             #     def __del__(self):
             #
             #         self.control['stop'] = True
             #         self.wait()
             #
             #     def stop(self):
             #
             #         self.lock.acquire()
             #
             #         self.control['stop'] = True
             #
             #         self.lock.release()
             #
             #     def pause(self):
             #
             #         self.lock.acquire()
             #
             #         self.control['pause'] = not(self.control['pause'])
             #         paused = self.control['pause']
             #
             #         self.lock.release()
             #
             #         return paused
             #
             #     def isPaused(self):
             #
             #         self.lock.acquire()
             #         paused = self.control['pause']
             #         self.lock.release()
             #
             #         return paused
             #
             #     def isStopped(self):
             #
             #         self.lock.acquire()
             #         stopped = self.control['stop']
             #         self.lock.release()
             #
             #         return stopped
             #
             #     def run(self):
             #
             #         self.control['stop'] = False
             #         self.control['pause'] = False
             #
             #         self.readXml(self.filename)
             #         self.createObjects()
             #         self.connectObjects()
             #         self.emit( SIGNAL( "jobStarted( PyQt_PyObject )" ), 1)
             #         Project.run(self)
             #         self.emit( SIGNAL( "jobFinished( PyQt_PyObject )" ), 1)
             #

schainpy/gui/viewcontroller/basicwindow.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/__init__.py +1 -1

             #from schainpy.model.data.jrodata import *
             # from schainpy.model.io.jrodataIO import *
             # from schainpy.model.proc.jroprocessing import *
             # from schainpy.model.graphics.jroplot import *
             # from schainpy.model.utils.jroutils import *
             # from schainpy.serializer import *
             from data import *
             from io import *
             from proc import *
             from graphics import *
-            from utils import *
+            from utils import *
  No newline at end of file

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

             '''
             $Author: murco $
             $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
             '''
             import copy
             import numpy
             import datetime
             from jroheaderIO import SystemHeader, RadarControllerHeader
             from schainpy import cSchain
             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:
                     -1        :    any error
                     anoise    :    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 lnoise
                 return cSchain.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 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
             class JROData(GenericData):
             #    m_BasicHeader = BasicHeader()
             #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 datatype = None #dtype but in string
             #     dtype = None
             #    nChannels = None
             #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
             #     nCode = None
             #
             #     nBaud = None
             #
             #     code = None
                 flagDecodeData = False #asumo q la data no esta decodificada
                 flagDeflipData = False #asumo q la data no esta sin flip
                 flagShiftFFT = False
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
             #     noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 def getNoise(self):
                     raise NotImplementedError
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNHeights(self):
                     return len(self.heightList)
                 def getHeiRange(self, extrapoints=0):
                     heis = self.heightList
             #        deltah = self.heightList[1] - self.heightList[0]
             #
             #        heis.append(self.heightList[-1])
                     return heis
                 def getDeltaH(self):
                     delta = self.heightList[1] - self.heightList[0]
                     return delta
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(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)
                     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
                 def get_ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                     return
                 def get_dtype(self):
                     '''
                     '''
                     return getNumpyDtype(self.datatype)
                 def set_dtype(self, numpyDtype):
                     '''
                     '''
                     self.datatype = getDataTypeCode(numpyDtype)
                 def get_code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 def set_code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                     return
                 def get_ncode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 def set_ncode(self, nCode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = nCode
                     return
                 def get_nbaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 def set_nbaud(self, nBaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nBaud
                     return
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 #noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 dtype = property(get_dtype, set_dtype)
             #     timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 code = property(get_code, set_code)
                 nCode = property(get_ncode, set_ncode)
                 nBaud = property(get_nbaud, set_nbaud)
             class Voltage(JROData):
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = 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.flagShiftFFT = False
                     self.flagDataAsBlock = False    #Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                 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
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt
                     return timeInterval
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Spectra(JROData):
                 #data spc es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 #data cspc es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 #data dc es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 #data power
                 data_pwr = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nIncohInt = None
                 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
                 nCohInt = None #se requiere para determinar el valor de timeInterval
                 ippFactor = None
                 profileIndex = 0
                 plotting = "spectra"
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.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.noise = None
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                 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:
                         return self.noise_estimation #this was estimated by getNoise Operation defined in jroproc_spectra.py
                     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
                     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
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints*self.ippFactor)
                     velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) #- deltav/2
                     return velrange
                 def getNPairs(self):
                     return len(self.pairsList)
                 def getPairsIndexList(self):
                     return range(self.nPairs)
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #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
                 def getFlagCspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 def getFlagDc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles
                     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
                 nPairs = property(getNPairs, setValue, "I'm the 'nPairs' property.")
                 pairsIndexList = property(getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
                 normFactor = property(getNormFactor, setValue, "I'm the 'getNormFactor' property.")
                 flag_cspc = property(getFlagCspc, setValue)
                 flag_dc = property(getFlagDc, setValue)
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, setValue, "I'm the 'timeInterval' property")
             class SpectraHeis(Spectra):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nCohInt = None
                 nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
             #         self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt*self.nCohInt*pwcode
                     return normFactor
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Fits(JROData):
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
                 nIncohInt = None
                 noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #         self.channelIndexList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
             #         self.utctime = None
             #         self.timeZone = None
             #         self.ltctime = None
             #         self.timeInterval = None
             #         self.header = None
             #         self.data_header = None
             #         self.data = None
             #         self.datatime = None
             #         self.flagNoData = False
             #         self.expName = ''
             #         self.nChannels = None
             #         self.nSamples = None
             #         self.dataBlocksPerFile = None
             #         self.comments = ''
             #
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getHeiRange(self):
                     heis = self.heightList
                     return heis
                 def getNHeights(self):
                     return len(self.heightList)
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNoise(self, type = 1):
                     #noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Correlation(JROData):
                 noise = None
                 SNR = None
                 #--------------------------------------------------
                 mode = None
                 split = False
                 data_cf = None
                 lags = None
                 lagRange = None
                 pairsList = None
                 normFactor = None
                 #--------------------------------------------------
             #     calculateVelocity = None
                 nLags = None
                 nPairs = None
                 nAvg = None
                 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 = None
                     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[range(0,1)] = ind_vel[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(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
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nProfiles
                     return timeInterval
                 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
                 def getNormFactor(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
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 normFactor = property(getNormFactor, "I'm the 'normFactor property'")
             class Parameters(Spectra):
                 experimentInfo = None   #Information about the experiment
                 #Information from previous data
                 inputUnit = None        #Type of data to be processed
                 operation = None        #Type of operation to parametrize
                 #normFactor = None       #Normalization Factor
                 groupList = None        #List of Pairs, Groups, etc
                 #Parameters
                 data_param = None       #Parameters obtained
                 data_pre = None         #Data Pre Parametrization
                 data_SNR = None         #Signal to Noise Ratio
             #     heightRange = None      #Heights
                 abscissaList = None    #Abscissa, can be velocities, lags or time
             #    noise = None            #Noise Potency
                 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"
                 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
                 def getTimeInterval(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
                 timeInterval = property(getTimeInterval)
                 noise = property(getNoise, setValue, "I'm the 'Noise' property.")

schainpy/model/graphics/figure.py +1 -1

             import os
             import numpy
             import time, datetime
             import mpldriver
             from schainpy.model.proc.jroproc_base import Operation
             def isTimeInHourRange(datatime, xmin, xmax):
                 if xmin == None or xmax == None:
                     return 1
                 hour = datatime.hour + datatime.minute/60.0
                 if xmin < (xmax % 24):
                     if hour >= xmin and hour <= xmax:
                         return 1
                     else:
                         return 0
                 else:
                     if hour >= xmin or hour <= (xmax % 24):
                         return 1
                     else:
                         return 0
                 return 0
             def isRealtime(utcdatatime):
                 utcnow = time.mktime(time.localtime())
                 delta = abs(utcnow - utcdatatime) # abs
                 if delta >= 30.:
                     return False
                 return True
             class Figure(Operation):
                 __driver = mpldriver
                 fig = None
                 id = None
                 wintitle = None
                 width = None
                 height = None
                 nplots = None
                 timerange = None
                 axesObjList = []
                 WIDTH = 300
                 HEIGHT = 200
                 PREFIX = 'fig'
                 xmin = None
                 xmax = None
                 counter_imagwr = 0
                 figfile = None
                 created = False
+                parameters = {}
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                 def __del__(self):
                     self.__driver.closeFigure()
                 def getFilename(self, name, ext='.png'):
                     path = '%s%03d' %(self.PREFIX, self.id)
                     filename = '%s_%s%s' %(self.PREFIX, name, ext)
                     return os.path.join(path, filename)
                 def getAxesObjList(self):
                     return self.axesObjList
                 def getSubplots(self):
                     raise NotImplementedError
                 def getScreenDim(self, widthplot, heightplot):
                     nrow, ncol = self.getSubplots()
                     widthscreen = widthplot*ncol
                     heightscreen = heightplot*nrow
                     return widthscreen, heightscreen
                 def getTimeLim(self, x, xmin=None, xmax=None, timerange=None):
             #         if self.xmin != None and self.xmax != None:
             #             if timerange == None:
             #                 timerange = self.xmax - self.xmin
             #             xmin = self.xmin + timerange
             #             xmax = self.xmax + timerange
             #
             #             return xmin, xmax
                     if timerange == None and (xmin==None or xmax==None):
                         timerange = 14400   #seconds
                     if timerange != None:
                         txmin = x[0] #- x[0] % min(timerange/10, 10*60)
                     else:
                         txmin = x[0] #- x[0] % 10*60
                     thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
                     thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
                     if timerange != None:
                         xmin = (thisdatetime - thisdate).seconds/(60*60.)
                         xmax = xmin + timerange/(60*60.)
                     d1970 = datetime.datetime(1970,1,1)
                     mindt = thisdate + datetime.timedelta(hours=xmin) #- datetime.timedelta(seconds=time.timezone)
                     xmin_sec = (mindt - d1970).total_seconds() #time.mktime(mindt.timetuple()) - time.timezone
                     maxdt = thisdate + datetime.timedelta(hours=xmax) #- datetime.timedelta(seconds=time.timezone)
                     xmax_sec = (maxdt - d1970).total_seconds() #time.mktime(maxdt.timetuple()) - time.timezone
                     return xmin_sec, xmax_sec
                 def init(self, id, nplots, wintitle):
                     raise NotImplementedError, "This method has been replaced by createFigure"
                 def createFigure(self, id, wintitle, widthplot=None, heightplot=None, show=True):
                     """
                     Crea la figura de acuerdo al driver y parametros seleccionados seleccionados.
                     Las dimensiones de la pantalla es calculada a partir de los atributos self.WIDTH
                     y self.HEIGHT y el numero de subplots (nrow, ncol)
                     Input:
                         id    :    Los parametros necesarios son
                         wintitle    :
                     """
                     if widthplot == None:
                         widthplot = self.WIDTH
                     if heightplot == None:
                         heightplot = self.HEIGHT
                     self.id = id
                     self.wintitle = wintitle
                     self.widthscreen, self.heightscreen = self.getScreenDim(widthplot, heightplot)
             #         if self.created:
             #             self.__driver.closeFigure(self.fig)
                     if not self.created:
                         self.fig = self.__driver.createFigure(id=self.id,
                                                               wintitle=self.wintitle,
                                                               width=self.widthscreen,
                                                               height=self.heightscreen,
                                                               show=show)
                     else:
                         self.__driver.clearFigure(self.fig)
                     self.axesObjList = []
                     self.counter_imagwr = 0
                     self.created = True
                 def setDriver(self, driver=mpldriver):
                     self.__driver = driver
                 def setTitle(self, title):
                     self.__driver.setTitle(self.fig, title)
                 def setWinTitle(self, title):
                     self.__driver.setWinTitle(self.fig, title=title)
                 def setTextFromAxes(self, text):
                     raise NotImplementedError, "This method has been replaced with Axes.setText"
                 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
                     raise NotImplementedError, "This method has been replaced with Axes.addAxes"
                 def addAxes(self, *args):
                     """
                     Input:
                         *args    :    Los parametros necesarios son
                                       nrow, ncol, xpos, ypos, colspan, rowspan
                     """
                     axesObj = Axes(self.fig, *args)
                     self.axesObjList.append(axesObj)
                 def saveFigure(self, figpath, figfile, *args):
                     filename = os.path.join(figpath, figfile)
                     fullpath = os.path.split(filename)[0]
                     if not os.path.exists(fullpath):
                         subpath = os.path.split(fullpath)[0]
                         if not os.path.exists(subpath):
                             os.mkdir(subpath)
                         os.mkdir(fullpath)
                     self.__driver.saveFigure(self.fig, filename, *args)
                 def save(self, figpath, figfile=None, save=True, ftp=False, wr_period=1, thisDatetime=None, update_figfile=True):
                     self.counter_imagwr += 1
                     if self.counter_imagwr < wr_period:
                         return
                     self.counter_imagwr = 0
                     if save:
                         if not figfile:
                             if not thisDatetime:
                                 raise ValueError, "Saving figure: figfile or thisDatetime should be defined"
                                 return
                             str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                             figfile = self.getFilename(name = str_datetime)
                         if self.figfile == None:
                             self.figfile = figfile
                         if update_figfile:
                             self.figfile = figfile
                         # store png plot to local folder
                         self.saveFigure(figpath, self.figfile)
                     if not ftp:
                         return
                     if not thisDatetime:
                         return
                     # store png plot to FTP server according to RT-Web format
                     ftp_filename = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
             #         ftp_filename = os.path.join(figpath, name)
                     self.saveFigure(figpath, ftp_filename)
                 def getNameToFtp(self, thisDatetime, FTP_WEI, EXP_CODE, SUB_EXP_CODE, PLOT_CODE, PLOT_POS):
                     YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year
                     DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday
                     FTP_WEI = '%2.2d'%FTP_WEI
                     EXP_CODE = '%3.3d'%EXP_CODE
                     SUB_EXP_CODE = '%2.2d'%SUB_EXP_CODE
                     PLOT_CODE = '%2.2d'%PLOT_CODE
                     PLOT_POS = '%2.2d'%PLOT_POS
                     name = YEAR_STR + DOY_STR + FTP_WEI + EXP_CODE + SUB_EXP_CODE + PLOT_CODE + PLOT_POS
                     return name
                 def draw(self):
                     self.__driver.draw(self.fig)
                 def run(self):
                     raise NotImplementedError
                 def close(self, show=False):
                     self.__driver.closeFigure(show=show, fig=self.fig)
                 axesList = property(getAxesObjList)
             class Axes:
                 __driver = mpldriver
                 fig = None
                 ax = None
                 plot = None
                 __missing = 1E30
                 __firsttime = None
                 __showprofile = False
                 xmin = None
                 xmax = None
                 ymin = None
                 ymax = None
                 zmin = None
                 zmax = None
                 x_buffer = None
                 z_buffer = None
                 decimationx = None
                 decimationy = None
                 __MAXNUMX = 200
                 __MAXNUMY = 400
                 __MAXNUMTIME = 500
                 def __init__(self, *args):
                     """
                     Input:
                         *args    :    Los parametros necesarios son
                                       fig, nrow, ncol, xpos, ypos, colspan, rowspan
                     """
                     ax = self.__driver.createAxes(*args)
                     self.fig = args[0]
                     self.ax = ax
                     self.plot = None
                     self.__firsttime = True
                     self.idlineList = []
                     self.x_buffer = numpy.array([])
                     self.z_buffer = numpy.array([])
                 def setText(self, text):
                     self.__driver.setAxesText(self.ax, text)
                 def setXAxisAsTime(self):
                     pass
                 def pline(self, x, y,
                            xmin=None, xmax=None,
                            ymin=None, ymax=None,
                            xlabel='', ylabel='',
                            title='',
                            **kwargs):
                     """
                     Input:
                         x        :
                         y        :
                         xmin    :
                         xmax    :
                         ymin    :
                         ymax    :
                         xlabel    :
                         ylabel    :
                         title    :
                         **kwargs :    Los parametros aceptados son
                                       ticksize
                                       ytick_visible
                     """
                     if self.__firsttime:
                         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)
                         self.plot = self.__driver.createPline(self.ax, x, y,
                                                               xmin, xmax,
                                                               ymin, ymax,
                                                               xlabel=xlabel,
                                                                 ylabel=ylabel,
                                                                 title=title,
                                                               **kwargs)
                         self.idlineList.append(0)
                         self.__firsttime = False
                         return
                     self.__driver.pline(self.plot, x, y, xlabel=xlabel,
                                                                 ylabel=ylabel,
                                                                 title=title)
             #         self.__driver.pause()
                 def addpline(self, x, y, idline, **kwargs):
                     lines = self.ax.lines
                     if idline in self.idlineList:
                         self.__driver.set_linedata(self.ax, x, y, idline)
                     if  idline not in(self.idlineList):
                         self.__driver.addpline(self.ax, x, y, **kwargs)
                         self.idlineList.append(idline)
                     return
                 def pmultiline(self, x, y,
                                xmin=None, xmax=None,
                                ymin=None, ymax=None,
                                xlabel='', ylabel='',
                                title='',
                                **kwargs):
                     if self.__firsttime:
                         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)
                         self.plot = self.__driver.createPmultiline(self.ax, x, y,
                                                               xmin, xmax,
                                                               ymin, ymax,
                                                               xlabel=xlabel,
                                                               ylabel=ylabel,
                                                               title=title,
                                                               **kwargs)
                         self.__firsttime = False
                         return
                     self.__driver.pmultiline(self.plot, x, y, xlabel=xlabel,
                                                                 ylabel=ylabel,
                                                                 title=title)
             #         self.__driver.pause()
                 def pmultilineyaxis(self, x, y,
                                xmin=None, xmax=None,
                                ymin=None, ymax=None,
                                xlabel='', ylabel='',
                                title='',
                                **kwargs):
                     if self.__firsttime:
                         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)
                         self.plot = self.__driver.createPmultilineYAxis(self.ax, x, y,
                                                               xmin, xmax,
                                                               ymin, ymax,
                                                               xlabel=xlabel,
                                                               ylabel=ylabel,
                                                               title=title,
                                                               **kwargs)
                         if self.xmin == None: self.xmin = xmin
                         if self.xmax == None: self.xmax = xmax
                         if self.ymin == None: self.ymin = ymin
                         if self.ymax == None: self.ymax = ymax
                         self.__firsttime = False
                         return
                     self.__driver.pmultilineyaxis(self.plot, x, y, xlabel=xlabel,
                                                                 ylabel=ylabel,
                                                                 title=title)
             #         self.__driver.pause()
                 def pcolor(self, x, y, z,
                            xmin=None, xmax=None,
                            ymin=None, ymax=None,
                            zmin=None, zmax=None,
                            xlabel='', ylabel='',
                            title='', colormap='jet',
                            **kwargs):
                     """
                     Input:
                         x        :
                         y        :
                         x        :
                         xmin    :
                         xmax    :
                         ymin    :
                         ymax    :
                         zmin    :
                         zmax    :
                         xlabel    :
                         ylabel    :
                         title    :
                         **kwargs :    Los parametros aceptados son
                                       ticksize=9,
                                       cblabel=''
                     """
                     #Decimating data
                     xlen = len(x)
                     ylen = len(y)
                     decimationx = int(xlen/self.__MAXNUMX) + 1
                     decimationy = int(ylen/self.__MAXNUMY) + 1
                     x_buffer = x#[::decimationx]
                     y_buffer = y#[::decimationy]
                     z_buffer = z#[::decimationx, ::decimationy]
                     #===================================================
                     if self.__firsttime:
                         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 = numpy.nanmin(z)
                         if zmax == None: zmax = numpy.nanmax(z)
                         self.plot = self.__driver.createPcolor(self.ax, x_buffer,
                                                                y_buffer,
                                                                z_buffer,
                                                                xmin, xmax,
                                                                ymin, ymax,
                                                                zmin, zmax,
                                                                xlabel=xlabel,
                                                                 ylabel=ylabel,
                                                                 title=title,
                                                                 colormap=colormap,
                                                                 **kwargs)
                         if self.xmin == None: self.xmin = xmin
                         if self.xmax == None: self.xmax = xmax
                         if self.ymin == None: self.ymin = ymin
                         if self.ymax == None: self.ymax = ymax
                         if self.zmin == None: self.zmin = zmin
                         if self.zmax == None: self.zmax = zmax
                         self.__firsttime = False
                         return
                     self.__driver.pcolor(self.plot,
                                          z_buffer,
                                          xlabel=xlabel,
                                          ylabel=ylabel,
                                          title=title)
             #         self.__driver.pause()
                 def pcolorbuffer(self, x, y, z,
                            xmin=None, xmax=None,
                            ymin=None, ymax=None,
                            zmin=None, zmax=None,
                            xlabel='', ylabel='',
                            title='', rti = True, colormap='jet',
                            maxNumX = None, maxNumY = None,
                            **kwargs):
                     if maxNumX == None:
                         maxNumX = self.__MAXNUMTIME
                     if maxNumY == None:
                         maxNumY = self.__MAXNUMY
                     if self.__firsttime:
                         self.z_buffer = z
                         self.x_buffer = numpy.hstack((self.x_buffer, x))
                         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 = numpy.nanmin(z)
                         if zmax == None: zmax = numpy.nanmax(z)
                         self.plot = self.__driver.createPcolor(self.ax, self.x_buffer, y, z,
                                                                xmin, xmax,
                                                                ymin, ymax,
                                                                zmin, zmax,
                                                                xlabel=xlabel,
                                                                 ylabel=ylabel,
                                                                 title=title,
                                                                 colormap=colormap,
                                                                 **kwargs)
                         if self.xmin == None: self.xmin = xmin
                         if self.xmax == None: self.xmax = xmax
                         if self.ymin == None: self.ymin = ymin
                         if self.ymax == None: self.ymax = ymax
                         if self.zmin == None: self.zmin = zmin
                         if self.zmax == None: self.zmax = zmax
                         self.__firsttime = False
                         return
                     self.x_buffer = numpy.hstack((self.x_buffer[:-1], x[0], x[-1]))
                     self.z_buffer = numpy.hstack((self.z_buffer, z))
                     z_buffer = self.z_buffer.reshape(-1,len(y))
                     #Decimating data
                     xlen = len(self.x_buffer)
                     ylen = len(y)
                     decimationx = int(xlen/maxNumX) + 1
                     decimationy = int(ylen/maxNumY) + 1
                     x_buffer = self.x_buffer#[::decimationx]
                     y_buffer = y#[::decimationy]
                     z_buffer = z_buffer#[::decimationx, ::decimationy]
                     #===================================================
                     x_buffer, y_buffer, z_buffer = self.__fillGaps(x_buffer, y_buffer, z_buffer)
                     self.__driver.addpcolorbuffer(self.ax, x_buffer, y_buffer, z_buffer, self.zmin, self.zmax,
                                             xlabel=xlabel,
                                             ylabel=ylabel,
                                             title=title,
                                             colormap=colormap)
             #         self.__driver.pause()
                 def polar(self, x, y,
                            title='', xlabel='',ylabel='',**kwargs):
                     if self.__firsttime:
                         self.plot = self.__driver.createPolar(self.ax, x, y, title = title, xlabel = xlabel, ylabel = ylabel)
                         self.__firsttime = False
                         self.x_buffer = x
                         self.y_buffer = y
                         return
                     self.x_buffer = numpy.hstack((self.x_buffer,x))
                     self.y_buffer = numpy.hstack((self.y_buffer,y))
                     self.__driver.polar(self.plot, self.x_buffer, self.y_buffer, xlabel=xlabel,
                                                         ylabel=ylabel,
                                                         title=title)
             #         self.__driver.pause()
                 def __fillGaps(self, x_buffer, y_buffer, z_buffer):
                     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,0.99*self.__missing,1.01*self.__missing)
                     return x_buffer, y_buffer, z_buffer

schainpy/model/graphics/jroplot_correlation.py +1 -2

             import os
             import datetime
             import numpy
             import copy
+            from schainpy.model import *
             from figure import Figure, isRealtime
             class CorrelationPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'corr'
                 def __init__(self):
                     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)
                     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,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       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)
                             if showprofile:
                                 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)):
                             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.getHeiRange()
                     z = copy.copy(dataOut.data_corr[:,:,0,:])
                     for i in range(dataOut.data_corr.shape[0]):
                         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 = 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"))
                         title = "Channel %d and %d: : %s" %(dataOut.pairsList[i][0],dataOut.pairsList[i][1] , str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         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)

schainpy/model/graphics/jroplot_data.py +514 -687

This diff has been collapsed as it changes many lines, (1201 lines changed) Show them Hide them
	@@ -1,955 +1,782
	1		1
	2	import os	2	import os
	3	import zmq
	4	import time	3	import time
	5	import ~~numpy~~	4	import glob
	6	import datetime	5	import datetime
	7	import numpy as np	6	from multiprocessing import Process
			7
			8	import zmq
			9	import numpy
	8	import matplotlib	10	import matplotlib
	9	import glob
	10	matplotlib.use('TkAgg')
	11	import matplotlib.pyplot as plt	11	import matplotlib.pyplot as plt
	12	from mpl_toolkits.axes_grid1 import make_axes_locatable	12	from mpl_toolkits.axes_grid1 import make_axes_locatable
	13	from matplotlib.ticker import FuncFormatter, LinearLocator	13	from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
	14	from multiprocessing import Process
	15		14
	16	from schainpy.model.proc.jroproc_base import Operation	15	from schainpy.model.proc.jroproc_base import Operation
	17		16	from schainpy.utils import log
	18	plt.ion()
	19		17
	20	func = lambda x, pos: ('%s') %(datetime.datetime.fromtimestamp(x).strftime('%H:%M'))	18	func = lambda x, pos: ('%s') %(datetime.datetime.fromtimestamp(x).strftime('%H:%M'))
	21		19
	22	d1970 = datetime.datetime(1970,1,1)	20	d1970 = datetime.datetime(1970, 1, 1)
			21
	23		22
	24	class PlotData(Operation, Process):	23	class PlotData(Operation, Process):
			24	'''
			25	Base class for Schain plotting operations
			26	'''
	25		27
	26	CODE = 'Figure'	28	CODE = 'Figure'
	27	colormap = 'jro'	29	colormap = 'jro'
			30	bgcolor = 'white'
	28	CONFLATE = False	31	CONFLATE = False
	29	__MAXNUMX = 80	32	__MAXNUMX = 80
	30	__missing = 1E30	33	__missing = 1E30
	31		34
	32	def __init__(self, **kwargs):	35	def __init__(self, **kwargs):
	33		36
	34	Operation.__init__(self, plot=True, **kwargs)	37	Operation.__init__(self, plot=True, **kwargs)
	35	Process.__init__(self)	38	Process.__init__(self)
	36	self.kwargs['code'] = self.CODE	39	self.kwargs['code'] = self.CODE
	37	self.mp = False	40	self.mp = False
	38	self.data~~Out~~ = None	41	self.data = None
	39	self.isConfig = False	42	self.isConfig = False
	40	self.figure = ~~None~~	43	self.figures = []
	41	self.axes = []	44	self.axes = []
			45	self.cb_axes = []
	42	self.localtime = kwargs.pop('localtime', True)	46	self.localtime = kwargs.pop('localtime', True)
	43	self.show = kwargs.get('show', True)	47	self.show = kwargs.get('show', True)
	44	self.save = kwargs.get('save', False)	48	self.save = kwargs.get('save', False)
	45	self.colormap = kwargs.get('colormap', self.colormap)	49	self.colormap = kwargs.get('colormap', self.colormap)
	46	self.colormap_coh = kwargs.get('colormap_coh', 'jet')	50	self.colormap_coh = kwargs.get('colormap_coh', 'jet')
	47	self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')	51	self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
	48	self.~~showprofile~~ = kwargs.get('~~showprofile~~', ~~Tru~~e)	52	self.colormaps = kwargs.get('colormaps', None)
	49	self.~~title~~ = kwargs.get('~~wintitle~~', '')	53	self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
			54	self.showprofile = kwargs.get('showprofile', False)
			55	self.title = kwargs.get('wintitle', self.CODE.upper())
			56	self.cb_label = kwargs.get('cb_label', None)
			57	self.cb_labels = kwargs.get('cb_labels', None)
	50	self.xaxis = kwargs.get('xaxis', 'frequency')	58	self.xaxis = kwargs.get('xaxis', 'frequency')
	51	self.zmin = kwargs.get('zmin', None)	59	self.zmin = kwargs.get('zmin', None)
	52	self.zmax = kwargs.get('zmax', None)	60	self.zmax = kwargs.get('zmax', None)
			61	self.zlimits = kwargs.get('zlimits', None)
	53	self.xmin = kwargs.get('xmin', None)	62	self.xmin = kwargs.get('xmin', None)
			63	if self.xmin is not None:
			64	self.xmin += 5
	54	self.xmax = kwargs.get('xmax', None)	65	self.xmax = kwargs.get('xmax', None)
	55	self.xrange = kwargs.get('xrange', 24)	66	self.xrange = kwargs.get('xrange', 24)
	56	self.ymin = kwargs.get('ymin', None)	67	self.ymin = kwargs.get('ymin', None)
	57	self.ymax = kwargs.get('ymax', None)	68	self.ymax = kwargs.get('ymax', None)
	58	self.~~__MAXNUMY~~ = kwargs.get('~~decimation~~', 80)	69	self.xlabel = kwargs.get('xlabel', None)
	59	self.throttle_value = 5	70	self.__MAXNUMY = kwargs.get('decimation', 100)
	60	self.times = []	71	self.showSNR = kwargs.get('showSNR', False)
	61	#self.interactive = self.kwargs['parent']	72	self.oneFigure = kwargs.get('oneFigure', True)
			73	self.width = kwargs.get('width', None)
			74	self.height = kwargs.get('height', None)
			75	self.colorbar = kwargs.get('colorbar', True)
			76	self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
			77	self.titles = ['' for __ in range(16)]
			78
			79	def __setup(self):
			80	'''
			81	Common setup for all figures, here figures and axes are created
			82	'''
			83
			84	self.setup()
	62		85
			86	if self.width is None:
			87	self.width = 8
			88
			89	self.figures = []
			90	self.axes = []
			91	self.cb_axes = []
			92	self.pf_axes = []
			93	self.cmaps = []
			94
			95	size = '15%' if self.ncols==1 else '30%'
			96	pad = '4%' if self.ncols==1 else '8%'
			97
			98	if self.oneFigure:
			99	if self.height is None:
			100	self.height = 1.4*self.nrows + 1
			101	fig = plt.figure(figsize=(self.width, self.height),
			102	edgecolor='k',
			103	facecolor='w')
			104	self.figures.append(fig)
			105	for n in range(self.nplots):
			106	ax = fig.add_subplot(self.nrows, self.ncols, n+1)
			107	ax.tick_params(labelsize=8)
			108	ax.firsttime = True
			109	self.axes.append(ax)
			110	if self.showprofile:
			111	cax = self.__add_axes(ax, size=size, pad=pad)
			112	cax.tick_params(labelsize=8)
			113	self.pf_axes.append(cax)
			114	else:
			115	if self.height is None:
			116	self.height = 3
			117	for n in range(self.nplots):
			118	fig = plt.figure(figsize=(self.width, self.height),
			119	edgecolor='k',
			120	facecolor='w')
			121	ax = fig.add_subplot(1, 1, 1)
			122	ax.tick_params(labelsize=8)
			123	ax.firsttime = True
			124	self.figures.append(fig)
			125	self.axes.append(ax)
			126	if self.showprofile:
			127	cax = self.__add_axes(ax, size=size, pad=pad)
			128	cax.tick_params(labelsize=8)
			129	self.pf_axes.append(cax)
			130
			131	for n in range(self.nrows):
			132	if self.colormaps is not None:
			133	cmap = plt.get_cmap(self.colormaps[n])
			134	else:
			135	cmap = plt.get_cmap(self.colormap)
			136	cmap.set_bad(self.bgcolor, 1.)
			137	self.cmaps.append(cmap)
			138
			139	def __add_axes(self, ax, size='30%', pad='8%'):
	63	'''	140	'''
	64	this new parameter is created to plot data from varius channels at different figures	141	Add new axes to the given figure
	65	1. crear una lista de figuras donde se puedan plotear las figuras,
	66	2. dar las opciones de configuracion a cada figura, estas opciones son iguales para ambas figuras
	67	3. probar?
	68	'''	142	'''
	69	self.ind_plt_ch = kwargs.get('ind_plt_ch', False)	143	divider = make_axes_locatable(ax)
	70	self.figurelist = None	144	nax = divider.new_horizontal(size=size, pad=pad)
			145	ax.figure.add_axes(nax)
			146	return nax
	71		147
	72		148
	73	def fill_gaps(self, x_buffer, y_buffer, z_buffer):	149	def setup(self):
			150	'''
			151	This method should be implemented in the child class, the following
			152	attributes should be set:
			153
			154	self.nrows: number of rows
			155	self.ncols: number of cols
			156	self.nplots: number of plots (channels or pairs)
			157	self.ylabel: label for Y axes
			158	self.titles: list of axes title
			159
			160	'''
			161	raise(NotImplementedError, 'Implement this method in child class')
	74		162
			163	def fill_gaps(self, x_buffer, y_buffer, z_buffer):
			164	'''
			165	Create a masked array for missing data
			166	'''
	75	if x_buffer.shape[0] < 2:	167	if x_buffer.shape[0] < 2:
	76	return x_buffer, y_buffer, z_buffer	168	return x_buffer, y_buffer, z_buffer
	77		169
	78	deltas = x_buffer[1:] - x_buffer[0:-1]	170	deltas = x_buffer[1:] - x_buffer[0:-1]
	79	x_median = np.median(deltas)	171	x_median = numpy.median(deltas)
	80		172
	81	index = np.where(deltas > 5*x_median)	173	index = numpy.where(deltas > 5*x_median)
	82		174
	83	if len(index[0]) != 0:	175	if len(index[0]) != 0:
	84	z_buffer[::, index[0], ::] = self.__missing	176	z_buffer[::, index[0], ::] = self.__missing
	85	z_buffer = np.ma.masked_inside(z_buffer,	177	z_buffer = numpy.ma.masked_inside(z_buffer,
	86	0.99*self.__missing,	178	0.99*self.__missing,
	87	1.01*self.__missing)	179	1.01*self.__missing)
	88		180
	89	return x_buffer, y_buffer, z_buffer	181	return x_buffer, y_buffer, z_buffer
	90		182
	91	def decimate(self):	183	def decimate(self):
	92		184
	93	# dx = int(len(self.x)/self.__MAXNUMX) + 1	185	# dx = int(len(self.x)/self.__MAXNUMX) + 1
	94	dy = int(len(self.y)/self.__MAXNUMY) + 1	186	dy = int(len(self.y)/self.__MAXNUMY) + 1
	95		187
	96	# x = self.x[::dx]	188	# x = self.x[::dx]
	97	x = self.x	189	x = self.x
	98	y = self.y[::dy]	190	y = self.y[::dy]
	99	z = self.z[::, ::, ::dy]	191	z = self.z[::, ::, ::dy]
	100		192
	101	return x, y, z	193	return x, y, z
	102		194
	103	'''	195	def format(self):
	104	JM:	196	'''
	105	elimana las otras imagenes generadas debido a que lso workers no llegan en orden y le pueden	197	Set min and max values, labels, ticks and titles
	106	poner otro tiempo a la figura q no necesariamente es el ultimo.	198	'''
	107	Solo se realiza cuando termina la imagen.
	108	Problemas:
	109		199
	110	File "/home/ci-81/workspace/schainv2.3/schainpy/model/graphics/jroplot_data.py", line 145, in __plot	200	if self.xmin is None:
	111	for n, eachfigure in enumerate(self.figurelist):	201	xmin = self.min_time
	112	TypeError: 'NoneType' object is not iterable	202	else:
			203	if self.xaxis is 'time':
			204	dt = datetime.datetime.fromtimestamp(self.min_time)
			205	xmin = (datetime.datetime.combine(dt.date(),
			206	datetime.time(int(self.xmin), 0, 0))-d1970).total_seconds()
			207	else:
			208	xmin = self.xmin
	113		209
	114	'''	210	if self.xmax is None:
	115	def deleteanotherfiles(self):	211	xmax = xmin+self.xrange6060
	116	figurenames=[]	212	else:
	117	if self.figurelist != None:	213	if self.xaxis is 'time':
	118	for n, eachfigure in enumerate(self.figurelist):	214	dt = datetime.datetime.fromtimestamp(self.min_time)
	119	#add specific name for each channel in channelList	215	xmax = (datetime.datetime.combine(dt.date(),
	120	ghostfigname = os.path.join(self.save, '{}_{}_{}'.format(self.titles[n].replace(' ',''),self.CODE,	216	datetime.time(int(self.xmax), 0, 0))-d1970).total_seconds()
	121	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d')))	217	else:
	122	figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n].replace(' ',''),self.CODE,	218	xmax = self.xmax
	123	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	219
	124		220	ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
	125	for ghostfigure in glob.glob(ghostfigname+'*'): #ghostfigure will adopt all posible names of figures	221	ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
	126	if ghostfigure != figname:	222
	127	os.remove(ghostfigure)	223	ystep = 200 if ymax>= 800 else 100 if ymax>=400 else 50 if ymax>=200 else 20
	128	print 'Removing GhostFigures:' , figname	224
	129	else :	225	for n, ax in enumerate(self.axes):
	130	'''Erasing ghost images for just on******************'''	226	if ax.firsttime:
	131	ghostfigname = os.path.join(self.save, '{}_{}'.format(self.CODE,datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d')))	227	ax.set_facecolor(self.bgcolor)
	132	figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	228	ax.yaxis.set_major_locator(MultipleLocator(ystep))
	133	for ghostfigure in glob.glob(ghostfigname+'*'): #ghostfigure will adopt all posible names of figures	229	if self.xaxis is 'time':
	134	if ghostfigure != figname:	230	ax.xaxis.set_major_formatter(FuncFormatter(func))
	135	os.remove(ghostfigure)	231	ax.xaxis.set_major_locator(LinearLocator(9))
	136	print 'Removing GhostFigures:' , figname	232	if self.xlabel is not None:
			233	ax.set_xlabel(self.xlabel)
			234	ax.set_ylabel(self.ylabel)
			235	ax.firsttime = False
			236	if self.showprofile:
			237	self.pf_axes[n].set_ylim(ymin, ymax)
			238	self.pf_axes[n].set_xlim(self.zmin, self.zmax)
			239	self.pf_axes[n].set_xlabel('dB')
			240	self.pf_axes[n].grid(b=True, axis='x')
			241	[tick.set_visible(False) for tick in self.pf_axes[n].get_yticklabels()]
			242	if self.colorbar:
			243	cb = plt.colorbar(ax.plt, ax=ax, pad=0.02)
			244	cb.ax.tick_params(labelsize=8)
			245	if self.cb_label:
			246	cb.set_label(self.cb_label, size=8)
			247	elif self.cb_labels:
			248	cb.set_label(self.cb_labels[n], size=8)
			249
			250	ax.set_title('{} - {} UTC'.format(
			251	self.titles[n],
			252	datetime.datetime.fromtimestamp(self.max_time).strftime('%H:%M:%S')),
			253	size=8)
			254	ax.set_xlim(xmin, xmax)
			255	ax.set_ylim(ymin, ymax)
			256
	137		257
	138	def __plot(self):	258	def __plot(self):
	139		259	'''
	140	print 'plotting...{}'.format(self.CODE)	260	'''
	141	if self.ind_plt_ch is False : #standard	261	log.success('Plotting', self.name)
			262
			263	self.plot()
			264	self.format()
			265
			266	for n, fig in enumerate(self.figures):
			267	if self.nrows == 0 or self.nplots == 0:
			268	log.warning('No data', self.name)
			269	continue
	142	if self.show:	270	if self.show:
	143	~~self~~.fig~~ure~~.show()	271	fig.show()
	144	~~self~~.~~plot~~()	272
	145	~~plt~~.tight_layout()	273	fig.tight_layout()
	146	~~self~~.fig~~ure~~.canvas.manager.set_window_title('{} {} - {}'.format(self.title, ~~self~~.~~CODE~~.~~upper(),~~	274	fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
	147	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))	275	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))
	148	else :	276	# fig.canvas.draw()
	149	print 'len(self.figurelist): ',len(self.figurelist)	277
	150	for n, eachfigure in enumerate(self.figurelist):	278	if self.save and self.data.ended:
	151	if self.~~show~~:	279	channels = range(self.nrows)
	152	~~eachfigure~~.~~show~~()	280	if self.oneFigure:
	153		281	label = ''
	154	~~self~~.~~plot~~()	282	else:
	155	eachfigure.tight_layout() # ajuste de cada subplot	283	label = '_{}'.format(channels[n])
	156	eachfigure.canvas.manager.set_window_title('{} {} - {}'.format(self.title[n], self.CODE.upper(),	284	figname = os.path.join(
	157	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))	285	self.save,
	158		286	'{}{}_{}.png'.format(
	159	# if self.save:	287	self.CODE,
	160	# if self.ind_plt_ch is False : #standard	288	label,
	161	# figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,	289	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')
	162	# datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	290	)
	163	# print 'Saving figure: {}'.format(figname)	291	)
	164	# self.figure.savefig(figname)
	165	# else :
	166	# for n, eachfigure in enumerate(self.figurelist):
	167	# #add specific name for each channel in channelList
	168	# figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n],self.CODE,
	169	# datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	170	#
	171	# print 'Saving figure: {}'.format(figname)
	172	# eachfigure.savefig(figname)
	173
	174	if self.ind_plt_ch is False :
	175	self.figure.canvas.draw()
	176	else :
	177	for eachfigure in self.figurelist:
	178	eachfigure.canvas.draw()
	179
	180	if self.save:
	181	if self.ind_plt_ch is False : #standard
	182	figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,
	183	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	184	print 'Saving figure: {}'.format(figname)	292	print 'Saving figure: {}'.format(figname)
	185	~~self~~.fig~~ure~~.savefig(figname)	293	fig.savefig(figname)
	186	else :
	187	for n, eachfigure in enumerate(self.figurelist):
	188	#add specific name for each channel in channelList
	189	figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n].replace(' ',''),self.CODE,
	190	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	191
	192	print 'Saving figure: {}'.format(figname)
	193	eachfigure.savefig(figname)
	194
	195		294
	196	def plot(self):	295	def plot(self):
	197		296	'''
	198	print 'plotting...{}'.format(self.CODE.upper())	297	'''
	199	return	298	raise(NotImplementedError, 'Implement this method in child class')
	200		299
	201	def run(self):	300	def run(self):
	202		301
	203	~~print~~ ~~'[Starting] {}'~~.~~format~~(self.name)	302	log.success('Starting', self.name)
	204		303
	205	context = zmq.Context()	304	context = zmq.Context()
	206	receiver = context.socket(zmq.SUB)	305	receiver = context.socket(zmq.SUB)
	207	receiver.setsockopt(zmq.SUBSCRIBE, '')	306	receiver.setsockopt(zmq.SUBSCRIBE, '')
	208	receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)	307	receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)
	209		308
	210	if 'server' in self.kwargs['parent']:	309	if 'server' in self.kwargs['parent']:
	211	receiver.connect('ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))	310	receiver.connect('ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))
	212	else:	311	else:
	213	receiver.connect("ipc:///tmp/zmq.plots")	312	receiver.connect("ipc:///tmp/zmq.plots")
	214
	215	seconds_passed = 0
	216		313
	217	while True:	314	while True:
	218	try:	315	try:
	219	self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)~~#flags=zmq.NOBLOCK~~	316	self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)
	220	self.started = self.data['STARTED']	317
	221	self.~~dataOut~~ = self.data[~~'dataOut'~~]	318	self.min_time = self.data.times[0]
	222		319	self.max_time = self.data.times[-1]
	223	if (len(self.times) < len(self.data['times']) and not self.started and self.data['ENDED']):
	224	continue
	225
	226	self.times = self.data['times']
	227	self.times.sort()
	228	self.throttle_value = self.data['throttle']
	229	self.min_time = self.times[0]
	230	self.max_time = self.times[-1]
	231		320
	232	if self.isConfig is False:	321	if self.isConfig is False:
	233	~~print~~ ~~'setting up'~~	322	self.__setup()
	234	self.setup()
	235	self.isConfig = True	323	self.isConfig = True
	236	self.__plot()	324
	237		325	self.__plot()
	238	if self.data['ENDED'] is True:
	239	print '******GRAPHIC ENDED******'
	240	self.ended = True
	241	self.isConfig = False
	242	self.__plot()
	243	self.deleteanotherfiles() #CLPDG
	244	elif seconds_passed >= self.data['throttle']:
	245	print 'passed', seconds_passed
	246	self.__plot()
	247	seconds_passed = 0
	248		326
	249	except zmq.Again as e:	327	except zmq.Again as e:
	250	~~print~~ 'Waiting for data...'	328	log.log('Waiting for data...')
	251	~~plt~~.~~pause~~(2)	329	if self.data:
	252	seconds_passed += 2	330	plt.pause(self.data.throttle)
			331	else:
			332	time.sleep(2)
	253		333
	254	def close(self):	334	def close(self):
	255	if self.data~~Out~~:	335	if self.data:
	256	self.__plot()	336	self.__plot()
	257		337
	258		338
	259	class PlotSpectraData(PlotData):	339	class PlotSpectraData(PlotData):
			340	'''
			341	Plot for Spectra data
			342	'''
	260		343
	261	CODE = 'spc'	344	CODE = 'spc'
	262	colormap = 'jro'	345	colormap = 'jro'
	263	CONFLATE = False
	264		346
	265	def setup(self):	347	def setup(self):
	266		348	self.nplots = len(self.data.channels)
	267	ncolspan = 1	349	self.ncols = int(numpy.sqrt(self.nplots)+ 0.9)
	268	colspan = 1	350	self.nrows = int((1.0*self.nplots/self.ncols) + 0.9)
	269	self.ncols = int(numpy.sqrt(self.dataOut.nChannels)+0.9)	351	self.width = 3.4*self.ncols
	270	self.nrows = int(self.dataOut.nChannels*1./self.ncols + 0.9)	352	self.height = 3*self.nrows
	271	self.width = 3.6*self.ncols	353	self.cb_label = 'dB'
	272	self.height = 3.2*self.nrows	354	if self.showprofile:
	273	if self.showprofile:	355	self.width += 0.8*self.ncols
	274	ncolspan = 3
	275	colspan = 2
	276	self.width += 1.2*self.ncols
	277		356
	278	self.ylabel = 'Range [Km]'	357	self.ylabel = 'Range [Km]'
	279	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]
	280
	281	if self.figure is None:
	282	self.figure = plt.figure(figsize=(self.width, self.height),
	283	edgecolor='k',
	284	facecolor='w')
	285	else:
	286	self.figure.clf()
	287
	288	n = 0
	289	for y in range(self.nrows):
	290	for x in range(self.ncols):
	291	if n >= self.dataOut.nChannels:
	292	break
	293	ax = plt.subplot2grid((self.nrows, self.ncolsncolspan), (y, xncolspan), 1, colspan)
	294	if self.showprofile:
	295	ax.ax_profile = plt.subplot2grid((self.nrows, self.ncolsncolspan), (y, xncolspan+colspan), 1, 1)
	296
	297	ax.firsttime = True
	298	self.axes.append(ax)
	299	n += 1
	300		358
	301	def plot(self):	359	def plot(self):
	302
	303	if self.xaxis == "frequency":	360	if self.xaxis == "frequency":
	304	x = self.data~~Out~~.~~getFreqRange~~(1)/~~1000.~~	361	x = self.data.xrange[0]
	305	xlabel = "Frequency (kHz)"	362	self.xlabel = "Frequency (kHz)"
	306	elif self.xaxis == "time":	363	elif self.xaxis == "time":
	307	x = self.data~~Out~~.~~getAcfRange~~(1)	364	x = self.data.xrange[1]
	308	xlabel = "Time (ms)"	365	self.xlabel = "Time (ms)"
	309	else:	366	else:
	310	x = self.data~~Out~~.~~getVelRange~~(1)	367	x = self.data.xrange[2]
	311	xlabel = "Velocity (m/s)"	368	self.xlabel = "Velocity (m/s)"
	312		369
	313	y = self.dataOut.getHeiRange()	370	if self.CODE == 'spc_mean':
	314	z = self.data[~~self~~.~~CODE~~]	371	x = self.data.xrange[2]
			372	self.xlabel = "Velocity (m/s)"
	315		373
			374	self.titles = []
			375
			376	y = self.data.heights
			377	self.y = y
			378	z = self.data['spc']
			379
	316	for n, ax in enumerate(self.axes):	380	for n, ax in enumerate(self.axes):
			381	noise = self.data['noise'][n][-1]
			382	if self.CODE == 'spc_mean':
			383	mean = self.data['mean'][n][-1]
	317	if ax.firsttime:	384	if ax.firsttime:
	318	self.xmax = self.xmax if self.xmax else np.nanmax(x)	385	self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
	319	self.xmin = self.xmin if self.xmin else -self.xmax	386	self.xmin = self.xmin if self.xmin else -self.xmax
	320	self.ymin = self.ymin if self.ymin else np.nanmin(y)	387	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	321	self.ymax = self.ymax if self.ymax else np.nanmax(y)	388	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	322	self.zmin = self.zmin if self.zmin else np.nanmin(z)	389	ax.plt = ax.pcolormesh(x, y, z[n].T,
	323	self.zmax = self.zmax if self.zmax else np.nanmax(z)	390	vmin=self.zmin,
	324	ax.plot = ax.pcolormesh(x, y, z[n].T,	391	vmax=self.zmax,
	325	~~vmin~~=self.~~zmin~~,	392	cmap=plt.get_cmap(self.colormap)
	326	~~vmax~~=~~self~~.~~zmax~~,	393	)
	327	cmap=plt.get_cmap(self.colormap)
	328	)
	329	divider = make_axes_locatable(ax)
	330	cax = divider.new_horizontal(size='3%', pad=0.05)
	331	self.figure.add_axes(cax)
	332	plt.colorbar(ax.plot, cax)
	333
	334	ax.set_xlim(self.xmin, self.xmax)
	335	ax.set_ylim(self.ymin, self.ymax)
	336
	337	ax.set_ylabel(self.ylabel)
	338	ax.set_xlabel(xlabel)
	339
	340	ax.firsttime = False
	341		394
	342	if self.showprofile:	395	if self.showprofile:
	343	ax.plot_profile= ax.~~ax_profile~~.plot(self.data['rti'][~~self~~.~~max_time~~][n], y)[0]	396	ax.plt_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], y)[0]
	344	ax.ax_profile.set_xlim(self.zmin, self.zmax)	397	ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
	345	ax.ax_profile.set_ylim(self.ymin, self.ymax)	398	color="k", linestyle="dashed", lw=1)[0]
	346	ax.ax_profile.set_xlabel('dB')	399	if self.CODE == 'spc_mean':
	347	ax.ax_profile.grid(b=True, axis='x')	400	ax.plt_mean = ax.plot(mean, y, color='k')[0]
	348	ax.plot_noise = ax.ax_profile.plot(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y,
	349	color="k", linestyle="dashed", lw=2)[0]
	350	[tick.set_visible(False) for tick in ax.ax_profile.get_yticklabels()]
	351	else:	401	else:
	352	ax.plot.set_array(z[n].T.ravel())	402	ax.plt.set_array(z[n].T.ravel())
	353	if self.showprofile:	403	if self.showprofile:
	354	ax.plot_profile.set_data(self.data['rti'][~~self~~.~~max_time~~][n], y)	404	ax.plt_profile.set_data(self.data['rti'][n][-1], y)
	355	ax.plot_noise.set_data(numpy.repeat(~~self~~.~~data~~['noise'][~~self~~.~~max_time~~][n], len(y)), y)	405	ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
			406	if self.CODE == 'spc_mean':
			407	ax.plt_mean.set_data(mean, y)
	356		408
	357	ax.set_title('{} - Noise: {:.2f} dB'.format(self.titles[n], self.data['noise'][self.max_time][n]),	409	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	358	size=8)
	359	self.saveTime = self.max_time	410	self.saveTime = self.max_time
	360		411
	361		412
	362	class PlotCrossSpectraData(PlotData):	413	class PlotCrossSpectraData(PlotData):
	363		414
	364	CODE = 'cspc'	415	CODE = 'cspc'
	365	zmin_coh = None	416	zmin_coh = None
	366	zmax_coh = None	417	zmax_coh = None
	367	zmin_phase = None	418	zmin_phase = None
	368	zmax_phase = None	419	zmax_phase = None
	369	CONFLATE = False
	370		420
	371	def setup(self):	421	def setup(self):
	372		422
	373	ncols~~pan~~ = 1	423	self.ncols = 4
	374	colspan = 1	424	self.nrows = len(self.data.pairs)
	375	self.n~~col~~s = 2	425	self.nplots = self.nrows*4
	376	self.~~nrows~~ = self.~~dataOut~~.~~nPair~~s	426	self.width = 3.4*self.ncols
	377	self.~~width~~ = 3.6*self.n~~col~~s	427	self.height = 3*self.nrows
	378	self.height = 3.2*self.nrows
	379
	380	self.ylabel = 'Range [Km]'	428	self.ylabel = 'Range [Km]'
	381	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]	429	self.showprofile = False
	382
	383	if self.figure is None:
	384	self.figure = plt.figure(figsize=(self.width, self.height),
	385	edgecolor='k',
	386	facecolor='w')
	387	else:
	388	self.figure.clf()
	389
	390	for y in range(self.nrows):
	391	for x in range(self.ncols):
	392	ax = plt.subplot2grid((self.nrows, self.ncols), (y, x), 1, 1)
	393	ax.firsttime = True
	394	self.axes.append(ax)
	395		430
	396	def plot(self):	431	def plot(self):
	397		432
	398	if self.xaxis == "frequency":	433	if self.xaxis == "frequency":
	399	x = self.data~~Out~~.~~getFreqRange~~(1)/~~1000.~~	434	x = self.data.xrange[0]
	400	xlabel = "Frequency (kHz)"	435	self.xlabel = "Frequency (kHz)"
	401	elif self.xaxis == "time":	436	elif self.xaxis == "time":
	402	x = self.data~~Out~~.~~getAcfRange~~(1)	437	x = self.data.xrange[1]
	403	xlabel = "Time (ms)"	438	self.xlabel = "Time (ms)"
	404	else:	439	else:
	405	x = self.data~~Out~~.~~getVelRange~~(1)	440	x = self.data.xrange[2]
	406	xlabel = "Velocity (m/s)"	441	self.xlabel = "Velocity (m/s)"
	407		442
	408	y = self.dataOut.getHeiRange()	443	self.titles = []
	409	z_coh = self.data['cspc_coh']	444
	410	~~z_phase~~ = self.data[~~'cspc_phase'~~]	445	y = self.data.heights
			446	self.y = y
			447	spc = self.data['spc']
			448	cspc = self.data['cspc']
	411		449
	412	for n in range(self.nrows):	450	for n in range(self.nrows):
	413	ax = self.~~axes~~[2*n]	451	noise = self.data['noise'][n][-1]
	414	~~ax1~~ = self.~~axe~~s[2*n+1]	452	pair = self.data.pairs[n]
			453	ax = self.axes[4*n]
			454	ax3 = self.axes[4*n+3]
	415	if ax.firsttime:	455	if ax.firsttime:
	416	self.xmax = self.xmax if self.xmax else np.nanmax(x)	456	self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
	417	self.xmin = self.xmin if self.xmin else -self.xmax	457	self.xmin = self.xmin if self.xmin else -self.xmax
	418	self.ymin = self.ymin if self.ymin else np.nanmin(y)	458	self.zmin = self.zmin if self.zmin else numpy.nanmin(spc)
	419	self.ymax = self.ymax if self.ymax else np.nanmax(y)	459	self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
	420	self.zmin_coh = self.zmin_coh if self.zmin_coh else 0.0	460	ax.plt = ax.pcolormesh(x, y, spc[pair[0]].T,
	421	self.zmax_coh = self.zmax_coh if self.zmax_coh else 1.0	461	vmin=self.zmin,
	422	self.zmin_phase = self.zmin_phase if self.zmin_phase else -180	462	vmax=self.zmax,
	423	self.zmax_phase = self.zmax_phase if self.zmax_phase else 180	463	cmap=plt.get_cmap(self.colormap)
	424		464	)
	425	ax.plot = ax.pcolormesh(x, y, z_coh[n].T,
	426	vmin=self.zmin_coh,
	427	vmax=self.zmax_coh,
	428	cmap=plt.get_cmap(self.colormap_coh)
	429	)
	430	divider = make_axes_locatable(ax)
	431	cax = divider.new_horizontal(size='3%', pad=0.05)
	432	self.figure.add_axes(cax)
	433	plt.colorbar(ax.plot, cax)
	434
	435	ax.set_xlim(self.xmin, self.xmax)
	436	ax.set_ylim(self.ymin, self.ymax)
	437
	438	ax.set_ylabel(self.ylabel)
	439	ax.set_xlabel(xlabel)
	440	ax.firsttime = False
	441
	442	ax1.plot = ax1.pcolormesh(x, y, z_phase[n].T,
	443	vmin=self.zmin_phase,
	444	vmax=self.zmax_phase,
	445	cmap=plt.get_cmap(self.colormap_phase)
	446	)
	447	divider = make_axes_locatable(ax1)
	448	cax = divider.new_horizontal(size='3%', pad=0.05)
	449	self.figure.add_axes(cax)
	450	plt.colorbar(ax1.plot, cax)
	451
	452	ax1.set_xlim(self.xmin, self.xmax)
	453	ax1.set_ylim(self.ymin, self.ymax)
	454
	455	ax1.set_ylabel(self.ylabel)
	456	ax1.set_xlabel(xlabel)
	457	ax1.firsttime = False
	458	else:	465	else:
	459	ax.plot.set_array(~~z_coh~~[n].T.ravel())	466	ax.plt.set_array(spc[pair[0]].T.ravel())
	460	ax1.plot.set_array(z_phase[n].T.ravel())	467	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	461
	462	ax.set_title('Coherence Ch{} * Ch{}'.format(self.dataOut.pairsList[n][0], self.dataOut.pairsList[n][1]), size=8)
	463	ax1.set_title('Phase Ch{} * Ch{}'.format(self.dataOut.pairsList[n][0], self.dataOut.pairsList[n][1]), size=8)
	464	self.saveTime = self.max_time
	465
	466
	467	class PlotSpectraMeanData(PlotSpectraData):
	468		468
	469	CODE = 'spc_mean'	469	ax = self.axes[4*n+1]
	470	colormap = 'jet'	470	if ax.firsttime:
	471		471	ax.plt = ax.pcolormesh(x, y, spc[pair[1]].T,
	472	def plot(self):
	473
	474	if self.xaxis == "frequency":
	475	x = self.dataOut.getFreqRange(1)/1000.
	476	xlabel = "Frequency (kHz)"
	477	elif self.xaxis == "time":
	478	x = self.dataOut.getAcfRange(1)
	479	xlabel = "Time (ms)"
	480	else:
	481	x = self.dataOut.getVelRange(1)
	482	xlabel = "Velocity (m/s)"
	483
	484	y = self.dataOut.getHeiRange()
	485	z = self.data['spc']
	486	mean = self.data['mean'][self.max_time]
	487
	488	for n, ax in enumerate(self.axes):
	489
	490	if ax.firsttime:
	491	self.xmax = self.xmax if self.xmax else np.nanmax(x)
	492	self.xmin = self.xmin if self.xmin else -self.xmax
	493	self.ymin = self.ymin if self.ymin else np.nanmin(y)
	494	self.ymax = self.ymax if self.ymax else np.nanmax(y)
	495	self.zmin = self.zmin if self.zmin else np.nanmin(z)
	496	self.zmax = self.zmax if self.zmax else np.nanmax(z)
	497	ax.plt = ax.pcolormesh(x, y, z[n].T,
	498	vmin=self.zmin,	472	vmin=self.zmin,
	499	vmax=self.zmax,	473	vmax=self.zmax,
	500	cmap=plt.get_cmap(self.colormap)	474	cmap=plt.get_cmap(self.colormap)
	501	)	475	)
	502	ax.plt_dop = ax.plot(mean[n], y,
	503	color='k')[0]
	504
	505	divider = make_axes_locatable(ax)
	506	cax = divider.new_horizontal(size='3%', pad=0.05)
	507	self.figure.add_axes(cax)
	508	plt.colorbar(ax.plt, cax)
	509
	510	ax.set_xlim(self.xmin, self.xmax)
	511	ax.set_ylim(self.ymin, self.ymax)
	512
	513	ax.set_ylabel(self.ylabel)
	514	ax.set_xlabel(xlabel)
	515
	516	ax.firsttime = False
	517
	518	if self.showprofile:
	519	ax.plt_profile= ax.ax_profile.plot(self.data['rti'][self.max_time][n], y)[0]
	520	ax.ax_profile.set_xlim(self.zmin, self.zmax)
	521	ax.ax_profile.set_ylim(self.ymin, self.ymax)
	522	ax.ax_profile.set_xlabel('dB')
	523	ax.ax_profile.grid(b=True, axis='x')
	524	ax.plt_noise = ax.ax_profile.plot(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y,
	525	color="k", linestyle="dashed", lw=2)[0]
	526	[tick.set_visible(False) for tick in ax.ax_profile.get_yticklabels()]
	527	else:	476	else:
	528	ax.plt.set_array(z[n].T.ravel())	477	ax.plt.set_array(spc[pair[1]].T.ravel())
	529	ax.plt_dop.set_data(mean[n], y)	478	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	530	if self.showprofile:	479
	531	ax.plt_profile.set_data(self.data['rti'][self.max_time][n], y)	480	out = cspc[n]/numpy.sqrt(spc[pair[0]]*spc[pair[1]])
	532	ax.plt_noise.set_data(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y)	481	coh = numpy.abs(out)
			482	phase = numpy.arctan2(out.imag, out.real)*180/numpy.pi
			483
			484	ax = self.axes[4*n+2]
			485	if ax.firsttime:
			486	ax.plt = ax.pcolormesh(x, y, coh.T,
			487	vmin=0,
			488	vmax=1,
			489	cmap=plt.get_cmap(self.colormap_coh)
			490	)
			491	else:
			492	ax.plt.set_array(coh.T.ravel())
			493	self.titles.append('Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
	533		494
	534	ax.set_title('{} - Noise: {:.2f} dB'.format(self.titles[n], self.data['noise'][self.max_time][n]),	495	ax = self.axes[4*n+3]
	535	size=8)	496	if ax.firsttime:
			497	ax.plt = ax.pcolormesh(x, y, phase.T,
			498	vmin=-180,
			499	vmax=180,
			500	cmap=plt.get_cmap(self.colormap_phase)
			501	)
			502	else:
			503	ax.plt.set_array(phase.T.ravel())
			504	self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
			505
	536	self.saveTime = self.max_time	506	self.saveTime = self.max_time
	537		507
	538		508
			509	class PlotSpectraMeanData(PlotSpectraData):
			510	'''
			511	Plot for Spectra and Mean
			512	'''
			513	CODE = 'spc_mean'
			514	colormap = 'jro'
			515
			516
	539	class PlotRTIData(PlotData):	517	class PlotRTIData(PlotData):
			518	'''
			519	Plot for RTI data
			520	'''
	540		521
	541	CODE = 'rti'	522	CODE = 'rti'
	542	colormap = 'jro'	523	colormap = 'jro'
	543		524
	544	def setup(self):	525	def setup(self):
	545	self.~~ncol~~s = 1	526	self.xaxis = 'time'
	546	self.nrows = self.dataOut.nChannels	527	self.ncols = 1
	547	self.width = 10	528	self.nrows = len(self.data.channels)
	548	#TODO : arreglar la altura de la figura, esta hardcodeada.	529	self.nplots = len(self.data.channels)
	549	#Se arreglo, testear!
	550	if self.ind_plt_ch:
	551	self.height = 3.2#*self.nrows if self.nrows<6 else 12
	552	else:
	553	self.height = 2.2*self.nrows if self.nrows<6 else 12
	554
	555	'''
	556	if self.nrows==1:
	557	self.height += 1
	558	'''
	559	self.ylabel = 'Range [Km]'	530	self.ylabel = 'Range [Km]'
	560	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]	531	self.cb_label = 'dB'
	561		532	self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
	562	'''
	563	Logica:
	564	1) Si la variable ind_plt_ch es True, va a crear mas de 1 figura
	565	2) guardamos "Figures" en una lista y "axes" en otra, quizas se deberia guardar el
	566	axis dentro de "Figures" como un diccionario.
	567	'''
	568	if self.ind_plt_ch is False: #standard mode
	569
	570	if self.figure is None: #solo para la priemra vez
	571	self.figure = plt.figure(figsize=(self.width, self.height),
	572	edgecolor='k',
	573	facecolor='w')
	574	else:
	575	self.figure.clf()
	576	self.axes = []
	577
	578
	579	for n in range(self.nrows):
	580	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)
	581	#ax = self.figure(n+1)
	582	ax.firsttime = True
	583	self.axes.append(ax)
	584
	585	else : #append one figure foreach channel in channelList
	586	if self.figurelist == None:
	587	self.figurelist = []
	588	for n in range(self.nrows):
	589	self.figure = plt.figure(figsize=(self.width, self.height),
	590	edgecolor='k',
	591	facecolor='w')
	592	#add always one subplot
	593	self.figurelist.append(self.figure)
	594
	595	else : # cada dia nuevo limpia el axes, pero mantiene el figure
	596	for eachfigure in self.figurelist:
	597	eachfigure.clf() # eliminaria todas las figuras de la lista?
	598	self.axes = []
	599
	600	for eachfigure in self.figurelist:
	601	ax = eachfigure.add_subplot(1,1,1) #solo 1 axis por figura
	602	#ax = self.figure(n+1)
	603	ax.firsttime = True
	604	#Cada figura tiene un distinto puntero
	605	self.axes.append(ax)
	606	#plt.close(eachfigure)
	607
	608		533
	609	def plot(self):	534	def plot(self):
			535	self.x = self.data.times
			536	self.y = self.data.heights
			537	self.z = self.data[self.CODE]
			538	self.z = numpy.ma.masked_invalid(self.z)
	610		539
	611	if self.ind_plt_ch is False: #standard mode	540	for n, ax in enumerate(self.axes):
	612	self.x = np.array(self.times)	541	x, y, z = self.fill_gaps(*self.decimate())
	613	self.y = self.dataOut.getHeiRange()	542	self.zmin = self.zmin if self.zmin else numpy.min(self.z)
	614	self.z = []	543	self.zmax = self.zmax if self.zmax else numpy.max(self.z)
	615		544	if ax.firsttime:
	616	for ch in range(self.nrows):	545	ax.plt = ax.pcolormesh(x, y, z[n].T,
	617	self.z.append([self.data[self.CODE][t][ch] for t in self.times])	546	vmin=self.zmin,
	618		547	vmax=self.zmax,
	619	self.z = np.array(self.z)	548	cmap=plt.get_cmap(self.colormap)
	620	for n, ax in enumerate(self.axes):	549	)
	621	x, y, z = self.fill_gaps(*self.decimate())	550	if self.showprofile:
	622	xmin = self.min_time	551	ax.plot_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], self.y)[0]
	623	xmax = xmin+self.xrange6060	552	ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
	624	self.zmin = self.zmin if self.zmin else np.min(self.z)	553	color="k", linestyle="dashed", lw=1)[0]
	625	self.zmax = self.zmax if self.zmax else np.max(self.z)	554	else:
	626	if ax.firsttime:	555	ax.collections.remove(ax.collections[0])
	627	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)	556	ax.plt = ax.pcolormesh(x, y, z[n].T,
	628	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)	557	vmin=self.zmin,
	629	plot = ax.pcolormesh(x, y, z[n].T,	558	vmax=self.zmax,
	630	~~vmin~~=self.~~zmin~~,	559	cmap=plt.get_cmap(self.colormap)
	631	~~vmax~~=~~self~~.~~zmax~~,	560	)
	632	cmap=plt.get_cmap(self.colormap)	561	if self.showprofile:
	633	)	562	ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
	634	divider = make_axes_locatable(ax)	563	ax.plot_noise.set_data(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y)
	635	cax = divider.new_horizontal(size='2%', pad=0.05)
	636	self.figure.add_axes(cax)
	637	plt.colorbar(plot, cax)
	638	ax.set_ylim(self.ymin, self.ymax)
	639	ax.xaxis.set_major_formatter(FuncFormatter(func))
	640	ax.xaxis.set_major_locator(LinearLocator(6))
	641	ax.set_ylabel(self.ylabel)
	642	if self.xmin is None:
	643	xmin = self.min_time
	644	else:
	645	xmin = (datetime.datetime.combine(self.dataOut.datatime.date(),
	646	datetime.time(self.xmin, 0, 0))-d1970).total_seconds()
	647	ax.set_xlim(xmin, xmax)
	648	ax.firsttime = False
	649	else:
	650	ax.collections.remove(ax.collections[0])
	651	ax.set_xlim(xmin, xmax)
	652	plot = ax.pcolormesh(x, y, z[n].T,
	653	vmin=self.zmin,
	654	vmax=self.zmax,
	655	cmap=plt.get_cmap(self.colormap)
	656	)
	657	ax.set_title('{} {}'.format(self.titles[n],
	658	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
	659	size=8)
	660
	661	self.saveTime = self.min_time
	662	else :
	663	self.x = np.array(self.times)
	664	self.y = self.dataOut.getHeiRange()
	665	self.z = []
	666
	667	for ch in range(self.nrows):
	668	self.z.append([self.data[self.CODE][t][ch] for t in self.times])
	669
	670	self.z = np.array(self.z)
	671	for n, eachfigure in enumerate(self.figurelist): #estaba ax in axes
	672
	673	x, y, z = self.fill_gaps(*self.decimate())
	674	xmin = self.min_time
	675	xmax = xmin+self.xrange6060
	676	self.zmin = self.zmin if self.zmin else np.min(self.z)
	677	self.zmax = self.zmax if self.zmax else np.max(self.z)
	678	if self.axes[n].firsttime:
	679	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)
	680	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)
	681	plot = self.axes[n].pcolormesh(x, y, z[n].T,
	682	vmin=self.zmin,
	683	vmax=self.zmax,
	684	cmap=plt.get_cmap(self.colormap)
	685	)
	686	divider = make_axes_locatable(self.axes[n])
	687	cax = divider.new_horizontal(size='2%', pad=0.05)
	688	eachfigure.add_axes(cax)
	689	#self.figure2.add_axes(cax)
	690	plt.colorbar(plot, cax)
	691	self.axes[n].set_ylim(self.ymin, self.ymax)
	692
	693	self.axes[n].xaxis.set_major_formatter(FuncFormatter(func))
	694	self.axes[n].xaxis.set_major_locator(LinearLocator(6))
	695
	696	self.axes[n].set_ylabel(self.ylabel)
	697
	698	if self.xmin is None:
	699	xmin = self.min_time
	700	else:
	701	xmin = (datetime.datetime.combine(self.dataOut.datatime.date(),
	702	datetime.time(self.xmin, 0, 0))-d1970).total_seconds()
	703
	704	self.axes[n].set_xlim(xmin, xmax)
	705	self.axes[n].firsttime = False
	706	else:
	707	self.axes[n].collections.remove(self.axes[n].collections[0])
	708	self.axes[n].set_xlim(xmin, xmax)
	709	plot = self.axes[n].pcolormesh(x, y, z[n].T,
	710	vmin=self.zmin,
	711	vmax=self.zmax,
	712	cmap=plt.get_cmap(self.colormap)
	713	)
	714	self.axes[n].set_title('{} {}'.format(self.titles[n],
	715	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
	716	size=8)
	717		564
	718	self.saveTime = self.min_time	565	self.saveTime = self.min_time
	719		566
	720		567
	721	class PlotCOHData(PlotRTIData):	568	class PlotCOHData(PlotRTIData):
			569	'''
			570	Plot for Coherence data
			571	'''
	722		572
	723	CODE = 'coh'	573	CODE = 'coh'
	724		574
	725	def setup(self):	575	def setup(self):
	726		576	self.xaxis = 'time'
	727	self.ncols = 1	577	self.ncols = 1
	728	self.nrows = self.data~~Out~~.~~nPairs~~	578	self.nrows = len(self.data.pairs)
	729	self.width = 10	579	self.nplots = len(self.data.pairs)
	730	self.height = 2.2*self.nrows if self.nrows<6 else 12	580	self.ylabel = 'Range [Km]'
	731	self.ind_plt_ch = False #just for coherence and phase	581	if self.CODE == 'coh':
	732	if self.nrows==1:	582	self.cb_label = ''
	733	self.height += 1	583	self.titles = ['Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
	734	self.ylabel = 'Range [Km]'
	735	self.titles = ['{} Ch{} * Ch{}'.format(self.CODE.upper(), x[0], x[1]) for x in self.dataOut.pairsList]
	736
	737	if self.figure is None:
	738	self.figure = plt.figure(figsize=(self.width, self.height),
	739	edgecolor='k',
	740	facecolor='w')
	741	else:	584	else:
	742	self.~~figure~~.~~clf~~()	585	self.cb_label = 'Degrees'
	743	self.axes = []	586	self.titles = ['Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
	744		587
	745	for n in range(self.nrows):	588
	746	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)	589	class PlotPHASEData(PlotCOHData):
	747	ax.firsttime = True	590	'''
	748	self.axes.append(ax)	591	Plot for Phase map data
			592	'''
			593
			594	CODE = 'phase'
			595	colormap = 'seismic'
	749		596
	750		597
	751	class PlotNoiseData(PlotData):	598	class PlotNoiseData(PlotData):
			599	'''
			600	Plot for noise
			601	'''
			602
	752	CODE = 'noise'	603	CODE = 'noise'
	753		604
	754	def setup(self):	605	def setup(self):
	755		606	self.xaxis = 'time'
	756	self.ncols = 1	607	self.ncols = 1
	757	self.nrows = 1	608	self.nrows = 1
	758	self.~~width~~ = 10	609	self.nplots = 1
	759	self.height = 3.2
	760	self.ylabel = 'Intensity [dB]'	610	self.ylabel = 'Intensity [dB]'
	761	self.titles = ['Noise']	611	self.titles = ['Noise']
	762		612	self.colorbar = False
	763	if self.figure is None:
	764	self.figure = plt.figure(figsize=(self.width, self.height),
	765	edgecolor='k',
	766	facecolor='w')
	767	else:
	768	self.figure.clf()
	769	self.axes = []
	770
	771	self.ax = self.figure.add_subplot(self.nrows, self.ncols, 1)
	772	self.ax.firsttime = True
	773		613
	774	def plot(self):	614	def plot(self):
	775		615
	776	x = self.times	616	x = self.data.times
	777	xmin = self.min_time	617	xmin = self.min_time
	778	xmax = xmin+self.xrange6060	618	xmax = xmin+self.xrange6060
	779	if self.ax.firsttime:	619	Y = self.data[self.CODE]
	780	for ch in self.dataOut.channelList:	620
	781	y = [self.data[self.CODE][t][ch] for t in self.times]	621	if self.axes[0].firsttime:
	782	self.ax.plot(x, y, lw=1, label='Ch{}'.format(ch))	622	for ch in self.data.channels:
	783	self.ax.firsttime = False	623	y = Y[ch]
	784	self.ax.xaxis.set_major_formatter(FuncFormatter(func))	624	self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
	785	self.ax.xaxis.set_major_locator(LinearLocator(6))
	786	self.ax.set_ylabel(self.ylabel)
	787	plt.legend()	625	plt.legend()
	788	else:	626	else:
	789	for ch in self.data~~Out~~.channelList:	627	for ch in self.data.channels:
	790	y = [self.data[self.CODE][t][ch] for t in self.times]	628	y = Y[ch]
	791	self.ax.lines[ch].set_data(x, y)	629	self.axes[0].lines[ch].set_data(x, y)
	792		630
	793	self.ax.set_xlim(xmin, xmax)	631	self.ymin = numpy.nanmin(Y) - 5
	794	self.ax.set_ylim(min(y)-5, max(y)+5)	632	self.ymax = numpy.nanmax(Y) + 5
	795	self.saveTime = self.min_time	633	self.saveTime = self.min_time
	796		634
	797		635
	798	class PlotWindProfilerData(PlotRTIData):
	799
	800	CODE = 'wind'
	801	colormap = 'seismic'
	802
	803	def setup(self):
	804	self.ncols = 1
	805	self.nrows = self.dataOut.data_output.shape[0]
	806	self.width = 10
	807	self.height = 2.2*self.nrows
	808	self.ylabel = 'Height [Km]'
	809	self.titles = ['Zonal Wind' ,'Meridional Wind', 'Vertical Wind']
	810	self.clabels = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
	811	self.windFactor = [1, 1, 100]
	812
	813	if self.figure is None:
	814	self.figure = plt.figure(figsize=(self.width, self.height),
	815	edgecolor='k',
	816	facecolor='w')
	817	else:
	818	self.figure.clf()
	819	self.axes = []
	820
	821	for n in range(self.nrows):
	822	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)
	823	ax.firsttime = True
	824	self.axes.append(ax)
	825
	826	def plot(self):
	827
	828	self.x = np.array(self.times)
	829	self.y = self.dataOut.heightList
	830	self.z = []
	831
	832	for ch in range(self.nrows):
	833	self.z.append([self.data['output'][t][ch] for t in self.times])
	834
	835	self.z = np.array(self.z)
	836	self.z = numpy.ma.masked_invalid(self.z)
	837
	838	cmap=plt.get_cmap(self.colormap)
	839	cmap.set_bad('black', 1.)
	840
	841	for n, ax in enumerate(self.axes):
	842	x, y, z = self.fill_gaps(*self.decimate())
	843	xmin = self.min_time
	844	xmax = xmin+self.xrange6060
	845	if ax.firsttime:
	846	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)
	847	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)
	848	self.zmax = self.zmax if self.zmax else numpy.nanmax(abs(self.z[:-1, :]))
	849	self.zmin = self.zmin if self.zmin else -self.zmax
	850
	851	plot = ax.pcolormesh(x, y, z[n].T*self.windFactor[n],
	852	vmin=self.zmin,
	853	vmax=self.zmax,
	854	cmap=cmap
	855	)
	856	divider = make_axes_locatable(ax)
	857	cax = divider.new_horizontal(size='2%', pad=0.05)
	858	self.figure.add_axes(cax)
	859	cb = plt.colorbar(plot, cax)
	860	cb.set_label(self.clabels[n])
	861	ax.set_ylim(self.ymin, self.ymax)
	862
	863	ax.xaxis.set_major_formatter(FuncFormatter(func))
	864	ax.xaxis.set_major_locator(LinearLocator(6))
	865
	866	ax.set_ylabel(self.ylabel)
	867
	868	ax.set_xlim(xmin, xmax)
	869	ax.firsttime = False
	870	else:
	871	ax.collections.remove(ax.collections[0])
	872	ax.set_xlim(xmin, xmax)
	873	plot = ax.pcolormesh(x, y, z[n].T*self.windFactor[n],
	874	vmin=self.zmin,
	875	vmax=self.zmax,
	876	cmap=plt.get_cmap(self.colormap)
	877	)
	878	ax.set_title('{} {}'.format(self.titles[n],
	879	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
	880	size=8)
	881
	882	self.saveTime = self.min_time
	883
	884
	885	class PlotSNRData(PlotRTIData):	636	class PlotSNRData(PlotRTIData):
			637	'''
			638	Plot for SNR Data
			639	'''
			640
	886	CODE = 'snr'	641	CODE = 'snr'
	887	colormap = 'jet'	642	colormap = 'jet'
	888		643
			644
	889	class PlotDOPData(PlotRTIData):	645	class PlotDOPData(PlotRTIData):
			646	'''
			647	Plot for DOPPLER Data
			648	'''
			649
	890	CODE = 'dop'	650	CODE = 'dop'
	891	colormap = 'jet'	651	colormap = 'jet'
	892		652
	893		653
	894	class PlotPHASEData(PlotCOHData):
	895	CODE = 'phase'
	896	colormap = 'seismic'
	897
	898
	899	class PlotSkyMapData(PlotData):	654	class PlotSkyMapData(PlotData):
			655	'''
			656	Plot for meteors detection data
			657	'''
	900		658
	901	CODE = 'met'	659	CODE = 'met'
	902		660
	903	def setup(self):	661	def setup(self):
	904		662
	905	self.ncols = 1	663	self.ncols = 1
	906	self.nrows = 1	664	self.nrows = 1
	907	self.width = 7.2	665	self.width = 7.2
	908	self.height = 7.2	666	self.height = 7.2
	909		667
	910	self.xlabel = 'Zonal Zenith Angle (deg)'	668	self.xlabel = 'Zonal Zenith Angle (deg)'
	911	self.ylabel = 'Meridional Zenith Angle (deg)'	669	self.ylabel = 'Meridional Zenith Angle (deg)'
	912		670
	913	if self.figure is None:	671	if self.figure is None:
	914	self.figure = plt.figure(figsize=(self.width, self.height),	672	self.figure = plt.figure(figsize=(self.width, self.height),
	915	edgecolor='k',	673	edgecolor='k',
	916	facecolor='w')	674	facecolor='w')
	917	else:	675	else:
	918	self.figure.clf()	676	self.figure.clf()
	919		677
	920	self.ax = plt.subplot2grid((self.nrows, self.ncols), (0, 0), 1, 1, polar=True)	678	self.ax = plt.subplot2grid((self.nrows, self.ncols), (0, 0), 1, 1, polar=True)
	921	self.ax.firsttime = True	679	self.ax.firsttime = True
	922		680
	923		681
	924	def plot(self):	682	def plot(self):
	925		683
	926	arrayParameters = np.concatenate([self.data['param'][t] for t in self.times])	684	arrayParameters = numpy.concatenate([self.data['param'][t] for t in self.data.times])
	927	error = arrayParameters[:,-1]	685	error = arrayParameters[:,-1]
	928	indValid = numpy.where(error == 0)[0]	686	indValid = numpy.where(error == 0)[0]
	929	finalMeteor = arrayParameters[indValid,:]	687	finalMeteor = arrayParameters[indValid,:]
	930	finalAzimuth = finalMeteor[:,3]	688	finalAzimuth = finalMeteor[:,3]
	931	finalZenith = finalMeteor[:,4]	689	finalZenith = finalMeteor[:,4]
	932		690
	933	x = finalAzimuth*numpy.pi/180	691	x = finalAzimuth*numpy.pi/180
	934	y = finalZenith	692	y = finalZenith
	935		693
	936	if self.ax.firsttime:	694	if self.ax.firsttime:
	937	self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]	695	self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]
	938	self.ax.set_ylim(0,90)	696	self.ax.set_ylim(0,90)
	939	self.ax.set_yticks(numpy.arange(0,90,20))	697	self.ax.set_yticks(numpy.arange(0,90,20))
	940	self.ax.set_xlabel(self.xlabel)	698	self.ax.set_xlabel(self.xlabel)
	941	self.ax.set_ylabel(self.ylabel)	699	self.ax.set_ylabel(self.ylabel)
	942	self.ax.yaxis.labelpad = 40	700	self.ax.yaxis.labelpad = 40
	943	self.ax.firsttime = False	701	self.ax.firsttime = False
	944	else:	702	else:
	945	self.ax.plot.set_data(x, y)	703	self.ax.plot.set_data(x, y)
	946		704
	947		705
	948	dt1 = datetime.datetime.fromtimestamp(self.min_time).strftime('%y/%m/%d %H:%M:%S')	706	dt1 = datetime.datetime.fromtimestamp(self.min_time).strftime('%y/%m/%d %H:%M:%S')
	949	dt2 = datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')	707	dt2 = datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')
	950	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,	708	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
	951	dt2,	709	dt2,
	952	len(x))	710	len(x))
	953	self.ax.set_title(title, size=8)	711	self.ax.set_title(title, size=8)
	954		712
	955	self.saveTime = self.max_time	713	self.saveTime = self.max_time
			714
			715	class PlotParamData(PlotRTIData):
			716	'''
			717	Plot for data_param object
			718	'''
			719
			720	CODE = 'param'
			721	colormap = 'seismic'
			722
			723	def setup(self):
			724	self.xaxis = 'time'
			725	self.ncols = 1
			726	self.nrows = self.data.shape(self.CODE)[0]
			727	self.nplots = self.nrows
			728	if self.showSNR:
			729	self.nrows += 1
			730
			731	self.ylabel = 'Height [Km]'
			732	self.titles = self.data.parameters \
			733	if self.data.parameters else ['Param {}'.format(x) for x in xrange(self.nrows)]
			734	if self.showSNR:
			735	self.titles.append('SNR')
			736
			737	def plot(self):
			738	self.data.normalize_heights()
			739	self.x = self.data.times
			740	self.y = self.data.heights
			741	if self.showSNR:
			742	self.z = numpy.concatenate(
			743	(self.data[self.CODE], self.data['snr'])
			744	)
			745	else:
			746	self.z = self.data[self.CODE]
			747
			748	self.z = numpy.ma.masked_invalid(self.z)
			749
			750	for n, ax in enumerate(self.axes):
			751
			752	x, y, z = self.fill_gaps(*self.decimate())
			753
			754	if ax.firsttime:
			755	if self.zlimits is not None:
			756	self.zmin, self.zmax = self.zlimits[n]
			757	self.zmax = self.zmax if self.zmax is not None else numpy.nanmax(abs(self.z[:-1, :]))
			758	self.zmin = self.zmin if self.zmin is not None else -self.zmax
			759	ax.plt = ax.pcolormesh(x, y, z[n, :, :].T*self.factors[n],
			760	vmin=self.zmin,
			761	vmax=self.zmax,
			762	cmap=self.cmaps[n]
			763	)
			764	else:
			765	if self.zlimits is not None:
			766	self.zmin, self.zmax = self.zlimits[n]
			767	ax.collections.remove(ax.collections[0])
			768	ax.plt = ax.pcolormesh(x, y, z[n, :, :].T*self.factors[n],
			769	vmin=self.zmin,
			770	vmax=self.zmax,
			771	cmap=self.cmaps[n]
			772	)
			773
			774	self.saveTime = self.min_time
			775
			776	class PlotOuputData(PlotParamData):
			777	'''
			778	Plot data_output object
			779	'''
			780
			781	CODE = 'output'
			782	colormap = 'seismic' No newline at end of file

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

             import os
             import datetime
             import numpy
             import inspect
             from figure import Figure, isRealtime, isTimeInHourRange
             from plotting_codes import *
             class FitGauPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'fitgau'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       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)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         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,
                         xaxis="frequency", colormap='jet', normFactor=None , GauSelector = 1):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if realtime:
                         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" %channel
                             channelIndexList.append(dataOut.channelList.index(channel))
             #         if normFactor is None:
             #             factor = dataOut.normFactor
             #         else:
             #             factor = normFactor
                     if xaxis == "frequency":
                         x = dataOut.spc_range[0]
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.spc_range[1]
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.spc_range[2]
                         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     y = dataOut.getHeiRange()
                     z = dataOut.GauSPC[:,GauSelector,:,:] #GauSelector]    #dataOut.data_spc/factor
                     print 'GausSPC', z[0,32,10:40]
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     noise = dataOut.spc_noise
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Spectra"
                     if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                         title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         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 = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         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):
                         index = channelIndexList[i]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
                         if len(dataOut.beam.codeList) != 0:
                             title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[index,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index,:], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[index], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class MomentsPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 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 = MOMENTS_CODE
                     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)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       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)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         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)):
                             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
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = dataOut.data_pre[channelIndexList,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.noise/factor
                     zdB = 10*numpy.log10(z)
                     avgdB = 10*numpy.log10(avg)
                     noisedB = 10*numpy.log10(noise)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters"
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         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 = numpy.nanmin(avgdB)*0.9
                         if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
                         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
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i], noisedB[i], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         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='')
                                     #Mean Line
                         mean = dataOut.data_param[i, 1, :]
                         axes.addpline(mean, y, idline=0, color="black", linestyle="solid", lw=1)
                         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)
             class SkyMapPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'mmap'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
             #         self.WIDTH = 280
             #         self.HEIGHT = 250
                     self.WIDTH = 600
                     self.HEIGHT = 600
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = MSKYMAP_CODE
                     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)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH, #+ self.WIDTHPROF,
                                       heightplot = self.HEIGHT,# + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = 1,1
                     counter = 0
                     x = 0
                     y = 0
                     self.addAxes(1, 1, 0, 0, 1, 1, True)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
                         tmin=0, tmax=24, 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, realtime=False):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     arrayParameters = dataOut.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
                     x1 = [dataOut.ltctime, dataOut.ltctime]
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     title = wintitle + " Parameters"
                     xlabel = "Zonal Zenith Angle (deg) "
                     ylabel = "Meridional Zenith Angle (deg)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if self.xmin is None and self.xmax is None:
                             self.xmin, self.xmax = self.getTimeLim(x1, tmin, tmax, timerange)
                         if timerange != None:
                             self.timerange = timerange
                         else:
                             self.timerange = self.xmax - self.xmin
                         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.firstdate = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     i = 0
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     axes = self.axesList[i*self.__nsubplots]
                     nevents = axes.x_buffer.shape[0] + x.shape[0]
                     title = "Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n" %(self.firstdate,str_datetime,nevents)
                     axes.polar(x, y,
                                 title=title, xlabel=xlabel, ylabel=ylabel,
                                 ticksize=9, cblabel='')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     if dataOut.ltctime >= self.xmax:
                         self.isConfigmagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                         axes.__firsttime = True
                         self.xmin += self.timerange
                         self.xmax += self.timerange
             class WindProfilerPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'wind'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 300
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = WIND_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         if counter >= self.nplots:
                             break
                         self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 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,
                         zmax_ver = None, zmin_ver = None, SNRmin = None, SNRmax = None,
                         timerange=None, SNRthresh = None,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
             #         if timerange is not None:
             #             self.timerange = timerange
             #
             #         tmin = None
             #         tmax = None
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.heightList
                     z = dataOut.data_output.copy()
                     nplots = z.shape[0]    #Number of wind dimensions estimated
                     nplotsw = nplots
                     #If there is a SNR function defined
                     if dataOut.data_SNR is not None:
                         nplots += 1
                         SNR = dataOut.data_SNR
                         SNRavg = numpy.average(SNR, axis=0)
                         SNRdB = 10*numpy.log10(SNR)
                         SNRavgdB = 10*numpy.log10(SNRavg)
                         if SNRthresh == None: SNRthresh = -5.0
                         ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
                         for i in range(nplotsw):
                             z[i,ind] = numpy.nan
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     #thisDatetime = datetime.datetime.now()
                     title = wintitle + "Wind"
                     xlabel = ""
                     ylabel = "Height (km)"
                     update_figfile = False
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange is not None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmax == None: zmax = numpy.nanmax(abs(z[range(2),:]))
                         #if numpy.isnan(zmax): zmax = 50
                         if zmin == None: zmin = -zmax
                         if nplotsw == 3:
                             if zmax_ver == None: zmax_ver = numpy.nanmax(abs(z[2,:]))
                             if zmin_ver == None: zmin_ver = -zmax_ver
                         if dataOut.data_SNR is not None:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRavgdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRavgdB)
                         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
                         update_figfile = True
                     self.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     strWind = ['Zonal', 'Meridional', 'Vertical']
                     strCb = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
                     zmaxVector = [zmax, zmax, zmax_ver]
                     zminVector = [zmin, zmin, zmin_ver]
                     windFactor = [1,1,100]
                     for i in range(nplotsw):
                         title = "%s Wind: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         z1 = z[i,:].reshape((1,-1))*windFactor[i]
                         #z1=numpy.ma.masked_where(z1==0.,z1)
                         axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel=strCb[i], cbsize="1%", colormap="seismic" )
                     if dataOut.data_SNR is not None:
                         i += 1
                         title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         SNRavgdB = SNRavgdB.reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRavgdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap="jet")
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     if dataOut.ltctime + dataOut.paramInterval >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
             class ParametersPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'param'
                 nplots = None
                 nchan = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = RTI_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       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)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, paramIndex = 0, colormap="jet",
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, timerange=None,
                         showSNR=False, SNRthresh = -numpy.inf, SNRmin=None, SNRmax=None,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, HEIGHT=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if HEIGHT is not None:
                         self.HEIGHT = HEIGHT
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = range(dataOut.data_param.shape[0])
                     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))
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.getHeiRange()
                     if dataOut.data_param.ndim == 3:
                         z = dataOut.data_param[channelIndexList,paramIndex,:]
                     else:
                         z = dataOut.data_param[channelIndexList,:]
                     if showSNR:
                         #SNR data
                         SNRarray = dataOut.data_SNR[channelIndexList,:]
                         SNRdB = 10*numpy.log10(SNRarray)
                         ind = numpy.where(SNRdB < SNRthresh)
                         z[ind] = numpy.nan
                     thisDatetime = dataOut.datatime
             #         thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nchan = len(channelIndexList)
                         self.nchan = nchan
                         self.plotFact = 1
                         nplots = nchan
                         if showSNR:
                             nplots = nchan*2
                             self.plotFact = 2
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRdB)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(z)
                         if zmax == None: zmax = numpy.nanmax(z)
                         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
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nchan):
                         index = channelIndexList[i]
                         title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.plotFact]
                         z1 = z[i,:].reshape((1,-1))
                         axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%",colormap=colormap)
                         if showSNR:
                             title = "Channel %d SNR: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                             axes = self.axesList[i*self.plotFact + 1]
                             SNRdB1 = SNRdB[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, SNRdB1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%",colormap='jet')
                     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)
             class Parameters1Plot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = PARMS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       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)
                             if showprofile:
                                 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,timerange=None,
                         parameterIndex = None, onlyPositive = False,
                         SNRthresh = -numpy.inf, SNR = True, SNRmin = None, SNRmax = None, onlySNR = False,
                         DOP = True,
                         zlabel = "", parameterName = "", parameterObject = "data_param",
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     #print inspect.getargspec(self.run).args
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     data_param = getattr(dataOut, parameterObject)
                     if channelList == None:
                         channelIndexList = numpy.arange(data_param.shape[0])
                     else:
                         channelIndexList = numpy.array(channelList)
                     nchan = len(channelIndexList) #Number of channels being plotted
                     if nchan < 1:
                         return
                     nGraphsByChannel = 0
                     if SNR:
                         nGraphsByChannel += 1
                     if DOP:
                         nGraphsByChannel += 1
                     if nGraphsByChannel < 1:
                         return
                     nplots = nGraphsByChannel*nchan
                     if timerange is not None:
                         self.timerange = timerange
                     #tmin = None
                     #tmax = None
                     if parameterIndex == None:
                         parameterIndex = 1
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.heightList
                     z = data_param[channelIndexList,parameterIndex,:].copy()
                     zRange = dataOut.abscissaList
             #         nChannels = z.shape[0]    #Number of wind dimensions estimated
             #        thisDatetime = dataOut.datatime
                     if dataOut.data_SNR is not None:
                         SNRarray = dataOut.data_SNR[channelIndexList,:]
                         SNRdB = 10*numpy.log10(SNRarray)
             #             SNRavgdB = 10*numpy.log10(SNRavg)
                         ind = numpy.where(SNRdB < 10**(SNRthresh/10))
                         z[ind] = numpy.nan
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     if (SNR and not onlySNR): nplots = 2*nplots
                     if onlyPositive:
                         colormap = "jet"
                         zmin = 0
                     else: colormap = "RdBu_r"
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(zRange)
                         if zmax == None: zmax = numpy.nanmax(zRange)
                         if SNR:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRdB)
                         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.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     for i in range(nchan):
                         if (SNR and not onlySNR): j = 2*i
                         else: j = i
                         j = nGraphsByChannel*i
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                         if not onlySNR:
                             axes = self.axesList[j*self.__nsubplots]
                             z1 = z[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
                                     ticksize=9, cblabel=zlabel, cbsize="1%")
                         if DOP:
                             title = "%s Channel %d: %s" %(parameterName, channelIndexList[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                             if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                                 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                             axes = self.axesList[j]
                             z1 = z[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, z1,
                                         xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                         xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
                                         ticksize=9, cblabel=zlabel, cbsize="1%")
                         if SNR:
                             title = "Channel %d Signal Noise Ratio (SNR): %s" %(channelIndexList[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                             axes = self.axesList[(j)*self.__nsubplots]
                             if not onlySNR:
                                 axes = self.axesList[(j + 1)*self.__nsubplots]
                             axes = self.axesList[(j + nGraphsByChannel-1)]
                             z1 = SNRdB[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap="jet",
                                     ticksize=9, cblabel=zlabel, cbsize="1%")
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         self.figfile = None
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=False)
             class SpectralFittingPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 N = None
                 ippSeconds = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = SPECFIT_CODE
                     self.WIDTH = 450
                     self.HEIGHT = 250
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+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 = 5
                     colspan = 4
                     if showprofile:
                         ncolspan = 5
                         colspan = 4
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       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)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, cutHeight=None, fit=False, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if cutHeight==None:
                         h=270
                     heightindex = numpy.abs(cutHeight - dataOut.heightList).argmin()
                     cutHeight = dataOut.heightList[heightindex]
                     factor = dataOut.normFactor
                     x = dataOut.abscissaList[:-1]
                     #y = dataOut.getHeiRange()
                     z = dataOut.data_pre[:,:,heightindex]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     listChannels = z.shape[0]
                     #Reconstruct Function
                     if fit==True:
                         groupArray = dataOut.groupList
                         listChannels = groupArray.reshape((groupArray.size))
                         listChannels.sort()
                         spcFitLine = numpy.zeros(z.shape)
                         constants = dataOut.constants
                         nGroups = groupArray.shape[0]
                         nChannels = groupArray.shape[1]
                         nProfiles = z.shape[1]
                         for f in range(nGroups):
                             groupChann = groupArray[f,:]
                             p = dataOut.data_param[f,:,heightindex]
             #                 p = numpy.array([ 89.343967,0.14036615,0.17086219,18.89835291,1.58388365,1.55099167])
                             fitLineAux = dataOut.library.modelFunction(p, constants)*nProfiles
                             fitLineAux = fitLineAux.reshape((nChannels,nProfiles))
                             spcFitLine[groupChann,:] = fitLineAux
             #             spcFitLine = spcFitLine/factor
                         z = z[listChannels,:]
                         spcFitLine = spcFitLine[listChannels,:]
                         spcFitLinedB = 10*numpy.log10(spcFitLine)
                     zdB = 10*numpy.log10(z)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Doppler Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Spectrum"
                     if not self.isConfig:
                         nplots = listChannels.size
                         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(zdB)
                         if ymax == None: ymax = numpy.nanmax(zdB)+2
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
             #             title = "Channel %d: %4.2fdB" %(dataOut.channelList[i]+1, noisedB[i])
                         title = "Height %4.1f km\nChannel %d:" %(cutHeight, listChannels[i])
                         axes = self.axesList[i*self.__nsubplots]
                         if fit == False:
                             axes.pline(x, zdB[i,:],
                                         xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                         xlabel=xlabel, ylabel=ylabel, title=title
                                         )
                         if fit == True:
                             fitline=spcFitLinedB[i,:]
                             y=numpy.vstack([zdB[i,:],fitline] )
                             legendlabels=['Data','Fitting']
                             axes.pmultilineyaxis(x, y,
                                         xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                         xlabel=xlabel, ylabel=ylabel, title=title,
                                         legendlabels=legendlabels, marker=None,
                                         linestyle='solid', grid='both')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class EWDriftsPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'drift'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 150
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = EWDRIFT_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         if counter >= self.nplots:
                             break
                         self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
                         counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         zmaxVertical = None, zminVertical = None, zmaxZonal = None, zminZonal = None,
                         timerange=None, SNRthresh = -numpy.inf, SNRmin = None, SNRmax = None, SNR_1 = False,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if timerange is not None:
                         self.timerange = timerange
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange1(dataOut.outputInterval)
             #         y = dataOut.heightList
                     y = dataOut.heightList
                     z = dataOut.data_output
                     nplots = z.shape[0]    #Number of wind dimensions estimated
                     nplotsw = nplots
                     #If there is a SNR function defined
                     if dataOut.data_SNR is not None:
                         nplots += 1
                         SNR = dataOut.data_SNR
                         if SNR_1:
                             SNR += 1
                         SNRavg = numpy.average(SNR, axis=0)
                         SNRdB = 10*numpy.log10(SNR)
                         SNRavgdB = 10*numpy.log10(SNRavg)
                         ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
                         for i in range(nplotsw):
                             z[i,ind] = numpy.nan
                     showprofile = False
             #        thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(x[1])
                     title = wintitle + " EW Drifts"
                     xlabel = ""
                     ylabel = "Height (Km)"
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmaxZonal == None: zmaxZonal = numpy.nanmax(abs(z[0,:]))
                         if zminZonal == None: zminZonal = -zmaxZonal
                         if zmaxVertical == None: zmaxVertical = numpy.nanmax(abs(z[1,:]))
                         if zminVertical == None: zminVertical = -zmaxVertical
                         if dataOut.data_SNR is not None:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRavgdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRavgdB)
                         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.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     strWind = ['Zonal','Vertical']
                     strCb = 'Velocity (m/s)'
                     zmaxVector = [zmaxZonal, zmaxVertical]
                     zminVector = [zminZonal, zminVertical]
                     for i in range(nplotsw):
                         title = "%s Drifts: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         z1 = z[i,:].reshape((1,-1))
                         axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel=strCb, cbsize="1%", colormap="RdBu_r")
                     if dataOut.data_SNR is not None:
                         i += 1
                         if SNR_1:
                             title = "Signal Noise Ratio + 1 (SNR+1): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         else:
                             title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         SNRavgdB = SNRavgdB.reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRavgdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap="jet")
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         self.figfile = None
             class PhasePlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'mphase'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 600
                     self.HEIGHT = 300
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = MPHASE_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
                 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,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=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):
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange1(dataOut.outputInterval)
                     y = dataOut.getHeiRange()
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     title = wintitle + " Phase of Beacon Signal" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase"
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = dataOut.data_output
                     update_figfile = False
                     if not self.isConfig:
                         self.nplots = phase_beacon.size
                         self.setup(id=id,
                                    nplots=self.nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange is not None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(phase_beacon) - 10.0
                         if ymax == None: ymax = numpy.nanmax(phase_beacon) + 10.0
                         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([])
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         update_figfile = True
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Offset %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["phase %d"%(chan) for chan in numpy.arange(self.nplots)]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         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()
                     self.save(figpath=figpath,
                       figfile=figfile,
                       save=save,
                       ftp=ftp,
                       wr_period=wr_period,
                       thisDatetime=thisDatetime,
                       update_figfile=update_figfile)
                     if dataOut.ltctime + dataOut.outputInterval >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
             class NSMeteorDetection1Plot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'nsm'
                 zminList = None
                 zmaxList = None
                 cmapList = None
                 titleList = None
                 nPairs = None
                 nChannels = None
                 nParam = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 750
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = 3
                     nrow = int(numpy.ceil(self.nplots/3.0))
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       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)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, SNRmin=None, SNRmax=None,
                         vmin=None, vmax=None, wmin=None, wmax=None, mode = 'SA',
                         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,
                         xaxis="frequency"):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     #SEPARAR EN DOS PLOTS
                     nParam = dataOut.data_param.shape[1] - 3
                     utctime = dataOut.data_param[0,0]
                     tmet = dataOut.data_param[:,1].astype(int)
                     hmet = dataOut.data_param[:,2].astype(int)
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = numpy.zeros((nParam, y.size, x.size - 1))
                     z[:,:] = numpy.nan
                     z[:,hmet,tmet] = dataOut.data_param[:,3:].T
                     z[0,:,:] = 10*numpy.log10(z[0,:,:])
                     xlabel = "Time (s)"
                     ylabel = "Range (km)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     if not self.isConfig:
                         nplots = nParam
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin is None: xmin = numpy.nanmin(x)
                         if xmax is None: xmax = numpy.nanmax(x)
                         if ymin is None: ymin = numpy.nanmin(y)
                         if ymax is None: ymax = numpy.nanmax(y)
                         if SNRmin is None: SNRmin = numpy.nanmin(z[0,:])
                         if SNRmax is None: SNRmax = numpy.nanmax(z[0,:])
                         if vmax is None: vmax = numpy.nanmax(numpy.abs(z[1,:]))
                         if vmin is None: vmin = -vmax
                         if wmin is None: wmin = 0
                         if wmax is None: wmax = 50
                         pairsList = dataOut.groupList
                         self.nPairs = len(dataOut.groupList)
                         zminList = [SNRmin, vmin, cmin] + [pmin]*self.nPairs
                         zmaxList = [SNRmax, vmax, cmax] + [pmax]*self.nPairs
                         titleList = ["SNR","Radial Velocity","Coherence"]
                         cmapList = ["jet","RdBu_r","jet"]
                         for i in range(self.nPairs):
                             strAux1 = "Phase Difference "+ str(pairsList[i][0]) + str(pairsList[i][1])
                             titleList = titleList + [strAux1]
                             cmapList = cmapList + ["RdBu_r"]
                         self.zminList = zminList
                         self.zmaxList = zmaxList
                         self.cmapList = cmapList
                         self.titleList = titleList
                         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
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     for i in range(nParam):
                         title = self.titleList[i] + ": " +str_datetime
                         axes = self.axesList[i]
                         axes.pcolor(x, y, z[i,:].T,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=self.zminList[i], zmax=self.zmaxList[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=self.cmapList[i],ticksize=9, cblabel='')
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class NSMeteorDetection2Plot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'nsm'
                 zminList = None
                 zmaxList = None
                 cmapList = None
                 titleList = None
                 nPairs = None
                 nChannels = None
                 nParam = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 750
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = 3
                     nrow = int(numpy.ceil(self.nplots/3.0))
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       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)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, SNRmin=None, SNRmax=None,
                         vmin=None, vmax=None, wmin=None, wmax=None, mode = 'SA',
                         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,
                         xaxis="frequency"):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     #Rebuild matrix
                     utctime = dataOut.data_param[0,0]
                     cmet = dataOut.data_param[:,1].astype(int)
                     tmet = dataOut.data_param[:,2].astype(int)
                     hmet = dataOut.data_param[:,3].astype(int)
                     nParam = 3
                     nChan = len(dataOut.groupList)
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = numpy.full((nChan, nParam, y.size, x.size - 1),numpy.nan)
                     z[cmet,:,hmet,tmet] = dataOut.data_param[:,4:]
                     z[:,0,:,:] = 10*numpy.log10(z[:,0,:,:]) #logarithmic scale
                     z = numpy.reshape(z, (nChan*nParam, y.size, x.size-1))
                     xlabel = "Time (s)"
                     ylabel = "Range (km)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     if not self.isConfig:
                         nplots = nParam*nChan
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin is None: xmin = numpy.nanmin(x)
                         if xmax is None: xmax = numpy.nanmax(x)
                         if ymin is None: ymin = numpy.nanmin(y)
                         if ymax is None: ymax = numpy.nanmax(y)
                         if SNRmin is None: SNRmin = numpy.nanmin(z[0,:])
                         if SNRmax is None: SNRmax = numpy.nanmax(z[0,:])
                         if vmax is None: vmax = numpy.nanmax(numpy.abs(z[1,:]))
                         if vmin is None: vmin = -vmax
                         if wmin is None: wmin = 0
                         if wmax is None: wmax = 50
                         self.nChannels = nChan
                         zminList = []
                         zmaxList = []
                         titleList = []
                         cmapList = []
                         for i in range(self.nChannels):
                             strAux1 = "SNR Channel "+ str(i)
                             strAux2 = "Radial Velocity Channel "+ str(i)
                             strAux3 = "Spectral Width Channel "+ str(i)
                             titleList = titleList + [strAux1,strAux2,strAux3]
                             cmapList = cmapList + ["jet","RdBu_r","jet"]
                             zminList = zminList + [SNRmin,vmin,wmin]
                             zmaxList = zmaxList + [SNRmax,vmax,wmax]
                         self.zminList = zminList
                         self.zmaxList = zmaxList
                         self.cmapList = cmapList
                         self.titleList = titleList
                         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
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     for i in range(self.nplots):
                         title = self.titleList[i] + ": " +str_datetime
                         axes = self.axesList[i]
                         axes.pcolor(x, y, z[i,:].T,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=self.zminList[i], zmax=self.zmaxList[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=self.cmapList[i],ticksize=9, cblabel='')
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)

schainpy/model/graphics/jroplot_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/graphics/jroplotter.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_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/io/jroIO_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/io/jroIO_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/io/jroIO_hf.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_kamisr.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_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/extensions.c 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_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_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/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/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/utils/log.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

schainpy/VERSION removed 0 -85

NO CONTENT: file was removed

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