##// END OF EJS Templates
radarsys
RSS
JARS model experiment is optional
Juan C. Espinoza -
r308:4f3abdc3b0dc
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,115 +1,115
1 1 import os
2 2
3 3 from django import forms
4 4 from apps.main.models import Device, Experiment
5 5 from .models import JARSConfiguration, JARSfilter
6 6 from .widgets import SpectralWidget
7 7 from apps.main.forms import add_empty_choice
8 8
9 9 def create_choices_from_model(model, filter_id=None):
10 10
11 11 #instance = globals()[model]
12 12 choices = model.objects.all().values_list('pk', 'name')
13 13 choices = add_empty_choice(choices)
14 14 return choices
15 15
16 16 class JARSConfigurationForm(forms.ModelForm):
17 17 def __init__(self, *args, **kwargs):
18 18 super(JARSConfigurationForm, self).__init__(*args, **kwargs)
19 19 instance = getattr(self, 'instance', None)
20 20
21 21 if instance and instance.pk:
22 22 devices = Device.objects.filter(device_type__name='jars')
23 23
24 if instance.experiment:
25 experiments = Experiment.objects.filter(pk=instance.experiment.id)
26 self.fields['experiment'].widget.choices = [(experiment.id, experiment) for experiment in experiments]
24 #if instance.experiment:
25 # experiments = Experiment.objects.filter(pk=instance.experiment.id)
26 # self.fields['experiment'].widget.choices = [(experiment.id, experiment) for experiment in experiments]
27 27
28 28 self.fields['device'].widget.choices = [(device.id, device) for device in devices]
29 29 #self.fields['spectral'].widget = SpectralWidget()
30 30 self.fields['spectral_number'].widget.attrs['readonly'] = True
31 31 self.fields['spectral'].widget = SpectralWidget()
32 32
33 33 #-------------JARS Configuration needs an Experiment-----------------
34 def clean(self):
35 cleaned_data = super(JARSConfigurationForm, self).clean()
36 experiment = cleaned_data.get('experiment')
37 if not experiment:
38 msg = "Error: Jars Configuration needs an Experiment"
39 self.add_error('experiment', msg)
34 #def clean(self):
35 # cleaned_data = super(JARSConfigurationForm, self).clean()
36 # experiment = cleaned_data.get('experiment')
37 # if not experiment:
38 # msg = "Error: Jars Configuration needs an Experiment"
39 # self.add_error('experiment', msg)
40 40
41 41 class Meta:
42 42 model = JARSConfiguration
43 43 exclude = ('type', 'parameters', 'status', 'filter_parms')
44 44
45 45
46 46 class JARSfilterForm(forms.ModelForm):
47 47 def __init__(self, *args, **kwargs):
48 48 super(JARSfilterForm, self).__init__(*args, **kwargs)
49 49 instance = getattr(self, 'instance', None)
50 50
51 51 self.fields['fch_decimal'].widget.attrs['readonly'] = True
52 52
53 53 if 'initial' in kwargs:
54 54 if 'filter_id' not in kwargs['initial']:
55 55 self.fields.pop('name')
56 56 else:
57 57 self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter))
58 58 filter_id = kwargs['initial']['filter_id']
59 59
60 60 if filter_id == 0:
61 61 for value in self.fields:
62 62 if value != 'name':
63 63 self.fields.pop(value)
64 64 self.fields['name'].label = "Filter Template Name"
65 65 else:
66 66 self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter, kwargs['initial']['filter_id']))
67 67 jars_filter = JARSfilter.objects.get(pk=kwargs['initial']['filter_id'])
68 68 labels = [f.name for f in jars_filter._meta.get_fields()]
69 69
70 70 for label in ['id']:
71 71 labels.remove(label)
72 72 for label in labels:
73 73 self.fields['name'].initial = kwargs['initial']['filter_id']
74 74 self.fields[label].initial = getattr(jars_filter,label)
75 75 self.fields['name'].label = "Filter Template Name"
76 76
77 77 class Meta:
78 78 model = JARSfilter
79 79 exclude = ('type', 'parameters', 'status')
80 80
81 81
82 82 class ExtFileField(forms.FileField):
83 83 """
84 84 Same as forms.FileField, but you can specify a file extension whitelist.
85 85
86 86 >>> from django.core.files.uploadedfile import SimpleUploadedFile
87 87 >>>
88 88 >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
89 89 >>>
90 90 >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
91 91 >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
92 92 >>>
93 93 >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
94 94 Traceback (most recent call last):
95 95 ...
96 96 ValidationError: [u'Not allowed filetype!']
97 97 """
98 98 def __init__(self, *args, **kwargs):
99 99 extensions = kwargs.pop("extensions")
100 100 self.extensions = [i.lower() for i in extensions]
101 101
102 102 super(ExtFileField, self).__init__(*args, **kwargs)
103 103
104 104 def clean(self, *args, **kwargs):
105 105 data = super(ExtFileField, self).clean(*args, **kwargs)
106 106 filename = data.name
107 107 ext = os.path.splitext(filename)[1]
108 108 ext = ext.lower()
109 109 if ext not in self.extensions:
110 110 raise forms.ValidationError('Not allowed file type: %s' % ext)
111 111
112 112
113 113 class JARSImportForm(forms.Form):
114 114
115 115 file_name = ExtFileField(extensions=['.racp','.json'])
Show file before | Show file after | Hide comments
@@ -1,343 +1,343
1 1 import json
2 2 import requests
3 3
4 4 from django.db import models
5 5 from django.core.validators import MinValueValidator, MaxValueValidator
6 6 from django.core.urlresolvers import reverse
7 7
8 8 from apps.main.models import Configuration
9 9 from apps.main.utils import Params
10 10 from .utils import create_jarsfiles
11 11
12 12 # Create your models here.
13 13
14 14 EXPERIMENT_TYPE = (
15 15 (0, 'RAW_DATA'),
16 16 (1, 'PDATA'),
17 17 )
18 18
19 19 DATA_TYPE = (
20 20 (0, 'SHORT'),
21 21 (1, 'FLOAT'),
22 22 )
23 23
24 24 DECODE_TYPE = (
25 25 (0, 'None'),
26 26 (1, 'TimeDomain'),
27 27 (2, 'FreqDomain'),
28 28 (3, 'InvFreqDomain'),
29 29 )
30 30
31 31 class JARSfilter(models.Model):
32 32
33 33 JARS_NBITS = 32
34 34
35 35 name = models.CharField(max_length=60, unique=True, default='')
36 36 clock = models.FloatField(verbose_name='Clock In (MHz)',validators=[MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
37 37 mult = models.PositiveIntegerField(verbose_name='Multiplier',validators=[MinValueValidator(1), MaxValueValidator(20)], default=5)
38 38 fch = models.FloatField(verbose_name='Frequency (MHz)', validators=[MaxValueValidator(150)], null=True, default=49.9200)
39 39 fch_decimal = models.BigIntegerField(verbose_name='Frequency (Decimal)',validators=[MinValueValidator(-9223372036854775808), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
40 40 filter_2 = models.PositiveIntegerField(verbose_name='Filter 2',validators=[MinValueValidator(2), MaxValueValidator(100)], default = 10)
41 41 filter_5 = models.PositiveIntegerField(verbose_name='Filter 5',validators=[MinValueValidator(1), MaxValueValidator(100)], default = 1)
42 42 filter_fir = models.PositiveIntegerField(verbose_name='FIR Filter',validators=[MinValueValidator(1), MaxValueValidator(100)], default = 6)
43 43
44 44 class Meta:
45 45 db_table = 'jars_filters'
46 46
47 47 def __unicode__(self):
48 48 return u'%s' % (self.name)
49 49
50 50 def parms_to_dict(self):
51 51
52 52 parameters = {}
53 53
54 54 #parameters['name'] = self.name
55 55 parameters['clock'] = float(self.clock)
56 56 parameters['mult'] = int(self.mult)
57 57 parameters['fch'] = float(self.fch)
58 58 parameters['fch_decimal'] = int(self.fch)
59 59 parameters['filter_fir'] = int(self.filter_fir)
60 60 parameters['filter_2'] = int(self.filter_2)
61 61 parameters['filter_5'] = int(self.filter_5)
62 62
63 63 return parameters
64 64
65 65 def dict_to_parms(self, parameters):
66 66
67 67 #self.name = parameters['name']
68 68 self.clock = parameters['clock']
69 69 self.mult = parameters['mult']
70 70 self.fch = parameters['fch']
71 71 self.fch_decimal = parameters['fch_decimal']
72 72 self.filter_fir = parameters['filter_fir']
73 73 self.filter_2 = parameters['filter_2']
74 74 self.filter_5 = parameters['filter_5']
75 75
76 76
77 77 class JARSConfiguration(Configuration):
78 78
79 79 ADC_RESOLUTION = 8
80 80 PCI_DIO_BUSWIDTH = 32
81 81 HEADER_VERSION = 1103
82 82 BEGIN_ON_START = True
83 83 REFRESH_RATE = 1
84 84
85 85 exp_type = models.PositiveIntegerField(verbose_name='Experiment Type', choices=EXPERIMENT_TYPE, default=0)
86 86 cards_number = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[MinValueValidator(1), MaxValueValidator(4)], default = 1)
87 87 channels_number = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[MinValueValidator(1), MaxValueValidator(8)], default = 5)
88 88 channels = models.CharField(verbose_name='Channels', max_length=15, default = '1,2,3,4,5')
89 89 data_type = models.PositiveIntegerField(verbose_name='Data Type', choices=DATA_TYPE, default=0)
90 90 raw_data_blocks = models.PositiveIntegerField(verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=60)
91 91 profiles_block = models.PositiveIntegerField(verbose_name='Profiles Per Block', default=400)
92 92 acq_profiles = models.PositiveIntegerField(verbose_name='Acquired Profiles', default=400)
93 93 ftp_interval = models.PositiveIntegerField(verbose_name='FTP Interval', default=60)
94 94 fftpoints = models.PositiveIntegerField(verbose_name='FFT Points',default=16)
95 95 cohe_integr_str = models.PositiveIntegerField(verbose_name='Coh. Int. Stride',validators=[MinValueValidator(1)], default=30)
96 96 cohe_integr = models.PositiveIntegerField(verbose_name='Coherent Integrations',validators=[MinValueValidator(1)], default=30)
97 97 incohe_integr = models.PositiveIntegerField(verbose_name='Incoherent Integrations',validators=[MinValueValidator(1)], default=30)
98 98 decode_data = models.PositiveIntegerField(verbose_name='Decode Data', choices=DECODE_TYPE, default=0)
99 99 post_coh_int = models.BooleanField(verbose_name='Post Coherent Integration', default=False)
100 100 spectral_number = models.PositiveIntegerField(verbose_name='# Spectral Combinations',validators=[MinValueValidator(1)], default=1)
101 101 spectral = models.CharField(verbose_name='Combinations', max_length=5000, default = '[0, 0],')
102 102 create_directory = models.BooleanField(verbose_name='Create Directory Per Day', default=True)
103 103 include_expname = models.BooleanField(verbose_name='Experiment Name in Directory', default=False)
104 104 #view_raw_data = models.BooleanField(verbose_name='View Raw Data', default=True)
105 105 save_ch_dc = models.BooleanField(verbose_name='Save Channels DC', default=True)
106 106 save_data = models.BooleanField(verbose_name='Save Data', default=True)
107 107 filter_parms = models.CharField(max_length=10000, default='{"clock": 60, "mult": 5, "fch": 49.92, "fch_decimal": 721554506, "filter_fir": 2, "filter_2": 12, "filter_5": 25}')
108 108
109 109 class Meta:
110 110 db_table = 'jars_configurations'
111 111
112 112 def filter_resolution(self):
113 113 filter_parms = eval(self.filter_parms)
114 114 if filter_parms.__class__.__name__=='str':
115 115 filter_parms = eval(filter_parms)
116 116
117 117 filter_clock = float(filter_parms['clock'])
118 118 filter_2 = filter_parms['filter_2']
119 119 filter_5 = filter_parms['filter_5']
120 120 filter_fir = filter_parms['filter_fir']
121 121
122 122 resolution = round((filter_clock/(filter_2*filter_5*filter_fir)),2)
123 123 return resolution
124 124
125 125 def dict_to_parms(self, params, id=None):
126 126
127 127 if id is not None:
128 128 data = Params(params).get_conf(id_conf=id)
129 129 else:
130 130 data = Params(params).get_conf(dtype='jars')
131 131 data['filter_parms'] = params['filter_parms']
132 132
133 133 self.name = data['name']
134 134 self.exp_type = data['exp_type']
135 135 #----PDATA----
136 136 if self.exp_type == 1:
137 137 self.incohe_integr = data['incohe_integr']
138 138 self.spectral_number = data['spectral_number']
139 139 self.spectral = data['spectral']
140 140 self.fftpoints = data['fftpoints']
141 141 self.save_ch_dc = data['save_ch_dc']
142 142 else:
143 143 self.raw_data_blocks = data['raw_data_blocks']
144 144 #----PDATA----
145 145 self.cards_number = data['cards_number']
146 146 self.channels_number = data['channels_number']
147 147 self.channels = data['channels']
148 148 self.data_type = data['data_type']
149 149 self.profiles_block = data['profiles_block']
150 150 self.acq_profiles = data['acq_profiles']
151 151 self.ftp_interval = data['ftp_interval']
152 152 self.cohe_integr_str = data['cohe_integr_str']
153 153 self.cohe_integr = data['cohe_integr']
154 154 #----DECODE----
155 155 self.decode_data = data['decode_data']
156 156 self.post_coh_int = data['post_coh_int']
157 157 #----DECODE----
158 158 self.create_directory = data['create_directory']
159 159 self.include_expname = data['include_expname']
160 160 self.save_data = data['save_data']
161 161 self.filter_parms = json.dumps(data['filter_parms'])
162 162
163 163 self.save()
164 164
165 165 def parms_to_text(self, file_format='jars'):
166 166
167 167 data = self.experiment.parms_to_dict()
168 168
169 169 for key in data['configurations']['allIds']:
170 170 if data['configurations']['byId'][key]['device_type'] in ('dds', 'cgs'):
171 171 data['configurations']['allIds'].remove(key)
172 172 data['configurations']['byId'].pop(key)
173 173 elif data['configurations']['byId'][key]['device_type'] == 'jars':
174 174 data['configurations']['byId'][key] = self.parms_to_dict()['configurations']['byId'][str(self.pk)]
175 175 elif data['configurations']['byId'][key]['device_type'] == 'rc':
176 176 data['configurations']['byId'][key]['pulses'] = ''
177 177 data['configurations']['byId'][key]['delays'] = ''
178 178 rc_ids = [pk for pk in data['configurations']['allIds'] if data['configurations']['byId'][pk]['device_type']=='rc']
179 179 mix_ids = [pk for pk in rc_ids if data['configurations']['byId'][pk]['mix']]
180 180
181 181 if mix_ids:
182 182 params = data['configurations']['byId'][mix_ids[0]]['parameters']
183 183 rc = data['configurations']['byId'][params.split('-')[0].split('|')[0]]
184 184 rc['mix'] = True
185 185 data['configurations']['byId'][rc['id']] = rc
186 186 elif len(rc_ids)==0:
187 187 self.message = 'File needs RC configuration'
188 188 return ''
189 189
190 190 json_data = json.dumps(data)
191 191 racp_file, filter_file = create_jarsfiles(json_data)
192 192 if file_format=='racp':
193 193 return racp_file
194 194
195 195 return filter_file
196 196
197 197 def request(self, cmd, method='get', **kwargs):
198 198
199 199 req = getattr(requests, method)(self.device.url(cmd), **kwargs)
200 200 payload = req.json()
201 201 return payload
202 202
203 203 def status_device(self):
204 204
205 205 try:
206 206 payload = self.request('status',
207 207 params={'name': self.experiment.name})
208 208 self.device.status = payload['status']
209 209 self.device.save()
210 210 self.message = payload['message']
211 211 except Exception as e:
212 212 self.device.status = 0
213 213 self.message = str(e)
214 214 self.device.save()
215 215 return False
216 216
217 217 return True
218 218
219 219 def stop_device(self):
220 220
221 221 try:
222 222 payload = self.request('stop', 'post')
223 223 self.device.status = payload['status']
224 224 self.device.save()
225 225 self.message = payload['message']
226 226 except Exception as e:
227 227 self.device.status = 0
228 228 self.message = str(e)
229 229 self.device.save()
230 230 return False
231 231
232 232 return True
233 233
234 234 def read_device(self):
235 235
236 236 try:
237 237 payload = self.request('read', params={'name': self.experiment.name})
238 238 self.message = 'Configuration loaded'
239 239 except:
240 240 self.device.status = 0
241 241 self.device.save()
242 242 self.message = 'Could not read JARS configuration.'
243 243 return False
244 244
245 245 return payload
246 246
247 247 def write_device(self):
248 248
249 249 if self.device.status == 3:
250 250 self.message = 'Could not configure device. Software Acquisition is running'
251 251 return False
252 252
253 253 data = self.experiment.parms_to_dict()
254 254
255 255 for key in data['configurations']['allIds']:
256 256 if data['configurations']['byId'][key]['device_type'] in ('dds', 'cgs'):
257 257 data['configurations']['allIds'].remove(key)
258 258 data['configurations']['byId'].pop(key)
259 259 elif data['configurations']['byId'][key]['device_type'] == 'jars':
260 260 data['configurations']['byId'][key] = self.parms_to_dict()['configurations']['byId'][str(self.pk)]
261 261 elif data['configurations']['byId'][key]['device_type'] == 'rc':
262 262 data['configurations']['byId'][key]['pulses'] = ''
263 263 data['configurations']['byId'][key]['delays'] = ''
264 264 rc_ids = [pk for pk in data['configurations']['allIds'] if data['configurations']['byId'][pk]['device_type']=='rc']
265 265 mix_ids = [pk for pk in rc_ids if data['configurations']['byId'][pk]['mix']]
266 266 if mix_ids:
267 267 params = data['configurations']['byId'][mix_ids[0]]['parameters']
268 268 rc = data['configurations']['byId'][params.split('-')[0].split('|')[0]]
269 269 rc['mix'] = True
270 270 data['configurations']['byId'][rc['id']] = rc
271 271 elif len(rc_ids)==0:
272 272 self.message = 'Missing RC configuration'
273 273 return False
274 274
275 275 json_data = json.dumps(data)
276 print json_data
276
277 277 try:
278 278 payload = self.request('write', 'post', json=json_data)
279 279 self.device.status = payload['status']
280 280 self.message = payload['message']
281 281 self.device.save()
282 282 if self.device.status == 1:
283 283 return False
284 284
285 285 except Exception as e:
286 286 self.device.status = 0
287 287 self.message = str(e)
288 288 self.device.save()
289 289 return False
290 290
291 291 return True
292 292
293 293 def start_device(self):
294 294
295 295 try:
296 296 payload = self.request('start', 'post',
297 297 json={'name': self.experiment.name})
298 298 self.device.status = payload['status']
299 299 self.message = payload['message']
300 300 self.device.save()
301 301 if self.device.status == 1:
302 302 return False
303 303
304 304 except Exception as e:
305 305 self.device.status = 0
306 306 self.message = str(e)
307 307 self.device.save()
308 308 return False
309 309
310 310 return True
311 311
312 312
313 313 def get_log(self):
314 314
315 315 payload = None
316 316
317 317 try:
318 318 payload = requests.get(self.device.url('get_log'), params={'name':self.experiment.name})
319 319 except:
320 320 self.device.status = 0
321 321 self.device.save()
322 322 self.message = 'Jars API is not running.'
323 323 return False
324 324
325 325 self.message = 'Jars API is running'
326 326
327 327 return payload
328 328
329 329
330 330 def update_from_file(self, filename):
331 331
332 332 f = JARSFile(filename)
333 333 self.dict_to_parms(f.data)
334 334 self.save()
335 335
336 336 def get_absolute_url_import(self):
337 337 return reverse('url_import_jars_conf', args=[str(self.id)])
338 338
339 339 def get_absolute_url_read(self):
340 340 return reverse('url_read_jars_conf', args=[str(self.id)])
341 341
342 342 def get_absolute_url_log(self):
343 343 return reverse('url_get_jars_log', args=[str(self.id)])
General Comments 0
You need to be logged in to leave comments. Login now