##// END OF EJS Templates
schain
RSS
Now we can merge ProcUnits for Double Pulse Experiments
rflores -
r1452:d596eb625435
parent child
Show More
Side by Side Unified
Context file:
r1452:d596eb625435 Loading diff...:

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

Show file before | Show file after | Hide comments
@@ -1,662 +1,665
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 class ConfBase():
28 class ConfBase():
29
29
30 def __init__(self):
30 def __init__(self):
31
31
32 self.id = '0'
32 self.id = '0'
33 self.name = None
33 self.name = None
34 self.priority = None
34 self.priority = None
35 self.parameters = {}
35 self.parameters = {}
36 self.object = None
36 self.object = None
37 self.operations = []
37 self.operations = []
38
38
39 def getId(self):
39 def getId(self):
40
40
41 return self.id
41 return self.id
42
42
43 def getNewId(self):
43 def getNewId(self):
44
44
45 return int(self.id) * 10 + len(self.operations) + 1
45 return int(self.id) * 10 + len(self.operations) + 1
46
46
47 def updateId(self, new_id):
47 def updateId(self, new_id):
48
48
49 self.id = str(new_id)
49 self.id = str(new_id)
50
50
51 n = 1
51 n = 1
52 for conf in self.operations:
52 for conf in self.operations:
53 conf_id = str(int(new_id) * 10 + n)
53 conf_id = str(int(new_id) * 10 + n)
54 conf.updateId(conf_id)
54 conf.updateId(conf_id)
55 n += 1
55 n += 1
56
56
57 def getKwargs(self):
57 def getKwargs(self):
58
58
59 params = {}
59 params = {}
60
60
61 for key, value in self.parameters.items():
61 for key, value in self.parameters.items():
62 if value not in (None, '', ' '):
62 if value not in (None, '', ' '):
63 params[key] = value
63 params[key] = value
64
64
65 return params
65 return params
66
66
67 def update(self, **kwargs):
67 def update(self, **kwargs):
68
68
69 if 'format' not in kwargs:
69 if 'format' not in kwargs:
70 kwargs['format'] = None
70 kwargs['format'] = None
71 for key, value, fmt in kwargs.items():
71 for key, value, fmt in kwargs.items():
72 self.addParameter(name=key, value=value, format=fmt)
72 self.addParameter(name=key, value=value, format=fmt)
73
73
74 def addParameter(self, name, value, format=None):
74 def addParameter(self, name, value, format=None):
75 '''
75 '''
76 '''
76 '''
77 if format is not None:
77 if format is not None:
78 self.parameters[name] = eval(format)(value)
78 self.parameters[name] = eval(format)(value)
79 elif isinstance(value, str) and re.search(r'(\d+/\d+/\d+)', value):
79 elif isinstance(value, str) and re.search(r'(\d+/\d+/\d+)', value):
80 self.parameters[name] = datetime.date(*[int(x) for x in value.split('/')])
80 self.parameters[name] = datetime.date(*[int(x) for x in value.split('/')])
81 elif isinstance(value, str) and re.search(r'(\d+:\d+:\d+)', value):
81 elif isinstance(value, str) and re.search(r'(\d+:\d+:\d+)', value):
82 self.parameters[name] = datetime.time(*[int(x) for x in value.split(':')])
82 self.parameters[name] = datetime.time(*[int(x) for x in value.split(':')])
83 else:
83 else:
84 try:
84 try:
85 self.parameters[name] = ast.literal_eval(value)
85 self.parameters[name] = ast.literal_eval(value)
86 except:
86 except:
87 if isinstance(value, str) and ',' in value:
87 if isinstance(value, str) and ',' in value:
88 self.parameters[name] = value.split(',')
88 self.parameters[name] = value.split(',')
89 else:
89 else:
90 self.parameters[name] = value
90 self.parameters[name] = value
91
91
92 def getParameters(self):
92 def getParameters(self):
93
93
94 params = {}
94 params = {}
95 for key, value in self.parameters.items():
95 for key, value in self.parameters.items():
96 s = type(value).__name__
96 s = type(value).__name__
97 if s == 'date':
97 if s == 'date':
98 params[key] = value.strftime('%Y/%m/%d')
98 params[key] = value.strftime('%Y/%m/%d')
99 elif s == 'time':
99 elif s == 'time':
100 params[key] = value.strftime('%H:%M:%S')
100 params[key] = value.strftime('%H:%M:%S')
101 else:
101 else:
102 params[key] = str(value)
102 params[key] = str(value)
103
103
104 return params
104 return params
105
105
106 def makeXml(self, element):
106 def makeXml(self, element):
107
107
108 xml = SubElement(element, self.ELEMENTNAME)
108 xml = SubElement(element, self.ELEMENTNAME)
109 for label in self.xml_labels:
109 for label in self.xml_labels:
110 xml.set(label, str(getattr(self, label)))
110 xml.set(label, str(getattr(self, label)))
111
111
112 for key, value in self.getParameters().items():
112 for key, value in self.getParameters().items():
113 xml_param = SubElement(xml, 'Parameter')
113 xml_param = SubElement(xml, 'Parameter')
114 xml_param.set('name', key)
114 xml_param.set('name', key)
115 xml_param.set('value', value)
115 xml_param.set('value', value)
116
116
117 for conf in self.operations:
117 for conf in self.operations:
118 conf.makeXml(xml)
118 conf.makeXml(xml)
119
119
120 def __str__(self):
120 def __str__(self):
121
121
122 if self.ELEMENTNAME == 'Operation':
122 if self.ELEMENTNAME == 'Operation':
123 s = ' {}[id={}]\n'.format(self.name, self.id)
123 s = ' {}[id={}]\n'.format(self.name, self.id)
124 else:
124 else:
125 s = '{}[id={}, inputId={}]\n'.format(self.name, self.id, self.inputId)
125 s = '{}[id={}, inputId={}]\n'.format(self.name, self.id, self.inputId)
126
126
127 for key, value in self.parameters.items():
127 for key, value in self.parameters.items():
128 if self.ELEMENTNAME == 'Operation':
128 if self.ELEMENTNAME == 'Operation':
129 s += ' {}: {}\n'.format(key, value)
129 s += ' {}: {}\n'.format(key, value)
130 else:
130 else:
131 s += ' {}: {}\n'.format(key, value)
131 s += ' {}: {}\n'.format(key, value)
132
132
133 for conf in self.operations:
133 for conf in self.operations:
134 s += str(conf)
134 s += str(conf)
135
135
136 return s
136 return s
137
137
138 class OperationConf(ConfBase):
138 class OperationConf(ConfBase):
139
139
140 ELEMENTNAME = 'Operation'
140 ELEMENTNAME = 'Operation'
141 xml_labels = ['id', 'name']
141 xml_labels = ['id', 'name']
142
142
143 def setup(self, id, name, priority, project_id, err_queue):
143 def setup(self, id, name, priority, project_id, err_queue):
144
144
145 self.id = str(id)
145 self.id = str(id)
146 self.project_id = project_id
146 self.project_id = project_id
147 self.name = name
147 self.name = name
148 self.type = 'other'
148 self.type = 'other'
149 self.err_queue = err_queue
149 self.err_queue = err_queue
150
150
151 def readXml(self, element, project_id, err_queue):
151 def readXml(self, element, project_id, err_queue):
152
152
153 self.id = element.get('id')
153 self.id = element.get('id')
154 self.name = element.get('name')
154 self.name = element.get('name')
155 self.type = 'other'
155 self.type = 'other'
156 self.project_id = str(project_id)
156 self.project_id = str(project_id)
157 self.err_queue = err_queue
157 self.err_queue = err_queue
158
158
159 for elm in element.iter('Parameter'):
159 for elm in element.iter('Parameter'):
160 self.addParameter(elm.get('name'), elm.get('value'))
160 self.addParameter(elm.get('name'), elm.get('value'))
161
161
162 def createObject(self):
162 def createObject(self):
163
163
164 className = eval(self.name)
164 className = eval(self.name)
165
165
166 if 'Plot' in self.name or 'Writer' in self.name or 'Send' in self.name or 'print' in self.name:
166 if 'Plot' in self.name or 'Writer' in self.name or 'Send' in self.name or 'print' in self.name:
167 kwargs = self.getKwargs()
167 kwargs = self.getKwargs()
168 opObj = className(self.id, self.id, self.project_id, self.err_queue, **kwargs)
168 opObj = className(self.id, self.id, self.project_id, self.err_queue, **kwargs)
169 opObj.start()
169 opObj.start()
170 self.type = 'external'
170 self.type = 'external'
171 else:
171 else:
172 opObj = className()
172 opObj = className()
173
173
174 self.object = opObj
174 self.object = opObj
175 return opObj
175 return opObj
176
176
177 class ProcUnitConf(ConfBase):
177 class ProcUnitConf(ConfBase):
178
178
179 ELEMENTNAME = 'ProcUnit'
179 ELEMENTNAME = 'ProcUnit'
180 xml_labels = ['id', 'inputId', 'name']
180 xml_labels = ['id', 'inputId', 'name']
181
181
182 def setup(self, project_id, id, name, datatype, inputId, err_queue):
182 def setup(self, project_id, id, name, datatype, inputId, err_queue):
183 '''
183 '''
184 '''
184 '''
185
185
186 if datatype == None and name == None:
186 if datatype == None and name == None:
187 raise ValueError('datatype or name should be defined')
187 raise ValueError('datatype or name should be defined')
188
188
189 if name == None:
189 if name == None:
190 if 'Proc' in datatype:
190 if 'Proc' in datatype:
191 name = datatype
191 name = datatype
192 else:
192 else:
193 name = '%sProc' % (datatype)
193 name = '%sProc' % (datatype)
194
194
195 if datatype == None:
195 if datatype == None:
196 datatype = name.replace('Proc', '')
196 datatype = name.replace('Proc', '')
197
197
198 self.id = str(id)
198 self.id = str(id)
199 self.project_id = project_id
199 self.project_id = project_id
200 self.name = name
200 self.name = name
201 self.datatype = datatype
201 self.datatype = datatype
202 self.inputId = inputId
202 self.inputId = inputId
203 self.err_queue = err_queue
203 self.err_queue = err_queue
204 self.operations = []
204 self.operations = []
205 self.parameters = {}
205 self.parameters = {}
206
206
207 def removeOperation(self, id):
207 def removeOperation(self, id):
208
208
209 i = [1 if x.id==id else 0 for x in self.operations]
209 i = [1 if x.id==id else 0 for x in self.operations]
210 self.operations.pop(i.index(1))
210 self.operations.pop(i.index(1))
211
211
212 def getOperation(self, id):
212 def getOperation(self, id):
213
213
214 for conf in self.operations:
214 for conf in self.operations:
215 if conf.id == id:
215 if conf.id == id:
216 return conf
216 return conf
217
217
218 def addOperation(self, name, optype='self'):
218 def addOperation(self, name, optype='self'):
219 '''
219 '''
220 '''
220 '''
221
221
222 id = self.getNewId()
222 id = self.getNewId()
223 conf = OperationConf()
223 conf = OperationConf()
224 conf.setup(id, name=name, priority='0', project_id=self.project_id, err_queue=self.err_queue)
224 conf.setup(id, name=name, priority='0', project_id=self.project_id, err_queue=self.err_queue)
225 self.operations.append(conf)
225 self.operations.append(conf)
226
226
227 return conf
227 return conf
228
228
229 def readXml(self, element, project_id, err_queue):
229 def readXml(self, element, project_id, err_queue):
230
230
231 self.id = element.get('id')
231 self.id = element.get('id')
232 self.name = element.get('name')
232 self.name = element.get('name')
233 self.inputId = None if element.get('inputId') == 'None' else element.get('inputId')
233 self.inputId = None if element.get('inputId') == 'None' else element.get('inputId')
234 self.datatype = element.get('datatype', self.name.replace(self.ELEMENTNAME.replace('Unit', ''), ''))
234 self.datatype = element.get('datatype', self.name.replace(self.ELEMENTNAME.replace('Unit', ''), ''))
235 self.project_id = str(project_id)
235 self.project_id = str(project_id)
236 self.err_queue = err_queue
236 self.err_queue = err_queue
237 self.operations = []
237 self.operations = []
238 self.parameters = {}
238 self.parameters = {}
239
239
240 for elm in element:
240 for elm in element:
241 if elm.tag == 'Parameter':
241 if elm.tag == 'Parameter':
242 self.addParameter(elm.get('name'), elm.get('value'))
242 self.addParameter(elm.get('name'), elm.get('value'))
243 elif elm.tag == 'Operation':
243 elif elm.tag == 'Operation':
244 conf = OperationConf()
244 conf = OperationConf()
245 conf.readXml(elm, project_id, err_queue)
245 conf.readXml(elm, project_id, err_queue)
246 self.operations.append(conf)
246 self.operations.append(conf)
247
247
248 def createObjects(self):
248 def createObjects(self):
249 '''
249 '''
250 Instancia de unidades de procesamiento.
250 Instancia de unidades de procesamiento.
251 '''
251 '''
252
252
253 className = eval(self.name)
253 className = eval(self.name)
254 kwargs = self.getKwargs()
254 kwargs = self.getKwargs()
255 procUnitObj = className()
255 procUnitObj = className()
256 procUnitObj.name = self.name
256 procUnitObj.name = self.name
257 log.success('creating process...', self.name)
257 log.success('creating process...', self.name)
258
258
259 for conf in self.operations:
259 for conf in self.operations:
260
260
261 opObj = conf.createObject()
261 opObj = conf.createObject()
262
262
263 log.success('adding operation: {}, type:{}'.format(
263 log.success('adding operation: {}, type:{}'.format(
264 conf.name,
264 conf.name,
265 conf.type), self.name)
265 conf.type), self.name)
266
266
267 procUnitObj.addOperation(conf, opObj)
267 procUnitObj.addOperation(conf, opObj)
268
268
269 self.object = procUnitObj
269 self.object = procUnitObj
270
270
271 def run(self):
271 def run(self):
272 '''
272 '''
273 '''
273 '''
274
274
275 return self.object.call(**self.getKwargs())
275 return self.object.call(**self.getKwargs())
276
276
277
277
278 class ReadUnitConf(ProcUnitConf):
278 class ReadUnitConf(ProcUnitConf):
279
279
280 ELEMENTNAME = 'ReadUnit'
280 ELEMENTNAME = 'ReadUnit'
281
281
282 def __init__(self):
282 def __init__(self):
283
283
284 self.id = None
284 self.id = None
285 self.datatype = None
285 self.datatype = None
286 self.name = None
286 self.name = None
287 self.inputId = None
287 self.inputId = None
288 self.operations = []
288 self.operations = []
289 self.parameters = {}
289 self.parameters = {}
290
290
291 def setup(self, project_id, id, name, datatype, err_queue, path='', startDate='', endDate='',
291 def setup(self, project_id, id, name, datatype, err_queue, path='', startDate='', endDate='',
292 startTime='', endTime='', server=None, **kwargs):
292 startTime='', endTime='', server=None, **kwargs):
293
293
294 if datatype == None and name == None:
294 if datatype == None and name == None:
295 raise ValueError('datatype or name should be defined')
295 raise ValueError('datatype or name should be defined')
296 if name == None:
296 if name == None:
297 if 'Reader' in datatype:
297 if 'Reader' in datatype:
298 name = datatype
298 name = datatype
299 datatype = name.replace('Reader','')
299 datatype = name.replace('Reader','')
300 else:
300 else:
301 name = '{}Reader'.format(datatype)
301 name = '{}Reader'.format(datatype)
302 if datatype == None:
302 if datatype == None:
303 if 'Reader' in name:
303 if 'Reader' in name:
304 datatype = name.replace('Reader','')
304 datatype = name.replace('Reader','')
305 else:
305 else:
306 datatype = name
306 datatype = name
307 name = '{}Reader'.format(name)
307 name = '{}Reader'.format(name)
308
308
309 self.id = id
309 self.id = id
310 self.project_id = project_id
310 self.project_id = project_id
311 self.name = name
311 self.name = name
312 self.datatype = datatype
312 self.datatype = datatype
313 self.err_queue = err_queue
313 self.err_queue = err_queue
314
314
315 self.addParameter(name='path', value=path, format='str')
315 self.addParameter(name='path', value=path, format='str')
316 self.addParameter(name='startDate', value=startDate)
316 self.addParameter(name='startDate', value=startDate)
317 self.addParameter(name='endDate', value=endDate)
317 self.addParameter(name='endDate', value=endDate)
318 self.addParameter(name='startTime', value=startTime)
318 self.addParameter(name='startTime', value=startTime)
319 self.addParameter(name='endTime', value=endTime)
319 self.addParameter(name='endTime', value=endTime)
320
320
321 for key, value in kwargs.items():
321 for key, value in kwargs.items():
322 self.addParameter(name=key, value=value)
322 self.addParameter(name=key, value=value)
323
323
324
324
325 class Project(Process):
325 class Project(Process):
326 """API to create signal chain projects"""
326 """API to create signal chain projects"""
327
327
328 ELEMENTNAME = 'Project'
328 ELEMENTNAME = 'Project'
329
329
330 def __init__(self, name=''):
330 def __init__(self, name=''):
331
331
332 Process.__init__(self)
332 Process.__init__(self)
333 self.id = '1'
333 self.id = '1'
334 if name:
334 if name:
335 self.name = '{} ({})'.format(Process.__name__, name)
335 self.name = '{} ({})'.format(Process.__name__, name)
336 self.filename = None
336 self.filename = None
337 self.description = None
337 self.description = None
338 self.email = None
338 self.email = None
339 self.alarm = []
339 self.alarm = []
340 self.configurations = {}
340 self.configurations = {}
341 # self.err_queue = Queue()
341 # self.err_queue = Queue()
342 self.err_queue = None
342 self.err_queue = None
343 self.started = False
343 self.started = False
344
344
345 def getNewId(self):
345 def getNewId(self):
346
346
347 idList = list(self.configurations.keys())
347 idList = list(self.configurations.keys())
348 id = int(self.id) * 10
348 id = int(self.id) * 10
349
349
350 while True:
350 while True:
351 id += 1
351 id += 1
352
352
353 if str(id) in idList:
353 if str(id) in idList:
354 continue
354 continue
355
355
356 break
356 break
357
357
358 return str(id)
358 return str(id)
359
359
360 def updateId(self, new_id):
360 def updateId(self, new_id):
361
361
362 self.id = str(new_id)
362 self.id = str(new_id)
363
363
364 keyList = list(self.configurations.keys())
364 keyList = list(self.configurations.keys())
365 keyList.sort()
365 keyList.sort()
366
366
367 n = 1
367 n = 1
368 new_confs = {}
368 new_confs = {}
369
369
370 for procKey in keyList:
370 for procKey in keyList:
371
371
372 conf = self.configurations[procKey]
372 conf = self.configurations[procKey]
373 idProcUnit = str(int(self.id) * 10 + n)
373 idProcUnit = str(int(self.id) * 10 + n)
374 conf.updateId(idProcUnit)
374 conf.updateId(idProcUnit)
375 new_confs[idProcUnit] = conf
375 new_confs[idProcUnit] = conf
376 n += 1
376 n += 1
377
377
378 self.configurations = new_confs
378 self.configurations = new_confs
379
379
380 def setup(self, id=1, name='', description='', email=None, alarm=[]):
380 def setup(self, id=1, name='', description='', email=None, alarm=[]):
381
381
382 self.id = str(id)
382 self.id = str(id)
383 self.description = description
383 self.description = description
384 self.email = email
384 self.email = email
385 self.alarm = alarm
385 self.alarm = alarm
386 if name:
386 if name:
387 self.name = '{} ({})'.format(Process.__name__, name)
387 self.name = '{} ({})'.format(Process.__name__, name)
388
388
389 def update(self, **kwargs):
389 def update(self, **kwargs):
390
390
391 for key, value in kwargs.items():
391 for key, value in kwargs.items():
392 setattr(self, key, value)
392 setattr(self, key, value)
393
393
394 def clone(self):
394 def clone(self):
395
395
396 p = Project()
396 p = Project()
397 p.id = self.id
397 p.id = self.id
398 p.name = self.name
398 p.name = self.name
399 p.description = self.description
399 p.description = self.description
400 p.configurations = self.configurations.copy()
400 p.configurations = self.configurations.copy()
401
401
402 return p
402 return p
403
403
404 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
404 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
405
405
406 '''
406 '''
407 '''
407 '''
408
408
409 if id is None:
409 if id is None:
410 idReadUnit = self.getNewId()
410 idReadUnit = self.getNewId()
411 else:
411 else:
412 idReadUnit = str(id)
412 idReadUnit = str(id)
413
413
414 conf = ReadUnitConf()
414 conf = ReadUnitConf()
415 conf.setup(self.id, idReadUnit, name, datatype, self.err_queue, **kwargs)
415 conf.setup(self.id, idReadUnit, name, datatype, self.err_queue, **kwargs)
416 self.configurations[conf.id] = conf
416 self.configurations[conf.id] = conf
417
417
418 return conf
418 return conf
419
419
420 def addProcUnit(self, id=None, inputId='0', datatype=None, name=None):
420 def addProcUnit(self, id=None, inputId='0', datatype=None, name=None):
421
421
422 '''
422 '''
423 '''
423 '''
424
424
425 if id is None:
425 if id is None:
426 idProcUnit = self.getNewId()
426 idProcUnit = self.getNewId()
427 else:
427 else:
428 idProcUnit = id
428 idProcUnit = id
429
429
430 conf = ProcUnitConf()
430 conf = ProcUnitConf()
431 conf.setup(self.id, idProcUnit, name, datatype, inputId, self.err_queue)
431 conf.setup(self.id, idProcUnit, name, datatype, inputId, self.err_queue)
432 self.configurations[conf.id] = conf
432 self.configurations[conf.id] = conf
433
433
434 return conf
434 return conf
435
435
436 def removeProcUnit(self, id):
436 def removeProcUnit(self, id):
437
437
438 if id in self.configurations:
438 if id in self.configurations:
439 self.configurations.pop(id)
439 self.configurations.pop(id)
440
440
441 def getReadUnit(self):
441 def getReadUnit(self):
442
442
443 for obj in list(self.configurations.values()):
443 for obj in list(self.configurations.values()):
444 if obj.ELEMENTNAME == 'ReadUnit':
444 if obj.ELEMENTNAME == 'ReadUnit':
445 return obj
445 return obj
446
446
447 return None
447 return None
448
448
449 def getProcUnit(self, id):
449 def getProcUnit(self, id):
450
450
451 return self.configurations[id]
451 return self.configurations[id]
452
452
453 def getUnits(self):
453 def getUnits(self):
454
454
455 keys = list(self.configurations)
455 keys = list(self.configurations)
456 keys.sort()
456 keys.sort()
457
457
458 for key in keys:
458 for key in keys:
459 yield self.configurations[key]
459 yield self.configurations[key]
460
460
461 def updateUnit(self, id, **kwargs):
461 def updateUnit(self, id, **kwargs):
462
462
463 conf = self.configurations[id].update(**kwargs)
463 conf = self.configurations[id].update(**kwargs)
464
464
465 def makeXml(self):
465 def makeXml(self):
466
466
467 xml = Element('Project')
467 xml = Element('Project')
468 xml.set('id', str(self.id))
468 xml.set('id', str(self.id))
469 xml.set('name', self.name)
469 xml.set('name', self.name)
470 xml.set('description', self.description)
470 xml.set('description', self.description)
471
471
472 for conf in self.configurations.values():
472 for conf in self.configurations.values():
473 conf.makeXml(xml)
473 conf.makeXml(xml)
474
474
475 self.xml = xml
475 self.xml = xml
476
476
477 def writeXml(self, filename=None):
477 def writeXml(self, filename=None):
478
478
479 if filename == None:
479 if filename == None:
480 if self.filename:
480 if self.filename:
481 filename = self.filename
481 filename = self.filename
482 else:
482 else:
483 filename = 'schain.xml'
483 filename = 'schain.xml'
484
484
485 if not filename:
485 if not filename:
486 print('filename has not been defined. Use setFilename(filename) for do it.')
486 print('filename has not been defined. Use setFilename(filename) for do it.')
487 return 0
487 return 0
488
488
489 abs_file = os.path.abspath(filename)
489 abs_file = os.path.abspath(filename)
490
490
491 if not os.access(os.path.dirname(abs_file), os.W_OK):
491 if not os.access(os.path.dirname(abs_file), os.W_OK):
492 print('No write permission on %s' % os.path.dirname(abs_file))
492 print('No write permission on %s' % os.path.dirname(abs_file))
493 return 0
493 return 0
494
494
495 if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
495 if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
496 print('File %s already exists and it could not be overwriten' % abs_file)
496 print('File %s already exists and it could not be overwriten' % abs_file)
497 return 0
497 return 0
498
498
499 self.makeXml()
499 self.makeXml()
500
500
501 ElementTree(self.xml).write(abs_file, method='xml')
501 ElementTree(self.xml).write(abs_file, method='xml')
502
502
503 self.filename = abs_file
503 self.filename = abs_file
504
504
505 return 1
505 return 1
506
506
507 def readXml(self, filename):
507 def readXml(self, filename):
508
508
509 abs_file = os.path.abspath(filename)
509 abs_file = os.path.abspath(filename)
510
510
511 self.configurations = {}
511 self.configurations = {}
512
512
513 try:
513 try:
514 self.xml = ElementTree().parse(abs_file)
514 self.xml = ElementTree().parse(abs_file)
515 except:
515 except:
516 log.error('Error reading %s, verify file format' % filename)
516 log.error('Error reading %s, verify file format' % filename)
517 return 0
517 return 0
518
518
519 self.id = self.xml.get('id')
519 self.id = self.xml.get('id')
520 self.name = self.xml.get('name')
520 self.name = self.xml.get('name')
521 self.description = self.xml.get('description')
521 self.description = self.xml.get('description')
522
522
523 for element in self.xml:
523 for element in self.xml:
524 if element.tag == 'ReadUnit':
524 if element.tag == 'ReadUnit':
525 conf = ReadUnitConf()
525 conf = ReadUnitConf()
526 conf.readXml(element, self.id, self.err_queue)
526 conf.readXml(element, self.id, self.err_queue)
527 self.configurations[conf.id] = conf
527 self.configurations[conf.id] = conf
528 elif element.tag == 'ProcUnit':
528 elif element.tag == 'ProcUnit':
529 conf = ProcUnitConf()
529 conf = ProcUnitConf()
530 input_proc = self.configurations[element.get('inputId')]
530 input_proc = self.configurations[element.get('inputId')]
531 conf.readXml(element, self.id, self.err_queue)
531 conf.readXml(element, self.id, self.err_queue)
532 self.configurations[conf.id] = conf
532 self.configurations[conf.id] = conf
533
533
534 self.filename = abs_file
534 self.filename = abs_file
535
535
536 return 1
536 return 1
537
537
538 def __str__(self):
538 def __str__(self):
539
539
540 text = '\nProject[id=%s, name=%s, description=%s]\n\n' % (
540 text = '\nProject[id=%s, name=%s, description=%s]\n\n' % (
541 self.id,
541 self.id,
542 self.name,
542 self.name,
543 self.description,
543 self.description,
544 )
544 )
545
545
546 for conf in self.configurations.values():
546 for conf in self.configurations.values():
547 text += '{}'.format(conf)
547 text += '{}'.format(conf)
548
548
549 return text
549 return text
550
550
551 def createObjects(self):
551 def createObjects(self):
552
552
553 keys = list(self.configurations.keys())
553 keys = list(self.configurations.keys())
554 keys.sort()
554 keys.sort()
555 for key in keys:
555 for key in keys:
556 conf = self.configurations[key]
556 conf = self.configurations[key]
557 conf.createObjects()
557 conf.createObjects()
558 if conf.inputId is not None:
558 if conf.inputId is not None:
559 conf.object.setInput(self.configurations[conf.inputId].object)
559 if isinstance(conf.inputId, list):
560 conf.object.setInput([self.configurations[x].object for x in conf.inputId])
561 else:
562 conf.object.setInput([self.configurations[conf.inputId].object])
560
563
561 def monitor(self):
564 def monitor(self):
562
565
563 t = Thread(target=self._monitor, args=(self.err_queue, self.ctx))
566 t = Thread(target=self._monitor, args=(self.err_queue, self.ctx))
564 t.start()
567 t.start()
565
568
566 def _monitor(self, queue, ctx):
569 def _monitor(self, queue, ctx):
567
570
568 import socket
571 import socket
569
572
570 procs = 0
573 procs = 0
571 err_msg = ''
574 err_msg = ''
572
575
573 while True:
576 while True:
574 msg = queue.get()
577 msg = queue.get()
575 if '#_start_#' in msg:
578 if '#_start_#' in msg:
576 procs += 1
579 procs += 1
577 elif '#_end_#' in msg:
580 elif '#_end_#' in msg:
578 procs -=1
581 procs -=1
579 else:
582 else:
580 err_msg = msg
583 err_msg = msg
581
584
582 if procs == 0 or 'Traceback' in err_msg:
585 if procs == 0 or 'Traceback' in err_msg:
583 break
586 break
584 time.sleep(0.1)
587 time.sleep(0.1)
585
588
586 if '|' in err_msg:
589 if '|' in err_msg:
587 name, err = err_msg.split('|')
590 name, err = err_msg.split('|')
588 if 'SchainWarning' in err:
591 if 'SchainWarning' in err:
589 log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), name)
592 log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), name)
590 elif 'SchainError' in err:
593 elif 'SchainError' in err:
591 log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), name)
594 log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), name)
592 else:
595 else:
593 log.error(err, name)
596 log.error(err, name)
594 else:
597 else:
595 name, err = self.name, err_msg
598 name, err = self.name, err_msg
596
599
597 time.sleep(1)
600 time.sleep(1)
598
601
599 ctx.term()
602 ctx.term()
600
603
601 message = ''.join(err)
604 message = ''.join(err)
602
605
603 if err_msg:
606 if err_msg:
604 subject = 'SChain v%s: Error running %s\n' % (
607 subject = 'SChain v%s: Error running %s\n' % (
605 schainpy.__version__, self.name)
608 schainpy.__version__, self.name)
606
609
607 subtitle = 'Hostname: %s\n' % socket.gethostbyname(
610 subtitle = 'Hostname: %s\n' % socket.gethostbyname(
608 socket.gethostname())
611 socket.gethostname())
609 subtitle += 'Working directory: %s\n' % os.path.abspath('./')
612 subtitle += 'Working directory: %s\n' % os.path.abspath('./')
610 subtitle += 'Configuration file: %s\n' % self.filename
613 subtitle += 'Configuration file: %s\n' % self.filename
611 subtitle += 'Time: %s\n' % str(datetime.datetime.now())
614 subtitle += 'Time: %s\n' % str(datetime.datetime.now())
612
615
613 readUnitConfObj = self.getReadUnit()
616 readUnitConfObj = self.getReadUnit()
614 if readUnitConfObj:
617 if readUnitConfObj:
615 subtitle += '\nInput parameters:\n'
618 subtitle += '\nInput parameters:\n'
616 subtitle += '[Data path = %s]\n' % readUnitConfObj.parameters['path']
619 subtitle += '[Data path = %s]\n' % readUnitConfObj.parameters['path']
617 subtitle += '[Start date = %s]\n' % readUnitConfObj.parameters['startDate']
620 subtitle += '[Start date = %s]\n' % readUnitConfObj.parameters['startDate']
618 subtitle += '[End date = %s]\n' % readUnitConfObj.parameters['endDate']
621 subtitle += '[End date = %s]\n' % readUnitConfObj.parameters['endDate']
619 subtitle += '[Start time = %s]\n' % readUnitConfObj.parameters['startTime']
622 subtitle += '[Start time = %s]\n' % readUnitConfObj.parameters['startTime']
620 subtitle += '[End time = %s]\n' % readUnitConfObj.parameters['endTime']
623 subtitle += '[End time = %s]\n' % readUnitConfObj.parameters['endTime']
621
624
622 a = Alarm(
625 a = Alarm(
623 modes=self.alarm,
626 modes=self.alarm,
624 email=self.email,
627 email=self.email,
625 message=message,
628 message=message,
626 subject=subject,
629 subject=subject,
627 subtitle=subtitle,
630 subtitle=subtitle,
628 filename=self.filename
631 filename=self.filename
629 )
632 )
630
633
631 a.start()
634 a.start()
632
635
633 def setFilename(self, filename):
636 def setFilename(self, filename):
634
637
635 self.filename = filename
638 self.filename = filename
636
639
637 def runProcs(self):
640 def runProcs(self):
638
641
639 err = False
642 err = False
640 n = len(self.configurations)
643 n = len(self.configurations)
641
644
642 while not err:
645 while not err:
643 for conf in self.getUnits():
646 for conf in self.getUnits():
644 ok = conf.run()
647 ok = conf.run()
645 if ok == 'Error':
648 if ok == 'Error':
646 n -= 1
649 n -= 1
647 continue
650 continue
648 elif not ok:
651 elif not ok:
649 break
652 break
650 if n == 0:
653 if n == 0:
651 err = True
654 err = True
652
655
653 def run(self):
656 def run(self):
654
657
655 log.success('\nStarting Project {} [id={}]'.format(self.name, self.id), tag='')
658 log.success('\nStarting Project {} [id={}]'.format(self.name, self.id), tag='')
656 self.started = True
659 self.started = True
657 self.start_time = time.time()
660 self.start_time = time.time()
658 self.createObjects()
661 self.createObjects()
659 self.runProcs()
662 self.runProcs()
660 log.success('{} Done (Time: {:4.2f}s)'.format(
663 log.success('{} Done (Time: {:4.2f}s)'.format(
661 self.name,
664 self.name,
662 time.time()-self.start_time), '')
665 time.time()-self.start_time), '')
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file
NO CONTENT: modified file
Show file before | Show file after | Hide comments
@@ -1,208 +1,226
1 '''
1 '''
2 Base clases to create Processing units and operations, the MPDecorator
2 Base clases to create Processing units and operations, the MPDecorator
3 must be used in plotting and writing operations to allow to run as an
3 must be used in plotting and writing operations to allow to run as an
4 external process.
4 external process.
5 '''
5 '''
6
6
7 import os
7 import os
8 import inspect
8 import inspect
9 import zmq
9 import zmq
10 import time
10 import time
11 import pickle
11 import pickle
12 import traceback
12 import traceback
13 from threading import Thread
13 from threading import Thread
14 from multiprocessing import Process, Queue
14 from multiprocessing import Process, Queue
15 from schainpy.utils import log
15 from schainpy.utils import log
16
16
17 QUEUE_SIZE = int(os.environ.get('QUEUE_MAX_SIZE', '10'))
17 QUEUE_SIZE = int(os.environ.get('QUEUE_MAX_SIZE', '10'))
18
18
19 class ProcessingUnit(object):
19 class ProcessingUnit(object):
20 '''
20 '''
21 Base class to create Signal Chain Units
21 Base class to create Signal Chain Units
22 '''
22 '''
23
23
24 proc_type = 'processing'
24 proc_type = 'processing'
25
25
26 def __init__(self):
26 def __init__(self):
27
27
28 self.dataIn = None
28 self.dataIn = None
29 self.dataOut = None
29 self.dataOut = None
30 self.isConfig = False
30 self.isConfig = False
31 self.operations = []
31 self.operations = []
32 self.name = 'Test'
33 self.inputs = []
32
34
33 def setInput(self, unit):
35 def setInput(self, unit):
34
36
35 self.dataIn = unit.dataOut
37 attr = 'dataIn'
38 for i, u in enumerate(unit):
39 if i==0:
40 self.dataIn = u.dataOut
41 self.inputs.append('dataIn')
42 else:
43 setattr(self, 'dataIn{}'.format(i), u.dataOut)
44 self.inputs.append('dataIn{}'.format(i))
36
45
37 def getAllowedArgs(self):
46 def getAllowedArgs(self):
38 if hasattr(self, '__attrs__'):
47 if hasattr(self, '__attrs__'):
39 return self.__attrs__
48 return self.__attrs__
40 else:
49 else:
41 return inspect.getargspec(self.run).args
50 return inspect.getargspec(self.run).args
42
51
43 def addOperation(self, conf, operation):
52 def addOperation(self, conf, operation):
44 '''
53 '''
45 '''
54 '''
46
55
47 self.operations.append((operation, conf.type, conf.getKwargs()))
56 self.operations.append((operation, conf.type, conf.getKwargs()))
48
57
49 def getOperationObj(self, objId):
58 def getOperationObj(self, objId):
50
59
51 if objId not in list(self.operations.keys()):
60 if objId not in list(self.operations.keys()):
52 return None
61 return None
53
62
54 return self.operations[objId]
63 return self.operations[objId]
55
64
56 def call(self, **kwargs):
65 def call(self, **kwargs):
57 '''
66 '''
58 '''
67 '''
59
68
60 try:
69 try:
61 if self.dataIn is not None and self.dataIn.flagNoData and not self.dataIn.error:
70 if self.dataIn is not None and self.dataIn.flagNoData and not self.dataIn.error:
62 return self.dataIn.isReady()
71 return self.dataIn.isReady()
63 elif self.dataIn is None or not self.dataIn.error:
72 elif self.dataIn is None or not self.dataIn.error:
64 self.run(**kwargs)
73 self.run(**kwargs)
65 elif self.dataIn.error:
74 elif self.dataIn.error:
66 self.dataOut.error = self.dataIn.error
75 self.dataOut.error = self.dataIn.error
67 self.dataOut.flagNoData = True
76 self.dataOut.flagNoData = True
68 except:
77 except:
69 err = traceback.format_exc()
78 err = traceback.format_exc()
70 if 'SchainWarning' in err:
79 if 'SchainWarning' in err:
71 log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), self.name)
80 log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), self.name)
72 elif 'SchainError' in err:
81 elif 'SchainError' in err:
73 log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), self.name)
82 log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), self.name)
74 else:
83 else:
75 log.error(err, self.name)
84 log.error(err, self.name)
76 self.dataOut.error = True
85 self.dataOut.error = True
77 ##### correcion de la declaracion Out
86 ##### correcion de la declaracion Out
78 for op, optype, opkwargs in self.operations:
87 for op, optype, opkwargs in self.operations:
79 aux = self.dataOut.copy()
88 aux = self.dataOut.copy()
80 if optype == 'other' and not self.dataOut.flagNoData:
89 if optype == 'other' and not self.dataOut.flagNoData:
81 self.dataOut = op.run(self.dataOut, **opkwargs)
90 self.dataOut = op.run(self.dataOut, **opkwargs)
82 elif optype == 'external' and not self.dataOut.flagNoData:
91 elif optype == 'external' and not self.dataOut.flagNoData:
83 #op.queue.put(self.dataOut)
92 #op.queue.put(self.dataOut)
84 op.queue.put(aux)
93 op.queue.put(aux)
85 elif optype == 'external' and self.dataOut.error:
94 elif optype == 'external' and self.dataOut.error:
86 #op.queue.put(self.dataOut)
95 #op.queue.put(self.dataOut)
87 op.queue.put(aux)
96 op.queue.put(aux)
88
97
89 return 'Error' if self.dataOut.error else self.dataOut.isReady()
98 try:
99 if self.dataOut.runNextUnit:
100 runNextUnit = self.dataOut.runNextUnit
101
102 else:
103 runNextUnit = self.dataOut.isReady()
104 except:
105 runNextUnit = self.dataOut.isReady()
106
107 return 'Error' if self.dataOut.error else runNextUnit
90
108
91 def setup(self):
109 def setup(self):
92
110
93 raise NotImplementedError
111 raise NotImplementedError
94
112
95 def run(self):
113 def run(self):
96
114
97 raise NotImplementedError
115 raise NotImplementedError
98
116
99 def close(self):
117 def close(self):
100
118
101 return
119 return
102
120
103
121
104 class Operation(object):
122 class Operation(object):
105
123
106 '''
124 '''
107 '''
125 '''
108
126
109 proc_type = 'operation'
127 proc_type = 'operation'
110
128
111 def __init__(self):
129 def __init__(self):
112
130
113 self.id = None
131 self.id = None
114 self.isConfig = False
132 self.isConfig = False
115
133
116 if not hasattr(self, 'name'):
134 if not hasattr(self, 'name'):
117 self.name = self.__class__.__name__
135 self.name = self.__class__.__name__
118
136
119 def getAllowedArgs(self):
137 def getAllowedArgs(self):
120 if hasattr(self, '__attrs__'):
138 if hasattr(self, '__attrs__'):
121 return self.__attrs__
139 return self.__attrs__
122 else:
140 else:
123 return inspect.getargspec(self.run).args
141 return inspect.getargspec(self.run).args
124
142
125 def setup(self):
143 def setup(self):
126
144
127 self.isConfig = True
145 self.isConfig = True
128
146
129 raise NotImplementedError
147 raise NotImplementedError
130
148
131 def run(self, dataIn, **kwargs):
149 def run(self, dataIn, **kwargs):
132 """
150 """
133 Realiza las operaciones necesarias sobre la dataIn.data y actualiza los
151 Realiza las operaciones necesarias sobre la dataIn.data y actualiza los
134 atributos del objeto dataIn.
152 atributos del objeto dataIn.
135
153
136 Input:
154 Input:
137
155
138 dataIn : objeto del tipo JROData
156 dataIn : objeto del tipo JROData
139
157
140 Return:
158 Return:
141
159
142 None
160 None
143
161
144 Affected:
162 Affected:
145 __buffer : buffer de recepcion de datos.
163 __buffer : buffer de recepcion de datos.
146
164
147 """
165 """
148 if not self.isConfig:
166 if not self.isConfig:
149 self.setup(**kwargs)
167 self.setup(**kwargs)
150
168
151 raise NotImplementedError
169 raise NotImplementedError
152
170
153 def close(self):
171 def close(self):
154
172
155 return
173 return
156
174
157
175
158 def MPDecorator(BaseClass):
176 def MPDecorator(BaseClass):
159 """
177 """
160 Multiprocessing class decorator
178 Multiprocessing class decorator
161
179
162 This function add multiprocessing features to a BaseClass.
180 This function add multiprocessing features to a BaseClass.
163 """
181 """
164
182
165 class MPClass(BaseClass, Process):
183 class MPClass(BaseClass, Process):
166
184
167 def __init__(self, *args, **kwargs):
185 def __init__(self, *args, **kwargs):
168 super(MPClass, self).__init__()
186 super(MPClass, self).__init__()
169 Process.__init__(self)
187 Process.__init__(self)
170
188
171 self.args = args
189 self.args = args
172 self.kwargs = kwargs
190 self.kwargs = kwargs
173 self.t = time.time()
191 self.t = time.time()
174 self.op_type = 'external'
192 self.op_type = 'external'
175 self.name = BaseClass.__name__
193 self.name = BaseClass.__name__
176 self.__doc__ = BaseClass.__doc__
194 self.__doc__ = BaseClass.__doc__
177
195
178 if 'plot' in self.name.lower() and not self.name.endswith('_'):
196 if 'plot' in self.name.lower() and not self.name.endswith('_'):
179 self.name = '{}{}'.format(self.CODE.upper(), 'Plot')
197 self.name = '{}{}'.format(self.CODE.upper(), 'Plot')
180
198
181 self.start_time = time.time()
199 self.start_time = time.time()
182 self.err_queue = args[3]
200 self.err_queue = args[3]
183 self.queue = Queue(maxsize=QUEUE_SIZE)
201 self.queue = Queue(maxsize=QUEUE_SIZE)
184 self.myrun = BaseClass.run
202 self.myrun = BaseClass.run
185
203
186 def run(self):
204 def run(self):
187
205
188 while True:
206 while True:
189
207
190 dataOut = self.queue.get()
208 dataOut = self.queue.get()
191
209
192 if not dataOut.error:
210 if not dataOut.error:
193 try:
211 try:
194 BaseClass.run(self, dataOut, **self.kwargs)
212 BaseClass.run(self, dataOut, **self.kwargs)
195 except:
213 except:
196 err = traceback.format_exc()
214 err = traceback.format_exc()
197 log.error(err, self.name)
215 log.error(err, self.name)
198 else:
216 else:
199 break
217 break
200
218
201 self.close()
219 self.close()
202
220
203 def close(self):
221 def close(self):
204
222
205 BaseClass.close(self)
223 BaseClass.close(self)
206 log.success('Done...(Time:{:4.2f} secs)'.format(time.time()-self.start_time), self.name)
224 log.success('Done...(Time:{:4.2f} secs)'.format(time.time()-self.start_time), self.name)
207
225
208 return MPClass
226 return MPClass
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file
NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
Show file before | Show file after | Hide comments
@@ -1,1862 +1,1860
1 import sys
1 import sys
2 import numpy,math
2 import numpy,math
3 from scipy import interpolate
3 from scipy import interpolate
4 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
4 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
5 from schainpy.model.data.jrodata import Voltage,hildebrand_sekhon
5 from schainpy.model.data.jrodata import Voltage,hildebrand_sekhon
6 from schainpy.utils import log
6 from schainpy.utils import log
7 from time import time
7 from time import time
8
8
9
9
10
10
11 class VoltageProc(ProcessingUnit):
11 class VoltageProc(ProcessingUnit):
12
12
13 def __init__(self):
13 def __init__(self):
14
14
15 ProcessingUnit.__init__(self)
15 ProcessingUnit.__init__(self)
16
16
17 self.dataOut = Voltage()
17 self.dataOut = Voltage()
18 self.flip = 1
18 self.flip = 1
19 self.setupReq = False
19 self.setupReq = False
20
20
21 def run(self):
21 def run(self):
22
22
23 if self.dataIn.type == 'AMISR':
23 if self.dataIn.type == 'AMISR':
24 self.__updateObjFromAmisrInput()
24 self.__updateObjFromAmisrInput()
25
25
26 if self.dataIn.type == 'Voltage':
26 if self.dataIn.type == 'Voltage':
27 self.dataOut.copy(self.dataIn)
27 self.dataOut.copy(self.dataIn)
28
28
29 def __updateObjFromAmisrInput(self):
29 def __updateObjFromAmisrInput(self):
30
30
31 self.dataOut.timeZone = self.dataIn.timeZone
31 self.dataOut.timeZone = self.dataIn.timeZone
32 self.dataOut.dstFlag = self.dataIn.dstFlag
32 self.dataOut.dstFlag = self.dataIn.dstFlag
33 self.dataOut.errorCount = self.dataIn.errorCount
33 self.dataOut.errorCount = self.dataIn.errorCount
34 self.dataOut.useLocalTime = self.dataIn.useLocalTime
34 self.dataOut.useLocalTime = self.dataIn.useLocalTime
35
35
36 self.dataOut.flagNoData = self.dataIn.flagNoData
36 self.dataOut.flagNoData = self.dataIn.flagNoData
37 self.dataOut.data = self.dataIn.data
37 self.dataOut.data = self.dataIn.data
38 self.dataOut.utctime = self.dataIn.utctime
38 self.dataOut.utctime = self.dataIn.utctime
39 self.dataOut.channelList = self.dataIn.channelList
39 self.dataOut.channelList = self.dataIn.channelList
40 #self.dataOut.timeInterval = self.dataIn.timeInterval
40 #self.dataOut.timeInterval = self.dataIn.timeInterval
41 self.dataOut.heightList = self.dataIn.heightList
41 self.dataOut.heightList = self.dataIn.heightList
42 self.dataOut.nProfiles = self.dataIn.nProfiles
42 self.dataOut.nProfiles = self.dataIn.nProfiles
43
43
44 self.dataOut.nCohInt = self.dataIn.nCohInt
44 self.dataOut.nCohInt = self.dataIn.nCohInt
45 self.dataOut.ippSeconds = self.dataIn.ippSeconds
45 self.dataOut.ippSeconds = self.dataIn.ippSeconds
46 self.dataOut.frequency = self.dataIn.frequency
46 self.dataOut.frequency = self.dataIn.frequency
47
47
48 self.dataOut.azimuth = self.dataIn.azimuth
48 self.dataOut.azimuth = self.dataIn.azimuth
49 self.dataOut.zenith = self.dataIn.zenith
49 self.dataOut.zenith = self.dataIn.zenith
50
50
51 self.dataOut.beam.codeList = self.dataIn.beam.codeList
51 self.dataOut.beam.codeList = self.dataIn.beam.codeList
52 self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
52 self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
53 self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
53 self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
54
54
55
55
56 class selectChannels(Operation):
56 class selectChannels(Operation):
57
57
58 def run(self, dataOut, channelList):
58 def run(self, dataOut, channelList):
59
59
60 channelIndexList = []
60 channelIndexList = []
61 self.dataOut = dataOut
61 self.dataOut = dataOut
62 for channel in channelList:
62 for channel in channelList:
63 if channel not in self.dataOut.channelList:
63 if channel not in self.dataOut.channelList:
64 raise ValueError("Channel %d is not in %s" %(channel, str(self.dataOut.channelList)))
64 raise ValueError("Channel %d is not in %s" %(channel, str(self.dataOut.channelList)))
65
65
66 index = self.dataOut.channelList.index(channel)
66 index = self.dataOut.channelList.index(channel)
67 channelIndexList.append(index)
67 channelIndexList.append(index)
68 self.selectChannelsByIndex(channelIndexList)
68 self.selectChannelsByIndex(channelIndexList)
69 return self.dataOut
69 return self.dataOut
70
70
71 def selectChannelsByIndex(self, channelIndexList):
71 def selectChannelsByIndex(self, channelIndexList):
72 """
72 """
73 Selecciona un bloque de datos en base a canales segun el channelIndexList
73 Selecciona un bloque de datos en base a canales segun el channelIndexList
74
74
75 Input:
75 Input:
76 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
76 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
77
77
78 Affected:
78 Affected:
79 self.dataOut.data
79 self.dataOut.data
80 self.dataOut.channelIndexList
80 self.dataOut.channelIndexList
81 self.dataOut.nChannels
81 self.dataOut.nChannels
82 self.dataOut.m_ProcessingHeader.totalSpectra
82 self.dataOut.m_ProcessingHeader.totalSpectra
83 self.dataOut.systemHeaderObj.numChannels
83 self.dataOut.systemHeaderObj.numChannels
84 self.dataOut.m_ProcessingHeader.blockSize
84 self.dataOut.m_ProcessingHeader.blockSize
85
85
86 Return:
86 Return:
87 None
87 None
88 """
88 """
89
89
90 for channelIndex in channelIndexList:
90 for channelIndex in channelIndexList:
91 if channelIndex not in self.dataOut.channelIndexList:
91 if channelIndex not in self.dataOut.channelIndexList:
92 raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
92 raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
93
93
94 if self.dataOut.type == 'Voltage':
94 if self.dataOut.type == 'Voltage':
95 if self.dataOut.flagDataAsBlock:
95 if self.dataOut.flagDataAsBlock:
96 """
96 """
97 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
97 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
98 """
98 """
99 data = self.dataOut.data[channelIndexList,:,:]
99 data = self.dataOut.data[channelIndexList,:,:]
100 else:
100 else:
101 data = self.dataOut.data[channelIndexList,:]
101 data = self.dataOut.data[channelIndexList,:]
102
102
103 self.dataOut.data = data
103 self.dataOut.data = data
104 # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
104 # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
105 self.dataOut.channelList = range(len(channelIndexList))
105 self.dataOut.channelList = range(len(channelIndexList))
106
106
107 elif self.dataOut.type == 'Spectra':
107 elif self.dataOut.type == 'Spectra':
108 data_spc = self.dataOut.data_spc[channelIndexList, :]
108 data_spc = self.dataOut.data_spc[channelIndexList, :]
109 data_dc = self.dataOut.data_dc[channelIndexList, :]
109 data_dc = self.dataOut.data_dc[channelIndexList, :]
110
110
111 self.dataOut.data_spc = data_spc
111 self.dataOut.data_spc = data_spc
112 self.dataOut.data_dc = data_dc
112 self.dataOut.data_dc = data_dc
113
113
114 # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
114 # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
115 self.dataOut.channelList = range(len(channelIndexList))
115 self.dataOut.channelList = range(len(channelIndexList))
116 self.__selectPairsByChannel(channelIndexList)
116 self.__selectPairsByChannel(channelIndexList)
117
117
118 return 1
118 return 1
119
119
120 def __selectPairsByChannel(self, channelList=None):
120 def __selectPairsByChannel(self, channelList=None):
121
121
122 if channelList == None:
122 if channelList == None:
123 return
123 return
124
124
125 pairsIndexListSelected = []
125 pairsIndexListSelected = []
126 for pairIndex in self.dataOut.pairsIndexList:
126 for pairIndex in self.dataOut.pairsIndexList:
127 # First pair
127 # First pair
128 if self.dataOut.pairsList[pairIndex][0] not in channelList:
128 if self.dataOut.pairsList[pairIndex][0] not in channelList:
129 continue
129 continue
130 # Second pair
130 # Second pair
131 if self.dataOut.pairsList[pairIndex][1] not in channelList:
131 if self.dataOut.pairsList[pairIndex][1] not in channelList:
132 continue
132 continue
133
133
134 pairsIndexListSelected.append(pairIndex)
134 pairsIndexListSelected.append(pairIndex)
135
135
136 if not pairsIndexListSelected:
136 if not pairsIndexListSelected:
137 self.dataOut.data_cspc = None
137 self.dataOut.data_cspc = None
138 self.dataOut.pairsList = []
138 self.dataOut.pairsList = []
139 return
139 return
140
140
141 self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
141 self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
142 self.dataOut.pairsList = [self.dataOut.pairsList[i]
142 self.dataOut.pairsList = [self.dataOut.pairsList[i]
143 for i in pairsIndexListSelected]
143 for i in pairsIndexListSelected]
144
144
145 return
145 return
146
146
147 class selectHeights(Operation):
147 class selectHeights(Operation):
148
148
149 def run(self, dataOut, minHei=None, maxHei=None, minIndex=None, maxIndex=None):
149 def run(self, dataOut, minHei=None, maxHei=None, minIndex=None, maxIndex=None):
150 """
150 """
151 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
151 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
152 minHei <= height <= maxHei
152 minHei <= height <= maxHei
153
153
154 Input:
154 Input:
155 minHei : valor minimo de altura a considerar
155 minHei : valor minimo de altura a considerar
156 maxHei : valor maximo de altura a considerar
156 maxHei : valor maximo de altura a considerar
157
157
158 Affected:
158 Affected:
159 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
159 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
160
160
161 Return:
161 Return:
162 1 si el metodo se ejecuto con exito caso contrario devuelve 0
162 1 si el metodo se ejecuto con exito caso contrario devuelve 0
163 """
163 """
164
164
165 self.dataOut = dataOut
165 self.dataOut = dataOut
166
166
167 if minHei and maxHei:
167 if minHei and maxHei:
168
168
169 if (minHei < self.dataOut.heightList[0]):
169 if (minHei < self.dataOut.heightList[0]):
170 minHei = self.dataOut.heightList[0]
170 minHei = self.dataOut.heightList[0]
171
171
172 if (maxHei > self.dataOut.heightList[-1]):
172 if (maxHei > self.dataOut.heightList[-1]):
173 maxHei = self.dataOut.heightList[-1]
173 maxHei = self.dataOut.heightList[-1]
174
174
175 minIndex = 0
175 minIndex = 0
176 maxIndex = 0
176 maxIndex = 0
177 heights = self.dataOut.heightList
177 heights = self.dataOut.heightList
178
178
179 inda = numpy.where(heights >= minHei)
179 inda = numpy.where(heights >= minHei)
180 indb = numpy.where(heights <= maxHei)
180 indb = numpy.where(heights <= maxHei)
181
181
182 try:
182 try:
183 minIndex = inda[0][0]
183 minIndex = inda[0][0]
184 except:
184 except:
185 minIndex = 0
185 minIndex = 0
186
186
187 try:
187 try:
188 maxIndex = indb[0][-1]
188 maxIndex = indb[0][-1]
189 except:
189 except:
190 maxIndex = len(heights)
190 maxIndex = len(heights)
191
191
192 self.selectHeightsByIndex(minIndex, maxIndex)
192 self.selectHeightsByIndex(minIndex, maxIndex)
193
193
194 return self.dataOut
194 return self.dataOut
195
195
196 def selectHeightsByIndex(self, minIndex, maxIndex):
196 def selectHeightsByIndex(self, minIndex, maxIndex):
197 """
197 """
198 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
198 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
199 minIndex <= index <= maxIndex
199 minIndex <= index <= maxIndex
200
200
201 Input:
201 Input:
202 minIndex : valor de indice minimo de altura a considerar
202 minIndex : valor de indice minimo de altura a considerar
203 maxIndex : valor de indice maximo de altura a considerar
203 maxIndex : valor de indice maximo de altura a considerar
204
204
205 Affected:
205 Affected:
206 self.dataOut.data
206 self.dataOut.data
207 self.dataOut.heightList
207 self.dataOut.heightList
208
208
209 Return:
209 Return:
210 1 si el metodo se ejecuto con exito caso contrario devuelve 0
210 1 si el metodo se ejecuto con exito caso contrario devuelve 0
211 """
211 """
212
212
213 if self.dataOut.type == 'Voltage':
213 if self.dataOut.type == 'Voltage':
214 if (minIndex < 0) or (minIndex > maxIndex):
214 if (minIndex < 0) or (minIndex > maxIndex):
215 raise ValueError("Height index range (%d,%d) is not valid" % (minIndex, maxIndex))
215 raise ValueError("Height index range (%d,%d) is not valid" % (minIndex, maxIndex))
216
216
217 if (maxIndex >= self.dataOut.nHeights):
217 if (maxIndex >= self.dataOut.nHeights):
218 maxIndex = self.dataOut.nHeights
218 maxIndex = self.dataOut.nHeights
219 #print("shapeeee",self.dataOut.data.shape)
219 #print("shapeeee",self.dataOut.data.shape)
220 #voltage
220 #voltage
221 if self.dataOut.flagDataAsBlock:
221 if self.dataOut.flagDataAsBlock:
222 """
222 """
223 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
223 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
224 """
224 """
225 data = self.dataOut.data[:,:, minIndex:maxIndex]
225 data = self.dataOut.data[:,:, minIndex:maxIndex]
226 else:
226 else:
227 data = self.dataOut.data[:, minIndex:maxIndex]
227 data = self.dataOut.data[:, minIndex:maxIndex]
228
228
229 # firstHeight = self.dataOut.heightList[minIndex]
229 # firstHeight = self.dataOut.heightList[minIndex]
230
230
231 self.dataOut.data = data
231 self.dataOut.data = data
232 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
232 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
233
233
234 if self.dataOut.nHeights <= 1:
234 if self.dataOut.nHeights <= 1:
235 raise ValueError("selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights))
235 raise ValueError("selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights))
236 elif self.dataOut.type == 'Spectra':
236 elif self.dataOut.type == 'Spectra':
237 if (minIndex < 0) or (minIndex > maxIndex):
237 if (minIndex < 0) or (minIndex > maxIndex):
238 raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (
238 raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (
239 minIndex, maxIndex))
239 minIndex, maxIndex))
240
240
241 if (maxIndex >= self.dataOut.nHeights):
241 if (maxIndex >= self.dataOut.nHeights):
242 maxIndex = self.dataOut.nHeights - 1
242 maxIndex = self.dataOut.nHeights - 1
243
243
244 # Spectra
244 # Spectra
245 data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
245 data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
246
246
247 data_cspc = None
247 data_cspc = None
248 if self.dataOut.data_cspc is not None:
248 if self.dataOut.data_cspc is not None:
249 data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
249 data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
250
250
251 data_dc = None
251 data_dc = None
252 if self.dataOut.data_dc is not None:
252 if self.dataOut.data_dc is not None:
253 data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
253 data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
254
254
255 self.dataOut.data_spc = data_spc
255 self.dataOut.data_spc = data_spc
256 self.dataOut.data_cspc = data_cspc
256 self.dataOut.data_cspc = data_cspc
257 self.dataOut.data_dc = data_dc
257 self.dataOut.data_dc = data_dc
258
258
259 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
259 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
260
260
261 return 1
261 return 1
262
262
263
263
264 class filterByHeights(Operation):
264 class filterByHeights(Operation):
265
265
266 def run(self, dataOut, window):
266 def run(self, dataOut, window):
267
267
268 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
268 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
269
269
270 if window == None:
270 if window == None:
271 window = (dataOut.radarControllerHeaderObj.txA/dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
271 window = (dataOut.radarControllerHeaderObj.txA/dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
272
272
273 newdelta = deltaHeight * window
273 newdelta = deltaHeight * window
274 r = dataOut.nHeights % window
274 r = dataOut.nHeights % window
275 newheights = (dataOut.nHeights-r)/window
275 newheights = (dataOut.nHeights-r)/window
276
276
277 if newheights <= 1:
277 if newheights <= 1:
278 raise ValueError("filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(dataOut.nHeights, window))
278 raise ValueError("filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(dataOut.nHeights, window))
279
279
280 if dataOut.flagDataAsBlock:
280 if dataOut.flagDataAsBlock:
281 """
281 """
282 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
282 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
283 """
283 """
284 buffer = dataOut.data[:, :, 0:int(dataOut.nHeights-r)]
284 buffer = dataOut.data[:, :, 0:int(dataOut.nHeights-r)]
285 buffer = buffer.reshape(dataOut.nChannels, dataOut.nProfiles, int(dataOut.nHeights/window), window)
285 buffer = buffer.reshape(dataOut.nChannels, dataOut.nProfiles, int(dataOut.nHeights/window), window)
286 buffer = numpy.sum(buffer,3)
286 buffer = numpy.sum(buffer,3)
287
287
288 else:
288 else:
289 buffer = dataOut.data[:,0:int(dataOut.nHeights-r)]
289 buffer = dataOut.data[:,0:int(dataOut.nHeights-r)]
290 buffer = buffer.reshape(dataOut.nChannels,int(dataOut.nHeights/window),int(window))
290 buffer = buffer.reshape(dataOut.nChannels,int(dataOut.nHeights/window),int(window))
291 buffer = numpy.sum(buffer,2)
291 buffer = numpy.sum(buffer,2)
292
292
293 dataOut.data = buffer
293 dataOut.data = buffer
294 dataOut.heightList = dataOut.heightList[0] + numpy.arange( newheights )*newdelta
294 dataOut.heightList = dataOut.heightList[0] + numpy.arange( newheights )*newdelta
295 dataOut.windowOfFilter = window
295 dataOut.windowOfFilter = window
296
296
297 return dataOut
297 return dataOut
298
298
299
299
300 class setH0(Operation):
300 class setH0(Operation):
301
301
302 def run(self, dataOut, h0, deltaHeight = None):
302 def run(self, dataOut, h0, deltaHeight = None):
303
303
304 if not deltaHeight:
304 if not deltaHeight:
305 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
305 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
306
306
307 nHeights = dataOut.nHeights
307 nHeights = dataOut.nHeights
308
308
309 newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
309 newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
310
310
311 dataOut.heightList = newHeiRange
311 dataOut.heightList = newHeiRange
312
312
313 return dataOut
313 return dataOut
314
314
315
315
316 class deFlip(Operation):
316 class deFlip(Operation):
317
317
318 def run(self, dataOut, channelList = []):
318 def run(self, dataOut, channelList = []):
319
319
320 data = dataOut.data.copy()
320 data = dataOut.data.copy()
321
321
322 if dataOut.flagDataAsBlock:
322 if dataOut.flagDataAsBlock:
323 flip = self.flip
323 flip = self.flip
324 profileList = list(range(dataOut.nProfiles))
324 profileList = list(range(dataOut.nProfiles))
325
325
326 if not channelList:
326 if not channelList:
327 for thisProfile in profileList:
327 for thisProfile in profileList:
328 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
328 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
329 flip *= -1.0
329 flip *= -1.0
330 else:
330 else:
331 for thisChannel in channelList:
331 for thisChannel in channelList:
332 if thisChannel not in dataOut.channelList:
332 if thisChannel not in dataOut.channelList:
333 continue
333 continue
334
334
335 for thisProfile in profileList:
335 for thisProfile in profileList:
336 data[thisChannel,thisProfile,:] = data[thisChannel,thisProfile,:]*flip
336 data[thisChannel,thisProfile,:] = data[thisChannel,thisProfile,:]*flip
337 flip *= -1.0
337 flip *= -1.0
338
338
339 self.flip = flip
339 self.flip = flip
340
340
341 else:
341 else:
342 if not channelList:
342 if not channelList:
343 data[:,:] = data[:,:]*self.flip
343 data[:,:] = data[:,:]*self.flip
344 else:
344 else:
345 for thisChannel in channelList:
345 for thisChannel in channelList:
346 if thisChannel not in dataOut.channelList:
346 if thisChannel not in dataOut.channelList:
347 continue
347 continue
348
348
349 data[thisChannel,:] = data[thisChannel,:]*self.flip
349 data[thisChannel,:] = data[thisChannel,:]*self.flip
350
350
351 self.flip *= -1.
351 self.flip *= -1.
352
352
353 dataOut.data = data
353 dataOut.data = data
354
354
355 return dataOut
355 return dataOut
356
356
357
357
358 class setAttribute(Operation):
358 class setAttribute(Operation):
359 '''
359 '''
360 Set an arbitrary attribute(s) to dataOut
360 Set an arbitrary attribute(s) to dataOut
361 '''
361 '''
362
362
363 def __init__(self):
363 def __init__(self):
364
364
365 Operation.__init__(self)
365 Operation.__init__(self)
366 self._ready = False
366 self._ready = False
367
367
368 def run(self, dataOut, **kwargs):
368 def run(self, dataOut, **kwargs):
369
369
370 for key, value in kwargs.items():
370 for key, value in kwargs.items():
371 setattr(dataOut, key, value)
371 setattr(dataOut, key, value)
372
372
373 return dataOut
373 return dataOut
374
374
375
375
376 @MPDecorator
376 @MPDecorator
377 class printAttribute(Operation):
377 class printAttribute(Operation):
378 '''
378 '''
379 Print an arbitrary attribute of dataOut
379 Print an arbitrary attribute of dataOut
380 '''
380 '''
381
381
382 def __init__(self):
382 def __init__(self):
383
383
384 Operation.__init__(self)
384 Operation.__init__(self)
385
385
386 def run(self, dataOut, attributes):
386 def run(self, dataOut, attributes):
387
387
388 if isinstance(attributes, str):
388 if isinstance(attributes, str):
389 attributes = [attributes]
389 attributes = [attributes]
390 for attr in attributes:
390 for attr in attributes:
391 if hasattr(dataOut, attr):
391 if hasattr(dataOut, attr):
392 log.log(getattr(dataOut, attr), attr)
392 log.log(getattr(dataOut, attr), attr)
393
393
394
394
395 class interpolateHeights(Operation):
395 class interpolateHeights(Operation):
396
396
397 def run(self, dataOut, topLim, botLim):
397 def run(self, dataOut, topLim, botLim):
398 #69 al 72 para julia
398 #69 al 72 para julia
399 #82-84 para meteoros
399 #82-84 para meteoros
400 if len(numpy.shape(dataOut.data))==2:
400 if len(numpy.shape(dataOut.data))==2:
401 sampInterp = (dataOut.data[:,botLim-1] + dataOut.data[:,topLim+1])/2
401 sampInterp = (dataOut.data[:,botLim-1] + dataOut.data[:,topLim+1])/2
402 sampInterp = numpy.transpose(numpy.tile(sampInterp,(topLim-botLim + 1,1)))
402 sampInterp = numpy.transpose(numpy.tile(sampInterp,(topLim-botLim + 1,1)))
403 #dataOut.data[:,botLim:limSup+1] = sampInterp
403 #dataOut.data[:,botLim:limSup+1] = sampInterp
404 dataOut.data[:,botLim:topLim+1] = sampInterp
404 dataOut.data[:,botLim:topLim+1] = sampInterp
405 else:
405 else:
406 nHeights = dataOut.data.shape[2]
406 nHeights = dataOut.data.shape[2]
407 x = numpy.hstack((numpy.arange(botLim),numpy.arange(topLim+1,nHeights)))
407 x = numpy.hstack((numpy.arange(botLim),numpy.arange(topLim+1,nHeights)))
408 y = dataOut.data[:,:,list(range(botLim))+list(range(topLim+1,nHeights))]
408 y = dataOut.data[:,:,list(range(botLim))+list(range(topLim+1,nHeights))]
409 f = interpolate.interp1d(x, y, axis = 2)
409 f = interpolate.interp1d(x, y, axis = 2)
410 xnew = numpy.arange(botLim,topLim+1)
410 xnew = numpy.arange(botLim,topLim+1)
411 ynew = f(xnew)
411 ynew = f(xnew)
412 dataOut.data[:,:,botLim:topLim+1] = ynew
412 dataOut.data[:,:,botLim:topLim+1] = ynew
413
413
414 return dataOut
414 return dataOut
415
415
416
416
417 class CohInt(Operation):
417 class CohInt(Operation):
418
418
419 isConfig = False
419 isConfig = False
420 __profIndex = 0
420 __profIndex = 0
421 __byTime = False
421 __byTime = False
422 __initime = None
422 __initime = None
423 __lastdatatime = None
423 __lastdatatime = None
424 __integrationtime = None
424 __integrationtime = None
425 __buffer = None
425 __buffer = None
426 __bufferStride = []
426 __bufferStride = []
427 __dataReady = False
427 __dataReady = False
428 __profIndexStride = 0
428 __profIndexStride = 0
429 __dataToPutStride = False
429 __dataToPutStride = False
430 n = None
430 n = None
431
431
432 def __init__(self, **kwargs):
432 def __init__(self, **kwargs):
433
433
434 Operation.__init__(self, **kwargs)
434 Operation.__init__(self, **kwargs)
435
435
436 def setup(self, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False):
436 def setup(self, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False):
437 """
437 """
438 Set the parameters of the integration class.
438 Set the parameters of the integration class.
439
439
440 Inputs:
440 Inputs:
441
441
442 n : Number of coherent integrations
442 n : Number of coherent integrations
443 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
443 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
444 overlapping :
444 overlapping :
445 """
445 """
446
446
447 self.__initime = None
447 self.__initime = None
448 self.__lastdatatime = 0
448 self.__lastdatatime = 0
449 self.__buffer = None
449 self.__buffer = None
450 self.__dataReady = False
450 self.__dataReady = False
451 self.byblock = byblock
451 self.byblock = byblock
452 self.stride = stride
452 self.stride = stride
453
453
454 if n == None and timeInterval == None:
454 if n == None and timeInterval == None:
455 raise ValueError("n or timeInterval should be specified ...")
455 raise ValueError("n or timeInterval should be specified ...")
456
456
457 if n != None:
457 if n != None:
458 self.n = n
458 self.n = n
459 self.__byTime = False
459 self.__byTime = False
460 else:
460 else:
461 self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
461 self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
462 self.n = 9999
462 self.n = 9999
463 self.__byTime = True
463 self.__byTime = True
464
464
465 if overlapping:
465 if overlapping:
466 self.__withOverlapping = True
466 self.__withOverlapping = True
467 self.__buffer = None
467 self.__buffer = None
468 else:
468 else:
469 self.__withOverlapping = False
469 self.__withOverlapping = False
470 self.__buffer = 0
470 self.__buffer = 0
471
471
472 self.__profIndex = 0
472 self.__profIndex = 0
473
473
474 def putData(self, data):
474 def putData(self, data):
475
475
476 """
476 """
477 Add a profile to the __buffer and increase in one the __profileIndex
477 Add a profile to the __buffer and increase in one the __profileIndex
478
478
479 """
479 """
480
480
481 if not self.__withOverlapping:
481 if not self.__withOverlapping:
482 self.__buffer += data.copy()
482 self.__buffer += data.copy()
483 self.__profIndex += 1
483 self.__profIndex += 1
484 return
484 return
485
485
486 #Overlapping data
486 #Overlapping data
487 nChannels, nHeis = data.shape
487 nChannels, nHeis = data.shape
488 data = numpy.reshape(data, (1, nChannels, nHeis))
488 data = numpy.reshape(data, (1, nChannels, nHeis))
489
489
490 #If the buffer is empty then it takes the data value
490 #If the buffer is empty then it takes the data value
491 if self.__buffer is None:
491 if self.__buffer is None:
492 self.__buffer = data
492 self.__buffer = data
493 self.__profIndex += 1
493 self.__profIndex += 1
494 return
494 return
495
495
496 #If the buffer length is lower than n then stakcing the data value
496 #If the buffer length is lower than n then stakcing the data value
497 if self.__profIndex < self.n:
497 if self.__profIndex < self.n:
498 self.__buffer = numpy.vstack((self.__buffer, data))
498 self.__buffer = numpy.vstack((self.__buffer, data))
499 self.__profIndex += 1
499 self.__profIndex += 1
500 return
500 return
501
501
502 #If the buffer length is equal to n then replacing the last buffer value with the data value
502 #If the buffer length is equal to n then replacing the last buffer value with the data value
503 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
503 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
504 self.__buffer[self.n-1] = data
504 self.__buffer[self.n-1] = data
505 self.__profIndex = self.n
505 self.__profIndex = self.n
506 return
506 return
507
507
508
508
509 def pushData(self):
509 def pushData(self):
510 """
510 """
511 Return the sum of the last profiles and the profiles used in the sum.
511 Return the sum of the last profiles and the profiles used in the sum.
512
512
513 Affected:
513 Affected:
514
514
515 self.__profileIndex
515 self.__profileIndex
516
516
517 """
517 """
518
518
519 if not self.__withOverlapping:
519 if not self.__withOverlapping:
520 data = self.__buffer
520 data = self.__buffer
521 n = self.__profIndex
521 n = self.__profIndex
522
522
523 self.__buffer = 0
523 self.__buffer = 0
524 self.__profIndex = 0
524 self.__profIndex = 0
525
525
526 return data, n
526 return data, n
527
527
528 #Integration with Overlapping
528 #Integration with Overlapping
529 data = numpy.sum(self.__buffer, axis=0)
529 data = numpy.sum(self.__buffer, axis=0)
530 # print data
530 # print data
531 # raise
531 # raise
532 n = self.__profIndex
532 n = self.__profIndex
533
533
534 return data, n
534 return data, n
535
535
536 def byProfiles(self, data):
536 def byProfiles(self, data):
537
537
538 self.__dataReady = False
538 self.__dataReady = False
539 avgdata = None
539 avgdata = None
540 # n = None
540 # n = None
541 # print data
541 # print data
542 # raise
542 # raise
543 self.putData(data)
543 self.putData(data)
544
544
545 if self.__profIndex == self.n:
545 if self.__profIndex == self.n:
546 avgdata, n = self.pushData()
546 avgdata, n = self.pushData()
547 self.__dataReady = True
547 self.__dataReady = True
548
548
549 return avgdata
549 return avgdata
550
550
551 def byTime(self, data, datatime):
551 def byTime(self, data, datatime):
552
552
553 self.__dataReady = False
553 self.__dataReady = False
554 avgdata = None
554 avgdata = None
555 n = None
555 n = None
556
556
557 self.putData(data)
557 self.putData(data)
558
558
559 if (datatime - self.__initime) >= self.__integrationtime:
559 if (datatime - self.__initime) >= self.__integrationtime:
560 avgdata, n = self.pushData()
560 avgdata, n = self.pushData()
561 self.n = n
561 self.n = n
562 self.__dataReady = True
562 self.__dataReady = True
563
563
564 return avgdata
564 return avgdata
565
565
566 def integrateByStride(self, data, datatime):
566 def integrateByStride(self, data, datatime):
567 # print data
567 # print data
568 if self.__profIndex == 0:
568 if self.__profIndex == 0:
569 self.__buffer = [[data.copy(), datatime]]
569 self.__buffer = [[data.copy(), datatime]]
570 else:
570 else:
571 self.__buffer.append([data.copy(),datatime])
571 self.__buffer.append([data.copy(),datatime])
572 self.__profIndex += 1
572 self.__profIndex += 1
573 self.__dataReady = False
573 self.__dataReady = False
574
574
575 if self.__profIndex == self.n * self.stride :
575 if self.__profIndex == self.n * self.stride :
576 self.__dataToPutStride = True
576 self.__dataToPutStride = True
577 self.__profIndexStride = 0
577 self.__profIndexStride = 0
578 self.__profIndex = 0
578 self.__profIndex = 0
579 self.__bufferStride = []
579 self.__bufferStride = []
580 for i in range(self.stride):
580 for i in range(self.stride):
581 current = self.__buffer[i::self.stride]
581 current = self.__buffer[i::self.stride]
582 data = numpy.sum([t[0] for t in current], axis=0)
582 data = numpy.sum([t[0] for t in current], axis=0)
583 avgdatatime = numpy.average([t[1] for t in current])
583 avgdatatime = numpy.average([t[1] for t in current])
584 # print data
584 # print data
585 self.__bufferStride.append((data, avgdatatime))
585 self.__bufferStride.append((data, avgdatatime))
586
586
587 if self.__dataToPutStride:
587 if self.__dataToPutStride:
588 self.__dataReady = True
588 self.__dataReady = True
589 self.__profIndexStride += 1
589 self.__profIndexStride += 1
590 if self.__profIndexStride == self.stride:
590 if self.__profIndexStride == self.stride:
591 self.__dataToPutStride = False
591 self.__dataToPutStride = False
592 # print self.__bufferStride[self.__profIndexStride - 1]
592 # print self.__bufferStride[self.__profIndexStride - 1]
593 # raise
593 # raise
594 return self.__bufferStride[self.__profIndexStride - 1]
594 return self.__bufferStride[self.__profIndexStride - 1]
595
595
596
596
597 return None, None
597 return None, None
598
598
599 def integrate(self, data, datatime=None):
599 def integrate(self, data, datatime=None):
600
600
601 if self.__initime == None:
601 if self.__initime == None:
602 self.__initime = datatime
602 self.__initime = datatime
603
603
604 if self.__byTime:
604 if self.__byTime:
605 avgdata = self.byTime(data, datatime)
605 avgdata = self.byTime(data, datatime)
606 else:
606 else:
607 avgdata = self.byProfiles(data)
607 avgdata = self.byProfiles(data)
608
608
609
609
610 self.__lastdatatime = datatime
610 self.__lastdatatime = datatime
611
611
612 if avgdata is None:
612 if avgdata is None:
613 return None, None
613 return None, None
614
614
615 avgdatatime = self.__initime
615 avgdatatime = self.__initime
616
616
617 deltatime = datatime - self.__lastdatatime
617 deltatime = datatime - self.__lastdatatime
618
618
619 if not self.__withOverlapping:
619 if not self.__withOverlapping:
620 self.__initime = datatime
620 self.__initime = datatime
621 else:
621 else:
622 self.__initime += deltatime
622 self.__initime += deltatime
623
623
624 return avgdata, avgdatatime
624 return avgdata, avgdatatime
625
625
626 def integrateByBlock(self, dataOut):
626 def integrateByBlock(self, dataOut):
627
627
628 times = int(dataOut.data.shape[1]/self.n)
628 times = int(dataOut.data.shape[1]/self.n)
629 avgdata = numpy.zeros((dataOut.nChannels, times, dataOut.nHeights), dtype=numpy.complex)
629 avgdata = numpy.zeros((dataOut.nChannels, times, dataOut.nHeights), dtype=numpy.complex)
630
630
631 id_min = 0
631 id_min = 0
632 id_max = self.n
632 id_max = self.n
633
633
634 for i in range(times):
634 for i in range(times):
635 junk = dataOut.data[:,id_min:id_max,:]
635 junk = dataOut.data[:,id_min:id_max,:]
636 avgdata[:,i,:] = junk.sum(axis=1)
636 avgdata[:,i,:] = junk.sum(axis=1)
637 id_min += self.n
637 id_min += self.n
638 id_max += self.n
638 id_max += self.n
639
639
640 timeInterval = dataOut.ippSeconds*self.n
640 timeInterval = dataOut.ippSeconds*self.n
641 avgdatatime = (times - 1) * timeInterval + dataOut.utctime
641 avgdatatime = (times - 1) * timeInterval + dataOut.utctime
642 self.__dataReady = True
642 self.__dataReady = True
643 return avgdata, avgdatatime
643 return avgdata, avgdatatime
644
644
645 def run(self, dataOut, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False, **kwargs):
645 def run(self, dataOut, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False, **kwargs):
646
646
647 if not self.isConfig:
647 if not self.isConfig:
648 self.setup(n=n, stride=stride, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
648 self.setup(n=n, stride=stride, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
649 self.isConfig = True
649 self.isConfig = True
650
650
651 if dataOut.flagDataAsBlock:
651 if dataOut.flagDataAsBlock:
652 """
652 """
653 Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
653 Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
654 """
654 """
655 avgdata, avgdatatime = self.integrateByBlock(dataOut)
655 avgdata, avgdatatime = self.integrateByBlock(dataOut)
656 dataOut.nProfiles /= self.n
656 dataOut.nProfiles /= self.n
657 else:
657 else:
658 if stride is None:
658 if stride is None:
659 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
659 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
660 else:
660 else:
661 avgdata, avgdatatime = self.integrateByStride(dataOut.data, dataOut.utctime)
661 avgdata, avgdatatime = self.integrateByStride(dataOut.data, dataOut.utctime)
662
662
663
663
664 # dataOut.timeInterval *= n
664 # dataOut.timeInterval *= n
665 dataOut.flagNoData = True
665 dataOut.flagNoData = True
666
666
667 if self.__dataReady:
667 if self.__dataReady:
668 dataOut.data = avgdata
668 dataOut.data = avgdata
669 if not dataOut.flagCohInt:
669 if not dataOut.flagCohInt:
670 dataOut.nCohInt *= self.n
670 dataOut.nCohInt *= self.n
671 dataOut.flagCohInt = True
671 dataOut.flagCohInt = True
672 dataOut.utctime = avgdatatime
672 dataOut.utctime = avgdatatime
673 # print avgdata, avgdatatime
673 # print avgdata, avgdatatime
674 # raise
674 # raise
675 # dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
675 # dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
676 dataOut.flagNoData = False
676 dataOut.flagNoData = False
677 return dataOut
677 return dataOut
678
678
679 class Decoder(Operation):
679 class Decoder(Operation):
680
680
681 isConfig = False
681 isConfig = False
682 __profIndex = 0
682 __profIndex = 0
683
683
684 code = None
684 code = None
685
685
686 nCode = None
686 nCode = None
687 nBaud = None
687 nBaud = None
688
688
689 def __init__(self, **kwargs):
689 def __init__(self, **kwargs):
690
690
691 Operation.__init__(self, **kwargs)
691 Operation.__init__(self, **kwargs)
692
692
693 self.times = None
693 self.times = None
694 self.osamp = None
694 self.osamp = None
695 # self.__setValues = False
695 # self.__setValues = False
696 self.isConfig = False
696 self.isConfig = False
697 self.setupReq = False
697 self.setupReq = False
698 def setup(self, code, osamp, dataOut):
698 def setup(self, code, osamp, dataOut):
699
699
700 self.__profIndex = 0
700 self.__profIndex = 0
701
701
702 self.code = code
702 self.code = code
703
703
704 self.nCode = len(code)
704 self.nCode = len(code)
705 self.nBaud = len(code[0])
705 self.nBaud = len(code[0])
706
706
707 if (osamp != None) and (osamp >1):
707 if (osamp != None) and (osamp >1):
708 self.osamp = osamp
708 self.osamp = osamp
709 self.code = numpy.repeat(code, repeats=self.osamp, axis=1)
709 self.code = numpy.repeat(code, repeats=self.osamp, axis=1)
710 self.nBaud = self.nBaud*self.osamp
710 self.nBaud = self.nBaud*self.osamp
711
711
712 self.__nChannels = dataOut.nChannels
712 self.__nChannels = dataOut.nChannels
713 self.__nProfiles = dataOut.nProfiles
713 self.__nProfiles = dataOut.nProfiles
714 self.__nHeis = dataOut.nHeights
714 self.__nHeis = dataOut.nHeights
715
715
716 if self.__nHeis < self.nBaud:
716 if self.__nHeis < self.nBaud:
717 raise ValueError('Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud))
717 raise ValueError('Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud))
718
718
719 #Frequency
719 #Frequency
720 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
720 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
721
721
722 __codeBuffer[:,0:self.nBaud] = self.code
722 __codeBuffer[:,0:self.nBaud] = self.code
723
723
724 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
724 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
725
725
726 if dataOut.flagDataAsBlock:
726 if dataOut.flagDataAsBlock:
727
727
728 self.ndatadec = self.__nHeis #- self.nBaud + 1
728 self.ndatadec = self.__nHeis #- self.nBaud + 1
729
729
730 self.datadecTime = numpy.zeros((self.__nChannels, self.__nProfiles, self.ndatadec), dtype=numpy.complex)
730 self.datadecTime = numpy.zeros((self.__nChannels, self.__nProfiles, self.ndatadec), dtype=numpy.complex)
731
731
732 else:
732 else:
733
733
734 #Time
734 #Time
735 self.ndatadec = self.__nHeis #- self.nBaud + 1
735 self.ndatadec = self.__nHeis #- self.nBaud + 1
736
736
737 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
737 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
738
738
739 def __convolutionInFreq(self, data):
739 def __convolutionInFreq(self, data):
740
740
741 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
741 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
742
742
743 fft_data = numpy.fft.fft(data, axis=1)
743 fft_data = numpy.fft.fft(data, axis=1)
744
744
745 conv = fft_data*fft_code
745 conv = fft_data*fft_code
746
746
747 data = numpy.fft.ifft(conv,axis=1)
747 data = numpy.fft.ifft(conv,axis=1)
748
748
749 return data
749 return data
750
750
751 def __convolutionInFreqOpt(self, data):
751 def __convolutionInFreqOpt(self, data):
752
752
753 raise NotImplementedError
753 raise NotImplementedError
754
754
755 def __convolutionInTime(self, data):
755 def __convolutionInTime(self, data):
756
756
757 code = self.code[self.__profIndex]
757 code = self.code[self.__profIndex]
758 for i in range(self.__nChannels):
758 for i in range(self.__nChannels):
759 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
759 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
760
760
761 return self.datadecTime
761 return self.datadecTime
762
762
763 def __convolutionByBlockInTime(self, data):
763 def __convolutionByBlockInTime(self, data):
764
764
765 repetitions = int(self.__nProfiles / self.nCode)
765 repetitions = int(self.__nProfiles / self.nCode)
766 junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
766 junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
767 junk = junk.flatten()
767 junk = junk.flatten()
768 code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
768 code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
769 profilesList = range(self.__nProfiles)
769 profilesList = range(self.__nProfiles)
770
770
771 for i in range(self.__nChannels):
771 for i in range(self.__nChannels):
772 for j in profilesList:
772 for j in profilesList:
773 self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
773 self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
774 return self.datadecTime
774 return self.datadecTime
775
775
776 def __convolutionByBlockInFreq(self, data):
776 def __convolutionByBlockInFreq(self, data):
777
777
778 raise NotImplementedError("Decoder by frequency fro Blocks not implemented")
778 raise NotImplementedError("Decoder by frequency fro Blocks not implemented")
779
779
780
780
781 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
781 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
782
782
783 fft_data = numpy.fft.fft(data, axis=2)
783 fft_data = numpy.fft.fft(data, axis=2)
784
784
785 conv = fft_data*fft_code
785 conv = fft_data*fft_code
786
786
787 data = numpy.fft.ifft(conv,axis=2)
787 data = numpy.fft.ifft(conv,axis=2)
788
788
789 return data
789 return data
790
790
791
791
792 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
792 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
793
793
794 if dataOut.flagDecodeData:
794 if dataOut.flagDecodeData:
795 print("This data is already decoded, recoding again ...")
795 print("This data is already decoded, recoding again ...")
796
796
797 if not self.isConfig:
797 if not self.isConfig:
798
798
799 if code is None:
799 if code is None:
800 if dataOut.code is None:
800 if dataOut.code is None:
801 raise ValueError("Code could not be read from %s instance. Enter a value in Code parameter" %dataOut.type)
801 raise ValueError("Code could not be read from %s instance. Enter a value in Code parameter" %dataOut.type)
802
802
803 code = dataOut.code
803 code = dataOut.code
804 else:
804 else:
805 code = numpy.array(code).reshape(nCode,nBaud)
805 code = numpy.array(code).reshape(nCode,nBaud)
806 self.setup(code, osamp, dataOut)
806 self.setup(code, osamp, dataOut)
807
807
808 self.isConfig = True
808 self.isConfig = True
809
809
810 if mode == 3:
810 if mode == 3:
811 sys.stderr.write("Decoder Warning: mode=%d is not valid, using mode=0\n" %mode)
811 sys.stderr.write("Decoder Warning: mode=%d is not valid, using mode=0\n" %mode)
812
812
813 if times != None:
813 if times != None:
814 sys.stderr.write("Decoder Warning: Argument 'times' in not used anymore\n")
814 sys.stderr.write("Decoder Warning: Argument 'times' in not used anymore\n")
815
815
816 if self.code is None:
816 if self.code is None:
817 print("Fail decoding: Code is not defined.")
817 print("Fail decoding: Code is not defined.")
818 return
818 return
819
819
820 self.__nProfiles = dataOut.nProfiles
820 self.__nProfiles = dataOut.nProfiles
821 datadec = None
821 datadec = None
822
822
823 if mode == 3:
823 if mode == 3:
824 mode = 0
824 mode = 0
825
825
826 if dataOut.flagDataAsBlock:
826 if dataOut.flagDataAsBlock:
827 """
827 """
828 Decoding when data have been read as block,
828 Decoding when data have been read as block,
829 """
829 """
830
830
831 if mode == 0:
831 if mode == 0:
832 datadec = self.__convolutionByBlockInTime(dataOut.data)
832 datadec = self.__convolutionByBlockInTime(dataOut.data)
833 if mode == 1:
833 if mode == 1:
834 datadec = self.__convolutionByBlockInFreq(dataOut.data)
834 datadec = self.__convolutionByBlockInFreq(dataOut.data)
835 else:
835 else:
836 """
836 """
837 Decoding when data have been read profile by profile
837 Decoding when data have been read profile by profile
838 """
838 """
839 if mode == 0:
839 if mode == 0:
840 datadec = self.__convolutionInTime(dataOut.data)
840 datadec = self.__convolutionInTime(dataOut.data)
841
841
842 if mode == 1:
842 if mode == 1:
843 datadec = self.__convolutionInFreq(dataOut.data)
843 datadec = self.__convolutionInFreq(dataOut.data)
844
844
845 if mode == 2:
845 if mode == 2:
846 datadec = self.__convolutionInFreqOpt(dataOut.data)
846 datadec = self.__convolutionInFreqOpt(dataOut.data)
847
847
848 if datadec is None:
848 if datadec is None:
849 raise ValueError("Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode)
849 raise ValueError("Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode)
850
850
851 dataOut.code = self.code
851 dataOut.code = self.code
852 dataOut.nCode = self.nCode
852 dataOut.nCode = self.nCode
853 dataOut.nBaud = self.nBaud
853 dataOut.nBaud = self.nBaud
854
854
855 dataOut.data = datadec
855 dataOut.data = datadec
856
856
857 dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
857 dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
858
858
859 dataOut.flagDecodeData = True #asumo q la data esta decodificada
859 dataOut.flagDecodeData = True #asumo q la data esta decodificada
860
860
861 if self.__profIndex == self.nCode-1:
861 if self.__profIndex == self.nCode-1:
862 self.__profIndex = 0
862 self.__profIndex = 0
863 return dataOut
863 return dataOut
864
864
865 self.__profIndex += 1
865 self.__profIndex += 1
866
866
867 return dataOut
867 return dataOut
868 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
868 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
869
869
870
870
871 class ProfileConcat(Operation):
871 class ProfileConcat(Operation):
872
872
873 isConfig = False
873 isConfig = False
874 buffer = None
874 buffer = None
875
875
876 def __init__(self, **kwargs):
876 def __init__(self, **kwargs):
877
877
878 Operation.__init__(self, **kwargs)
878 Operation.__init__(self, **kwargs)
879 self.profileIndex = 0
879 self.profileIndex = 0
880
880
881 def reset(self):
881 def reset(self):
882 self.buffer = numpy.zeros_like(self.buffer)
882 self.buffer = numpy.zeros_like(self.buffer)
883 self.start_index = 0
883 self.start_index = 0
884 self.times = 1
884 self.times = 1
885
885
886 def setup(self, data, m, n=1):
886 def setup(self, data, m, n=1):
887 self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
887 self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
888 self.nHeights = data.shape[1]#.nHeights
888 self.nHeights = data.shape[1]#.nHeights
889 self.start_index = 0
889 self.start_index = 0
890 self.times = 1
890 self.times = 1
891
891
892 def concat(self, data):
892 def concat(self, data):
893
893
894 self.buffer[:,self.start_index:self.nHeights*self.times] = data.copy()
894 self.buffer[:,self.start_index:self.nHeights*self.times] = data.copy()
895 self.start_index = self.start_index + self.nHeights
895 self.start_index = self.start_index + self.nHeights
896
896
897 def run(self, dataOut, m):
897 def run(self, dataOut, m):
898 dataOut.flagNoData = True
898 dataOut.flagNoData = True
899
899
900 if not self.isConfig:
900 if not self.isConfig:
901 self.setup(dataOut.data, m, 1)
901 self.setup(dataOut.data, m, 1)
902 self.isConfig = True
902 self.isConfig = True
903
903
904 if dataOut.flagDataAsBlock:
904 if dataOut.flagDataAsBlock:
905 raise ValueError("ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False")
905 raise ValueError("ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False")
906
906
907 else:
907 else:
908 self.concat(dataOut.data)
908 self.concat(dataOut.data)
909 self.times += 1
909 self.times += 1
910 if self.times > m:
910 if self.times > m:
911 dataOut.data = self.buffer
911 dataOut.data = self.buffer
912 self.reset()
912 self.reset()
913 dataOut.flagNoData = False
913 dataOut.flagNoData = False
914 # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
914 # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
915 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
915 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
916 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
916 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
917 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
917 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
918 dataOut.ippSeconds *= m
918 dataOut.ippSeconds *= m
919 return dataOut
919 return dataOut
920
920
921 class ProfileSelector(Operation):
921 class ProfileSelector(Operation):
922
922
923 profileIndex = None
923 profileIndex = None
924 # Tamanho total de los perfiles
924 # Tamanho total de los perfiles
925 nProfiles = None
925 nProfiles = None
926
926
927 def __init__(self, **kwargs):
927 def __init__(self, **kwargs):
928
928
929 Operation.__init__(self, **kwargs)
929 Operation.__init__(self, **kwargs)
930 self.profileIndex = 0
930 self.profileIndex = 0
931
931
932 def incProfileIndex(self):
932 def incProfileIndex(self):
933
933
934 self.profileIndex += 1
934 self.profileIndex += 1
935
935
936 if self.profileIndex >= self.nProfiles:
936 if self.profileIndex >= self.nProfiles:
937 self.profileIndex = 0
937 self.profileIndex = 0
938
938
939 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
939 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
940
940
941 if profileIndex < minIndex:
941 if profileIndex < minIndex:
942 return False
942 return False
943
943
944 if profileIndex > maxIndex:
944 if profileIndex > maxIndex:
945 return False
945 return False
946
946
947 return True
947 return True
948
948
949 def isThisProfileInList(self, profileIndex, profileList):
949 def isThisProfileInList(self, profileIndex, profileList):
950
950
951 if profileIndex not in profileList:
951 if profileIndex not in profileList:
952 return False
952 return False
953
953
954 return True
954 return True
955
955
956 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
956 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
957
957 #print("before",dataOut.data.shape)
958 """
958 """
959 ProfileSelector:
959 ProfileSelector:
960
960
961 Inputs:
961 Inputs:
962 profileList : Index of profiles selected. Example: profileList = (0,1,2,7,8)
962 profileList : Index of profiles selected. Example: profileList = (0,1,2,7,8)
963
963
964 profileRangeList : Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
964 profileRangeList : Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
965
965
966 rangeList : List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
966 rangeList : List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
967
967
968 """
968 """
969
969
970 if rangeList is not None:
970 if rangeList is not None:
971 if type(rangeList[0]) not in (tuple, list):
971 if type(rangeList[0]) not in (tuple, list):
972 rangeList = [rangeList]
972 rangeList = [rangeList]
973
973
974 dataOut.flagNoData = True
974 dataOut.flagNoData = True
975
975
976 if dataOut.flagDataAsBlock:
976 if dataOut.flagDataAsBlock:
977 """
977 """
978 data dimension = [nChannels, nProfiles, nHeis]
978 data dimension = [nChannels, nProfiles, nHeis]
979 """
979 """
980 if profileList != None:
980 if profileList != None:
981 dataOut.data = dataOut.data[:,profileList,:]
981 dataOut.data = dataOut.data[:,profileList,:]
982
982
983 if profileRangeList != None:
983 if profileRangeList != None:
984 minIndex = profileRangeList[0]
984 minIndex = profileRangeList[0]
985 maxIndex = profileRangeList[1]
985 maxIndex = profileRangeList[1]
986 profileList = list(range(minIndex, maxIndex+1))
986 profileList = list(range(minIndex, maxIndex+1))
987
987
988 dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
988 dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
989
989
990 if rangeList != None:
990 if rangeList != None:
991
991
992 profileList = []
992 profileList = []
993
993
994 for thisRange in rangeList:
994 for thisRange in rangeList:
995 minIndex = thisRange[0]
995 minIndex = thisRange[0]
996 maxIndex = thisRange[1]
996 maxIndex = thisRange[1]
997
997
998 profileList.extend(list(range(minIndex, maxIndex+1)))
998 profileList.extend(list(range(minIndex, maxIndex+1)))
999
999
1000 dataOut.data = dataOut.data[:,profileList,:]
1000 dataOut.data = dataOut.data[:,profileList,:]
1001
1001
1002 dataOut.nProfiles = len(profileList)
1002 dataOut.nProfiles = len(profileList)
1003 dataOut.profileIndex = dataOut.nProfiles - 1
1003 dataOut.profileIndex = dataOut.nProfiles - 1
1004 dataOut.flagNoData = False
1004 dataOut.flagNoData = False
1005
1005 #print(dataOut.data.shape)
1006 return dataOut
1006 return dataOut
1007
1007
1008 """
1008 """
1009 data dimension = [nChannels, nHeis]
1009 data dimension = [nChannels, nHeis]
1010 """
1010 """
1011
1011
1012 if profileList != None:
1012 if profileList != None:
1013
1013
1014 if self.isThisProfileInList(dataOut.profileIndex, profileList):
1014 if self.isThisProfileInList(dataOut.profileIndex, profileList):
1015
1015
1016 self.nProfiles = len(profileList)
1016 self.nProfiles = len(profileList)
1017 dataOut.nProfiles = self.nProfiles
1017 dataOut.nProfiles = self.nProfiles
1018 dataOut.profileIndex = self.profileIndex
1018 dataOut.profileIndex = self.profileIndex
1019 dataOut.flagNoData = False
1019 dataOut.flagNoData = False
1020
1020
1021 self.incProfileIndex()
1021 self.incProfileIndex()
1022 return dataOut
1022 return dataOut
1023
1023
1024 if profileRangeList != None:
1024 if profileRangeList != None:
1025
1025
1026 minIndex = profileRangeList[0]
1026 minIndex = profileRangeList[0]
1027 maxIndex = profileRangeList[1]
1027 maxIndex = profileRangeList[1]
1028
1028
1029 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
1029 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
1030
1030
1031 self.nProfiles = maxIndex - minIndex + 1
1031 self.nProfiles = maxIndex - minIndex + 1
1032 dataOut.nProfiles = self.nProfiles
1032 dataOut.nProfiles = self.nProfiles
1033 dataOut.profileIndex = self.profileIndex
1033 dataOut.profileIndex = self.profileIndex
1034 dataOut.flagNoData = False
1034 dataOut.flagNoData = False
1035
1035
1036 self.incProfileIndex()
1036 self.incProfileIndex()
1037 return dataOut
1037 return dataOut
1038
1038
1039 if rangeList != None:
1039 if rangeList != None:
1040
1040
1041 nProfiles = 0
1041 nProfiles = 0
1042
1042
1043 for thisRange in rangeList:
1043 for thisRange in rangeList:
1044 minIndex = thisRange[0]
1044 minIndex = thisRange[0]
1045 maxIndex = thisRange[1]
1045 maxIndex = thisRange[1]
1046
1046
1047 nProfiles += maxIndex - minIndex + 1
1047 nProfiles += maxIndex - minIndex + 1
1048
1048
1049 for thisRange in rangeList:
1049 for thisRange in rangeList:
1050
1050
1051 minIndex = thisRange[0]
1051 minIndex = thisRange[0]
1052 maxIndex = thisRange[1]
1052 maxIndex = thisRange[1]
1053
1053
1054 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
1054 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
1055
1055
1056 self.nProfiles = nProfiles
1056 self.nProfiles = nProfiles
1057 dataOut.nProfiles = self.nProfiles
1057 dataOut.nProfiles = self.nProfiles
1058 dataOut.profileIndex = self.profileIndex
1058 dataOut.profileIndex = self.profileIndex
1059 dataOut.flagNoData = False
1059 dataOut.flagNoData = False
1060
1060
1061 self.incProfileIndex()
1061 self.incProfileIndex()
1062
1062
1063 break
1063 break
1064
1064
1065 return dataOut
1065 return dataOut
1066
1066
1067
1067
1068 if beam != None: #beam is only for AMISR data
1068 if beam != None: #beam is only for AMISR data
1069 if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
1069 if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
1070 dataOut.flagNoData = False
1070 dataOut.flagNoData = False
1071 dataOut.profileIndex = self.profileIndex
1071 dataOut.profileIndex = self.profileIndex
1072
1072
1073 self.incProfileIndex()
1073 self.incProfileIndex()
1074
1074
1075 return dataOut
1075 return dataOut
1076
1076
1077 raise ValueError("ProfileSelector needs profileList, profileRangeList or rangeList parameter")
1077 raise ValueError("ProfileSelector needs profileList, profileRangeList or rangeList parameter")
1078
1078
1079
1079
1080 class Reshaper(Operation):
1080 class Reshaper(Operation):
1081
1081
1082 def __init__(self, **kwargs):
1082 def __init__(self, **kwargs):
1083
1083
1084 Operation.__init__(self, **kwargs)
1084 Operation.__init__(self, **kwargs)
1085
1085
1086 self.__buffer = None
1086 self.__buffer = None
1087 self.__nitems = 0
1087 self.__nitems = 0
1088
1088
1089 def __appendProfile(self, dataOut, nTxs):
1089 def __appendProfile(self, dataOut, nTxs):
1090
1090
1091 if self.__buffer is None:
1091 if self.__buffer is None:
1092 shape = (dataOut.nChannels, int(dataOut.nHeights/nTxs) )
1092 shape = (dataOut.nChannels, int(dataOut.nHeights/nTxs) )
1093 self.__buffer = numpy.empty(shape, dtype = dataOut.data.dtype)
1093 self.__buffer = numpy.empty(shape, dtype = dataOut.data.dtype)
1094
1094
1095 ini = dataOut.nHeights * self.__nitems
1095 ini = dataOut.nHeights * self.__nitems
1096 end = ini + dataOut.nHeights
1096 end = ini + dataOut.nHeights
1097
1097
1098 self.__buffer[:, ini:end] = dataOut.data
1098 self.__buffer[:, ini:end] = dataOut.data
1099
1099
1100 self.__nitems += 1
1100 self.__nitems += 1
1101
1101
1102 return int(self.__nitems*nTxs)
1102 return int(self.__nitems*nTxs)
1103
1103
1104 def __getBuffer(self):
1104 def __getBuffer(self):
1105
1105
1106 if self.__nitems == int(1./self.__nTxs):
1106 if self.__nitems == int(1./self.__nTxs):
1107
1107
1108 self.__nitems = 0
1108 self.__nitems = 0
1109
1109
1110 return self.__buffer.copy()
1110 return self.__buffer.copy()
1111
1111
1112 return None
1112 return None
1113
1113
1114 def __checkInputs(self, dataOut, shape, nTxs):
1114 def __checkInputs(self, dataOut, shape, nTxs):
1115
1115
1116 if shape is None and nTxs is None:
1116 if shape is None and nTxs is None:
1117 raise ValueError("Reshaper: shape of factor should be defined")
1117 raise ValueError("Reshaper: shape of factor should be defined")
1118
1118
1119 if nTxs:
1119 if nTxs:
1120 if nTxs < 0:
1120 if nTxs < 0:
1121 raise ValueError("nTxs should be greater than 0")
1121 raise ValueError("nTxs should be greater than 0")
1122
1122
1123 if nTxs < 1 and dataOut.nProfiles % (1./nTxs) != 0:
1123 if nTxs < 1 and dataOut.nProfiles % (1./nTxs) != 0:
1124 raise ValueError("nProfiles= %d is not divisibled by (1./nTxs) = %f" %(dataOut.nProfiles, (1./nTxs)))
1124 raise ValueError("nProfiles= %d is not divisibled by (1./nTxs) = %f" %(dataOut.nProfiles, (1./nTxs)))
1125
1125
1126 shape = [dataOut.nChannels, dataOut.nProfiles*nTxs, dataOut.nHeights/nTxs]
1126 shape = [dataOut.nChannels, dataOut.nProfiles*nTxs, dataOut.nHeights/nTxs]
1127
1127
1128 return shape, nTxs
1128 return shape, nTxs
1129
1129
1130 if len(shape) != 2 and len(shape) != 3:
1130 if len(shape) != 2 and len(shape) != 3:
1131 raise ValueError("shape dimension should be equal to 2 or 3. shape = (nProfiles, nHeis) or (nChannels, nProfiles, nHeis). Actually shape = (%d, %d, %d)" %(dataOut.nChannels, dataOut.nProfiles, dataOut.nHeights))
1131 raise ValueError("shape dimension should be equal to 2 or 3. shape = (nProfiles, nHeis) or (nChannels, nProfiles, nHeis). Actually shape = (%d, %d, %d)" %(dataOut.nChannels, dataOut.nProfiles, dataOut.nHeights))
1132
1132
1133 if len(shape) == 2:
1133 if len(shape) == 2:
1134 shape_tuple = [dataOut.nChannels]
1134 shape_tuple = [dataOut.nChannels]
1135 shape_tuple.extend(shape)
1135 shape_tuple.extend(shape)
1136 else:
1136 else:
1137 shape_tuple = list(shape)
1137 shape_tuple = list(shape)
1138
1138
1139 nTxs = 1.0*shape_tuple[1]/dataOut.nProfiles
1139 nTxs = 1.0*shape_tuple[1]/dataOut.nProfiles
1140
1140
1141 return shape_tuple, nTxs
1141 return shape_tuple, nTxs
1142
1142
1143 def run(self, dataOut, shape=None, nTxs=None):
1143 def run(self, dataOut, shape=None, nTxs=None):
1144
1144
1145 shape_tuple, self.__nTxs = self.__checkInputs(dataOut, shape, nTxs)
1145 shape_tuple, self.__nTxs = self.__checkInputs(dataOut, shape, nTxs)
1146
1146
1147 dataOut.flagNoData = True
1147 dataOut.flagNoData = True
1148 profileIndex = None
1148 profileIndex = None
1149
1149
1150 if dataOut.flagDataAsBlock:
1150 if dataOut.flagDataAsBlock:
1151
1151
1152 dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
1152 dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
1153 dataOut.flagNoData = False
1153 dataOut.flagNoData = False
1154
1154
1155 profileIndex = int(dataOut.nProfiles*self.__nTxs) - 1
1155 profileIndex = int(dataOut.nProfiles*self.__nTxs) - 1
1156
1156
1157 else:
1157 else:
1158
1158
1159 if self.__nTxs < 1:
1159 if self.__nTxs < 1:
1160
1160
1161 self.__appendProfile(dataOut, self.__nTxs)
1161 self.__appendProfile(dataOut, self.__nTxs)
1162 new_data = self.__getBuffer()
1162 new_data = self.__getBuffer()
1163
1163
1164 if new_data is not None:
1164 if new_data is not None:
1165 dataOut.data = new_data
1165 dataOut.data = new_data
1166 dataOut.flagNoData = False
1166 dataOut.flagNoData = False
1167
1167
1168 profileIndex = dataOut.profileIndex*nTxs
1168 profileIndex = dataOut.profileIndex*nTxs
1169
1169
1170 else:
1170 else:
1171 raise ValueError("nTxs should be greater than 0 and lower than 1, or use VoltageReader(..., getblock=True)")
1171 raise ValueError("nTxs should be greater than 0 and lower than 1, or use VoltageReader(..., getblock=True)")
1172
1172
1173 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1173 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1174
1174
1175 dataOut.heightList = numpy.arange(dataOut.nHeights/self.__nTxs) * deltaHeight + dataOut.heightList[0]
1175 dataOut.heightList = numpy.arange(dataOut.nHeights/self.__nTxs) * deltaHeight + dataOut.heightList[0]
1176
1176
1177 dataOut.nProfiles = int(dataOut.nProfiles*self.__nTxs)
1177 dataOut.nProfiles = int(dataOut.nProfiles*self.__nTxs)
1178
1178
1179 dataOut.profileIndex = profileIndex
1179 dataOut.profileIndex = profileIndex
1180
1180
1181 dataOut.ippSeconds /= self.__nTxs
1181 dataOut.ippSeconds /= self.__nTxs
1182
1182
1183 return dataOut
1183 return dataOut
1184
1184
1185 class SplitProfiles(Operation):
1185 class SplitProfiles(Operation):
1186
1186
1187 def __init__(self, **kwargs):
1187 def __init__(self, **kwargs):
1188
1188
1189 Operation.__init__(self, **kwargs)
1189 Operation.__init__(self, **kwargs)
1190
1190
1191 def run(self, dataOut, n):
1191 def run(self, dataOut, n):
1192
1192
1193 dataOut.flagNoData = True
1193 dataOut.flagNoData = True
1194 profileIndex = None
1194 profileIndex = None
1195
1195
1196 if dataOut.flagDataAsBlock:
1196 if dataOut.flagDataAsBlock:
1197
1197
1198 #nchannels, nprofiles, nsamples
1198 #nchannels, nprofiles, nsamples
1199 shape = dataOut.data.shape
1199 shape = dataOut.data.shape
1200
1200
1201 if shape[2] % n != 0:
1201 if shape[2] % n != 0:
1202 raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[2]))
1202 raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[2]))
1203
1203
1204 new_shape = shape[0], shape[1]*n, int(shape[2]/n)
1204 new_shape = shape[0], shape[1]*n, int(shape[2]/n)
1205
1205
1206 dataOut.data = numpy.reshape(dataOut.data, new_shape)
1206 dataOut.data = numpy.reshape(dataOut.data, new_shape)
1207 dataOut.flagNoData = False
1207 dataOut.flagNoData = False
1208
1208
1209 profileIndex = int(dataOut.nProfiles/n) - 1
1209 profileIndex = int(dataOut.nProfiles/n) - 1
1210
1210
1211 else:
1211 else:
1212
1212
1213 raise ValueError("Could not split the data when is read Profile by Profile. Use VoltageReader(..., getblock=True)")
1213 raise ValueError("Could not split the data when is read Profile by Profile. Use VoltageReader(..., getblock=True)")
1214
1214
1215 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1215 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1216
1216
1217 dataOut.heightList = numpy.arange(dataOut.nHeights/n) * deltaHeight + dataOut.heightList[0]
1217 dataOut.heightList = numpy.arange(dataOut.nHeights/n) * deltaHeight + dataOut.heightList[0]
1218
1218
1219 dataOut.nProfiles = int(dataOut.nProfiles*n)
1219 dataOut.nProfiles = int(dataOut.nProfiles*n)
1220
1220
1221 dataOut.profileIndex = profileIndex
1221 dataOut.profileIndex = profileIndex
1222
1222
1223 dataOut.ippSeconds /= n
1223 dataOut.ippSeconds /= n
1224
1224
1225 return dataOut
1225 return dataOut
1226
1226
1227 class CombineProfiles(Operation):
1227 class CombineProfiles(Operation):
1228 def __init__(self, **kwargs):
1228 def __init__(self, **kwargs):
1229
1229
1230 Operation.__init__(self, **kwargs)
1230 Operation.__init__(self, **kwargs)
1231
1231
1232 self.__remData = None
1232 self.__remData = None
1233 self.__profileIndex = 0
1233 self.__profileIndex = 0
1234
1234
1235 def run(self, dataOut, n):
1235 def run(self, dataOut, n):
1236
1236
1237 dataOut.flagNoData = True
1237 dataOut.flagNoData = True
1238 profileIndex = None
1238 profileIndex = None
1239
1239
1240 if dataOut.flagDataAsBlock:
1240 if dataOut.flagDataAsBlock:
1241
1241
1242 #nchannels, nprofiles, nsamples
1242 #nchannels, nprofiles, nsamples
1243 shape = dataOut.data.shape
1243 shape = dataOut.data.shape
1244 new_shape = shape[0], shape[1]/n, shape[2]*n
1244 new_shape = shape[0], shape[1]/n, shape[2]*n
1245
1245
1246 if shape[1] % n != 0:
1246 if shape[1] % n != 0:
1247 raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[1]))
1247 raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[1]))
1248
1248
1249 dataOut.data = numpy.reshape(dataOut.data, new_shape)
1249 dataOut.data = numpy.reshape(dataOut.data, new_shape)
1250 dataOut.flagNoData = False
1250 dataOut.flagNoData = False
1251
1251
1252 profileIndex = int(dataOut.nProfiles*n) - 1
1252 profileIndex = int(dataOut.nProfiles*n) - 1
1253
1253
1254 else:
1254 else:
1255
1255
1256 #nchannels, nsamples
1256 #nchannels, nsamples
1257 if self.__remData is None:
1257 if self.__remData is None:
1258 newData = dataOut.data
1258 newData = dataOut.data
1259 else:
1259 else:
1260 newData = numpy.concatenate((self.__remData, dataOut.data), axis=1)
1260 newData = numpy.concatenate((self.__remData, dataOut.data), axis=1)
1261
1261
1262 self.__profileIndex += 1
1262 self.__profileIndex += 1
1263
1263
1264 if self.__profileIndex < n:
1264 if self.__profileIndex < n:
1265 self.__remData = newData
1265 self.__remData = newData
1266 #continue
1266 #continue
1267 return
1267 return
1268
1268
1269 self.__profileIndex = 0
1269 self.__profileIndex = 0
1270 self.__remData = None
1270 self.__remData = None
1271
1271
1272 dataOut.data = newData
1272 dataOut.data = newData
1273 dataOut.flagNoData = False
1273 dataOut.flagNoData = False
1274
1274
1275 profileIndex = dataOut.profileIndex/n
1275 profileIndex = dataOut.profileIndex/n
1276
1276
1277
1277
1278 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1278 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1279
1279
1280 dataOut.heightList = numpy.arange(dataOut.nHeights*n) * deltaHeight + dataOut.heightList[0]
1280 dataOut.heightList = numpy.arange(dataOut.nHeights*n) * deltaHeight + dataOut.heightList[0]
1281
1281
1282 dataOut.nProfiles = int(dataOut.nProfiles/n)
1282 dataOut.nProfiles = int(dataOut.nProfiles/n)
1283
1283
1284 dataOut.profileIndex = profileIndex
1284 dataOut.profileIndex = profileIndex
1285
1285
1286 dataOut.ippSeconds *= n
1286 dataOut.ippSeconds *= n
1287
1287
1288 return dataOut
1288 return dataOut
1289
1289
1290 class PulsePair(Operation):
1290 class PulsePair(Operation):
1291 '''
1291 '''
1292 Function PulsePair(Signal Power, Velocity)
1292 Function PulsePair(Signal Power, Velocity)
1293 The real component of Lag[0] provides Intensity Information
1293 The real component of Lag[0] provides Intensity Information
1294 The imag component of Lag[1] Phase provides Velocity Information
1294 The imag component of Lag[1] Phase provides Velocity Information
1295
1295
1296 Configuration Parameters:
1296 Configuration Parameters:
1297 nPRF = Number of Several PRF
1297 nPRF = Number of Several PRF
1298 theta = Degree Azimuth angel Boundaries
1298 theta = Degree Azimuth angel Boundaries
1299
1299
1300 Input:
1300 Input:
1301 self.dataOut
1301 self.dataOut
1302 lag[N]
1302 lag[N]
1303 Affected:
1303 Affected:
1304 self.dataOut.spc
1304 self.dataOut.spc
1305 '''
1305 '''
1306 isConfig = False
1306 isConfig = False
1307 __profIndex = 0
1307 __profIndex = 0
1308 __initime = None
1308 __initime = None
1309 __lastdatatime = None
1309 __lastdatatime = None
1310 __buffer = None
1310 __buffer = None
1311 noise = None
1311 noise = None
1312 __dataReady = False
1312 __dataReady = False
1313 n = None
1313 n = None
1314 __nch = 0
1314 __nch = 0
1315 __nHeis = 0
1315 __nHeis = 0
1316 removeDC = False
1316 removeDC = False
1317 ipp = None
1317 ipp = None
1318 lambda_ = 0
1318 lambda_ = 0
1319
1319
1320 def __init__(self,**kwargs):
1320 def __init__(self,**kwargs):
1321 Operation.__init__(self,**kwargs)
1321 Operation.__init__(self,**kwargs)
1322
1322
1323 def setup(self, dataOut, n = None, removeDC=False):
1323 def setup(self, dataOut, n = None, removeDC=False):
1324 '''
1324 '''
1325 n= Numero de PRF's de entrada
1325 n= Numero de PRF's de entrada
1326 '''
1326 '''
1327 self.__initime = None
1327 self.__initime = None
1328 ####print("[INICIO]-setup del METODO PULSE PAIR")
1328 ####print("[INICIO]-setup del METODO PULSE PAIR")
1329 self.__lastdatatime = 0
1329 self.__lastdatatime = 0
1330 self.__dataReady = False
1330 self.__dataReady = False
1331 self.__buffer = 0
1331 self.__buffer = 0
1332 self.__profIndex = 0
1332 self.__profIndex = 0
1333 self.noise = None
1333 self.noise = None
1334 self.__nch = dataOut.nChannels
1334 self.__nch = dataOut.nChannels
1335 self.__nHeis = dataOut.nHeights
1335 self.__nHeis = dataOut.nHeights
1336 self.removeDC = removeDC
1336 self.removeDC = removeDC
1337 self.lambda_ = 3.0e8/(9345.0e6)
1337 self.lambda_ = 3.0e8/(9345.0e6)
1338 self.ippSec = dataOut.ippSeconds
1338 self.ippSec = dataOut.ippSeconds
1339 self.nCohInt = dataOut.nCohInt
1339 self.nCohInt = dataOut.nCohInt
1340 ####print("IPPseconds",dataOut.ippSeconds)
1340 ####print("IPPseconds",dataOut.ippSeconds)
1341 ####print("ELVALOR DE n es:", n)
1341 ####print("ELVALOR DE n es:", n)
1342 if n == None:
1342 if n == None:
1343 raise ValueError("n should be specified.")
1343 raise ValueError("n should be specified.")
1344
1344
1345 if n != None:
1345 if n != None:
1346 if n<2:
1346 if n<2:
1347 raise ValueError("n should be greater than 2")
1347 raise ValueError("n should be greater than 2")
1348
1348
1349 self.n = n
1349 self.n = n
1350 self.__nProf = n
1350 self.__nProf = n
1351
1351
1352 self.__buffer = numpy.zeros((dataOut.nChannels,
1352 self.__buffer = numpy.zeros((dataOut.nChannels,
1353 n,
1353 n,
1354 dataOut.nHeights),
1354 dataOut.nHeights),
1355 dtype='complex')
1355 dtype='complex')
1356
1356
1357 def putData(self,data):
1357 def putData(self,data):
1358 '''
1358 '''
1359 Add a profile to he __buffer and increase in one the __profiel Index
1359 Add a profile to he __buffer and increase in one the __profiel Index
1360 '''
1360 '''
1361 self.__buffer[:,self.__profIndex,:]= data
1361 self.__buffer[:,self.__profIndex,:]= data
1362 self.__profIndex += 1
1362 self.__profIndex += 1
1363 return
1363 return
1364
1364
1365 def pushData(self,dataOut):
1365 def pushData(self,dataOut):
1366 '''
1366 '''
1367 Return the PULSEPAIR and the profiles used in the operation
1367 Return the PULSEPAIR and the profiles used in the operation
1368 Affected : self.__profileIndex
1368 Affected : self.__profileIndex
1369 '''
1369 '''
1370 #----------------- Remove DC-----------------------------------
1370 #----------------- Remove DC-----------------------------------
1371 if self.removeDC==True:
1371 if self.removeDC==True:
1372 mean = numpy.mean(self.__buffer,1)
1372 mean = numpy.mean(self.__buffer,1)
1373 tmp = mean.reshape(self.__nch,1,self.__nHeis)
1373 tmp = mean.reshape(self.__nch,1,self.__nHeis)
1374 dc= numpy.tile(tmp,[1,self.__nProf,1])
1374 dc= numpy.tile(tmp,[1,self.__nProf,1])
1375 self.__buffer = self.__buffer - dc
1375 self.__buffer = self.__buffer - dc
1376 #------------------Calculo de Potencia ------------------------
1376 #------------------Calculo de Potencia ------------------------
1377 pair0 = self.__buffer*numpy.conj(self.__buffer)
1377 pair0 = self.__buffer*numpy.conj(self.__buffer)
1378 pair0 = pair0.real
1378 pair0 = pair0.real
1379 lag_0 = numpy.sum(pair0,1)
1379 lag_0 = numpy.sum(pair0,1)
1380 #-----------------Calculo de Cscp------------------------------ New
1380 #-----------------Calculo de Cscp------------------------------ New
1381 cspc_pair01 = self.__buffer[0]*self.__buffer[1]
1381 cspc_pair01 = self.__buffer[0]*self.__buffer[1]
1382 #------------------Calculo de Ruido x canal--------------------
1382 #------------------Calculo de Ruido x canal--------------------
1383 self.noise = numpy.zeros(self.__nch)
1383 self.noise = numpy.zeros(self.__nch)
1384 for i in range(self.__nch):
1384 for i in range(self.__nch):
1385 daux = numpy.sort(pair0[i,:,:],axis= None)
1385 daux = numpy.sort(pair0[i,:,:],axis= None)
1386 self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
1386 self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
1387
1387
1388 self.noise = self.noise.reshape(self.__nch,1)
1388 self.noise = self.noise.reshape(self.__nch,1)
1389 self.noise = numpy.tile(self.noise,[1,self.__nHeis])
1389 self.noise = numpy.tile(self.noise,[1,self.__nHeis])
1390 noise_buffer = self.noise.reshape(self.__nch,1,self.__nHeis)
1390 noise_buffer = self.noise.reshape(self.__nch,1,self.__nHeis)
1391 noise_buffer = numpy.tile(noise_buffer,[1,self.__nProf,1])
1391 noise_buffer = numpy.tile(noise_buffer,[1,self.__nProf,1])
1392 #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
1392 #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
1393 #------------------ P= S+N ,P=lag_0/N ---------------------------------
1393 #------------------ P= S+N ,P=lag_0/N ---------------------------------
1394 #-------------------- Power --------------------------------------------------
1394 #-------------------- Power --------------------------------------------------
1395 data_power = lag_0/(self.n*self.nCohInt)
1395 data_power = lag_0/(self.n*self.nCohInt)
1396 #--------------------CCF------------------------------------------------------
1396 #--------------------CCF------------------------------------------------------
1397 data_ccf =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
1397 data_ccf =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
1398 #------------------ Senal --------------------------------------------------
1398 #------------------ Senal --------------------------------------------------
1399 data_intensity = pair0 - noise_buffer
1399 data_intensity = pair0 - noise_buffer
1400 data_intensity = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
1400 data_intensity = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
1401 #data_intensity = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
1401 #data_intensity = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
1402 for i in range(self.__nch):
1402 for i in range(self.__nch):
1403 for j in range(self.__nHeis):
1403 for j in range(self.__nHeis):
1404 if data_intensity[i][j] < 0:
1404 if data_intensity[i][j] < 0:
1405 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
1405 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
1406
1406
1407 #----------------- Calculo de Frecuencia y Velocidad doppler--------
1407 #----------------- Calculo de Frecuencia y Velocidad doppler--------
1408 pair1 = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
1408 pair1 = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
1409 lag_1 = numpy.sum(pair1,1)
1409 lag_1 = numpy.sum(pair1,1)
1410 data_freq = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
1410 data_freq = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
1411 data_velocity = (self.lambda_/2.0)*data_freq
1411 data_velocity = (self.lambda_/2.0)*data_freq
1412
1412
1413 #---------------- Potencia promedio estimada de la Senal-----------
1413 #---------------- Potencia promedio estimada de la Senal-----------
1414 lag_0 = lag_0/self.n
1414 lag_0 = lag_0/self.n
1415 S = lag_0-self.noise
1415 S = lag_0-self.noise
1416
1416
1417 #---------------- Frecuencia Doppler promedio ---------------------
1417 #---------------- Frecuencia Doppler promedio ---------------------
1418 lag_1 = lag_1/(self.n-1)
1418 lag_1 = lag_1/(self.n-1)
1419 R1 = numpy.abs(lag_1)
1419 R1 = numpy.abs(lag_1)
1420
1420
1421 #---------------- Calculo del SNR----------------------------------
1421 #---------------- Calculo del SNR----------------------------------
1422 data_snrPP = S/self.noise
1422 data_snrPP = S/self.noise
1423 for i in range(self.__nch):
1423 for i in range(self.__nch):
1424 for j in range(self.__nHeis):
1424 for j in range(self.__nHeis):
1425 if data_snrPP[i][j] < 1.e-20:
1425 if data_snrPP[i][j] < 1.e-20:
1426 data_snrPP[i][j] = 1.e-20
1426 data_snrPP[i][j] = 1.e-20
1427
1427
1428 #----------------- Calculo del ancho espectral ----------------------
1428 #----------------- Calculo del ancho espectral ----------------------
1429 L = S/R1
1429 L = S/R1
1430 L = numpy.where(L<0,1,L)
1430 L = numpy.where(L<0,1,L)
1431 L = numpy.log(L)
1431 L = numpy.log(L)
1432 tmp = numpy.sqrt(numpy.absolute(L))
1432 tmp = numpy.sqrt(numpy.absolute(L))
1433 data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
1433 data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
1434 n = self.__profIndex
1434 n = self.__profIndex
1435
1435
1436 self.__buffer = numpy.zeros((self.__nch, self.__nProf,self.__nHeis), dtype='complex')
1436 self.__buffer = numpy.zeros((self.__nch, self.__nProf,self.__nHeis), dtype='complex')
1437 self.__profIndex = 0
1437 self.__profIndex = 0
1438 return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,data_ccf,n
1438 return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,data_ccf,n
1439
1439
1440
1440
1441 def pulsePairbyProfiles(self,dataOut):
1441 def pulsePairbyProfiles(self,dataOut):
1442
1442
1443 self.__dataReady = False
1443 self.__dataReady = False
1444 data_power = None
1444 data_power = None
1445 data_intensity = None
1445 data_intensity = None
1446 data_velocity = None
1446 data_velocity = None
1447 data_specwidth = None
1447 data_specwidth = None
1448 data_snrPP = None
1448 data_snrPP = None
1449 data_ccf = None
1449 data_ccf = None
1450 self.putData(data=dataOut.data)
1450 self.putData(data=dataOut.data)
1451 if self.__profIndex == self.n:
1451 if self.__profIndex == self.n:
1452 data_power,data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, n = self.pushData(dataOut=dataOut)
1452 data_power,data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, n = self.pushData(dataOut=dataOut)
1453 self.__dataReady = True
1453 self.__dataReady = True
1454
1454
1455 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf
1455 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf
1456
1456
1457
1457
1458 def pulsePairOp(self, dataOut, datatime= None):
1458 def pulsePairOp(self, dataOut, datatime= None):
1459
1459
1460 if self.__initime == None:
1460 if self.__initime == None:
1461 self.__initime = datatime
1461 self.__initime = datatime
1462 data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf = self.pulsePairbyProfiles(dataOut)
1462 data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf = self.pulsePairbyProfiles(dataOut)
1463 self.__lastdatatime = datatime
1463 self.__lastdatatime = datatime
1464
1464
1465 if data_power is None:
1465 if data_power is None:
1466 return None, None, None,None,None,None,None
1466 return None, None, None,None,None,None,None
1467
1467
1468 avgdatatime = self.__initime
1468 avgdatatime = self.__initime
1469 deltatime = datatime - self.__lastdatatime
1469 deltatime = datatime - self.__lastdatatime
1470 self.__initime = datatime
1470 self.__initime = datatime
1471
1471
1472 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf, avgdatatime
1472 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf, avgdatatime
1473
1473
1474 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1474 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1475 #print("hey")
1475 #print("hey")
1476 #print(dataOut.data.shape)
1476 #print(dataOut.data.shape)
1477 #exit(1)
1477 #exit(1)
1478 #print(self.__profIndex)
1478 #print(self.__profIndex)
1479 if not self.isConfig:
1479 if not self.isConfig:
1480 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1480 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1481 self.isConfig = True
1481 self.isConfig = True
1482 data_power, data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, avgdatatime = self.pulsePairOp(dataOut, dataOut.utctime)
1482 data_power, data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, avgdatatime = self.pulsePairOp(dataOut, dataOut.utctime)
1483 dataOut.flagNoData = True
1483 dataOut.flagNoData = True
1484
1484
1485 if self.__dataReady:
1485 if self.__dataReady:
1486 ###print("READY ----------------------------------")
1486 ###print("READY ----------------------------------")
1487 dataOut.nCohInt *= self.n
1487 dataOut.nCohInt *= self.n
1488 dataOut.dataPP_POW = data_intensity # S
1488 dataOut.dataPP_POW = data_intensity # S
1489 dataOut.dataPP_POWER = data_power # P valor que corresponde a POTENCIA MOMENTO
1489 dataOut.dataPP_POWER = data_power # P valor que corresponde a POTENCIA MOMENTO
1490 dataOut.dataPP_DOP = data_velocity
1490 dataOut.dataPP_DOP = data_velocity
1491 dataOut.dataPP_SNR = data_snrPP
1491 dataOut.dataPP_SNR = data_snrPP
1492 dataOut.dataPP_WIDTH = data_specwidth
1492 dataOut.dataPP_WIDTH = data_specwidth
1493 dataOut.dataPP_CCF = data_ccf
1493 dataOut.dataPP_CCF = data_ccf
1494 dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo.
1494 dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo.
1495 dataOut.nProfiles = int(dataOut.nProfiles/n)
1495 dataOut.nProfiles = int(dataOut.nProfiles/n)
1496 dataOut.utctime = avgdatatime
1496 dataOut.utctime = avgdatatime
1497 dataOut.flagNoData = False
1497 dataOut.flagNoData = False
1498 return dataOut
1498 return dataOut
1499
1499
1500 class PulsePair_vRF(Operation):
1500 class PulsePair_vRF(Operation):
1501 '''
1501 '''
1502 Function PulsePair(Signal Power, Velocity)
1502 Function PulsePair(Signal Power, Velocity)
1503 The real component of Lag[0] provides Intensity Information
1503 The real component of Lag[0] provides Intensity Information
1504 The imag component of Lag[1] Phase provides Velocity Information
1504 The imag component of Lag[1] Phase provides Velocity Information
1505
1505
1506 Configuration Parameters:
1506 Configuration Parameters:
1507 nPRF = Number of Several PRF
1507 nPRF = Number of Several PRF
1508 theta = Degree Azimuth angel Boundaries
1508 theta = Degree Azimuth angel Boundaries
1509
1509
1510 Input:
1510 Input:
1511 self.dataOut
1511 self.dataOut
1512 lag[N]
1512 lag[N]
1513 Affected:
1513 Affected:
1514 self.dataOut.spc
1514 self.dataOut.spc
1515 '''
1515 '''
1516 isConfig = False
1516 isConfig = False
1517 __profIndex = 0
1517 __profIndex = 0
1518 __initime = None
1518 __initime = None
1519 __lastdatatime = None
1519 __lastdatatime = None
1520 __buffer = None
1520 __buffer = None
1521 noise = None
1521 noise = None
1522 __dataReady = False
1522 __dataReady = False
1523 n = None
1523 n = None
1524 __nch = 0
1524 __nch = 0
1525 __nHeis = 0
1525 __nHeis = 0
1526 removeDC = False
1526 removeDC = False
1527 ipp = None
1527 ipp = None
1528 lambda_ = 0
1528 lambda_ = 0
1529
1529
1530 def __init__(self,**kwargs):
1530 def __init__(self,**kwargs):
1531 Operation.__init__(self,**kwargs)
1531 Operation.__init__(self,**kwargs)
1532
1532
1533 def setup(self, dataOut, n = None, removeDC=False):
1533 def setup(self, dataOut, n = None, removeDC=False):
1534 '''
1534 '''
1535 n= Numero de PRF's de entrada
1535 n= Numero de PRF's de entrada
1536 '''
1536 '''
1537 self.__initime = None
1537 self.__initime = None
1538 ####print("[INICIO]-setup del METODO PULSE PAIR")
1538 ####print("[INICIO]-setup del METODO PULSE PAIR")
1539 self.__lastdatatime = 0
1539 self.__lastdatatime = 0
1540 self.__dataReady = False
1540 self.__dataReady = False
1541 self.__buffer = 0
1541 self.__buffer = 0
1542 self.__profIndex = 0
1542 self.__profIndex = 0
1543 self.noise = None
1543 self.noise = None
1544 self.__nch = dataOut.nChannels
1544 self.__nch = dataOut.nChannels
1545 self.__nHeis = dataOut.nHeights
1545 self.__nHeis = dataOut.nHeights
1546 self.removeDC = removeDC
1546 self.removeDC = removeDC
1547 self.lambda_ = 3.0e8/(9345.0e6)
1547 self.lambda_ = 3.0e8/(9345.0e6)
1548 self.ippSec = dataOut.ippSeconds
1548 self.ippSec = dataOut.ippSeconds
1549 self.nCohInt = dataOut.nCohInt
1549 self.nCohInt = dataOut.nCohInt
1550 ####print("IPPseconds",dataOut.ippSeconds)
1550 ####print("IPPseconds",dataOut.ippSeconds)
1551 ####print("ELVALOR DE n es:", n)
1551 ####print("ELVALOR DE n es:", n)
1552 if n == None:
1552 if n == None:
1553 raise ValueError("n should be specified.")
1553 raise ValueError("n should be specified.")
1554
1554
1555 if n != None:
1555 if n != None:
1556 if n<2:
1556 if n<2:
1557 raise ValueError("n should be greater than 2")
1557 raise ValueError("n should be greater than 2")
1558
1558
1559 self.n = n
1559 self.n = n
1560 self.__nProf = n
1560 self.__nProf = n
1561
1561
1562 self.__buffer = numpy.zeros((dataOut.nChannels,
1562 self.__buffer = numpy.zeros((dataOut.nChannels,
1563 n,
1563 n,
1564 dataOut.nHeights),
1564 dataOut.nHeights),
1565 dtype='complex')
1565 dtype='complex')
1566
1566
1567 def putData(self,data):
1567 def putData(self,data):
1568 '''
1568 '''
1569 Add a profile to he __buffer and increase in one the __profiel Index
1569 Add a profile to he __buffer and increase in one the __profiel Index
1570 '''
1570 '''
1571 self.__buffer[:,self.__profIndex,:]= data
1571 self.__buffer[:,self.__profIndex,:]= data
1572 self.__profIndex += 1
1572 self.__profIndex += 1
1573 return
1573 return
1574
1574
1575 def putDataByBlock(self,data,n):
1575 def putDataByBlock(self,data,n):
1576 '''
1576 '''
1577 Add a profile to he __buffer and increase in one the __profiel Index
1577 Add a profile to he __buffer and increase in one the __profiel Index
1578 '''
1578 '''
1579 self.__buffer[:]= data
1579 self.__buffer[:]= data
1580 self.__profIndex = n
1580 self.__profIndex = n
1581 return
1581 return
1582
1582
1583 def pushData(self,dataOut):
1583 def pushData(self,dataOut):
1584 '''
1584 '''
1585 Return the PULSEPAIR and the profiles used in the operation
1585 Return the PULSEPAIR and the profiles used in the operation
1586 Affected : self.__profileIndex
1586 Affected : self.__profileIndex
1587 '''
1587 '''
1588 #----------------- Remove DC-----------------------------------
1588 #----------------- Remove DC-----------------------------------
1589 if self.removeDC==True:
1589 if self.removeDC==True:
1590 mean = numpy.mean(self.__buffer,1)
1590 mean = numpy.mean(self.__buffer,1)
1591 tmp = mean.reshape(self.__nch,1,self.__nHeis)
1591 tmp = mean.reshape(self.__nch,1,self.__nHeis)
1592 dc= numpy.tile(tmp,[1,self.__nProf,1])
1592 dc= numpy.tile(tmp,[1,self.__nProf,1])
1593 self.__buffer = self.__buffer - dc
1593 self.__buffer = self.__buffer - dc
1594 #------------------Calculo de Potencia ------------------------
1594 #------------------Calculo de Potencia ------------------------
1595 pair0 = self.__buffer*numpy.conj(self.__buffer)
1595 pair0 = self.__buffer*numpy.conj(self.__buffer)
1596 pair0 = pair0.real
1596 pair0 = pair0.real
1597 lag_0 = numpy.sum(pair0,1)
1597 lag_0 = numpy.sum(pair0,1)
1598 #-----------------Calculo de Cscp------------------------------ New
1598 #-----------------Calculo de Cscp------------------------------ New
1599 cspc_pair01 = self.__buffer[0]*self.__buffer[1]
1599 cspc_pair01 = self.__buffer[0]*self.__buffer[1]
1600 #------------------Calculo de Ruido x canal--------------------
1600 #------------------Calculo de Ruido x canal--------------------
1601 self.noise = numpy.zeros(self.__nch)
1601 self.noise = numpy.zeros(self.__nch)
1602 for i in range(self.__nch):
1602 for i in range(self.__nch):
1603 daux = numpy.sort(pair0[i,:,:],axis= None)
1603 daux = numpy.sort(pair0[i,:,:],axis= None)
1604 self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
1604 self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
1605
1605
1606 self.noise = self.noise.reshape(self.__nch,1)
1606 self.noise = self.noise.reshape(self.__nch,1)
1607 self.noise = numpy.tile(self.noise,[1,self.__nHeis])
1607 self.noise = numpy.tile(self.noise,[1,self.__nHeis])
1608 noise_buffer = self.noise.reshape(self.__nch,1,self.__nHeis)
1608 noise_buffer = self.noise.reshape(self.__nch,1,self.__nHeis)
1609 noise_buffer = numpy.tile(noise_buffer,[1,self.__nProf,1])
1609 noise_buffer = numpy.tile(noise_buffer,[1,self.__nProf,1])
1610 #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
1610 #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
1611 #------------------ P= S+N ,P=lag_0/N ---------------------------------
1611 #------------------ P= S+N ,P=lag_0/N ---------------------------------
1612 #-------------------- Power --------------------------------------------------
1612 #-------------------- Power --------------------------------------------------
1613 data_power = lag_0/(self.n*self.nCohInt)
1613 data_power = lag_0/(self.n*self.nCohInt)
1614 #--------------------CCF------------------------------------------------------
1614 #--------------------CCF------------------------------------------------------
1615 data_ccf =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
1615 data_ccf =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
1616 #------------------ Senal --------------------------------------------------
1616 #------------------ Senal --------------------------------------------------
1617 data_intensity = pair0 - noise_buffer
1617 data_intensity = pair0 - noise_buffer
1618 data_intensity = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
1618 data_intensity = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
1619 #data_intensity = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
1619 #data_intensity = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
1620 for i in range(self.__nch):
1620 for i in range(self.__nch):
1621 for j in range(self.__nHeis):
1621 for j in range(self.__nHeis):
1622 if data_intensity[i][j] < 0:
1622 if data_intensity[i][j] < 0:
1623 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
1623 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
1624
1624
1625 #----------------- Calculo de Frecuencia y Velocidad doppler--------
1625 #----------------- Calculo de Frecuencia y Velocidad doppler--------
1626 pair1 = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
1626 pair1 = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
1627 lag_1 = numpy.sum(pair1,1)
1627 lag_1 = numpy.sum(pair1,1)
1628 data_freq = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
1628 data_freq = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
1629 data_velocity = (self.lambda_/2.0)*data_freq
1629 data_velocity = (self.lambda_/2.0)*data_freq
1630
1630
1631 #---------------- Potencia promedio estimada de la Senal-----------
1631 #---------------- Potencia promedio estimada de la Senal-----------
1632 lag_0 = lag_0/self.n
1632 lag_0 = lag_0/self.n
1633 S = lag_0-self.noise
1633 S = lag_0-self.noise
1634
1634
1635 #---------------- Frecuencia Doppler promedio ---------------------
1635 #---------------- Frecuencia Doppler promedio ---------------------
1636 lag_1 = lag_1/(self.n-1)
1636 lag_1 = lag_1/(self.n-1)
1637 R1 = numpy.abs(lag_1)
1637 R1 = numpy.abs(lag_1)
1638
1638
1639 #---------------- Calculo del SNR----------------------------------
1639 #---------------- Calculo del SNR----------------------------------
1640 data_snrPP = S/self.noise
1640 data_snrPP = S/self.noise
1641 for i in range(self.__nch):
1641 for i in range(self.__nch):
1642 for j in range(self.__nHeis):
1642 for j in range(self.__nHeis):
1643 if data_snrPP[i][j] < 1.e-20:
1643 if data_snrPP[i][j] < 1.e-20:
1644 data_snrPP[i][j] = 1.e-20
1644 data_snrPP[i][j] = 1.e-20
1645
1645
1646 #----------------- Calculo del ancho espectral ----------------------
1646 #----------------- Calculo del ancho espectral ----------------------
1647 L = S/R1
1647 L = S/R1
1648 L = numpy.where(L<0,1,L)
1648 L = numpy.where(L<0,1,L)
1649 L = numpy.log(L)
1649 L = numpy.log(L)
1650 tmp = numpy.sqrt(numpy.absolute(L))
1650 tmp = numpy.sqrt(numpy.absolute(L))
1651 data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
1651 data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
1652 n = self.__profIndex
1652 n = self.__profIndex
1653
1653
1654 self.__buffer = numpy.zeros((self.__nch, self.__nProf,self.__nHeis), dtype='complex')
1654 self.__buffer = numpy.zeros((self.__nch, self.__nProf,self.__nHeis), dtype='complex')
1655 self.__profIndex = 0
1655 self.__profIndex = 0
1656 return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,data_ccf,n
1656 return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,data_ccf,n
1657
1657
1658
1658
1659 def pulsePairbyProfiles(self,dataOut,n):
1659 def pulsePairbyProfiles(self,dataOut,n):
1660
1660
1661 self.__dataReady = False
1661 self.__dataReady = False
1662 data_power = None
1662 data_power = None
1663 data_intensity = None
1663 data_intensity = None
1664 data_velocity = None
1664 data_velocity = None
1665 data_specwidth = None
1665 data_specwidth = None
1666 data_snrPP = None
1666 data_snrPP = None
1667 data_ccf = None
1667 data_ccf = None
1668
1668
1669 if dataOut.flagDataAsBlock:
1669 if dataOut.flagDataAsBlock:
1670 self.putDataByBlock(data=dataOut.data,n=n)
1670 self.putDataByBlock(data=dataOut.data,n=n)
1671 else:
1671 else:
1672 self.putData(data=dataOut.data)
1672 self.putData(data=dataOut.data)
1673 if self.__profIndex == self.n:
1673 if self.__profIndex == self.n:
1674 data_power,data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, n = self.pushData(dataOut=dataOut)
1674 data_power,data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, n = self.pushData(dataOut=dataOut)
1675 self.__dataReady = True
1675 self.__dataReady = True
1676
1676
1677 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf
1677 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf
1678
1678
1679
1679
1680 def pulsePairOp(self, dataOut, n, datatime= None):
1680 def pulsePairOp(self, dataOut, n, datatime= None):
1681
1681
1682 if self.__initime == None:
1682 if self.__initime == None:
1683 self.__initime = datatime
1683 self.__initime = datatime
1684 data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf = self.pulsePairbyProfiles(dataOut,n)
1684 data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf = self.pulsePairbyProfiles(dataOut,n)
1685 self.__lastdatatime = datatime
1685 self.__lastdatatime = datatime
1686
1686
1687 if data_power is None:
1687 if data_power is None:
1688 return None, None, None,None,None,None,None
1688 return None, None, None,None,None,None,None
1689
1689
1690 avgdatatime = self.__initime
1690 avgdatatime = self.__initime
1691 deltatime = datatime - self.__lastdatatime
1691 deltatime = datatime - self.__lastdatatime
1692 self.__initime = datatime
1692 self.__initime = datatime
1693
1693
1694 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf, avgdatatime
1694 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf, avgdatatime
1695
1695
1696 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1696 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1697 #print("hey")
1697
1698 #print(dataOut.data.shape)
1699 #exit(1)
1700 if dataOut.flagDataAsBlock:
1698 if dataOut.flagDataAsBlock:
1701 n = dataOut.nProfileBlocks
1699 n = dataOut.nProfiles
1702 #print(self.__profIndex)
1700
1703 if not self.isConfig:
1701 if not self.isConfig:
1704 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1702 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1705 self.isConfig = True
1703 self.isConfig = True
1706
1704
1707
1705
1708 data_power, data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, avgdatatime = self.pulsePairOp(dataOut, n, dataOut.utctime)
1706 data_power, data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, avgdatatime = self.pulsePairOp(dataOut, n, dataOut.utctime)
1709
1707
1710
1708
1711 dataOut.flagNoData = True
1709 dataOut.flagNoData = True
1712
1710
1713 if self.__dataReady:
1711 if self.__dataReady:
1714 ###print("READY ----------------------------------")
1712 ###print("READY ----------------------------------")
1715 dataOut.nCohInt *= self.n
1713 dataOut.nCohInt *= self.n
1716 dataOut.dataPP_POW = data_intensity # S
1714 dataOut.dataPP_POW = data_intensity # S
1717 dataOut.dataPP_POWER = data_power # P valor que corresponde a POTENCIA MOMENTO
1715 dataOut.dataPP_POWER = data_power # P valor que corresponde a POTENCIA MOMENTO
1718 dataOut.dataPP_DOP = data_velocity
1716 dataOut.dataPP_DOP = data_velocity
1719 dataOut.dataPP_SNR = data_snrPP
1717 dataOut.dataPP_SNR = data_snrPP
1720 dataOut.dataPP_WIDTH = data_specwidth
1718 dataOut.dataPP_WIDTH = data_specwidth
1721 dataOut.dataPP_CCF = data_ccf
1719 dataOut.dataPP_CCF = data_ccf
1722 dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo.
1720 dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo.
1723 dataOut.nProfiles = int(dataOut.nProfiles/n)
1721 dataOut.nProfiles = int(dataOut.nProfiles/n)
1724 dataOut.utctime = avgdatatime
1722 dataOut.utctime = avgdatatime
1725 dataOut.flagNoData = False
1723 dataOut.flagNoData = False
1726 return dataOut
1724 return dataOut
1727
1725
1728 # import collections
1726 # import collections
1729 # from scipy.stats import mode
1727 # from scipy.stats import mode
1730 #
1728 #
1731 # class Synchronize(Operation):
1729 # class Synchronize(Operation):
1732 #
1730 #
1733 # isConfig = False
1731 # isConfig = False
1734 # __profIndex = 0
1732 # __profIndex = 0
1735 #
1733 #
1736 # def __init__(self, **kwargs):
1734 # def __init__(self, **kwargs):
1737 #
1735 #
1738 # Operation.__init__(self, **kwargs)
1736 # Operation.__init__(self, **kwargs)
1739 # # self.isConfig = False
1737 # # self.isConfig = False
1740 # self.__powBuffer = None
1738 # self.__powBuffer = None
1741 # self.__startIndex = 0
1739 # self.__startIndex = 0
1742 # self.__pulseFound = False
1740 # self.__pulseFound = False
1743 #
1741 #
1744 # def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
1742 # def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
1745 #
1743 #
1746 # #Read data
1744 # #Read data
1747 #
1745 #
1748 # powerdB = dataOut.getPower(channel = channel)
1746 # powerdB = dataOut.getPower(channel = channel)
1749 # noisedB = dataOut.getNoise(channel = channel)[0]
1747 # noisedB = dataOut.getNoise(channel = channel)[0]
1750 #
1748 #
1751 # self.__powBuffer.extend(powerdB.flatten())
1749 # self.__powBuffer.extend(powerdB.flatten())
1752 #
1750 #
1753 # dataArray = numpy.array(self.__powBuffer)
1751 # dataArray = numpy.array(self.__powBuffer)
1754 #
1752 #
1755 # filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
1753 # filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
1756 #
1754 #
1757 # maxValue = numpy.nanmax(filteredPower)
1755 # maxValue = numpy.nanmax(filteredPower)
1758 #
1756 #
1759 # if maxValue < noisedB + 10:
1757 # if maxValue < noisedB + 10:
1760 # #No se encuentra ningun pulso de transmision
1758 # #No se encuentra ningun pulso de transmision
1761 # return None
1759 # return None
1762 #
1760 #
1763 # maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
1761 # maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
1764 #
1762 #
1765 # if len(maxValuesIndex) < 2:
1763 # if len(maxValuesIndex) < 2:
1766 # #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
1764 # #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
1767 # return None
1765 # return None
1768 #
1766 #
1769 # phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
1767 # phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
1770 #
1768 #
1771 # #Seleccionar solo valores con un espaciamiento de nSamples
1769 # #Seleccionar solo valores con un espaciamiento de nSamples
1772 # pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
1770 # pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
1773 #
1771 #
1774 # if len(pulseIndex) < 2:
1772 # if len(pulseIndex) < 2:
1775 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1773 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1776 # return None
1774 # return None
1777 #
1775 #
1778 # spacing = pulseIndex[1:] - pulseIndex[:-1]
1776 # spacing = pulseIndex[1:] - pulseIndex[:-1]
1779 #
1777 #
1780 # #remover senales que se distancien menos de 10 unidades o muestras
1778 # #remover senales que se distancien menos de 10 unidades o muestras
1781 # #(No deberian existir IPP menor a 10 unidades)
1779 # #(No deberian existir IPP menor a 10 unidades)
1782 #
1780 #
1783 # realIndex = numpy.where(spacing > 10 )[0]
1781 # realIndex = numpy.where(spacing > 10 )[0]
1784 #
1782 #
1785 # if len(realIndex) < 2:
1783 # if len(realIndex) < 2:
1786 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1784 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1787 # return None
1785 # return None
1788 #
1786 #
1789 # #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
1787 # #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
1790 # realPulseIndex = pulseIndex[realIndex]
1788 # realPulseIndex = pulseIndex[realIndex]
1791 #
1789 #
1792 # period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
1790 # period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
1793 #
1791 #
1794 # print "IPP = %d samples" %period
1792 # print "IPP = %d samples" %period
1795 #
1793 #
1796 # self.__newNSamples = dataOut.nHeights #int(period)
1794 # self.__newNSamples = dataOut.nHeights #int(period)
1797 # self.__startIndex = int(realPulseIndex[0])
1795 # self.__startIndex = int(realPulseIndex[0])
1798 #
1796 #
1799 # return 1
1797 # return 1
1800 #
1798 #
1801 #
1799 #
1802 # def setup(self, nSamples, nChannels, buffer_size = 4):
1800 # def setup(self, nSamples, nChannels, buffer_size = 4):
1803 #
1801 #
1804 # self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
1802 # self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
1805 # maxlen = buffer_size*nSamples)
1803 # maxlen = buffer_size*nSamples)
1806 #
1804 #
1807 # bufferList = []
1805 # bufferList = []
1808 #
1806 #
1809 # for i in range(nChannels):
1807 # for i in range(nChannels):
1810 # bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) + numpy.NAN,
1808 # bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) + numpy.NAN,
1811 # maxlen = buffer_size*nSamples)
1809 # maxlen = buffer_size*nSamples)
1812 #
1810 #
1813 # bufferList.append(bufferByChannel)
1811 # bufferList.append(bufferByChannel)
1814 #
1812 #
1815 # self.__nSamples = nSamples
1813 # self.__nSamples = nSamples
1816 # self.__nChannels = nChannels
1814 # self.__nChannels = nChannels
1817 # self.__bufferList = bufferList
1815 # self.__bufferList = bufferList
1818 #
1816 #
1819 # def run(self, dataOut, channel = 0):
1817 # def run(self, dataOut, channel = 0):
1820 #
1818 #
1821 # if not self.isConfig:
1819 # if not self.isConfig:
1822 # nSamples = dataOut.nHeights
1820 # nSamples = dataOut.nHeights
1823 # nChannels = dataOut.nChannels
1821 # nChannels = dataOut.nChannels
1824 # self.setup(nSamples, nChannels)
1822 # self.setup(nSamples, nChannels)
1825 # self.isConfig = True
1823 # self.isConfig = True
1826 #
1824 #
1827 # #Append new data to internal buffer
1825 # #Append new data to internal buffer
1828 # for thisChannel in range(self.__nChannels):
1826 # for thisChannel in range(self.__nChannels):
1829 # bufferByChannel = self.__bufferList[thisChannel]
1827 # bufferByChannel = self.__bufferList[thisChannel]
1830 # bufferByChannel.extend(dataOut.data[thisChannel])
1828 # bufferByChannel.extend(dataOut.data[thisChannel])
1831 #
1829 #
1832 # if self.__pulseFound:
1830 # if self.__pulseFound:
1833 # self.__startIndex -= self.__nSamples
1831 # self.__startIndex -= self.__nSamples
1834 #
1832 #
1835 # #Finding Tx Pulse
1833 # #Finding Tx Pulse
1836 # if not self.__pulseFound:
1834 # if not self.__pulseFound:
1837 # indexFound = self.__findTxPulse(dataOut, channel)
1835 # indexFound = self.__findTxPulse(dataOut, channel)
1838 #
1836 #
1839 # if indexFound == None:
1837 # if indexFound == None:
1840 # dataOut.flagNoData = True
1838 # dataOut.flagNoData = True
1841 # return
1839 # return
1842 #
1840 #
1843 # self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
1841 # self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
1844 # self.__pulseFound = True
1842 # self.__pulseFound = True
1845 # self.__startIndex = indexFound
1843 # self.__startIndex = indexFound
1846 #
1844 #
1847 # #If pulse was found ...
1845 # #If pulse was found ...
1848 # for thisChannel in range(self.__nChannels):
1846 # for thisChannel in range(self.__nChannels):
1849 # bufferByChannel = self.__bufferList[thisChannel]
1847 # bufferByChannel = self.__bufferList[thisChannel]
1850 # #print self.__startIndex
1848 # #print self.__startIndex
1851 # x = numpy.array(bufferByChannel)
1849 # x = numpy.array(bufferByChannel)
1852 # self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
1850 # self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
1853 #
1851 #
1854 # deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1852 # deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1855 # dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
1853 # dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
1856 # # dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
1854 # # dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
1857 #
1855 #
1858 # dataOut.data = self.__arrayBuffer
1856 # dataOut.data = self.__arrayBuffer
1859 #
1857 #
1860 # self.__startIndex += self.__newNSamples
1858 # self.__startIndex += self.__newNSamples
1861 #
1859 #
1862 # return
1860 # return
General Comments 0
You need to be logged in to leave comments. Login now