radarsys Commit - r111:e02ef9acb4e3 · Jicamarca Repository

Optimize pulses's plot and generation ...

Juan C. Espinoza -

r111:e02ef9acb4e3

parent child

Context file:

r111:e02ef9acb4e3

Collapse all files

apps/rc/fixtures/rc_initial_data.json +2 -1

             [{"fields": {"number_of_codes": 0, "codes": "[]", "name": "None", "bits_per_code": 0}, "model": "rc.rclinecode", "pk": 1},
              {"fields": {"number_of_codes": 2, "codes": "[u'11101101', u'11100010']", "name": "COMPLEMENTARY_CODE_8", "bits_per_code": 8}, "model": "rc.rclinecode", "pk": 2},
              {"fields": {"number_of_codes": 1, "codes": "[u'1101101001000100010001111000']", "name": "BINARY_CODE_28", "bits_per_code": 28}, "model": "rc.rclinecode", "pk": 3},
              {"fields": {"number_of_codes": 2, "codes": "[u'11', u'10']", "name": "COMPLEMENTARY_CODE_2", "bits_per_code": 2}, "model": "rc.rclinecode", "pk": 4},
              {"fields": {"number_of_codes": 2, "codes": "[u'1110110111100010111011010001110111101101111000100001001011100010', u'1110110111100010111011010001110100010010000111011110110100011101']", "name": "COMPLEMENTARY_CODE_64", "bits_per_code": 64}, "model": "rc.rclinecode", "pk": 5},
              {"fields": {"number_of_codes": 1, "codes": "[u'11100010010']", "name": "BARKER11", "bits_per_code": 11}, "model": "rc.rclinecode", "pk": 6},
              {"fields": {"number_of_codes": 2, "codes": "[u'1111100110101' ]", "name": "BARKER13", "bits_per_code": 13}, "model": "rc.rclinecode", "pk": 7},
              {"fields": {"number_of_codes": 2, "codes": "[u'1101101001000100010001111000', u'0010010110111011101110000111']", "name": "BINARY_CODE_28_FLIP", "bits_per_code": 28}, "model": "rc.rclinecode", "pk": 8},
              {"fields": {"number_of_codes": 2, "codes": "[u'11101101111000101110110100011101', u'11101101111000100001001011100010']", "name": "COMPLEMENTARY_CODE_32", "bits_per_code": 32}, "model": "rc.rclinecode", "pk": 9},
              {"fields": {"number_of_codes": 128, "codes": "[u'1111000100100101', u'1011001010010111', u'1101001000100000', u'1001000110010010', u'1110001001111011', u'1010000111001001', u'1100000101111110', u'1000001011001100', u'1111101001010110', u'1011100111100100', u'1101100101010011', u'1001101011100001', u'1110100100001000', u'1010101010111010', u'1100101000001101', u'1000100110111111', u'1111010010011100', u'1011011100101110', u'1101011110011001', u'1001010000101011', u'1110011111000010', u'1010010001110000', u'1100010011000111', u'1000011101110101', u'1111111111101111', u'1011110001011101', u'1101110011101010', u'1001111101011000', u'1110110010110001', u'1010111100000011', u'1100111110110100', u'1000110000000110', u'0011111000000011', u'0111110110110001', u'0001110100000110', u'0101111010110100', u'0010110101011101', u'0110111011101111', u'0000111001011000', u'0100110111101010', u'0011010101110000', u'0111011011000010', u'0001011001110101', u'0101010111000111', u'0010011000101110', u'0110010110011100', u'0000010100101011', u'0100011010011001', u'0011101110111010', u'0111100000001000', u'0001100010111111', u'0101101100001101', u'0010100011100100', u'0110101101010110', u'0000101111100001', u'0100100001010011', u'0011000011001001', u'0111001101111011', u'0001001111001100', u'0101000001111110', u'0010001110010111', u'0110000000100101', u'0000000010010010', u'0100001100100000', u'1010110011001110', u'1110111101111100', u'1000111111001011', u'1100110001111001', u'1011111110010000', u'1111110000100010', u'1001110010010101', u'1101111100100111', u'1010011110111101', u'1110010000001111', u'1000010010111000', u'1100011100001010', u'1011010011100011', u'1111011101010001', u'1001011111100110', u'1101010001010100', u'1010100101110111', u'1110101011000101', u'1000101001110010', u'1100100111000000', u'1011101000101001', u'1111100110011011', u'1001100100101100', u'1101101010011110', u'1010001000000100', u'1110000110110110', u'1000000100000001', u'1100001010110011', u'1011000101011010', u'1111001011101000', u'1001001001011111', u'1101000111101101', u'1100100111000110', u'1000101001110100', u'1110101011000011', u'1010100101110001', u'1101101010011000', u'1001100100101010', u'1111100110011101', u'1011101000101111', u'1100001010110101', u'1000000100000111', u'1110000110110000', u'1010001000000010', u'1101000111101011', u'1001001001011001', u'1111001011101110', u'1011000101011100', u'1100110001111111', u'1000111111001101', u'1110111101111010', u'1010110011001000', u'1101111100100001', u'1001110010010011', u'1111110000100100', u'1011111110010110', u'1100011100001100', u'1000010010111110', u'1110010000001001', u'1010011110111011', u'1101010001010010', u'1001011111100000', u'1111011101010111', u'1011010011100101']", "name": "AC128", "bits_per_code": 16}, "model": "rc.rclinecode", "pk": 10},
              {"fields": {"number_of_codes": 2, "codes": "[u'11101101111000101110110100011101111011011110001000010010111000101110110111100010111011010001110100010010000111011110110100011101', u'11101101111000101110110100011101111011011110001000010010111000100001001000011101000100101110001011101101111000100001001011100010']", "name": "COMPLEMENTARY_CODE_128", "bits_per_code": 128}, "model": "rc.rclinecode", "pk": 11},
              {"fields": {"number_of_codes": 2, "codes": "[u'1110110111100010', u'1110110100011101']", "name": "COMPLEMENTARY_CODE_16", "bits_per_code": 16}, "model": "rc.rclinecode", "pk": 12},
              {"fields": {"number_of_codes": 1, "codes": "[u'11']", "name": "BARKER2", "bits_per_code": 2}, "model": "rc.rclinecode", "pk": 13},
              {"fields": {"number_of_codes": 1, "codes": "[u'110']", "name": "BARKER3", "bits_per_code": 3}, "model": "rc.rclinecode", "pk": 14},
              {"fields": {"number_of_codes": 2, "codes": "[u'1110', u'1101']", "name": "COMPLEMENTARY_CODE_4", "bits_per_code": 4}, "model": "rc.rclinecode", "pk": 15},
              {"fields": {"number_of_codes": 1, "codes": "[u'1110010']", "name": "BARKER7", "bits_per_code": 7}, "model": "rc.rclinecode", "pk": 16},
              {"fields": {"number_of_codes": 1, "codes": "[u'1101']", "name": "BARKER4", "bits_per_code": 4}, "model": "rc.rclinecode", "pk": 17},
              {"fields": {"number_of_codes": 1, "codes": "[u'11101']", "name": "BARKER5", "bits_per_code": 5}, "model": "rc.rclinecode", "pk": 18},
              {"fields": {"params": "{\"TX_ref\": {\"model\": \"RCLine\",  \"value\": \"\"}, \"range\": { \"value\": 0, \"help\": \"Frame numbers or frame ranges separated by commas, use 0 for all frames eg: 1,2,10-15\"}}", "name": "tr", "description": ""}, "model": "rc.rclinetype", "pk": 1},
              {"fields": {"params": "{\"pulse_width\":{\"value\": 0, \"widget\":\"dc\"},\r\n \"delays\":{\"value\": \"\", \"widget\":\"km\", \"help\": \"Delay entries separated by commas (TAUs)\"},\r\n \"range\":{\"value\": 0, \"help\": \"Frame numbers or frame ranges separated by commas, use 0 for all frames eg: 1,2,10-15\"}}", "name": "tx", "description": ""}, "model": "rc.rclinetype", "pk": 2},
              {"fields": {"params": "{\"TX_ref\": {\"model\": \"RCLine\",  \"value\": \"\"}, \"code\": {\"model\":\"RCLineCode\",\"value\": \"\"}, \"codes\":{\"value\":\"\", \"widget\":\"codes\"}}", "name": "codes", "description": ""}, "model": "rc.rclinetype", "pk": 3},
              {"fields": {"params": "{ \"TX_ref\":{\"model\": \"RCLine\",  \"value\": \"\"}, \"params\": {\"first_height\":{ \"value\": 0, \"widget\":\"km\"},\"resolution\": {\"value\": 0, \"widget\":\"km\"}, \"number_of_samples\": { \"value\": 0, \"help\":\"number of samples (NSA)\"}}}", "name": "windows", "description": ""}, "model": "rc.rclinetype", "pk": 4},
              {"fields": {"params": "{\"invert\":{\"value\": 0, \"help\": \"Set to 1 for synchro pulse at the end\"}}", "name": "sync", "description": ""}, "model": "rc.rclinetype", "pk": 5},
              {"fields": {"params": "{ \"periodic\": { \"value\": 0, \"help\": \"Set to 1 for IPP periodic\"}, \"params\": {\"begin\": { \"value\": 0, \"widget\":\"unit\"}, \"end\": {\"value\": 0, \"widget\":\"unit\"}}}", "name": "prog_pulses", "description": ""}, "model": "rc.rclinetype", "pk": 6},
              {"fields": {"params": "{\"number_of_flips\": {\"value\": 0}}", "name": "flip", "description": ""}, "model": "rc.rclinetype", "pk": 7},
-             {"fields": {"params": "{}", "name": "none", "description": ""}, "model": "rc.rclinetype", "pk": 8}]
+             {"fields": {"params": "{}", "name": "none", "description": ""}, "model": "rc.rclinetype", "pk": 8},
+             {"fields": {"params": "{}", "name": "mix", "description": ""}, "model": "rc.rclinetype", "pk": 9}]
  No newline at end of file

apps/rc/forms.py +1 -1

             import os
             import ast
             import json
             from django import forms
             from django.utils.safestring import mark_safe
             from apps.main.models import Device
             from apps.main.forms import add_empty_choice
             from .models import RCConfiguration, RCLine, RCLineType, RCLineCode
             from .widgets import KmUnitWidget, KmUnitHzWidget, KmUnitDcWidget, UnitKmWidget, DefaultWidget, CodesWidget, HiddenWidget, HCheckboxSelectMultiple
             def create_choices_from_model(model, conf_id, all=False):
                 if model=='RCLine':
                     instance = RCConfiguration.objects.get(pk=conf_id)
                     choices =  [(line.pk, line.get_name()) for line in instance.get_lines(line_type__name='tx')]
                     choices = add_empty_choice(choices, label='All')
                 else:
                     instance = globals()[model]
                     choices = instance.objects.all().values_list('pk', 'name')
                 return choices
             class ExtFileField(forms.FileField):
                 """
                 Same as forms.FileField, but you can specify a file extension whitelist.
                 >>> from django.core.files.uploadedfile import SimpleUploadedFile
                 >>>
                 >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
                 >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
                 Traceback (most recent call last):
                 ...
                 ValidationError: [u'Not allowed filetype!']
                 """
                 def __init__(self, *args, **kwargs):
                     extensions = kwargs.pop("extensions")
                     self.extensions = [i.lower() for i in extensions]
                     super(ExtFileField, self).__init__(*args, **kwargs)
                 def clean(self, *args, **kwargs):
                     data = super(ExtFileField, self).clean(*args, **kwargs)
                     filename = data.name
                     ext = os.path.splitext(filename)[1]
                     ext = ext.lower()
                     if ext not in self.extensions:
                         raise forms.ValidationError('Not allowed file type: %s' % ext)
             class RCConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(RCConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='rc')
                         if instance.experiment:
                             self.fields['experiment'].widget.attrs['read_only'] = True
                             #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                         self.fields['ipp'].widget = KmUnitHzWidget(attrs={'km2unit':instance.km2unit})
                         self.fields['clock'].widget.attrs['readonly'] = True
                     self.fields['time_before'].label = mark_safe(self.fields['time_before'].label)
                     self.fields['time_after'].label = mark_safe(self.fields['time_after'].label)
                     if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
                         self.fields['experiment'].widget.attrs['disabled'] = 'disabled'
                 class Meta:
                     model = RCConfiguration
-                    exclude = ('type', 'parameters', 'status')
+                    exclude = ('type', 'parameters', 'status', 'mix')
                 def clean(self):
                     form_data = super(RCConfigurationForm, self).clean()
                     if 'clock_divider' in form_data:
                         if form_data['clock_divider']<1:
                             self.add_error('clock_divider', 'Invalid Value')
                         else:
                             if form_data['ipp']*(20./3*(form_data['clock_in']/form_data['clock_divider']))%10<>0:
                                 self.add_error('ipp', 'Invalid IPP units={}'.format(form_data['ipp']*(20./3*(form_data['clock_in']/form_data['clock_divider']))))
                     return form_data
             class RCMixConfigurationForm(forms.Form):
                 clock_in = forms.CharField(widget=forms.HiddenInput())
                 clock_divider = forms.CharField(widget=forms.HiddenInput())
                 name = forms.CharField()
                 experiment = forms.ChoiceField()
                 operation = forms.ChoiceField(widget=forms.RadioSelect(),
                                               choices=[(0, 'OR'), (1, 'XOR'), (2, 'AND'), (3, 'NAND')],
                                               initial=1)
                 delay = forms.CharField()
                 mask = forms.MultipleChoiceField(choices=[(0, 'L1'),(1, 'L2'),(2, 'L3'),(3, 'L4'),(4, 'L5'),(5, 'L6'),(6, 'L7'),(7, 'L8')],
                                                  widget=HCheckboxSelectMultiple())
                 result = forms.CharField(required=False,
                                          widget=forms.Textarea(attrs={'readonly':True, 'rows':5, 'class':'tabuled'}))
                 def __init__(self, *args, **kwargs):
                     confs = kwargs.pop('confs', [])
                     if confs:
                         km2unit = confs[0].km2unit
                         clock_in = confs[0].clock_in
                         clock_divider = confs[0].clock_divider
                     else:
                         km2unit = clock_in = clock_divider = 0
                     super(RCMixConfigurationForm, self).__init__(*args, **kwargs)
                     self.fields['experiment'].choices = [(conf.pk, '{} | {}'.format(conf.pk, conf.name)) for conf in confs]
                     self.fields['delay'].widget = KmUnitWidget(attrs = {'km2unit':km2unit})
                     self.fields['clock_in'].initial = clock_in
                     self.fields['clock_divider'].initial = clock_divider
             class RCLineForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     self.extra_fields = kwargs.pop('extra_fields', [])
                     super(RCLineForm, self).__init__(*args, **kwargs)
                     if 'initial' in kwargs and 'line_type' in kwargs['initial']:
                         line_type = RCLineType.objects.get(pk=kwargs['initial']['line_type'])
                         if 'code_id' in kwargs['initial']:
                             model_initial = kwargs['initial']['code_id']
                         else:
                             model_initial = 0
                         params = json.loads(line_type.params)
                         for label, value in self.extra_fields.items():
                             if label=='params':
                                 continue
                             if 'model' in params[label]:
                                 self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'],
                                                                                                          kwargs['initial']['rc_configuration']),
                                                                        initial=model_initial)
                             else:
                                 if label=='codes' and 'code_id' in kwargs['initial']:
                                     self.fields[label] = forms.CharField(initial=RCLineCode.objects.get(pk=kwargs['initial']['code_id']).codes)
                                 else:
                                     self.fields[label] = forms.CharField(initial=value['value'])
                                 if label=='codes':
                                     self.fields[label].widget = CodesWidget()
                     if self.data:
                         line_type = RCLineType.objects.get(pk=self.data['line_type'])
                         if 'code_id' in self.data:
                             model_initial = self.data['code_id']
                         else:
                             model_initial = 0
                         params = json.loads(line_type.params)
                         for label, value in self.extra_fields.items():
                             if label=='params':
                                 continue
                             if 'model' in params[label]:
                                 self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'],
                                                                                                          self.data['rc_configuration']),
                                                                        initial=model_initial)
                             else:
                                 if label=='codes' and 'code' in self.data:
                                     self.fields[label] = forms.CharField(initial=self.data['codes'])
                                 else:
                                     self.fields[label] = forms.CharField(initial=self.data[label])
                                 if label=='codes':
                                     self.fields[label].widget = CodesWidget()
                 class Meta:
                     model = RCLine
                     fields = ('rc_configuration', 'line_type', 'channel')
                     widgets = {
                         'channel': forms.HiddenInput(),
                     }
                 def clean(self):
                     form_data = self.cleaned_data
                     if 'code' in self.data and self.data['TX_ref']=="0":
                         self.add_error('TX_ref', 'Choose a valid TX reference')
                     return form_data
                 def save(self):
                     line = super(RCLineForm, self).save()
                     #auto add channel
                     line.channel = RCLine.objects.filter(rc_configuration=line.rc_configuration).count()-1
                     #auto add position for TX, TR & CODE
                     if line.line_type.name in ('tx', ):
                         line.position = RCLine.objects.filter(rc_configuration=line.rc_configuration, line_type=line.line_type).count()-1
                     #save extra fields in params
                     params = {}
                     for label, value in self.extra_fields.items():
                         if label=='params':
                             params['params'] = []
                         elif label=='codes':
                             params[label] = [s for s in self.data[label].split('\r\n') if s]
                         else:
                             params[label] = self.data[label]
                     line.params = json.dumps(params)
                     line.save()
                     return
             class RCLineViewForm(forms.Form):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields')
                     line = kwargs.pop('line')
                     subform = kwargs.pop('subform', False)
                     super(RCLineViewForm, self).__init__(*args, **kwargs)
                     if subform:
                         params = json.loads(line.line_type.params)['params']
                     else:
                         params = json.loads(line.line_type.params)
                     for label, value in extra_fields.items():
                         if label=='params':
                             continue
                         if 'ref' in label:
                             if value in (0, '0'):
                                 value = 'All'
                             else:
                                 value = RCLine.objects.get(pk=value).get_name()
                         elif label=='code':
                             value = RCLineCode.objects.get(pk=value).name
                         self.fields[label] = forms.CharField(initial=value)
                         if 'widget' in params[label]:
                             km2unit = line.rc_configuration.km2unit
                             if params[label]['widget']=='km':
                                 self.fields[label].widget = KmUnitWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='unit':
                                 self.fields[label].widget = UnitKmWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='dc':
                                 self.fields[label].widget = KmUnitDcWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='codes':
                                 self.fields[label].widget = CodesWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                         else:
                             self.fields[label].widget = DefaultWidget(attrs={'disabled':True})
             class RCLineEditForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields', [])
                     conf = kwargs.pop('conf', False)
                     line = kwargs.pop('line')
                     subform = kwargs.pop('subform', False)
                     super(RCLineEditForm, self).__init__(*args, **kwargs)
                     if subform is not False:
                         params = json.loads(line.line_type.params)['params']
                         count = subform
                     else:
                         params = json.loads(line.line_type.params)
                         count = -1
                     for label, value in extra_fields.items():
                         if label in ('params',):
                             continue
                         if 'help' in params[label]:
                             help_text = params[label]['help']
                         else:
                             help_text = ''
                         if 'model' in params[label]:
                             self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'], conf.id),
                                                         initial=value,
                                                         widget=forms.Select(attrs={'name':'%s|%s|%s' % (count, line.id, label)}),
                                                         help_text=help_text)
                         else:
                             self.fields[label] = forms.CharField(initial=value, help_text=help_text)
                             if label in ('code', ):
                                 self.fields[label].widget = HiddenWidget(attrs={'name':'%s|%s|%s' % (count, line.id, label)})
                             elif 'widget' in params[label]:
                                 km2unit = line.rc_configuration.km2unit
                                 if params[label]['widget']=='km':
                                     self.fields[label].widget = KmUnitWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='unit':
                                     self.fields[label].widget = UnitKmWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='dc':
                                     self.fields[label].widget = KmUnitDcWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='codes':
                                     self.fields[label].widget = CodesWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                             else:
                                 self.fields[label].widget = DefaultWidget(attrs={'name':'%s|%s|%s' % (count, line.id, label)})
                 class Meta:
                     model = RCLine
                     exclude = ('rc_configuration', 'line_type', 'channel', 'position', 'params', 'pulses')
             class RCSubLineEditForm(forms.Form):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields')
                     count = kwargs.pop('count')
                     line = kwargs.pop('line')
                     super(RCSubLineEditForm, self).__init__(*args, **kwargs)
                     for label, value in extra_fields.items():
                         self.fields[label] = forms.CharField(initial=value,
                                                              widget=forms.TextInput(attrs={'name':'%s|%s|%s' % (count, line, label)}))
             class RCImportForm(forms.Form):
                 file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])
             class RCLineCodesForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(RCLineCodesForm, self).__init__(*args, **kwargs)
                     if 'initial' in kwargs:
                         self.fields['code'] = forms.ChoiceField(choices=RCLineCode.objects.all().values_list('pk', 'name'),
                                                                 initial=kwargs['initial']['code'])
                     if 'instance' in kwargs:
                         self.fields['code'] = forms.ChoiceField(choices=RCLineCode.objects.all().values_list('pk', 'name'),
                                                                 initial=kwargs['instance'].pk)
                     self.fields['codes'].widget = CodesWidget()
                 class Meta:
                     model = RCLineCode
                     exclude = ('name',)
   No newline at end of file

apps/rc/models.py +179 -87

             import ast
             import json
             import numpy as np
             from polymorphic import PolymorphicModel
             from django.db import models
             from django.core.urlresolvers import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             from devices.rc import api
-            from .utils import RCFile, pulses, pulses_from_code, create_mask, pulses_to_points
+            from .utils import RCFile
             # Create your models here.
             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'),
                 ('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,
                         }
             class RCConfiguration(Configuration):
                 ipp = models.FloatField(verbose_name='Inter pulse period (Km)', validators=[MinValueValidator(1), MaxValueValidator(9000)], default=300)
                 ntx = models.PositiveIntegerField(verbose_name='Number of TX', validators=[MinValueValidator(1), MaxValueValidator(300)], 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)
                 mix = models.BooleanField(default=False)
                 class Meta:
                     db_table = 'rc_configurations'
                 def __unicode__(self):
                     if self.mix:
                         return u'[MIXED]: %s' % self.name
                     else:
                         return u'[%s]: %s' % (self.device.name, self.name)
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_rc_pulses', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_rc_conf', args=[str(self.id)])
                 @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)
                     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(pk=8)
+                    empty_line = RCLineType.objects.get(name='none')
                     for line in self.get_lines():
                         line.line_type = empty_line
                         line.params = '{}'
                         line.save()
                 def parms_to_dict(self):
                     '''
                     '''
+                    ignored = ('parameters', 'type', 'polymorphic_ctype', 'configuration_ptr',
+                               'created_date', 'programmed_date')
                     data = {}
                     for field in self._meta.fields:
+                        if field.name in ignored:
+                            continue
                         data[field.name] = '{}'.format(field.value_from_object(self))
-                    data.pop('parameters')
                     data['lines'] = []
                     for line in self.get_lines():
                         line_data = json.loads(line.params)
                         if 'TX_ref' in line_data and line_data['TX_ref'] not in (0, '0'):
                             line_data['TX_ref'] = RCLine.objects.get(pk=line_data['TX_ref']).get_name()
                         if 'code' in line_data:
                             line_data['code'] = RCLineCode.objects.get(pk=line_data['code']).name
                         line_data['type'] = line.line_type.name
                         data['lines'].append(line_data)
                     data['delays'] = self.get_delays()
                     data['pulses'] = self.get_pulses()
                     return data
                 def dict_to_parms(self, 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.clean_lines()
                     lines = []
                     positions = {'tx':0, 'tr':0}
                     for i, line_data in enumerate(data['lines']):
                         line_type = RCLineType.objects.get(name=line_data.pop('type'))
                         if line_type.name=='codes':
                             code = RCLineCode.objects.get(name=line_data['code'])
                             line_data['code'] = code.pk
                         line = RCLine.objects.filter(rc_configuration=self, channel=i)
                         if line:
                             line = line[0]
                             line.line_type = line_type
                             line.params = json.dumps(line_data)
                         else:
                             line = RCLine(rc_configuration=self, line_type=line_type,
                                           params=json.dumps(line_data),
                                           channel=i)
                         if line_type.name=='tx':
                             line.position = positions['tx']
                             positions['tx'] += 1
                         if line_type.name=='tr':
                             line.position = positions['tr']
                             positions['tr'] += 1
                         line.save()
                         lines.append(line)
                     for line, line_data in zip(lines, data['lines']):
                         if 'TX_ref' in line_data:
                             params = json.loads(line.params)
                             if line_data['TX_ref'] in (0, '0'):
                                 params['TX_ref'] = '0'
                             else:
                                 params['TX_ref'] = [l.pk for l in lines if l.line_type.name=='tx' and l.get_name()==line_data['TX_ref']][0]
                             line.params = json.dumps(params)
                             line.save()
                 def get_delays(self):
-                    pulses = [line.get_pulses() for line in self.get_lines()]
+                    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.get_pulses() for line in self.get_lines()]
+                    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()
-                    line_points = [pulses_to_points(line.pulses_as_array()) for line in self.get_lines()]
+                    line_points = [line.pulses_as_points() for line in self.get_lines()]
                     line_points = [[(x, x+y) for x,y in tups] for tups in line_points]
                     line_points = [[t for x in tups for t in x] for tups in line_points]
                     states = [[1 if x in tups else 0 for tups in line_points] for x in points]
                     if binary:
                         states.reverse()
                         states = [int(''.join([str(x) for x in flips]), 2) for flips in states]
                     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):
                     '''
                     Create "dat" stream to be send to CR
                     '''
                     data = []
                     # create header
                     data.append(self.add_cmd('DISABLE'))
                     data.append(self.add_cmd('CONTINUE'))
                     data.append(self.add_cmd('RESTART'))
                     if self.control_sw:
                         data.append(self.add_cmd('SW_ONE'))
                     else:
                         data.append(self.add_cmd('SW_ZERO'))
                     if self.control_tx:
                         data.append(self.add_cmd('TX_ONE'))
                     else:
                         data.append(self.add_cmd('TX_ZERO'))
                     # write divider
                     data.append(self.add_cmd('CLOCK_DIVIDER'))
                     data.append(self.add_data(self.clock_divider))
                     # write delays
                     data.append(self.add_cmd('DELAY_START'))
                     # first delay is always zero
                     data.append(self.add_data(1))
                     delays = self.get_delays()
                     for delay in delays:
                         while delay>252:
                             data.append(self.add_data(253))
                             delay -= 253
                         data.append(self.add_data(delay))
                     # write flips
                     data.append(self.add_cmd('FLIP_START'))
                     states = self.get_pulses(binary=False)
                     for flips, delay in zip(states, delays):
                         flips.reverse()
                         flip = int(''.join([str(x) for x in flips]), 2)
                         data.append(self.add_data(flip+1))
                         while delay>252:
                             data.append(self.add_data(1))
                             delay -= 253
                     # write sampling period
                     data.append(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.append(self.add_data(dh))
                     # write enable
                     data.append(self.add_cmd('ENABLE'))
                     return '\n'.join(['{}'.format(x) for tup in data for x in tup])
                 def update_from_file(self, filename):
                     '''
                     Update instance from file
                     '''
                     f = RCFile(filename)
                     self.dict_to_parms(f.data)
+                    self.update_pulses()
+                    self.save()
                 def update_pulses(self):
                     for line in self.get_lines():
-                        if line.line_type.name=='tr':
-                            continue
                         line.update_pulses()
-                    for tr in self.get_lines(line_type__name='tr'):
+                def plot_pulses(self):
-                        tr.update_pulses()
+                    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, PreviewSaveTool
+                    lines = self.get_lines()
+                    max_value = self.ipp*self.km2unit*self.ntx
+                    N = len(lines)
+                    fig = plt.figure(figsize=(10, 2+N*0.5))
+                    ax = fig.add_subplot(111)
+                    labels = []
+                    for i, line in enumerate(lines):
+                        labels.append(line.get_name())
+                        l = ax.plot((0, max_value),(N-i-1, N-i-1))
+                        points = [(tup[0], tup[1]-tup[0]) for tup in line.pulses_as_points() if tup<>(0,0)]
+                        ax.broken_barh(points, (N-i-1, 0.5),
+                                       edgecolor=l[0].get_color(), facecolor='none')
+                    labels.reverse()
+                    ax.set_yticklabels(labels)
+                    plot = to_bokeh(fig, use_pandas=False)
+                    plot.tools = [PanTool(dimensions=['width']), WheelZoomTool(dimensions=['width']), ResetTool(), PreviewSaveTool()]
+                    return components(plot, CDN)
                 def status_device(self):
                     return 0
                 def stop_device(self):
                     answer = api.disable(ip = self.device.ip_address,
                                          port = self.device.port_address)
                     if answer[0] != "1":
                         self.message = answer[0:]
                         return 0
                     self.message = answer[2:]
                     return 1
                 def start_device(self):
                     answer = api.enable(ip = self.device.ip_address,
                                         port = self.device.port_address)
                     if answer[0] != "1":
                         self.message = answer[0:]
                         return 0
                     self.message = answer[2:]
                     return 1
                 def write_device(self):
                     answer = api.write_config(ip = self.device.ip_address,
                                              port = self.device.port_address,
                                              parms = self.parms_to_dict())
                     if answer[0] != "1":
                         self.message = answer[0:]
                         return 0
                     self.message = answer[2:]
                     return 1
             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 __unicode__(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 __unicode__(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)
                 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 __unicode__(self):
                     if self.rc_configuration:
                         return u'%s - %s' % (self.rc_configuration, self.get_name())
                 def clone(self, **kwargs):
                     self.pk = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def get_name(self):
                     chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+                    s = ''
                     if self.line_type.name in ('tx',):
-                        return '%s%s' % (self.line_type.name.upper(), chars[self.position])
+                        s = chars[self.position]
                     elif self.line_type.name in ('codes', 'windows', 'tr'):
-                        if 'TX_ref' not in json.loads(self.params):
+                        if 'TX_ref' in json.loads(self.params):
-                            return self.line_type.name.upper()
                             pk = json.loads(self.params)['TX_ref']
                             if pk in (0, '0'):
-                            refs = ','.join(chars[l.position] for l in self.rc_configuration.get_lines(line_type__name='tx'))
+                                s = ','.join(chars[l.position] for l in self.rc_configuration.get_lines(line_type__name='tx'))
-                            return '%s (%s)' % (self.line_type.name.upper(), refs)
                             else:
                                 ref = RCLine.objects.get(pk=pk)
-                            return '%s (%s)' % (self.line_type.name.upper(), chars[ref.position])
+                                s = chars[ref.position]
-                    elif self.line_type.name in ('flip', 'prog_pulses', 'sync', 'none', 'mix'):
-                        return '%s %s' % (self.line_type.name.upper(), self.channel)
+                    if s:
+                        return '{}({}) {}'.format(self.line_type.name.upper(), s, self.channel)
                     else:
-                        return self.line_type.name.upper()
+                        return '{} {}'.format(self.line_type.name.upper(), self.channel)
                 def get_lines(self, **kwargs):
                     return RCLine.objects.filter(rc_configuration=self.rc_configuration, **kwargs)
                 def pulses_as_array(self):
-                    return (np.fromstring(self.pulses, dtype=np.uint8)-48).astype(np.int8)
+                    y = np.zeros(self.rc_configuration.ntx*self.rc_configuration.ipp*self.rc_configuration.km2unit)
-                def get_pulses(self):
-                    X = self.pulses_as_array()
+                    for tup in ast.literal_eval(self.pulses):
+                        y[tup[0]:tup[1]] = 1
-                    d = X[1:]-X[:-1]
+                    return y.astype(np.int8)
-                    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]
+                def pulses_as_points(self):
-                    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)]
+                    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 + (tx_width + 1)/2 + params['first_height']*km2unit - params['resolution']*km2unit)
                     elif ref=='sub_baud':
                         return int(1 + params['first_height']*km2unit - params['resolution']*km2unit/2)
                     else:
                         return 0
-                def update_pulses(self, save=True, tr=False):
+                def update_pulses(self):
                     '''
                     Update pulses field
                     '''
                     km2unit = self.rc_configuration.km2unit
                     us2unit = self.rc_configuration.us2unit
                     ipp = self.rc_configuration.ipp
                     ntx = self.rc_configuration.ntx
                     ipp_u = int(ipp*km2unit)
-                    x = np.arange(0, ipp_u*ntx)
+                    y = []
                     if self.line_type.name=='tr':
-                        params = json.loads(self.params)
+                        tr_params = json.loads(self.params)
-                        if params['TX_ref'] in ('0', 0):
-                            txs = [tx.update_pulses(save=False, tr=True) for tx in self.get_lines(line_type__name='tx')]
+                        if tr_params['TX_ref'] in ('0', 0):
+                            txs = self.get_lines(line_type__name='tx')
                         else:
-                            txs = [tx.update_pulses(save=False, tr=True) for tx in RCLine.objects.filter(pk=params['TX_ref'])]
+                            txs = [RCLine.objects.filter(pk=tr_params['TX_ref'])]
-                        if len(txs)==0 or 0 in [len(tx) for tx in txs]:
-                            return
-                        y = np.any(txs, axis=0, out=np.ones(ipp_u*ntx))
+                        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':
-                            mask = create_mask(ranges, ipp_u, ntx, self.rc_configuration.sync)
+                                y_tx = self.mask_ranges(y_tx, ranges)
-                            y = y.astype(np.int8) & mask
+                            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)
                     elif self.line_type.name=='tx':
                         params = json.loads(self.params)
                         delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
-                        y = pulses(x, ipp_u, float(params['pulse_width'])*km2unit,
+                        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=int(self.rc_configuration.time_before*us2unit),
+                                            before=before,
-                                   after=int(self.rc_configuration.time_after*us2unit) if tr else 0,
+                                            after=after,
                                             sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]<>'0':
-                            mask = create_mask(ranges, ipp_u, ntx, self.rc_configuration.sync)
+                                y = self.mask_ranges(y, ranges)
-                            y = y & mask
                     elif self.line_type.name=='flip':
-                        width = float(json.loads(self.params)['number_of_flips'])*ipp*km2unit
+                        n = float(json.loads(self.params)['number_of_flips'])
-                        y = pulses(x, 2*width, width)
+                        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]
-                        y = pulses_from_code(tx.pulses_as_array(),
+                        f = int(float(tx_params['pulse_width'])*km2unit)/len(params['codes'][0])
-                                             params['codes'],
+                        codes = [(np.fromstring(''.join([s*f for s in code]), dtype=np.uint8)-48).astype(np.int8) for code in params['codes']]
-                                             int(float(tx_params['pulse_width'])*km2unit))
+                        codes = [self.array_to_points(code) for code in codes]
+                        n = len(codes)
+                        for i, tup in enumerate(tx.pulses_as_points()):
+                            code = codes[i%n]
+                            y.extend([(c[0]+tup[0], c[1]+tup[0]) for c in code])
                         ranges = tx_params['range'].split(',')
                         if len(ranges)>0 and ranges[0]<>'0':
-                            mask = create_mask(ranges, ipp_u, ntx, self.rc_configuration.sync)
+                            y = self.mask_ranges(y, ranges)
-                            y = y.astype(np.int8) & mask
                     elif self.line_type.name=='sync':
                         params = json.loads(self.params)
-                        y = np.zeros(ipp_u*ntx)
+                        n = ipp_u*ntx
                         if params['invert'] in ('1', 1):
-                            y[-1] = 1
+                            y = [(n-1, n)]
                         else:
-                            y[0] = 1
+                            y = [(0, 1)]
                     elif self.line_type.name=='prog_pulses':
                         params = json.loads(self.params)
                         if int(params['periodic'])==0:
-                            nntx = ntx
-                        else:
                             nntx = 1
+                            nipp = ipp_u*ntx
+                        else:
+                            nntx = ntx
+                            nipp = ipp_u
                         if 'params' in params and len(params['params'])>0:
-                            y = sum([pulses(x, ipp_u*nntx, (pp['end']-pp['begin']), shift=pp['begin']) for pp in params['params']])
+                            for p in params['params']:
-                        else:
+                                y_pp = self.points(nntx, nipp,
-                            y = np.zeros(ipp_u*ntx)
+                                                   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:
-                            y = sum([pulses(x, ipp_u, pp['resolution']*pp['number_of_samples']*km2unit,
+                            tr_params = json.loads(self.get_lines(line_type__name='tr')[0].params)
-                                            shift=0,
+                            tr_ranges = tr_params['range'].split(',')
-                                            before=int(self.rc_configuration.time_before*us2unit)+self.get_win_ref(pp, params['TX_ref'],km2unit),
+                            for p in params['params']:
-                                            sync=self.rc_configuration.sync) for pp in params['params']])
+                                y_win = self.points(ntx, ipp_u,
-                            tr = self.get_lines(line_type__name='tr')[0]
+                                                    p['resolution']*p['number_of_samples']*km2unit,
-                            ranges = json.loads(tr.params)['range'].split(',')
+                                                    before=int(self.rc_configuration.time_before*us2unit)+self.get_win_ref(p, params['TX_ref'], km2unit),
-                            if len(ranges)>0 and ranges[0]<>'0':
+                                                    sync=self.rc_configuration.sync)
-                                mask = create_mask(ranges, ipp_u, ntx, self.rc_configuration.sync)
-                                y = y & mask
+                                if len(tr_ranges)>0 and tr_ranges[0]<>'0':
-                        else:
+                                    y_win = self.mask_ranges(y_win, tr_ranges)
-                            y = np.zeros(ipp_u*ntx)
+                                y.extend(y_win)
                     elif self.line_type.name=='mix':
                         values = self.rc_configuration.parameters.split('-')
                         confs = RCConfiguration.objects.filter(pk__in=[value.split('|')[0] for value in values])
                         modes = [value.split('|')[1] for value in values]
                         delays = [value.split('|')[2] for value in values]
                         masks = [value.split('|')[3] for value in values]
                         y = confs[0].get_lines(channel=self.channel)[0].pulses_as_array()
+                        ysize = len(y)
                         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 delay>0:
                                 y_temp = np.empty_like(Y)
                                 y_temp[:delay] = 0
                                 y_temp[delay:] = Y[:-delay]
+                            y_tempsize = len(y_temp)
                             if modes[i]=='OR':
-                                y2 = y | y_temp
+                                y = y | y_temp
                             elif modes[i]=='XOR':
-                                y2 = y ^ y_temp
+                                y = y ^ y_temp
                             elif modes[i]=='AND':
-                                y2 = y & y_temp
+                                y = y & y_temp
                             elif modes[i]=='NAND':
-                                y2 = y & ~y_temp
+                                y = y & ~y_temp
-                            y = y2
+                        y = self.array_to_points(y)
                     else:
-                        y = np.zeros(ipp_u*ntx)
+                        y = []
-                    if save:
+                    self.pulses = y
-                        self.pulses = (y+48).astype(np.uint8).tostring()
                     self.save()
+                @staticmethod
+                def array_to_points(X):
+                    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 = [(ipp*x+before+delay[x%delays], ipp*x+width+before+delay[x%delays]+after) for x in range(ntx)]
+                    return Y    
  No newline at end of file

apps/rc/urls.py +1 -1

             from django.conf.urls import url
             urlpatterns = (
                 url(r'^(?P<conf_id>-?\d+)/$', 'apps.rc.views.conf', name='url_rc_conf'),
                 url(r'^(?P<conf_id>-?\d+)/import/$', 'apps.rc.views.import_file', name='url_import_rc_conf'),
                 url(r'^(?P<conf_id>-?\d+)/edit/$', 'apps.rc.views.conf_edit', name='url_edit_rc_conf'),
-                url(r'^(?P<conf_id>-?\d+)/plot/$', 'apps.rc.views.view_pulses', name='url_plot_rc_pulses'),
+                url(r'^(?P<conf_id>-?\d+)/plot/$', 'apps.rc.views.plot_pulses', name='url_plot_rc_pulses'),
                 url(r'^(?P<id_conf>-?\d+)/write/$', 'apps.main.views.dev_conf_write', name='url_write_rc_conf'),
                 url(r'^(?P<id_conf>-?\d+)/read/$', 'apps.main.views.dev_conf_read', name='url_read_rc_conf'),
                 url(r'^(?P<conf_id>-?\d+)/add_line/$', 'apps.rc.views.add_line', name='url_add_rc_line'),
                 url(r'^(?P<conf_id>-?\d+)/add_line/(?P<line_type_id>-?\d+)/$', 'apps.rc.views.add_line', name='url_add_rc_line'),
                 url(r'^(?P<conf_id>-?\d+)/add_line/(?P<line_type_id>-?\d+)/code/(?P<code_id>-?\d+)/$', 'apps.rc.views.add_line', name='url_add_rc_line_code'),
                 url(r'^(?P<conf_id>-?\d+)/update_position/$', 'apps.rc.views.update_lines_position', name='url_update_rc_lines_position'),
                 url(r'^(?P<conf_id>-?\d+)/line/(?P<line_id>-?\d+)/delete/$', 'apps.rc.views.remove_line', name='url_remove_rc_line'),
                 url(r'^(?P<conf_id>-?\d+)/line/(?P<line_id>-?\d+)/add_subline/$', 'apps.rc.views.add_subline', name='url_add_rc_subline'),
                 url(r'^(?P<conf_id>-?\d+)/line/(?P<line_id>-?\d+)/codes/$', 'apps.rc.views.edit_codes', name='url_edit_rc_codes'),
                 url(r'^(?P<conf_id>-?\d+)/line/(?P<line_id>-?\d+)/codes/(?P<code_id>-?\d+)/$', 'apps.rc.views.edit_codes', name='url_edit_rc_codes'),
                 url(r'^(?P<conf_id>-?\d+)/line/(?P<line_id>-?\d+)/subline/(?P<subline_id>-?\d+)/delete/$', 'apps.rc.views.remove_subline', name='url_remove_rc_subline'),
             )

apps/rc/utils.py 0 -109

             import json
-            import numpy as np
-            import matplotlib.pyplot as plt
             class RCFile(object):
                 '''
                 Class to handle Radar controller configuration files
                 '''
                 def __init__(self, f=None):
                     self.data = {}
                     if isinstance(f, str):
                         self.f = open(f)
                         self.name = f.split('/')[-1]
                     elif hasattr(f, 'read'):
                         self.f = f
                         self.name = f.name.split('/')[-1]
                     else:
                         self.f = f
                         self.name = None
                     if self.f:
                         if 'racp' in self.name:
                             self.parse_racp()
                         elif 'dat' in self.name:
                             self.parse_dat()
                         elif 'json' in self.name:
                             self.data = json.load(self.f)
                     self.f.close()
                 def get_line_parameters(self, data, line):
                     line_params = {}
                     for label in data:
                         if 'L%d' % line in label or '(Line %d)' % line in label or 'Line%d' % line in label:
                             line_params[label] = data[label]
                     return line_params
                 def parse_racp(self):
                     data = {}
                     raw_data =  [s.strip() for s in self.f.readlines()]
                     for line in raw_data:
                         if line and '=' in line:
                             label, value = line.strip().split('=')
                             data[label] = value
                     self.data['experiment_type'] = data['EXPERIMENT TYPE']
                     self.data['header_version'] = data['HEADER VERSION']
                     self.data['name'] = data['EXPERIMENT NAME']
                     self.data['ipp'] = float(data['IPP'])
                     self.data['ntx'] = int(data['NTX'])
                     if 'CLOCK DIVIDER' in data:
                         self.data['clock_divider'] = int(data['CLOCK DIVIDER'])
                     else:
                         self.data['clock_divider'] = 1
                     self.data['clock_in'] = float(data['RELOJ'])*self.data['clock_divider']
                     self.data['clock'] = float(data['RELOJ'])
                     self.data['time_before'] = int(data['TR_BEFORE'])
                     self.data['time_after'] = int(data['TR_AFTER'])
                     if 'SYNCHRO DELAY' in data:
                         self.data['sync'] = int(data['SYNCHRO DELAY'])
                     else:
                         self.data['sync'] = 0
                     self.data['lines'] = []
                     if 'SAMPLING REFERENCE' in data:
                         if data['SAMPLING REFERENCE']=='MIDDLE OF FIRST BAUD':
                             self.data['sampling_reference'] = 'first_baud'
                         elif data['SAMPLING REFERENCE']=='MIDDLE OF FIRST SUB-BAUD':
                             self.data['sampling_reference'] = 'sub_baud'
                         else:
                             self.data['sampling_reference'] = 'none'
                     #Add TR line
                     if 'Pulse selection_TR' in data:
                         if 'A,' in data['Pulse selection_TR']:
                             rng = data['Pulse selection_TR'].replace('A,', '')
                             ref = 'TXA'
                         elif 'A' in data['Pulse selection_TR']:
                             rng = data['Pulse selection_TR'].replace('A', '')
                             ref = 'TXA'
                         elif 'B,' in data['Pulse selection_TR']:
                             rng = data['Pulse selection_TR'].replace('B,', '')
                             ref = 'TXB'
                         elif 'B' in data['Pulse selection_TR']:
                             rng = data['Pulse selection_TR'].replace('B', '')
                             ref = 'TXB'
                         else:
                             rng = data['Pulse selection_TR']
                             ref = '0'
                         line = {'type':'tr', 'range': rng if rng else '0', 'TX_ref':ref}
                     else:
                         line = {'type': 'tr', 'range': '0', 'TX_ref': '0'}
                     self.data['lines'].append(line)
                     #Add TX's lines
                     if 'TXA' in data:
                         line = {'type':'tx', 'pulse_width':data['TXA'], 'delays':'0'}
                         if 'Pulse selection_TXA' in data:
                             line['range'] = data['Pulse selection_TXA']
                         else:
                             line['range'] = '0'
                         self.data['lines'].append(line)
                     else:
                         self.data['lines'].append({'type':'tx', 'pulse_width':'0', 'delays':'0', 'range':'0'})
                     if 'TXB' in data:
                         line = {'type':'tx', 'pulse_width':data['TXB'], 'delays':'0'}
                         if 'Pulse selection_TXB' in data:
                             line['range'] = data['Pulse selection_TXB']
                         else:
                             line['range'] = '0'
                         if 'Number of Taus' in data:
                             delays = [data['TAU({0})'.format(i)] for i in range(int(data['Number of Taus']))]
                             line['delays'] = ','.join(delays)
                         self.data['lines'].append(line)
                     else:
                         self.data['lines'].append({'type':'tx', 'pulse_width':'0', 'delays':'0', 'range':'0'})
                     #Add Other lines (4-6)
                     for n in range(4, 7):
                         params = self.get_line_parameters(data, n)
                         labels = params.keys()
                         if 'L%d_FLIP' % n in labels:
                             line = {'type':'flip', 'number_of_flips':data['L%d_FLIP' % n]}
                         elif 'Code Type' in data and n==4:
                             line = {'type':'codes', 'code':data['Code Type'], 'TX_ref':data['L%d_REFERENCE' % n]}
                             if 'Number of Codes' in data:
                                 line['codes'] = [data['COD({})'.format(x)] for x in range(int(data['Number of Codes']))]
                         elif 'Code Type (Line %d)' % n in labels:
                             line = {'type':'codes', 'code':data['Code Type (Line %d)' % n], 'TX_ref':data['L%d_REFERENCE' % n]}
                             if 'Number of Codes (Line %d)' % n in data:
                                 line['codes'] = [data['L{}_COD({})'.format(n, x)] for x in range(int(data['Number of Codes (Line %d)' % n]))]
                         elif 'Sampling Windows (Line %d)' % n in data:
                             line = {'type':'windows', 'TX_ref':data['L%d_REFERENCE' % n]}
                             windows = []
                             for w in range(int(data['Sampling Windows (Line %d)' % n])):
                                 windows.append({'first_height':float(data['L%d_H0(%d)' % (n, w)]),
                                      'number_of_samples':int(data['L%d_NSA(%d)' % (n, w)]),
                                      'resolution':float(data['L%d_DH(%d)' % (n, w)])}
                                     )
                             line['params'] = windows
                         elif 'Line%d' % n in labels and data['Line%d' % n]=='Synchro':
                             line = {'type':'sync', 'invert':0}
                         elif 'L%d Number Of Portions' % n in labels:
                             line = {'type':'prog_pulses'}
                             if 'L%s Portions IPP Periodic' % n in data:
                                 line['periodic'] = 1 if data['L%s Portions IPP Periodic' % n]=='YES' else 0
                             portions = []
                             x = raw_data.index('L%d Number Of Portions=%s' % (n, data['L%d Number Of Portions' % n]))
                             for w in range(int(data['L%d Number Of Portions' % n])):
                                 begin = raw_data[x+1+2*w].split('=')[-1]
                                 end = raw_data[x+2+2*w].split('=')[-1]
                                 portions.append({'begin':int(begin),
                                      'end':int(end)}
                                     )
                             line['params'] = portions
                         elif 'FLIP1' in data and n==5:
                             line = {'type':'flip', 'number_of_flips':data['FLIP1']}
                         elif 'FLIP2' in data and n==6:
                             line = {'type':'flip', 'number_of_flips':data['FLIP2']}
                         else:
                             line = {'type':'none'}
                         self.data['lines'].append(line)
                     #Add line 7 (windows)
                     if 'Sampling Windows' in data:
                         line = {'type':'windows', 'TX_ref':data['L7_REFERENCE']}
                         windows = []
                         x = raw_data.index('Sampling Windows=%s' % data['Sampling Windows'])
                         for w in range(int(data['Sampling Windows'])):
                             h0 = raw_data[x+1+3*w].split('=')[-1]
                             nsa = raw_data[x+2+3*w].split('=')[-1]
                             dh = raw_data[x+3+3*w].split('=')[-1]
                             windows.append({'first_height':float(h0),
                                  'number_of_samples':int(nsa),
                                  'resolution':float(dh)}
                                 )
                         line['params'] = windows
                         self.data['lines'].append(line)
                     else:
                         self.data['lines'].append({'type':'none'})
                     #Add line 8 (synchro inverted)
                     self.data['lines'].append({'type':'sync', 'invert':1})
                     return
                 def parse_dat(self):
                     pass
                 def get_json(self, indent=None):
                     return json.dumps(self.data, indent=indent)
-            def pulses_to_points(X):
-                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]-tup[0]) for tup in zip(up, dw)]
-            def pulses_from_code(X, codes, width):
-                d = X[1:]-X[:-1]
-                up = np.where(d==1)[0]
-                if X[0]==1:
-                    up = np.concatenate((np.array([-1]), up))
-                up += 1
-                f = width/len(codes[0])
-                codes = [(np.fromstring(''.join([s*f for s in code]), dtype=np.uint8)-48).astype(np.int8) for code in codes]
-                y = np.zeros(len(X))
-                j=0
-                n = len(codes)
-                for i in up:
-                    y[i:i+width] = codes[j%n]
-                    j += 1
-                return y
-            def create_mask(ranges, ipp, ntx, sync):
-                x = np.arange(ipp*ntx)
-                iranges = set()
-                for index in ranges:
-                    if '-' in index:
-                        args = [int(a) for a in index.split('-')]
-                        iranges = iranges.union([i for i in range(args[0], args[1]+1)])
-                    else:
-                        iranges.add(int(index))
-                y = np.any([(x>=(idx-1)*ipp+sync) & (x<idx*ipp+sync) for idx in iranges], axis=0).astype(np.int8)
-                return y
-            def pulses(X, period, width, delay=0, before=0, after=0, sync=0, shift=0):
-                delay_array = delay
-                if isinstance(delay, (list, tuple)):
-                    delay_array = np.ones(len(X))
-                    delays = [d for __ in xrange(len(X)/(period*len(delay))) for d in delay]
-                    for i, delay in enumerate(delays):
-                        delay_array[np.arange(period*i, period*(i+1))] *= delay
-                if after>0:
-                    width += after+before
-                    before = 0
-                Y = ((X%period<width+delay_array+before+sync) & (X%period>=delay_array+before+sync)).astype(np.int8)
-                if shift>0:
-                    y = np.empty_like(Y)
-                    y[:shift] = 0
-                    y[shift:] = Y[:-shift]
-                    return y
-                else:
-                    return Y
-            def plot_pulses(unit, maximun, lines):
-                from bokeh.resources import CDN
-                from bokeh.embed import components
-                from bokeh.mpl import to_bokeh
-                from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, PreviewSaveTool
-                N = len(lines)
-                fig = plt.figure(figsize=(10, 2+N*0.5))
-                ax = fig.add_subplot(111)
-                labels = []
-                for i, line in enumerate(lines):
-                    labels.append(line.get_name())
-                    l = ax.plot((0, maximun),(N-i-1, N-i-1))
-                    ax.broken_barh(pulses_to_points(line.pulses_as_array()), (N-i-1, 0.5),
-                                   edgecolor=l[0].get_color(), facecolor='none')
-                labels.reverse()
-                ax.set_yticklabels(labels)
-                plot = to_bokeh(fig, use_pandas=False)
-                plot.tools = [PanTool(dimensions=['width']), WheelZoomTool(dimensions=['width']), ResetTool(), PreviewSaveTool()]
-                return components(plot, CDN)

apps/rc/views.py +9 -24

             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 apps.main.models import Configuration, Experiment, Device
             from apps.main.views import sidebar
             from .models import RCConfiguration, RCLine, RCLineType, RCLineCode
             from .forms import RCConfigurationForm, RCLineForm, RCLineViewForm, RCLineEditForm, RCImportForm, RCLineCodesForm
-            from .utils import plot_pulses
             def conf(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                 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['dev_conf'] = conf
                 kwargs['rc_lines'] = lines
                 kwargs['dev_conf_keys'] = ['name', 'ipp', 'ntx', 'clock_in', 'clock_divider', 'clock',
                                            'time_before', 'time_after', 'sync', 'sampling_reference', 'control_tx', 'control_sw']
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'rc_conf.html', kwargs)
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                 for line in lines:
                     params = json.loads(line.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
                 if request.method=='GET':
                     form = RCConfigurationForm(instance=conf)
                 elif request.method=='POST':
                     line_data = {}
                     conf_data = {}
                     extras = []
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
                             conf_data[label] = value
                             continue
                         elif label.split('|')[0]<>'-1':
                             extras.append(label)
                             continue
                         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}
                     #update conf
                     form = RCConfigurationForm(conf_data, instance=conf)
                     if form.is_valid():
                         form.save()
                         #update lines fields
                         extras.sort()
                         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)
                             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['rc_lines'] = lines
                 kwargs['edit'] = True
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['previous'] = conf.get_absolute_url()
                 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_view'] = True
                 kwargs['title'] = 'Confirm delete'
                 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)
                 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)
                         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}
                     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:
+                        try:
-                        if True:
                             conf.update_from_file(request.FILES['file_name'])
-                            conf.save()
-                            for line in conf.get_lines():
-                                if line.line_type.name=='tr':
-                                    continue
-                                line.update_pulses()
-                            for tr in conf.get_lines('tr'):
-                                tr.update_pulses()
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
-                            return redirect(conf.get_absolute_url())
+                            return redirect(conf.get_absolute_url_edit())
-                        #except Exception as e:
+                        except Exception as e:
-                        #    messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], e))
+                            messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], 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 view_pulses(request, conf_id):
+            def plot_pulses(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
-                lines = RCLine.objects.filter(rc_configuration=conf)
-                unit = (conf.clock/conf.clock_divider)*3./20
-                N = conf.ipp*conf.km2unit*conf.ntx
+                script, div = conf.plot_pulses()
-                script, div = plot_pulses(unit, N, lines)
                 kwargs = {}
                 kwargs['title'] = 'RC Pulses'
                 kwargs['suptitle'] = conf.name
                 kwargs['div'] = mark_safe(div)
                 kwargs['script'] = mark_safe(script)
+                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)

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