##// END OF EJS Templates
schain
RSS
VoltageIO.py...
Victor Sarmiento -
r80:b70924dd9256
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,397 +1,476
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 '''
6 '''
7
7
8 import os, sys
8 import os, sys
9 import numpy
9 import numpy
10 import glob
10 import glob
11 import fnmatch
11 import fnmatch
12 import time, datetime
12 import time, datetime
13
13
14 path = os.path.split(os.getcwd())[0]
14 path = os.path.split(os.getcwd())[0]
15 sys.path.append(path)
15 sys.path.append(path)
16
16
17 from Model.JROHeader import *
17 from Model.JROHeader import *
18 from Model.Voltage import Voltage
18 from Model.Voltage import Voltage
19
19
20 from IO.DataIO import JRODataReader
20 from IO.DataIO import JRODataReader
21 from IO.DataIO import JRODataWriter
21 from IO.DataIO import JRODataWriter
22
22
23
23
24 class VoltageReader(JRODataReader):
24 class VoltageReader(JRODataReader):
25 """
25 """
26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
28 perfiles*alturas*canales) son almacenados en la variable "buffer".
28 perfiles*alturas*canales) son almacenados en la variable "buffer".
29
29
30 perfiles * alturas * canales
30 perfiles * alturas * canales
31
31
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
35 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
35 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
36
36
37 Example:
37 Example:
38
38
39 dpath = "/home/myuser/data"
39 dpath = "/home/myuser/data"
40
40
41 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
41 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
42
42
43 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
43 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
44
44
45 readerObj = VoltageReader()
45 readerObj = VoltageReader()
46
46
47 readerObj.setup(dpath, startTime, endTime)
47 readerObj.setup(dpath, startTime, endTime)
48
48
49 while(True):
49 while(True):
50
50
51 #to get one profile
51 #to get one profile
52 profile = readerObj.getData()
52 profile = readerObj.getData()
53
53
54 #print the profile
54 #print the profile
55 print profile
55 print profile
56
56
57 #If you want to see all datablock
57 #If you want to see all datablock
58 print readerObj.datablock
58 print readerObj.datablock
59
59
60 if readerObj.flagNoMoreFiles:
60 if readerObj.flagNoMoreFiles:
61 break
61 break
62
62
63 """
63 """
64 m_DataObj = None
64 m_DataObj = None
65
65
66 idProfile = 0
66 idProfile = 0
67
67
68 datablock = None
68 datablock = None
69
69
70 pts2read = 0
70 pts2read = 0
71
71
72 utc = 0
72 utc = 0
73
73
74 ext = ".r"
74 ext = ".r"
75
75
76 optchar = "D"
76 optchar = "D"
77
77
78
78
79 def __init__(self, m_Voltage=None):
79 def __init__(self, m_Voltage=None):
80 """
80 """
81 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
81 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
82
82
83 Input:
83 Input:
84 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
84 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
85 almacenar un perfil de datos cada vez que se haga un requerimiento
85 almacenar un perfil de datos cada vez que se haga un requerimiento
86 (getData). El perfil sera obtenido a partir del buffer de datos,
86 (getData). El perfil sera obtenido a partir del buffer de datos,
87 si el buffer esta vacio se hara un nuevo proceso de lectura de un
87 si el buffer esta vacio se hara un nuevo proceso de lectura de un
88 bloque de datos.
88 bloque de datos.
89 Si este parametro no es pasado se creara uno internamente.
89 Si este parametro no es pasado se creara uno internamente.
90
90
91 Variables afectadas:
91 Variables afectadas:
92 self.m_DataObj
92 self.m_DataObj
93
93
94 Return:
94 Return:
95 None
95 None
96 """
96 """
97 if m_Voltage == None:
97 if m_Voltage == None:
98 m_Voltage = Voltage()
98 m_Voltage = Voltage()
99
99
100 if not(isinstance(m_Voltage, Voltage)):
100 if not(isinstance(m_Voltage, Voltage)):
101 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
101 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
102
102
103 self.m_DataObj = m_Voltage
103 self.m_DataObj = m_Voltage
104
104
105 self.idProfile = 0
106
107 self.datablock = None
108
109 self.pts2read = 0
110
111 self.utc = 0
112
113 self.ext = ".r"
114
115 self.optchar = "D"
116
117 self.m_BasicHeader = BasicHeader()
118
119 self.m_SystemHeader = SystemHeader()
120
121 self.m_RadarControllerHeader = RadarControllerHeader()
122
123 self.m_ProcessingHeader = ProcessingHeader()
124
125 self.online = 0
126
127 self.fp = None
128
129 self.idFile = None
130
131 self.startDateTime = None
132
133 self.endDateTime = None
134
135 self.dataType = None
136
137 self.fileSizeByHeader = None
138
139 self.filenameList = []
140
141 self.filename = None
142
143 self.fileSize = None
144
145 self.firstHeaderSize = 0
146
147 self.basicHeaderSize = 24
148
149 self.pathList = []
150
151 self.filenameList = []
152
153 self.lastUTTime = 0
154
155 self.maxTimeStep = 30
156
157 self.flagNoMoreFiles = 0
158
159 self.set = 0
160
161 self.path = None
162
163 self.datablockIndex = 9999
164
165 self.delay = 3 #seconds
166
167 self.nTries = 3 #quantity tries
168
169 self.nFiles = 3 #number of files for searching
170
171 self.nBlocks = 0
172
173 self.flagIsNewFile = 1
174
175 self.ippSeconds = 0
176
177 self.flagResetProcessing = 0
178
179 self.flagIsNewBlock = 0
180
181 self.nReadBlocks = 0
182
183 self.blocksize = 0
105
184
106 def __hasNotDataInBuffer(self):
185 def __hasNotDataInBuffer(self):
107 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
186 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
108 return 1
187 return 1
109 return 0
188 return 0
110
189
111
190
112 def getBlockDimension(self):
191 def getBlockDimension(self):
113 """
192 """
114 Obtiene la cantidad de puntos a leer por cada bloque de datos
193 Obtiene la cantidad de puntos a leer por cada bloque de datos
115
194
116 Affected:
195 Affected:
117 self.pts2read
196 self.pts2read
118 self.blocksize
197 self.blocksize
119
198
120 Return:
199 Return:
121 None
200 None
122 """
201 """
123 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
202 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
124 self.blocksize = self.pts2read
203 self.blocksize = self.pts2read
125 self.m_DataObj.nProfiles = self.m_ProcessingHeader.profilesPerBlock
204 self.m_DataObj.nProfiles = self.m_ProcessingHeader.profilesPerBlock
126
205
127
206
128 def readBlock(self):
207 def readBlock(self):
129 """
208 """
130 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
209 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
131 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
210 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
132 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
211 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
133 es seteado a 0
212 es seteado a 0
134
213
135 Inputs:
214 Inputs:
136 None
215 None
137
216
138 Return:
217 Return:
139 None
218 None
140
219
141 Affected:
220 Affected:
142 self.datablockIndex
221 self.datablockIndex
143 self.datablock
222 self.datablock
144 self.flagIsNewFile
223 self.flagIsNewFile
145 self.idProfile
224 self.idProfile
146 self.flagIsNewBlock
225 self.flagIsNewBlock
147 self.nReadBlocks
226 self.nReadBlocks
148
227
149 Exceptions:
228 Exceptions:
150 Si un bloque leido no es un bloque valido
229 Si un bloque leido no es un bloque valido
151 """
230 """
152 blockOk_flag = False
231 blockOk_flag = False
153 fpointer = self.fp.tell()
232 fpointer = self.fp.tell()
154
233
155 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
234 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
156
235
157 if self.online:
236 if self.online:
158 if junk.size != self.blocksize:
237 if junk.size != self.blocksize:
159 for nTries in range( self.nTries ):
238 for nTries in range( self.nTries ):
160 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
239 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
161 time.sleep( self.delay )
240 time.sleep( self.delay )
162 self.fp.seek( fpointer )
241 self.fp.seek( fpointer )
163 fpointer = self.fp.tell()
242 fpointer = self.fp.tell()
164
243
165 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
244 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
166
245
167 if junk.size == self.blocksize:
246 if junk.size == self.blocksize:
168 blockOk_flag = True
247 blockOk_flag = True
169 break
248 break
170
249
171 if not( blockOk_flag ):
250 if not( blockOk_flag ):
172 return 0
251 return 0
173
252
174 try:
253 try:
175 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
254 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
176 except:
255 except:
177 print "Data file %s is invalid" % self.filename
256 print "Data file %s is invalid" % self.filename
178 return 0
257 return 0
179
258
180 junk = numpy.transpose(junk, (2,0,1))
259 junk = numpy.transpose(junk, (2,0,1))
181 self.datablock = junk['real'] + junk['imag']*1j
260 self.datablock = junk['real'] + junk['imag']*1j
182
261
183 self.datablockIndex = 0
262 self.datablockIndex = 0
184 self.flagIsNewFile = 0
263 self.flagIsNewFile = 0
185 self.idProfile = 0
264 self.idProfile = 0
186 self.flagIsNewBlock = 1
265 self.flagIsNewBlock = 1
187
266
188 self.nReadBlocks += 1
267 self.nReadBlocks += 1
189 self.nBlocks += 1
268 self.nBlocks += 1
190
269
191 return 1
270 return 1
192
271
193
272
194 def getData(self):
273 def getData(self):
195 """
274 """
196 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
275 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
197 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
276 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
198 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
277 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
199
278
200 Ademas incrementa el contador del buffer en 1.
279 Ademas incrementa el contador del buffer en 1.
201
280
202 Return:
281 Return:
203 data : retorna un perfil de voltages (alturas * canales) copiados desde el
282 data : retorna un perfil de voltages (alturas * canales) copiados desde el
204 buffer. Si no hay mas archivos a leer retorna None.
283 buffer. Si no hay mas archivos a leer retorna None.
205
284
206 Variables afectadas:
285 Variables afectadas:
207 self.m_DataObj
286 self.m_DataObj
208 self.datablockIndex
287 self.datablockIndex
209 self.idProfile
288 self.idProfile
210
289
211 Affected:
290 Affected:
212 self.m_DataObj
291 self.m_DataObj
213 self.datablockIndex
292 self.datablockIndex
214 self.flagResetProcessing
293 self.flagResetProcessing
215 self.flagIsNewBlock
294 self.flagIsNewBlock
216 self.idProfile
295 self.idProfile
217 """
296 """
218 if self.flagNoMoreFiles: return 0
297 if self.flagNoMoreFiles: return 0
219
298
220 self.flagResetProcessing = 0
299 self.flagResetProcessing = 0
221 self.flagIsNewBlock = 0
300 self.flagIsNewBlock = 0
222
301
223 if self.__hasNotDataInBuffer():
302 if self.__hasNotDataInBuffer():
224
303
225 if not( self.readNextBlock() ):
304 if not( self.readNextBlock() ):
226 self.setNextFile()
305 self.setNextFile()
227 return 0
306 return 0
228
307
229 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
308 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
230 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
309 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
231 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
310 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
232 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
311 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
233 self.m_DataObj.heights = self.heights
312 self.m_DataObj.heightList = self.heightList
234 self.m_DataObj.dataType = self.dataType
313 self.m_DataObj.dataType = self.dataType
235
314
236 if self.flagNoMoreFiles == 1:
315 if self.flagNoMoreFiles == 1:
237 print 'Process finished'
316 print 'Process finished'
238 return 0
317 return 0
239
318
240 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
319 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
241
320
242 if self.datablock == None:
321 if self.datablock == None:
243 self.m_DataObj.flagNoData = True
322 self.m_DataObj.flagNoData = True
244 return 0
323 return 0
245
324
246 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
325 time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
247 self.m_DataObj.m_BasicHeader.utc = time
326 self.m_DataObj.m_BasicHeader.utc = time
248
327
249 self.m_DataObj.flagNoData = False
328 self.m_DataObj.flagNoData = False
250 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
329 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
251
330
252 self.m_DataObj.data = self.datablock[:,self.datablockIndex,:]
331 self.m_DataObj.data = self.datablock[:,self.datablockIndex,:]
253 self.m_DataObj.idProfile = self.idProfile
332 self.m_DataObj.idProfile = self.idProfile
254
333
255 self.datablockIndex += 1
334 self.datablockIndex += 1
256 self.idProfile += 1
335 self.idProfile += 1
257
336
258 #call setData - to Data Object
337 #call setData - to Data Object
259
338
260 return 1 #self.m_DataObj.data
339 return 1 #self.m_DataObj.data
261
340
262
341
263 class VoltageWriter( JRODataWriter ):
342 class VoltageWriter( JRODataWriter ):
264 """
343 """
265 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
344 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
266 de los datos siempre se realiza por bloques.
345 de los datos siempre se realiza por bloques.
267 """
346 """
268 __configHeaderFile = 'wrSetHeadet.txt'
347 __configHeaderFile = 'wrSetHeadet.txt'
269
348
270 m_DataObj = None
349 m_DataObj = None
271
350
272 ext = ".r"
351 ext = ".r"
273
352
274 optchar = "D"
353 optchar = "D"
275
354
276 datablock = None
355 datablock = None
277
356
278 datablockIndex = 0
357 datablockIndex = 0
279
358
280 shapeBuffer = None
359 shapeBuffer = None
281
360
282
361
283 def __init__(self, m_Voltage=None):
362 def __init__(self, m_Voltage=None):
284 """
363 """
285 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
364 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
286
365
287 Affected:
366 Affected:
288 self.m_DataObj
367 self.m_DataObj
289
368
290 Return: None
369 Return: None
291 """
370 """
292 if m_Voltage == None:
371 if m_Voltage == None:
293 m_Voltage = Voltage()
372 m_Voltage = Voltage()
294
373
295 if not( isinstance(m_Voltage, Voltage) ):
374 if not( isinstance(m_Voltage, Voltage) ):
296 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
375 raise ValueError, "in VoltageReader, m_Voltage must be an Spectra class object"
297
376
298 self.m_DataObj = m_Voltage
377 self.m_DataObj = m_Voltage
299
378
300
379
301 def hasAllDataInBuffer(self):
380 def hasAllDataInBuffer(self):
302 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
381 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
303 return 1
382 return 1
304 return 0
383 return 0
305
384
306
385
307 def setBlockDimension(self):
386 def setBlockDimension(self):
308 """
387 """
309 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
388 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
310
389
311 Affected:
390 Affected:
312 self.shape_spc_Buffer
391 self.shape_spc_Buffer
313 self.shape_cspc_Buffer
392 self.shape_cspc_Buffer
314 self.shape_dc_Buffer
393 self.shape_dc_Buffer
315
394
316 Return: None
395 Return: None
317 """
396 """
318 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
397 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
319 self.m_ProcessingHeader.numHeights,
398 self.m_ProcessingHeader.numHeights,
320 self.m_SystemHeader.numChannels )
399 self.m_SystemHeader.numChannels )
321
400
322 self.datablock = numpy.zeros(self.m_SystemHeader.numChannels,
401 self.datablock = numpy.zeros((self.m_SystemHeader.numChannels,
323 self.m_ProcessingHeader.profilesPerBlock,
402 self.m_ProcessingHeader.profilesPerBlock,
324 self.m_ProcessingHeader.numHeights,
403 self.m_ProcessingHeader.numHeights),
325 numpy.dtype('complex'))
404 dtype=numpy.dtype('complex'))
326
405
327
406
328 def writeBlock(self):
407 def writeBlock(self):
329 """
408 """
330 Escribe el buffer en el file designado
409 Escribe el buffer en el file designado
331
410
332 Affected:
411 Affected:
333 self.datablockIndex
412 self.datablockIndex
334 self.flagIsNewFile
413 self.flagIsNewFile
335 self.flagIsNewBlock
414 self.flagIsNewBlock
336 self.nWriteBlocks
415 self.nWriteBlocks
337 self.blocksCounter
416 self.blocksCounter
338
417
339 Return: None
418 Return: None
340 """
419 """
341 data = numpy.zeros( self.shapeBuffer, self.dataType )
420 data = numpy.zeros( self.shapeBuffer, self.dataType )
342
421
343 junk = numpy.transpose(self.datablock, (1,2,0))
422 junk = numpy.transpose(self.datablock, (1,2,0))
344
423
345 data['real'] = junk.real
424 data['real'] = junk.real
346 data['imag'] = junk.imag
425 data['imag'] = junk.imag
347
426
348 data = data.reshape( (-1) )
427 data = data.reshape( (-1) )
349
428
350 data.tofile( self.fp )
429 data.tofile( self.fp )
351
430
352 self.datablock.fill(0)
431 self.datablock.fill(0)
353 self.datablockIndex = 0
432 self.datablockIndex = 0
354 self.flagIsNewFile = 0
433 self.flagIsNewFile = 0
355 self.flagIsNewBlock = 1
434 self.flagIsNewBlock = 1
356 self.nWriteBlocks += 1
435 self.nWriteBlocks += 1
357 self.blocksCounter += 1
436 self.blocksCounter += 1
358
437
359
438
360 def putData(self):
439 def putData(self):
361 """
440 """
362 Setea un bloque de datos y luego los escribe en un file
441 Setea un bloque de datos y luego los escribe en un file
363
442
364 Affected:
443 Affected:
365 self.flagIsNewBlock
444 self.flagIsNewBlock
366 self.datablockIndex
445 self.datablockIndex
367
446
368 Return:
447 Return:
369 0 : Si no hay data o no hay mas files que puedan escribirse
448 0 : Si no hay data o no hay mas files que puedan escribirse
370 1 : Si se escribio la data de un bloque en un file
449 1 : Si se escribio la data de un bloque en un file
371 """
450 """
372 self.flagIsNewBlock = 0
451 self.flagIsNewBlock = 0
373
452
374 if self.m_DataObj.flagNoData:
453 if self.m_DataObj.flagNoData:
375 return 0
454 return 0
376
455
377 if self.m_DataObj.flagResetProcessing:
456 if self.m_DataObj.flagResetProcessing:
378
457
379 self.datablock.fill(0)
458 self.datablock.fill(0)
380 self.datablockIndex = 0
459 self.datablockIndex = 0
381 self.setNextFile()
460 self.setNextFile()
382
461
383 self.datablock[:,self.datablockIndex,:] = self.m_DataObj.data
462 self.datablock[:,self.datablockIndex,:] = self.m_DataObj.data
384
463
385 self.datablockIndex += 1
464 self.datablockIndex += 1
386
465
387 if self.hasAllDataInBuffer():
466 if self.hasAllDataInBuffer():
388 #if self.flagIsNewFile:
467 #if self.flagIsNewFile:
389 self.getHeader()
468 self.getHeader()
390 self.writeNextBlock()
469 self.writeNextBlock()
391
470
392 if self.flagNoMoreFiles:
471 if self.flagNoMoreFiles:
393 #print 'Process finished'
472 #print 'Process finished'
394 return 0
473 return 0
395
474
396 return 1
475 return 1
397 No newline at end of file
476
General Comments 0
You need to be logged in to leave comments. Login now