##// END OF EJS Templates
schain
RSS
v2.2.0: Controller updated
Miguel Valdez -
r708:e5ce72bc2207
parent child
Show More

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

Show file before | Show file after | Hide comments
@@ -1,38 +1,36
1 1 Prerequisites:
2 2
3 3 Core:
4 4 -numpy 1.8.0
5 5 -scipy
6 6 -math
7 7 -matplotlib
8 8 -h5py
9 9 -ftplib
10 10 -paramiko (optional for SendTFilesToServer)
11 11 -stuffr (optional for jroIO_hf)
12 12 -pyfits (Fits data)
13 13
14 14 GUI:
15 15 -PyQt4
16 16 -wxPython
17 -msgpack-numpy
18 -cPickle
19 17
20 18 Signal Chain Installation:
21 19
22 20 1. Install numpy, matplotlib, TKAgg
23 21 2. Install digital_rf_hdf5 module (developed by Haystack Observatory)
24 22 if you want to use USRP data
25 23 3. untar schainpy-x.x.x.tar.gz
26 24 4. cd schainpy-x.x.x
27 25 5. execute:
28 26 [hostname]$ sudo pyhon setup.py install
29 27 6. testing gui:
30 28 [hostname]$ schainGUI (enter)
31 29
32 30 If you want to use serialization and zerorpc you will need to install the next packages:
33 31
34 32 1. zerorpc
35 33 [hostname]$ sudo port install zerorpc
36 34
37 35 2. cPickle, msgpack and msgpack_numpy
38 36 [hostname]$ sudo port install cPickle msgpack mspack_numpy No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,7 +1,7
1 1 '''
2 2 Created on Feb 7, 2012
3 3
4 4 @author $Author$
5 5 @version $Id$
6 6 '''
7 __version__ = "2.1.5" No newline at end of file
7 __version__ = "2.2.0" No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1263 +1,1289
1 1 '''
2 2 Created on September , 2012
3 3 @author:
4 4 '''
5 5
6 6 import sys
7 7 import ast
8 8 import datetime
9 9 import traceback
10 10 import schainpy
11 11 import schainpy.admin
12 12
13 13 from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
14 14 from xml.dom import minidom
15 15
16 16 from schainpy.model import *
17 17 from time import sleep
18 18
19 19 def prettify(elem):
20 20 """Return a pretty-printed XML string for the Element.
21 21 """
22 22 rough_string = tostring(elem, 'utf-8')
23 23 reparsed = minidom.parseString(rough_string)
24 24 return reparsed.toprettyxml(indent=" ")
25 25
26 26 class ParameterConf():
27 27
28 28 id = None
29 29 name = None
30 30 value = None
31 31 format = None
32 32
33 33 __formated_value = None
34 34
35 35 ELEMENTNAME = 'Parameter'
36 36
37 37 def __init__(self):
38 38
39 39 self.format = 'str'
40 40
41 41 def getElementName(self):
42 42
43 43 return self.ELEMENTNAME
44 44
45 45 def getValue(self):
46 46
47 47 value = self.value
48 48 format = self.format
49 49
50 50 if self.__formated_value != None:
51 51
52 52 return self.__formated_value
53 53
54 54 if format == 'str':
55 55 self.__formated_value = str(value)
56 56 return self.__formated_value
57 57
58 58 if value == '':
59 59 raise ValueError, "%s: This parameter value is empty" %self.name
60 60
61 61 if format == 'list':
62 62 strList = value.split(',')
63 63
64 64 self.__formated_value = strList
65 65
66 66 return self.__formated_value
67 67
68 68 if format == 'intlist':
69 69 """
70 70 Example:
71 71 value = (0,1,2)
72 72 """
73 73 value = value.replace('(', '')
74 74 value = value.replace(')', '')
75 75
76 76 value = value.replace('[', '')
77 77 value = value.replace(']', '')
78 78
79 79 strList = value.split(',')
80 80 intList = [int(float(x)) for x in strList]
81 81
82 82 self.__formated_value = intList
83 83
84 84 return self.__formated_value
85 85
86 86 if format == 'floatlist':
87 87 """
88 88 Example:
89 89 value = (0.5, 1.4, 2.7)
90 90 """
91 91
92 92 value = value.replace('(', '')
93 93 value = value.replace(')', '')
94 94
95 95 value = value.replace('[', '')
96 96 value = value.replace(']', '')
97 97
98 98 strList = value.split(',')
99 99 floatList = [float(x) for x in strList]
100 100
101 101 self.__formated_value = floatList
102 102
103 103 return self.__formated_value
104 104
105 105 if format == 'date':
106 106 strList = value.split('/')
107 107 intList = [int(x) for x in strList]
108 108 date = datetime.date(intList[0], intList[1], intList[2])
109 109
110 110 self.__formated_value = date
111 111
112 112 return self.__formated_value
113 113
114 114 if format == 'time':
115 115 strList = value.split(':')
116 116 intList = [int(x) for x in strList]
117 117 time = datetime.time(intList[0], intList[1], intList[2])
118 118
119 119 self.__formated_value = time
120 120
121 121 return self.__formated_value
122 122
123 123 if format == 'pairslist':
124 124 """
125 125 Example:
126 126 value = (0,1),(1,2)
127 127 """
128 128
129 129 value = value.replace('(', '')
130 130 value = value.replace(')', '')
131 131
132 132 value = value.replace('[', '')
133 133 value = value.replace(']', '')
134 134
135 135 strList = value.split(',')
136 136 intList = [int(item) for item in strList]
137 137 pairList = []
138 138 for i in range(len(intList)/2):
139 139 pairList.append((intList[i*2], intList[i*2 + 1]))
140 140
141 141 self.__formated_value = pairList
142 142
143 143 return self.__formated_value
144 144
145 145 if format == 'multilist':
146 146 """
147 147 Example:
148 148 value = (0,1,2),(3,4,5)
149 149 """
150 150 multiList = ast.literal_eval(value)
151 151
152 152 if type(multiList[0]) == int:
153 153 multiList = ast.literal_eval("(" + value + ")")
154 154
155 155 self.__formated_value = multiList
156 156
157 157 return self.__formated_value
158 158
159 159 if format == 'bool':
160 160 value = int(value)
161 161
162 162 if format == 'int':
163 163 value = float(value)
164 164
165 165 format_func = eval(format)
166 166
167 167 self.__formated_value = format_func(value)
168 168
169 169 return self.__formated_value
170 170
171 171 def updateId(self, new_id):
172 172
173 173 self.id = str(new_id)
174 174
175 175 def setup(self, id, name, value, format='str'):
176 176
177 177 self.id = str(id)
178 178 self.name = name
179 179 self.value = str(value)
180 180 self.format = str.lower(format)
181 181
182 182 try:
183 183 self.getValue()
184 184 except:
185 185 return 0
186 186
187 187 return 1
188 188
189 189 def update(self, name, value, format='str'):
190 190
191 191 self.name = name
192 192 self.value = str(value)
193 193 self.format = format
194 194
195 195 def makeXml(self, opElement):
196 196
197 197 parmElement = SubElement(opElement, self.ELEMENTNAME)
198 198 parmElement.set('id', str(self.id))
199 199 parmElement.set('name', self.name)
200 200 parmElement.set('value', self.value)
201 201 parmElement.set('format', self.format)
202 202
203 203 def readXml(self, parmElement):
204 204
205 205 self.id = parmElement.get('id')
206 206 self.name = parmElement.get('name')
207 207 self.value = parmElement.get('value')
208 208 self.format = str.lower(parmElement.get('format'))
209 209
210 210 #Compatible with old signal chain version
211 211 if self.format == 'int' and self.name == 'idfigure':
212 212 self.name = 'id'
213 213
214 214 def printattr(self):
215 215
216 216 print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
217 217
218 218 class OperationConf():
219 219
220 220 id = None
221 221 name = None
222 222 priority = None
223 223 type = None
224 224
225 225 parmConfObjList = []
226 226
227 227 ELEMENTNAME = 'Operation'
228 228
229 229 def __init__(self):
230 230
231 231 self.id = '0'
232 232 self.name = None
233 233 self.priority = None
234 234 self.type = 'self'
235 235
236 236
237 237 def __getNewId(self):
238 238
239 239 return int(self.id)*10 + len(self.parmConfObjList) + 1
240 240
241 241 def updateId(self, new_id):
242 242
243 243 self.id = str(new_id)
244 244
245 245 n = 1
246 246 for parmObj in self.parmConfObjList:
247 247
248 248 idParm = str(int(new_id)*10 + n)
249 249 parmObj.updateId(idParm)
250 250
251 251 n += 1
252 252
253 253 def getElementName(self):
254 254
255 255 return self.ELEMENTNAME
256 256
257 257 def getParameterObjList(self):
258 258
259 259 return self.parmConfObjList
260 260
261 261 def getParameterObj(self, parameterName):
262 262
263 263 for parmConfObj in self.parmConfObjList:
264 264
265 265 if parmConfObj.name != parameterName:
266 266 continue
267 267
268 268 return parmConfObj
269 269
270 270 return None
271 271
272 272 def getParameterObjfromValue(self, parameterValue):
273 273
274 274 for parmConfObj in self.parmConfObjList:
275 275
276 276 if parmConfObj.getValue() != parameterValue:
277 277 continue
278 278
279 279 return parmConfObj.getValue()
280 280
281 281 return None
282 282
283 283 def getParameterValue(self, parameterName):
284 284
285 285 parameterObj = self.getParameterObj(parameterName)
286 286
287 287 # if not parameterObj:
288 288 # return None
289 289
290 290 value = parameterObj.getValue()
291 291
292 292 return value
293 293
294 294 def setup(self, id, name, priority, type):
295 295
296 296 self.id = str(id)
297 297 self.name = name
298 298 self.type = type
299 299 self.priority = priority
300 300
301 301 self.parmConfObjList = []
302 302
303 303 def removeParameters(self):
304 304
305 305 for obj in self.parmConfObjList:
306 306 del obj
307 307
308 308 self.parmConfObjList = []
309 309
310 310 def addParameter(self, name, value, format='str'):
311 311
312 312 id = self.__getNewId()
313 313
314 314 parmConfObj = ParameterConf()
315 315 if not parmConfObj.setup(id, name, value, format):
316 316 return None
317 317
318 318 self.parmConfObjList.append(parmConfObj)
319 319
320 320 return parmConfObj
321 321
322 322 def changeParameter(self, name, value, format='str'):
323 323
324 324 parmConfObj = self.getParameterObj(name)
325 325 parmConfObj.update(name, value, format)
326 326
327 327 return parmConfObj
328 328
329 329 def makeXml(self, procUnitElement):
330 330
331 331 opElement = SubElement(procUnitElement, self.ELEMENTNAME)
332 332 opElement.set('id', str(self.id))
333 333 opElement.set('name', self.name)
334 334 opElement.set('type', self.type)
335 335 opElement.set('priority', str(self.priority))
336 336
337 337 for parmConfObj in self.parmConfObjList:
338 338 parmConfObj.makeXml(opElement)
339 339
340 340 def readXml(self, opElement):
341 341
342 342 self.id = opElement.get('id')
343 343 self.name = opElement.get('name')
344 344 self.type = opElement.get('type')
345 345 self.priority = opElement.get('priority')
346 346
347 347 #Compatible with old signal chain version
348 348 #Use of 'run' method instead 'init'
349 349 if self.type == 'self' and self.name == 'init':
350 350 self.name = 'run'
351 351
352 352 self.parmConfObjList = []
353 353
354 354 parmElementList = opElement.getiterator(ParameterConf().getElementName())
355 355
356 356 for parmElement in parmElementList:
357 357 parmConfObj = ParameterConf()
358 358 parmConfObj.readXml(parmElement)
359 359
360 360 #Compatible with old signal chain version
361 361 #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
362 362 if self.type != 'self' and self.name == 'Plot':
363 363 if parmConfObj.format == 'str' and parmConfObj.name == 'type':
364 364 self.name = parmConfObj.value
365 365 continue
366 366
367 367 self.parmConfObjList.append(parmConfObj)
368 368
369 369 def printattr(self):
370 370
371 371 print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
372 372 self.id,
373 373 self.name,
374 374 self.type,
375 375 self.priority)
376 376
377 377 for parmConfObj in self.parmConfObjList:
378 378 parmConfObj.printattr()
379 379
380 380 def createObject(self, plotter_queue=None):
381 381
382 382 if self.type == 'self':
383 383 raise ValueError, "This operation type cannot be created"
384 384
385 385 if self.type == 'plotter':
386 386 #Plotter(plotter_name)
387 if not plotter_queue:
388 raise ValueError, "plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)"
389
387 390 opObj = Plotter(self.name, plotter_queue)
388 391
389 392 if self.type == 'external' or self.type == 'other':
390 393 className = eval(self.name)
391 394 opObj = className()
392 395
393 396 return opObj
394 397
395 398 class ProcUnitConf():
396 399
397 400 id = None
398 401 name = None
399 402 datatype = None
400 403 inputId = None
401 404 parentId = None
402 405
403 406 opConfObjList = []
404 407
405 408 procUnitObj = None
406 409 opObjList = []
407 410
408 411 ELEMENTNAME = 'ProcUnit'
409 412
410 413 def __init__(self):
411 414
412 415 self.id = None
413 416 self.datatype = None
414 417 self.name = None
415 418 self.inputId = None
416 419
417 420 self.opConfObjList = []
418 421
419 422 self.procUnitObj = None
420 423 self.opObjDict = {}
421 424
422 425 def __getPriority(self):
423 426
424 427 return len(self.opConfObjList)+1
425 428
426 429 def __getNewId(self):
427 430
428 431 return int(self.id)*10 + len(self.opConfObjList) + 1
429 432
430 433 def getElementName(self):
431 434
432 435 return self.ELEMENTNAME
433 436
434 437 def getId(self):
435 438
436 439 return self.id
437 440
438 441 def updateId(self, new_id, parentId=parentId):
439 442
440 443
441 444 new_id = int(parentId)*10 + (int(self.id) % 10)
442 445 new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
443 446
444 447 #If this proc unit has not inputs
445 448 if self.inputId == '0':
446 449 new_inputId = 0
447 450
448 451 n = 1
449 452 for opConfObj in self.opConfObjList:
450 453
451 454 idOp = str(int(new_id)*10 + n)
452 455 opConfObj.updateId(idOp)
453 456
454 457 n += 1
455 458
456 459 self.parentId = str(parentId)
457 460 self.id = str(new_id)
458 461 self.inputId = str(new_inputId)
459 462
460 463
461 464 def getInputId(self):
462 465
463 466 return self.inputId
464 467
465 468 def getOperationObjList(self):
466 469
467 470 return self.opConfObjList
468 471
469 472 def getOperationObj(self, name=None):
470 473
471 474 for opConfObj in self.opConfObjList:
472 475
473 476 if opConfObj.name != name:
474 477 continue
475 478
476 479 return opConfObj
477 480
478 481 return None
479 482
480 483 def getOpObjfromParamValue(self, value=None):
481 484
482 485 for opConfObj in self.opConfObjList:
483 486 if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
484 487 continue
485 488 return opConfObj
486 489 return None
487 490
488 491 def getProcUnitObj(self):
489 492
490 493 return self.procUnitObj
491 494
492 495 def setup(self, id, name, datatype, inputId, parentId=None):
493 496
494 497 #Compatible with old signal chain version
495 498 if datatype==None and name==None:
496 499 raise ValueError, "datatype or name should be defined"
497 500
498 501 if name==None:
499 502 if 'Proc' in datatype:
500 503 name = datatype
501 504 else:
502 505 name = '%sProc' %(datatype)
503 506
504 507 if datatype==None:
505 508 datatype = name.replace('Proc','')
506 509
507 510 self.id = str(id)
508 511 self.name = name
509 512 self.datatype = datatype
510 513 self.inputId = inputId
511 514 self.parentId = parentId
512 515
513 516 self.opConfObjList = []
514 517
515 518 self.addOperation(name='run', optype='self')
516 519
517 520 def removeOperations(self):
518 521
519 522 for obj in self.opConfObjList:
520 523 del obj
521 524
522 525 self.opConfObjList = []
523 526 self.addOperation(name='run')
524 527
525 528 def addParameter(self, **kwargs):
526 529 '''
527 530 Add parameters to "run" operation
528 531 '''
529 532 opObj = self.opConfObjList[0]
530 533
531 534 opObj.addParameter(**kwargs)
532 535
533 536 return opObj
534 537
535 538 def addOperation(self, name, optype='self'):
536 539
537 540 id = self.__getNewId()
538 541 priority = self.__getPriority()
539 542
540 543 opConfObj = OperationConf()
541 544 opConfObj.setup(id, name=name, priority=priority, type=optype)
542 545
543 546 self.opConfObjList.append(opConfObj)
544 547
545 548 return opConfObj
546 549
547 550 def makeXml(self, projectElement):
548 551
549 552 procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
550 553 procUnitElement.set('id', str(self.id))
551 554 procUnitElement.set('name', self.name)
552 555 procUnitElement.set('datatype', self.datatype)
553 556 procUnitElement.set('inputId', str(self.inputId))
554 557
555 558 for opConfObj in self.opConfObjList:
556 559 opConfObj.makeXml(procUnitElement)
557 560
558 561 def readXml(self, upElement):
559 562
560 563 self.id = upElement.get('id')
561 564 self.name = upElement.get('name')
562 565 self.datatype = upElement.get('datatype')
563 566 self.inputId = upElement.get('inputId')
564 567
565 568 if self.ELEMENTNAME == "ReadUnit":
566 569 self.datatype = self.datatype.replace("Reader", "")
567 570
568 571 if self.ELEMENTNAME == "ProcUnit":
569 572 self.datatype = self.datatype.replace("Proc", "")
570 573
571 574 if self.inputId == 'None':
572 575 self.inputId = '0'
573 576
574 577 self.opConfObjList = []
575 578
576 579 opElementList = upElement.getiterator(OperationConf().getElementName())
577 580
578 581 for opElement in opElementList:
579 582 opConfObj = OperationConf()
580 583 opConfObj.readXml(opElement)
581 584 self.opConfObjList.append(opConfObj)
582 585
583 586 def printattr(self):
584 587
585 588 print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
586 589 self.id,
587 590 self.name,
588 591 self.datatype,
589 592 self.inputId)
590 593
591 594 for opConfObj in self.opConfObjList:
592 595 opConfObj.printattr()
593 596
594 597 def createObjects(self, plotter_queue=None):
595 598
596 599 className = eval(self.name)
597 600 procUnitObj = className()
598 601
599 602 for opConfObj in self.opConfObjList:
600 603
601 604 if opConfObj.type == 'self':
602 605 continue
603 606
604 607 opObj = opConfObj.createObject(plotter_queue)
605 608
606 609 self.opObjDict[opConfObj.id] = opObj
607 610 procUnitObj.addOperation(opObj, opConfObj.id)
608 611
609 612 self.procUnitObj = procUnitObj
610 613
611 614 return procUnitObj
612 615
613 616 def run(self):
614 617
615 618 is_ok = False
616 619
617 620 for opConfObj in self.opConfObjList:
618 621
619 622 kwargs = {}
620 623 for parmConfObj in opConfObj.getParameterObjList():
621 624 if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
622 625 continue
623 626
624 627 kwargs[parmConfObj.name] = parmConfObj.getValue()
625 628
626 629 #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
627 630 sts = self.procUnitObj.call(opType = opConfObj.type,
628 631 opName = opConfObj.name,
629 632 opId = opConfObj.id,
630 633 **kwargs)
631 634 is_ok = is_ok or sts
632 635
633 636 return is_ok
634 637
635 638 def close(self):
636 639
637 640 for opConfObj in self.opConfObjList:
638 641 if opConfObj.type == 'self':
639 642 continue
640 643
641 644 opObj = self.procUnitObj.getOperationObj(opConfObj.id)
642 645 opObj.close()
643 646
644 647 self.procUnitObj.close()
645 648
646 649 return
647 650
648 651 class ReadUnitConf(ProcUnitConf):
649 652
650 653 path = None
651 654 startDate = None
652 655 endDate = None
653 656 startTime = None
654 657 endTime = None
655 658
656 659 ELEMENTNAME = 'ReadUnit'
657 660
658 661 def __init__(self):
659 662
660 663 self.id = None
661 664 self.datatype = None
662 665 self.name = None
663 666 self.inputId = None
664 667
665 668 self.parentId = None
666 669
667 670 self.opConfObjList = []
668 671 self.opObjList = []
669 672
670 673 def getElementName(self):
671 674
672 675 return self.ELEMENTNAME
673 676
674 677 def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, **kwargs):
675 678
676 679 #Compatible with old signal chain version
677 680 if datatype==None and name==None:
678 681 raise ValueError, "datatype or name should be defined"
679 682
680 683 if name==None:
681 684 if 'Reader' in datatype:
682 685 name = datatype
683 686 else:
684 687 name = '%sReader' %(datatype)
685 688
686 689 if datatype==None:
687 690 datatype = name.replace('Reader','')
688 691
689 692 self.id = id
690 693 self.name = name
691 694 self.datatype = datatype
692 695
693 696 self.path = os.path.abspath(path)
694 697 self.startDate = startDate
695 698 self.endDate = endDate
696 699 self.startTime = startTime
697 700 self.endTime = endTime
698 701
699 702 self.inputId = '0'
700 703 self.parentId = parentId
701 704
702 705 self.addRunOperation(**kwargs)
703 706
704 707 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
705 708
706 709 #Compatible with old signal chain version
707 710 if datatype==None and name==None:
708 711 raise ValueError, "datatype or name should be defined"
709 712
710 713 if name==None:
711 714 if 'Reader' in datatype:
712 715 name = datatype
713 716 else:
714 717 name = '%sReader' %(datatype)
715 718
716 719 if datatype==None:
717 720 datatype = name.replace('Reader','')
718 721
719 722 self.datatype = datatype
720 723 self.name = name
721 724 self.path = path
722 725 self.startDate = startDate
723 726 self.endDate = endDate
724 727 self.startTime = startTime
725 728 self.endTime = endTime
726 729
727 730 self.inputId = '0'
728 731 self.parentId = parentId
729 732
730 733 self.updateRunOperation(**kwargs)
731 734
732 735 def removeOperations(self):
733 736
734 737 for obj in self.opConfObjList:
735 738 del obj
736 739
737 740 self.opConfObjList = []
738 741
739 742 def addRunOperation(self, **kwargs):
740 743
741 744 opObj = self.addOperation(name = 'run', optype = 'self')
742 745
743 746 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
744 747 opObj.addParameter(name='path' , value=self.path, format='str')
745 748 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
746 749 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
747 750 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
748 751 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
749 752
750 753 for key, value in kwargs.items():
751 754 opObj.addParameter(name=key, value=value, format=type(value).__name__)
752 755
753 756 return opObj
754 757
755 758 def updateRunOperation(self, **kwargs):
756 759
757 760 opObj = self.getOperationObj(name = 'run')
758 761 opObj.removeParameters()
759 762
760 763 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
761 764 opObj.addParameter(name='path' , value=self.path, format='str')
762 765 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
763 766 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
764 767 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
765 768 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
766 769
767 770 for key, value in kwargs.items():
768 771 opObj.addParameter(name=key, value=value, format=type(value).__name__)
769 772
770 773 return opObj
771 774
772 775 # def makeXml(self, projectElement):
773 776 #
774 777 # procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
775 778 # procUnitElement.set('id', str(self.id))
776 779 # procUnitElement.set('name', self.name)
777 780 # procUnitElement.set('datatype', self.datatype)
778 781 # procUnitElement.set('inputId', str(self.inputId))
779 782 #
780 783 # for opConfObj in self.opConfObjList:
781 784 # opConfObj.makeXml(procUnitElement)
782 785
783 786 def readXml(self, upElement):
784 787
785 788 self.id = upElement.get('id')
786 789 self.name = upElement.get('name')
787 790 self.datatype = upElement.get('datatype')
788 791 self.inputId = upElement.get('inputId')
789 792
790 793 if self.ELEMENTNAME == "ReadUnit":
791 794 self.datatype = self.datatype.replace("Reader", "")
792 795
793 796 if self.inputId == 'None':
794 797 self.inputId = '0'
795 798
796 799 self.opConfObjList = []
797 800
798 801 opElementList = upElement.getiterator(OperationConf().getElementName())
799 802
800 803 for opElement in opElementList:
801 804 opConfObj = OperationConf()
802 805 opConfObj.readXml(opElement)
803 806 self.opConfObjList.append(opConfObj)
804 807
805 808 if opConfObj.name == 'run':
806 809 self.path = opConfObj.getParameterValue('path')
807 810 self.startDate = opConfObj.getParameterValue('startDate')
808 811 self.endDate = opConfObj.getParameterValue('endDate')
809 812 self.startTime = opConfObj.getParameterValue('startTime')
810 813 self.endTime = opConfObj.getParameterValue('endTime')
811 814
812 815 class Project():
813 816
814 817 id = None
815 818 name = None
816 819 description = None
817 820 filename = None
818 821
819 822 procUnitConfObjDict = None
820 823
821 824 ELEMENTNAME = 'Project'
822 825
823 826 __plotterQueue = None
824 827
825 def __init__(self, filename=None, plotter_queue=None):
828 def __init__(self, plotter_queue=None):
826 829
827 830 self.id = None
828 831 self.name = None
829 832 self.description = None
830 833
831 self.filename = filename
832 834 self.__plotterQueue = plotter_queue
833 835
834 836 self.procUnitConfObjDict = {}
835 837
836 838 def __getNewId(self):
837 839
838 840 id = int(self.id)*10 + len(self.procUnitConfObjDict) + 1
839 841
840 842 return str(id)
841 843
842 844 def getElementName(self):
843 845
844 846 return self.ELEMENTNAME
845 847
846 848 def getId(self):
847 849
848 850 return self.id
849 851
850 852 def updateId(self, new_id):
851 853
852 854 self.id = str(new_id)
853 855
854 856 keyList = self.procUnitConfObjDict.keys()
855 857 keyList.sort()
856 858
857 859 n = 1
858 860 newProcUnitConfObjDict = {}
859 861
860 862 for procKey in keyList:
861 863
862 864 procUnitConfObj = self.procUnitConfObjDict[procKey]
863 865 idProcUnit = str(int(self.id)*10 + n)
864 866 procUnitConfObj.updateId(idProcUnit, parentId = self.id)
865 867
866 868 newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
867 869 n += 1
868 870
869 871 self.procUnitConfObjDict = newProcUnitConfObjDict
870 872
871 873 def setup(self, id, name, description):
872 874
873 875 self.id = str(id)
874 876 self.name = name
875 877 self.description = description
876 878
877 879 def update(self, name, description):
878 880
879 881 self.name = name
880 882 self.description = description
881 883
882 884 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
883 885
884 886 if id is None:
885 887 idReadUnit = self.__getNewId()
886 888 else:
887 889 idReadUnit = str(id)
888 890
889 891 readUnitConfObj = ReadUnitConf()
890 892 readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
891 893
892 894 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
893 895
894 896 return readUnitConfObj
895 897
896 898 def addProcUnit(self, inputId='0', datatype=None, name=None):
897 899
898 900 idProcUnit = self.__getNewId()
899 901
900 902 procUnitConfObj = ProcUnitConf()
901 903 procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
902 904
903 905 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
904 906
905 907 return procUnitConfObj
906 908
907 909 def removeProcUnit(self, id):
908 910
909 911 if id in self.procUnitConfObjDict.keys():
910 912 self.procUnitConfObjDict.pop(id)
911 913
912 914 def getReadUnitId(self):
913 915
914 916 readUnitConfObj = self.getReadUnitObj()
915 917
916 918 return readUnitConfObj.id
917 919
918 920 def getReadUnitObj(self):
919 921
920 922 for obj in self.procUnitConfObjDict.values():
921 923 if obj.getElementName() == "ReadUnit":
922 924 return obj
923 925
924 926 return None
925 927
926 928 def getProcUnitObj(self, id=None, name=None):
927 929
928 930 if id != None:
929 931 return self.procUnitConfObjDict[id]
930 932
931 933 if name != None:
932 934 return self.getProcUnitObjByName(name)
933 935
934 936 return None
935 937
936 938 def getProcUnitObjByName(self, name):
937 939
938 940 for obj in self.procUnitConfObjDict.values():
939 941 if obj.name == name:
940 942 return obj
941 943
942 944 return None
943 945
944 946 def procUnitItems(self):
945 947
946 948 return self.procUnitConfObjDict.items()
947 949
948 950 def makeXml(self):
949 951
950 952 projectElement = Element('Project')
951 953 projectElement.set('id', str(self.id))
952 954 projectElement.set('name', self.name)
953 955 projectElement.set('description', self.description)
954 956
955 957 for procUnitConfObj in self.procUnitConfObjDict.values():
956 958 procUnitConfObj.makeXml(projectElement)
957 959
958 960 self.projectElement = projectElement
959 961
960 962 def writeXml(self, filename=None):
961 963
962 964 if filename == None:
965 if self.filename:
963 966 filename = self.filename
967 else:
968 filename = "schain.xml"
964 969
965 970 if not filename:
966 971 print "filename has not been defined. Use setFilename(filename) for do it."
967 972 return 0
968 973
969 974 abs_file = os.path.abspath(filename)
970 975
971 976 if not os.access(os.path.dirname(abs_file), os.W_OK):
972 977 print "No write permission on %s" %os.path.dirname(abs_file)
973 978 return 0
974 979
975 980 if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
976 981 print "File %s already exists and it could not be overwriten" %abs_file
977 982 return 0
978 983
979 984 self.makeXml()
980 985
981 986 ElementTree(self.projectElement).write(abs_file, method='xml')
982 987
988 self.filename = abs_file
989
983 990 return 1
984 991
985 992 def readXml(self, filename = None):
986 993
987 if filename == None:
988 filename = self.filename
989
990 994 abs_file = os.path.abspath(filename)
991 995
992 996 if not os.path.isfile(abs_file):
993 997 print "%s does not exist" %abs_file
994 998 return 0
995 999
996 1000 self.projectElement = None
997 1001 self.procUnitConfObjDict = {}
998 1002
999 1003 self.projectElement = ElementTree().parse(abs_file)
1000 1004
1001 1005 self.project = self.projectElement.tag
1002 1006
1003 1007 self.id = self.projectElement.get('id')
1004 1008 self.name = self.projectElement.get('name')
1005 1009 self.description = self.projectElement.get('description')
1006 1010
1007 1011 readUnitElementList = self.projectElement.getiterator(ReadUnitConf().getElementName())
1008 1012
1009 1013 for readUnitElement in readUnitElementList:
1010 1014 readUnitConfObj = ReadUnitConf()
1011 1015 readUnitConfObj.readXml(readUnitElement)
1012 1016
1013 1017 if readUnitConfObj.parentId == None:
1014 1018 readUnitConfObj.parentId = self.id
1015 1019
1016 1020 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
1017 1021
1018 1022 procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
1019 1023
1020 1024 for procUnitElement in procUnitElementList:
1021 1025 procUnitConfObj = ProcUnitConf()
1022 1026 procUnitConfObj.readXml(procUnitElement)
1023 1027
1024 1028 if procUnitConfObj.parentId == None:
1025 1029 procUnitConfObj.parentId = self.id
1026 1030
1027 1031 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
1028 1032
1029 if self.filename == None:
1030 1033 self.filename = abs_file
1031 1034
1032 1035 return 1
1033 1036
1034 1037 def printattr(self):
1035 1038
1036 1039 print "Project[%s]: name = %s, description = %s" %(self.id,
1037 1040 self.name,
1038 1041 self.description)
1039 1042
1040 1043 for procUnitConfObj in self.procUnitConfObjDict.values():
1041 1044 procUnitConfObj.printattr()
1042 1045
1043 1046 def createObjects(self):
1044 1047
1045 1048 for procUnitConfObj in self.procUnitConfObjDict.values():
1046 1049 procUnitConfObj.createObjects(self.__plotterQueue)
1047 1050
1048 1051 def __connect(self, objIN, thisObj):
1049 1052
1050 1053 thisObj.setInput(objIN.getOutputObj())
1051 1054
1052 1055 def connectObjects(self):
1053 1056
1054 1057 for thisPUConfObj in self.procUnitConfObjDict.values():
1055 1058
1056 1059 inputId = thisPUConfObj.getInputId()
1057 1060
1058 1061 if int(inputId) == 0:
1059 1062 continue
1060 1063
1061 1064 #Get input object
1062 1065 puConfINObj = self.procUnitConfObjDict[inputId]
1063 1066 puObjIN = puConfINObj.getProcUnitObj()
1064 1067
1065 1068 #Get current object
1066 1069 thisPUObj = thisPUConfObj.getProcUnitObj()
1067 1070
1068 1071 self.__connect(puObjIN, thisPUObj)
1069 1072
1070 1073 def __handleError(self, procUnitConfObj):
1071 1074
1072 1075 import socket
1073 1076
1074 1077 err = traceback.format_exception(sys.exc_info()[0],
1075 1078 sys.exc_info()[1],
1076 1079 sys.exc_info()[2])
1077 1080
1078 1081 subject = "SChain v%s: Error running %s\n" %(schainpy.__version__, procUnitConfObj.name)
1079 1082
1080 1083 subtitle = "%s: %s\n" %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
1081 1084 subtitle += "Hostname: %s\n" %socket.gethostbyname(socket.gethostname())
1082 1085 subtitle += "Working directory: %s\n" %os.path.abspath("./")
1083 1086 subtitle += "Configuration file: %s\n" %self.filename
1084 1087 subtitle += "Time: %s\n" %str(datetime.datetime.now())
1085 1088
1086 1089 readUnitConfObj = self.getReadUnitObj()
1087 1090 if readUnitConfObj:
1088 1091 subtitle += "\nInput parameters:\n"
1089 1092 subtitle += "[Data path = %s]\n" %readUnitConfObj.path
1090 1093 subtitle += "[Data type = %s]\n" %readUnitConfObj.datatype
1091 1094 subtitle += "[Start date = %s]\n" %readUnitConfObj.startDate
1092 1095 subtitle += "[End date = %s]\n" %readUnitConfObj.endDate
1093 1096 subtitle += "[Start time = %s]\n" %readUnitConfObj.startTime
1094 1097 subtitle += "[End time = %s]\n" %readUnitConfObj.endTime
1095 1098
1096 1099 message = "".join(err)
1097 1100
1098 1101 sys.stderr.write(message)
1099 1102
1100 1103 adminObj = schainpy.admin.SchainNotify()
1101 1104 adminObj.sendAlert(message=message,
1102 1105 subject=subject,
1103 1106 subtitle=subtitle,
1104 1107 filename=self.filename)
1105 1108
1106 1109 def isPaused(self):
1107 1110 return 0
1108 1111
1109 1112 def isStopped(self):
1110 1113 return 0
1111 1114
1112 1115 def runController(self):
1113 1116 """
1114 1117 returns 0 when this process has been stopped, 1 otherwise
1115 1118 """
1116 1119
1117 1120 if self.isPaused():
1118 1121 print "Process suspended"
1119 1122
1120 1123 while True:
1121 1124 sleep(0.1)
1122 1125
1123 1126 if not self.isPaused():
1124 1127 break
1125 1128
1126 1129 if self.isStopped():
1127 1130 break
1128 1131
1129 1132 print "Process reinitialized"
1130 1133
1131 1134 if self.isStopped():
1132 1135 print "Process stopped"
1133 1136 return 0
1134 1137
1135 1138 return 1
1136 1139
1137 1140 def setFilename(self, filename):
1138 1141
1139 1142 self.filename = filename
1140 1143
1141 1144 def setPlotterQueue(self, plotter_queue):
1142 1145
1143 1146 self.__plotterQueue = plotter_queue
1144 1147
1145 1148 def getPlotterQueue(self):
1146 1149
1147 1150 return self.__plotterQueue
1148 1151
1152 def useExternalPlotManager(self):
1153
1154 plotterList = ['Scope',
1155 'SpectraPlot', 'RTIPlot',
1156 'CrossSpectraPlot', 'CoherenceMap',
1157 'PowerProfilePlot', 'Noise', 'BeaconPhase',
1158 'CorrelationPlot',
1159 'SpectraHeisScope','RTIfromSpectraHeis']
1160
1161 for thisPUConfObj in self.procUnitConfObjDict.values():
1162
1163 inputId = thisPUConfObj.getInputId()
1164
1165 if int(inputId) == 0:
1166 continue
1167
1168 for thisOpObj in thisPUConfObj.getOperationObjList():
1169
1170 if thisOpObj.type == "self":
1171 continue
1172
1173 if thisOpObj.name in plotterList:
1174 thisOpObj.type = "plotter"
1175
1149 1176 def run(self):
1150 1177
1151 1178 print
1152 1179 print "*"*60
1153 1180 print " Starting SIGNAL CHAIN PROCESSING v%s " %schainpy.__version__
1154 1181 print "*"*60
1155 1182 print
1156 1183
1157 1184 keyList = self.procUnitConfObjDict.keys()
1158 1185 keyList.sort()
1159 1186
1160 1187 while(True):
1161 1188
1162 1189 is_ok = False
1163 1190
1164 1191 for procKey in keyList:
1165 1192 # print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
1166 1193
1167 1194 procUnitConfObj = self.procUnitConfObjDict[procKey]
1168 1195
1169 1196 try:
1170 1197 sts = procUnitConfObj.run()
1171 1198 is_ok = is_ok or sts
1172 1199 except ValueError, e:
1173 1200 print "***** Error occurred in %s *****" %(procUnitConfObj.name)
1174 1201 sleep(0.5)
1175 1202 print e
1176 1203 is_ok = False
1177 1204 break
1178 1205 except:
1179 1206 print "***** Error occurred in %s *****" %(procUnitConfObj.name)
1180 1207 sleep(0.5)
1181 1208 self.__handleError(procUnitConfObj)
1182 1209 is_ok = False
1183 1210 break
1184 1211
1185 1212 #If every process unit finished so end process
1186 1213 if not(is_ok):
1187 1214 print "Every process unit have finished"
1188 1215 break
1189 1216
1190 1217 if not self.runController():
1191 1218 break
1192 1219
1193 1220 #Closing every process
1194 1221 for procKey in keyList:
1195 1222 procUnitConfObj = self.procUnitConfObjDict[procKey]
1196 1223 procUnitConfObj.close()
1197 1224
1198 1225 print "Process finished"
1199 1226
1200 1227 def start(self):
1201 1228
1202 if not self.writeXml():
1203 return
1229 self.writeXml()
1204 1230
1205 1231 self.createObjects()
1206 1232 self.connectObjects()
1207 1233 self.run()
1208 1234
1209 1235 if __name__ == '__main__':
1210 1236
1211 1237 desc = "Segundo Test"
1212 1238 filename = "schain.xml"
1213 1239
1214 1240 controllerObj = Project()
1215 1241
1216 1242 controllerObj.setup(id = '191', name='test01', description=desc)
1217 1243
1218 1244 readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
1219 1245 path='data/rawdata/',
1220 1246 startDate='2011/01/01',
1221 1247 endDate='2012/12/31',
1222 1248 startTime='00:00:00',
1223 1249 endTime='23:59:59',
1224 1250 online=1,
1225 1251 walk=1)
1226 1252
1227 1253 procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
1228 1254
1229 1255 opObj10 = procUnitConfObj0.addOperation(name='selectChannels')
1230 1256 opObj10.addParameter(name='channelList', value='3,4,5', format='intlist')
1231 1257
1232 1258 opObj10 = procUnitConfObj0.addOperation(name='selectHeights')
1233 1259 opObj10.addParameter(name='minHei', value='90', format='float')
1234 1260 opObj10.addParameter(name='maxHei', value='180', format='float')
1235 1261
1236 1262 opObj12 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
1237 1263 opObj12.addParameter(name='n', value='10', format='int')
1238 1264
1239 1265 procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj0.getId())
1240 1266 procUnitConfObj1.addParameter(name='nFFTPoints', value='32', format='int')
1241 1267 # procUnitConfObj1.addParameter(name='pairList', value='(0,1),(0,2),(1,2)', format='')
1242 1268
1243 1269
1244 1270 opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
1245 1271 opObj11.addParameter(name='idfigure', value='1', format='int')
1246 1272 opObj11.addParameter(name='wintitle', value='SpectraPlot0', format='str')
1247 1273 opObj11.addParameter(name='zmin', value='40', format='int')
1248 1274 opObj11.addParameter(name='zmax', value='90', format='int')
1249 1275 opObj11.addParameter(name='showprofile', value='1', format='int')
1250 1276
1251 1277 print "Escribiendo el archivo XML"
1252 1278
1253 1279 controllerObj.writeXml(filename)
1254 1280
1255 1281 print "Leyendo el archivo XML"
1256 1282 controllerObj.readXml(filename)
1257 1283 #controllerObj.printattr()
1258 1284
1259 1285 controllerObj.createObjects()
1260 1286 controllerObj.connectObjects()
1261 1287 controllerObj.run()
1262 1288
1263 1289 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,141 +1,140
1 1 import threading
2 2
3 3 from schainpy.controller import Project
4 4
5 5 class ControllerThread(threading.Thread, Project):
6 6
7 def __init__(self, filename=None, plotter_queue=None):
7 def __init__(self, plotter_queue=None):
8 8
9 9 threading.Thread.__init__(self)
10 Project.__init__(self, filename, plotter_queue)
10 Project.__init__(self, plotter_queue)
11 11
12 12 self.setDaemon(True)
13 13
14 14 self.lock = threading.Lock()
15 15 self.control = {'stop':False, 'pause':False}
16 16
17 17 def __del__(self):
18 18
19 19 self.control['stop'] = True
20 20
21 21 def stop(self):
22 22
23 23 self.lock.acquire()
24 24
25 25 self.control['stop'] = True
26 26
27 27 self.lock.release()
28 28
29 29 def pause(self):
30 30
31 31 self.lock.acquire()
32 32
33 33 self.control['pause'] = not(self.control['pause'])
34 34 paused = self.control['pause']
35 35
36 36 self.lock.release()
37 37
38 38 return paused
39 39
40 40 def isPaused(self):
41 41
42 42 self.lock.acquire()
43 43 paused = self.control['pause']
44 44 self.lock.release()
45 45
46 46 return paused
47 47
48 48 def isStopped(self):
49 49
50 50 self.lock.acquire()
51 51 stopped = self.control['stop']
52 52 self.lock.release()
53 53
54 54 return stopped
55 55
56 56 def run(self):
57 57 self.control['stop'] = False
58 58 self.control['pause'] = False
59 59
60 if not self.writeXml(self.filename):
61 return
60 self.writeXml()
62 61
63 62 self.createObjects()
64 63 self.connectObjects()
65 64 Project.run(self)
66 65
67 66 def isRunning(self):
68 67
69 68 return self.is_alive()
70 69
71 70 def isFinished(self):
72 71
73 72 return not self.is_alive()
74 73
75 74 # from PyQt4 import QtCore
76 75 # from PyQt4.QtCore import SIGNAL
77 76 #
78 77 # class ControllerQThread(QtCore.QThread, Project):
79 78 #
80 79 # def __init__(self, filename):
81 80 #
82 81 # QtCore.QThread.__init__(self)
83 82 # Project.__init__(self)
84 83 #
85 84 # self.filename = filename
86 85 #
87 86 # self.lock = threading.Lock()
88 87 # self.control = {'stop':False, 'pause':False}
89 88 #
90 89 # def __del__(self):
91 90 #
92 91 # self.control['stop'] = True
93 92 # self.wait()
94 93 #
95 94 # def stop(self):
96 95 #
97 96 # self.lock.acquire()
98 97 #
99 98 # self.control['stop'] = True
100 99 #
101 100 # self.lock.release()
102 101 #
103 102 # def pause(self):
104 103 #
105 104 # self.lock.acquire()
106 105 #
107 106 # self.control['pause'] = not(self.control['pause'])
108 107 # paused = self.control['pause']
109 108 #
110 109 # self.lock.release()
111 110 #
112 111 # return paused
113 112 #
114 113 # def isPaused(self):
115 114 #
116 115 # self.lock.acquire()
117 116 # paused = self.control['pause']
118 117 # self.lock.release()
119 118 #
120 119 # return paused
121 120 #
122 121 # def isStopped(self):
123 122 #
124 123 # self.lock.acquire()
125 124 # stopped = self.control['stop']
126 125 # self.lock.release()
127 126 #
128 127 # return stopped
129 128 #
130 129 # def run(self):
131 130 #
132 131 # self.control['stop'] = False
133 132 # self.control['pause'] = False
134 133 #
135 134 # self.readXml(self.filename)
136 135 # self.createObjects()
137 136 # self.connectObjects()
138 137 # self.emit( SIGNAL( "jobStarted( PyQt_PyObject )" ), 1)
139 138 # Project.run(self)
140 139 # self.emit( SIGNAL( "jobFinished( PyQt_PyObject )" ), 1)
141 140 # No newline at end of file
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now