radarsys Commit - r400:fea82e8575d1 · Jicamarca Repository

ver_3Julio :: new changes

jespinoza -

r400:fea82e8575d1

parent child

Context file:

r400:fea82e8575d1

Collapse all files

apps/abs/models.py +1 -1

             from django.db import models
             from apps.main.models import Configuration , User
             from django.urls import reverse
             from celery.execute import send_task
             from datetime import datetime
             import ast
             import socket
             import json
             import requests
             import struct
             import os, sys, time
             antenna_default = json.dumps({
                                 "antenna_up": [[0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
                                                 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
                                                 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
                                                 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0]
                                                 ]
                                                ,
                                 "antenna_down": [[0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
                                                 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
                                                 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
                                                 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0]],
                             })
             tx_default = json.dumps({
                             "up": [[1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1]],
                           "down": [[1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1]],
                          })
             rx_default = json.dumps({
                             "up": [[1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1]],
                           "down": [[1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1]],
                          })
             status_default = '0000000000000000000000000000000000000000000000000000000000000000'
             default_messages = {}
             for i in range(1,65):
                 default_messages[str(i)] = "Module "+str(i)
             ues_default = json.dumps({
                             "up": [0.533333,0.00000,1.06667,0.00000],
                             "down": [0.533333,0.00000,1.06667,0.00000]
                         })
             onlyrx_default = json.dumps({
                                 "up": False,
                                 "down": False
                             })
             def up_convertion(cadena):
                 valores = []
                 for c in cadena:
                     if c == 1.0: valores=valores+['000']
                     if c == 2.0: valores=valores+['001']
                     if c == 3.0: valores=valores+['010']
                     if c == 0.0: valores=valores+['011']
                     if c == 0.5: valores=valores+['100']
                     if c == 1.5: valores=valores+['101']
                     if c == 2.5: valores=valores+['110']
                     if c == 3.5: valores=valores+['111']
                 return valores
             def up_conv_bits(value):
                 if value == 1.0: bits="000"
                 if value == 2.0: bits="001"
                 if value == 3.0: bits="010"
                 if value == 0.0: bits="011"
                 if value == 0.5: bits="100"
                 if value == 1.5: bits="101"
                 if value == 2.5: bits="110"
                 if value == 3.5: bits="111"
                 return bits
             def down_convertion(cadena):
                 valores = []
                 for c in cadena:
                     if c == 1.0: valores=valores+['000']
                     if c == 2.0: valores=valores+['001']
                     if c == 3.0: valores=valores+['010']
                     if c == 0.0: valores=valores+['011']
                     if c == 0.5: valores=valores+['100']
                     if c == 1.5: valores=valores+['101']
                     if c == 2.5: valores=valores+['110']
                     if c == 3.5: valores=valores+['111']
                 return valores
             def down_conv_bits(value):
                 if value == 1.0: bits="000"
                 if value == 2.0: bits="001"
                 if value == 3.0: bits="010"
                 if value == 0.0: bits="011"
                 if value == 0.5: bits="100"
                 if value == 1.5: bits="101"
                 if value == 2.5: bits="110"
                 if value == 3.5: bits="111"
                 return bits
             def up_conv_value(bits):
                 if bits == "000": value=1.0
                 if bits == "001": value=2.0
                 if bits == "010": value=3.0
                 if bits == "011": value=0.0
                 if bits == "100": value=0.5
                 if bits == "101": value=1.5
                 if bits == "110": value=2.5
                 if bits == "111": value=3.5
                 return value
             def down_conv_value(bits):
                 if bits == "000": value=1.0
                 if bits == "001": value=2.0
                 if bits == "010": value=3.0
                 if bits == "011": value=0.0
                 if bits == "100": value=0.5
                 if bits == "101": value=1.5
                 if bits == "110": value=2.5
                 if bits == "111": value=3.5
                 return value
             def ip2position(module_number):
                 j=0
                 i=0
                 for x in range(0,module_number-1):
                     j=j+1
                     if j==8:
                         i=i+1
                         j=0
                 pos = [i,j]
                 return pos
             def fromBinary2Char(binary_string):
                 number = int(binary_string, 2)
                 #Plus 33 to avoid more than 1 characters values such as: '\x01'-'\x1f'
                 number = number + 33
                 char = chr(number)
                 return char
             def fromChar2Binary(char):
                 number = ord(char) - 33
                 #Minus 33 to get the real value
                 bits = bin(number)[2:]
                 #To ensure we have a string with 6bits
                 if len(bits) < 6:
                     bits = bits.zfill(6)
                 return bits
             OPERATION_MODES = (
                              (0, 'Manual'),
                              (1, 'Automatic'),
                          )
             class ABSConfiguration(Configuration):
                 active_beam     = models.PositiveSmallIntegerField(verbose_name='Active Beam', default=0)
                 module_status   = models.CharField(verbose_name='Module Status', max_length=10000, default=status_default)
                 operation_mode  = models.PositiveSmallIntegerField(verbose_name='Operation Mode', choices=OPERATION_MODES, default = 0)
                 operation_value = models.FloatField(verbose_name='Periodic (seconds)', default="10", null=True, blank=True)
                 module_messages = models.CharField(verbose_name='Modules Messages', max_length=10000, default=json.dumps(default_messages))
                 class Meta:
                     db_table = 'abs_configurations'
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_abs_patterns', args=[str(self.id)])
                 def parms_to_dict(self):
                     parameters = {}
                     parameters['device_id'] = self.device.id
                     parameters['label']      = self.label
                     parameters['device_type']      = self.device.device_type.name
                     parameters['beams']     = {}
                     beams = ABSBeam.objects.filter(abs_conf=self)
                     b=1
                     for beam in beams:
                         #absbeam = ABSBeam.objects.get(pk=beams[beam])
                         parameters['beams']['beam'+str(b)] = beam.parms_to_dict()#absbeam.parms_to_dict()
                         b+=1
                     return parameters
                 def dict_to_parms(self, parameters):
                     self.label = parameters['label']
                     absbeams  = ABSBeam.objects.filter(abs_conf=self)
                     beams     = parameters['beams']
                     if absbeams:
                         beams_number    = len(beams)
                         absbeams_number = len(absbeams)
                         if beams_number==absbeams_number:
                             i = 1
                             for absbeam in absbeams:
                                 absbeam.dict_to_parms(beams['beam'+str(i)])
                                 i = i+1
                         elif beams_number > absbeams_number:
                             i = 1
                             for absbeam in absbeams:
                                 absbeam.dict_to_parms(beams['beam'+str(i)])
                                 i=i+1
                             for x in range(i,beams_number+1):
                                 new_beam = ABSBeam(
                                            name     =beams['beam'+str(i)]['name'],
                                            antenna  =json.dumps(beams['beam'+str(i)]['antenna']),
                                            abs_conf = self,
                                            tx       =json.dumps(beams['beam'+str(i)]['tx']),
                                            rx       =json.dumps(beams['beam'+str(i)]['rx']),
                                            ues      =json.dumps(beams['beam'+str(i)]['ues']),
                                            only_rx  =json.dumps(beams['beam'+str(i)]['only_rx'])
                                            )
                                 new_beam.save()
                                 i=i+1
                         else: #beams_number < absbeams_number:
                             i = 1
                             for absbeam in absbeams:
                                 if i <= beams_number:
                                     absbeam.dict_to_parms(beams['beam'+str(i)])
                                     i=i+1
                                 else:
                                     absbeam.delete()
                     else:
                         for beam in beams:
                             new_beam = ABSBeam(
                                        name     =beams[beam]['name'],
                                        antenna  =json.dumps(beams[beam]['antenna']),
                                        abs_conf = self,
                                        tx       =json.dumps(beams[beam]['tx']),
                                        rx       =json.dumps(beams[beam]['rx']),
                                        ues      =json.dumps(beams[beam]['ues']),
                                        only_rx  =json.dumps(beams[beam]['only_rx'])
                                        )
                             new_beam.save()
                 def update_from_file(self, parameters):
                     self.dict_to_parms(parameters)
                     self.save()
                 def get_beams(self, **kwargs):
                     '''
                     This function returns ABS Configuration beams
                     '''
                     return ABSBeam.objects.filter(abs_conf=self.pk, **kwargs)
                 def clone(self, **kwargs):
                     beams = self.get_beams()
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for beam in beams:
                         beam.clone(abs_conf=self)
                     #-----For Active Beam-----
                     new_beams = ABSBeam.objects.filter(abs_conf=self)
                     self.active_beam = new_beams[0].id
                     self.save()
                     #-----For Active Beam-----
                     #-----For Device Status---
                     self.device.status = 3
                     self.device.save()
                     #-----For Device Status---
                     return self
                 def start_device(self):
                     if self.device.status == 3:
                         try:
                             #self.write_device()
                             send_task('task_change_beam', [self.id],)
                             self.message = 'ABS running'
                         except Exception as e:
                             self.message = str(e)
                             return False
                         return True
                     else:
                         self.message = 'Please, select Write ABS Device first.'
                         return False
                 def stop_device(self):
                     self.device.status = 2
                     self.device.save()
                     self.message = 'ABS has been stopped.'
                     self.save()
                     return True
                 def write_device(self):
                     """
                     This function sends the beams list to every abs module.
                     It needs 'module_conf' function
                     """
                     print("Write")
                     beams  = ABSBeam.objects.filter(abs_conf=self)
                     nbeams = len(beams)
                     # Se manda a cero RC para poder realizar cambio de beam
                     if self.experiment is None:
                         confs = []
                     else:
                         confs = Configuration.objects.filter(experiment = self.experiment).filter(type=0)
                     confdds  = ''
                     confjars = ''
                     confrc   = ''
                     #TO STOP DEVICES: DDS-JARS-RC
                     for i in range(0,len(confs)):
                         if i==0:
                             for conf in confs:
                                 if conf.device.device_type.name == 'dds':
                                     confdds = conf
                                     confdds.stop_device()
                                     break
                         if i==1:
                             for conf in confs:
                                 if conf.device.device_type.name == 'jars':
                                     confjars = conf
                                     confjars.stop_device()
                                     break
                         if i==2:
                             for conf in confs:
                                 if conf.device.device_type.name == 'rc':
                                     confrc = conf
                                     confrc.stop_device()
                                     break
                     '''
                     if self.connected_modules() == 0 :
                         print("No encuentra modulos")
                         self.message = "No ABS Module detected."
                         return False
                     '''
                     #-------------Write each abs module-----------
                     if beams:
                         block_id = 0
                         message = 'SNDF{:03d}{:02d}{:02d}'.format(nbeams, nbeams, block_id)
                         for i, status in enumerate(self.module_status):
                             message += ''.join([fromBinary2Char(beam.module_6bits(i)) for beam in beams])
                         status = ['0'] * 64
                         n = 0
                         print("Llega una antes entrar a multicast")
                         sock = self.send_multicast(message)
                         while True:
                         #for i in range(32):
                             try:
                                 data, address = sock.recvfrom(1024)
                                 print (address, data)
                                 data = data.decode("utf-8")
                                 if data == '1':
                                     status[int(address[0][10:])-1] = '3'
                                     #print (int(address[0][10:])-1)
                                 elif data == '0':
                                     status[int(address[0][10:])-1] = '1'
                             except socket.timeout:
                                 print('Timeout')
                                 break
                             except Exception as e:
                                 print ('Error {}'.format(e))
                                 n += 1
                         sock.close()
                     else:
                         self.message = "ABS Configuration does not have beams"
                         print('No beams')
                         #Start DDS-RC-JARS
                         if confdds:
                             confdds.start_device()
                         if confrc:
                             #print confrc
                             confrc.start_device()
                         if confjars:
                             confjars.start_device()
                         return False
                     if n == 64:
                         self.message = "Could not write ABS Modules"
                         self.device.status = 0
                         self.module_status = ''.join(status)
                         self.save()
                         print('Could not write ABS')
                         #Start DDS-RC-JARS
                         if confdds:
                             confdds.start_device()
                         if confrc:
                             #print confrc
                             confrc.start_device()
                         if confjars:
                             confjars.start_device()
                         return False
                     else:
                         self.message = "ABS Beams List have been sent to ABS Modules"
                         print('ABS beams list sent')
                         self.active_beam = beams[0].pk
                     #Start DDS-RC-JARS
                     if confdds:
                         confdds.start_device()
                     if confrc:
                         #print confrc
                         confrc.start_device()
                     if confjars:
                         confjars.start_device()
                     print('Inicia intento de salvar device.status')
                     self.device.status = 3
                     self.module_status = ''.join(status)
                     #print(status)
                     self.save()
                     print('Estatus salvado')
                     conf_active, __ = ABSActive.objects.get_or_create(pk=1)
                     conf_active.conf = self
                     conf_active.save()
                     return True
                 def read_module(self, module):
                     """
                     Read out-bits (up-down) of 1 abs module NOT for Configuration
                     """
                     ip_address  = self.device.ip_address
                     ip_address  = ip_address.split('.')
                     module_seq  = (ip_address[0],ip_address[1],ip_address[2])
                     dot         = '.'
                     module_ip   = dot.join(module_seq)+'.'+str(module)
                     module_port = self.device.port_address
                     read_route = 'http://'+module_ip+':'+str(module_port)+'/read'
                     module_status = json.loads(self.module_status)
                     print(read_route)
                     module_bits = ''
                     try:
                         r_read      = requests.get(read_route, timeout=0.5)
                         answer      = r_read.json()
                         module_bits = answer['allbits']
                     except:
                         return {}
                     return module_bits
                 def read_device(self):
                     parms = {}
                     # Reads active modules.
                     module_status = json.loads(self.module_status)
                     total = 0
                     for status in module_status:
                         if module_status[status] != 0:
                             module_bits = self.read_module(int(status))
                             bits={}
                             if module_bits:
                                 bits = (str(module_bits['um2']) + str(module_bits['um1']) + str(module_bits['um0']) +
                                         str(module_bits['dm2']) + str(module_bits['dm1']) + str(module_bits['dm0']) )
                                 parms[str(status)] = bits
                             total +=1
                     if total==0:
                         self.message = "No ABS Module detected. Please select 'Status'."
                         return False
                     self.message = "ABS Modules have been read"
                     #monitoreo_tx = JROABSClnt_01CeCnMod000000MNTR10
                     return parms
                 def connected_modules(self):
                     """
                     This function returns the number of connected abs-modules without updating.
                     """
                     num = 0
                     print(self.module_status)
                     for i, status in  enumerate(self.module_status):
                         if status != '0':
                             num += 1
                             #print('status {}:{}'.format(i+1, status))
                     return num
                 def send_multicast(self, message):
                     #print("Send multicast")
                     multicast_group = ('224.3.29.71', 10000)
                     # Create the datagram socket
                     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                     sock.settimeout(1)
-                    local_ip = os.environ.get('LOCAL_IP', '192.168.2.128')
+                    local_ip = os.environ.get('LOCAL_IP', '192.168.1.128')
                     sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton(local_ip))
                     sock.sendto(message.encode(), multicast_group)
                     print('Sending ' + message)
                     return sock
                 def status_device(self):
                     """
                     This function returns the status of all abs-modules as one.
                     If at least one module is connected, its answer is "1"
                     """
                     print ('Status device')
                     print (self.active_beam)
                     beams = ABSBeam.objects.filter(abs_conf=self)
                     #print beams[self.active_beam-1].module_6bits(0)
                     active = ABSActive.objects.get(pk=1)
                     if active.conf != self:
                         self.message = 'La configuracion actual es la del siguiente enlace %s.' % active.conf.get_absolute_url()
                         self.message +=  "\n"
                         self.message += 'Se debe realizar un write en esta configuracion para luego obtener un status valido.'
                         return False
                     sock = self.send_multicast('MNTR')
                     n = 0
                     status = ['0'] * 64
                     while True:
                     #for i in range(32):
                         #if True:
                         try:
                             print("Recibiendo")
                             address = None
                             data, address = sock.recvfrom(2)
                             print (address, data)
                             print("!!!!")
                             data = data.decode()
                             aux_mon = "1"
                             aux_expected = aux_mon
                             if(len(data)==2):
                                 print ("data[1]: ")
                                 print (data[1])
                                 aux_mon = fromChar2Binary(data[1])
                                 print (aux_mon)
                                 aux_i = (str(address[0]).split('.'))[3]
                                 print (aux_i)
                                 print ('Active beam')
                                 beam_active = ABSBeam.objects.get(pk=self.active_beam)
                                 print (beam_active)
                                 aux_expected = beam_active.module_6bits(int(aux_i)-1)
                                 print (aux_expected)
                             print ("data[0]: ")
                             print (data[0])
                             if data[0] == '1':
                                 status[int(address[0][10:])-1] = '3'
                                 if aux_mon == aux_expected:
                                     print ('Es igual')
                                 else:
                                     print ('Es diferente')
                                     status[int(address[0][10:])-1] = '2'
                             elif data[0] == '0':
                                 status[int(address[0][10:])-1] = '1'
                             n += 1
                             print('Module: {} connected'.format(address))
                         except socket.timeout:
                             print('Timeout')
                             break
                         except:
                             print('Module: {} error'.format(address))
                             pass
                     sock.close()
                     if n > 0:
                         self.message = 'ABS modules Status have been updated.'
                         self.device.status = 1
                     else:
                         self.device.status = 0
                         self.message = 'No ABS module is connected.'
                     self.module_status = ''.join(status)
                     self.save()
                     return self.device.status
                 def send_beam(self, beam_pos):
                     """
                     This function connects to a multicast group and sends the beam number
                     to all abs modules.
                     """
                     print ('Send beam')
                     print (self.active_beam)
                     beams = ABSBeam.objects.filter(abs_conf=self)
                     #print beams[self.active_beam-1].module_6bits(0)
                     active = ABSActive.objects.get(pk=1)
                     if active.conf != self:
                         self.message = 'La configuracion actual es la del siguiente enlace %s.' % active.conf.get_absolute_url()
                         self.message +=  "\n"
                         self.message += 'Se debe realizar un write en esta configuracion para luego obtener un status valido.'
                         return False
                     # Se manda a cero RC para poder realizar cambio de beam
                     if self.experiment is None:
                         confs = []
                     else:
                         confs = Configuration.objects.filter(experiment = self.experiment).filter(type=0)
                     confdds  = ''
                     confjars = ''
                     confrc   = ''
                     #TO STOP DEVICES: DDS-JARS-RC
                     for i in range(0,len(confs)):
                         if i==0:
                             for conf in confs:
                                 if conf.device.device_type.name == 'dds':
                                     confdds = conf
                                     confdds.stop_device()
                                     break
                         if i==1:
                             for conf in confs:
                                 if conf.device.device_type.name == 'jars':
                                     confjars = conf
                                     confjars.stop_device()
                                     break
                         if i==2:
                             for conf in confs:
                                 if conf.device.device_type.name == 'rc':
                                     confrc = conf
                                     confrc.stop_device()
                                     break
                     if beam_pos > 0:
                         beam_pos = beam_pos - 1
                     else:
                         beam_pos = 0
                     #El indice del apunte debe ser menor que el numero total de apuntes
                     #El servidor tcp en el embebido comienza a contar desde 0
                     status = ['0'] * 64
                     message = 'CHGB{}'.format(beam_pos)
                     sock = self.send_multicast(message)
                     while True:
                     #for i in range(32):
                         try:
                             data, address = sock.recvfrom(1024)
                             print (address, data)
                             data = data.decode()
                             if data == '1':
                                 status[int(address[0][10:])-1] = '3'
                             elif data == '0':
                                 status[int(address[0][10:])-1] = '1'
                         except socket.timeout:
                             print('Timeout')
                             break
                         except  Exception as e:
                             print ('Error {}'.format(e))
                             pass
                     sock.close()
                     #Start DDS-RC-JARS
                     if confdds:
                         confdds.start_device()
                     if confrc:
                         #print confrc
                         confrc.start_device()
                     if confjars:
                         confjars.start_device()
                     self.message = "ABS Beam has been changed"
                     self.module_status = ''.join(status)
                     self.save()
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_abs_conf', args=[str(self.id)])
             class ABSActive(models.Model):
                 conf = models.ForeignKey(ABSConfiguration, null=True, verbose_name='ABS Configuration', on_delete=models.CASCADE)
                 class Meta:
                     db_table = 'abs_absactive'
             class ABSBeam(models.Model):
                 name         = models.CharField(max_length=60, default='Beam')
                 antenna      = models.CharField(verbose_name='Antenna', max_length=1000, default=antenna_default)
                 abs_conf     = models.ForeignKey('ABSConfiguration', null=True,
                 verbose_name='ABS Configuration', on_delete=models.CASCADE)
                 tx           = models.CharField(verbose_name='Tx', max_length=1000, default=tx_default)
                 rx           = models.CharField(verbose_name='Rx', max_length=1000, default=rx_default)
                 s_time       = models.TimeField(verbose_name='Star Time', default='00:00:00')
                 e_time       = models.TimeField(verbose_name='End Time', default='23:59:59')
                 ues          = models.CharField(verbose_name='Ues', max_length=100, default=ues_default)
                 only_rx      = models.CharField(verbose_name='Only RX', max_length=40, default=onlyrx_default)
                 class Meta:
                     db_table = 'abs_beams'
                 def __unicode__(self):
                     return u'%s' % (self.name)
                 def parms_to_dict(self):
                     parameters = {}
                     parameters['name']          = self.name
                     parameters['antenna']       = ast.literal_eval(self.antenna)
                     parameters['abs_conf']      = self.abs_conf.name
                     parameters['tx']            = ast.literal_eval(self.tx)
                     parameters['rx']            = ast.literal_eval(self.rx)
                     parameters['s_time']        = self.s_time.strftime("%H:%M:%S")
                     parameters['e_time']        = self.e_time.strftime("%H:%M:%S")
                     parameters['ues']           = ast.literal_eval(self.ues)
                     parameters['only_rx']       = json.loads(self.only_rx)
                     return parameters
                 def dict_to_parms(self, parameters):
                     self.name     = parameters['name']
                     self.antenna  = json.dumps(parameters['antenna'])
                     #self.abs_conf = parameters['abs_conf']
                     self.tx       = json.dumps(parameters['tx'])
                     self.rx       = json.dumps(parameters['rx'])
                     #self.s_time = parameters['s_time']
                     #self.e_time = parameters['e_time']
                     self.ues      = json.dumps(parameters['ues'])
                     self.only_rx     = json.dumps(parameters['only_rx'])
                     self.save()
                 def clone(self, **kwargs):
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def module_6bits(self, module):
                     """
                     This function reads antenna pattern and choose 6bits (upbits-downbits) for one abs module
                     """
                     module += 1
                     if module > 64:
                         beam_bits = ""
                         return beam_bits
                     data      = ast.literal_eval(self.antenna)
                     up_data   = data['antenna_up']
                     down_data = data['antenna_down']
                     pos        = ip2position(module)
                     up_value   = up_data[pos[0]][pos[1]]
                     down_value = down_data[pos[0]][pos[1]]
                     up_bits   = up_conv_bits(up_value)
                     down_bits = down_conv_bits(down_value)
                     beam_bits = up_bits+down_bits
                     return beam_bits
                 @property
                 def get_upvalues(self):
                     """
                     This function reads antenna pattern and show the up-value of one abs module
                     """
                     data      = ast.literal_eval(self.antenna)
                     up_data   = data['antenna_up']
                     up_values = []
                     for data in up_data:
                         for i in range(0,8):
                             up_values.append(data[i])
                     return up_values
                 @property
                 def antenna_upvalues(self):
                     """
                     This function reads antenna pattern and show the up - values of one abs beam
                     in a particular order
                     """
                     data      = ast.literal_eval(self.antenna)
                     up_data   = data['antenna_up']
                     return up_data
                 @property
                 def antenna_downvalues(self):
                     """
                     This function reads antenna pattern and show the down - values of one abs beam
                     in a particular order
                     """
                     data      = ast.literal_eval(self.antenna)
                     down_data   = data['antenna_down']
                     return down_data
                 @property
                 def get_downvalues(self):
                     """
                     This function reads antenna pattern and show the down-value of one abs module
                     """
                     data      = ast.literal_eval(self.antenna)
                     down_data = data['antenna_down']
                     down_values = []
                     for data in down_data:
                         for i in range(0,8):
                             down_values.append(data[i])
                     return down_values
                 @property
                 def get_up_ues(self):
                     """
                     This function shows the up-ues-value of one beam
                     """
                     data      = ast.literal_eval(self.ues)
                     up_ues = data['up']
                     return up_ues
                 @property
                 def get_down_ues(self):
                     """
                     This function shows the down-ues-value of one beam
                     """
                     data      = ast.literal_eval(self.ues)
                     down_ues = data['down']
                     return down_ues
                 @property
                 def get_up_onlyrx(self):
                     """
                     This function shows the up-onlyrx-value of one beam
                     """
                     data      = json.loads(self.only_rx)
                     up_onlyrx = data['up']
                     return up_onlyrx
                 @property
                 def get_down_onlyrx(self):
                     """
                     This function shows the down-onlyrx-value of one beam
                     """
                     data      = json.loads(self.only_rx)
                     down_onlyrx = data['down']
                     return down_onlyrx
                 @property
                 def get_tx(self):
                     """
                     This function shows the tx-values of one beam
                     """
                     data = json.loads(self.tx)
                     return data
                 @property
                 def get_uptx(self):
                     """
                     This function shows the up-tx-values of one beam
                     """
                     data = json.loads(self.tx)
                     up_data = data['up']
                     up_values = []
                     for data in up_data:
                         for i in range(0,8):
                             up_values.append(data[i])
                     return up_values
                 @property
                 def get_downtx(self):
                     """
                     This function shows the down-tx-values of one beam
                     """
                     data = json.loads(self.tx)
                     down_data = data['down']
                     down_values = []
                     for data in down_data:
                         for i in range(0,8):
                             down_values.append(data[i])
                     return down_values
                 @property
                 def get_rx(self):
                     """
                     This function shows the rx-values of one beam
                     """
                     data = json.loads(self.rx)
                     return data
                 @property
                 def get_uprx(self):
                     """
                     This function shows the up-rx-values of one beam
                     """
                     data = json.loads(self.rx)
                     up_data = data['up']
                     up_values = []
                     for data in up_data:
                         for i in range(0,8):
                             up_values.append(data[i])
                     return up_values
                 @property
                 def get_downrx(self):
                     """
                     This function shows the down-rx-values of one beam
                     """
                     data = json.loads(self.rx)
                     down_data = data['down']
                     down_values = []
                     for data in down_data:
                         for i in range(0,8):
                             down_values.append(data[i])
                     return down_values

apps/abs/urls.py +1 -1

             from django.urls import path
             from apps.abs import views
             urlpatterns = (
                 path('<int:id_conf>/', views.abs_conf, name='url_abs_conf'),
                 path('<int:id_conf>/edit/', views.abs_conf_edit, name='url_edit_abs_conf'),
                 path('alert/', views.abs_conf_alert, name='url_alert_abs_conf'),
                 path('<int:id_conf>/import/', views.import_file, name='url_import_abs_conf'),
                 #url(r'^(?P<id_conf>-?\d+)/status/', views.abs_conf, {'status_request':True},name='url_status_abs_conf'),
                 path('<int:id_conf>/change_beam/<int:id_beam>/', views.send_beam, name='url_send_beam'),
                 path('<int:id_conf>/plot/', views.plot_patterns, name='url_plot_abs_patterns'),
                 path('<int:id_conf>/plot/<int:id_beam>/', views.plot_patterns, name='url_plot_abs_patterns'),
-                path('<int:id_conf>/plot/<int:id_beam>/<int:antenna>/pattern.png', views.plot_pattern, name='url_plot_beam'),
+                path('<int:id_conf>/plot/<int:id_beam>/<slug:antenna>/pattern.png', views.plot_pattern, name='url_plot_beam'),
                 path('<int:id_conf>/add_beam/', views.add_beam, name='url_add_abs_beam'),
                 path('<int:id_conf>/beam/<int:id_beam>/delete/', views.remove_beam, name='url_remove_abs_beam'),
                 path('<int:id_conf>/beam/<int:id_beam>/edit/', views.edit_beam, name='url_edit_abs_beam'),
             )

apps/abs/utils/overJroShow.py +6 -6

             #!/usr/bin/python
             import sys, os, os.path
             import traceback
             import cgi
             from http import cookies
             import time, datetime
             import types
             import numpy
             import numpy.fft
             import scipy.linalg
             import scipy.special
             from io import StringIO
             #import Misc_Routines
             from .Misc_Routines import CoFactors
             #import TimeTools
             from .TimeTools import Time , Julian ,Doy2Date
             #import JroAntSetup
             from .JroAntSetup import ReturnSetup
             #import Graphics_OverJro
             from .Graphics_OverJro import AntPatternPlot ,BFieldPlot,CelestialObjectsPlot,PatternCutPlot,SkyNoisePlot
             #import Astro_Coords
             from .Astro_Coords import Geodetic ,AltAz ,CelestialBodies
             class JroPattern():
                 def __init__(self,pattern=0,path=None,filename=None,nptsx=101,nptsy=101,maxphi=5,fftopt=0, \
                     getcut=0,dcosx=None,dcosy=None,eomwl=6,airwl=4, **kwargs):
                     """
                     JroPattern class creates an object to represent the useful parameters for beam mode-
                     lling of the Jicamarca VHF radar.
                     Parameters
                     ----------
                     pattern = An integer (See JroAntSetup to know the available values) to load a prede-
                       fined configuration. The default value  is 0. To use a  user-defined configuration
                       pattern  must be None.
                     path = A string giving the directory that contains the user-configuration file. PATH
                       will work if pattern is None.
                     filename = A string giving the  name of the  user-configuration  file. FILENAME will
                       work if pattern is None.
                     nptsx = A scalar to specify the number of points  used to define the angular resolu-
                       tion in the "x" axis. The default value is 101.
                     nptsy = A scalar to specify the number of points  used to define the angular resolu-
                       tion in the "x" axis. The default value is 101.
                     maxphi = A scalar giving the maximum (absolute) angle (in degree) to model the ante-
                       nna pattern. The default value is 5 degrees.
                     fftopt = Set this input  to 1 to model  the beam using FFT.  To model  using antenna
                       theory set to 0 (default value).
                     getcut = Set to 1 to show an antenna cut instead of a contour plot of itself (set to
 ). The defautl value is 0.
                     dcosx = An array giving the directional cosines for the  x-axis. DCOSX  will work if
                       getcut is actived.
                     dcosy = An array giving the directional cosines for the  y-axis. DCOSY  will work if
                       getcut is actived.
                     eomwl = A scalar giving the radar wavelength. The default value is 6m (50 MHZ).
                     airwl = Set this input to float (or intger) to specify the wavelength (in meters) of
                       the transmitted EOM wave in the air. The default value is 4m.
                     Modification History
                     --------------------
                     Converted to Object-oriented Programming by Freddy Galindo, ROJ, 20 September 2009.
                     """
                     # Getting antenna configuration.
                     if filename:
                         setup = ReturnSetup(path=path,filename=filename,pattern=pattern)
                         ues = setup["ues"]
                         phase = setup["phase"]
                         gaintx = setup["gaintx"]
                         gainrx = setup["gainrx"]
                         justrx = setup["justrx"]
                         self.title = setup["title"]
                     else:
                         ues = kwargs["ues"]
                         phase = kwargs["phases"]
                         gaintx = kwargs["gain_tx"]
                         gainrx = kwargs["gain_rx"]
                         justrx = kwargs["just_rx"]
                         self.title = kwargs.get("title", "JRO Pattern")
                     # Defining attributes for JroPattern class.
                     # Antenna configuration
                     self.uestx = ues
                     self.phasetx = phase
                     self.gaintx = gaintx
                     self.uesrx = ues
                     self.phaserx = phase
                     self.gainrx = gainrx
                     self.justrx = justrx
                     # Pattern resolution & method to model
                     self.maxphi = maxphi
                     self.nptsx = nptsx
                     self.nptsy = nptsy
                     self.fftopt = fftopt
                     # To get a cut of the pattern.
                     self.getcut = getcut
                     maxdcos = numpy.sin(maxphi*CoFactors.d2r)
                     if dcosx==None:dcosx = ((numpy.arange(nptsx,dtype=float)/(nptsx-1))-0.5)*2*maxdcos
                     if dcosy==None:dcosy = ((numpy.arange(nptsy,dtype=float)/(nptsy-1))-0.5)*2*maxdcos
                     self.dcosx = dcosx
                     self.dcosy = dcosy
                     self.nx = dcosx.size
                     self.ny = dcosy.size*(getcut==0) + (getcut==1)
                     self.eomwl = eomwl
                     self.airwl = airwl
                     self.kk = 2.*numpy.pi/eomwl
                     self.pattern = None
                     self.meanpos = None
                     self.norpattern = None
                     self.maxpattern = None
                     self.getPattern()
                 def getPattern(self):
                     """
                     getpattern method returns the modeled total antenna pattern and its mean position.
                     Return
                     ------
                     pattern = An array giving the Modelled antenna pattern.
                     mean_pos = A 2-elements array giving the mean position of the main beam.
                     Examples
                     --------
                     >> [pattern, mean_pos] = JroPattern(pattern=2).getPattern()
                     >> print meanpos
                     [  8.08728085e-14  -4.78193873e-14]
                     Modification history
                     --------------------
                     Developed by Jorge L. Chau.
                     Converted to Python by Freddy R. Galindo, ROJ, 20 September 2009.
                     """
                     if (self.fftopt>0) and (self.getcut>0):
                         #print  "Conflict bewteen fftopt and getcut"
                         #print  "To get a cut of the antenna pattern uses ffopt=0"
                         return None, None
                     if (self.fftopt==0):
                         # Getting antenna pattern using the array method
                         self.pattern = self.__usingArray(rx=1)
                         if (self.justrx==0):self.pattern = self.pattern*self.__usingArray(rx=0)
                     elif (self.fftopt>0):
                         # Getting antenna pattern using FFT method
                         self.pattern = self.__usingFFT(rx=1)
                         if (self.justrx==0):self.pattern = self.pattern*self.__usingFFT(rx=0)
                     self.maxpattern = numpy.nanmax(self.pattern)
                     self.norpattern = self.pattern/self.maxpattern
                     if self.getcut==0:self.__getBeamPars()
                 def __usingArray(self,rx):
                     """
                     __usingArray method returns the Jicamarca antenna pattern computed using array model
                     pattern = dipolepattern x modulepattern
                     Parameters
                     ----------
                     rx = Set to 1 to use the Rx information. Otherwise set to 0 for Tx.
                     Return
                     ------
                     pattern = An array giving the modelled antenna pattern using the array model.
                     Modification history
                     --------------------
                     Developed by Jorge L. Chau.
                     Converted to Python by Freddy R. Galindo, ROJ, 20 September 2009.
                     """
                     if rx==1:
                         ues = self.uesrx
                         phase = self.phaserx
                         gain = self.gainrx
                     elif rx==0:
                         ues = self.uestx
                         phase = self.phasetx
                         gain = self.gaintx
                     ues = ues*360./self.airwl
                     phase = phase*360./self.airwl
                     for ii in range(4):
                         if ii==0:dim = numpy.array([4,0,8,4])   # WEST
                         elif ii==1:dim = numpy.array([0,0,4,4]) # NORTH
                         elif ii==2:dim = numpy.array([0,4,4,8]) # EAST
                         elif ii==3:dim = numpy.array([4,4,8,8]) # SOUTH
                         xi = dim[0]; xf = dim[2]; yi = dim[1]; yf = dim[3]
                         phase[xi:xf,yi:yf] = phase[xi:xf,yi:yf] + ues[ii]
                     phase = -phase
                     ar = self.eomwl*numpy.array([[0.5,6., 24.5],[0.5,6.,24.5]])
                     nr = numpy.array([[12.,4.,2.],[12.,4.,2.]])
                     lr = 0.25*self.eomwl*numpy.array([[0,0.,0],[0.,0,0]])
                     # Computing module and dipole patterns.
                     pattern = (numpy.abs(self.__dipPattern(ar,nr,lr)*self.__modPattern(phase,gain)))**2
                     return pattern
                 def __usingFFT(self,rx):
                     """
                     __usingFFT method returns the Jicamarca antenna pattern computed using The Fast Fou-
                     rier Transform.
                     pattern = iFFT(FFT(gain*EXP(j*phase)))
                     Parameters
                     ----------
                     rx = Set to 1 to use the Rx information. Otherwise set to 0 for Tx.
                     Return
                     ------
                     pattern = An array giving the modelled antenna pattern using the array model.
                     Modification history
                     --------------------
                     Developed by Jorge L. Chau.
                     Converted to Python by Freddy R. Galindo, ROJ, 20 September 2009.
                     """
                     if rx==1:
                         ues = self.uesrx
                         phase = self.phaserx
                         gain = self.gainrx
                     elif rx==0:
                         ues = self.uestx
                         phase = self.phasetx
                         gain = self.gaintx
                     ues = ues*360./self.airwl
                     phase = phase*360./self.airwl
                     for ii in range(4):
                         if ii==0:dim = numpy.array([4,0,8,4])   # WEST
                         elif ii==1:dim = numpy.array([0,0,4,4]) # NORTH
                         elif ii==2:dim = numpy.array([0,4,4,8]) # EAST
                         elif ii==3:dim = numpy.array([4,4,8,8]) # SOUTH
                         xi = dim[0]; xf = dim[2]; yi = dim[1]; yf = dim[3]
                         phase[xi:xf,yi:yf] = phase[xi:xf,yi:yf] + ues[ii]
                     phase = -phase
                     delta_x = self.eomwl/2.
                     delta_y = self.eomwl/2.
                     nxfft = 2048
                     nyfft = 2048
                     dcosx = (numpy.arange(nxfft) - (0.5*nxfft))/(nxfft*delta_x)*self.eomwl
                     dcosy = (numpy.arange(nyfft) - (0.5*nyfft))/(nyfft*delta_y)*self.eomwl
                     fft_gain = numpy.zeros((nxfft,nyfft))
                     fft_phase = numpy.zeros((nxfft,nyfft))
                     nx = 8
                     ny = 8
                     ndx =12
                     ndy =12
                     for iy in numpy.arange(ny):
                         for ix in numpy.arange(nx):
                             ix1 = nxfft/2-self.nx/2*ndx+ix*ndx
                             if ix<(nx/2):ix1 = ix1 - 1
                             if ix>=(nx/2):ix1 = ix1 + 1
                             iy1 = nyfft/2-ny/2*ndx+iy*ndy
                             if iy<(ny/2):iy1 = iy1 - 1
                             if iy>=(ny/2):iy1 = iy1 + 1
                             fft_gain[ix1:ix1+ndx-1,iy1:iy1+ndy-1] = gain[ix,ny-1-iy]
                             fft_phase[ix1:ix1+ndx-1,iy1:iy1+ndy-1] = phase[ix,ny-1-iy]
                     fft_phase = fft_phase*CoFactors.d2r
                     pattern = numpy.abs(numpy.fft.fft2(fft_gain*numpy.exp(numpy.complex(0,1)*fft_phase)))**2
                     pattern = numpy.fft.fftshift(pattern)
                     xvals = numpy.where((dcosx>=(numpy.min(self.dcosx))) & (dcosx<=(numpy.max(self.dcosx))))
                     yvals = numpy.where((dcosy>=(numpy.min(self.dcosy))) & (dcosy<=(numpy.max(self.dcosy))))
                     pattern = pattern[xvals[0][0]:xvals[0][-1],yvals[0][0]:yvals[0][-1]]
                     return pattern
                 def __readAttenuation(self):
                     """
                     _readAttenuation reads the attenuations' file and returns an array giving  these va-
                     lues (dB). The ext file must be in the directory "resource".
                     Return
                     ------
                     attenuation = An array giving attenuation values read from the text file.
                     Modification history
                     --------------------
                     Developed by Jorge L. Chau.
                     Converted to Python by Freddy R. Galindo, ROJ, 20 September 2009.
                     """
             #         attenuation = None
             # #        foldr = sys.path[-1] + os.sep + "resource" + os.sep
             #         base_path = os.path.dirname(os.path.abspath(__file__))
             #         #foldr = './resource'
             #         #filen = "attenuation.txt"
             #         attenuationFile = os.path.join(base_path,"resource","attenuation.txt")
             #         #ff = open(os.path.join(foldr,filen),'r')
             #         ff = open(attenuationFile,'r')
             #         print(ff.read())
             #         exec(ff.read())
             #         ff.close()
                     attenuation = numpy.array([[[-21.25,-15.25,-9.25,-3.25,03.25,09.25,15.25,21.25],
             		         [-21.25,-15.25,-9.25,-3.25,03.25,09.25,15.25,21.25],
                		         [-21.25,-15.25,-9.25,-3.25,03.25,09.25,15.25,21.25],
             		         [-21.25,-15.25,-9.25,-3.25,03.25,09.25,15.25,21.25],
             		         [-21.25,-15.25,-9.25,-3.25,03.25,09.25,15.25,21.25],
             		         [-21.25,-15.25,-9.25,-3.25,03.25,09.25,15.25,21.25],
             		         [-21.25,-15.25,-9.25,-3.25,03.25,09.25,15.25,21.25],
             		         [-21.25,-15.25,-9.25,-3.25,03.25,09.25,15.25,21.25]],
                    		         [[21.25,21.25,21.25,21.25,21.25,21.25,21.25,21.25],
             		         [15.25,15.25,15.25,15.25,15.25,15.25,15.25,15.25],
             		         [09.25,09.25,09.25,09.25,09.25,09.25,09.25,09.25],
             		         [03.25,03.25,03.25,03.25,03.25,03.25,03.25,03.25],
             		         [-03.25,-03.25,-03.25,-03.25,-03.25,-03.25,-03.25,-03.25],
             		         [-09.25,-09.25,-09.25,-09.25,-09.25,-09.25,-09.25,-09.25],
             		         [-15.25,-15.25,-15.25,-15.25,-15.25,-15.25,-15.25,-15.25],
                 		         [-21.25,-21.25,-21.25,-21.25,-21.25,-21.25,-21.25,-21.25]]])
                     return attenuation
                 def __dipPattern(self,ar,nr,lr):
                     """
                     _dipPattern function computes the dipole's pattern to  the Jicamarca radar. The next
                     equation defines the pattern as a function of the mainlobe direction:
                     sincx = SIN(k/2*n0x*(a0x*SIN(phi)*COS(alpha)))/SIN(k/2*(a0x*SIN(phi)*COS(alpha)))
                     sincy = SIN(k/2*n0y*(a0y*SIN(phi)*SIN(alpha)))/SIN(k/2*(a0y*SIN(phi)*SIN(alpha)))
                     A0(phi,alpha) = sincx*sincy
                     Parameters
                     ----------
                     ar = ?
                     nr = ?
                     lr = ?
                     Return
                     ------
                     dipole = An array giving antenna pattern from the dipole point of view..
                     Modification history
                     --------------------
                     Developed by Jorge L. Chau.
                     Converted to Python by Freddy R. Galindo, ROJ, 20 September 2009.
                     """
                     dipole = numpy.zeros((self.nx,self.ny),dtype=complex)
                     for iy in range(self.ny):
                         for ix in range(self.nx):
                             yindex = iy*(self.getcut==0) + ix*(self.getcut==1)
                             argx = ar[0,0]*self.dcosx[ix] - lr[0,0]
                             if argx == 0.0:
                                 junkx = nr[0,0]
                             else:
                                 junkx = numpy.sin(0.5*self.kk*nr[0,0]*argx)/numpy.sin(0.5*self.kk*argx)
                             argy = ar[1,0]*self.dcosy[yindex] - lr[1,0]
                             if argy == 0.0:
                                 junky = nr[1,0]
                             else:
                                 junky = numpy.sin(0.5*self.kk*nr[1,0]*argy)/numpy.sin(0.5*self.kk*argy)
                             dipole[ix,iy] = junkx*junky
                     return dipole
                 def __modPattern(self,phase,gain):
                     """
                     ModPattern computes the module's pattern to the Jicamarca radar.  The next equation
                     defines    the pattern as a function mainlobe direction:
                     phasex = pos(x)*SIN(phi)*COS(alpha)
                     phasey = pos(y)*SIN(phi)*SIN(alpha)
                     A1(phi,alpha) = TOTAL(gain*EXP(COMPLEX(0,k*(phasex+phasey)+phase)))
                     Parameters
                     ----------
                     phase = Bidimensional array (8x8) giving the phase (in meters) of each module.
                     gain  = Bidimensional array (8x8) giving to  define modules  will be active  (ones)
                       and which will not (zeros).
                     Return
                     ------
                     module = An array giving antenna pattern from the module point of view..
                     Modification history
                     --------------------
                     Developed by Jorge L. Chau.
                     Converted to Python by Freddy R. Galindo, ROJ, 20 September 2009.
                     """
                     pos  = self.eomwl*self.__readAttenuation()
                     posx = pos[0,:,:]
                     posy = pos[1,:,:]
                     phase = phase*CoFactors.d2r
                     module = numpy.zeros((self.nx,self.ny),dtype=complex)
                     for iy in range(self.ny):
                         for ix in range(self.nx):
                             yindex = iy*(self.getcut==0) + ix*(self.getcut==1)
                             phasex = posx*self.dcosx[ix]
                             phasey = posy*self.dcosy[yindex]
                             tmp = gain*numpy.exp(numpy.complex(0,1.)*(self.kk*(phasex+phasey)+phase))
                             module[ix,iy] = tmp.sum()
                     return module
                 def __getBeamPars(self):
                     """
                     _getBeamPars computes the main-beam parameters of the antenna.
                     Modification history
                     --------------------
                     Developed by Jorge L. Chau.
                     Converted to Python by Freddy R. Galindo, ROJ, 20 September 2009.
                     """
                     dx = self.dcosx[1] - self.dcosx[0]
                     dy = self.dcosy[1] - self.dcosy[0]
                     amp = self.norpattern
                     xx =  numpy.resize(self.dcosx,(self.nx,self.nx)).transpose()
                     yy =  numpy.resize(self.dcosy,(self.ny,self.ny))
                     mm0 = amp[numpy.where(amp > 0.5)]
                     xx0 = xx[numpy.where(amp > 0.5)]
                     yy0 = yy[numpy.where(amp > 0.5)]
                     xc = numpy.sum(mm0*xx0)/numpy.sum(mm0)
                     yc = numpy.sum(mm0*yy0)/numpy.sum(mm0)
                     rc = numpy.sqrt(mm0.size*dx*dy/numpy.pi)
                     nnx = numpy.where(numpy.abs(self.dcosx - xc) < rc)
                     nny = numpy.where(numpy.abs(self.dcosy - yc) < rc)
                     mm1 = amp[numpy.min(nnx):numpy.max(nnx)+1,numpy.min(nny):numpy.max(nny)+1]
                     xx1 = self.dcosx[numpy.min(nnx):numpy.max(nnx)+1]
                     yy1 = self.dcosy[numpy.min(nny):numpy.max(nny)+1]
                     # fitting data into the main beam.
-                    import gaussfit
+                    from .gaussfit import fitgaussian
-                    params = gaussfit.fitgaussian(mm1)
+                    params = fitgaussian(mm1)
                     # Tranforming from indexes to axis' values
                     xcenter = xx1[0] + (((xx1[xx1.size-1] - xx1[0])/(xx1.size -1))*(params[1]))
                     ycenter = yy1[0] + (((yy1[yy1.size-1] - yy1[0])/(yy1.size -1))*(params[2]))
                     xwidth  = ((xx1[xx1.size-1] - xx1[0])/(xx1.size-1))*(params[3])*(1/CoFactors.d2r)
                     ywidth  = ((yy1[yy1.size-1] - yy1[0])/(yy1.size-1))*(params[4])*(1/CoFactors.d2r)
                     meanwx = (xwidth*ywidth)
                     meanpos = numpy.array([xcenter,ycenter])
                     #print  'Position: %f %f' %(xcenter,ycenter)
                     #print  'Widths:   %f %f' %(xwidth, ywidth)
                     #print  'BWHP:     %f' %(2*numpy.sqrt(2*meanwx)*numpy.sqrt(-numpy.log(0.5)))
                     self.meanpos = meanpos
             class BField():
                 def __init__(self,year=None,doy=None,site=1,heights=None,alpha_i=90):
                     """
                     BField class creates an object to get  the Magnetic  field for a  specific date and
                     height(s).
                     Parameters
                     ----------
                     year = A scalar giving the desired year.  If the value is None (default value) then
                       the current year will be used.
                     doy = A scalar giving the desired day of the year. If the value is None (default va-
                       lue) then the current doy will be used.
                     site = An integer to choose the geographic coordinates of the place where the magne-
                       tic field will be computed. The default value is over Jicamarca (site=1)
                     heights = An array giving the heights (km) where the magnetic field will be modeled By default the magnetic field will be computed at 100, 500 and 1000km.
                     alpha_i = Angle to interpolate the magnetic field.
                     Modification History
                     --------------------
                     Converted to Object-oriented Programming by Freddy Galindo, ROJ, 07 October 2009.
                     """
                     tmp = time.localtime()
                     if year==None: year = tmp[0]
                     if doy==None:  doy = tmp[7]
                     self.year = year
                     self.doy = doy
                     self.site = site
                     if heights==None:heights = numpy.array([100,500,1000])
                     self.heights = heights
                     self.alpha_i = alpha_i
                 def getBField(self,maglimits=numpy.array([-7,-7,7,7])):
                     """
                     getBField models the magnetic field for a different heights in a specific date.
                     Parameters
                     ----------
                     maglimits = An 4-elements array giving ..... The default value is [-7,-7,7,7].
                     Return
                     ------
                     dcos = An 4-dimensional array giving the directional cosines of the magnetic field
                       over the desired place.
                     alpha = An 3-dimensional array giving the angle of the magnetic field over the desi-
                       red place.
                     Modification History
                     --------------------
                     Converted to Python by Freddy R. Galindo, ROJ, 07 October 2009.
                     """
                     x_ant = numpy.array([1,0,0])
                     y_ant = numpy.array([0,1,0])
                     z_ant = numpy.array([0,0,1])
                     if self.site==0:
                         title_site = "Magnetic equator"
                         coord_site = numpy.array([-76+52./60.,-11+57/60.,0.5])
                     elif self.site==1:
                         title_site = 'Jicamarca'
                         coord_site = [-76-52./60.,-11-57/60.,0.5]
                         theta = (45+5.35)*numpy.pi/180.      # (50.35 and 1.46 from Fleish Thesis)
                         delta = -1.46*numpy.pi/180
                         x_ant1 = numpy.roll(self.rotvector(self.rotvector(x_ant,1,delta),3,theta),1)
                         y_ant1 = numpy.roll(self.rotvector(self.rotvector(y_ant,1,delta),3,theta),1)
                         z_ant1 = numpy.roll(self.rotvector(self.rotvector(z_ant,1,delta),3,theta),1)
                         ang0 = -1*coord_site[0]*numpy.pi/180.
                         ang1 = coord_site[1]*numpy.pi/180.
                         x_ant = self.rotvector(self.rotvector(x_ant1,2,ang1),3,ang0)
                         y_ant = self.rotvector(self.rotvector(y_ant1,2,ang1),3,ang0)
                         z_ant = self.rotvector(self.rotvector(z_ant1,2,ang1),3,ang0)
                     else:
             #            print "No defined Site. Skip..."
                         return None
                     nhei = self.heights.size
                     pt_intercep = numpy.zeros((nhei,2))
                     nfields = 1
                     grid_res = 0.5
                     nlon = int(numpy.int(maglimits[2] - maglimits[0])/grid_res + 1)
                     nlat = int(numpy.int(maglimits[3] - maglimits[1])/grid_res + 1)
                     location = numpy.zeros((nlon,nlat,2))
                     mlon = numpy.atleast_2d(numpy.arange(nlon)*grid_res + maglimits[0])
                     mrep = numpy.atleast_2d(numpy.zeros(nlat) + 1)
                     location0 = numpy.dot(mlon.transpose(),mrep)
                     mlat = numpy.atleast_2d(numpy.arange(nlat)*grid_res + maglimits[1])
                     mrep = numpy.atleast_2d(numpy.zeros(nlon) + 1)
                     location1 = numpy.dot(mrep.transpose(),mlat)
                     location[:,:,0] = location0
                     location[:,:,1] = location1
                     alpha = numpy.zeros((nlon,nlat,nhei))
                     rr = numpy.zeros((nlon,nlat,nhei,3))
                     dcos = numpy.zeros((nlon,nlat,nhei,2))
                     global first_time
                     first_time = None
                     for ilon in numpy.arange(nlon):
                         for ilat in numpy.arange(nlat):
                             outs = self.__bdotk(self.heights,
                                                 self.year + self.doy/366.,
                                                 coord_site[1],
                                                 coord_site[0],
                                                 coord_site[2],
                                                 coord_site[1]+location[ilon,ilat,1],
                                                 location[ilon,ilat,0]*720./180.)
                             alpha[ilon, ilat,:] = outs[1]
                             rr[ilon, ilat,:,:] = outs[3]
                             mrep = numpy.atleast_2d((numpy.zeros(nhei)+1)).transpose()
                             tmp = outs[3]*numpy.dot(mrep,numpy.atleast_2d(x_ant))
                             tmp = tmp.sum(axis=1)
                             dcos[ilon,ilat,:,0] = tmp/numpy.sqrt((outs[3]**2).sum(axis=1))
                             mrep = numpy.atleast_2d((numpy.zeros(nhei)+1)).transpose()
                             tmp = outs[3]*numpy.dot(mrep,numpy.atleast_2d(y_ant))
                             tmp = tmp.sum(axis=1)
                             dcos[ilon,ilat,:,1] = tmp/numpy.sqrt((outs[3]**2).sum(axis=1))
                     return dcos, alpha, nlon, nlat
                 def __bdotk(self,heights,tm,gdlat=-11.95,gdlon=-76.8667,gdalt=0.0,decd=-12.88, ham=-4.61666667):
                     global first_time
                     # Mean Earth radius in Km WGS 84
                     a_igrf = 6371.2
                     bk = numpy.zeros(heights.size)
                     alpha = numpy.zeros(heights.size)
                     bfm = numpy.zeros(heights.size)
                     rr = numpy.zeros((heights.size,3))
                     rgc = numpy.zeros((heights.size,3))
-                    ObjGeodetic = Astro_Coords.Geodetic(gdlat,gdalt)
+                    ObjGeodetic = Geodetic(gdlat,gdalt)
                     [gclat,gcalt] = ObjGeodetic.change2geocentric()
                     gclat = gclat*numpy.pi/180.
                     gclon = gdlon*numpy.pi/180.
                     # Antenna position from center of Earth
                     ca_vector = [numpy.cos(gclat)*numpy.cos(gclon),numpy.cos(gclat)*numpy.sin(gclon),numpy.sin(gclat)]
                     ca_vector = gcalt*numpy.array(ca_vector)
                     dec = decd*numpy.pi/180.
                     # K  vector respect to the center of earth.
                     klon = gclon + ham*numpy.pi/720.
                     k_vector = [numpy.cos(dec)*numpy.cos(klon),numpy.cos(dec)*numpy.sin(klon),numpy.sin(dec)]
                     k_vector = numpy.array(k_vector)
                     for ih in numpy.arange(heights.size):
                         # Vector from Earth's center to volume of interest
                         rr[ih,:] = k_vector*heights[ih]
                         cv_vector = numpy.squeeze(ca_vector) + rr[ih,:]
                         cv_gcalt = numpy.sqrt(numpy.sum(cv_vector**2.))
                         cvxy = numpy.sqrt(numpy.sum(cv_vector[0:2]**2.))
                         radial = cv_vector/cv_gcalt
                         east = numpy.array([-1*cv_vector[1],cv_vector[0],0])/cvxy
                         comp1 = east[1]*radial[2] - radial[1]*east[2]
                         comp2 = east[2]*radial[0] - radial[2]*east[0]
                         comp3 = east[0]*radial[1] - radial[0]*east[1]
                         north = -1*numpy.array([comp1, comp2, comp3])
                         rr_k = cv_vector - numpy.squeeze(ca_vector)
                         u_rr = rr_k/numpy.sqrt(numpy.sum(rr_k**2.))
                         cv_gclat = numpy.arctan2(cv_vector[2],cvxy)
                         cv_gclon = numpy.arctan2(cv_vector[1],cv_vector[0])
                         bhei = cv_gcalt-a_igrf
                         blat = cv_gclat*180./numpy.pi
                         blon = cv_gclon*180./numpy.pi
                         bfield = self.__igrfkudeki(bhei,tm,blat,blon)
                         B = (bfield[0]*north + bfield[1]*east - bfield[2]*radial)*1.0e-5
                         bfm[ih] = numpy.sqrt(numpy.sum(B**2.)) #module
                         bk[ih] = numpy.sum(u_rr*B)
                         alpha[ih] = numpy.arccos(bk[ih]/bfm[ih])*180/numpy.pi
                         rgc[ih,:] = numpy.array([cv_gclon, cv_gclat, cv_gcalt])
                     return bk, alpha, bfm, rr, rgc
                 def __igrfkudeki(self,heights,time,latitude,longitude,ae=6371.2):
                     """
                     __igrfkudeki calculates the International Geomagnetic Reference Field for given in-
                     put conditions based on IGRF2005 coefficients.
                     Parameters
                     ----------
                     heights = Scalar or vector giving the height above the Earth  of the point in ques-
                       tion in kilometers.
                     time = Scalar or vector giving the decimal year of time in question (e.g. 1991.2).
                     latitude = Latitude of point in question in decimal degrees. Scalar or vector.
                     longitude = Longitude of point in question in decimal degrees. Scalar or vector.
                     ae =
                     first_time =
                     Return
                     ------
                     bn =
                     be =
                     bd =
                     bmod =
                     balpha =
                     first_time =
                     Modification History
                     --------------------
                     Converted to Python by Freddy R. Galindo, ROJ, 03 October 2009.
                     """
                     global first_time
                     global gs, hs, nvec, mvec, maxcoef
                     heights = numpy.atleast_1d(heights)
                     time = numpy.atleast_1d(time)
                     latitude = numpy.atleast_1d(latitude)
                     longitude = numpy.atleast_1d(longitude)
                     if numpy.max(latitude)==90:
             #            print "Field calculations are not supported at geographic poles"
                         pass
                     # output arrays
                     bn = numpy.zeros(heights.size)
                     be = numpy.zeros(heights.size)
                     bd = numpy.zeros(heights.size)
                     if first_time==None:first_time=0
                     time0 = time[0]
                     if time!=first_time:
                         #print "Getting coefficients for", time0
                         [periods,g,h ] = self.__readIGRFcoeff()
                         top_year = numpy.max(periods)
                         nperiod = (top_year - 1900)/5 + 1
                         maxcoef = 10
                         if time0>=2000:maxcoef = 12
                         # Normalization array for Schmidt fucntions
                         multer = numpy.zeros((2+maxcoef,1+maxcoef)) + 1
                         for cn in (numpy.arange(maxcoef)+1):
                             for rm in (numpy.arange(cn)+1):
                                 tmp = numpy.arange(2*rm) + cn - rm + 1.
                                 multer[rm+1,cn] = ((-1.)**rm)*numpy.sqrt(2./tmp.prod())
                         schmidt = multer[1:,1:].transpose()
                         # n and m arrays
                         nvec = numpy.atleast_2d(numpy.arange(maxcoef)+2)
                         mvec = numpy.atleast_2d(numpy.arange(maxcoef+1)).transpose()
                         # Time adjusted igrf g and h with Schmidt normalization
                         # IGRF coefficient arrays: g0(n,m), n=1, maxcoeff,m=0, maxcoeff, ...
                         if time0<top_year:
                             dtime = (time0 - 1900) % 5
                             ntime = (time0 - 1900 - dtime)/5
                         else:
                             # Estimating coefficients for times > top_year
                             dtime = (time0 - top_year) + 5
                             ntime = g[:,0,0].size - 2
                         g0 = g[ntime,1:maxcoef+1,:maxcoef+1]
                         h0 = h[ntime,1:maxcoef+1,:maxcoef+1]
                         gdot = g[ntime+1,1:maxcoef+1,:maxcoef+1]-g[ntime,1:maxcoef+1,:maxcoef+1]
                         hdot = h[ntime+1,1:maxcoef+1,:maxcoef+1]-h[ntime,1:maxcoef+1,:maxcoef+1]
                         gs = (g0 + dtime*(gdot/5.))*schmidt[:maxcoef,0:maxcoef+1]
                         hs = (h0 + dtime*(hdot/5.))*schmidt[:maxcoef,0:maxcoef+1]
                         first_time = time0
                     for ii in numpy.arange(heights.size):
                         # Height dependence array rad = (ae/(ae+height))**(n+3)
                         rad = numpy.atleast_2d((ae/(ae + heights[ii]))**(nvec+1))
                         # Sin and Cos of m times longitude phi arrays
                         mphi = mvec*longitude[ii]*numpy.pi/180.
                         cosmphi = numpy.atleast_2d(numpy.cos(mphi))
                         sinmphi = numpy.atleast_2d(numpy.sin(mphi))
                         # Cos of colatitude theta
                         c = numpy.cos((90 - latitude[ii])*numpy.pi/180.)
                         # Legendre functions p(n,m|c)
                         [p,dp]= scipy.special.lpmn(maxcoef+1,maxcoef+1,c)
                         p = p[:,:-1].transpose()
                         s = numpy.sqrt((1. - c)*(1 + c))
                         # Generate derivative array dpdtheta = -s*dpdc
                         dpdtheta = c*p/s
                         for m in numpy.arange(maxcoef+2):    dpdtheta[:,m] = m*dpdtheta[:,m]
                         dpdtheta = dpdtheta + numpy.roll(p,-1,axis=1)
                         # Extracting arrays required for field calculations
                         p = p[1:maxcoef+1,:maxcoef+1]
                         dpdtheta = dpdtheta[1:maxcoef+1,:maxcoef+1]
                         # Weigh p and dpdtheta with gs and hs coefficients.
                         gp = gs*p
                         hp = hs*p
                         gdpdtheta = gs*dpdtheta
                         hdpdtheta = hs*dpdtheta
                         # Calcultate field components
                         matrix0 = numpy.dot(gdpdtheta,cosmphi)
                         matrix1 = numpy.dot(hdpdtheta,sinmphi)
                         bn[ii] = numpy.dot(rad,(matrix0 + matrix1))
                         matrix0 = numpy.dot(hp,(mvec*cosmphi))
                         matrix1 = numpy.dot(gp,(mvec*sinmphi))
                         be[ii] = numpy.dot((-1*rad),((matrix0 - matrix1)/s))
                         matrix0 = numpy.dot(gp,cosmphi)
                         matrix1 = numpy.dot(hp,sinmphi)
                         bd[ii] = numpy.dot((-1*nvec*rad),(matrix0 + matrix1))
                     bmod = numpy.sqrt(bn**2. + be**2. + bd**2.)
                     btheta = numpy.arctan(bd/numpy.sqrt(be**2. + bn**2.))*180/numpy.pi
                     balpha = numpy.arctan(be/bn)*180./numpy.pi
                     #bn : north
                     #be : east
                     #bn : radial
                     #bmod : module
                     return bn, be, bd, bmod, btheta, balpha
                 def str2num(self, datum):
                     try:
                         return int(datum)
                     except:
                         try:
                             return float(datum)
                         except:
                             return datum
                 def __readIGRFfile(self, filename):
                     list_years=[]
                     for i in range(1,24):
                         list_years.append(1895.0 + i*5)
                     epochs=list_years
                     epochs.append(epochs[-1]+5)
                     nepochs = numpy.shape(epochs)
                     gg = numpy.zeros((13,14,nepochs[0]),dtype=float)
                     hh = numpy.zeros((13,14,nepochs[0]),dtype=float)
                     coeffs_file=open(filename)
                     lines=coeffs_file.readlines()
                     coeffs_file.close()
                     for line in lines:
                         items = line.split()
                         g_h = items[0]
                         n = self.str2num(items[1])
                         m = self.str2num(items[2])
                         coeffs = items[3:]
                         for i in range(len(coeffs)-1):
                             coeffs[i] = self.str2num(coeffs[i])
                         #coeffs = numpy.array(coeffs)
                         ncoeffs = numpy.shape(coeffs)[0]
                         if g_h == 'g':
                 #            print n," g ",m
                             gg[n-1,m,:]=coeffs
                         elif g_h=='h':
                 #            print n," h ",m
                             hh[n-1,m,:]=coeffs
                 #        else :
                 #            continue
                 #    Ultimo Reordenamiento para  almacenar .
                     gg[:,:,nepochs[0]-1] = gg[:,:,nepochs[0]-2] + 5*gg[:,:,nepochs[0]-1]
                     hh[:,:,nepochs[0]-1] = hh[:,:,nepochs[0]-2] + 5*hh[:,:,nepochs[0]-1]
             #        return numpy.array([gg,hh])
                     periods = numpy.array(epochs)
                     g = gg
                     h = hh
                     return periods, g, h
                 def __readIGRFcoeff(self,filename="igrf10coeffs.dat"):
                     """
                     __readIGRFcoeff reads the coefficients from  a binary file which is located  in the
                     folder "resource."
                     Parameter
                     ---------
                     filename = A string to specify the name of the file which contains thec coeffs. The
                     default value is "igrf10coeffs.dat"
                     Return
                     ------
                     periods = A lineal array giving...
                     g1 =
                     h1 =
                     Modification History
                     --------------------
                     Converted to Python by Freddy R. Galindo, ROJ, 03 October 2009.
                     """
             # #        igrfile = sys.path[-1] + os.sep + "resource" + os.sep + filename
             #         igrfile = os.path.join('./resource',filename)
             #         f = open(igrfile,'rb')
             #         #f = open(os.getcwd() + os.sep + "resource" + os.sep + filename,'rb')
             #
             #         # Reading SkyNoise Power (lineal scale)
             #         periods = numpy.fromfile(f,numpy.dtype([('var','<f4')]),23)
             #         periods = periods['var']
             #
             #         g = numpy.fromfile(f,numpy.dtype([('var','<f8')]),23*14*14)
             #         g = g['var'].reshape((14,14,23)).transpose()
             #
             #         h = numpy.fromfile(f,numpy.dtype([('var','<f8')]),23*14*14)
             #         h = h['var'].reshape((14,14,23)).transpose()
             #
             #         f.close()
                     base_path = os.path.dirname(os.path.abspath(__file__))
                     filename = os.path.join(base_path,"resource","igrf11coeffs.txt")
                     period_v, g_v, h_v = self.__readIGRFfile(filename)
                     g2 = numpy.zeros((14,14,24))
                     h2 = numpy.zeros((14,14,24))
                     g2[1:14,:,:] = g_v
                     h2[1:14,:,:] = h_v
                     g = numpy.transpose(g2, (2,0,1))
                     h = numpy.transpose(h2, (2,0,1))
                     periods = period_v.copy()
                     return periods, g, h
                 def rotvector(self,vector,axis=1,ang=0):
                     """
                     rotvector function returns the new vector generated rotating the rectagular coords.
                     Parameters
                     ----------
                     vector = A lineal 3-elements array (x,y,z).
                     axis = A integer to specify  the axis used to rotate the coord systems. The default
                       value is 1.
                         axis = 1 -> Around "x"
                         axis = 2 -> Around "y"
                         axis = 3 -> Around "z"
                     ang = Angle of rotation (in radians). The default value is zero.
                     Return
                     ------
                     rotvector = A lineal array of 3 elements giving the new coordinates.
                     Modification History
                     --------------------
                     Converted to Python by Freddy R. Galindo, ROJ, 01 October 2009.
                     """
                     if axis==1:
                         t = [[1,0,0],[0,numpy.cos(ang),numpy.sin(ang)],[0,-numpy.sin(ang),numpy.cos(ang)]]
                     elif axis==2:
                         t = [[numpy.cos(ang),0,-numpy.sin(ang)],[0,1,0],[numpy.sin(ang),0,numpy.cos(ang)]]
                     elif axis==3:
                         t = [[numpy.cos(ang),numpy.sin(ang),0],[-numpy.sin(ang),numpy.cos(ang),0],[0,0,1]]
                     rotvector = numpy.array(numpy.dot(numpy.array(t),numpy.array(vector)))
                     return rotvector
             class overJroShow:
             #    __serverdocspath = '/usr/local/www/htdocs'
             #    __tmpDir = 'overJro/tempReports'
             #     __serverdocspath = '/Users/dsuarez/Pictures'
             #     __tmpDir = 'overjro'
                 __serverdocspath = ''
                 __tmpDir = ''
                 def __init__(self, title=''):
                     self.year = None
                     self.month = None
                     self.dom = None
                     self.pattern = None
                     self.maxphi = None
                     self.heights = None
                     self.filename = None
                     self.showType = None
                     self.path = None
                     self.objects = None
                     self.nptsx = 101
                     self.nptsy = 101
                     self.fftopt = 0
                     self.site = 1
                     self.dcosx = 1
                     self.dcosy = 1
                     self.dcosxrange = None
                     self.dcosyrange = None
                     self.maxha_min= 0.
                     self.show_object = None
                     self.dcosx_mag = None
                     self.dcosy_mag = None
                     self.ha_mag = None
                     self.time_mag = None
                     self.main_dec = None
                     self.ObjC = None
                     self.ptitle = title
                     self.path4plotname = None
                     self.plotname0 = None
                     self.plotname1 = None
                     self.plotname2 = None
                     self.scriptHeaders = 0
                     self.glat = -11.95
                     self.glon = -76.8667
                     self.UT = 5 #timezone
                     self.glat = -11.951481
                     self.glon = -76.874383
             #       self.outputHead('Show Plot')
             #        self.printBody()
                 def setScriptState(self):
                     self.madForm = cgi.FieldStorage()
                     if self.madForm.has_key('serverdocspath'):
                         self.__serverdocspath = self.madForm.getvalue('serverdocspath')#'/usr/local/www/htdocs'
                     if self.madForm.has_key('tmpdir'):
                         self.__tmpDir = self.madForm.getvalue('tmpdir')#'overJro/tempReports'
                     if self.madForm.has_key('showType'):
                         self.showType = int(self.madForm.getvalue('showType'))
                     if self.showType == 0 or self.showType == 1:
             #             if self.madForm.has_key('year') and \
             #                 self.madForm.has_key('month') and \
             #                 self.madForm.has_key('dom') and \
             #                 self.madForm.has_key('pattern') and \
             #                 self.madForm.has_key('maxphi') and \
             #                 self.madForm.has_key('objects') and \
             #                 self.madForm.has_key('heights'):
                         if self.madForm.has_key('year') and \
                             self.madForm.has_key('month') and \
                             self.madForm.has_key('dom') and \
                             self.madForm.has_key('maxphi') and \
                             self.madForm.has_key('objects') and \
                             self.madForm.has_key('heights'):
                                 self.year = int(self.madForm.getvalue('year'))
                                 self.month = int(self.madForm.getvalue('month'))
                                 self.dom = int(self.madForm.getvalue('dom'))
                                 self.maxphi = float(self.madForm.getvalue('maxphi'))
                                 if self.madForm.has_key('pattern'):
                                     tmp_pattern = self.madForm.getvalue('pattern') #pattern es predifinido en listado o definido por el usuario
                                     self.pattern=[]
                                     if tmp_pattern[0] == '[':
                                         tmp_pattern=tmp_pattern[1:]
                                     if tmp_pattern[-1] == ']':
                                         tmp_pattern=tmp_pattern[0:len(tmp_pattern)-1]
                                     for s in tmp_pattern.split(','):
                                         self.pattern.append(float(s))
                                 elif self.madForm.has_key('filename'):
                                     if self.madForm.has_key('filename'):
                                         self.filename = self.madForm.getvalue('filename') # nombre de archivo: patron de radiacion definido por el usuario
                                     if self.madForm.has_key('path'):
                                         self.path = self.madForm.getvalue('path') #path donde se encuentra el archivo: patron de radiacion del usuario
                                 else:
                                     print ("Content-Type: text/html\n")
                                     print ('<h3> This cgi plot script was called without the proper arguments.</h3>')
                                     print ('<p> This is a script used to plot Antenna Cuts over Jicamarca Antenna</p>')
                                     print ('<p> Required arguments:</p>')
                                     print ('<p>    pattern - chekbox indicating objects over jicamarca antenna</p>')
                                     print ('<p> or')
                                     print ('<p>    filename - The pattern defined by users is a file text')
                                     print ('<p>    path - folder with pattern files')
                                     sys.exit(0)
                                 tmp_heights = self.madForm.getvalue('heights')
                                 self.heights=[]
                                 if tmp_heights[0] == '[':
                                     tmp_heights=tmp_heights[1:]
                                 if tmp_heights[-1] == ']':
                                     tmp_heights=tmp_heights[0:len(tmp_heights)-1]
                                 for s in tmp_heights.split(','):
                                     self.heights.append(float(s))
                                 self.heights = numpy.array(self.heights)
                                 tmp_objects = self.madForm.getvalue('objects') #lista con los objetos a graficar en el patron de radiacion
                                 self.objects=[]
                                 if tmp_objects[0] == '[':
                                     tmp_objects=tmp_objects[1:]
                                 if tmp_objects[-1] == ']':
                                     tmp_objects=tmp_objects[0:len(tmp_objects)-1]
                                 for s in tmp_objects.split(','):
                                     self.objects.append(int(s))
                                 if self.showType == 1:
                                     if numpy.sum(self.objects) == 0:
                                         if  self.scriptHeaders == 0:
                                             print ("Content-Type: text/html\n")
                                         print ('<h3> This cgi plot script was called without the proper arguments.</h3>')
                                         print ('<p> This is a script used to plot Antenna Cuts over Jicamarca Antenna</p>')
                                         print ('<p> Required arguments:</p>')
                                         print ('<p>    objects - chekbox indicating objects over jicamarca antenna</p>')
                                         print ('<p> Please, options in "Select Object" must be checked')
                                         sys.exit(0)
                                 #considerar para futura implementacion
                                 if self.madForm.has_key('filename'):
                                     self.filename = self.madForm.getvalue('filename') # nombre de archivo: patron de radiacion definido por el usuario
                                 if self.madForm.has_key('path'):
                                     self.path = self.madForm.getvalue('path') #path donde se encuentra el archivo: patron de radiacion del usuario
                         else:
                             if  self.scriptHeaders == 0:
                                 print ("Content-Type: text/html\n")
                             print ('<h3> This cgi plot script was called without the proper arguments.</h3>')
                             print ('<p> This is a script used to plot Pattern Field and Celestial Objects over Jicamarca Antenna</p>')
                             print ('<p> Required arguments:</p>')
                             print ('<p>    year - year of event</p>')
                             print ('<p>    month - month of event</p>')
                             print ('<p>    dom - day of month</p>')
                             print ('<p>    pattern - pattern is defined by "Select an Experiment" list box</p>')
                             print ('<p>    maxphi - maxphi is defined by "Max Angle" text box</p>')
                             print ('<p>    objects - objects is a list defined by checkbox in "Select Object"</p>')
                             print ('<p>    heights - heights is defined by "Heights" text box, for default heights=[100,500,1000]</p>')
                             print ('<p>    showType - showType is a hidden element for show plot of Pattern&Object or Antenna Cuts or Sky Noise</p>')
                             sys.exit(0)
                     if self.showType == 2:
                         if self.madForm.has_key('year') and \
                             self.madForm.has_key('month') and \
                             self.madForm.has_key('dom'):
                             self.year = int(self.madForm.getvalue('year'))
                             self.month = int(self.madForm.getvalue('month'))
                             self.dom = int(self.madForm.getvalue('dom'))
                         else:
                             if  self.scriptHeaders == 0:
                                 print ("Content-Type: text/html\n")
                             print ('<h3> This cgi plot script was called without the proper arguments.</h3>')
                             print ('<p> This is a script used to plot Sky Noise over Jicamarca Antenna</p>')
                             print ('<p> Required arguments:</p>')
                             print ('<p>    year - year of event</p>')
                             print ('<p>    month - month of event</p>')
                             print ('<p>    dom - day of month</p>')
                             sys.exit(0)
                 def initParameters1(self):
                     gui=1
                     if self.pattern==None:
                         if gui==1: self.filename = self.filename.split(',')
                     pattern = numpy.atleast_1d(self.pattern)
                     filename = numpy.atleast_1d(self.filename)
                     npatterns = numpy.max(numpy.array([pattern.size,filename.size]))
                     self.pattern = numpy.resize(pattern,npatterns)
                     self.filename = numpy.resize(filename,npatterns)
                     self.doy = datetime.datetime(self.year,self.month,self.dom).timetuple().tm_yday
                     if self.objects==None:
                         self.objects=numpy.zeros(5)
                     else:
                         tmp = numpy.atleast_1d(self.objects)
                         self.objects = numpy.zeros(5)
                         self.objects[0:tmp.size] = tmp
                     self.show_object = self.objects
                     self.maxha_min = 4*self.maxphi*numpy.sqrt(2)*1.25
                     if self.heights==None:
                         self.heights = numpy.array([100.,500.,1000.])
                     #ROJ geographic coordinates and time zone
                     self.glat = -11.95
                     self.glon = -76.8667
                     self.UT = 5 #timezone
                     self.glat = -11.951481
                     self.glon = -76.874383
                     self.junkjd = Time(self.year,self.month,self.dom).change2julday()
                     self.junklst = Julian(self.junkjd).change2lst(longitude=self.glon)
                     # Finding RA of observatory for a specific date
                     self.ra_obs = self.junklst*CoFactors.h2d
                 def initParameters(self):
                     # Defining plot filenames
                     self.path4plotname = os.path.join(self.__serverdocspath,self.__tmpDir)
                     self.plotname0 = 'over_jro_0_%i.png'% (time.time()) #plot pattern & objects
                     self.plotname1 = 'over_jro_1_%i.png'% (time.time()) #plot antenna cuts
                     self.plotname2 = 'over_jro_2_%i.png'% (time.time()) #plot sky noise
                     # Defining antenna axes respect to geographic coordinates (See Ochs report).
             #        alfa = 1.46*Misc_Routines.CoFactors.d2r
             #        theta = 51.01*Misc_Routines.CoFactors.d2r
                     alfa = 1.488312*CoFactors.d2r
                     th = 6.166710 + 45.0
                     theta = th*CoFactors.d2r
                     sina = numpy.sin(alfa)
                     cosa = numpy.cos(alfa)
                     MT1 = numpy.array([[1,0,0],[0,cosa,-sina],[0,sina,cosa]])
                     sinb = numpy.sin(theta)
                     cosb = numpy.cos(theta)
                     MT2 = numpy.array([[cosb,sinb,0],[-sinb,cosb,0],[0,0,1]])
                     self.MT3 = numpy.array(numpy.dot(MT2, MT1)).transpose()
                     self.xg = numpy.dot(self.MT3.transpose(),numpy.array([1,0,0]))
                     self.yg = numpy.dot(self.MT3.transpose(),numpy.array([0,1,0]))
                     self.zg = numpy.dot(self.MT3.transpose(),numpy.array([0,0,1]))
                 def plotPattern2(self, date, phases, gain_tx, gain_rx, ues, just_rx):
                     # Plotting Antenna patterns.
                     self.initParameters()
                     self.doy = datetime.datetime(date.year,date.month,date.day).timetuple().tm_yday
                     self.junkjd = Time(self.year,self.month,self.dom).change2julday()
                     self.junklst = Julian(self.junkjd).change2lst(longitude=self.glon)
                     self.ra_obs = self.junklst*CoFactors.h2d
                     date = Time(date.year,date.month,date.day).change2strdate(mode=2)
                     mesg = 'Over Jicamarca: ' + date[0]
                     ObjAnt = JroPattern(pattern=0,
                                         filename=None,
                                         path=None,
                                         nptsx=self.nptsx,
                                         nptsy=self.nptsy,
                                         #maxphi=self.maxphi,
                                         fftopt=self.fftopt,
                                         phases=numpy.array(phases),
                                         gain_tx=numpy.array(gain_tx),
                                         gain_rx=numpy.array(gain_rx),
                                         ues=numpy.array(ues),
                                         just_rx=just_rx
                                         )
                     dum = AntPatternPlot()
                     dum.contPattern(iplot=0,
                                     gpath=self.path4plotname,
                                     filename=self.plotname0,
                                     mesg=mesg,
                                     amp=ObjAnt.norpattern,
                                     x=ObjAnt.dcosx,
                                     y=ObjAnt.dcosy,
                                     getCut=ObjAnt.getcut,
                                     title=self.ptitle,
                                     save=False)
                     dum.plotRaDec(gpath=self.path4plotname,
                                   filename=self.plotname0,
                                   jd=self.junkjd,
                                   ra_obs=self.ra_obs,
                                   xg=self.xg,
                                   yg=self.yg,
                                   x=ObjAnt.dcosx,
                                   y=ObjAnt.dcosy,
                                   save=False)
                     ObjB = BField(self.year,self.doy,1,self.heights)
                     [dcos, alpha, nlon, nlat] = ObjB.getBField()
                     dum.plotBField('', '',dcos,alpha,nlon,nlat,
                                    self.dcosxrange,
                                    self.dcosyrange,
                                    ObjB.heights,
                                    ObjB.alpha_i,
                                    save=False)
                     return dum.fig
                 def plotPattern(self):
                     # Plotting Antenna patterns.
                     npatterns = numpy.size(self.pattern)
                     if npatterns==1:
                         if self.pattern[0] == None: npatterns = self.filename.__len__()
                     date = TimeTools.Time(self.year,self.month,self.dom).change2strdate(mode=2)
                     mesg = 'Over Jicamarca: ' + date[0]
                     title = ''
                     for ii in numpy.arange(npatterns):
                         ObjAnt = JroPattern(pattern=self.pattern[ii],
                                             filename=self.filename[ii],
                                             path=self.path,
                                             nptsx=self.nptsx,
                                             nptsy=self.nptsy,
                                             maxphi=self.maxphi,
                                             fftopt=self.fftopt)
                         title += ObjAnt.title
                         # Plotting Contour Map
                         self.path4plotname = '/home/jespinoza/workspace/radarsys/trunk/webapp/apps/abs/static/images'
                         dum = AntPatternPlot()
                         dum.contPattern(iplot=ii,
                                                                     gpath=self.path4plotname,
                                                                     filename=self.plotname0,
                                                                     mesg=mesg,
                                                                     amp=ObjAnt.norpattern,
                                                                     x=ObjAnt.dcosx,
                                                                     y=ObjAnt.dcosy,
                                                                     getCut=ObjAnt.getcut,
                                                                     title=title)
             #                                                         title=ObjAnt.title)
             #             self.ptitle = ObjAnt.title
                         if ii != (npatterns-1):
                             title += '+'
                         vect_ant = numpy.array([ObjAnt.meanpos[0],ObjAnt.meanpos[1],numpy.sqrt(1-numpy.sum(ObjAnt.meanpos**2.))])
                         vect_geo = numpy.dot(scipy.linalg.inv(self.MT3),vect_ant)
                         vect_polar = Misc_Routines.Vector(numpy.array(vect_geo),direction=1).Polar2Rect()
-                        [ra,dec,ha] = Astro_Coords.AltAz(vect_polar[1],vect_polar[0],self.junkjd).change2equatorial()
+                        [ra,dec,ha] = AltAz(vect_polar[1],vect_polar[0],self.junkjd).change2equatorial()
                         print('Main beam position (HA(min), DEC(degrees)): %f %f')%(ha*4.,dec)
                         self.main_dec = dec
                     self.ptitle = title
                     AntPatternPlot().plotRaDec(gpath=self.path4plotname,
                                                                 filename=self.plotname0,
                                                                 jd=self.junkjd,
                                                                 ra_obs=self.ra_obs,
                                                                 xg=self.xg,
                                                                 yg=self.yg,
                                                                 x=ObjAnt.dcosx,
                                                                 y=ObjAnt.dcosy)
                     self.dcosx = ObjAnt.dcosx
                     self.dcosy = ObjAnt.dcosy
                     self.dcosxrange = [numpy.min(self.dcosx),numpy.max(self.dcosx)]
                     self.dcosyrange = [numpy.min(self.dcosy),numpy.max(self.dcosy)]
                 def plotBfield(self):
                     if self.show_object[0]>0:
                         # Getting B field
                         ObjB = BField(self.year,self.doy,self.site,self.heights)
                         [dcos, alpha, nlon, nlat] = ObjB.getBField()
                         # Plotting B field.
             #            print "Drawing magnetic field over Observatory"
                         Obj = BFieldPlot()
                         Obj.plotBField(self.path4plotname,self.plotname0,dcos,alpha,nlon,nlat,self.dcosxrange,self.dcosyrange,ObjB.heights,ObjB.alpha_i)
                         if self.show_object[0]>1:
                             Bhei = 0
                             dcosx = Obj.alpha_location[:,0,Bhei]
                             dcosy = Obj.alpha_location[:,1,Bhei]
                             vect_ant = [dcosx,dcosy,numpy.sqrt(1.-(dcosx**2. + dcosy**2.))]
                             vect_ant = numpy.array(vect_ant)
                             vect_geo = numpy.dot(scipy.linalg.inv(self.MT3),vect_ant)
                             vect_geo = numpy.array(vect_geo).transpose()
                             vect_polar = Misc_Routines.Vector(vect_geo,direction=1).Polar2Rect()
-                            [ra,dec,ha] = Astro_Coords.AltAz(vect_polar[1,:],vect_polar[0,:],self.junkjd).change2equatorial()
+                            [ra,dec,ha] = AltAz(vect_polar[1,:],vect_polar[0,:],self.junkjd).change2equatorial()
                             val = numpy.where(ha>=180)
                             if val[0].size>0:ha[val] = ha[val] -360.
                             val = numpy.where(numpy.abs(ha)<=self.maxphi)
                             if val[0].size>2:
                                 self.dcosx_mag = dcosx[val]
                                 self.dcosy_mag = dcosy[val]
                                 self.ha_mag = ha[val]
                                 self.time_mag = 0
                 def plotCelestial(self):
                     ntod = 24.*16.
                     tod = numpy.arange(ntod)/ntod*24.
                     [month,dom] = Doy2Date(self.year,self.doy).change2date()
                     jd = Time(self.year,month,dom,tod+self.UT).change2julday()
                     if numpy.sum(self.show_object[1:]>0)!=0:
                         self.ObjC = CelestialObjectsPlot(jd,self.main_dec,tod,self.maxha_min,self.show_object)
                         self.ObjC.drawObject(self.glat,
                                         self.glon,
                                         self.xg,
                                         self.yg,
                                         self.dcosxrange,
                                         self.dcosyrange,
                                         self.path4plotname,
                                         self.plotname0)
                 def plotAntennaCuts(self):
             #        print "Drawing antenna cuts"
                     incha = 0.05 # min
                     nha = numpy.int32(2*self.maxha_min/incha) + 1.
                     newha = numpy.arange(nha)/nha*2.*self.maxha_min - self.maxha_min
                     nha_star = numpy.int32(200./incha)
                     star_ha = (numpy.arange(nha_star) - (nha_star/2))*nha_star
                     #Init ObjCut for PatternCutPlot()
                     view_objects = numpy.where(self.show_object>0)
                     subplots = len(view_objects[0])
                     ObjCut = PatternCutPlot(subplots)
                     for io in (numpy.arange(5)):
                         if self.show_object[io]==2:
                             if io==0:
                                 if self.dcosx_mag.size!=0:
                                     dcosx = self.dcosx_mag
                                     dcosy = self.dcosy_mag
                                     dcosz = 1 - numpy.sqrt(dcosx**2. + dcosy**2.)
                                     # Finding rotation of B respec to antenna coords.
                                     [mm,bb] = scipy.polyfit(dcosx,dcosy,1)
                                     alfa = 0.0
                                     theta = -1.*numpy.arctan(mm)
                                     sina = numpy.sin(alfa); cosa = numpy.cos(alfa)
                                     MT1 = [[1,0,0],[0,cosa,-sina],[0,sina,cosa]]
                                     MT1 = numpy.array(MT1)
                                     sinb = numpy.sin(theta); cosb = numpy.cos(theta)
                                     MT2 = [[cosb,sinb,0],[-sinb,cosb,0],[0,0,1]]
                                     MT2 = numpy.array(MT2)
                                     MT3_mag = numpy.dot(MT2, MT1)
                                     MT3_mag = numpy.array(MT3_mag).transpose()
                                     # Getting dcos respec to B coords
                                     vector = numpy.array([dcosx,dcosy,dcosz])
                                     nvector = numpy.dot(MT3_mag,vector)
                                     nvector = numpy.array(nvector).transpose()
             ##                        print 'Rotation (deg) %f'%(theta/Misc_Routines.CoFactors.d2r)
                                     yoffset = numpy.sum(nvector[:,1])/nvector[:,1].size
             #                        print 'Dcosyoffset %f'%(yoffset)
                                     ha = self.ha_mag*4.
                                     time = self.time_mag
                                     width_star = 0.1 # half width in minutes
                                     otitle = 'B Perp. cut'
             #                    else:
             #                        print "No B perp. over Observatory"
             #
             #
                             elif io==1:
                                 if self.ObjC.dcosx_sun.size!=0:
                                     dcosx = self.ObjC.dcosx_sun
                                     dcosy = self.ObjC.dcosy_sun
                                     ha = self.ObjC.ha_sun*4.0
                                     time = self.ObjC.time_sun
                                     width_star = 2. # half width in minutes
                                     otitle = 'Sun cut'
             #                    else:
             #                        print "Sun is not passing over Observatory"
                             elif io==2:
                                 if self.ObjC.dcosx_moon.size!=0:
                                     dcosx = self.ObjC.dcosx_moon
                                     dcosy = self.ObjC.dcosy_moon
                                     ha = self.ObjC.ha_moon*4
                                     time = self.ObjC.time_moon
                                     m_distance = 404114.6  # distance to the Earth in km
                                     m_diameter = 1734.4    # diameter in km.
                                     width_star = numpy.arctan(m_distance/m_diameter)
                                     width_star = width_star/2./CoFactors.d2r*4.
                                     otitle = 'Moon cut'
             #                    else:
             #                        print "Moon is not passing over Observatory"
                             elif io==3:
                                 if self.ObjC.dcosx_hydra.size!=0:
                                     dcosx = self.ObjC.dcosx_hydra
                                     dcosy = self.ObjC.dcosy_hydra
                                     ha = self.ObjC.ha_hydra*4.
                                     time = self.ObjC.time_hydra
                                     width_star = 0.25 # half width in minutes
                                     otitle = 'Hydra cut'
             #                    else:
             #                        print "Hydra is not passing over Observatory"
                             elif io==4:
                                 if self.ObjC.dcosx_galaxy.size!=0:
                                     dcosx = self.ObjC.dcosx_galaxy
                                     dcosy = self.ObjC.dcosy_galaxy
                                     ha = self.ObjC.ha_galaxy*4.
                                     time = self.ObjC.time_galaxy
                                     width_star = 25. # half width in minutes
                                     otitle = 'Galaxy cut'
             #                    else:
             #                        print "Galaxy center is not passing over Jicamarca"
             #
             #
                             hour = numpy.int32(time)
                             mins = numpy.int32((time - hour)*60.)
                             secs = numpy.int32(((time - hour)*60. - mins)*60.)
                             ObjT = Time(self.year,self.month,self.dom,hour,mins,secs)
                             subtitle = ObjT.change2strdate()
                             star_cut = numpy.exp(-(star_ha/width_star)**2./2.)
                             pol = scipy.polyfit(ha,dcosx,3.)
                             polx = numpy.poly1d(pol); newdcosx = polx(newha)
                             pol = scipy.polyfit(ha,dcosy,3.)
                             poly = numpy.poly1d(pol);newdcosy = poly(newha)
                             patterns = []
                             for icut in numpy.arange(self.pattern.size):
                                 # Getting Antenna cut.
                                 Obj = JroPattern(dcosx=newdcosx,
                                                     dcosy=newdcosy,
                                                     getcut=1,
                                                     pattern=self.pattern[icut],
                                                     path=self.path,
                                                     filename=self.filename[icut])
                                 Obj.getPattern()
                                 patterns.append(Obj.pattern)
                             ObjCut.drawCut(io,
                                            patterns,
                                            self.pattern.size,
                                            newha,
                                            otitle,
                                            subtitle,
                                            self.ptitle)
                     ObjCut.saveFig(self.path4plotname,self.plotname1)
                 def plotSkyNoise(self):
             #       print 'Creating SkyNoise map over Jicamarca'
                     dom = self.dom
                     month = self.month
                     year = self.year
                     julian = Time(year,month,dom).change2julday()
-                    [powr,time, lst] = Astro_Coords.CelestialBodies().skyNoise(julian)
+                    [powr,time, lst] = CelestialBodies().skyNoise(julian)
                     SkyNoisePlot([year,month,dom],powr,time,lst).getPlot(self.path4plotname,self.plotname2)
                 def outputHead(self,title):
                     print ("Content-Type: text/html")
                     print (self).scriptHeaders = 1
                     print ('<html>')
                     print ('<head>')
                     print ('\t<title>' + title + '</title>')
                     print ('<style type="text/css">')
                     print ('body')
                     print ('{')
                     print ('background-color:#ffffff;')
                     print ('}')
                     print ('h1')
                     print ('{')
                     print ('color:black;')
                     print ('font-size:18px;')
                     print ('text-align:center;')
                     print ('}')
                     print ('p')
                     print ('{')
                     print ('font-family:"Arial";')
                     print ('font-size:16px;')
                     print ('color:black;')
                     print ('}')
                     print ('</style>')
             #        self.printJavaScript()
                     print ('</head>')
                 def printJavaScript(self):
                     print
                 def printBody(self):
                     print ('<body>')
             #        print '<h1>Test Input Parms</h1>'
             #        for key in self.madForm.keys():
             #                #print '<p> name=' + str(key)
             #                if type(self.madForm.getvalue(key)) == types.ListType:
             #                    for value in self.madForm.getvalue(key):
             #                        print '<p> name=' + str(key) + \
             #                              ' value=' + value + ''
             #                else:
             #                    print '<p> name=' + str(key) + \
             #                              ' value=' + str(cgi.escape(self.madForm.getvalue(key))) + ''
                     print ('<form name="form1" method="post" target="showFrame">')
                     print ('    <div align="center">')
                     print ('        <table width=98% border="1" cellpadding="1">')
                     print ('            <tr>')
                     print ('                <td colspan="2" align="center">')
                     if self.showType == 0:
                         print ('                    <IMG SRC="%s" BORDER="0" >')%(os.path.join(os.sep + self.__tmpDir,self.plotname0))
                     if self.showType == 1:
                         print ('                    <IMG SRC="%s" BORDER="0" >')%(os.path.join(os.sep + self.__tmpDir,self.plotname1))
                     if self.showType == 2:
                         print ('                    <IMG SRC="%s" BORDER="0" >')%(os.path.join(os.sep + self.__tmpDir,self.plotname2))
                     print ('                </td>')
                     print ('            </tr>')
                     print ('        </table>')
                     print ('    </div>')
                     print ('</form>')
                     print ('</body>')
                     print ('</html>')
                 #def execute(self, serverdocspath, tmpdir, currentdate, finalpath, showType=0, maxphi=5.0, objects="[1,1]", heights="[150,500,1000]"):
                 def setInputParameters(self, serverpath, currentdate, finalpath, showType=0, maxphi=5.0, objects="[1,1]", heights="[150,500,1000]"):
                     self.objects=[]
                     self.heights=[]
                     #self.__serverdocspath = serverdocspath
                     self.__serverdocspath = os.path.split(serverpath)[0]
                     #self.__tmpDir = tmpdir
                     self.__tmpDir = os.path.split(serverpath)[1]
                     self.showType = int(showType)
                     self.year = int(currentdate.strftime("%Y")) # Get year of currentdate
                     self.month = int(currentdate.strftime("%m")) # Get month of currentdate
                     self.dom = int(currentdate.strftime("%d")) # Get day of currentdate
                     self.filename = os.path.split(finalpath)[1]
                     self.path = os.path.split(finalpath)[0]
                     self.maxphi = float(maxphi)
                     tmp_objects = (objects.replace("[","")).replace("]","")
                     for s in tmp_objects.split(','):
                         self.objects.append(int(s))
                     tmp_heights = (heights.replace("[","")).replace("]","")
                     for s in tmp_heights.split(','):
                         self.heights.append(float(s))
                     self.heights = numpy.array(self.heights)
                 def setupParameters(self):
                     self.initParameters()
                 def initParametersCGI(self):
                     self.setScriptState()
                     self.initParameters()
                 def execute(self):
                     if self.showType == 0 or self.showType == 1:
                         self.initParameters1()
                         self.plotPattern()
                         if numpy.sum(self.show_object>0) != 0:
                             self.plotBfield()
                             self.plotCelestial()
                         if numpy.sum(self.show_object>1) != 0:
                             self.plotAntennaCuts()
                     if self.showType == 2:
                         self.plotSkyNoise()
                 def getPlot(self):
                     return os.path.join(self.__serverdocspath,self.__tmpDir,self.plotname0)
             if __name__ == '__main__':
                 # Script overJroShow.py
                 # This script only calls the init function of the class overJroShow()
                 # All work is done by the init function
                 phases = numpy.array([[2.0,0.0,1.5,1.5,1.0,1.0,1.0,0.5],
                         [2.0,2.5,2.5,3.5,0.5,1.0,1.0,1.0],
                         [2.5,2.5,1.0,1.0,0.5,0.5,0.5,0.5],
                         [1.0,1.0,1.0,1.0,0.5,0.5,0.5,1.0],
                         [0.5,0.5,0.5,0.5,0.5,0.0,0.0,0.0],
                         [0.5,0.5,1.0,0.5,0.0,0.0,0.0,0.0],
                         [0.5,0.5,0.5,1.0,0.0,0.0,0.0,0.0],
                         [0.5,0.5,0.5,0.5,0.0,0.0,0.0,0.0]])
                 gain_tx = numpy.array([[0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,1,1,1,1],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0]])
                 gain_rx = numpy.array([[0,0,0,0,0,0,0,0],
                         [0,0,1,0,0,0,0,0],
                         [0,0,1,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0],
                         [0,0,0,0,0,0,0,0]])
                 jro = overJroShow()
                 fig = jro.plotPattern2(datetime.datetime.today(),
                                        phases=phases,
                                        gain_tx=gain_tx,
                                        gain_rx=gain_rx,
                                        ues=numpy.array([0.0,0.0,0.0,0.0]),
                                        just_rx=0)
                 fig.savefig('./pat.png')

apps/rc/models.py +11 -6

             import ast
             import json
             import requests
             import numpy as np
+            import time
             from base64 import b64encode
             from struct import pack
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             from apps.main.utils import Params
             from devices.rc import api
             from apps.rc.utils import RCFile
             LINE_TYPES = (
                 ('none', 'Not used'),
                 ('tr', 'Transmission/reception selector signal'),
                 ('tx', 'A modulating signal (Transmission pulse)'),
                 ('codes', 'BPSK modulating signal'),
                 ('windows', 'Sample window signal'),
                 ('sync', 'Synchronizing signal'),
                 ('flip', 'IPP related periodic signal'),
                 ('prog_pulses', 'Programmable pulse'),
                 ('mix', 'Mixed line'),
                 )
             SAMPLING_REFS = (
                 ('none', 'No Reference'),
                 ('begin_baud', 'Begin of the first baud'),
                 ('first_baud', 'Middle of the first baud'),
                 ('sub_baud', 'Middle of the sub-baud')
                              )
             DAT_CMDS = {
                     # Pulse Design commands
                     'DISABLE' : 0, # Disables pulse generation
                     'ENABLE' : 24, # Enables pulse generation
                     'DELAY_START' : 40, # Write delay status to memory
                     'FLIP_START' : 48, # Write flip status to memory
                     'SAMPLING_PERIOD' : 64, # Establish Sampling Period
                     'TX_ONE' : 72, # Output '0' in line TX
                     'TX_ZERO' : 88, # Output '0' in line TX
                     'SW_ONE' : 104, # Output '0' in line SW
                     'SW_ZERO' : 112, # Output '1' in line SW
                     'RESTART': 120, # Restarts CR8 Firmware
                     'CONTINUE' : 253, # Function Unknown
                     # Commands available to new controllers
                     # In Pulse Design Executable, the clock divisor code is written as 12 at the start, but it should be written as code 22(below) just before the final enable.
                     'CLOCK_DIVISOR_INIT' : 12, # Specifies Clock Divisor. Legacy command, ignored in the actual .dat conversion
                     'CLOCK_DIVISOR_LAST' : 22, # Specifies Clock Divisor (default 60 if not included) syntax: 255,22 254,N-1.
                     'CLOCK_DIVIDER' : 8,
                         }
             MAX_BITS = 8
             # Rotate left: 0b1001 --> 0b0011
             rol = lambda val, r_bits: \
                 (val << r_bits%MAX_BITS) & (2**MAX_BITS-1) | \
                 ((val & (2**MAX_BITS-1)) >> (MAX_BITS-(r_bits%MAX_BITS)))
             # Rotate right: 0b1001 --> 0b1100
             ror = lambda val, r_bits: \
                 ((val & (2**MAX_BITS-1)) >> r_bits%MAX_BITS) | \
                 (val << (MAX_BITS-(r_bits%MAX_BITS)) & (2**MAX_BITS-1))
             class RCConfiguration(Configuration):
                 ipp = models.FloatField(verbose_name='IPP [Km]', validators=[MinValueValidator(1)], default=300)
                 ntx = models.PositiveIntegerField(verbose_name='Number of TX', validators=[MinValueValidator(1)], default=1)
                 clock_in = models.FloatField(verbose_name='Clock in [MHz]', validators=[MinValueValidator(1), MaxValueValidator(80)], default=1)
                 clock_divider = models.PositiveIntegerField(verbose_name='Clock divider', validators=[MinValueValidator(1), MaxValueValidator(256)], default=1)
                 clock = models.FloatField(verbose_name='Clock Master [MHz]', blank=True, default=1)
                 time_before = models.PositiveIntegerField(verbose_name='Time before [&mu;S]', default=12)
                 time_after = models.PositiveIntegerField(verbose_name='Time after [&mu;S]', default=1)
                 sync = models.PositiveIntegerField(verbose_name='Synchro delay', default=0)
                 sampling_reference = models.CharField(verbose_name='Sampling Reference', choices=SAMPLING_REFS, default='none', max_length=40)
                 control_tx = models.BooleanField(verbose_name='Control Switch TX', default=False)
                 control_sw = models.BooleanField(verbose_name='Control Switch SW', default=False)
                 total_units = models.PositiveIntegerField(default=0)
                 mix = models.BooleanField(default=False)
                 class Meta:
                     db_table = 'rc_configurations'
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_rc_pulses', args=[str(self.id)])
                 @property
                 def ipp_unit(self):
                     return '{} ({})'.format(self.ipp, int(self.ipp*self.km2unit))
                 @property
                 def us2unit(self):
                     return self.clock_in/self.clock_divider
                 @property
                 def km2unit(self):
                     return 20./3*(self.clock_in/self.clock_divider)
                 def clone(self, **kwargs):
                     lines = self.get_lines()
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for line in lines:
                         line.clone(rc_configuration=self)
                     new_lines = self.get_lines()
                     for line in new_lines:
                         line_params = json.loads(line.params)
                         if 'TX_ref' in line_params and (line_params['TX_ref'] != '0'):
                             ref_line = RCLine.objects.get(pk=line_params['TX_ref'])
                             line_params['TX_ref'] = ['{}'.format(l.pk) for l in new_lines if l.get_name()==ref_line.get_name()][0]
                             line.params = json.dumps(line_params)
                             line.save()
                     return self
                 def get_lines(self, **kwargs):
                     '''
                     Retrieve configuration lines
                     '''
                     return RCLine.objects.filter(rc_configuration=self.pk, **kwargs)
                 def clean_lines(self):
                     '''
                     '''
                     empty_line = RCLineType.objects.get(name='none')
                     for line in self.get_lines():
                         line.line_type = empty_line
                         line.params = '{}'
                         line.save()
                 def dict_to_parms(self, params, id=None):
                     '''
                     '''
                     if id:
                         data = Params(params).get_conf(id_conf=id)
                     else:
                         data = Params(params).get_conf(dtype='rc')
                     #print(data)
                     # self.name = data['name']
                     self.ipp = data['ipp']
                     self.ntx = data['ntx']
                     self.clock_in = data['clock_in']
                     self.clock_divider = data['clock_divider']
                     self.clock = data['clock']
                     self.time_before = data['time_before']
                     self.time_after = data['time_after']
                     self.sync = data['sync']
                     self.sampling_reference = data['sampling_reference']
                     self.total_units = self.ipp*self.ntx*self.km2unit
                     self.save()
                     self.clean_lines()
                     #print(params)
                     positions = {'tx':0, 'tr':0}
                     for i, id in enumerate(data['lines']):
                         line_data = params['lines']['byId'][id]
                         line_type = RCLineType.objects.get(name=line_data['line_type'])
                         if line_type.name == 'codes':
                             code = RCLineCode.objects.get(name=line_data['params']['code'])
                             line_data['params']['code'] = code.pk
                         if line_type.name == 'tx':
                             position = positions['tx']
                             positions['tx'] += 1
                         elif line_type.name == 'tr':
                             position = positions['tr']
                             positions['tr'] += 1
                         else:
                             position = 0
                         line, dum = RCLine.objects.update_or_create(
                             rc_configuration=self,
                             channel=i,
                             position=position,
                             defaults={
                                 'line_type': line_type,
                                 'params': json.dumps(line_data['params'])
                                 }
                             )
                     for i, line in enumerate(self.get_lines()):
                         line_params = json.loads(line.params)
                         if 'TX_ref' in line_params:
                             if line_params['TX_ref'] in (0, '0'):
                                 line_params['TX_ref'] = '0'
                             else:
                                 ref_id = '{}'.format(line_params['TX_ref'])
                                 ref_line = params['lines']['byId'][ref_id]
                                 line_params['TX_ref'] = RCLine.objects.get(
                                     rc_configuration=self,
                                     params=json.dumps(ref_line['params'])
                                     ).pk
                             line.params = json.dumps(line_params)
                             print(line.params)
                             line.save()
                     print("Fin de dict to param")
                 def get_delays(self):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     points = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in points for x in tup])
                     points = list(points)
                     points.sort()
                     if points[0]!=0:
                         points.insert(0, 0)
                     return [points[i+1]-points[i] for i in range(len(points)-1)]
                 def get_pulses(self, binary=True):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     tuples = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in tuples for x in tup])
                     points = list(points)
                     points.sort()
                     states = []
                     last = [0 for x in pulses]
                     for x in points:
                         dum = []
                         for i, tups in enumerate(pulses):
                             ups = [tup[0] for tup in tups if tup!=(0,0)]
                             dws = [tup[1] for tup in tups if tup!=(0,0)]
                             if x in ups:
                                 dum.append(1)
                             elif x in dws:
                                 dum.append(0)
                             else:
                                 dum.append(last[i])
                         states.append(dum)
                         last = dum
                     if binary:
                         ret = []
                         for flips in states:
                             flips.reverse()
                             ret.append(int(''.join([str(x) for x in flips]), 2))
                         states = ret
                     return states[:-1]
                 def add_cmd(self, cmd):
                     if cmd in DAT_CMDS:
                         return (255, DAT_CMDS[cmd])
                 def add_data(self, value):
                     return (254, value-1)
                 def parms_to_binary(self, dat=True):
                     '''
                     Create "dat" stream to be send to CR
                     '''
                     data = bytearray()
                     # create header
                     data.extend(self.add_cmd('DISABLE'))
                     data.extend(self.add_cmd('CONTINUE'))
                     data.extend(self.add_cmd('RESTART'))
                     if self.control_sw:
                         data.extend(self.add_cmd('SW_ONE'))
                     else:
                         data.extend(self.add_cmd('SW_ZERO'))
                     if self.control_tx:
                         data.extend(self.add_cmd('TX_ONE'))
                     else:
                         data.extend(self.add_cmd('TX_ZERO'))
                     # write divider
                     data.extend(self.add_cmd('CLOCK_DIVIDER'))
                     data.extend(self.add_data(self.clock_divider))
                     # write delays
                     data.extend(self.add_cmd('DELAY_START'))
                     # first delay is always zero
                     data.extend(self.add_data(1))
                     delays = self.get_delays()
                     for delay in delays:
                         while delay>252:
                             data.extend(self.add_data(253))
                             delay -= 253
                         data.extend(self.add_data(int(delay)))
                     # write flips
                     data.extend(self.add_cmd('FLIP_START'))
                     states = self.get_pulses(binary=True)
                     last = 0
                     for flip, delay in zip(states, delays):
                         data.extend(self.add_data((flip^last)+1))
                         last = flip
                         while delay>252:
                             data.extend(self.add_data(1))
                             delay -= 253
                     # write sampling period
                     data.extend(self.add_cmd('SAMPLING_PERIOD'))
                     wins = self.get_lines(line_type__name='windows')
                     if wins:
                         win_params = json.loads(wins[0].params)['params']
                         if win_params:
                             dh = int(win_params[0]['resolution']*self.km2unit)
                         else:
                             dh = 1
                     else:
                         dh = 1
                     data.extend(self.add_data(dh))
                     # write enable
                     data.extend(self.add_cmd('ENABLE'))
                     if not dat:
                         return data
                     return '\n'.join(['{}'.format(x) for x in data])
                 def update_pulses(self):
                     contador = 0
                     for line in self.get_lines():
                         contador=contador+1
                         print(contador)
                         line.update_pulses()
                 def plot_pulses2(self, km=False):
                     import matplotlib
                     matplotlib.use('Agg')
                     import matplotlib.pyplot as plt
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.mpl import to_bokeh
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     lines = self.get_lines()
                     N = len(lines)
                     npoints = self.total_units/self.km2unit if km else self.total_units
                     fig = plt.figure(figsize=(12, 2+N*0.5))
                     ax = fig.add_subplot(111)
                     labels = ['IPP']
                     for i, line in enumerate(lines):
                         labels.append(line.get_name(channel=True))
                         l = ax.plot((0, npoints),(N-i-1, N-i-1))
                         points = [(tup[0], tup[1]-tup[0]) for tup in line.pulses_as_points(km=km) if tup!=(0,0)]
                         ax.broken_barh(points, (N-i-1, 0.5),
                                        edgecolor=l[0].get_color(), facecolor='none')
                     n = 0
                     f = ((self.ntx+50)/100)*5 if ((self.ntx+50)/100)*10>0 else 2
                     for x in np.arange(0, npoints, self.ipp if km else self.ipp*self.km2unit):
                         if n%f==0:
                             ax.text(x, N, '%s' % n, size=10)
                         n += 1
                     labels.reverse()
                     ax.set_yticks(range(len(labels)))
                     ax.set_yticklabels(labels)
                     ax.set_xlabel = 'Units'
                     plot = to_bokeh(fig, use_pandas=False)
                     plot.tools = [PanTool(dimensions="width"), WheelZoomTool(dimensions="width"), ResetTool(), SaveTool()]
                     plot.toolbar_location="above"
                     return components(plot, CDN)
                 def plot_pulses(self, km=False):
                     from bokeh.plotting import figure
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.models import FixedTicker, PrintfTickFormatter
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     from bokeh.models.sources import ColumnDataSource
                     lines = self.get_lines().reverse()
                     N = len(lines)
                     npoints = self.total_units/self.km2unit if km else self.total_units
                     ipp = self.ipp if km else self.ipp*self.km2unit
                     hover = HoverTool(tooltips=[("Line", "@name"),
                                                 ("IPP", "@ipp"),
                                                 ("X", "@left")])
                     tools = [PanTool(dimensions="width"),
                              WheelZoomTool(dimensions="width"),
                              hover, SaveTool()]
                     plot = figure(width=1000,
                                   height=40+N*50,
                                   y_range = (0, N),
                                   tools=tools,
                                   toolbar_location='above',
                                   toolbar_sticky=False,)
                     plot.xaxis.axis_label = 'Km' if km else 'Units'
                     plot.xaxis[0].formatter = PrintfTickFormatter(format='%d')
                     plot.yaxis.axis_label = 'Pulses'
                     plot.yaxis[0].ticker=FixedTicker(ticks=list(range(N)))
                     plot.yaxis[0].formatter = PrintfTickFormatter(format='Line %d')
                     for i, line in enumerate(lines):
                         points = [tup for tup in line.pulses_as_points(km=km) if tup!=(0,0)]
                         source = ColumnDataSource(data = dict(
                                                               bottom = [i for tup in points],
                                                               top = [i+0.5 for tup in points],
                                                               left = [tup[0] for tup in points],
                                                               right = [tup[1] for tup in points],
                                                               ipp = [int(tup[0]/ipp) for tup in points],
                                                               name = [line.get_name() for tup in points]
                                                               ))
                         plot.quad(
                                  bottom = 'bottom',
                                  top = 'top',
                                  left = 'left',
                                  right = 'right',
                                  source = source,
                                  fill_alpha = 0,
                                  #line_color = 'blue',
                                  )
                         plot.line([0, npoints], [i, i])#, color='blue')
                     return components(plot, CDN)
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         self.device.status = 0
                         payload = self.request('status')
                         if payload['status']=='enable':
                             self.device.status = 3
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'RC status: {}'.format(payload['status'])
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         self.device.save()
                         self.message = 'RC status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'RC restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'RC restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'RC reset: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
                         payload = self.request('stop', 'post')
                         self.message = 'RC stop: {}'.format(payload['stop'])
                         if payload['stop']=='ok':
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC stop: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         payload = self.request('start', 'post')
                         self.message = 'RC start: {}'.format(payload['start'])
                         if payload['start']=='ok':
                             self.device.status = 3
                             self.device.save()
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC start: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def write_device(self, raw=False):
                     print("write device")
                     if not raw:
+                        pass
+                        '''
                         clock = RCClock.objects.get(rc_configuration=self)
                         if clock.mode:
                             data = {'default': clock.frequency}
                         else:
                             data = {'manual': [clock.multiplier, clock.divisor, clock.reference]}
                         payload = self.request('setfreq', 'post', data=json.dumps(data))
                         if payload['setfreq'] != 'ok':
                             self.message = 'RC write: {}'.format(payload['setfreq'])
                         else:
                             self.message = payload['setfreq']
                             if payload['setfreq'] == 'fail':
                                 self.message = 'RC write: error programming CGS chip'
+                        '''
                     values = []
+                    print('ok')
                     for pulse, delay in zip(self.get_pulses(), self.get_delays()):
                         while delay > 65536:
                             values.append((pulse, 65535))
                             delay -= 65536
                         values.append((pulse, delay-1))
                     data = bytearray()
                     #reset
                     data.extend((128, 0))
                     #disable
                     data.extend((129, 0))
                     #SW switch
                     if self.control_sw:
                         data.extend((130, 2))
                     else:
                         data.extend((130, 0))
                     #divider
                     data.extend((131, self.clock_divider-1))
                     #enable writing
                     data.extend((139, 62))
                     last = 0
                     for tup in values:
                         vals = pack('<HH', last^tup[0], tup[1])
                         last = tup[0]
                         data.extend((133, vals[1], 132, vals[0], 133, vals[3], 132, vals[2]))
                     #enable
                     data.extend((129, 1))
                     if raw:
                         return b64encode(data)
                     #try:
                     payload = self.request('stop', 'post')
                     payload = self.request('reset', 'post')
                     #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
                     #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
                     n = len(data)
                     x = 0
-                    #while x < n:
+                    while x < n:
-                    payload = self.request('write', 'post', data=b64encode(data))
+                        payload = self.request('write', 'post', data=b64encode(data[x:x+1024]))
-                    #    x += 1024
+                        x += 1024
+                        time.sleep(1)
+                        print('writing... ', x)
                     if payload['write']=='ok':
                         self.device.status = 3
                         self.device.save()
                         self.message = 'RC configured and started'
                     else:
                         self.device.status = 1
                         self.device.save()
                         self.message = 'RC write: {}'.format(payload['write'])
                         return False
                         #payload = self.request('start', 'post')
                     #except Exception as e:
                     #    if 'No route to host' not in str(e):
                     #        self.device.status = 4
                     #    else:
                     #        self.device.status = 0
                     #    self.message = 'RC write: {}'.format(str(e))
                     #    self.device.save()
                     #    return False
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_rc_conf', args=[str(self.id)])
             class RCLineCode(models.Model):
                 name = models.CharField(max_length=40)
                 bits_per_code = models.PositiveIntegerField(default=0)
                 number_of_codes = models.PositiveIntegerField(default=0)
                 codes = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'rc_line_codes'
                     ordering = ('name',)
                 def __str__(self):
                     return u'%s' % self.name
             class RCLineType(models.Model):
                 name = models.CharField(choices=LINE_TYPES, max_length=40)
                 description = models.TextField(blank=True, null=True)
                 params = models.TextField(default='[]')
                 class Meta:
                     db_table = 'rc_line_types'
                 def __str__(self):
                     return u'%s - %s' % (self.name.upper(), self.get_name_display())
             class RCLine(models.Model):
                 rc_configuration = models.ForeignKey('RCConfiguration', on_delete=models.CASCADE)
                 line_type = models.ForeignKey('RCLineType',on_delete=models.CASCADE)
                 channel = models.PositiveIntegerField(default=0)
                 position = models.PositiveIntegerField(default=0)
                 params = models.TextField(default='{}')
                 pulses = models.TextField(default='')
                 class Meta:
                     db_table = 'rc_lines'
                     ordering = ['channel']
                 def __str__(self):
                     if self.rc_configuration:
                         return u'{}|{} - {}'.format(self.pk, self.get_name(), self.rc_configuration.name)
                 def jsonify(self):
                     data = {}
                     data['params'] = json.loads(self.params)
                     data['id'] = '{}'.format(self.pk)
                     data['line_type'] = self.line_type.name
                     data['name'] = self.get_name()
                     if data['line_type']=='codes':
                         data['params']['code'] = RCLineCode.objects.get(pk=data['params']['code']).name
                     return data
                 def clone(self, **kwargs):
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def get_name(self, channel=False):
                     chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                     s = ''
                     if self.line_type.name in ('tx',):
                         s = chars[self.position]
                     elif self.line_type.name in ('codes', 'windows', 'tr'):
                         if 'TX_ref' in json.loads(self.params):
                             pk = json.loads(self.params)['TX_ref']
                             if pk in (0, '0'):
                                 s = ','.join(chars[l.position] for l in self.rc_configuration.get_lines(line_type__name='tx'))
                             else:
                                 ref = RCLine.objects.get(pk=pk)
                                 s = chars[ref.position]
                             s = '({})'.format(s)
                     s = '{}{}'.format(self.line_type.name.upper(), s)
                     if channel:
                         return '{} {}'.format(s, self.channel)
                     else:
                         return s
                 def get_lines(self, **kwargs):
                     return RCLine.objects.filter(rc_configuration=self.rc_configuration, **kwargs)
                 def pulses_as_array(self):
                     y = np.zeros(self.rc_configuration.total_units)
                     for tup in ast.literal_eval(self.pulses):
                         y[tup[0]:tup[1]] = 1
                     return y.astype(np.int8)
                 def pulses_as_points(self, km=False):
                     if km:
                         unit2km = 1/self.rc_configuration.km2unit
                         return [(tup[0]*unit2km, tup[1]*unit2km) for tup in ast.literal_eval(self.pulses)]
                     else:
                         return ast.literal_eval(self.pulses)
                 def get_win_ref(self, params, tx_id, km2unit):
                     ref = self.rc_configuration.sampling_reference
                     codes = [line for line in self.get_lines(line_type__name='codes') if int(json.loads(line.params)['TX_ref'])==int(tx_id)]
                     if codes:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit/len(json.loads(codes[0].params)['codes'][0])
                     else:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit
                     if ref=='first_baud':
                         return int(1 + round((tx_width + 1)/2 + params['first_height']*km2unit - params['resolution']*km2unit))
                     elif ref=='sub_baud':
                         return np.ceil(1 + params['first_height']*km2unit - params['resolution']*km2unit/2)
                     else:
                         return 0
                 def update_pulses(self):
                     '''
                     Update pulses field
                     '''
                     km2unit = self.rc_configuration.km2unit
                     us2unit = self.rc_configuration.us2unit
                     ipp = self.rc_configuration.ipp
                     ntx = int(self.rc_configuration.ntx)
                     ipp_u = int(ipp*km2unit)
                     total = ipp_u*ntx if self.rc_configuration.total_units==0 else self.rc_configuration.total_units
                     y = []
                     if self.line_type.name=='tr':
                         tr_params = json.loads(self.params)
                         #print(tr_params)
                         #print(tr_params['TX_ref'])
                         if tr_params['TX_ref'] in ('0', 0):
                             txs = self.get_lines(line_type__name='tx')
                         else:
                             txs = RCLine.objects.filter(pk=tr_params['TX_ref'])
                         for tx in txs:
                             params = json.loads(tx.params)
                             if float(params['pulse_width'])==0:
                                 continue
                             delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                             width = float(params['pulse_width'])*km2unit+int(self.rc_configuration.time_before*us2unit)
                             before = 0
                             after = int(self.rc_configuration.time_after*us2unit)
                             y_tx = self.points(ntx, ipp_u, width,
                                                delay=delays,
                                                before=before,
                                                after=after,
                                                sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]!='0':
                                 y_tx = self.mask_ranges(y_tx, ranges)
                             tr_ranges = tr_params['range'].split(',')
                             if len(tr_ranges)>0 and tr_ranges[0]!='0':
                                 y_tx = self.mask_ranges(y_tx, tr_ranges)
                             y.extend(y_tx)
                         self.pulses = str(y)
                         y = self.array_to_points(self.pulses_as_array())
                     elif self.line_type.name=='tx':
                         params = json.loads(self.params)
                         delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                         width = float(params['pulse_width'])*km2unit
                         if width>0:
                             before = int(self.rc_configuration.time_before*us2unit)
                             after = 0
                             y = self.points(ntx, ipp_u, width,
                                             delay=delays,
                                             before=before,
                                             after=after,
                                             sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]!='0':
                                 y = self.mask_ranges(y, ranges)
                     elif self.line_type.name=='flip':
                         n = float(json.loads(self.params)['number_of_flips'])
                         width = n*ipp*km2unit
                         y = self.points(int((ntx+1)/(2*n)), ipp_u*n*2, width)
                     elif self.line_type.name=='codes':
                         params = json.loads(self.params)
                         tx = RCLine.objects.get(pk=params['TX_ref'])
                         tx_params = json.loads(tx.params)
                         delays = [float(d)*km2unit for d in tx_params['delays'].split(',') if d]
                         f = int(float(tx_params['pulse_width'])*km2unit/len(params['codes'][0]))
                         codes = [(np.fromstring(''.join([s*f for s in code]), dtype=np.uint8)-48).astype(np.int8) for code in params['codes']]
                         codes = [self.array_to_points(code) for code in codes]
                         n = len(codes)
                         ranges = tx_params['range'].split(',')
                         if len(ranges)>0 and ranges[0]!='0':
                             dum = self.mask_ranges(tx.pulses_as_points(), ranges)
                         else:
                             dum = tx.pulses_as_points()
                         for i, tup in enumerate(dum):
                             if tup==(0,0): continue
                             code = codes[i%n]
                             y.extend([(c[0]+tup[0], c[1]+tup[0]) for c in code])
                     elif self.line_type.name=='sync':
                         params = json.loads(self.params)
                         n = ipp_u*ntx
                         if params['invert'] in ('1', 1):
                             y = [(n-1, n)]
                         else:
                             y = [(0, 1)]
                     elif self.line_type.name=='prog_pulses':
                         params = json.loads(self.params)
                         if int(params['periodic'])==0:
                             nntx = 1
                             nipp = ipp_u*ntx
                         else:
                             nntx = ntx
                             nipp = ipp_u
                         if 'params' in params and len(params['params'])>0:
                             for p in params['params']:
                                 y_pp = self.points(nntx, nipp,
                                                    p['end']-p['begin'],
                                                    before=p['begin'])
                                 y.extend(y_pp)
                     elif self.line_type.name=='windows':
                         params = json.loads(self.params)
                         if 'params' in params and len(params['params'])>0:
                             tx = RCLine.objects.get(pk=params['TX_ref'])
                             tx_params = json.loads(tx.params)
                             ranges = tx_params['range'].split(',')
                             for p in params['params']:
                                 y_win = self.points(ntx, ipp_u,
                                                     p['resolution']*p['number_of_samples']*km2unit,
                                                     before=int(self.rc_configuration.time_before*us2unit)+p['first_height']*km2unit,
                                                     sync=self.rc_configuration.sync+self.get_win_ref(p, params['TX_ref'], km2unit))
                                 if len(ranges)>0 and ranges[0]!='0':
                                     y_win = self.mask_ranges(y_win, ranges)
                                 y.extend(y_win)
                     elif self.line_type.name=='mix':
                         values = self.rc_configuration.parameters.split('-')
                         confs = [RCConfiguration.objects.get(pk=value.split('|')[0]) for value in values]
                         modes = [value.split('|')[1] for value in values]
                         ops = [value.split('|')[2] for value in values]
                         delays = [value.split('|')[3] for value in values]
                         masks = [value.split('|')[4] for value in values]
                         print("masks")
                         print(masks)
                         print('{:8b}'.format(int(masks[0])))
                         mask = list('{:8b}'.format(int(masks[0])))
                         print("mask")
                         print(mask)
                         mask.reverse()
                         print("mask reverse")
                         print(mask)
                         if mask[self.channel] in ('0', '', ' '):
                             y = np.zeros(confs[0].total_units, dtype=np.int8)
                         else:
                             y = confs[0].get_lines(channel=self.channel)[0].pulses_as_array()
                         for i in range(1, len(values)):
                             mask = list('{:8b}'.format(int(masks[i])))
                             mask.reverse()
                             if mask[self.channel] in ('0', '', ' '):
                                 continue
                             Y = confs[i].get_lines(channel=self.channel)[0].pulses_as_array()
                             delay = float(delays[i])*km2unit
                             if modes[i]=='P':
                                 if delay>0:
                                     if delay<self.rc_configuration.ipp*km2unit and len(Y)==len(y):
                                         y_temp = np.empty_like(Y)
                                         y_temp[:delay] = 0
                                         y_temp[delay:] = Y[:-delay]
                                     elif delay+len(Y)>len(y):
                                         y_new = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_new[:len(y)] = y
                                         y = y_new
                                         y_temp = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)==len(y):
                                         y_temp = np.zeros(delay+len(Y))
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)<len(y):
                                         y_temp = np.zeros(len(y), dtype=np.int8)
                                         y_temp[delay:delay+len(Y)] = Y
                                 else:
                                     y_temp = Y.copy()
                                 if ops[i]=='OR':
                                     y = y | y_temp
                                 elif ops[i]=='XOR':
                                     y = y ^ y_temp
                                 elif ops[i]=='AND':
                                     y = y & y_temp
                                 elif ops[i]=='NAND':
                                     y = y & ~y_temp
                             else:
                                 y = np.concatenate([y, Y])
                         total = len(y)
                         y = self.array_to_points(y)
                     else:
                         y = []
                     if self.rc_configuration.total_units != total:
                         self.rc_configuration.total_units = total
                         self.rc_configuration.save()
                     self.pulses = str(y)
                     self.save()
                 @staticmethod
                 def array_to_points(X):
                     if X.size==0:
                         return []
                     d = X[1:]-X[:-1]
                     up = np.where(d==1)[0]
                     if X[0]==1:
                         up = np.concatenate((np.array([-1]), up))
                     up += 1
                     dw = np.where(d==-1)[0]
                     if X[-1]==1:
                         dw = np.concatenate((dw, np.array([len(X)-1])))
                     dw += 1
                     return [(tup[0], tup[1]) for tup in zip(up, dw)]
                 @staticmethod
                 def mask_ranges(Y, ranges):
                     y = [(0, 0) for __ in Y]
                     for index in ranges:
                         if '-' in index:
                             args = [int(a) for a in index.split('-')]
                             y[args[0]-1:args[1]] = Y[args[0]-1:args[1]]
                         else:
                             y[int(index)-1] = Y[int(index)-1]
                     return y
                 @staticmethod
                 def points(ntx, ipp, width, delay=[0], before=0, after=0, sync=0):
                     delays = len(delay)
                     Y = [(int(ipp*x+before+delay[x%delays]+sync), int(ipp*x+width+before+delay[x%delays]+after+sync)) for x in range(ntx)]
                     return Y
             class RCClock(models.Model):
                 rc_configuration = models.ForeignKey('RCConfiguration', on_delete=models.CASCADE)
                 mode = models.BooleanField(default=True, choices=((True, 'Auto'), (False, 'Manual')))
                 multiplier = models.PositiveIntegerField(default=60)
                 divisor = models.PositiveIntegerField(default=10)
                 reference = models.PositiveSmallIntegerField(default=1, choices=((0, 'Internal (25MHz)'), (1, 'External (10MHz)')))
-                frequency = models.FloatField(default=60.0)
  No newline at end of file
+                frequency = models.FloatField(default=60.0)

apps/rc/views.py +2 -3

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import RCConfiguration, RCLine, RCLineType, RCLineCode, RCClock
             from .forms import RCConfigurationForm, RCLineForm, RCLineViewForm, RCLineEditForm, RCImportForm, RCLineCodesForm, RCClockForm
             def conf(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                 clk = RCClock.objects.filter(rc_configuration=conf).first()
                 if clk is None:
                     clk = RCClock(rc_configuration=conf)
                     clk.save()
                 for line in lines:
                     params = json.loads(line.params)
                     line.form = RCLineViewForm(extra_fields=params, line=line)
                     if 'params' in params:
                         line.subforms = [RCLineViewForm(extra_fields=fields, line=line, subform=True) for fields in params['params']]
                 kwargs = {}
                 kwargs['clock'] = clk
                 kwargs['dev_conf'] = conf
                 kwargs['rc_lines'] = lines
                 kwargs['dev_conf_keys'] = ['ipp_unit', 'ntx', 'clock_divider', 'clock',
                                            'time_before', 'time_after', 'sync', 'sampling_reference',
                                            'control_tx', 'control_sw']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'rc_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 clock = RCClock.objects.get(rc_configuration=conf)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                 for line in lines:
                     params = json.loads(line.params)
                     #print(params)
                     line.form = RCLineEditForm(conf=conf, line=line, extra_fields=params)
                     line.subform = False
                     if 'params' in params:
                         line.subforms = [RCLineEditForm(extra_fields=fields, line=line, subform=i) for i, fields in enumerate(params['params'])]
                         line.subform = True
                     print(params)
                     print("fin de sub carga de params")
                 #print("fin de carga de params")
                 if request.method=='GET':
                     print("GET case")
                     form = RCConfigurationForm(instance=conf)
                     form_clock = RCClockForm(instance=clock)
                 elif request.method=='POST':
                     #print("ingreso a post conf edit")
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     print("Inicio impresion POST#####")
                     print(request.POST.items)
                     print("Fin impresion de POST items#####")
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
                             if label in ('mode', 'multiplier', 'divisor', 'reference', 'frequency'):
                                 clock_data[label] = value
                             else:
                                 conf_data[label] = value
                             continue
                         elif label.split('|')[0]!='-1':
                             extras.append(label)
                             continue
                         #print(label)
                         x, pk, name = label.split('|')
                         if name=='codes':
                             value = [s for s in value.split('\r\n') if s]
                         if pk in line_data:
                             line_data[pk][name] = value
                         else:
                             line_data[pk] = {name:value}
                         #print(line_data[pk])
                     #update conf
                     form_clock = RCClockForm(clock_data, instance=clock)
                     form = RCConfigurationForm(conf_data, instance=conf)
                     #print(request.POST.items())
                     if form_clock.is_valid() and form.is_valid():
                         form_clock.save()
                         form.save()
                         #update lines fields
-                        extras.sort()
+                        extras.sort(key=lambda x: int(x.split('|')[0]))
                         #print("Inicio extras")
                         #print(extras)
                         #print("Fin extras")
                         for label in extras:
                             x, pk, name = label.split('|')
                             if pk not in line_data:
                                 line_data[pk] = {}
                             if 'params' not in line_data[pk]:
                                 line_data[pk]['params'] = []
                             if len(line_data[pk]['params'])<int(x)+1:
                                 line_data[pk]['params'].append({})
                             line_data[pk]['params'][int(x)][name] = float(request.POST[label])
                         for pk, params in line_data.items():
                             line = RCLine.objects.get(pk=pk)
                             if line.line_type.name in ('windows', 'prog_pulses'):
                                 if 'params' not in params:
                                     params['params'] = []
                             line.params = json.dumps(params)
                             #print(line.params)
                             line.save()
                         #update pulses field
                         conf.update_pulses()
                         messages.success(request, 'RC Configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['form_clock'] = form_clock
                 kwargs['rc_lines'] = lines
                 kwargs['edit'] = True
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'rc_conf_edit.html', kwargs)
             def add_line(request, conf_id, line_type_id=None, code_id=None):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 if request.method=='GET':
                     if line_type_id:
                         line_type = get_object_or_404(RCLineType, pk=line_type_id)
                         if code_id:
                             form = RCLineForm(initial={'rc_configuration':conf_id, 'line_type': line_type_id, 'code_id': code_id},
                                               extra_fields=json.loads(line_type.params))
                         else:
                             form = RCLineForm(initial={'rc_configuration':conf_id, 'line_type': line_type_id},
                                               extra_fields=json.loads(line_type.params))
                     else:
                         line_type = {'id':0}
                         form = RCLineForm(initial={'rc_configuration':conf_id})
                 if request.method=='POST':
                     line_type = get_object_or_404(RCLineType, pk=line_type_id)
                     form = RCLineForm(request.POST,
                                       extra_fields=json.loads(line_type.params))
                     if form.is_valid():
                         form.save()
                         form.instance.update_pulses()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Add Line'
                 kwargs['button'] = 'Add'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['dev_conf'] = conf
                 kwargs['line_type'] = line_type
                 return render(request, 'rc_add_line.html', kwargs)
             def edit_codes(request, conf_id, line_id, code_id=None):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 params = json.loads(line.params)
                 if request.method=='GET':
                     if code_id:
                         code = get_object_or_404(RCLineCode, pk=code_id)
                         form = RCLineCodesForm(instance=code)
                     else:
                         initial = {'code': params['code'],
                                    'codes': params['codes'] if 'codes' in params else [],
                                    'number_of_codes': len(params['codes']) if 'codes' in params else 0,
                                    'bits_per_code': len(params['codes'][0]) if 'codes' in params else 0,
                                    }
                         form = RCLineCodesForm(initial=initial)
                 if request.method=='POST':
                     form = RCLineCodesForm(request.POST)
                     if form.is_valid():
                         params['code'] = request.POST['code']
                         params['codes'] = [s for s in request.POST['codes'].split('\r\n') if s]
                         line.params = json.dumps(params)
                         line.save()
                         messages.success(request, 'Line: "%s" has been updated.'  % line)
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = line
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['dev_conf'] = conf
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['line'] = line
                 return render(request, 'rc_edit_codes.html', kwargs)
             def add_subline(request, conf_id, line_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         params = json.loads(line.params)
                         subparams = json.loads(line.line_type.params)
                         if 'params' in subparams:
                             dum = {}
                             for key, value in subparams['params'].items():
                                 dum[key] = value['value']
                             params['params'].append(dum)
                             line.params = json.dumps(params)
                             line.save()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['title'] = 'Add new'
                 kwargs['suptitle'] = '%s to %s' % (line.line_type.name, line)
                 return render(request, 'confirm.html', kwargs)
             def remove_line(request, conf_id, line_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         try:
                             channel = line.channel
                             line.delete()
                             for ch in range(channel+1, RCLine.objects.filter(rc_configuration=conf).count()+1):
                                 l = RCLine.objects.get(rc_configuration=conf, channel=ch)
                                 l.channel = l.channel-1
                                 l.save()
                             messages.success(request, 'Line: "%s" has been deleted.'  % line)
                         except:
                             messages.error(request, 'Unable to delete line: "%s".' % line)
                     return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['object'] = line
                 kwargs['delete'] = True
                 kwargs['title'] = 'Delete'
                 kwargs['suptitle'] = 'Line'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 return render(request, 'confirm.html', kwargs)
             def remove_subline(request, conf_id, line_id, subline_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         params = json.loads(line.params)
                         params['params'].remove(params['params'][int(subline_id)-1])
                         line.params = json.dumps(params)
                         line.save()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['object'] = line
                 kwargs['object_name'] = line.line_type.name
                 kwargs['delete_view'] = True
                 kwargs['title'] = 'Confirm delete'
                 return render(request, 'confirm.html', kwargs)
             def update_lines_position(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 print("ingreso a update_lines_position")
                 if request.method=='POST':
                     ch = 0
                     for item in request.POST['items'].split('&'):
                         line = RCLine.objects.get(pk=item.split('=')[-1])
                         line.channel = ch
                         line.save()
                         ch += 1
                     lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                     for line in lines:
                         params = json.loads(line.params)
                         print(params)
                         print("Fin de impresion_lines_position")
                         line.form = RCLineEditForm(conf=conf, line=line, extra_fields=params)
                         if 'params' in params:
                             line.subform = True
                             line.subforms = [RCLineEditForm(extra_fields=fields, line=line, subform=i) for i, fields in enumerate(params['params'])]
                     html = render(request, 'rc_lines.html', {'dev_conf':conf, 'rc_lines':lines, 'edit':True})
                     data = {'html': html.content.decode('utf8')}
                     return HttpResponse(json.dumps(data), content_type="application/json")
                 return redirect('url_edit_rc_conf', conf.id)
             def import_file(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = RCImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             conf.update_pulses()
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = RCImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'rc_import.html', kwargs)
             def plot_pulses(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 km = True if 'km' in request.GET else False
                 script, div = conf.plot_pulses(km=km)
                 kwargs = {}
                 kwargs['no_sidebar'] = True
                 kwargs['title'] = 'RC Pulses'
                 kwargs['suptitle'] = conf.name
                 kwargs['div'] = mark_safe(div)
                 kwargs['script'] = mark_safe(script)
                 kwargs['units'] = conf.km2unit
                 kwargs['kms'] = 1/conf.km2unit
                 if km:
                     kwargs['km_selected'] = True
                 if 'json' in request.GET:
                     return HttpResponse(json.dumps({'div':mark_safe(div), 'script':mark_safe(script)}), content_type="application/json")
                 else:
                     return render(request, 'rc_pulses.html', kwargs)
             def plot_pulses2(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 km = True if 'km' in request.GET else False
                 script, div = conf.plot_pulses2(km=km)
                 kwargs = {}
                 kwargs['no_sidebar'] = True
                 kwargs['title'] = 'RC Pulses'
                 kwargs['suptitle'] = conf.name
                 kwargs['div'] = mark_safe(div)
                 kwargs['script'] = mark_safe(script)
                 kwargs['units'] = conf.km2unit
                 kwargs['kms'] = 1/conf.km2unit
                 if km:
                     kwargs['km_selected'] = True
                 if 'json' in request.GET:
                     return HttpResponse(json.dumps({'div':mark_safe(div), 'script':mark_safe(script)}), content_type="application/json")
                 else:
                     return render(request, 'rc_pulses.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
-                return HttpResponse(raw, content_type='application/json')
  No newline at end of file
+                return HttpResponse(raw, content_type='application/json')

docker-compose.yml +43 -41

@@ -1,68 +1,70
1	version: '2'	1	version: '2'
2	services:	2	services:
3	# Django app	3	# Django app
4	web:	4	# web:
5	~~container_name~~: 'radarsys'	5	# container_name: 'radarsys'
6	~~build~~: .	6	# build: .
7	~~restart~~: always	7	# restart: always
8	~~image~~: radarsys	8	# image: radarsys
9	~~command~~: gunicorn radarsys.wsgi:application -w 2 -b :8000	9	# command: gunicorn radarsys.wsgi:application -w 2 -b :8000
10	# command: python manage.py runserver 0.0.0.0:8030	10	# # command: python manage.py runserver 0.0.0.0:8030
11	# ports:	11	# # ports:
12	# - 8030:8030	12	# # - 8030:8030
13	~~env_file~~: .env	13	# env_file: .env
14		14
15	links:	15	# links:
16	- redis	16	# - redis
17	- postgres	17	# - postgres
18	volumes:	18	# volumes:
19	- './:/radarsys'	19	# - './:/radarsys'
20	- '${DOCKER_DATA}/static:/radarsys/static'	20	# - '${DOCKER_DATA}/static:/radarsys/static'
21	depends_on:	21	# depends_on:
22	- redis	22	# - redis
23	- postgres	23	# - postgres
24		24
25	redis:	25	redis:
26	container_name: 'radarsys-redis'	26	container_name: 'radarsys-redis'
27	image: 'redis:3.2-alpine'	27	image: 'redis:3.2-alpine'
28	volumes:	28	volumes:
29	- '${DOCKER_DATA}/redis:/data'	29	- '${DOCKER_DATA}/redis:/data'
		30	ports:
		31	- 6300:6379
30		32
31	celery_worker:	33	celery_worker:
32	container_name: 'radarsys-celery'	34	container_name: 'radarsys-celery'
33	image: radarsys	35	image: radarsys
34	env_file: .env	36	env_file: .env
35	command: celery -A radarsys worker -l info	37	command: celery -A radarsys worker -l info
36	volumes_from:	38	# volumes_from:
37	- web	39	# - web
38	depends_on:	40	# depends_on:
39	- web	41	# - web
40		42
41	# PostgreSQL	43	# PostgreSQL
42	postgres:	44	postgres:
43	container_name: 'radarsys-postgres'	45	container_name: 'radarsys-postgres'
44	build: ./postgres/	46	build: ./postgres/
45	volumes:	47	volumes:
46	- ./postgres/docker-entrypoint-initdb.d:/docker-entrypoint-initdb.d	48	- ./postgres/docker-entrypoint-initdb.d:/docker-entrypoint-initdb.d
47	- ~~pgdata~~:/var/lib/postgresql/data	49	- /data/dockers/radarsys/postgres:/var/lib/postgresql/data
48	# ports:	50	ports:
49	# - 5432:5432	51	- 5400:5432
50	env_file: .env	52	env_file: .env
51		53
52	# Web Server	54	# Web Server
53	nginx:	55	# nginx:
54	container_name: 'radarsys-nginx'	56	# container_name: 'radarsys-nginx'
55	restart: always	57	# restart: always
56	build: ./nginx/	58	# build: ./nginx/
57	ports:	59	# ports:
58	- '8030:8030'	60	# - '8030:8030'
59	volumes_from:	61	# volumes_from:
60	- web	62	# - web
61	links:	63	# links:
62	- web:web	64	# - web:web
63	depends_on:	65	# depends_on:
64	- web	66	# - web
65		67
66	volumes:	68	# volumes:
67	pgdata:	69	# pgdata:
68	driver: local	70	# driver: local

radarsys/settings.py +21 -27

             """
             Django settings for radarsys project.
             Generated by 'django-admin startproject' using Django 1.8.6.
             For more information on this file, see
             https://docs.djangoproject.com/en/1.8/topics/settings/
             For the full list of settings and their values, see
             https://docs.djangoproject.com/en/1.8/ref/settings/
             """
             # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
             import os
             BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
             # Quick-start development settings - unsuitable for production
             # See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/
             # SECURITY WARNING: keep the secret key used in production secret!
             SECRET_KEY = 'xshb$k5fc-+j16)cvyffj&9u__0q3$l!hieh#+tbzqg)*f^km0'
             # SECURITY WARNING: don't run with debug turned on in production!
             DEBUG = True
             ALLOWED_HOSTS = ['*']
             # Application definition
-            INSTALLED_APPS = [
+            INSTALLED_APPS = (
                 'django.contrib.admin',
                 'django.contrib.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
                 'django.contrib.messages',
                 'django.contrib.staticfiles',
                 'bootstrap4',
                 'polymorphic',
                 'apps.accounts',
                 'apps.main',
                 'apps.misc',
                 'apps.rc',
                 'apps.dds',
+                'apps.dds_rest',
                 'apps.jars',
                 'apps.usrp',
                 'apps.abs',
                 'apps.cgs',
-                'apps.dds_rest',
             MIDDLEWARE = [
                 'django.middleware.security.SecurityMiddleware',
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.common.CommonMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
                 'django.contrib.auth.middleware.AuthenticationMiddleware',
                 'django.contrib.messages.middleware.MessageMiddleware',
                 'django.middleware.clickjacking.XFrameOptionsMiddleware',
             ]
             ROOT_URLCONF = 'radarsys.urls'
             TEMPLATES = [
                 {
                     'BACKEND': 'django.template.backends.django.DjangoTemplates',
-                    'DIRS': [os.path.join(BASE_DIR, "templates")],
+                    'DIRS': [os.path.join(BASE_DIR, "templates").replace('\\', '/'),],
                     'APP_DIRS': True,
                     'OPTIONS': {
                         'context_processors': [
                             'django.template.context_processors.debug',
                             'django.template.context_processors.request',
                             'django.contrib.auth.context_processors.auth',
                             'django.contrib.messages.context_processors.messages',
                             'apps.main.processors.radarsys_globals',
                         ],
                     },
                 },
             ]
             WSGI_APPLICATION = 'radarsys.wsgi.application'
             # Database
             # https://docs.djangoproject.com/en/1.8/ref/settings/#databases
             DATABASES = {
                 'default': {
                     'ENGINE': 'django.db.backends.sqlite3',
                     'NAME': 'radarsys.sqlite',
+                    # 'ENGINE': 'django.db.backends.postgresql_psycopg2',
+                    # 'NAME': os.environ.get('DB_NAME', 'radarsys'),
+                    # 'USER': os.environ.get('DB_USER', 'docker'),
+                    # 'PASSWORD': os.environ.get('DB_PASSWORD', 'docker'),
+                    # 'HOST': os.environ.get('POSTGRES_PORT_5432_TCP_ADDR', 'localhost'),
+                    # 'PORT': os.environ.get('POSTGRES_PORT_5432_TCP_PORT', '5400'),
+                    }
                 }
-                # 'default': {
-                #     'ENGINE': 'django.db.backends.postgresql_psycopg2',
-                #     'NAME': os.environ.get('DB_NAME', 'radarsys'),
-                #     'USER': os.environ.get('DB_USER', 'docker'),
-                #     'PASSWORD': os.environ.get('DB_PASSWORD', 'docker'),
-                #     'HOST': os.environ.get('POSTGRES_PORT_5432_TCP_ADDR', 'localhost'),
-                #     'PORT': os.environ.get('POSTGRES_PORT_5432_TCP_PORT', '5400'),
-                #}
             # Internationalization
             # https://docs.djangoproject.com/en/1.8/topics/i18n/
             LANGUAGE_CODE = 'en-us'
-            USE_TZ   = False #True
             TIME_ZONE = os.environ.get('TZ', 'America/Lima')
             USE_I18N = True
             USE_L10N = True
+            USE_TZ = False
             # Static files (CSS, JavaScript, Images)
             # https://docs.djangoproject.com/en/1.8/howto/static-files/
             MEDIA_URL = '/media/'
             MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
             STATIC_URL = '/static/'
             STATIC_ROOT = os.path.join(BASE_DIR, 'static')
             STATICFILES_FINDERS = (
                 'django.contrib.staticfiles.finders.FileSystemFinder',
                 'django.contrib.staticfiles.finders.AppDirectoriesFinder',
             )
             # Celery stuff
+            REDIS_HOST = os.environ.get('REDIS_HOST', '127.0.0.1')
-            REDIS_HOST = os.environ.get('REDIS_HOST', 'localhost')
+            REDIS_PORT = os.environ.get('REDIS_PORT', 6300)
-            #REDIS_HOST = os.environ.get('REDIS_HOST', '127.0.0.1')
-            REDIS_PORT = os.environ.get('REDIS_PORT', 6379)
             BROKER_TRANSPORT = 'redis'
-            #BROKER_URL       = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
+            BROKER_URL = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
-            BROKER_URL       = 'redis://{}:{}'.format(REDIS_HOST, REDIS_PORT)
-            CELERY_RESULT_BACKEND    = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
+            CELERY_RESULT_BACKEND = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
-            CELERY_BROKER_TRANSPORT  = BROKER_URL
+            CELERY_BROKER_TRANSPORT = BROKER_URL
-            CELERY_ACCEPT_CONTENT    = ['application/json']
+            CELERY_ACCEPT_CONTENT = ['application/json']
-            CELERY_TASK_SERIALIZER   = 'json'
+            CELERY_TASK_SERIALIZER = 'json'
             CELERY_RESULT_SERIALIZER = 'json'
-            CELERY_ENABLE_UTC        = False
+            CELERY_ENABLE_UTC = False
-            CELERY_TIMEZONE          = 'America/Lima'
  No newline at end of file

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages