schain Commit - r1371:603b419b2641 · Jicamarca Repository

Separación de datos antes del 17 de Julio del 2021, donde se modificó los apuntes y la lectura de estos

joabAM -

r1371:603b419b2641

parent child

Context file:

r1371:603b419b2641

Collapse all files

amisr_reader.xml created 644 +1 0

	@@ -0,0 +1,1
				1	<Project description="AMISR EEJ Experiment" id="11" name="Process (eej_proc)"><ReadUnit id="111" inputId="None" name="AMISRReader"><Parameter name="path" value="/media/soporte/UARS_4T_D02/AMISR_DATA/2021/" /><Parameter name="startDate" value="2021/07/11" /><Parameter name="endDate" value="2021/07/11" /><Parameter name="startTime" value="07:01:30" /><Parameter name="endTime" value="19:00:00" /><Parameter name="walk" value="1" /><Parameter name="code" value="(1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1)" /><Parameter name="nCode" value="1" /><Parameter name="nBaud" value="28" /><Parameter name="timezone" value="ut" /><Parameter name="online" value="0" /></ReadUnit><ProcUnit id="112" inputId="111" name="VoltageProc"><Operation id="1121" name="setAttribute"><Parameter name="frequency" value="445090000.0" /></Operation><Operation id="1122" name="Decoder"><Parameter name="code" value="(1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1)" /><Parameter name="nCode" value="1" /><Parameter name="nBaud" value="28" /><Parameter name="osamp" value="1" /></Operation></ProcUnit><ProcUnit id="113" inputId="112" name="SpectraProc"><Parameter name="nFFTPoints" value="16" /><Operation id="1131" name="IncohInt"><Parameter name="n" value="150" /></Operation><Operation id="1132" name="removeDC" /><Operation id="1133" name="SpectraPlot"><Parameter name="id" value="21" /><Parameter name="xaxis" value="velocity" /><Parameter name="ymax" value="300" /><Parameter name="showprofile" value="1" /><Parameter name="wintitle" value="AMISR Beam 0" /><Parameter name="zmin" value="45" /><Parameter name="zmax" value="65" /><Parameter name="save" value="/home/soporte/Data/EEJ/EEJ2021192/plots" /><Parameter name="colormap" value="jet" /><Parameter name="localtime" value="0" /><Parameter name="show" value="1" /></Operation><Operation id="1134" name="SpectraWriter"><Parameter name="path" value="/home/soporte/Data/EEJ/EEJ2021192" /><Parameter name="blocksPerFile" value="10" /></Operation><Operation id="1135" name="NoisePlot"><Parameter name="id" value="3" /><Parameter name="wintitle" value="title0" /><Parameter name="showprofile" value="0" /><Parameter name="xmin" value="07" /><Parameter name="xmax" value="18" /><Parameter name="ymin" value="45" /><Parameter name="ymax" value="65" /><Parameter name="save" value="/home/soporte/Data/EEJ/EEJ2021192" /><Parameter name="localtime" value="0" /><Parameter name="show" value="0" /></Operation><Operation id="1136" name="RTIPlot"><Parameter name="id" value="2" /><Parameter name="localtime" value="0" /><Parameter name="wintitle" value="RTI" /><Parameter name="xmin" value="07" /><Parameter name="xmax" value="18" /><Parameter name="ymin" value="0" /><Parameter name="zmin" value="45" /><Parameter name="zmax" value="65" /><Parameter name="showprofile" value="0" /><Parameter name="save" value="/home/soporte/Data/EEJ/EEJ2021192/plots" /><Parameter name="colormap" value="jet" /><Parameter name="show" value="1" /></Operation></ProcUnit><ProcUnit id="114" inputId="113" name="ParametersProc"><Operation id="1141" name="SpectralMoments" /><Operation id="1142" name="ParamWriter"><Parameter name="path" value="/home/soporte/Data/EEJ/EEJ2021192" /><Parameter name="blocksPerFile" value="10" /><Parameter name="metadataList" value="['type', 'inputUnit', 'heightList']" /><Parameter name="dataList" value="['moments', 'data_SNR', 'utctime']" /><Parameter name="mode" value="1" /></Operation></ProcUnit></Project> No newline at end of file

schainpy/controller.py +659 -918

This diff has been collapsed as it changes many lines, (1577 lines changed) Show them Hide them
	@@ -1,918 +1,659
	1	# Copyright (c) 2012-2020 Jicamarca Radio Observatory	1	# Copyright (c) 2012-2020 Jicamarca Radio Observatory
	2	# All rights reserved.	2	# All rights reserved.
	3	#	3	#
	4	# Distributed under the terms of the BSD 3-clause license.	4	# Distributed under the terms of the BSD 3-clause license.
	5	"""API to create signal chain projects	5	"""API to create signal chain projects
	6		6
	7	The API is provide through class: Project	7	The API is provide through class: Project
	8	"""	8	"""
	9		9
	10	import re	10	import re
	11	import sys	11	import sys
	12	import ast	12	import ast
	13	import datetime	13	import datetime
	14	import traceback	14	import traceback
	15	import time	15	import time
	16	import multiprocessing	16	import multiprocessing
	17	from multiprocessing import Process, Queue	17	from multiprocessing import Process, Queue
	18	from threading import Thread	18	from threading import Thread
	19	from xml.etree.ElementTree import ElementTree, Element, SubElement	19	from xml.etree.ElementTree import ElementTree, Element, SubElement
	20		20
	21	from schainpy.admin import Alarm, SchainWarning	21	from schainpy.admin import Alarm, SchainWarning
	22	from schainpy.model import *	22	from schainpy.model import *
	23	from schainpy.utils import log	23	from schainpy.utils import log
	24		24
	25	if 'darwin' in sys.platform and sys.version_info[0] == 3 and sys.version_info[1] > 7:	25	if 'darwin' in sys.platform and sys.version_info[0] == 3 and sys.version_info[1] > 7:
	26	multiprocessing.set_start_method('fork')	26	multiprocessing.set_start_method('fork')
	27		27
	28	DTYPES = {	28	class ConfBase():
	29	'Voltage': '.r',	29
	30	'Spectra': '.pdata'	30	def __init__(self):
	31	}	31
	32		32	self.id = '0'
	33		33	self.name = None
	34	def MPProject(project, n=cpu_count()):	34	self.priority = None
	35	'''	35	self.parameters = {}
	36	Project wrapper to run schain in n processes	36	self.object = None
	37	'''	37	self.operations = []
	38		38
	39	rconf = project.getReadUnitObj()	39	def getId(self):
	40	op = rconf.getOperationObj('run')	40
	41	dt1 = op.getParameterValue('startDate')	41	return self.id
	42	dt2 = op.getParameterValue('endDate')	42
	43	tm1 = op.getParameterValue('startTime')	43	def getNewId(self):
	44	tm2 = op.getParameterValue('endTime')	44
	45	days = (dt2 - dt1).days	45	return int(self.id) * 10 + len(self.operations) + 1
	46		46
	47	for day in range(days + 1):	47	def updateId(self, new_id):
	48	skip = 0	48
	49	cursor = 0	49	self.id = str(new_id)
	50	processes = []	50
	51	dt = dt1 + datetime.timedelta(day)	51	n = 1
	52	dt_str = dt.strftime('%Y/%m/%d')	52	for conf in self.operations:
	53	reader = JRODataReader()	53	conf_id = str(int(new_id) * 10 + n)
	54	paths, files = reader.searchFilesOffLine(path=rconf.path,	54	conf.updateId(conf_id)
	55	startDate=dt,	55	n += 1
	56	endDate=dt,	56
	57	startTime=tm1,	57	def getKwargs(self):
	58	endTime=tm2,	58
	59	ext=DTYPES[rconf.datatype])	59	params = {}
	60	nFiles = len(files)	60
	61	if nFiles == 0:	61	for key, value in self.parameters.items():
	62	continue	62	if value not in (None, '', ' '):
	63	skip = int(math.ceil(nFiles / n))	63	params[key] = value
	64	while nFiles > cursor * skip:	64
	65	rconf.update(startDate=dt_str, endDate=dt_str, cursor=cursor,	65	return params
	66	skip=skip)	66
	67	p = project.clone()	67	def update(self, **kwargs):
	68	p.start()	68
	69	processes.append(p)	69	for key, value in kwargs.items():
	70	cursor += 1	70	self.addParameter(name=key, value=value)
	71		71
	72	def beforeExit(exctype, value, trace):	72	def addParameter(self, name, value, format=None):
	73	for process in processes:	73	'''
	74	process.terminate()	74	'''
	75	process.join()	75
	76	print(traceback.print_tb(trace))	76	if isinstance(value, str) and re.search(r'(\d+/\d+/\d+)', value):
	77		77	self.parameters[name] = datetime.date(*[int(x) for x in value.split('/')])
	78	sys.excepthook = beforeExit	78	elif isinstance(value, str) and re.search(r'(\d+:\d+:\d+)', value):
	79		79	self.parameters[name] = datetime.time(*[int(x) for x in value.split(':')])
	80	for process in processes:	80	else:
	81	~~process~~.~~join~~()	81	try:
	82	process.terminate()	82	self.parameters[name] = ast.literal_eval(value)
	83		83	except:
	84	time.sleep(3)	84	if isinstance(value, str) and ',' in value:
	85		85	self.parameters[name] = value.split(',')
	86	def wait(context):	86	else:
	87		87	self.parameters[name] = value
	88	time.sleep(1)	88
	89	c = zmq.Context()	89	def getParameters(self):
	90	receiver = c.socket(zmq.SUB)	90
	91	receiver.connect('ipc:///tmp/schain_{}_pub'.format(self.id))	91	params = {}
	92	receiver.setsockopt(zmq.SUBSCRIBE, self.id.encode())	92	for key, value in self.parameters.items():
	93	msg = receiver.recv_multipart()[1]	93	s = type(value).__name__
	94	context.terminate()	94	if s == 'date':
	95		95	params[key] = value.strftime('%Y/%m/%d')
	96	class ParameterConf():	96	elif s == 'time':
	97		97	params[key] = value.strftime('%H:%M:%S')
	98	id = None	98	else:
	99	name = None	99	params[key] = str(value)
	100	value = None	100
	101	format = None	101	return params
	102		102
	103	__formated_value = None	103	def makeXml(self, element):
	104		104
	105	ELEMENTNAME = 'Parameter'	105	xml = SubElement(element, self.ELEMENTNAME)
	106		106	for label in self.xml_labels:
	107	def __init__(self):	107	xml.set(label, str(getattr(self, label)))
	108		108
	109	self.format = 'str'	109	for key, value in self.getParameters().items():
	110		110	xml_param = SubElement(xml, 'Parameter')
	111	def getElementName(self):	111	xml_param.set('name', key)
	112		112	xml_param.set('value', value)
	113	return self.ELEMENTNAME	113
	114		114	for conf in self.operations:
	115	def getValue(self):	115	conf.makeXml(xml)
	116		116
	117	value = self.value	117	def __str__(self):
	118	format = self.format	118
	119		119	if self.ELEMENTNAME == 'Operation':
	120	if self.__formated_value != None:	120	s = ' {}[id={}]\n'.format(self.name, self.id)
	121		121	else:
	122	return self.__formated_value	122	s = '{}[id={}, inputId={}]\n'.format(self.name, self.id, self.inputId)
	123		123
	124	if format == 'obj':	124	for key, value in self.parameters.items():
	125	return value	125	if self.ELEMENTNAME == 'Operation':
	126		126	s += ' {}: {}\n'.format(key, value)
	127	if format == 'str':	127	else:
	128	self.__formated_value = str(value)	128	s += ' {}: {}\n'.format(key, value)
	129	return self.__formated_value	129
	130		130	for conf in self.operations:
	131	if value == '':	131	s += str(conf)
	132	raise ValueError('%s: This parameter value is empty' % self.name)	132
	133		133	return s
	134	if format == 'list':	134
	135	strList = [s.strip() for s in value.split(',')]	135	class OperationConf(ConfBase):
	136	self.__formated_value = strList	136
	137		137	ELEMENTNAME = 'Operation'
	138	return self.__formated_value	138	xml_labels = ['id', 'name']
	139		139
	140	if format == 'intlist':	140	def setup(self, id, name, priority, project_id, err_queue):
	141	'''	141
	142	Example:	142	self.id = str(id)
	143	value = (0,1,2)	143	self.project_id = project_id
	144	'''	144	self.name = name
	145		145	self.type = 'other'
	146	new_value = ast.literal_eval(value)	146	self.err_queue = err_queue
	147		147
	148	if type(new_value) not in (tuple, list):	148	def readXml(self, element, project_id, err_queue):
	149	new_value = [int(new_value)]	149
	150		150	self.id = element.get('id')
	151	self.__formated_value = new_value	151	self.name = element.get('name')
	152		152	self.type = 'other'
	153	return self.__formated_value	153	self.project_id = str(project_id)
	154		154	self.err_queue = err_queue
	155	if format == 'floatlist':	155
	156	'''	156	for elm in element.iter('Parameter'):
	157	Example:	157	self.addParameter(elm.get('name'), elm.get('value'))
	158	value = (0.5, 1.4, 2.7)	158
	159	'''	159	def createObject(self):
	160		160
	161	new_value = ast.literal_eval(value)	161	className = eval(self.name)
	162		162
	163	if type(new_value) not in (tuple, list):	163	if 'Plot' in self.name or 'Writer' in self.name or 'Send' in self.name or 'print' in self.name:
	164	new_value = [float(new_value)]	164	kwargs = self.getKwargs()
	165		165	opObj = className(self.id, self.id, self.project_id, self.err_queue, **kwargs)
	166	self.__formated_value = new_value	166	opObj.start()
	167		167	self.type = 'external'
	168	return self.__formated_value	168	else:
	169		169	opObj = className()
	170	if format == 'date':	170
	171	strList = value.split('/')	171	self.object = opObj
	172	intList = [int(x) for x in strList]	172	return opObj
	173	date = datetime.date(intList[0], intList[1], intList[2])	173
	174		174	class ProcUnitConf(ConfBase):
	175	self.__formated_value = date	175
	176		176	ELEMENTNAME = 'ProcUnit'
	177	return self.__formated_value	177	xml_labels = ['id', 'inputId', 'name']
	178		178
	179	if format == 'time':	179	def setup(self, project_id, id, name, datatype, inputId, err_queue):
	180	strList = value.split(':')	180	'''
	181	intList = [int(x) for x in strList]	181	'''
	182	time = datetime.time(intList[0], intList[1], intList[2])	182
	183		183	if datatype == None and name == None:
	184	self.__formated_value = time	184	raise ValueError('datatype or name should be defined')
	185		185
	186	return self.__formated_value	186	if name == None:
	187		187	if 'Proc' in datatype:
	188	if format == 'pairslist':	188	name = datatype
	189	~~'''~~	189	else:
	190	Example:	190	name = '%sProc' % (datatype)
	191	value = (0,1),(1,2)	191
	192	'''	192	if datatype == None:
	193		193	datatype = name.replace('Proc', '')
	194	new_value = ast.literal_eval(value)	194
	195		195	self.id = str(id)
	196	if type(new_value) not in (tuple, list):	196	self.project_id = project_id
	197	raise ValueError('%s has to be a tuple or list of pairs' % value)	197	self.name = name
	198		198	self.datatype = datatype
	199	if type(new_value[0]) not in (tuple, list):	199	self.inputId = inputId
	200	if len(new_value) != 2:	200	self.err_queue = err_queue
	201	raise ValueError('%s has to be a tuple or list of pairs' % value)	201	self.operations = []
	202	new_value = [new_value]	202	self.parameters = {}
	203		203
	204	for thisPair in new_value:	204	def removeOperation(self, id):
	205	if len(thisPair) != 2:	205
	206	raise ValueError('%s has to be a tuple or list of pairs' % value)	206	i = [1 if x.id==id else 0 for x in self.operations]
	207		207	self.operations.pop(i.index(1))
	208	self.__formated_value = new_value	208
	209		209	def getOperation(self, id):
	210	return self.__formated_value	210
	211		211	for conf in self.operations:
	212	if format == 'multilist':	212	if conf.id == id:
	213	'''	213	return conf
	214	Example:	214
	215	value = (0,1,2),(3,4,5)	215	def addOperation(self, name, optype='self'):
	216	~~'''~~	216	'''
	217	multiList = ast.literal_eval(value)	217	'''
	218		218
	219	if type(multiList[0]) == int:	219	id = self.getNewId()
	220	multiList = ast.literal_eval('(' + value + ')')	220	conf = OperationConf()
	221		221	conf.setup(id, name=name, priority='0', project_id=self.project_id, err_queue=self.err_queue)
	222	self.__formated_value = multiList	222	self.operations.append(conf)
	223		223
	224	return self.__formated_value	224	return conf
	225		225
	226	if format == 'bool':	226	def readXml(self, element, project_id, err_queue):
	227	value = int(value)	227
	228		228	self.id = element.get('id')
	229	if format == 'int':	229	self.name = element.get('name')
	230	value = float(value)	230	self.inputId = None if element.get('inputId') == 'None' else element.get('inputId')
	231		231	self.datatype = element.get('datatype', self.name.replace(self.ELEMENTNAME.replace('Unit', ''), ''))
	232	format_func = eval(format)	232	self.project_id = str(project_id)
	233		233	self.err_queue = err_queue
	234	self.__formated_value = format_func(value)	234	self.operations = []
	235		235	self.parameters = {}
	236	return self.__formated_value	236
	237		237	for elm in element:
	238	def updateId(self, new_id):	238	if elm.tag == 'Parameter':
	239		239	self.addParameter(elm.get('name'), elm.get('value'))
	240	self.id = str(new_id)	240	elif elm.tag == 'Operation':
	241		241	conf = OperationConf()
	242	def setup(self, id, name, value, format='str'):	242	conf.readXml(elm, project_id, err_queue)
	243	self.id = str(id)	243	self.operations.append(conf)
	244	self.name = name	244
	245	if format == 'obj':	245	def createObjects(self):
	246	self.value = value	246	'''
	247	else:	247	Instancia de unidades de procesamiento.
	248	self.value = str(value)	248	'''
	249	self.format = str.lower(format)	249
	250		250	className = eval(self.name)
	251	self.get~~Value~~()	251	kwargs = self.getKwargs()
	252		252	procUnitObj = className()
	253	return 1	253	procUnitObj.name = self.name
	254		254	log.success('creating process...', self.name)
	255	def update(self, name, value, format='str'):	255
	256		256	for conf in self.operations:
	257	self.name = name	257
	258	self.value = str(value)	258	opObj = conf.createObject()
	259	self.format = format	259
	260		260	log.success('adding operation: {}, type:{}'.format(
	261	def makeXml(self, opElement):	261	conf.name,
	262	if self.name not in ('queue',):	262	conf.type), self.name)
	263	parmElement = SubElement(opElement, self.ELEMENTNAME)	263
	264	parmElement.set('id', str(self.id))	264	procUnitObj.addOperation(conf, opObj)
	265	parmElement.set('name', self.name)	265
	266	parmElement.set('value', self.value)	266	self.object = procUnitObj
	267	parmElement.set('format', self.format)	267
	268		268	def run(self):
	269	def readXml(self, parmElement):	269	'''
	270		270	'''
	271	self.id = parmElement.get('id')	271
	272	self.name = parmElement.get('name')	272	return self.object.call(**self.getKwargs())
	273	self.value = parmElement.get('value')	273
	274	self.format = str.lower(parmElement.get('format'))	274
	275		275	class ReadUnitConf(ProcUnitConf):
	276	# Compatible with old signal chain version	276
	277	if self.format == 'int' and self.name == 'idfigure':	277	ELEMENTNAME = 'ReadUnit'
	278	self.name = 'id'	278
	279		279	def __init__(self):
	280	def printattr(self):	280
	281		281	self.id = None
	282	print('Parameter[%s]: name = %s, value = %s, format = %s, project_id = %s' % (self.id, self.name, self.value, self.format, self.project_id))	282	self.datatype = None
	283		283	self.name = None
	284	class OperationConf():	284	self.inputId = None
	285		285	self.operations = []
	286	ELEMENTNAME = 'Operation'	286	self.parameters = {}
	287		287
	288	def __init__(self):	288	def setup(self, project_id, id, name, datatype, err_queue, path='', startDate='', endDate='',
	289		289	startTime='', endTime='', server=None, **kwargs):
	290	self.id = '0'	290
	291	self.name = None	291	if datatype == None and name == None:
	292	self.priority = None	292	raise ValueError('datatype or name should be defined')
	293	self.parameters = {}	293	if name == None:
	294	self.object = None	294	if 'Reader' in datatype:
	295	self.operations = []	295	name = datatype
	296		296	datatype = name.replace('Reader','')
	297	def getId(self):	297	else:
	298		298	name = '{}Reader'.format(datatype)
	299	return self.id	299	if datatype == None:
	300		300	if 'Reader' in name:
	301	def getNewId(self):	301	datatype = name.replace('Reader','')
	302		302	else:
	303	return int(self.id) * 10 + len(self.operations) + 1	303	datatype = name
	304		304	name = '{}Reader'.format(name)
	305	def updateId(self, new_id):	305
	306		306	self.id = id
	307	self.id = ~~str~~(~~new_id~~)	307	self.project_id = project_id
	308		308	self.name = name
	309	n = 1	309	self.datatype = datatype
	310	for conf in self.operations:	310	self.err_queue = err_queue
	311	conf_id = str(int(new_id) * 10 + n)	311
	312	conf.updateId(conf_id)	312	self.addParameter(name='path', value=path)
	313	n += 1	313	self.addParameter(name='startDate', value=startDate)
	314		314	self.addParameter(name='endDate', value=endDate)
	315	def getKwargs(self):	315	self.addParameter(name='startTime', value=startTime)
	316		316	self.addParameter(name='endTime', value=endTime)
	317	params = {}	317
	318		318	for key, value in kwargs.items():
	319	for key, value in self.parameters.items():	319	self.addParameter(name=key, value=value)
	320	if value not in (None, '', ' '):	320
	321	params[key] = value	321
	322		322	class Project(Process):
	323	return params	323	"""API to create signal chain projects"""
	324		324
	325	def update(self, **kwargs):	325	ELEMENTNAME = 'Project'
	326		326
	327	for key, value in kwargs.items():	327	def __init__(self, name=''):
	328	self.addParameter(name=key, value=value)	328
	329		329	Process.__init__(self)
	330	def addParameter(self, name, value, format=None):	330	self.id = '1'
	331	'''	331	if name:
	332	'''	332	self.name = '{} ({})'.format(Process.__name__, name)
	333		333	self.filename = None
	334	if isinstance(value, str) and re.search(r'(\d+/\d+/\d+)', value):	334	self.description = None
	335	self.parameters[name] = datetime.date(*[int(x) for x in value.split('/')])	335	self.email = None
	336	elif isinstance(value, str) and re.search(r'(\d+:\d+:\d+)', value):	336	self.alarm = []
	337	self.parameters[name] = datetime.time(*[int(x) for x in value.split(':')])	337	self.configurations = {}
	338	else:	338	# self.err_queue = Queue()
	339	try:	339	self.err_queue = None
	340	self.parameters[name] = ast.literal_eval(value)	340	self.started = False
	341	except:	341
	342	if isinstance(value, str) and ',' in value:	342	def getNewId(self):
	343	self.parameters[name] = value.split(',')	343
	344	else:	344	idList = list(self.configurations.keys())
	345	self.parameters[name] = value	345	id = int(self.id) * 10
	346		346
	347	def getParameters(self):	347	while True:
	348		348	id += 1
	349	params = {}	349
	350	for key, value in self.parameters.items():	350	if str(id) in idList:
	351	s = type(value).__name__	351	continue
	352	if s == 'date':	352
	353	params[key] = value.strftime('%Y/%m/%d')	353	break
	354	elif s == 'time':	354
	355	params[key] = value.strftime('%H:%M:%S')	355	return str(id)
	356	else:	356
	357	params[key] = str(value)	357	def updateId(self, new_id):
	358		358
	359	return params	359	self.id = str(new_id)
	360		360
	361	def makeXml(self, element):	361	keyList = list(self.configurations.keys())
	362		362	keyList.sort()
	363	xml = SubElement(element, self.ELEMENTNAME)	363
	364	for label in self.xml_labels:	364	n = 1
	365	xml.set(label, str(getattr(self, label)))	365	new_confs = {}
	366		366
	367	for key, value in self.getParameters().items():	367	for procKey in keyList:
	368	xml_param = SubElement(xml, 'Parameter')	368
	369	xml_param.set('name', key)	369	conf = self.configurations[procKey]
	370	xml_param.set('value', value)	370	idProcUnit = str(int(self.id) * 10 + n)
	371		371	conf.updateId(idProcUnit)
	372	for conf in self.operations:	372	new_confs[idProcUnit] = conf
	373	conf.makeXml(xml)	373	n += 1
	374		374
	375	def __str__(self):	375	self.configurations = new_confs
	376		376
	377	if self.ELEMENTNAME == 'Operation':	377	def setup(self, id=1, name='', description='', email=None, alarm=[]):
	378	s = ' {}[id={}]\n'.format(self.name, self.id)	378
	379	else:	379	self.id = str(id)
	380	s = '{}[id={}, inputId={}]\n'.format(self.name, self.id, self.inputId)	380	self.description = description
	381		381	self.email = email
	382	for key, value in self.parameters.items():	382	self.alarm = alarm
	383	if self.ELEMENTNAME == 'Operation':	383	if name:
	384	s += ' ~~{}: {}~~\n'.format(~~key~~, ~~valu~~e)	384	self.name = '{} ({})'.format(Process.__name__, name)
	385	else:	385
	386	s += ' {}: {}\n'.format(key, value)	386	def update(self, **kwargs):
	387		387
	388	for conf in self.operations:	388	for key, value in kwargs.items():
	389	s += str(conf)	389	setattr(self, key, value)
	390		390
	391	return s	391	def clone(self):
	392		392
	393	class OperationConf(ConfBase):	393	p = Project()
	394		394	p.id = self.id
	395	ELEMENTNAME = 'Operation'	395	p.name = self.name
	396	xml_labels = ['id', 'name']	396	p.description = self.description
	397		397	p.configurations = self.configurations.copy()
	398	def setup(self, id, name, priority, project_id, err_queue):	398
	399		399	return p
	400	self.id = str(id)	400
	401	self.project_id = project_id	401	def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
	402	self.name = name	402
	403	self.type = 'other'	403	'''
	404	self.err_queue = err_queue	404	'''
	405		405
	406	def readXml(self, element, project_id, err_queue):	406	if id is None:
	407		407	idReadUnit = self.getNewId()
	408	self.id = element.get('id')	408	else:
	409	self.name = element.get('name')	409	idReadUnit = str(id)
	410	self.type = 'other'	410
	411	self.project_id = str(project_id)	411	conf = ReadUnitConf()
	412	self.err_queue = err_queue	412	conf.setup(self.id, idReadUnit, name, datatype, self.err_queue, **kwargs)
	413		413	self.configurations[conf.id] = conf
	414	for elm in element.iter('Parameter'):	414
	415	self.addParameter(elm.get('name'), elm.get('value'))	415	return conf
	416		416
	417	def createObject(self):	417	def addProcUnit(self, id=None, inputId='0', datatype=None, name=None):
	418		418
	419	className = eval(self.name)	419	'''
	420		420	'''
	421	if 'Plot' in self.name or 'Writer' in self.name or 'Send' in self.name or 'print' in self.name:	421
	422	kwargs = self.getKwargs()	422	if id is None:
	423	opObj = className(self.id, self.id, self.project_id, self.err_queue, **kwargs)	423	idProcUnit = self.getNewId()
	424	opObj.start()	424	else:
	425	self.type = 'external'	425	idProcUnit = id
	426	else:	426
	427	opObj = className()	427	conf = ProcUnitConf()
	428		428	conf.setup(self.id, idProcUnit, name, datatype, inputId, self.err_queue)
	429	self.object = opObj	429	self.configurations[conf.id] = conf
	430	return opObj	430
	431		431	return conf
	432	class ProcUnitConf(ConfBase):	432
	433		433	def removeProcUnit(self, id):
	434	ELEMENTNAME = 'ProcUnit'	434
	435	xml_labels = ['id', 'inputId', 'name']	435	if id in self.configurations:
	436		436	self.configurations.pop(id)
	437	def setup(self, project_id, id, name, datatype, inputId, err_queue):	437
	438	'''	438	def getReadUnit(self):
	439	'''	439
	440		440	for obj in list(self.configurations.values()):
	441	if datatype == None and name == None:	441	if obj.ELEMENTNAME == 'ReadUnit':
	442	raise ValueError('datatype or name should be defined')	442	return obj
	443		443
	444	if ~~name~~ == None:	444	return None
	445	if 'Proc' in datatype:	445
	446	name = datatype	446	def getProcUnit(self, id):
	447	else:	447
	448	name = '%sProc' % (datatype)	448	return self.configurations[id]
	449		449
	450	if datatype == None:	450	def getUnits(self):
	451	datatype = name.replace('Proc', '')	451
	452		452	keys = list(self.configurations)
	453	~~self~~.id = ~~str~~(id)	453	keys.sort()
	454	self.project_id = project_id	454
	455	self.name = name	455	for key in keys:
	456	self.datatype = datatype	456	yield self.configurations[key]
	457	self.inputId = inputId	457
	458	self.err_queue = err_queue	458	def updateUnit(self, id, **kwargs):
	459	self.operations = []	459
	460	self.parameters = {}	460	conf = self.configurations[id].update(**kwargs)
	461		461
	462	def ~~removeOperation~~(self, id):	462	def makeXml(self):
	463		463
	464	i = [1 if x.id==id else 0 for x in self.operations]	464	xml = Element('Project')
	465	self.operations.pop(i.index(1))	465	xml.set('id', str(self.id))
	466		466	xml.set('name', self.name)
	467	def getOperation(self, id):	467	xml.set('description', self.description)
	468		468
	469	for conf in self.~~ope~~rations:	469	for conf in self.configurations.values():
	470	if conf.id == id:	470	conf.makeXml(xml)
	471	return conf	471
	472		472	self.xml = xml
	473	def addOperation(self, name, optype='self'):	473
	474	'''	474	def writeXml(self, filename=None):
	475	'''	475
	476		476	if filename == None:
	477	id = self.getNewId()	477	if self.filename:
	478	conf = OperationConf()	478	filename = self.filename
	479	conf.setup(id, name=name, priority='0', project_id=self.project_id, err_queue=self.err_queue)	479	else:
	480	self.operations.append(conf)	480	filename = 'schain.xml'
	481		481
	482	return conf	482	if not filename:
	483		483	print('filename has not been defined. Use setFilename(filename) for do it.')
	484	def readXml(self, element, project_id, err_queue):	484	return 0
	485		485
	486	self.id = element.get('id')	486	abs_file = os.path.abspath(filename)
	487	self.name = element.get('name')	487
	488	self.inputId = None if element.get('inputId') == 'None' else element.get('inputId')	488	if not os.access(os.path.dirname(abs_file), os.W_OK):
	489	self.datatype = element.get('datatype', self.name.replace(self.ELEMENTNAME.replace('Unit', ''), ''))	489	print('No write permission on %s' % os.path.dirname(abs_file))
	490	self.project_id = str(project_id)	490	return 0
	491	self.err_queue = err_queue	491
	492	self.operations = []	492	if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
	493	self.parameters = {}	493	print('File %s already exists and it could not be overwriten' % abs_file)
	494		494	return 0
	495	for elm in element:	495
	496	if elm.tag == 'Parameter':	496	self.makeXml()
	497	self.addParameter(elm.get('name'), elm.get('value'))	497
	498	elif elm.tag == 'Operation':	498	ElementTree(self.xml).write(abs_file, method='xml')
	499	conf = OperationConf()	499
	500	conf.readXml(elm, project_id, err_queue)	500	self.filename = abs_file
	501	self.operations.append(conf)	501
	502		502	return 1
	503	def createObjects(self):	503
	504	'''	504	def readXml(self, filename):
	505	Instancia de unidades de procesamiento.	505
	506	'''	506	abs_file = os.path.abspath(filename)
	507		507
	508	className = eval(self.name)	508	self.configurations = {}
	509	#print(self.name)	509
	510	kwargs = self.getKwargs()	510	try:
	511	procUnitObj = className()	511	self.xml = ElementTree().parse(abs_file)
	512	procUnitObj.name = self.name	512	except:
	513	log.success('creating process...', self.name)	513	log.error('Error reading %s, verify file format' % filename)
	514		514	return 0
	515	for conf in self.operations:	515
	516		516	self.id = self.xml.get('id')
	517	opObj = conf.createObject()	517	self.name = self.xml.get('name')
	518		518	self.description = self.xml.get('description')
	519	log.success('adding operation: {}, type:{}'.format(	519
	520	conf.name,	520	for element in self.xml:
	521	conf.type), self.name)	521	if element.tag == 'ReadUnit':
	522		522	conf = ReadUnitConf()
	523	procUnitObj.addOperation(conf, opObj)	523	conf.readXml(element, self.id, self.err_queue)
	524		524	self.configurations[conf.id] = conf
	525	~~self~~.~~objec~~t = ~~procUnitObj~~	525	elif element.tag == 'ProcUnit':
	526		526	conf = ProcUnitConf()
	527	def run(self):	527	input_proc = self.configurations[element.get('inputId')]
	528	'''	528	conf.readXml(element, self.id, self.err_queue)
	529	'''	529	self.configurations[conf.id] = conf
	530		530
	531	return self.object.call(**self.getKwargs())	531	self.filename = abs_file
	532		532
	533		533	return 1
	534	class ReadUnitConf(ProcUnitConf):	534
	535		535	def __str__(self):
	536	ELEMENTNAME = 'ReadUnit'	536
	537		537	text = '\nProject[id=%s, name=%s, description=%s]\n\n' % (
	538	def __init__(self):	538	self.id,
	539		539	self.name,
	540	self.id = ~~None~~	540	self.description,
	541	self.datatype = None	541	)
	542	self.name = None	542
	543	self.inputId = None	543	for conf in self.configurations.values():
	544	self.operations = []	544	text += '{}'.format(conf)
	545	self.parameters = {}	545
	546		546	return text
	547	def setup(self, project_id, id, name, datatype, err_queue, path='', startDate='', endDate='',	547
	548	startTime='', endTime='', server=None, **kwargs):	548	def createObjects(self):
	549		549
	550	if datatype == None and name == None:	550	keys = list(self.configurations.keys())
	551	raise ValueError('datatype or name should be defined')	551	keys.sort()
	552	if name == None:	552	for key in keys:
	553	if 'Reader' in datatype:	553	conf = self.configurations[key]
	554	name = datatype	554	conf.createObjects()
	555	datatype = name.replace('Reader','')	555	if conf.inputId is not None:
	556	else:	556	conf.object.setInput(self.configurations[conf.inputId].object)
	557	name = '{}Reader'.format(datatype)	557
	558	if datatype == None:	558	def monitor(self):
	559	if 'Reader' in name:	559
	560	datatype = name.replace('Reader','')	560	t = Thread(target=self._monitor, args=(self.err_queue, self.ctx))
	561	else:	561	t.start()
	562	datatype = name	562
	563	name = '{}Reader'.format(name)	563	def _monitor(self, queue, ctx):
	564		564
	565	self.id = id	565	import socket
	566	self.project_id = project_id	566
	567	self.name = name	567	procs = 0
	568	self.datatype = datatype	568	err_msg = ''
	569	self.err_queue = err_queue	569
	570		570	while True:
	571	self.addParameter(name='path', value=path)	571	msg = queue.get()
	572	self.addParameter(name='startDate', value=startDate)	572	if '#_start_#' in msg:
	573	self.addParameter(name='endDate', value=endDate)	573	procs += 1
	574	self.addParameter(name='startTime', value=startTime)	574	elif '#_end_#' in msg:
	575	self.addParameter(name='endTime', value=endTime)	575	procs -=1
	576		576	else:
	577	for key, value in kwargs.items():	577	err_msg = msg
	578	self.addParameter(name=key, value=value)	578
	579		579	if procs == 0 or 'Traceback' in err_msg:
	580		580	break
	581	class Project(Process):	581	time.sleep(0.1)
	582	"""API to create signal chain projects"""	582
	583		583	if '\|' in err_msg:
	584	ELEMENTNAME = 'Project'	584	name, err = err_msg.split('\|')
	585		585	if 'SchainWarning' in err:
	586	def __init__(self, name=''):	586	log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), name)
	587		587	elif 'SchainError' in err:
	588	Process.__init__(self)	588	log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), name)
	589	self.id = '1'	589	else:
	590	if name:	590	log.error(err, name)
	591	self.name = '{} ({})'.format(Process.__name__, name)	591	else:
	592	self.filename = None	592	name, err = self.name, err_msg
	593	self.description = None	593
	594	self.email = None	594	time.sleep(1)
	595	self.alarm = []	595
	596	self.configurations = {}	596	ctx.term()
	597	# self.err_queue = Queue()	597
	598	self.err_queue = None	598	message = ''.join(err)
	599	self.started = False	599
	600		600	if err_msg:
	601	def getNewId(self):	601	subject = 'SChain v%s: Error running %s\n' % (
	602		602	schainpy.__version__, self.name)
	603	idList = list(self.configurations.keys())	603
	604	id = int(self.id) * 10	604	subtitle = 'Hostname: %s\n' % socket.gethostbyname(
	605		605	socket.gethostname())
	606	while True:	606	subtitle += 'Working directory: %s\n' % os.path.abspath('./')
	607	id += 1	607	subtitle += 'Configuration file: %s\n' % self.filename
	608		608	subtitle += 'Time: %s\n' % str(datetime.datetime.now())
	609	if str(id) in idList:	609
	610	continue	610	readUnitConfObj = self.getReadUnit()
	611		611	if readUnitConfObj:
	612	break	612	subtitle += '\nInput parameters:\n'
	613		613	subtitle += '[Data path = %s]\n' % readUnitConfObj.parameters['path']
	614	return str(id)	614	subtitle += '[Start date = %s]\n' % readUnitConfObj.parameters['startDate']
	615		615	subtitle += '[End date = %s]\n' % readUnitConfObj.parameters['endDate']
	616	def updateId(self, new_id):	616	subtitle += '[Start time = %s]\n' % readUnitConfObj.parameters['startTime']
	617		617	subtitle += '[End time = %s]\n' % readUnitConfObj.parameters['endTime']
	618	self.id = str(new_id)	618
	619		619	a = Alarm(
	620	keyList = list(self.configurations.keys())	620	modes=self.alarm,
	621	keyList.sort()	621	email=self.email,
	622		622	message=message,
	623	n = 1	623	subject=subject,
	624	new_confs = {}	624	subtitle=subtitle,
	625		625	filename=self.filename
	626	for procKey in keyList:	626	)
	627		627
	628	conf = self.configurations[procKey]	628	a.start()
	629	idProcUnit = str(int(self.id) * 10 + n)	629
	630	conf.updateId(idProcUnit)	630	def setFilename(self, filename):
	631	new_confs[idProcUnit] = conf	631
	632	n += 1	632	self.filename = filename
	633		633
	634	self.configurations = new_confs	634	def runProcs(self):
	635		635
	636	def setup(self, id=1, name='', description='', email=None, alarm=[]):	636	err = False
	637		637	n = len(self.configurations)
	638	self.id = str(id)	638
	639	self.description = description	639	while not err:
	640	self.email = email	640	for conf in self.getUnits():
	641	self.alarm = alarm	641	ok = conf.run()
	642	if name:	642	if ok == 'Error':
	643	self.name = '{} ({})'.format(Process.__name__, name)	643	n -= 1
	644		644	continue
	645	def update(self, **kwargs):	645	elif not ok:
	646		646	break
	647	for key, value in kwargs.items():	647	if n == 0:
	648	setattr(self, key, value)	648	err = True
	649		649
	650	def ~~clone~~(self):	650	def run(self):
	651		651
	652	p = Project()	652	log.success('\nStarting Project {} [id={}]'.format(self.name, self.id), tag='')
	653	p.id = self.id	653	self.started = True
	654	p.name = self.name	654	self.start_time = time.time()
	655	p.description = self.description	655	self.createObjects()
	656	p.configurations = self.configurations.copy()	656	self.runProcs()
	657		657	log.success('{} Done (Time: {:4.2f}s)'.format(
	658	return p	658	self.name,
	659		659	time.time()-self.start_time), '')
	660	def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
	661
	662	'''
	663	'''
	664
	665	if id is None:
	666	idReadUnit = self.getNewId()
	667	else:
	668	idReadUnit = str(id)
	669
	670	conf = ReadUnitConf()
	671	conf.setup(self.id, idReadUnit, name, datatype, self.err_queue, **kwargs)
	672	self.configurations[conf.id] = conf
	673
	674	return conf
	675
	676	def addProcUnit(self, id=None, inputId='0', datatype=None, name=None):
	677
	678	'''
	679	'''
	680
	681	if id is None:
	682	idProcUnit = self.getNewId()
	683	else:
	684	idProcUnit = id
	685
	686	conf = ProcUnitConf()
	687	conf.setup(self.id, idProcUnit, name, datatype, inputId, self.err_queue)
	688	self.configurations[conf.id] = conf
	689
	690	return conf
	691
	692	def removeProcUnit(self, id):
	693
	694	if id in self.configurations:
	695	self.configurations.pop(id)
	696
	697	def getReadUnit(self):
	698
	699	for obj in list(self.configurations.values()):
	700	if obj.ELEMENTNAME == 'ReadUnit':
	701	return obj
	702
	703	return None
	704
	705	def getProcUnit(self, id):
	706
	707	return self.configurations[id]
	708
	709	def getUnits(self):
	710
	711	keys = list(self.configurations)
	712	keys.sort()
	713
	714	for key in keys:
	715	yield self.configurations[key]
	716
	717	def updateUnit(self, id, **kwargs):
	718
	719	conf = self.configurations[id].update(**kwargs)
	720
	721	def makeXml(self):
	722
	723	xml = Element('Project')
	724	xml.set('id', str(self.id))
	725	xml.set('name', self.name)
	726	xml.set('description', self.description)
	727
	728	for conf in self.configurations.values():
	729	conf.makeXml(xml)
	730
	731	self.xml = xml
	732
	733	def writeXml(self, filename=None):
	734
	735	if filename == None:
	736	if self.filename:
	737	filename = self.filename
	738	else:
	739	filename = 'schain.xml'
	740
	741	if not filename:
	742	print('filename has not been defined. Use setFilename(filename) for do it.')
	743	return 0
	744
	745	abs_file = os.path.abspath(filename)
	746
	747	if not os.access(os.path.dirname(abs_file), os.W_OK):
	748	print('No write permission on %s' % os.path.dirname(abs_file))
	749	return 0
	750
	751	if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
	752	print('File %s already exists and it could not be overwriten' % abs_file)
	753	return 0
	754
	755	self.makeXml()
	756
	757	ElementTree(self.xml).write(abs_file, method='xml')
	758
	759	self.filename = abs_file
	760
	761	return 1
	762
	763	def readXml(self, filename):
	764
	765	abs_file = os.path.abspath(filename)
	766
	767	self.configurations = {}
	768
	769	try:
	770	self.xml = ElementTree().parse(abs_file)
	771	except:
	772	log.error('Error reading %s, verify file format' % filename)
	773	return 0
	774
	775	self.id = self.xml.get('id')
	776	self.name = self.xml.get('name')
	777	self.description = self.xml.get('description')
	778
	779	for element in self.xml:
	780	if element.tag == 'ReadUnit':
	781	conf = ReadUnitConf()
	782	conf.readXml(element, self.id, self.err_queue)
	783	self.configurations[conf.id] = conf
	784	elif element.tag == 'ProcUnit':
	785	conf = ProcUnitConf()
	786	input_proc = self.configurations[element.get('inputId')]
	787	conf.readXml(element, self.id, self.err_queue)
	788	self.configurations[conf.id] = conf
	789
	790	self.filename = abs_file
	791
	792	return 1
	793
	794	def __str__(self):
	795
	796	text = '\nProject[id=%s, name=%s, description=%s]\n\n' % (
	797	self.id,
	798	self.name,
	799	self.description,
	800	)
	801
	802	for conf in self.configurations.values():
	803	text += '{}'.format(conf)
	804
	805	return text
	806
	807	def createObjects(self):
	808
	809	keys = list(self.configurations.keys())
	810	keys.sort()
	811	for key in keys:
	812	conf = self.configurations[key]
	813	conf.createObjects()
	814	if conf.inputId is not None:
	815	conf.object.setInput(self.configurations[conf.inputId].object)
	816
	817	def monitor(self):
	818
	819	t = Thread(target=self._monitor, args=(self.err_queue, self.ctx))
	820	t.start()
	821
	822	def _monitor(self, queue, ctx):
	823
	824	import socket
	825
	826	procs = 0
	827	err_msg = ''
	828
	829	while True:
	830	msg = queue.get()
	831	if '#_start_#' in msg:
	832	procs += 1
	833	elif '#_end_#' in msg:
	834	procs -=1
	835	else:
	836	err_msg = msg
	837
	838	if procs == 0 or 'Traceback' in err_msg:
	839	break
	840	time.sleep(0.1)
	841
	842	if '\|' in err_msg:
	843	name, err = err_msg.split('\|')
	844	if 'SchainWarning' in err:
	845	log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), name)
	846	elif 'SchainError' in err:
	847	log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), name)
	848	else:
	849	log.error(err, name)
	850	else:
	851	name, err = self.name, err_msg
	852
	853	time.sleep(1)
	854
	855	ctx.term()
	856
	857	message = ''.join(err)
	858
	859	if err_msg:
	860	subject = 'SChain v%s: Error running %s\n' % (
	861	schainpy.__version__, self.name)
	862
	863	subtitle = 'Hostname: %s\n' % socket.gethostbyname(
	864	socket.gethostname())
	865	subtitle += 'Working directory: %s\n' % os.path.abspath('./')
	866	subtitle += 'Configuration file: %s\n' % self.filename
	867	subtitle += 'Time: %s\n' % str(datetime.datetime.now())
	868
	869	readUnitConfObj = self.getReadUnit()
	870	if readUnitConfObj:
	871	subtitle += '\nInput parameters:\n'
	872	subtitle += '[Data path = %s]\n' % readUnitConfObj.parameters['path']
	873	subtitle += '[Start date = %s]\n' % readUnitConfObj.parameters['startDate']
	874	subtitle += '[End date = %s]\n' % readUnitConfObj.parameters['endDate']
	875	subtitle += '[Start time = %s]\n' % readUnitConfObj.parameters['startTime']
	876	subtitle += '[End time = %s]\n' % readUnitConfObj.parameters['endTime']
	877
	878	a = Alarm(
	879	modes=self.alarm,
	880	email=self.email,
	881	message=message,
	882	subject=subject,
	883	subtitle=subtitle,
	884	filename=self.filename
	885	)
	886
	887	a.start()
	888
	889	def setFilename(self, filename):
	890
	891	self.filename = filename
	892
	893	def runProcs(self):
	894
	895	err = False
	896	n = len(self.configurations)
	897
	898	while not err:
	899	for conf in self.getUnits():
	900	ok = conf.run()
	901	if ok == 'Error':
	902	n -= 1
	903	continue
	904	elif not ok:
	905	break
	906	if n == 0:
	907	err = True
	908
	909	def run(self):
	910
	911	log.success('\nStarting Project {} [id={}]'.format(self.name, self.id), tag='')
	912	self.started = True
	913	self.start_time = time.time()
	914	self.createObjects()
	915	self.runProcs()
	916	log.success('{} Done (Time: {:4.2f}s)'.format(
	917	self.name,
	918	time.time()-self.start_time), '')

schainpy/model/io/jroIO_kamisr.py +15 -13

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

schainpy/model/io/jroIO_spectra.py +5 -5

             '''
             Created on Jul 2, 2014
             @author: roj-idl71
             '''
             import numpy
             from schainpy.model.io.jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jrodata import Spectra
             from schainpy.utils import log
             class SpectraReader(JRODataReader, ProcessingUnit):
                 """
                 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
                 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
                                     paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                     canales * alturas                            (DC Channels)
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = SpectraReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         readerObj.getData()
                         print readerObj.data_spc
                         print readerObj.data_cspc
                         print readerObj.data_dc
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 def __init__(self):#, **kwargs):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
                         dataOut    :    Objeto de la clase Spectra. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Affected:
                         self.dataOut
                     Return      : None
                     """
                     ProcessingUnit.__init__(self)
                     self.pts2read_SelfSpectra = 0
                     self.pts2read_CrossSpectra = 0
                     self.pts2read_DCchannels = 0
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.dataOut = Spectra()
                     self.profileIndex = 1
                     self.nRdChannels = None
                     self.nRdPairs = None
                     self.rdPairList = []
                 def createObjByDefault(self):
                     dataObj = Spectra()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     return 1
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.nRdChannels
                         self.nRdPairs
                         self.pts2read_SelfSpectra
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
                         self.dataOut.nChannels
                         self.dataOut.nPairs
                     Return:
                         None
                     """
                     self.nRdChannels = 0
                     self.nRdPairs = 0
                     self.rdPairList = []
                     for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
                         if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
                             self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
                         else:
                             self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
                             self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
                     pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
                     self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
                     self.blocksize = self.pts2read_SelfSpectra
                     if self.processingHeaderObj.flag_cspc:
                         self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
                         self.blocksize += self.pts2read_CrossSpectra
                     if self.processingHeaderObj.flag_dc:
                         self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
                         self.blocksize += self.pts2read_DCchannels
                 def readBlock(self):
                     """
                     Lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Return: None
                     Variables afectadas:
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     fpointer = self.fp.tell()
                     spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
                     spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
                         cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_dc:
                         dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
                         dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
                     if not self.processingHeaderObj.shif_fft:
                         #desplaza a la derecha en el eje 2 determinadas posiciones
                         shift = int(self.processingHeaderObj.profilesPerBlock/2)
                         spc = numpy.roll( spc, shift , axis=2 )
                         if self.processingHeaderObj.flag_cspc:
                             #desplaza a la derecha en el eje 2 determinadas posiciones
                             cspc = numpy.roll( cspc, shift, axis=2 )
                     #Dimensions : nChannels, nProfiles, nSamples
                     spc = numpy.transpose( spc, (0,2,1) )
                     self.data_spc = spc
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.transpose( cspc, (0,2,1) )
                         self.data_cspc = cspc['real'] + cspc['imag']*1j
                     else:
                         self.data_cspc = None
                     if self.processingHeaderObj.flag_dc:
                         self.data_dc = dc['real'] + dc['imag']*1j
                     else:
                         self.data_dc = None
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getFirstHeader(self):
                     self.getBasicHeader()
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     self.dataOut.dtype = self.dtype
                     self.dataOut.pairsList = self.rdPairList
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                     self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
                     self.dataOut.flagShiftFFT = True    #Data is always shifted
                     self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
                     self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data esta sin flip
                 def getData(self):
                     """
                     First method to execute before "RUN" is called.
                     Copia el buffer de lectura a la clase "Spectra",
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Return:
 :    Si no hay mas archivos disponibles
 :    Si hizo una buena copia del buffer
                     Affected:
                         self.dataOut
                         self.flagDiscontinuousBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         return 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             self.dataOut.flagNoData = True
                             return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_spc is None:
                         self.dataOut.flagNoData = True
                         return 0
                     self.getBasicHeader()
                     self.getFirstHeader()
                     self.dataOut.data_spc = self.data_spc
                     self.dataOut.data_cspc = self.data_cspc
                     self.dataOut.data_dc = self.data_dc
                     self.dataOut.flagNoData = False
                     self.dataOut.realtime = self.online
                     return self.dataOut.data_spc
             @MPDecorator
             class SpectraWriter(JRODataWriter, Operation):
                 """
                 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 def __init__(self):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj
                     Return: None
                     """
                     Operation.__init__(self)
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.shape_spc_Buffer = None
                     self.shape_cspc_Buffer = None
                     self.shape_dc_Buffer = None
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_dc = None
                     self.setFile = None
                     self.noMoreFiles = 0
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     return 1
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shape_spc_Buffer = (self.dataOut.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
                     self.shape_cspc_Buffer = (self.dataOut.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
                     self.shape_dc_Buffer = (self.dataOut.nChannels,
                                             self.processingHeaderObj.nHeights)
                 def writeBlock(self):
                     """processingHeaderObj
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     spc = numpy.transpose( self.data_spc, (0,2,1) )
                     if not self.processingHeaderObj.shif_fft:
                         spc = numpy.roll( spc, int(self.processingHeaderObj.profilesPerBlock/2), axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     data = spc.reshape((-1))
                     data = data.astype(self.dtype[0])
                     data.tofile(self.fp)
                     if self.data_cspc is not None:
                         cspc = numpy.transpose( self.data_cspc, (0,2,1) )
                         data = numpy.zeros( numpy.shape(cspc), self.dtype )
                         #print 'data.shape', self.shape_cspc_Buffer
                         if not self.processingHeaderObj.shif_fft:
                             cspc = numpy.roll( cspc, int(self.processingHeaderObj.profilesPerBlock/2), axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         data['real'] = cspc.real
                         data['imag'] = cspc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     if self.data_dc is not None:
                         dc = self.data_dc
                         data = numpy.zeros( numpy.shape(dc), self.dtype )
                         data['real'] = dc.real
                         data['imag'] = dc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
             #         self.data_spc.fill(0)
             #
             #         if self.data_dc is not None:
             #             self.data_dc.fill(0)
             #
             #         if self.data_cspc is not None:
             #             self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                     self.blockIndex += 1
             #         print "[Writing] Block = %d04" %self.blockIndex
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagDiscontinuousBlock:
                         self.data_spc.fill(0)
                         if self.dataOut.data_cspc is not None:
                             self.data_cspc.fill(0)
                         if self.dataOut.data_dc is not None:
                             self.data_dc.fill(0)
                         self.setNextFile()
                     if self.flagIsNewFile == 0:
                         self.setBasicHeader()
                     self.data_spc = self.dataOut.data_spc.copy()
                     if self.dataOut.data_cspc is not None:
                         self.data_cspc = self.dataOut.data_cspc.copy()
                     if self.dataOut.data_dc is not None:
                         self.data_dc = self.dataOut.data_dc.copy()
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
             #            self.setFirstHeader()
                         self.writeNextBlock()
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
                     '''
                     dtype_width = self.getDtypeWidth()
                     pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
                     pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
                     blocksize = (pts2write_SelfSpectra*dtype_width)
                     if self.dataOut.data_cspc is not None:
                         pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
                         blocksize += (pts2write_CrossSpectra*dtype_width*2)
                     if self.dataOut.data_dc is not None:
                         pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
                         blocksize += (pts2write_DCchannels*dtype_width*2)
             #         blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
                     return blocksize
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.processingHeaderObj.dtype = 1 # Spectra
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
                         for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
                         if self.dataOut.nPairs > 0:
                             for pair in self.dataOut.pairsList:
                                 pairsList.append(pair[0])
                                 pairsList.append(pair[1])
                         spectraComb = channelList + pairsList
                         spectraComb = numpy.array(spectraComb, dtype="u1")
                         self.processingHeaderObj.spectraComb = spectraComb
                     if self.dataOut.code is not None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                     self.processingHeaderObj.processFlags = self.getProcessFlags()
-                    self.setBasicHeader()
  No newline at end of file
+                    self.setBasicHeader()

schainpy/model/proc/jroproc_base.py +1 -1

             '''
             Base clases to create Processing units and operations, the MPDecorator
             must be used in plotting and writing operations to allow to run as an
             external process.
             '''
             import inspect
             import zmq
             import time
             import pickle
             import traceback
             from threading import Thread
             from multiprocessing import Process, Queue
             from schainpy.utils import log
             class ProcessingUnit(object):
                 '''
                 Base class to create Signal Chain Units
                 '''
                 proc_type = 'processing'
                 def __init__(self):
                     self.dataIn = None
                     self.dataOut = None
                     self.isConfig = False
                     self.operations = []
                 def setInput(self, unit):
                     self.dataIn = unit.dataOut
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def addOperation(self, conf, operation):
                     '''
                     '''
                     self.operations.append((operation, conf.type, conf.getKwargs()))
                 def getOperationObj(self, objId):
                     if objId not in list(self.operations.keys()):
                         return None
                     return self.operations[objId]
                 def call(self, **kwargs):
                     '''
                     '''
                     try:
                         if self.dataIn is not None and self.dataIn.flagNoData and not self.dataIn.error:
                             return self.dataIn.isReady()
                         elif self.dataIn is None or not self.dataIn.error:
                             self.run(**kwargs)
                         elif self.dataIn.error:
                             self.dataOut.error = self.dataIn.error
                             self.dataOut.flagNoData = True
                     except:
                         err = traceback.format_exc()
                         if 'SchainWarning' in err:
                             log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), self.name)
                         elif 'SchainError' in err:
                             log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), self.name)
                         else:
                             log.error(err, self.name)
                         self.dataOut.error = True
                     for op, optype, opkwargs in self.operations:
                         if optype == 'other' and not self.dataOut.flagNoData:
                             self.dataOut = op.run(self.dataOut, **opkwargs)
                         elif optype == 'external' and not self.dataOut.flagNoData:
                             op.queue.put(self.dataOut)
                         elif optype == 'external' and self.dataOut.error:
                             op.queue.put(self.dataOut)
                     return 'Error' if self.dataOut.error else self.dataOut.isReady()
                 def setup(self):
                     raise NotImplementedError
                 def run(self):
                     raise NotImplementedError
                 def close(self):
                     return
             class Operation(object):
                 '''
                 '''
                 proc_type = 'operation'
                 def __init__(self):
                     self.id = None
                     self.isConfig = False
                     if not hasattr(self, 'name'):
                         self.name = self.__class__.__name__
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def setup(self):
                     self.isConfig = True
                     raise NotImplementedError
                 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 NotImplementedError
                 def close(self):
                     return
             def MPDecorator(BaseClass):
                 """
                 Multiprocessing class decorator
                 This function add multiprocessing features to a BaseClass.
                 """
                 class MPClass(BaseClass, Process):
                     def __init__(self, *args, **kwargs):
                         super(MPClass, self).__init__()
                         Process.__init__(self)
                         self.args = args
                         self.kwargs = kwargs
                         self.t = time.time()
                         self.op_type = 'external'
                         self.name = BaseClass.__name__
                         self.__doc__ = BaseClass.__doc__
                         if 'plot' in self.name.lower() and not self.name.endswith('_'):
                             self.name = '{}{}'.format(self.CODE.upper(), 'Plot')
                         self.start_time = time.time()
-                        self.err_queue = args[3]
+                        #self.err_queue = args[2]
                         self.queue = Queue(maxsize=1)
                         self.myrun = BaseClass.run
                     def run(self):
                         while True:
                             dataOut = self.queue.get()
                             if not dataOut.error:
                                 try:
                                     BaseClass.run(self, dataOut, **self.kwargs)
                                 except:
                                     err = traceback.format_exc()
                                     log.error(err, self.name)
                             else:
                                 break
                         self.close()
                     def close(self):
                         BaseClass.close(self)
                         log.success('Done...(Time:{:4.2f} secs)'.format(time.time()-self.start_time), self.name)
                 return MPClass

schainpy/scripts/amisr_eej_proc_offline_v3.py +28 -25

-            #!/usr/bin/env python
             import os, sys
             import time
             import datetime
             path = os.path.dirname(os.getcwd())
             path = os.path.dirname(path)
             sys.path.insert(0, path)
             from schainpy.controller import Project
             def main():
                 desc = "AMISR EEJ Experiment"
                 filename = "amisr_reader.xml"
                 xmin = '07'
                 xmax = '18' #-> el plot genera +1 en la hora, es decir aparece 18 como máximo
                 ymin = '0'
                 ymax = '300'
                 dbmin = '45' #'60'#'55' #'40' #noise  esf  eej
                 dbmax = '65' #'70' #'55'
-                showSPC = '0' #view plot Spectra
+                showSPC = '1' #view plot Spectra
-                showRTI = '0' #view plot RTI
+                showRTI = '1' #view plot RTI
-                showNOISE = '0' #view plot NOISE
+                showNOISE = '1' #view plot NOISE
-                localtime='0' #para ajustar el horario en las gráficas '0' para dejar en utc
+                localtime='1' #para ajustar el horario en las gráficas '0' para dejar en utc
                 code = '1,-1,-1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,1,-1,1,1,-1,1'
                 nCode = '1'
                 nBaud = '28'
                 nosamp = '1' # oversample for EEJ
                 today = time.strftime("%Y/%m/%d")
                 #startDate=today
                 #endDate=today
-                startDate='2019/12/16'
+                startDate='2021/07/11'
-                endDate='2019/12/16'
+                endDate='2021/07/11'
                 #inPath= '/home/soporte/dataAMISR_test/'
                 inPath= '/home/soporte/dataAMISR/'
+                inPath= '/media/soporte/UARS_4T_D02/AMISR_DATA/2021/'
                 #inPath = '/mnt/data_amisr'
                 outPath = '/home/soporte/Data/EEJ'
                 ##.......................................................................................
                 ##.......................................................................................
                 #l = startDate.split('/')                        #adding day of the year to outPath
                 l = startDate.split('/')
                 datelist = datetime.date(int(l[0]),int(l[1]),int(l[2]))
                 DOY = datelist.timetuple().tm_yday
                 outPath= outPath+"/EEJ"+l[0]+str(DOY)
                 if os.path.exists(outPath):
                     print("outPath", outPath)
                 else :
                     os.mkdir(outPath)
                     print("Creating...", outPath)
                 ##.......................................................................................
                 ##.......................................................................................
                 controllerObj = Project()
                 controllerObj.setup(id = '11', name='eej_proc', description=desc)
                 ##.......................................................................................
                 ##.......................................................................................
                 readUnitConfObj = controllerObj.addReadUnit(datatype='AMISRReader',
                                                             path=inPath,
                                                             startDate=startDate,#startDate, #'2014/10/07',
                                                             endDate=endDate, #endDate '2014/10/07',
                                                             startTime='07:01:30',#'07:00:00',
                                                             endTime='19:00:00',#'15:00:00',
-                                                            walk=0,
+                                                            walk=1,
                                                             code = code,
                                                             nCode = nCode,
                                                             nBaud = nBaud,
-                                                            timezone='ut',
+                                                            timezone='lt',
                                                             online=0)
                 #AMISR Processing Unit
                 ##.......................................................................................
                 ##.......................................................................................
                 procUnitConfObj0 = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
-                opObj10 = procUnitConfObj0.addOperation(name='setRadarFrequency')
+                opObj10 = procUnitConfObj0.addOperation(name='setAttribute')
-                opObj10.addParameter(name='frequency', value='445e6', format='float')
+                opObj10.addParameter(name='frequency', value='445.09e6')
+                # opObj10 = procUnitConfObj0.addOperation(name='setRadarFrequency')
+                # opObj10.addParameter(name='frequency', value='445e6', format='float')
                 opObj01 = procUnitConfObj0.addOperation(name='Decoder', optype='other')
                 opObj01.addParameter(name='code', value=code, format='floatlist')
                 opObj01.addParameter(name='nCode', value=nCode, format='int')
                 opObj01.addParameter(name='nBaud', value=nBaud, format='int')
                 opObj01.addParameter(name='osamp', value=nosamp, format='int')
-                opObj02 = procUnitConfObj0.addOperation(name='CohInt', optype='other')
+                # opObj02 = procUnitConfObj0.addOperation(name='CohInt', optype='other')
-                opObj02.addParameter(name='n', value='2', format='int')
+                # opObj02.addParameter(name='n', value='2', format='int')
                 ##.......................................................................................
                 ##.......................................................................................
                 procUnitConfObj1 = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObj0.getId())
                 procUnitConfObj1.addParameter(name='nFFTPoints', value='16', format='int')
                 opObj11 = procUnitConfObj1.addOperation(name='IncohInt', optype='other')
                 opObj11.addParameter(name='n', value='150', format='int') #300?
                 ## Remove DC signal
                 opObj11 = procUnitConfObj1.addOperation(name='removeDC')
                 ##.......................................................................................
                 ##.......................................................................................
-                opObj13 = procUnitConfObj1.addOperation(name='getNoise' , optype ='self')
+                # opObj13 = procUnitConfObj1.addOperation(name='getNoise' , optype ='self')
-                opObj13.addParameter(name='minHei', value='100', format='float')
+                # opObj13.addParameter(name='minHei', value='100', format='float')
-                opObj13.addParameter(name='maxHei', value='280', format='float')
+                # opObj13.addParameter(name='maxHei', value='280', format='float')
                 #
                 opObj12 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
                 opObj12.addParameter(name='id', value='21', format='int')
                 opObj12.addParameter(name= 'xaxis', value='velocity')
                 opObj12.addParameter(name='ymax', value=ymax, format='int')
                 opObj12.addParameter(name='showprofile', value='1', format='int')
                 opObj12.addParameter(name='wintitle', value='AMISR Beam 0', format='str')
                 opObj12.addParameter(name='zmin', value=dbmin, format='int')
                 opObj12.addParameter(name='zmax', value=dbmax, format='int')
                 opObj12.addParameter(name='save', value=outPath+'/plots', format='str')
                 opObj12.addParameter(name='colormap', value='jet', format='str')
                 opObj12.addParameter(name='localtime', value=localtime,format='int')
                 opObj12.addParameter(name='show', value = showSPC, format='int')
                 ##Generate *.pdata from AMISR data
                 ##.......................................................................................
                 ##.......................................................................................
                 opObj13 = procUnitConfObj1.addOperation(name='SpectraWriter', optype='external')
                 opObj13.addParameter(name='path', value=outPath)
                 opObj13.addParameter(name='blocksPerFile', value='10', format='int')
                 opObj14 = procUnitConfObj1.addOperation(name='NoisePlot', optype='external')
                 opObj14.addParameter(name='id', value='3', format='int')
                 opObj14.addParameter(name='wintitle', value='title0', format='str')
                 opObj14.addParameter(name='showprofile', value='0', format='int')
-                opObj14.addParameter(name='xmin', value=xmin, format='int')
+                opObj14.addParameter(name='tmin', value=xmin, format='int')
-                opObj14.addParameter(name='xmax', value=xmax, format='int')
+                opObj14.addParameter(name='tmax', value=xmax, format='int')
                 opObj14.addParameter(name='ymin', value=dbmin, format='int')
                 opObj14.addParameter(name='ymax', value=dbmax, format='int')
                 opObj14.addParameter(name='save', value=outPath, format='str')
                 opObj14.addParameter(name='localtime', value=localtime,format='int')
                 opObj14.addParameter(name='show', value = showNOISE, format='int')
+                #
                 opObj15 = procUnitConfObj1.addOperation(name='RTIPlot', optype='external')
                 opObj15.addParameter(name='id', value='2', format='int')
                 opObj15.addParameter(name='localtime', value=localtime,format='int')
                 opObj15.addParameter(name='wintitle', value='RTI', format='str')
-                opObj15.addParameter(name='xmin', value=xmin, format='int')
+                opObj15.addParameter(name='tmin', value=xmin, format='int')
-                opObj15.addParameter(name='xmax', value=xmax, format='int') #max value =23
+                opObj15.addParameter(name='tmax', value=xmax, format='int') #max value =23
                 opObj15.addParameter(name='ymin', value=ymin, format='int')
                 opObj15.addParameter(name='zmin', value=dbmin, format='int')
                 opObj15.addParameter(name='zmax', value=dbmax, format='int')
                 opObj15.addParameter(name='showprofile', value='0', format='int')
                 opObj15.addParameter(name='save', value=outPath+'/plots', format='str')
                 opObj15.addParameter(name='colormap', value='jet', format='str')
                 opObj15.addParameter(name='show', value = showRTI, format='int')
                 ##.......................................................................................
                 ##.......................................................................................
                 procUnitConfObj2 = controllerObj.addProcUnit(datatype='ParametersProc', inputId=procUnitConfObj1.getId())
                 opObj16 =  procUnitConfObj2.addOperation(name='SpectralMoments', optype='other')
-                #Using ParamWriter::::
+                #Using HDFWriter::::
                 ##.......................................................................................
                 ##.......................................................................................
-                opObj17 = procUnitConfObj2.addOperation(name='ParamWriter', optype='external')
+                opObj17 = procUnitConfObj2.addOperation(name='HDFWriter', optype='external')
                 opObj17.addParameter(name='path', value=outPath)
                 opObj17.addParameter(name='blocksPerFile', value='10', format='int')
                 opObj17.addParameter(name='metadataList',value='type,inputUnit,heightList',format='list')
                 opObj17.addParameter(name='dataList',value='moments,data_SNR,utctime',format='list')
-                opObj17.addParameter(name='mode',value='1',format='int') #'0' channels, '1' parameters, '3' table (for meteors)
-                ##opObj17.addParameter(name='setType', value ='anything', format='str')#no usar
                 ##.......................................................................................
                 ##.......................................................................................
                 #print("Escribiendo el archivo XML",controllerObj.writeXml(path +'/'+filename))
                 controllerObj.start()
                 #print("Leyendo el archivo XML",controllerObj.readXml(path +'/'+filename))
                 ##.......................................................................................
                 ##.......................................................................................
             if __name__ == '__main__':
                 import time
                 start_time = time.time()
                 main()
                 print("--- %s seconds ---" % (time.time() - start_time))

schainpy/scripts/joab.xml removed 0 -1

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