schain-jc Commit - r573:e93e8802031b

A new SendToServer Unit has been created to upload files to a remote server....

Miguel Valdez -

r573:e93e8802031b

parent child

Context file:

r573:e93e8802031b

Collapse all files

schainpy/model/graphics/plotting_codes.py created 644 +27 0

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

schainpy/model/utils/scp.py created 644 +464 0

@@ -0,0 +1,464
	1	# scp.py
	2	# Copyright (C) 2008 James Bardin <j.bardin@gmail.com>
	3
	4	"""
	5	Utilities for sending files over ssh using the scp1 protocol.
	6	"""
	7
	8	__version__ = '0.10.0'
	9
	10	import locale
	11	import os
	12	import re
	13	from socket import timeout as SocketTimeout
	14
	15
	16	# this is quote from the shlex module, added in py3.3
	17	_find_unsafe = re.compile(br'[^\w@%+=:,./~-]').search
	18
	19
	20	def _sh_quote(s):
	21	"""Return a shell-escaped version of the string `s`."""
	22	if not s:
	23	return b""
	24	if _find_unsafe(s) is None:
	25	return s
	26
	27	# use single quotes, and put single quotes into double quotes
	28	# the string $'b is then quoted as '$'"'"'b'
	29	return b"'" + s.replace(b"'", b"'\"'\"'") + b"'"
	30
	31
	32	# Unicode conversion functions; assume UTF-8
	33
	34	def asbytes(s):
	35	"""Turns unicode into bytes, if needed.
	36	Assumes UTF-8.
	37	"""
	38	if isinstance(s, bytes):
	39	return s
	40	else:
	41	return s.encode('utf-8')
	42
	43
	44	def asunicode(s):
	45	"""Turns bytes into unicode, if needed.
	46	Uses UTF-8.
	47	"""
	48	if isinstance(s, bytes):
	49	return s.decode('utf-8', 'replace')
	50	else:
	51	return s
	52
	53
	54	# os.path.sep is unicode on Python 3, no matter the platform
	55	bytes_sep = asbytes(os.path.sep)
	56
	57
	58	# Unicode conversion function for Windows
	59	# Used to convert local paths if the local machine is Windows
	60
	61	def asunicode_win(s):
	62	"""Turns bytes into unicode, if needed.
	63	"""
	64	if isinstance(s, bytes):
	65	return s.decode(locale.getpreferredencoding())
	66	else:
	67	return s
	68
	69
	70	class SCPClient(object):
	71	"""
	72	An scp1 implementation, compatible with openssh scp.
	73	Raises SCPException for all transport related errors. Local filesystem
	74	and OS errors pass through.
	75	Main public methods are .put and .get
	76	The get method is controlled by the remote scp instance, and behaves
	77	accordingly. This means that symlinks are resolved, and the transfer is
	78	halted after too many levels of symlinks are detected.
	79	The put method uses os.walk for recursion, and sends files accordingly.
	80	Since scp doesn't support symlinks, we send file symlinks as the file
	81	(matching scp behaviour), but we make no attempt at symlinked directories.
	82	"""
	83	def __init__(self, transport, buff_size=16384, socket_timeout=5.0,
	84	progress=None, sanitize=_sh_quote):
	85	"""
	86	Create an scp1 client.
	87	@param transport: an existing paramiko L{Transport}
	88	@type transport: L{Transport}
	89	@param buff_size: size of the scp send buffer.
	90	@type buff_size: int
	91	@param socket_timeout: channel socket timeout in seconds
	92	@type socket_timeout: float
	93	@param progress: callback - called with (filename, size, sent) during
	94	transfers
	95	@param sanitize: function - called with filename, should return
	96	safe or escaped string. Uses _sh_quote by default.
	97	@type progress: function(string, int, int)
	98	"""
	99	self.transport = transport
	100	self.buff_size = buff_size
	101	self.socket_timeout = socket_timeout
	102	self.channel = None
	103	self.preserve_times = False
	104	self._progress = progress
	105	self._recv_dir = b''
	106	self._rename = False
	107	self._utime = None
	108	self.sanitize = sanitize
	109	self._dirtimes = {}
	110
	111	def __enter__(self):
	112	self.channel = self._open()
	113	return self
	114
	115	def __exit__(self, type, value, traceback):
	116	self.close()
	117
	118	def put(self, files, remote_path=b'.',
	119	recursive=False, preserve_times=False):
	120	"""
	121	Transfer files to remote host.
	122	@param files: A single path, or a list of paths to be transfered.
	123	recursive must be True to transfer directories.
	124	@type files: string OR list of strings
	125	@param remote_path: path in which to receive the files on the remote
	126	host. defaults to '.'
	127	@type remote_path: str
	128	@param recursive: transfer files and directories recursively
	129	@type recursive: bool
	130	@param preserve_times: preserve mtime and atime of transfered files
	131	and directories.
	132	@type preserve_times: bool
	133	"""
	134	self.preserve_times = preserve_times
	135	self.channel = self._open()
	136	self._pushed = 0
	137	self.channel.settimeout(self.socket_timeout)
	138	scp_command = (b'scp -t ', b'scp -r -t ')[recursive]
	139	self.channel.exec_command(scp_command +
	140	self.sanitize(asbytes(remote_path)))
	141	self._recv_confirm()
	142
	143	if not isinstance(files, (list, tuple)):
	144	files = [files]
	145
	146	if recursive:
	147	self._send_recursive(files)
	148	else:
	149	self._send_files(files)
	150
	151	self.close()
	152
	153	def get(self, remote_path, local_path='',
	154	recursive=False, preserve_times=False):
	155	"""
	156	Transfer files from remote host to localhost
	157	@param remote_path: path to retreive from remote host. since this is
	158	evaluated by scp on the remote host, shell wildcards and
	159	environment variables may be used.
	160	@type remote_path: str
	161	@param local_path: path in which to receive files locally
	162	@type local_path: str
	163	@param recursive: transfer files and directories recursively
	164	@type recursive: bool
	165	@param preserve_times: preserve mtime and atime of transfered files
	166	and directories.
	167	@type preserve_times: bool
	168	"""
	169	if not isinstance(remote_path, (list, tuple)):
	170	remote_path = [remote_path]
	171	remote_path = [self.sanitize(asbytes(r)) for r in remote_path]
	172	self._recv_dir = local_path or os.getcwd()
	173	self._rename = (len(remote_path) == 1 and
	174	not os.path.isdir(os.path.abspath(local_path)))
	175	if len(remote_path) > 1:
	176	if not os.path.exists(self._recv_dir):
	177	raise SCPException("Local path '%s' does not exist" %
	178	asunicode(self._recv_dir))
	179	elif not os.path.isdir(self._recv_dir):
	180	raise SCPException("Local path '%s' is not a directory" %
	181	asunicode(self._recv_dir))
	182	rcsv = (b'', b' -r')[recursive]
	183	prsv = (b'', b' -p')[preserve_times]
	184	self.channel = self._open()
	185	self._pushed = 0
	186	self.channel.settimeout(self.socket_timeout)
	187	self.channel.exec_command(b"scp" +
	188	rcsv +
	189	prsv +
	190	b" -f " +
	191	b' '.join(remote_path))
	192	self._recv_all()
	193	self.close()
	194
	195	def _open(self):
	196	"""open a scp channel"""
	197	if self.channel is None:
	198	self.channel = self.transport.open_session()
	199
	200	return self.channel
	201
	202	def close(self):
	203	"""close scp channel"""
	204	if self.channel is not None:
	205	self.channel.close()
	206	self.channel = None
	207
	208	def _read_stats(self, name):
	209	"""return just the file stats needed for scp"""
	210	if os.name == 'nt':
	211	name = asunicode(name)
	212	stats = os.stat(name)
	213	mode = oct(stats.st_mode)[-4:]
	214	size = stats.st_size
	215	atime = int(stats.st_atime)
	216	mtime = int(stats.st_mtime)
	217	return (mode, size, mtime, atime)
	218
	219	def _send_files(self, files):
	220	for name in files:
	221	basename = asbytes(os.path.basename(name))
	222	(mode, size, mtime, atime) = self._read_stats(name)
	223	if self.preserve_times:
	224	self._send_time(mtime, atime)
	225	file_hdl = open(name, 'rb')
	226
	227	# The protocol can't handle \n in the filename.
	228	# Quote them as the control sequence \^J for now,
	229	# which is how openssh handles it.
	230	self.channel.sendall(("C%s %d " % (mode, size)).encode('ascii') +
	231	basename.replace(b'\n', b'\\^J') + b"\n")
	232	self._recv_confirm()
	233	file_pos = 0
	234	if self._progress:
	235	if size == 0:
	236	# avoid divide-by-zero
	237	self._progress(basename, 1, 1)
	238	else:
	239	self._progress(basename, size, 0)
	240	buff_size = self.buff_size
	241	chan = self.channel
	242	while file_pos < size:
	243	chan.sendall(file_hdl.read(buff_size))
	244	file_pos = file_hdl.tell()
	245	if self._progress:
	246	self._progress(basename, size, file_pos)
	247	chan.sendall('\x00')
	248	file_hdl.close()
	249	self._recv_confirm()
	250
	251	def _chdir(self, from_dir, to_dir):
	252	# Pop until we're one level up from our next push.
	253	# Push once into to_dir.
	254	# This is dependent on the depth-first traversal from os.walk
	255
	256	# add path.sep to each when checking the prefix, so we can use
	257	# path.dirname after
	258	common = os.path.commonprefix([from_dir + bytes_sep,
	259	to_dir + bytes_sep])
	260	# now take the dirname, since commonprefix is character based,
	261	# and we either have a seperator, or a partial name
	262	common = os.path.dirname(common)
	263	cur_dir = from_dir.rstrip(bytes_sep)
	264	while cur_dir != common:
	265	cur_dir = os.path.split(cur_dir)[0]
	266	self._send_popd()
	267	# now we're in our common base directory, so on
	268	self._send_pushd(to_dir)
	269
	270	def _send_recursive(self, files):
	271	for base in files:
	272	if not os.path.isdir(base):
	273	# filename mixed into the bunch
	274	self._send_files([base])
	275	continue
	276	last_dir = asbytes(base)
	277	for root, dirs, fls in os.walk(base):
	278	self._chdir(last_dir, asbytes(root))
	279	self._send_files([os.path.join(root, f) for f in fls])
	280	last_dir = asbytes(root)
	281	# back out of the directory
	282	while self._pushed > 0:
	283	self._send_popd()
	284
	285	def _send_pushd(self, directory):
	286	(mode, size, mtime, atime) = self._read_stats(directory)
	287	basename = asbytes(os.path.basename(directory))
	288	if self.preserve_times:
	289	self._send_time(mtime, atime)
	290	self.channel.sendall(('D%s 0 ' % mode).encode('ascii') +
	291	basename.replace(b'\n', b'\\^J') + b'\n')
	292	self._recv_confirm()
	293	self._pushed += 1
	294
	295	def _send_popd(self):
	296	self.channel.sendall('E\n')
	297	self._recv_confirm()
	298	self._pushed -= 1
	299
	300	def _send_time(self, mtime, atime):
	301	self.channel.sendall(('T%d 0 %d 0\n' % (mtime, atime)).encode('ascii'))
	302	self._recv_confirm()
	303
	304	def _recv_confirm(self):
	305	# read scp response
	306	msg = b''
	307	try:
	308	msg = self.channel.recv(512)
	309	except SocketTimeout:
	310	raise SCPException('Timout waiting for scp response')
	311	# slice off the first byte, so this compare will work in py2 and py3
	312	if msg and msg[0:1] == b'\x00':
	313	return
	314	elif msg and msg[0:1] == b'\x01':
	315	raise SCPException(asunicode(msg[1:]))
	316	elif self.channel.recv_stderr_ready():
	317	msg = self.channel.recv_stderr(512)
	318	raise SCPException(asunicode(msg))
	319	elif not msg:
	320	raise SCPException('No response from server')
	321	else:
	322	raise SCPException('Invalid response from server', msg)
	323
	324	def _recv_all(self):
	325	# loop over scp commands, and receive as necessary
	326	command = {b'C': self._recv_file,
	327	b'T': self._set_time,
	328	b'D': self._recv_pushd,
	329	b'E': self._recv_popd}
	330	while not self.channel.closed:
	331	# wait for command as long as we're open
	332	self.channel.sendall('\x00')
	333	msg = self.channel.recv(1024)
	334	if not msg: # chan closed while recving
	335	break
	336	assert msg[-1:] == b'\n'
	337	msg = msg[:-1]
	338	code = msg[0:1]
	339	try:
	340	command[code](msg[1:])
	341	except KeyError:
	342	raise SCPException(asunicode(msg[1:]))
	343	# directory times can't be set until we're done writing files
	344	self._set_dirtimes()
	345
	346	def _set_time(self, cmd):
	347	try:
	348	times = cmd.split(b' ')
	349	mtime = int(times[0])
	350	atime = int(times[2]) or mtime
	351	except:
	352	self.channel.send(b'\x01')
	353	raise SCPException('Bad time format')
	354	# save for later
	355	self._utime = (atime, mtime)
	356
	357	def _recv_file(self, cmd):
	358	chan = self.channel
	359	parts = cmd.strip().split(b' ', 2)
	360
	361	try:
	362	mode = int(parts[0], 8)
	363	size = int(parts[1])
	364	if self._rename:
	365	path = self._recv_dir
	366	self._rename = False
	367	elif os.name == 'nt':
	368	path = os.path.join(asunicode_win(self._recv_dir),
	369	parts[2].decode('utf-8'))
	370	else:
	371	path = os.path.join(asbytes(self._recv_dir),
	372	parts[2])
	373	except:
	374	chan.send('\x01')
	375	chan.close()
	376	raise SCPException('Bad file format')
	377
	378	try:
	379	file_hdl = open(path, 'wb')
	380	except IOError as e:
	381	chan.send(b'\x01' + str(e).encode('utf-8'))
	382	chan.close()
	383	raise
	384
	385	if self._progress:
	386	if size == 0:
	387	# avoid divide-by-zero
	388	self._progress(path, 1, 1)
	389	else:
	390	self._progress(path, size, 0)
	391	buff_size = self.buff_size
	392	pos = 0
	393	chan.send(b'\x00')
	394	try:
	395	while pos < size:
	396	# we have to make sure we don't read the final byte
	397	if size - pos <= buff_size:
	398	buff_size = size - pos
	399	file_hdl.write(chan.recv(buff_size))
	400	pos = file_hdl.tell()
	401	if self._progress:
	402	self._progress(path, size, pos)
	403
	404	msg = chan.recv(512)
	405	if msg and msg[0:1] != b'\x00':
	406	raise SCPException(asunicode(msg[1:]))
	407	except SocketTimeout:
	408	chan.close()
	409	raise SCPException('Error receiving, socket.timeout')
	410
	411	file_hdl.truncate()
	412	try:
	413	os.utime(path, self._utime)
	414	self._utime = None
	415	os.chmod(path, mode)
	416	# should we notify the other end?
	417	finally:
	418	file_hdl.close()
	419	# '\x00' confirmation sent in _recv_all
	420
	421	def _recv_pushd(self, cmd):
	422	parts = cmd.split(b' ', 2)
	423	try:
	424	mode = int(parts[0], 8)
	425	if self._rename:
	426	path = self._recv_dir
	427	self._rename = False
	428	elif os.name == 'nt':
	429	path = os.path.join(asunicode_win(self._recv_dir),
	430	parts[2].decode('utf-8'))
	431	else:
	432	path = os.path.join(asbytes(self._recv_dir),
	433	parts[2])
	434	except:
	435	self.channel.send(b'\x01')
	436	raise SCPException('Bad directory format')
	437	try:
	438	if not os.path.exists(path):
	439	os.mkdir(path, mode)
	440	elif os.path.isdir(path):
	441	os.chmod(path, mode)
	442	else:
	443	raise SCPException('%s: Not a directory' % path)
	444	self._dirtimes[path] = (self._utime)
	445	self._utime = None
	446	self._recv_dir = path
	447	except (OSError, SCPException) as e:
	448	self.channel.send(b'\x01' + asbytes(str(e)))
	449	raise
	450
	451	def _recv_popd(self, *cmd):
	452	self._recv_dir = os.path.split(self._recv_dir)[0]
	453
	454	def _set_dirtimes(self):
	455	try:
	456	for d in self._dirtimes:
	457	os.utime(d, self._dirtimes[d])
	458	finally:
	459	self._dirtimes = {}
	460
	461
	462	class SCPException(Exception):
	463	"""SCP exception class"""
	464	pass No newline at end of file

schainpy/controller.py +23 -12

             '''
             Created on September , 2012
             @author:
             '''
             from xml.etree.ElementTree import Element, SubElement
             from xml.etree import ElementTree as ET
             from xml.dom import minidom
             #import datetime
             from model import *
             import ast
             def prettify(elem):
                 """Return a pretty-printed XML string for the Element.
                 """
                 rough_string = ET.tostring(elem, 'utf-8')
                 reparsed = minidom.parseString(rough_string)
                 return reparsed.toprettyxml(indent="  ")
             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):
                     if self.__formated_value != None:
                         return self.__formated_value
                     value = self.value
                     if self.format == 'bool':
                         value = int(value)
                     if self.format == 'list':
                         strList = value.split(',')
                         self.__formated_value = strList
                         return self.__formated_value
                     if self.format == 'intlist':
                         """
                         Example:
                             value = (0,1,2)
                         """
                         strList = value.split(',')
                         intList = [int(x) for x in strList]
                         self.__formated_value = intList
                         return self.__formated_value
                     if self.format == 'floatlist':
                         """
                         Example:
                             value = (0.5, 1.4, 2.7)
                         """
                         strList = value.split(',')
                         floatList = [float(x) for x in strList]
                         self.__formated_value = floatList
                         return self.__formated_value
                     if self.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 self.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 self.format == 'pairslist':
                         """
                         Example:
                             value = (0,1),(1,2)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         strList = value.split(',')
                         intList = [int(item) for item in strList]
                         pairList = []
                         for i in range(len(intList)/2):
                             pairList.append((intList[i*2], intList[i*2 + 1]))
                         self.__formated_value = pairList
                         return self.__formated_value
                     if self.format == 'multilist':
                         """
                         Example:
                             value = (0,1,2),(3,4,5)
                         """
                         multiList = ast.literal_eval(value)
                         self.__formated_value = multiList
                         return self.__formated_value
                     format_func = eval(self.format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def setup(self, id, name, value, format='str'):
                     self.id = id
                     self.name = name
                     self.value = str(value)
                     self.format = str.lower(format)
                 def makeXml(self, opElement):
                     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)
             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 getElementName(self):
                     return self.ELEMENTNAME
                 def getParameterObjList(self):
                     return self.parmConfObjList
                 def setup(self, id, name, priority, type):
                     self.id = id
                     self.name = name
                     self.type = type
                     self.priority = priority
                     self.parmConfObjList = []
                 def addParameter(self, name, value, format='str'):
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
                     parmConfObj.setup(id, name, value, format)
                     self.parmConfObjList.append(parmConfObj)
                     return parmConfObj
                 def makeXml(self, upElement):
                     opElement = SubElement(upElement, 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.getiterator(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,
                                                                           self.id,
                                                                           self.name,
                                                                           self.type,
                                                                           self.priority)
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self):
                     if self.type == 'self':
                         raise ValueError, "This operation type cannot be created"
                     if self.type == 'external' or self.type == 'other':
                         className = eval(self.name)
                         opObj = className()
                     return opObj
             class ProcUnitConf():
                 id = None
                 name = None
                 datatype = None
                 inputId = 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 str(self.id)
                 def getInputId(self):
                     return str(self.inputId)
                 def getOperationObjList(self):
                     return self.opConfObjList
                 def getProcUnitObj(self):
                     return self.procUnitObj
                 def setup(self, id, name, datatype, inputId):
                     self.id = id
                     self.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def addParameter(self, **kwargs):
                     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, procUnitElement):
                     upElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     upElement.set('id', str(self.id))
                     upElement.set('name', self.name)
                     upElement.set('datatype', self.datatype)
                     upElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
                         opConfObj.makeXml(upElement)
                 def readXml(self, upElement):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
-                    #Compatible with old signal chain version
-                    if self.ELEMENTNAME == ReadUnitConf().getElementName():
-                        if 'Reader' not in self.name:
-                            self.name += 'Reader'
-                    if self.ELEMENTNAME == ProcUnitConf().getElementName():
-                        if 'Proc' not in self.name:
-                            self.name += 'Proc'
                     self.opConfObjList = []
                     opElementList = upElement.getiterator(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,
                                                                          self.id,
                                                                          self.name,
                                                                          self.datatype,
                                                                          self.inputId)
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def createObjects(self):
                     className = eval(self.name)
                     procUnitObj = className()
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = opConfObj.createObject()
                         self.opObjDict[opConfObj.id] = opObj
                         procUnitObj.addOperation(opObj, opConfObj.id)
                     self.procUnitObj = procUnitObj
                     return procUnitObj
                 def run(self):
                     finalSts = False
                     for opConfObj in self.opConfObjList:
                         kwargs = {}
                         for parmConfObj in opConfObj.getParameterObjList():
                             kwargs[parmConfObj.name] = parmConfObj.getValue()
                         #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
                         sts = self.procUnitObj.call(opType = opConfObj.type,
                                                     opName = opConfObj.name,
                                                     opId = opConfObj.id,
                                                      **kwargs)
                         finalSts = finalSts or sts
                     return finalSts
+                def close(self):
+                    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 = 0
                     self.opConfObjList = []
                     self.opObjList = []
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, id, name, datatype, path="", startDate="", endDate="", startTime="", endTime="", **kwargs):
                     self.id = id
                     self.name = name
                     self.datatype = datatype
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.addRunOperation(**kwargs)
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name = 'run', optype = 'self')
                     opObj.addParameter(name='path'     , value=self.path, format='str')
                     opObj.addParameter(name='startDate' , value=self.startDate, format='date')
                     opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
                     opObj.addParameter(name='startTime' , value=self.startTime, 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
             class Project():
                 id = None
                 name = None
                 description = None
             #    readUnitConfObjList = None
                 procUnitConfObjDict = None
                 ELEMENTNAME = 'Project'
                 def __init__(self):
                     self.id = None
                     self.name = None
                     self.description = None
             #        self.readUnitConfObjList = []
                     self.procUnitConfObjDict = {}
                 def __getNewId(self):
                     id = int(self.id)*10 + len(self.procUnitConfObjDict) + 1
                     return str(id)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, id, name, description):
                     self.id = id
                     self.name = name
                     self.description = description
                 def addReadUnit(self, datatype=None, name=None, **kwargs):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         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','')
                     id = self.__getNewId()
                     readUnitConfObj = ReadUnitConf()
                     readUnitConfObj.setup(id, name, datatype, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
-                def addProcUnit(self, inputId, datatype=None, name=None):
+                def addProcUnit(self, inputId=0, datatype=None, name=None):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Proc' in datatype:
                             name = datatype
                         else:
                             name = '%sProc' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Proc','')
                     id = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
                     procUnitConfObj.setup(id, name, datatype, inputId)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.makeXml(projectElement)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename):
                     self.makeXml()
                     #print prettify(self.projectElement)
                     ElementTree(self.projectElement).write(filename, method='xml')
                 def readXml(self, filename):
                     #tree = ET.parse(filename)
                     self.projectElement = None
             #        self.readUnitConfObjList = []
                     self.procUnitConfObjDict = {}
                     self.projectElement = ElementTree().parse(filename)
                     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.getiterator(ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         readUnitConfObj.readXml(readUnitElement)
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement)
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                 def printattr(self):
                     print "Project[%s]: name = %s, description = %s" %(self.id,
                                                                           self.name,
                                                                           self.description)
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.printattr()
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.printattr()
                 def createObjects(self):
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.createObjects()
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.createObjects()
                 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 run(self):
             #        for readUnitConfObj in self.readUnitConfObjList:
             #            readUnitConfObj.run()
                     print
                     print "*"*40
                     print "   Starting SIGNAL CHAIN PROCESSING  "
                     print "*"*40
                     print
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     while(True):
                         finalSts = False
                         for procKey in keyList:
             #                 print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
                             procUnitConfObj = self.procUnitConfObjDict[procKey]
                             sts = procUnitConfObj.run()
                             finalSts = finalSts or sts
                         #If every process unit finished so end process
                         if not(finalSts):
                             print "Every process unit have finished"
                             break
+                    #Closing every process
+                    for procKey in keyList:
+                        procUnitConfObj = self.procUnitConfObjDict[procKey]
+                        procUnitConfObj.close()
+                def start(self, filename):
+                    self.writeXml(filename)
+                    self.readXml(filename)
+                    self.createObjects()
+                    self.connectObjects()
+                    self.run()
             if __name__ == '__main__':
                 desc = "Segundo Test"
                 filename = "schain.xml"
                 controllerObj = Project()
                 controllerObj.setup(id = '191', name='test01', description=desc)
                 readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
                                                             path='data/rawdata/',
                                                             startDate='2011/01/01',
                                                             endDate='2012/12/31',
                                                             startTime='00:00:00',
                                                             endTime='23:59:59',
                                                             online=1,
                                                             walk=1)
             #    opObj00 = readUnitConfObj.addOperation(name='printInfo')
                 procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
                 opObj10 = procUnitConfObj0.addOperation(name='selectChannels')
                 opObj10.addParameter(name='channelList', value='3,4,5', format='intlist')
                 opObj10 = procUnitConfObj0.addOperation(name='selectHeights')
                 opObj10.addParameter(name='minHei', value='90', format='float')
                 opObj10.addParameter(name='maxHei', value='180', format='float')
                 opObj12 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
                 opObj12.addParameter(name='n', value='10', format='int')
                 procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj0.getId())
                 procUnitConfObj1.addParameter(name='nFFTPoints', value='32', format='int')
             #    procUnitConfObj1.addParameter(name='pairList', value='(0,1),(0,2),(1,2)', format='')
                 opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
                 opObj11.addParameter(name='idfigure', value='1', format='int')
                 opObj11.addParameter(name='wintitle', value='SpectraPlot0', format='str')
                 opObj11.addParameter(name='zmin', value='40', format='int')
                 opObj11.addParameter(name='zmax', value='90', format='int')
                 opObj11.addParameter(name='showprofile', value='1', format='int')
             #    opObj11 = procUnitConfObj1.addOperation(name='CrossSpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='2', format='int')
             #    opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
             #    opObj11.addParameter(name='zmin', value='40', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #    procUnitConfObj2 = controllerObj.addProcUnit(datatype='Voltage', inputId=procUnitConfObj0.getId())
             #
             #    opObj12 = procUnitConfObj2.addOperation(name='CohInt', optype='external')
             #    opObj12.addParameter(name='n', value='2', format='int')
             #    opObj12.addParameter(name='overlapping', value='1', format='int')
             #
             #    procUnitConfObj3 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj2.getId())
             #    procUnitConfObj3.addParameter(name='nFFTPoints', value='32', format='int')
             #
             #    opObj11 = procUnitConfObj3.addOperation(name='SpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='2', format='int')
             #    opObj11.addParameter(name='wintitle', value='SpectraPlot1', format='str')
             #    opObj11.addParameter(name='zmin', value='40', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #    opObj11.addParameter(name='showprofile', value='1', format='int')
             #    opObj11 = procUnitConfObj1.addOperation(name='RTIPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='10', format='int')
             #    opObj11.addParameter(name='wintitle', value='RTI', format='str')
             ##    opObj11.addParameter(name='xmin', value='21', format='float')
             ##    opObj11.addParameter(name='xmax', value='22', format='float')
             #    opObj11.addParameter(name='zmin', value='40', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #    opObj11.addParameter(name='showprofile', value='1', format='int')
             #    opObj11.addParameter(name='timerange', value=str(60), format='int')
             #    opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
             #    opObj10.addParameter(name='channelList', value='0,2,4,6', format='intlist')
             #
             #    opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
             #    opObj12.addParameter(name='n', value='2', format='int')
             #
             #    opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='2', format='int')
             #    opObj11.addParameter(name='wintitle', value='SpectraPlot10', format='str')
             #    opObj11.addParameter(name='zmin', value='70', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #
             #    opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
             #    opObj10.addParameter(name='channelList', value='2,6', format='intlist')
             #
             #    opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
             #    opObj12.addParameter(name='n', value='2', format='int')
             #
             #    opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='3', format='int')
             #    opObj11.addParameter(name='wintitle', value='SpectraPlot10', format='str')
             #    opObj11.addParameter(name='zmin', value='70', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
             #    opObj12 = procUnitConfObj1.addOperation(name='decoder')
             #    opObj12.addParameter(name='ncode', value='2', format='int')
             #    opObj12.addParameter(name='nbauds', value='8', format='int')
             #    opObj12.addParameter(name='code0', value='001110011', format='int')
             #    opObj12.addParameter(name='code1', value='001110011', format='int')
             #    procUnitConfObj2 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj1.getId())
             #
             #    opObj21 = procUnitConfObj2.addOperation(name='IncohInt', optype='external')
             #    opObj21.addParameter(name='n', value='2', format='int')
             #
             #    opObj11 = procUnitConfObj2.addOperation(name='SpectraPlot', optype='external')
             #    opObj11.addParameter(name='idfigure', value='4', format='int')
             #    opObj11.addParameter(name='wintitle', value='SpectraPlot OBJ 2', format='str')
             #    opObj11.addParameter(name='zmin', value='70', format='int')
             #    opObj11.addParameter(name='zmax', value='90', format='int')
                 print "Escribiendo el archivo XML"
                 controllerObj.writeXml(filename)
                 print "Leyendo el archivo XML"
                 controllerObj.readXml(filename)
                 #controllerObj.printattr()
                 controllerObj.createObjects()
                 controllerObj.connectObjects()
                 controllerObj.run()
   No newline at end of file

schainpy/model/graphics/figure.py +44 -2

             import os
             import numpy
             import time, datetime
             import mpldriver
             import Queue
             import threading
             def isRealtime(utcdatatime):
                 utcnow = time.mktime(time.localtime())
                 delta = abs(utcnow - utcdatatime) # abs
                 if delta >= 30.:
                     return False
                 return True
             class Figure:
                 __driver = mpldriver
                 __isConfigThread = False
                 fig = None
                 id = None
                 wintitle = None
                 width = None
                 height = None
                 nplots = None
                 timerange = None
                 axesObjList = []
                 WIDTH = None
                 HEIGHT = None
                 PREFIX = 'fig'
                 xmin = None
                 xmax = None
+                counter_imagwr = 0
+                figfile = None
                 def __init__(self):
                     raise ValueError, "This method is not implemented"
                 def __del__(self):
                     self.__driver.closeFigure(True)
                 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 ValueError, "Abstract method: This method should be defined"
                 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):
                         raise ValueError, "timerange or xmin+xmax should be defined"
                     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.)
                     mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
                     xmin_sec = time.mktime(mindt.timetuple())
                     maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
                     xmax_sec = time.mktime(maxdt.timetuple())
                     return xmin_sec, xmax_sec
             #         if timerange != None:
             #             txmin = x[0] - x[0]%timerange
             #         else:
             #             txmin = numpy.min(x)
             #
             #         thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
             #         thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
             #
             #         ####################################################
             #         #If the x is out of xrange
             #         if xmax != None:
             #             if xmax < (thisdatetime - thisdate).seconds/(60*60.):
             #                 xmin = None
             #                 xmax = None
             #
             #         if xmin == None:
             #             td = thisdatetime - thisdate
             #             xmin = td.seconds/(60*60.)
             #
             #         if xmax == None:
             #             xmax = xmin + self.timerange/(60*60.)
             #
             #         mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
             #         tmin = time.mktime(mindt.timetuple())
             #
             #         maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
             #         tmax = time.mktime(maxdt.timetuple())
             #
             #         #self.timerange = tmax - tmin
             #
             #         return tmin, tmax
                 def init(self, id, nplots, wintitle):
                     raise ValueError, "This method has been replaced with 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)
                     self.fig = self.__driver.createFigure(id=self.id,
                                                           wintitle=self.wintitle,
                                                           width=self.widthscreen,
                                                           height=self.heightscreen,
                                                           show=show)
                     self.axesObjList = []
+                    self.counter_imagwr = 0
                 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 ValueError, "Este metodo ha sido reemplazaado con el metodo setText de la clase Axes"
                 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
                     raise ValueError, "Este metodo ha sido reemplazaado con el metodo 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):
+                    if not save:
+                        return
+                    if figfile == None:
+                        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
+                    self.counter_imagwr += 1
+                    if self.counter_imagwr<wr_period:
+                        return
+                    # store png plot to local folder
+                    self.saveFigure(figpath, self.figfile)
+                    self.counter_imagwr = 0
+                    if not ftp:
+                        return
+                    if not thisDatetime:
+                        return
+                    # store png plot to FTP server according to RT-Web format
+                    name = 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 ValueError, "This method is not implemented"
                 def close(self):
                     self.__driver.show(True)
                 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 = 300
                 __MAXNUMY = 150
                 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)
                 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)
                 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)
                 def pcolor(self, x, y, z,
                            xmin=None, xmax=None,
                            ymin=None, ymax=None,
                            zmin=None, zmax=None,
                            xlabel='', ylabel='',
                            title='', rti = False, colormap='jet',
                            **kwargs):
                     """
                     Input:
                         x        :
                         y        :
                         x        :
                         xmin    :
                         xmax    :
                         ymin    :
                         ymax    :
                         zmin    :
                         zmax    :
                         xlabel    :
                         ylabel    :
                         title    :
                         **kwargs :    Los parametros aceptados son
                                       ticksize=9,
                                       cblabel=''
                                       rti = True or False
                     """
                     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, 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
                     if rti:
                         self.__driver.addpcolor(self.ax, x, y, z, self.zmin, self.zmax,
                                                 xlabel=xlabel,
                                                 ylabel=ylabel,
                                                 title=title,
                                                 colormap=colormap)
                         return
                     self.__driver.pcolor(self.plot, z,
                                          xlabel=xlabel,
                                          ylabel=ylabel,
                                          title=title)
                 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.__MAXNUMX
                     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, x[-1]))
                     self.z_buffer = numpy.hstack((self.z_buffer, z))
                     if self.decimationx == None:
                         deltax = float(self.xmax - self.xmin)/maxNumX
                         deltay = float(self.ymax - self.ymin)/maxNumY
                         resolutionx = self.x_buffer[2]-self.x_buffer[0]
                         resolutiony = y[1]-y[0]
                         self.decimationx = numpy.ceil(deltax / resolutionx)
                         self.decimationy = numpy.ceil(deltay / resolutiony)
                     z_buffer = self.z_buffer.reshape(-1,len(y))
                     x_buffer = self.x_buffer[::self.decimationx]
                     y_buffer = y[::self.decimationy]
                     z_buffer = z_buffer[::self.decimationx, ::self.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)
                 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)
                 def __fillGaps(self, x_buffer, y_buffer, z_buffer):
                     deltas = x_buffer[1:] - x_buffer[0:-1]
                     x_median = numpy.median(deltas)
                     index = numpy.where(deltas >= 2*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
   No newline at end of file

schainpy/model/graphics/jroplot_correlation.py +6 -16

             import os
             import datetime
             import numpy
             import copy
             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]+1,dataOut.pairsList[i][1]+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()
-                    if save:
+                    self.save(figpath=figpath,
+                              figfile=figfile,
-                        if figfile == None:
+                              save=save,
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                              ftp=ftp,
-                            figfile = self.getFilename(name = str_datetime)
+                              wr_period=wr_period,
+                              thisDatetime=thisDatetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, figfile)
-                            # store png plot to FTP server according to RT-Web format
-                            if ftp:
-                                name = 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)
-                            self.counter_imagwr = 0

schainpy/model/graphics/jroplot_heispectra.py +14 -30

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from figure import Figure, isRealtime
             class SpectraHeisScope(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self):
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 230
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 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, show):
                     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,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if dataOut.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))
             #        x = dataOut.heightList
                     c   =  3E8
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     #deberia cambiar para el caso de 1Mhz y 100KHz
                     x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
                     #para 1Mhz descomentar la siguiente linea
                     #x= x/(10000.0)
             #        y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
             #        y = y.real
                     factor = dataOut.normFactor
                     data = dataOut.data_spc / factor
                     datadB = 10.*numpy.log10(data)
                     y = datadB
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = ""
                     #para 1Mhz descomentar la siguiente linea
                     #xlabel = "Frequency x 10000"
                     ylabel = "Intensity (dB)"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    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)
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         ychannel = y[i,:]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(i, numpy.max(ychannel), str_datetime)
                         axes = self.axesList[i]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, grid='both')
                     self.draw()
-                    if save:
+                    self.save(figpath=figpath,
+                              figfile=figfile,
-                        if figfile == None:
+                              save=save,
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                              ftp=ftp,
-                            figfile = self.getFilename(name = str_datetime)
+                              wr_period=wr_period,
+                              thisDatetime=thisDatetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, figfile)
-                            # store png plot to FTP server according to RT-Web format
-                            #name = 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)
-                            self.counter_imagwr = 0
             class RTIfromSpectraHeis(Figure):
                 isConfig = None
                 __nsubplots = None
                 PREFIX = 'rtinoise'
                 def __init__(self):
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 820
                     self.HEIGHT = 200
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.xdata = None
                     self.ydata = 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="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     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))
                     if timerange != None:
                         self.timerange = timerange
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     factor = dataOut.normFactor
                     data = dataOut.data_spc / factor
                     data = numpy.average(data,axis=1)
                     datadB = 10*numpy.log10(data)
             #        factor = dataOut.normFactor
             #        noise = dataOut.getNoise()/factor
             #        noisedB = 10*numpy.log10(noise)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Intensity (dB)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         tmin, tmax = self.getTimeLim(x, xmin, xmax)
                         if ymin == None: ymin = numpy.nanmin(datadB)
                         if ymax == None: ymax = numpy.nanmax(datadB)
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                     self.setWinTitle(title)
             #        title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     title = "RTI - %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     legendlabels = ["channel %d"%idchannel for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = datadB[channelIndexList].reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='.', markersize=8, linestyle="solid", grid='both',
                                 XAxisAsTime=True
                                 )
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         del self.xdata
                         del self.ydata
                         self.__isConfig = False
+                        self.figfile = None
-                    if save:
-                        if self.figfile == None:
+                    self.save(figpath=figpath,
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                              figfile=figfile,
-                            self.figfile = self.getFilename(name = str_datetime)
+                              save=save,
+                              ftp=ftp,
-                        self.counter_imagwr += 1
+                              wr_period=wr_period,
-                        if (self.counter_imagwr>=wr_period):
+                              thisDatetime=thisDatetime,
-                            # store png plot to local folder
+                              update_figfile=False)
-                            self.saveFigure(figpath, self.figfile)
-                            # store png plot to FTP server according to RT-Web format
-                            #name = 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)
-                            self.counter_imagwr = 0

schainpy/model/graphics/jroplot_parameters.py +57 -117

             import os
             import datetime
             import numpy
             from figure import Figure, isRealtime
+            from plotting_codes import *
             class MomentsPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 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.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)"
                     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
                     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]+1, 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()
-                    if save:
-                        if figfile == None:
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                            figfile = self.getFilename(name = str_datetime)
-                        self.counter_imagwr += 1
+                    self.save(figpath=figpath,
-                        if (self.counter_imagwr>=wr_period):
+                              figfile=figfile,
-                            # store png plot to local folder
+                              save=save,
-                            self.saveFigure(figpath, figfile)
+                              ftp=ftp,
-                            self.counter_imagwr = 0
+                              wr_period=wr_period,
-                            # store png plot to FTP server according to RT-Web format
+                              thisDatetime=thisDatetime)
-                            if ftp:
-                                name = 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)
             class SkyMapPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 def __init__(self):
                     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 = 1
+                    self.PLOT_CODE = SKYMAP_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,
                         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
                     """
                     arrayParameters = dataOut.data_param
                     error = arrayParameters[:,-1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid,:]
                     finalAzimuth = finalMeteor[:,4]
                     finalZenith = finalMeteor[:,5]
                     x = finalAzimuth*numpy.pi/180
                     y = finalZenith
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters"
                     xlabel = "Zonal Zenith Angle (deg) "
                     ylabel = "Meridional Zenith Angle (deg)"
                     if not self.__isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         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
                     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()
-                    if save:
-                        self.counter_imagwr += 1
+                    self.save(figpath=figpath,
-                        if (self.counter_imagwr==wr_period):
+                              figfile=figfile,
+                              save=save,
-                            if figfile == None:
+                              ftp=ftp,
-                                figfile = self.getFilename(name = self.name)
+                              wr_period=wr_period,
+                              thisDatetime=thisDatetime)
-                            self.saveFigure(figpath, figfile)
-                            self.counter_imagwr = 0
-                            if ftp:
-                                #provisionalmente envia archivos en el formato de la web en tiempo real
-                                name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
-                                path = '%s%03d' %(self.PREFIX, self.id)
-                                ftp_file = os.path.join(path,'ftp','%s.png'%name)
-                                self.saveFigure(figpath, ftp_file)
-                                ftp_filename = os.path.join(figpath,ftp_file)
-                                try:
-                                    self.sendByFTP(ftp_filename, server, folder, username, password)
-                                except:
-                                    self.counter_imagwr = 0
-                                    raise ValueError, 'Error FTP'
             class WindProfilerPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'wind'
                 def __init__(self):
                     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 = 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,
                         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 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))
                     if timerange != None:
                         self.timerange = timerange
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange1()
             #         y = dataOut.heightList
                     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 != 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
                     showprofile = False
             #        thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + "Wind"
                     xlabel = ""
                     ylabel = "Range (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 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 != 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', '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]
                         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="RdBu_r" )
                     if dataOut.data_SNR != 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()
-                    if save:
-                        if self.figfile == None:
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                            self.figfile = self.getFilename(name = str_datetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, self.figfile)
-                            self.counter_imagwr = 0
-                            if ftp:
-                                # store png plot to FTP server according to RT-Web format
-                                name = 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)
                     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 ParametersPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 def __init__(self):
                     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 = 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,
                         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):
                     """
                     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 timerange != None:
                         self.timerange = timerange
                     #tmin = None
                     #tmax = None
                     if parameterIndex == None:
                         parameterIndex = 1
                     x = dataOut.getTimeRange1()
                     y = dataOut.heightList
                     z = data_param[channelIndexList,parameterIndex,:].copy()
                     zRange = dataOut.abscissaList
                     nplots = z.shape[0]    #Number of wind dimensions estimated
             #        thisDatetime = dataOut.datatime
                     if dataOut.data_SNR != 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: 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 != None:
                             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: j = 2*i
                         else: j = i
                         title = "%s Channel %d: %s" %(parameterName, channelIndexList[i]+1, 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*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 SNR:
                             title = "Channel %d Signal Noise Ratio (SNR): %s" %(channelIndexList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                             axes = self.axesList[(j + 1)*self.__nsubplots]
                             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 save:
-                        if self.figfile == None:
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                            self.figfile = self.getFilename(name = str_datetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, self.figfile)
-                            self.counter_imagwr = 0
-                            if ftp:
-                                # store png plot to FTP server according to RT-Web format
-                                name = 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)
                     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):
                     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]+1)
                         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()
-                    if save:
+                    self.save(figpath=figpath,
-                        date = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                              figfile=figfile,
-                        if figfile == None:
+                              save=save,
-                            figfile = self.getFilename(name = date)
+                              ftp=ftp,
+                              wr_period=wr_period,
-                        self.saveFigure(figpath, figfile)
+                              thisDatetime=thisDatetime)
             class EWDriftsPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'drift'
                 def __init__(self):
                     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 = 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 != None:
                         self.timerange = timerange
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange1()
             #         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 != 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 != 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 != 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 save:
-                        if self.figfile == None:
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                            self.figfile = self.getFilename(name = str_datetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, self.figfile)
-                            self.counter_imagwr = 0
-                            if ftp:
-                                # store png plot to FTP server according to RT-Web format
-                                name = 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)
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         self.__isConfig = False
-                        self.figfile = None
  No newline at end of file
+                        self.figfile = None
+                    self.save(figpath=figpath,
+                              figfile=figfile,
+                              save=save,
+                              ftp=ftp,
+                              wr_period=wr_period,
+                              thisDatetime=thisDatetime,
+                              update_figfile=False)
  No newline at end of file

schainpy/model/graphics/jroplot_spectra.py +72 -133

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from figure import Figure, isRealtime
+            from plotting_codes import *
             class SpectraPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 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.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):
                     """
                     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"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[channelIndexList,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     avg = numpy.nanmean(z, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     noise = dataOut.getNoise()/factor
                     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)
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     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):
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i]+1, noisedB[i], str_datetime)
                         if len(dataOut.beam.codeList) != 0:
                             title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[i]+1, noisedB[i], dataOut.beam.azimuthList[i], dataOut.beam.zenithList[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='')
                         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()
-                    if save:
+                    if figfile == None:
+                        str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                        if figfile == None:
+                        name = str_datetime
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                        if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
-                            figfile = self.getFilename(name = str_datetime)
+                            name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
-                            name = str_datetime
+                        figfile = self.getFilename(name)
-                            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.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, figfile)
-                            self.counter_imagwr = 0
-                            if ftp:
+                    self.save(figpath=figpath,
-                                # store png plot to FTP server according to RT-Web format
+                              figfile=figfile,
-                                name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
+                              save=save,
-                                ftp_filename = os.path.join(figpath, name)
+                              ftp=ftp,
-                                self.saveFigure(figpath, ftp_filename)
+                              wr_period=wr_period,
+                              thisDatetime=thisDatetime)
             class CrossSpectraPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTH = None
                 HEIGHT = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cspc'
                 def __init__(self):
                     self.isConfig = False
                     self.__nsubplots = 4
                     self.counter_imagwr = 0
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
-                    self.PLOT_CODE = 1
+                    self.PLOT_CODE = CROSS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = 4
                     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=True)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", pairsList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', 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 pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %str(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     factor = dataOut.normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[:,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     noise = dataOut.noise/factor
                     zdB = 10*numpy.log10(z)
                     noisedB = 10*numpy.log10(noise)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=False,
                                    show=show)
                         avg = numpy.abs(numpy.average(z, axis=1))
                         avgdB = 10*numpy.log10(avg)
                         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):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[pair[0]], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[pair[1]], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots+1]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
                         coherence = numpy.abs(coherenceComplex)
             #            phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
                         phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
                         title = "Coherence %d%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+2]
                         axes0.pcolor(x, y, coherence,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=coherence_cmap, cblabel='')
                         title = "Phase %d%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+3]
                         axes0.pcolor(x, y, phase,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=phase_cmap, cblabel='')
                     self.draw()
-                    if save != '':
+                    self.save(figpath=figpath,
+                              figfile=figfile,
-                        if figfile == None:
+                              save=save,
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                              ftp=ftp,
-                            figfile = self.getFilename(name = str_datetime)
+                              wr_period=wr_period,
+                              thisDatetime=thisDatetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, figfile)
-                            self.counter_imagwr = 0
-                            if ftp:
-                                # store png plot to FTP server according to RT-Web format
-                                name = 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)
             class RTIPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'rti'
                 def __init__(self):
                     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 = 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, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         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()
                     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,
                         timerange=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 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))
             #         if timerange != None:
             #             self.timerange = timerange
                     #tmin = None
                     #tmax = None
                     factor = dataOut.normFactor
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[channelIndexList,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10.*numpy.log10(avg)
             #        thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     if not self.__isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         noise = dataOut.noise/factor
                         noisedB = 10*numpy.log10(noise)
                         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.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(self.nplots):
                         title = "Channel %d: %s" %(dataOut.channelList[i]+1, 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[i*self.__nsubplots]
                         zdB = avgdB[i].reshape((1,-1))
                         axes.pcolorbuffer(x, y, zdB,
                                     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%")
                         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')
                     self.draw()
-                    if save:
-                        if self.figfile == None:
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                            self.figfile = self.getFilename(name = str_datetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, self.figfile)
-                            self.counter_imagwr = 0
-                            if ftp:
-                                # store png plot to FTP server according to RT-Web format
-                                name = 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)
                     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 CoherenceMap(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cmap'
                 def __init__(self):
                     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 = 3
+                    self.PLOT_CODE = COH_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.counter_imagwr = 0
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots*2
                     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 = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     nrow, ncol = self.getSubplots()
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
             #         tmin = None
             #         tmax = None
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 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.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
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         coherence = numpy.abs(avgcoherenceComplex)
                         z = coherence.reshape((1,-1))
                         counter = 0
                         title = "Coherence %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2]
                         axes.pcolorbuffer(x, y, z,
                                     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='', colormap=coherence_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(coherence, y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=5,
                                     grid='x')
                         counter += 1
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         z = phase.reshape((1,-1))
                         title = "Phase %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2 + counter]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(phase, y,
                                     xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=4,
                                     grid='x')
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         self.__isConfig = False
+                        self.figfile = None
-                    if save:
-                        if figfile == None:
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                            figfile = self.getFilename(name = str_datetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
+                    self.save(figpath=figpath,
-                            # store png plot to local folder
+                              figfile=figfile,
-                            self.saveFigure(figpath, figfile)
+                              save=save,
-                            self.counter_imagwr = 0
+                              ftp=ftp,
+                              wr_period=wr_period,
-                            if ftp:
+                              thisDatetime=thisDatetime,
-                                # store png plot to FTP server according to RT-Web format
+                              update_figfile=False)
-                                name = 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)
             class PowerProfile(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spcprofile'
                 def __init__(self):
                     self.isConfig = False
                     self.__nsubplots = 1
+                    self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 300
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=None):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     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
                     y = dataOut.getHeiRange()
                     #for voltage
                     if dataOut.type == 'Voltage':
                         x = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
                         x = x.real
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                     #for spectra
                     if dataOut.type == 'Spectra':
                         x = dataOut.data_spc[channelIndexList,:,:]/factor
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                         x = numpy.average(x, axis=1)
                     xdB = 10*numpy.log10(x)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "dB"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if xmin == None: xmin = numpy.nanmin(xdB)*0.9
                         if xmax == None: xmax = numpy.nanmax(xdB)*1.1
                         self.__isConfig = True
                     self.setWinTitle(title)
                     title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["channel %d"%x for x in channelList]
                     axes.pmultiline(xdB, y,
                             xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                             xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
                             ytick_visible=True, nxticks=5,
                             grid='x')
                     self.draw()
-                    if save:
+                    self.save(figpath=figpath,
+                              figfile=figfile,
-                        if figfile == None:
+                              save=save,
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                              ftp=ftp,
-                            figfile = self.getFilename(name = str_datetime)
+                              wr_period=wr_period,
+                              thisDatetime=thisDatetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
-                            # store png plot to local folder
-                            self.saveFigure(figpath, figfile)
-                            self.counter_imagwr = 0
             class Noise(Figure):
                 isConfig = None
                 __nsubplots = None
                 PREFIX = 'noise'
                 def __init__(self):
                     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 = 17
+                    self.PLOT_CODE = NOISE_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def openfile(self, filename):
                     f = open(filename,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Noise \n')
                     f.write('DD MM YYYY  HH MM SS   Channel0    Channel1    Channel2    Channel3\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 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="", channelList=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):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     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.getTimeRange()
                     #y = dataOut.getHeiRange()
                     factor = dataOut.normFactor
                     noise = dataOut.noise/factor
                     noisedB = 10*numpy.log10(noise)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Intensity (dB)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.floor(numpy.nanmin(noisedB)) - 10.0
                         if ymax == None: ymax = numpy.nanmax(noisedB) + 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)
                         noise_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_noise = os.path.join(figpath,noise_file)
                         self.openfile(self.filename_noise)
                     #store data beacon phase
                     self.save_data(self.filename_noise, noisedB, thisDatetime)
                     self.setWinTitle(title)
                     title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["channel %d"%(idchannel+1) for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = noisedB[channelIndexList].reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         del self.xdata
                         del self.ydata
                         self.__isConfig = False
+                        self.figfile = None
-                    if save != '':
-                        if self.figfile == None:
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                            self.figfile = self.getFilename(name = str_datetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
+                    self.save(figpath=figpath,
-                            # store png plot to local folder
+                              figfile=figfile,
-                            self.saveFigure(figpath, self.figfile)
+                              save=save,
-                            self.counter_imagwr = 0
+                              ftp=ftp,
+                              wr_period=wr_period,
-                            if ftp:
+                              thisDatetime=thisDatetime,
-                                # store png plot to FTP server according to RT-Web format
+                              update_figfile=False)
-                                name = 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)
             class BeaconPhase(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     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 = 18
+                    self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       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 save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 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):
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
             #         if len(pairsIndexList) > 4:
             #             pairsIndexList = pairsIndexList[0:4]
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Phase of Beacon Signal" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase"
                     nplots = len(pairsIndexList)
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         #print "Phase %d%d" %(pair[0], pair[1])
                         #print phase[dataOut.beacon_heiIndexList]
                         phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                     if not self.__isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 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)
                         #self.save_phase(self.filename_phase)
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Beacon Signal %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["pairs %d%d"%(pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         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()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         del self.xdata
                         del self.ydata
                         self.__isConfig = False
+                        self.figfile = None
-                    if save:
-                        if self.figfile == None:
-                            str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
-                            self.figfile = self.getFilename(name = str_datetime)
-                        self.counter_imagwr += 1
-                        if (self.counter_imagwr>=wr_period):
+                    self.save(figpath=figpath,
-                            # store png plot to local folder
+                              figfile=figfile,
-                            self.saveFigure(figpath, self.figfile)
+                              save=save,
-                            self.counter_imagwr = 0
+                              ftp=ftp,
+                              wr_period=wr_period,
-                            if ftp:
+                              thisDatetime=thisDatetime,
-                                # store png plot to FTP server according to RT-Web format
+                              update_figfile=False)
-                                name = 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)

schainpy/model/graphics/jroplot_voltage.py +6 -12

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from figure import Figure
             class Scope(Figure):
                 isConfig = None
                 def __init__(self):
                     self.isConfig = False
                     self.WIDTH = 300
                     self.HEIGHT = 200
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     nrow = self.nplots
                     ncol = 3
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     self.createFigure(id=id,
                                       wintitle=wintitle,
                                       show=show)
                     nrow,ncol = self.getSubplots()
                     colspan = 3
                     rowspan = 1
                     for i in range(nplots):
                         self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
                 def plot_iq(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     yreal = y[channelIndexList,:].real
                     yimag = y[channelIndexList,:].imag
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity - IQ"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = min(numpy.nanmin(yreal),numpy.nanmin(yimag))
                         if ymax == None: ymax = max(numpy.nanmax(yreal),numpy.nanmax(yimag))
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         axes.pline(x, yreal[i,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                         axes.addpline(x, yimag[i,:], idline=1, color="red", linestyle="solid", lw=2)
                 def plot_power(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
                     yreal = y.real
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(yreal)
                         if ymax == None: ymax = numpy.nanmax(yreal)
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         ychannel = yreal[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=None, show=True, wr_period=1,
                         ftp=False, server=None, folder=None, username=None, password=None, type='power'):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     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))
                     x = dataOut.heightList
                     y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
                     y = y.real
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     if type == "power":
                         self.plot_power(dataOut.heightList,
                                         dataOut.data,
                                         id,
                                         channelIndexList,
                                         thisDatetime,
                                         wintitle,
                                         show,
                                         xmin,
                                         xmax,
                                         ymin,
                                         ymax)
                     if type == "iq":
                         self.plot_iq(dataOut.heightList,
                                      dataOut.data,
                                      id,
                                      channelIndexList,
                                      thisDatetime,
                                      wintitle,
                                      show,
                                      xmin,
                                      xmax,
                                      ymin,
                                      ymax)
                     self.draw()
-                    if save:
+                    self.save(figpath=figpath,
-                        date = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                              figfile=figfile,
-                        if figfile == None:
+                              save=save,
-                            figfile = self.getFilename(name = date)
+                              ftp=ftp,
+                              wr_period=wr_period,
-                        self.saveFigure(figpath, figfile)
+                              thisDatetime=thisDatetime)
-                        self.counter_imagwr += 1
-                        if (ftp and (self.counter_imagwr==wr_period)):
-                            ftp_filename = os.path.join(figpath,figfile)
-                            self.sendByFTP_Thread(ftp_filename, server, folder, username, password)
-                            self.counter_imagwr = 0

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

             '''
             Created on Jul 2, 2014
             @author: roj-idl71
             '''
             import os
             import sys
             import glob
             import time
             import numpy
             import fnmatch
             import time, datetime
             #import h5py
             import traceback
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             LOCALTIME = True
             def isNumber(cad):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float( cad )
                     return True
                 except:
                     return False
             def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 try:
                     fp = open(filename,'rb')
                 except IOError:
                     traceback.print_exc()
                     raise IOError, "The file %s can't be opened" %(filename)
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
             def isFileinThisTime(filename, startTime, endTime):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startTime          :    tiempo inicial del rango seleccionado en formato datetime.time
                     endTime            :    tiempo final del rango seleccionado en formato datetime.time
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 try:
                     fp = open(filename,'rb')
                 except IOError:
                     traceback.print_exc()
                     raise IOError, "The file %s can't be opened" %(filename)
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 thisDatetime = basicHeaderObj.datatime
                 thisTime = thisDatetime.time()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return None
                 if not ((startTime <= thisTime) and (endTime > thisTime)):
                     return None
                 return thisDatetime
             def getFileFromSet(path, ext, set):
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     try:
                         year = int(thisFile[1:5])
                         doy  = int(thisFile[5:8])
                     except:
                         continue
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
                 if len(myfile)!= 0:
                     return myfile[0]
                 else:
                     filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())
                     print 'the filename %s does not exist'%filename
                     print '...going to the last file: '
                 if validFilelist:
                     validFilelist = sorted( validFilelist, key=str.lower )
                     return validFilelist[-1]
                 return None
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     year = thisFile[1:5]
                     if not isNumber(year):
                         continue
                     doy = thisFile[5:8]
                     if not isNumber(doy):
                         continue
                     year = int(year)
                     doy = int(doy)
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 if validFilelist:
                     validFilelist = sorted( validFilelist, key=str.lower )
                     return validFilelist[-1]
                 return None
             def checkForRealPath(path, foldercounter, year, doy, set, ext):
                 """
                 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
                 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
                 el path exacto de un determinado file.
                 Example    :
                     nombre correcto del file es  .../.../D2009307/P2009307367.ext
                     Entonces la funcion prueba con las siguientes combinaciones
                         .../.../y2009307367.ext
                         .../.../Y2009307367.ext
                         .../.../x2009307/y2009307367.ext
                         .../.../x2009307/Y2009307367.ext
                         .../.../X2009307/y2009307367.ext
                         .../.../X2009307/Y2009307367.ext
                     siendo para este caso, la ultima combinacion de letras, identica al file buscado
                 Return:
                     Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
                     caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
                     para el filename
                 """
                 fullfilename = None
                 find_flag = False
                 filename = None
                 prefixDirList = [None,'d','D']
                 if ext.lower() == ".r": #voltage
                     prefixFileList = ['d','D']
                 elif ext.lower() == ".pdata": #spectra
                     prefixFileList = ['p','P']
                 else:
                     return None, filename
                 #barrido por las combinaciones posibles
                 for prefixDir in prefixDirList:
                     thispath = path
                     if prefixDir != None:
                         #formo el nombre del directorio xYYYYDDD (x=d o x=D)
                         if foldercounter == 0:
                             thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
                         else:
                             thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
                     for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
                         filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
                         fullfilename = os.path.join( thispath, filename ) #formo el path completo
                         if os.path.exists( fullfilename ): #verifico que exista
                             find_flag = True
                             break
                     if find_flag:
                         break
                 if not(find_flag):
                     return None, filename
                 return fullfilename, filename
             def isDoyFolder(folder):
                 try:
                     year = int(folder[1:5])
                 except:
                     return 0
                 try:
                     doy = int(folder[5:8])
                 except:
                     return 0
                 return 1
             class JRODataIO:
                 c = 3E8
                 isConfig = False
                 basicHeaderObj = None
                 systemHeaderObj = None
                 radarControllerHeaderObj = None
                 processingHeaderObj = None
                 online = 0
                 dtype = None
                 pathList = []
                 filenameList = []
                 filename = None
                 ext = None
                 flagIsNewFile = 1
                 flagDiscontinuousBlock = 0
                 flagIsNewBlock = 0
                 fp = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 versionFile = 1103
                 fileSize = None
             #     ippSeconds = None
                 fileSizeByHeader = None
                 fileIndex = None
                 profileIndex = None
                 blockIndex = None
                 nTotalBlocks = None
                 maxTimeStep = 30
                 lastUTTime = None
                 datablock = None
                 dataOut = None
                 blocksize = None
                 getByBlock = False
                 def __init__(self):
                     raise ValueError, "Not implemented"
                 def run(self):
                     raise ValueError, "Not implemented"
             class JRODataReader(JRODataIO):
                 nReadBlocks = 0
                 delay  = 10   #number of seconds waiting a new file
                 nTries  = 3  #quantity tries
                 nFiles = 3   #number of files for searching
                 path = None
                 foldercounter = 0
                 flagNoMoreFiles = 0
                 datetimeList = []
                 __isFirstTimeOnline = 1
                 __printInfo = True
                 profileIndex = None
                 nTxs = 1
                 txIndex = None
                 def __init__(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def createObjByDefault(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def getBlockDimension(self):
                     raise ValueError, "No implemented"
                 def __searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
                                         startTime=datetime.time(0,0,0),
                                         endTime=datetime.time(23,59,59),
                                         set=None,
                                         expLabel='',
                                         ext='.r',
                                         walk=True):
                     pathList = []
                     if not walk:
                         #pathList.append(path)
                         multi_path = path.split(',')
                         for single_path in multi_path:
                             pathList.append(single_path)
                     else:
                         #dirList = []
                         multi_path = path.split(',')
                         for single_path in multi_path:
                             dirList = []
                             for thisPath in os.listdir(single_path):
                                 if not os.path.isdir(os.path.join(single_path,thisPath)):
                                     continue
                                 if not isDoyFolder(thisPath):
                                     continue
                                 dirList.append(thisPath)
                             if not(dirList):
                                 return None, None
                             thisDate = startDate
                             while(thisDate <= endDate):
                                 year = thisDate.timetuple().tm_year
                                 doy = thisDate.timetuple().tm_yday
                                 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
                                 if len(matchlist) == 0:
                                     thisDate += datetime.timedelta(1)
                                     continue
                                 for match in matchlist:
                                     pathList.append(os.path.join(single_path,match,expLabel))
                                 thisDate += datetime.timedelta(1)
                     if pathList == []:
                         print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
                         return None, None
                     print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
                     filenameList = []
                     datetimeList = []
                     pathDict = {}
                     filenameList_to_sort = []
                     for i in range(len(pathList)):
                         thisPath = pathList[i]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         if len(fileList) < 1:
                             continue
                         fileList.sort()
                         pathDict.setdefault(fileList[0])
                         pathDict[fileList[0]] = i
                         filenameList_to_sort.append(fileList[0])
                     filenameList_to_sort.sort()
                     for file in filenameList_to_sort:
                         thisPath = pathList[pathDict[file]]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             thisDatetime = isFileinThisTime(filename, startTime, endTime)
                             if not(thisDatetime):
                                 continue
                             filenameList.append(filename)
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
                         print "Any file was found for the time range %s - %s" %(startTime, endTime)
                         return None, None
                     print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
                     print
                     for i in range(len(filenameList)):
                         print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
                     self.filenameList = filenameList
                     self.datetimeList = datetimeList
                     return pathList, filenameList
                 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None):
                     """
                     Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
                     devuelve el archivo encontrado ademas de otros datos.
                     Input:
                         path           :    carpeta donde estan contenidos los files que contiene data
                         expLabel        :     Nombre del subexperimento (subfolder)
                         ext              :    extension de los files
                         walk        :    Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
                     Return:
                         directory   :    eL directorio donde esta el file encontrado
                         filename    :    el ultimo file de una determinada carpeta
                         year        :    el anho
                         doy         :    el numero de dia del anho
                         set         :    el set del archivo
                     """
                     dirList = []
                     if not walk:
                         fullpath = path
                         foldercounter = 0
                     else:
                         #Filtra solo los directorios
                         for thisPath in os.listdir(path):
                             if not os.path.isdir(os.path.join(path,thisPath)):
                                 continue
                             if not isDoyFolder(thisPath):
                                 continue
                             dirList.append(thisPath)
                         if not(dirList):
                             return None, None, None, None, None, None
                         dirList = sorted( dirList, key=str.lower )
                         doypath = dirList[-1]
                         foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
                         fullpath = os.path.join(path, doypath, expLabel)
                     print "%s folder was found: " %(fullpath )
                     if set == None:
                         filename = getlastFileFromPath(fullpath, ext)
                     else:
                         filename = getFileFromSet(fullpath, ext, set)
                     if not(filename):
                         return None, None, None, None, None, None
                     print "%s file was found" %(filename)
                     if not(self.__verifyFile(os.path.join(fullpath, filename))):
                         return None, None, None, None, None, None
                     year = int( filename[1:5] )
                     doy  = int( filename[5:8] )
                     set  = int( filename[8:11] )
                     return fullpath, foldercounter, filename, year, doy, set
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print "No more Files"
                             return 0
                         filename = self.filenameList[idFile]
                         if not(self.__verifyFile(filename)):
                             continue
                         fileSize = os.path.getsize(filename)
                         fp = open(filename,'rb')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fp = fp
-                    print "Setting the file: %s"%self.filename
+                    print "[Reading] Setting the file: %s"%self.filename
                     return 1
                 def __setNextFileOnline(self):
                     """
                     Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
                     no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
                     siguientes.
                     Affected:
                         self.flagIsNewFile
                         self.filename
                         self.fileSize
                         self.fp
                         self.set
                         self.flagNoMoreFiles
                     Return:
 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
 : si el file fue abierto con exito y esta listo a ser leido
                     Excepciones:
                         Si un determinado file no puede ser abierto
                     """
                     nFiles = 0
                     fileOk_flag = False
                     firstTime_flag = True
                     self.set += 1
                     if self.set > 999:
                         self.set = 0
                         self.foldercounter += 1
                     #busca el 1er file disponible
                     fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
                     if fullfilename:
                         if self.__verifyFile(fullfilename, False):
                             fileOk_flag = True
                     #si no encuentra un file entonces espera y vuelve a buscar
                     if not(fileOk_flag):
                         for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
                             if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
                                 tries = self.nTries
                             else:
                                 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
                             for nTries in range( tries ):
                                 if firstTime_flag:
                                     print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
                                     sleep( self.delay )
                                 else:
                                     print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
                                 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
                                 if fullfilename:
                                     if self.__verifyFile(fullfilename):
                                         fileOk_flag = True
                                         break
                             if fileOk_flag:
                                 break
                             firstTime_flag = False
                             print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename
                             self.set += 1
                             if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
                                 self.set = 0
                                 self.doy += 1
                                 self.foldercounter = 0
                     if fileOk_flag:
                         self.fileSize = os.path.getsize( fullfilename )
                         self.filename = fullfilename
                         self.flagIsNewFile = 1
                         if self.fp != None: self.fp.close()
                         self.fp = open(fullfilename, 'rb')
                         self.flagNoMoreFiles = 0
-                        print 'Setting the file: %s' % fullfilename
+                        print '[Reading] Setting the file: %s' % fullfilename
                     else:
                         self.fileSize = 0
                         self.filename = None
                         self.flagIsNewFile = 0
                         self.fp = None
                         self.flagNoMoreFiles = 1
-                        print 'No more Files'
+                        print '[Reading] No more files to read'
                     return fileOk_flag
                 def setNextFile(self):
                     if self.fp != None:
                         self.fp.close()
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.__readFirstHeader()
                     self.nReadBlocks = 0
                     return 1
                 def __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                     Si el modo de lectura es OffLine siempre retorn 0
                     """
                     if not self.online:
                         return 0
                     if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     for nTries in range( self.nTries ):
                         self.fp.close()
                         self.fp = open( self.filename, 'rb' )
                         self.fp.seek( currentPointer )
                         self.fileSize = os.path.getsize( self.filename )
                         currentSize = self.fileSize - currentPointer
                         if ( currentSize >= neededSize ):
                             self.basicHeaderObj.read(self.fp)
                             return 1
                         if self.fileSize == self.fileSizeByHeader:
             #                self.flagEoF = True
                             return 0
                         print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
                         sleep( self.delay )
                     return 0
                 def waitDataBlock(self,pointer_location):
                     currentPointer = pointer_location
                     neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize
                     for nTries in range( self.nTries ):
                         self.fp.close()
                         self.fp = open( self.filename, 'rb' )
                         self.fp.seek( currentPointer )
                         self.fileSize = os.path.getsize( self.filename )
                         currentSize = self.fileSize - currentPointer
                         if ( currentSize >= neededSize ):
                             return 1
                         print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
                         sleep( self.delay )
                     return 0
                 def __jumpToLastBlock(self):
                     if not(self.__isFirstTimeOnline):
                         return
                     csize = self.fileSize - self.fp.tell()
                     blocksize = self.processingHeaderObj.blockSize
                     #salta el primer bloque de datos
                     if csize > self.processingHeaderObj.blockSize:
                         self.fp.seek(self.fp.tell() + blocksize)
                     else:
                         return
                     csize = self.fileSize - self.fp.tell()
                     neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     while True:
                         if self.fp.tell()<self.fileSize:
                             self.fp.seek(self.fp.tell() + neededsize)
                         else:
                             self.fp.seek(self.fp.tell() - neededsize)
                             break
             #        csize = self.fileSize - self.fp.tell()
             #        neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
             #        factor = int(csize/neededsize)
             #        if factor > 0:
             #            self.fp.seek(self.fp.tell() + factor*neededsize)
                     self.flagIsNewFile = 0
                     self.__isFirstTimeOnline = 0
                 def __setNewBlock(self):
                     if self.fp == None:
                         return 0
                     if self.online:
                         self.__jumpToLastBlock()
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.basicHeaderObj.utc
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.basicHeaderObj.read(self.fp)
                         return 1
                     if self.__waitNewBlock():
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
                     self.flagDiscontinuousBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagDiscontinuousBlock = 1
                     return 1
                 def readNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
                 def __readFirstHeader(self):
                     self.basicHeaderObj.read(self.fp)
                     self.systemHeaderObj.read(self.fp)
                     self.radarControllerHeaderObj.read(self.fp)
                     self.processingHeaderObj.read(self.fp)
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
                     else:
                         raise ValueError, 'Data type was not defined'
                     self.dtype = datatype_str
                     #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
             #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
             #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def __verifyFile(self, filename, msgFlag=True):
                     msg = None
                     try:
                         fp = open(filename, 'rb')
                         currentPosition = fp.tell()
                     except IOError:
                         traceback.print_exc()
                         if msgFlag:
                             print "[Reading] The file %s can't be opened" % (filename)
                         return False
                     neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
                     if neededSize == 0:
                         basicHeaderObj = BasicHeader(LOCALTIME)
                         systemHeaderObj = SystemHeader()
                         radarControllerHeaderObj = RadarControllerHeader()
                         processingHeaderObj = ProcessingHeader()
                         try:
                             if not( basicHeaderObj.read(fp) ): raise IOError
                             if not( systemHeaderObj.read(fp) ): raise IOError
                             if not( radarControllerHeaderObj.read(fp) ): raise IOError
                             if not( processingHeaderObj.read(fp) ): raise IOError
             #                 data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                             neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
                         except IOError:
                             traceback.print_exc()
                             if msgFlag:
                                 print "[Reading] The file %s is empty or it hasn't enough data" % filename
                             fp.close()
                             return False
                     else:
                         msg = "[Reading] Skipping the file %s due to it hasn't enough data" %filename
                     fp.close()
                     fileSize = os.path.getsize(filename)
                     currentSize = fileSize - currentPosition
                     if currentSize < neededSize:
                         if msgFlag and (msg != None):
                             print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
                         return False
                     return True
                 def setup(self,
                             path=None,
                             startDate=None,
                             endDate=None,
                             startTime=datetime.time(0,0,0),
                             endTime=datetime.time(23,59,59),
                             set=None,
                             expLabel = "",
                             ext = None,
                             online = False,
                             delay = 60,
                             walk = True,
                             getblock = False,
                             nTxs = 1):
                     if path == None:
                         raise ValueError, "[Reading] The path is not valid"
                     if ext == None:
                         ext = self.ext
                     if online:
                         print "[Reading] Searching files in online mode..."
                         for nTries in range( self.nTries ):
                             fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
                             if fullpath:
                                 break
                             print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
                             sleep( self.delay )
                         if not(fullpath):
-                            print "There 'isn't any valid file in %s" % path
+                            print "[Reading] There 'isn't any valid file in %s" % path
                             return None
                         self.year = year
                         self.doy  = doy
                         self.set  = set - 1
                         self.path = path
                         self.foldercounter = foldercounter
                         last_set = None
                     else:
                         print "[Reading] Searching files in offline mode ..."
                         pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
                                                                            startTime=startTime, endTime=endTime,
                                                                            set=set, expLabel=expLabel, ext=ext,
                                                                            walk=walk)
                         if not(pathList):
                             print "[Reading] No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
                                                                     datetime.datetime.combine(startDate,startTime).ctime(),
                                                                     datetime.datetime.combine(endDate,endTime).ctime())
                             sys.exit(-1)
                         self.fileIndex = -1
                         self.pathList = pathList
                         self.filenameList = filenameList
                         file_name = os.path.basename(filenameList[-1])
                         basename, ext = os.path.splitext(file_name)
                         last_set = int(basename[-3:])
                     self.online = online
                     self.delay = delay
                     ext = ext.lower()
                     self.ext = ext
                     self.getByBlock = getblock
                     self.nTxs = int(nTxs)
                     if not(self.setNextFile()):
                         if (startDate!=None) and (endDate!=None):
                             print "[Reading] No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
                         elif startDate != None:
                             print "[Reading] No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
                         else:
                             print "[Reading] No files"
                         sys.exit(-1)
             #        self.updateDataHeader()
                     if last_set != None:
                         self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
                     return
                 def getBasicHeader(self):
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                     self.dataOut.timeZone = self.basicHeaderObj.timeZone
                     self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
                     self.dataOut.errorCount = self.basicHeaderObj.errorCount
                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
                     self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
                 def getFirstHeader(self):
                     raise ValueError, "This method has not been implemented"
                 def getData(self):
                     raise ValueError, "This method has not been implemented"
                 def hasNotDataInBuffer(self):
                     raise ValueError, "This method has not been implemented"
                 def readBlock(self):
                     raise ValueError, "This method has not been implemented"
                 def isEndProcess(self):
                     return self.flagNoMoreFiles
                 def printReadBlocks(self):
                     print "[Reading] Number of read blocks per file %04d" %self.nReadBlocks
                 def printTotalBlocks(self):
                     print "[Reading] Number of read blocks %04d" %self.nTotalBlocks
                 def printNumberOfBlock(self):
                     if self.flagIsNewBlock:
                         print "[Reading] Block No. %04d, Total blocks %04d -> %s" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks, self.dataOut.datatime.ctime())
                         self.dataOut.blocknow = self.basicHeaderObj.dataBlock
                 def printInfo(self):
                     if self.__printInfo == False:
                         return
                     self.basicHeaderObj.printInfo()
                     self.systemHeaderObj.printInfo()
                     self.radarControllerHeaderObj.printInfo()
                     self.processingHeaderObj.printInfo()
                     self.__printInfo = False
                 def run(self, **kwargs):
                     if not(self.isConfig):
             #            self.dataOut = dataOut
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
             class JRODataWriter(JRODataIO):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 blockIndex = 0
                 path = None
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
                 nWriteBlocks = 0
                 def __init__(self, dataOut=None):
                     raise ValueError, "Not implemented"
                 def hasAllDataInBuffer(self):
                     raise ValueError, "Not implemented"
                 def setBlockDimension(self):
                     raise ValueError, "Not implemented"
                 def writeBlock(self):
                     raise ValueError, "No implemented"
                 def putData(self):
                     raise ValueError, "No implemented"
                 def setBasicHeader(self):
                     self.basicHeaderObj.size = self.basicHeaderSize #bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
                     utc = numpy.floor(self.dataOut.utctime)
                     milisecond  = (self.dataOut.utctime - utc)* 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = self.dataOut.timeZone
                     self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
                     self.basicHeaderObj.errorCount = self.dataOut.errorCount
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj self.
                     Return:
                         None
                     """
                     raise ValueError, "No implemented"
                 def __writeFirstHeader(self):
                     """
                     Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                     Affected:
                         __dataType
                     Return:
                         None
                     """
             #        CALCULAR PARAMETROS
                     sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
                     self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
                     self.basicHeaderObj.write(self.fp)
                     self.systemHeaderObj.write(self.fp)
                     self.radarControllerHeaderObj.write(self.fp)
                     self.processingHeaderObj.write(self.fp)
                     self.dtype = self.dataOut.dtype
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    Si escribio el Basic el First Header
                     """
                     if self.fp == None:
                         self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
                         self.basicHeaderObj.write(self.fp)
                         return 1
                     if not( self.setNextFile() ):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not( self.__setNewBlock() ):
                         return 0
                     self.writeBlock()
                     return 1
                 def setNextFile(self):
                     """
                     Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
                     timeTuple = time.localtime( self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     fullpath = os.path.join( path, subfolder )
                     if not( os.path.exists(fullpath) ):
                         os.mkdir(fullpath)
                         self.setFile = -1 #inicializo mi contador de seteo
                     else:
                         filesList = os.listdir( fullpath )
                         if len( filesList ) > 0:
                             filesList = sorted( filesList, key=str.lower )
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber( filen[8:11] ):
                                 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 self.setFile = -1
                         else:
                             self.setFile = -1 #inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                     filen = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
                                                     ext )
                     filename = os.path.join( path, subfolder, filen )
                     fp = open( filename,'wb' )
                     self.blockIndex = 0
                     #guardando atributos
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     self.setFirstHeader()
                     print '[Writing] file: %s'%self.filename
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=0, ext=None):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path      :    el path destino en el cual se escribiran los files a crear
                         format    :    formato en el cual sera salvado un file
                         set       :    el setebo del file
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     ext = ext.lower()
                     self.ext = ext
                     self.path = path
                     self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock
                     self.dataOut = dataOut
                     if not(self.setNextFile()):
                         print "[Writing] There isn't a next file"
                         return 0
                     self.setBlockDimension()
                     return 1
                 def run(self, dataOut, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, **kwargs)
                         self.isConfig = True
                     self.putData()

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

             '''
             Created on Jul 15, 2014
             @author: roj-idl71
             '''
             import time
             import threading
             import cPickle
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             SERIALIZER = cPickle
             # from schainpy.serializer import DynamicSerializer
             from schainpy.model.io.jroIO_usrp import USRPReader
             from schainpy.serializer.DataTranslate import obj2Serial
             class USRPReaderAPI(USRPReader, threading.Thread):
             #     __isBufferEmpty = True
                 __DATAKEYLIST = ['data','utctime','flagNoData']
                 def __init__(self, serializer='msgpack'):
                     threading.Thread.__init__(self)
                     USRPReader.__init__(self)
             #         self.__serializerObj = DynamicSerializer.DynamicSerializer('msgpack')
                     self.__mySerial = None
                     self.__isBufferEmpty = True
                     self.setSerializer(serializer)
                 def setSerializer(self, serializer):
                     self.__serializer = serializer
                 def getSerializer(self):
                     return self.__serializer
                 def getProfileIndex(self):
                     return self.profileIndex
                 def getSerialMetaData(self):
                     if self.__isBufferEmpty:
                         ini = time.time()
                         while True:
                             if not self.__isBufferEmpty:
                                 break
                             if time.time() - ini > 20:
                                 break
                             sleep(1e-12)
             #             if not self.getData():
             #                 self.__isBufferEmpty = False
             #                 return None
                     if self.dataOut.flagNoData:
                         return None
                     myMetadataSerial = obj2Serial(self.dataOut,
                                                   serializer = self.__serializer)
                     return myMetadataSerial
                 def getSerialData(self):
                     if self.__isBufferEmpty:
                         ini = time.time()
                         while True:
                             if not self.__isBufferEmpty:
                                 break
                             if time.time() - ini > 20:
                                 break
                             sleep(1e-12)
             #             if not self.getData():
             #                 self.__isBufferEmpty = False
             #                 return None
                     if self.dataOut.flagNoData:
                         return None
                     self.__isBufferEmpty = True
                     return self.__mySerial
                 def run(self):
                     '''
-                    This method will be called many times so here you should put all your code
+                    This method will be called once when start() is called
                     '''
                     if not self.isConfig:
                         raise IOError, 'setup() method has to be called before start()'
                     while True:
                         if not self.__isBufferEmpty:
                             sleep(1e-12)
                             continue
                         if not self.getData():
                             break
                         print ".",
                         self.__mySerial = obj2Serial(self.dataOut,
                                                      keyList = self.__DATAKEYLIST,
                                                      serializer = self.__serializer)
                         self.__isBufferEmpty = False
             #             print self.profileIndex
             #             print 'wait 1 second'
             #             sleep(0.1)
                     return

schainpy/model/proc/jroproc_base.py +10 -3

             '''
             $Author: murco $
             $Id: jroproc_base.py 1 2012-11-12 18:56:07Z murco $
             '''
             class ProcessingUnit(object):
                 """
                 Esta es la clase base para el procesamiento de datos.
                 Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
                     - Metodos internos (callMethod)
                     - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
                       tienen que ser agreagados con el metodo "add".
                 """
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataIn = None
                 dataInList = []
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataOut = None
                 operations2RunDict = None
                 isConfig = False
                 def __init__(self):
                     self.dataIn = None
                     self.dataInList = []
-                    self.dataOut = {}
+                    self.dataOut = None
                     self.operations2RunDict = {}
                     self.isConfig = False
                 def addOperation(self, opObj, objId):
                     """
                     Agrega un objeto del tipo "Operation" (opObj) a la lista de objetos "self.objectList" y retorna el
                     identificador asociado a este objeto.
                     Input:
                         object    :    objeto de la clase "Operation"
                     Return:
                         objId    :    identificador del objeto, necesario para ejecutar la operacion
                     """
                     self.operations2RunDict[objId] = opObj
                     return objId
                 def operation(self, **kwargs):
                     """
                     Operacion directa sobre la data (dataOut.data). Es necesario actualizar los valores de los
                     atributos del objeto dataOut
                     Input:
                         **kwargs    :    Diccionario de argumentos de la funcion a ejecutar
                     """
                     raise ValueError, "ImplementedError"
                 def callMethod(self, name, **kwargs):
                     """
                     Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
                     Input:
                         name        :    nombre del metodo a ejecutar
                         **kwargs     :    diccionario con los nombres y valores de la funcion a ejecutar.
                     """
                     #Checking the inputs
                     if name == 'run':
                         if not self.checkInputs():
                             self.dataOut.flagNoData = True
                             return False
                     else:
                         #Si no es un metodo RUN la entrada es la misma dataOut (interna)
                         if self.dataOut.isEmpty():
                             return False
                     #Getting the pointer to method
                     methodToCall = getattr(self, name)
                     #Executing the self method
                     methodToCall(**kwargs)
                     #Checkin the outputs
             #         if name == 'run':
             #             pass
             #         else:
             #             pass
             #
             #         if name != 'run':
             #             return True
+                    if self.dataOut == None:
+                        return False
                     if self.dataOut.isEmpty():
                         return False
                     return True
                 def callObject(self, objId, **kwargs):
                     """
                     Ejecuta la operacion asociada al identificador del objeto "objId"
                     Input:
                         objId        :    identificador del objeto a ejecutar
                         **kwargs    :    diccionario con los nombres y valores de la funcion a ejecutar.
                     Return:
                         None
                     """
                     if self.dataOut.isEmpty():
                         return False
                     externalProcObj = self.operations2RunDict[objId]
                     externalProcObj.run(self.dataOut, **kwargs)
                     return True
                 def call(self, opType, opName=None, opId=None, **kwargs):
                     """
                     Return True si ejecuta la operacion interna nombrada "opName" o la operacion externa
                     identificada con el id "opId"; con los argumentos "**kwargs".
                     False si la operacion no se ha ejecutado.
                     Input:
                         opType    :    Puede ser "self" o "external"
                             La operacion puede ser de dos tipos (callMethod or callObject):
 . Un metodo propio de esta clase:
                                 opType = "self"
 . El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
                                 opType = "other" or "external".
                         opName    : Si la operacion es interna (opType = 'self'), entonces el "opName" sera
                                     usada para llamar a un metodo interno de la clase Processing
                         opId    :    Si la operacion es externa (opType = 'other'), entonces el "opId" sera
                                     usada para llamar al metodo "run" de la clase Operation registrada con ese Id
                     Exception:
                            Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
                            "addOperation" e identificado con el valor "opId"  = el id de la operacion.
                            De lo contrario retornara un error del tipo IOError
                     """
                     if opType == 'self':
                         if not opName:
                             raise IOError, "opName parameter should be defined"
                         sts = self.callMethod(opName, **kwargs)
                     if opType == 'other' or opType == 'external':
                         if not opId:
                             raise IOError, "opId parameter should be defined"
                         if opId not in self.operations2RunDict.keys():
                             raise IOError, "This id operation have not been registered"
                         sts = self.callObject(opId, **kwargs)
                     return sts
                 def setInput(self, dataIn):
                     self.dataIn = dataIn
                     self.dataInList.append(dataIn)
                 def getOutputObj(self):
                     return self.dataOut
                 def checkInputs(self):
                     for thisDataIn in self.dataInList:
                         if thisDataIn.isEmpty():
                             return False
                     return True
                 def setup(self):
                     raise ValueError, "Not implemented"
                 def run(self):
                     raise ValueError, "Not implemented"
+                def close(self):
+                    #Close every thread, queue or any other object here is it is neccesary.
+                    return
             class Operation(object):
                 """
                 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
                 y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
                 acumulacion dentro de esta clase
                 Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
                 """
                 __buffer = None
                 isConfig = False
                 def __init__(self):
                     self.__buffer = None
                     self.isConfig = False
                 def setup(self):
                     self.isConfig = True
                     raise ValueError, "Not implemented"
                 def run(self, dataIn, **kwargs):
                     """
                     Realiza las operaciones necesarias sobre la dataIn.data y actualiza los
                     atributos del objeto dataIn.
                     Input:
                         dataIn    :    objeto del tipo JROData
                     Return:
                         None
                     Affected:
                         __buffer    :    buffer de recepcion de datos.
                     """
                     if not self.isConfig:
                         self.setup(**kwargs)
                     raise ValueError, "ImplementedError"

schainpy/model/utils/jroutils_ftp.py +562 -3

This diff has been collapsed as it changes many lines, (565 lines changed) Show them Hide them
	@@ -1,353 +1,912
	1	'''	1	'''
	2	@author: Daniel Suarez	2	@author: Daniel Suarez
	3	'''	3	'''
	4	import os	4	import os
	5	import glob	5	import glob
	6	import ftplib	6	import ftplib
			7
			8	try:
			9	import paramiko
			10	import scp
			11	except:
			12	print "You should install paramiko if you will use SSH protocol to upload files to a server"
			13
	7	import multiprocessing	14	import multiprocessing
			15
			16	import time
			17	import threading
			18
			19
			20	try:
			21	from gevent import sleep
			22	except:
			23	from time import sleep
			24
	8	from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation	25	from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
	9		26
			27	class Remote(threading.Thread):
			28	"""
			29	Remote is a parent class used to define the behaviour of FTP and SSH class. These clases are
			30	used to upload or download files remotely.
			31
			32	Non-standard Python modules used:
			33	None
			34
			35	Written by:
			36
			37	"Miguel Urco":mailto:miguel.urco@jro.igp.gob.pe Jun. 03, 2015
			38
			39	"""
			40
			41	server = None
			42	username = None
			43	password = None
			44	remotefolder = None
			45
			46	period = 60
			47	fileList = []
			48	bussy = False
			49
			50	def __init__(self, server, username, password, remotefolder, period=60):
			51
			52	threading.Thread.__init__(self)
			53	self._stop = threading.Event()
			54
			55	self.status = 0
			56
			57	self.period = period
			58	self.fileList = []
			59	self.bussy = False
			60
			61	self.stopFlag = False
			62
			63	print "[Remote Server] Opening server: %s" %server
			64	if self.open(server, username, password, remotefolder):
			65	print "[Remote Server] %s server was opened successfully" %server
			66
			67	def stop(self):
			68
			69	self.stopFlag = True
			70
			71	def open(self):
			72	"""
			73	Connect to server and create a connection class (FTP or SSH) to remote server.
			74	"""
			75	raise NotImplementedError, "Implement this method in child class"
			76
			77	def close(self):
			78	"""
			79	Close connection to server
			80	"""
			81	raise NotImplementedError, "Implement this method in child class"
			82
			83	def mkdir(self, remotefolder):
			84	"""
			85	Create a folder remotely
			86	"""
			87	raise NotImplementedError, "Implement this method in child class"
			88
			89	def cd(self, remotefolder):
			90	"""
			91	Change working directory in remote server
			92	"""
			93	raise NotImplementedError, "Implement this method in child class"
			94
			95	def download(self, filename, localfolder=None):
			96	"""
			97	Download a file from server to local host
			98	"""
			99	raise NotImplementedError, "Implement this method in child class"
			100
			101	def sendFile(self, fullfilename):
			102	"""
			103	sendFile method is used to upload a local file to the current directory in remote server
			104
			105	Inputs:
			106	fullfilename - full path name of local file to store in remote directory
			107
			108	Returns:
			109	0 in error case else 1
			110	"""
			111	raise NotImplementedError, "Implement this method in child class"
			112
			113	def upload(self, fullfilename, remotefolder=None):
			114	"""
			115	upload method is used to upload a local file to remote directory. This method changes
			116	working directory before sending a file.
			117
			118	Inputs:
			119	fullfilename - full path name of local file to store in remote directory
			120
			121	remotefolder - remote directory
			122
			123	Returns:
			124	0 in error case else 1
			125	"""
			126	print "[Remote Server] Uploading %s to %s:%s" %(fullfilename, self.server, self.remotefolder)
			127
			128	if not self.status:
			129	return 0
			130
			131	if remotefolder == None:
			132	remotefolder = self.remotefolder
			133
			134	if not self.cd(remotefolder):
			135	return 0
			136
			137	if not self.sendFile(fullfilename):
			138	print "[Remote Server] Error uploading file %s" %fullfilename
			139	return 0
			140
			141	print "[Remote Server] upload finished successfully"
			142
			143	return 1
			144
			145	def delete(self, filename):
			146	"""
			147	Remove a file from remote server
			148	"""
			149	pass
			150
			151	def updateFileList(self, fileList):
			152	"""
			153	Remove a file from remote server
			154	"""
			155
			156	if fileList == self.fileList:
			157	return 1
			158
			159	init = time.time()
			160
			161	while(self.bussy):
			162	sleep(0.1)
			163	if time.time() - init > 2*self.period:
			164	return 0
			165
			166	self.fileList = fileList
			167
			168	return 1
			169
			170	def run(self):
			171
			172	if not self.cd(self.remotefolder):
			173	raise ValueError, "It could not change to the new remote directory: %s" %remotefolder
			174
			175	while True:
			176
			177	sleep(self.period)
			178
			179	self.bussy = True
			180
			181	for thisFile in self.fileList:
			182	self.upload(thisFile, self.remotefolder)
			183
			184	self.bussy = False
			185
			186	if self.stopFlag:
			187	break
			188
			189	print "[Remote Server] Thread stopped successfully"
			190
			191	class FTPClient(Remote):
			192
			193	__ftpClientObj = None
			194
			195	def __init__(self, server, username, password, remotefolder, period=60):
			196	"""
			197	"""
			198	Remote.__init__(self, server, username, password, remotefolder, period)
			199
			200	def open(self, server, username, password, remotefolder):
			201
			202	"""
			203	This method is used to set FTP parameters and establish a connection to remote server
			204
			205	Inputs:
			206	server - remote server IP Address
			207
			208	username - remote server Username
			209
			210	password - remote server password
			211
			212	remotefolder - remote server current working directory
			213
			214	Return: void
			215
			216	Affects:
			217	self.status - in case of error or fail connection this parameter is set to 0 else 1
			218
			219	"""
			220
			221	if server == None:
			222	raise ValueError, "FTP server should be defined"
			223
			224	if username == None:
			225	raise ValueError, "FTP username should be defined"
			226
			227	if password == None:
			228	raise ValueError, "FTP password should be defined"
			229
			230	if remotefolder == None:
			231	raise ValueError, "FTP remote folder should be defined"
			232
			233	try:
			234	ftpClientObj = ftplib.FTP(server)
			235	except ftplib.all_errors:
			236	print "FTP server connection fail: %s" %server
			237	self.status = 0
			238	return 0
			239
			240	try:
			241	ftpClientObj.login(username, password)
			242	except ftplib.all_errors:
			243	print "FTP username or password are incorrect"
			244	self.status = 0
			245	return 0
			246
			247	if remotefolder == None:
			248	remotefolder = ftpClientObj.pwd()
			249	else:
			250	try:
			251	ftpClientObj.cwd(remotefolder)
			252	except ftplib.all_errors:
			253	print "FTP remote folder is invalid: %s" %remotefolder
			254	remotefolder = ftpClientObj.pwd()
			255
			256	self.server = server
			257	self.username = username
			258	self.password = password
			259	self.remotefolder = remotefolder
			260	self.__ftpClientObj = ftpClientObj
			261	self.status = 1
			262
			263	return 1
			264
			265	def close(self):
			266	"""
			267	Close connection to remote server
			268	"""
			269	if not self.status:
			270	return 0
			271
			272	self.__ftpClientObj.close()
			273
			274	def mkdir(self, remotefolder):
			275	"""
			276	mkdir is used to make a new directory in remote server
			277
			278	Input:
			279	remotefolder - directory name
			280
			281	Return:
			282	0 in error case else 1
			283	"""
			284	if not self.status:
			285	return 0
			286
			287	try:
			288	self.__ftpClientObj.mkd(dirname)
			289	except ftplib.all_errors:
			290	print "Error creating remote folder: %s" %remotefolder
			291	return 0
			292
			293	return 1
			294
			295	def cd(self, remotefolder):
			296	"""
			297	cd is used to change remote working directory on server
			298
			299	Input:
			300	remotefolder - current working directory
			301
			302	Affects:
			303	self.remotefolder
			304
			305	Return:
			306	0 in case of error else 1
			307	"""
			308	if not self.status:
			309	return 0
			310
			311	if remotefolder == self.remotefolder:
			312	return 1
			313
			314	try:
			315	self.__ftpClientObj.cwd(remotefolder)
			316	except ftplib.all_errors:
			317	print 'Error changing to %s' %remotefolder
			318	print 'Trying to create remote folder'
			319
			320	if not self.mkdir(remotefolder):
			321	print 'Remote folder could not be created'
			322	return 0
			323
			324	try:
			325	self.__ftpClientObj.cwd(remotefolder)
			326	except ftplib.all_errors:
			327	return 0
			328
			329	self.remotefolder = remotefolder
			330
			331	return 1
			332
			333	def sendFile(self, fullfilename):
			334
			335	if not self.status:
			336	return 0
			337
			338	file = open(fullfilename, 'rb')
			339
			340	filename = os.path.split(fullfilename)[-1]
			341
			342	command = "STOR %s" %filename
			343
			344	try:
			345	self.__ftpClientObj.storbinary(command, file)
			346	except ftplib.all_errors:
			347	return 0
			348
			349	try:
			350	self.__ftpClientObj.sendcmd('SITE CHMOD 755 ' + filename)
			351	except ftplib.all_errors, e:
			352	print e
			353
			354	file.close()
			355
			356	return 1
			357
			358	class SSHClient(Remote):
			359
			360	__sshClientObj = None
			361	__scpClientObj = None
			362
			363	def __init__(self, server, username, password, remotefolder, period=60):
			364	"""
			365	"""
			366	Remote.__init__(self, server, username, password, remotefolder, period)
			367
			368	def open(self, server, username, password, remotefolder, port=22):
			369
			370	"""
			371	This method is used to set SSH parameters and establish a connection to a remote server
			372
			373	Inputs:
			374	server - remote server IP Address
			375
			376	username - remote server Username
			377
			378	password - remote server password
			379
			380	remotefolder - remote server current working directory
			381
			382	Return: void
			383
			384	Affects:
			385	self.status - in case of error or fail connection this parameter is set to 0 else 1
			386
			387	"""
			388
			389	if server == None:
			390	raise ValueError, "SSH server should be defined"
			391
			392	if username == None:
			393	raise ValueError, "SSH username should be defined"
			394
			395	if password == None:
			396	raise ValueError, "SSH password should be defined"
			397
			398	if remotefolder == None:
			399	raise ValueError, "SSH remote folder should be defined"
			400
			401	try:
			402	sshClientObj = paramiko.SSHClient()
			403	except:
			404	print "SSH server connection fail: %s" %server
			405	self.status = 0
			406	return 0
			407
			408	sshClientObj.load_system_host_keys()
			409	sshClientObj.set_missing_host_key_policy(paramiko.WarningPolicy())
			410
			411	try:
			412	sshClientObj.connect(server, username=username, password=password, port=port)
			413	except :
			414	print "SSH username or password are incorrect: %s"
			415	self.status = 0
			416	return 0
			417
			418	scpClientObj = scp.SCPClient(sshClientObj.get_transport(), socket_timeout=30)
			419
			420	if remotefolder == None:
			421	remotefolder = self.pwd()
			422
			423	self.server = server
			424	self.username = username
			425	self.password = password
			426	self.remotefolder = remotefolder
			427	self.__sshClientObj = sshClientObj
			428	self.__scpClientObj = scpClientObj
			429	self.status = 1
			430
			431	return 1
			432
			433	def close(self):
			434	"""
			435	Close connection to remote server
			436	"""
			437	if not self.status:
			438	return 0
			439
			440	self.__sshObj.close()
			441
			442	def mkdir(self, remotefolder):
			443	"""
			444	mkdir is used to make a new directory in remote server
			445
			446	Input:
			447	remotefolder - directory name
			448
			449	Return:
			450	0 in error case else 1
			451	"""
			452	if not self.status:
			453	return 0
			454
			455	stdin, stdout, stderr = self.__sshClientObj.exec_command('mkdir %s' %remotefolder)
			456	result = stderr.readlines()[0]
			457
			458	if len(result) > 1:
			459	return 0
			460
			461	return 1
			462
			463	def pwd(self):
			464
			465	if not self.status:
			466	return None
			467
			468	stdin, stdout, stderr = self.__sshClientObj.exec_command('pwd')
			469	result = stdout.readlines()[0]
			470
			471	if len(result) < 1:
			472	return None
			473
			474	return result[:-1]
			475
			476	def cd(self, remotefolder):
			477	"""
			478	cd is used to change remote working directory on server
			479
			480	Input:
			481	remotefolder - current working directory
			482
			483	Affects:
			484	self.remotefolder
			485
			486	Return:
			487	0 in case of error else 1
			488	"""
			489	if not self.status:
			490	return 0
			491
			492	if remotefolder == self.remotefolder:
			493	return 1
			494
			495	self.remotefolder = remotefolder
			496
			497	return 1
			498
			499	def sendFile(self, fullfilename):
			500
			501	if not self.status:
			502	return 0
			503
			504	try:
			505	self.__scpClientObj.put(fullfilename, remote_path=self.remotefolder)
			506	except:
			507	return 0
			508
			509	return 1
			510
			511	class SendToServer(ProcessingUnit):
			512
			513	def __init__(self):
			514
			515	ProcessingUnit.__init__(self)
			516
			517	self.isConfig = False
			518	self.clientObj = None
			519
			520	def setup(self, server, username, password, remotefolder, localfolder, ext='.png', period=60, protocol='ftp'):
			521
			522	self.clientObj = None
			523	self.localfolder = localfolder
			524	self.ext = ext
			525	self.period = period
			526
			527	if str.lower(protocol) == 'ftp':
			528	self.clientObj = FTPClient(server, username, password, remotefolder, period)
			529
			530	if str.lower(protocol) == 'ssh':
			531	self.clientObj = SSHClient(server, username, password, remotefolder, period)
			532
			533	if not self.clientObj:
			534	raise ValueError, "%s has been chosen as remote access protocol but it is not valid" %protocol
			535
			536	self.clientObj.start()
			537
			538	def findFiles(self):
			539
			540	filenameList = glob.glob1(self.localfolder, '*%s' %self.ext)
			541
			542	if len(filenameList) < 1:
			543	return []
			544
			545	fullfilenameList = [os.path.join(self.localfolder, thisFile) for thisFile in filenameList]
			546
			547	return fullfilenameList
			548
			549	def run(self, **kwargs):
			550
			551	if not self.isConfig:
			552	self.init = time.time()
			553	self.setup(**kwargs)
			554	self.isConfig = True
			555
			556	if time.time() - self.init >= self.period:
			557	fullfilenameList = self.findFiles()
			558	self.clientObj.updateFileList(fullfilenameList)
			559	self.init = time.time()
			560
			561	def close(self):
			562	print "[Remote Server] Stopping thread"
			563	self.clientObj.stop()
			564
			565
	10	class FTP(object):	566	class FTP(object):
	11	"""	567	"""
	12	Ftp is a public class used to define custom File Transfer Protocol from "ftplib" python module	568	Ftp is a public class used to define custom File Transfer Protocol from "ftplib" python module
	13		569
	14	Non-standard Python modules used: None	570	Non-standard Python modules used: None
	15		571
	16	Written by "Daniel Suarez":mailto:daniel.suarez@jro.igp.gob.pe Oct. 26, 2010	572	Written by "Daniel Suarez":mailto:daniel.suarez@jro.igp.gob.pe Oct. 26, 2010
	17	"""	573	"""
	18		574
	19	def __init__(self,server = None, username=None, password=None, remotefolder=None):	575	def __init__(self,server = None, username=None, password=None, remotefolder=None):
	20	"""	576	"""
	21	This method is used to setting parameters for FTP and establishing connection to remote server	577	This method is used to setting parameters for FTP and establishing connection to remote server
	22		578
	23	Inputs:	579	Inputs:
	24	server - remote server IP Address	580	server - remote server IP Address
	25		581
	26	username - remote server Username	582	username - remote server Username
	27		583
	28	password - remote server password	584	password - remote server password
	29		585
	30	remotefolder - remote server current working directory	586	remotefolder - remote server current working directory
	31		587
	32	Return: void	588	Return: void
	33		589
	34	Affects:	590	Affects:
	35	self.status - in Error Case or Connection Failed this parameter is set to 1 else 0	591	self.status - in Error Case or Connection Failed this parameter is set to 1 else 0
	36		592
	37	self.folderList - sub-folder list of remote folder	593	self.folderList - sub-folder list of remote folder
	38		594
	39	self.fileList - file list of remote folder	595	self.fileList - file list of remote folder
	40		596
	41		597
	42	"""	598	"""
	43		599
	44	if ((server == None) and (username==None) and (password==None) and (remotefolder==None)):	600	if ((server == None) and (username==None) and (password==None) and (remotefolder==None)):
	45	server, username, password, remotefolder = self.parmsByDefault()	601	server, username, password, remotefolder = self.parmsByDefault()
	46		602
	47	self.server = server	603	self.server = server
	48	self.username = username	604	self.username = username
	49	self.password = password	605	self.password = password
	50	self.remotefolder = remotefolder	606	self.remotefolder = remotefolder
	51	self.file = None	607	self.file = None
	52	self.ftp = None	608	self.ftp = None
	53	self.status = 0	609	self.status = 0
	54		610
	55	try:	611	try:
	56	self.ftp = ftplib.FTP(self.server)	612	self.ftp = ftplib.FTP(self.server)
	57	self.ftp.login(self.username,self.password)	613	self.ftp.login(self.username,self.password)
	58	self.ftp.cwd(self.remotefolder)	614	self.ftp.cwd(self.remotefolder)
	59	# print 'Connect to FTP Server: Successfully'	615	# print 'Connect to FTP Server: Successfully'
	60		616
	61	except ftplib.all_errors:	617	except ftplib.all_errors:
	62	print 'Error FTP Service'	618	print 'Error FTP Service'
	63	self.status = 1	619	self.status = 1
	64	return	620	return
	65		621
	66		622
	67		623
	68	self.dirList = []	624	self.dirList = []
	69		625
	70	try:	626	try:
	71	self.dirList = self.ftp.nlst()	627	self.dirList = self.ftp.nlst()
	72		628
	73	except ftplib.error_perm, resp:	629	except ftplib.error_perm, resp:
	74	if str(resp) == "550 No files found":	630	if str(resp) == "550 No files found":
	75	print "no files in this directory"	631	print "no files in this directory"
	76	self.status = 1	632	self.status = 1
	77	return	633	return
	78		634
	79	except ftplib.all_errors:	635	except ftplib.all_errors:
	80	print 'Error Displaying Dir-Files'	636	print 'Error Displaying Dir-Files'
	81	self.status = 1	637	self.status = 1
	82	return	638	return
	83		639
	84	self.fileList = []	640	self.fileList = []
	85	self.folderList = []	641	self.folderList = []
	86	#only for test	642	#only for test
	87	for f in self.dirList:	643	for f in self.dirList:
	88	name, ext = os.path.splitext(f)	644	name, ext = os.path.splitext(f)
	89	if ext != '':	645	if ext != '':
	90	self.fileList.append(f)	646	self.fileList.append(f)
	91	# print 'filename: %s - size: %d'%(f,self.ftp.size(f))	647	# print 'filename: %s - size: %d'%(f,self.ftp.size(f))
	92		648
	93	def parmsByDefault(self):	649	def parmsByDefault(self):
	94	server = 'jro-app.igp.gob.pe'	650	server = 'jro-app.igp.gob.pe'
	95	username = 'wmaster'	651	username = 'wmaster'
	96	password = 'mst2010vhf'	652	password = 'mst2010vhf'
	97	remotefolder = '/home/wmaster/graficos'	653	remotefolder = '/home/wmaster/graficos'
	98		654
	99	return server, username, password, remotefolder	655	return server, username, password, remotefolder
	100		656
	101		657
	102	def mkd(self,dirname):	658	def mkd(self,dirname):
	103	"""	659	"""
	104	mkd is used to make directory in remote server	660	mkd is used to make directory in remote server
	105		661
	106	Input:	662	Input:
	107	dirname - directory name	663	dirname - directory name
	108		664
	109	Return:	665	Return:
	110	1 in error case else 0	666	1 in error case else 0
	111	"""	667	"""
	112	try:	668	try:
	113	self.ftp.mkd(dirname)	669	self.ftp.mkd(dirname)
	114	except:	670	except:
	115	print 'Error creating remote folder:%s'%dirname	671	print 'Error creating remote folder:%s'%dirname
	116	return 1	672	return 1
	117		673
	118	return 0	674	return 0
	119		675
	120		676
	121	def delete(self,filename):	677	def delete(self,filename):
	122	"""	678	"""
	123	delete is used to delete file in current working directory of remote server	679	delete is used to delete file in current working directory of remote server
	124		680
	125	Input:	681	Input:
	126	filename - filename to delete in remote folder	682	filename - filename to delete in remote folder
	127		683
	128	Return:	684	Return:
	129	1 in error case else 0	685	1 in error case else 0
	130	"""	686	"""
	131		687
	132	try:	688	try:
	133	self.ftp.delete(filename)	689	self.ftp.delete(filename)
	134	except:	690	except:
	135	print 'Error deleting remote file:%s'%filename	691	print 'Error deleting remote file:%s'%filename
	136	return 1	692	return 1
	137		693
	138	return 0	694	return 0
	139		695
	140	def download(self,filename,localfolder):	696	def download(self,filename,localfolder):
	141	"""	697	"""
	142	download is used to downloading file from remote folder into local folder	698	download is used to downloading file from remote folder into local folder
	143		699
	144	Inputs:	700	Inputs:
	145	filename - filename to donwload	701	filename - filename to donwload
	146		702
	147	localfolder - directory local to store filename	703	localfolder - directory local to store filename
	148		704
	149	Returns:	705	Returns:
	150	self.status - 1 in error case else 0	706	self.status - 1 in error case else 0
	151	"""	707	"""
	152		708
	153	self.status = 0	709	self.status = 0
	154		710
	155		711
	156	if not(filename in self.fileList):	712	if not(filename in self.fileList):
	157	print 'filename:%s not exists'%filename	713	print 'filename:%s not exists'%filename
	158	self.status = 1	714	self.status = 1
	159	return self.status	715	return self.status
	160		716
	161	newfilename = os.path.join(localfolder,filename)	717	newfilename = os.path.join(localfolder,filename)
	162		718
	163	self.file = open(newfilename, 'wb')	719	self.file = open(newfilename, 'wb')
	164		720
	165	try:	721	try:
	166	print 'Download: ' + filename	722	print 'Download: ' + filename
	167	self.ftp.retrbinary('RETR ' + filename, self.__handleDownload)	723	self.ftp.retrbinary('RETR ' + filename, self.__handleDownload)
	168	print 'Download Complete'	724	print 'Download Complete'
	169	except ftplib.all_errors:	725	except ftplib.all_errors:
	170	print 'Error Downloading ' + filename	726	print 'Error Downloading ' + filename
	171	self.status = 1	727	self.status = 1
	172	return self.status	728	return self.status
	173		729
	174	self.file.close()	730	self.file.close()
	175		731
	176	return self.status	732	return self.status
	177		733
	178		734
	179	def __handleDownload(self,block):	735	def __handleDownload(self,block):
	180	"""	736	"""
	181	__handleDownload is used to handle writing file	737	__handleDownload is used to handle writing file
	182	"""	738	"""
	183	self.file.write(block)	739	self.file.write(block)
	184		740
	185		741
	186	def upload(self,filename,remotefolder=None):	742	def upload(self,filename,remotefolder=None):
	187	"""	743	"""
	188	upload is used to uploading local file to remote directory	744	upload is used to uploading local file to remote directory
	189		745
	190	Inputs:	746	Inputs:
	191	filename - full path name of local file to store in remote directory	747	filename - full path name of local file to store in remote directory
	192		748
	193	remotefolder - remote directory	749	remotefolder - remote directory
	194		750
	195	Returns:	751	Returns:
	196	self.status - 1 in error case else 0	752	self.status - 1 in error case else 0
	197	"""	753	"""
	198		754
	199	if remotefolder == None:	755	if remotefolder == None:
	200	remotefolder = self.remotefolder	756	remotefolder = self.remotefolder
	201		757
	202	self.status = 0	758	self.status = 0
	203		759
	204	try:	760	try:
	205	self.ftp.cwd(remotefolder)	761	self.ftp.cwd(remotefolder)
	206		762
	207	self.file = open(filename, 'rb')	763	self.file = open(filename, 'rb')
	208		764
	209	(head, tail) = os.path.split(filename)	765	(head, tail) = os.path.split(filename)
	210		766
	211	command = "STOR " + tail	767	command = "STOR " + tail
	212		768
	213	print 'Uploading: ' + tail	769	print 'Uploading: ' + tail
	214	self.ftp.storbinary(command, self.file)	770	self.ftp.storbinary(command, self.file)
	215	print 'Upload Completed'	771	print 'Upload Completed'
	216		772
	217	except ftplib.all_errors:	773	except ftplib.all_errors:
	218	print 'Error Uploading ' + tail	774	print 'Error Uploading ' + tail
	219	self.status = 1	775	self.status = 1
	220	return self.status	776	return self.status
	221		777
	222	self.file.close()	778	self.file.close()
	223		779
	224	#back to initial directory in __init__()	780	#back to initial directory in __init__()
	225	self.ftp.cwd(self.remotefolder)	781	self.ftp.cwd(self.remotefolder)
	226		782
	227	return self.status	783	return self.status
	228		784
	229		785
	230	def dir(self,remotefolder):	786	def dir(self,remotefolder):
	231	"""	787	"""
	232	dir is used to change working directory of remote server and get folder and file list	788	dir is used to change working directory of remote server and get folder and file list
	233		789
	234	Input:	790	Input:
	235	remotefolder - current working directory	791	remotefolder - current working directory
	236		792
	237	Affects:	793	Affects:
	238	self.fileList - file list of working directory	794	self.fileList - file list of working directory
	239		795
	240	Return:	796	Return:
	241	infoList - list with filenames and size of file in bytes	797	infoList - list with filenames and size of file in bytes
	242		798
	243	self.folderList - folder list	799	self.folderList - folder list
	244	"""	800	"""
	245		801
	246	self.remotefolder = remotefolder	802	self.remotefolder = remotefolder
	247	print 'Change to ' + self.remotefolder	803	print 'Change to ' + self.remotefolder
	248	try:	804	try:
	249	self.ftp.cwd(remotefolder)	805	self.ftp.cwd(remotefolder)
	250	except ftplib.all_errors:	806	except ftplib.all_errors:
	251	print 'Error Change to ' + self.remotefolder	807	print 'Error Change to ' + self.remotefolder
	252	infoList = None	808	infoList = None
	253	self.folderList = None	809	self.folderList = None
	254	return infoList,self.folderList	810	return infoList,self.folderList
	255		811
	256	self.dirList = []	812	self.dirList = []
	257		813
	258	try:	814	try:
	259	self.dirList = self.ftp.nlst()	815	self.dirList = self.ftp.nlst()
	260		816
	261	except ftplib.error_perm, resp:	817	except ftplib.error_perm, resp:
	262	if str(resp) == "550 No files found":	818	if str(resp) == "550 No files found":
	263	print "no files in this directory"	819	print "no files in this directory"
	264	infoList = None	820	infoList = None
	265	self.folderList = None	821	self.folderList = None
	266	return infoList,self.folderList	822	return infoList,self.folderList
	267	except ftplib.all_errors:	823	except ftplib.all_errors:
	268	print 'Error Displaying Dir-Files'	824	print 'Error Displaying Dir-Files'
	269	infoList = None	825	infoList = None
	270	self.folderList = None	826	self.folderList = None
	271	return infoList,self.folderList	827	return infoList,self.folderList
	272		828
	273	infoList = []	829	infoList = []
	274	self.fileList = []	830	self.fileList = []
	275	self.folderList = []	831	self.folderList = []
	276	for f in self.dirList:	832	for f in self.dirList:
	277	name,ext = os.path.splitext(f)	833	name,ext = os.path.splitext(f)
	278	if ext != '':	834	if ext != '':
	279	self.fileList.append(f)	835	self.fileList.append(f)
	280	value = (f,self.ftp.size(f))	836	value = (f,self.ftp.size(f))
	281	infoList.append(value)	837	infoList.append(value)
	282		838
	283	if ext == '':	839	if ext == '':
	284	self.folderList.append(f)	840	self.folderList.append(f)
	285		841
	286	return infoList,self.folderList	842	return infoList,self.folderList
	287		843
	288		844
	289	def close(self):	845	def close(self):
	290	"""	846	"""
	291	close is used to close and end FTP connection	847	close is used to close and end FTP connection
	292		848
	293	Inputs: None	849	Inputs: None
	294		850
	295	Return: void	851	Return: void
	296		852
	297	"""	853	"""
	298	self.ftp.close()	854	self.ftp.close()
	299		855
	300	class SendByFTP(Operation):	856	class SendByFTP(Operation):
			857
	301	def __init__(self):	858	def __init__(self):
			859
	302	self.status = 1	860	self.status = 1
	303	self.counter = 0	861	self.counter = 0
	304		862
	305	def error_print(self, ValueError):	863	def error_print(self, ValueError):
			864
	306	print ValueError, 'Error FTP'	865	print ValueError, 'Error FTP'
	307	print "don't worry the program is running..."	866	print "don't worry the program is running..."
	308		867
	309	def worker_ftp(self, server, username, password, remotefolder, filenameList):	868	def worker_ftp(self, server, username, password, remotefolder, filenameList):
	310		869
	311	self.ftpObj = FTP(server, username, password, remotefolder)	870	self.ftpClientObj = FTP(server, username, password, remotefolder)
	312	for filename in filenameList:	871	for filename in filenameList:
	313	self.ftpObj.upload(filename)	872	self.ftpClientObj.upload(filename)
	314	self.ftpObj.close()	873	self.ftpClientObj.close()
	315		874
	316	def ftp_thread(self, server, username, password, remotefolder):	875	def ftp_thread(self, server, username, password, remotefolder):
	317	if not(self.status):	876	if not(self.status):
	318	return	877	return
	319		878
	320	p = multiprocessing.Process(target=self.worker_ftp, args=(server, username, password, remotefolder, self.filenameList,))	879	p = multiprocessing.Process(target=self.worker_ftp, args=(server, username, password, remotefolder, self.filenameList,))
	321	p.start()	880	p.start()
	322		881
	323	p.join(3)	882	p.join(3)
	324		883
	325	if p.is_alive():	884	if p.is_alive():
	326	p.terminate()	885	p.terminate()
	327	p.join()	886	p.join()
	328	print 'killing ftp process...'	887	print 'killing ftp process...'
	329	self.status = 0	888	self.status = 0
	330	return	889	return
	331		890
	332	self.status = 1	891	self.status = 1
	333	return	892	return
	334		893
	335	def filterByExt(self, ext, localfolder):	894	def filterByExt(self, ext, localfolder):
	336	fnameList = glob.glob1(localfolder,ext)	895	fnameList = glob.glob1(localfolder,ext)
	337	self.filenameList = [os.path.join(localfolder,x) for x in fnameList]	896	self.filenameList = [os.path.join(localfolder,x) for x in fnameList]
	338		897
	339	if len(self.filenameList) == 0:	898	if len(self.filenameList) == 0:
	340	self.status = 0	899	self.status = 0
	341		900
	342	def run(self, dataOut, ext, localfolder, remotefolder, server, username, password, period=1):	901	def run(self, dataOut, ext, localfolder, remotefolder, server, username, password, period=1):
	343		902
	344	self.counter += 1	903	self.counter += 1
	345	if self.counter >= period:	904	if self.counter >= period:
	346	self.filterByExt(ext, localfolder)	905	self.filterByExt(ext, localfolder)
	347		906
	348	self.ftp_thread(server, username, password, remotefolder)	907	self.ftp_thread(server, username, password, remotefolder)
	349		908
	350	self.counter = 0	909	self.counter = 0
	351		910
	352	self.status = 1	911	self.status = 1
	353		912

schainpy/model/graphics/jroplot.py removed 0 -5

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