This is a static copy of a profile reportHome
interpRegisters (1 call, 0.776 sec)
Generated 05-Aug-2011 13:00:46 using cpu time.
function in file /home/LeechJ/cbass_analysis/reduc/interpRegisters.m
Copy to new window for comparing multiple runs
Parents (calling functions)
| Function Name | Function Type | Calls |
| read_arc | function | 1 |
Lines where the most time was spent
| Line Number | Code | Calls | Total Time | % Time | Time Plot |
| 395 | iLoad = interp1(dcut.antenna0.... | 1 | 0.306 s | 39.4% |  |
| 377 | iAz = interp1(dcut.antenna0.se... | 1 | 0.153 s | 19.7% | |
| 379 | iEl = interp1(dcut.antenna0.se... | 1 | 0.131 s | 16.9% | |
| 228 | d.antenna0.servo.fast_az_pos =... | 1 | 0.055 s | 7.0% | |
| 56 | if(utcLength~=length(unique(d.... | 1 | 0.033 s | 4.2% | |
| All other lines | | | 0.098 s | 12.7% | |
| Totals | | | 0.776 s | 100% | |
Children (called functions)
| Function Name | Function Type | Calls | Total Time | % Time | Time Plot |
| interp1 | function | 9 | 0.678 s | 87.3% | |
| unique | function | 3 | 0.033 s | 4.2% | |
| Self time (built-ins, overhead, etc.) | | | 0.066 s | 8.5% | |
| Totals | | | 0.776 s | 100% | |
Code Analyzer results
No Code Analyzer messages.Coverage results
[ Show coverage for parent directory ]
| Total lines in function | 440 |
| Non-code lines (comments, blank lines) | 194 |
| Code lines (lines that can run) | 246 |
| Code lines that did run | 120 |
| Code lines that did not run | 126 |
| Coverage (did run/can run) | 48.78 % |
Function listing
time calls line
1 function d = interpRegisters(d)
2
3 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4 % function d = interpRegisters(d)
5 %
6 % only the cryocon and the az/el need to be interpolated
7 %
8 % Modified:
9 % 27-Jan-2011 (MAS) -- Made the interpolation of corrupted data more
10 % efficient.
11 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12
1 13 hasRx = 0;
1 14 hasCryo = 0;
1 15 hasServo= 0;
16 %display('interpRegisters');
1 17 if(isfield(d, 'antenna0'))
1 18 if(isfield(d.antenna0, 'servo'))
1 19 if(isfield(d.antenna0.servo, 'fast_az_pos'))
1 20 hasServo = 1;
1 21 end
1 22 end
23
1 24 if(isfield(d.antenna0, 'thermal'))
1 25 if(isfield(d.antenna0.thermal, 'ccTemperatureLoad'))
1 26 hasCryo = 1;
1 27 end
1 28 end
29
1 30 if(isfield(d.antenna0, 'receiver'))
1 31 if(isfield(d.antenna0.receiver, 'utc'))
1 32 hasRx = 1;
1 33 end
1 34 end
1 35 end
36
37 %display('interpRegisters1');
1 38 hasAny = hasServo + hasRx + hasCryo;
1 39 if(hasAny<2)
40 %display('Nothing to inpterpolate')
41 return;
42 end
43
0.01 1 44 if(~hasRx)
45 display('Nothing to interpolate')
46 return;
47 end
48
49
1 50 utcLength = length(d.antenna0.receiver.utc);
51
52 %display('interpRegisters2');
53 % check to see that the backend reported back data on time for the whole
54 % track -- at this point we know it has receiver data.
1 55 indRxBad = zeros(size(d.antenna0.receiver.utc));
0.03 1 56 if(utcLength~=length(unique(d.antenna0.receiver.utc)))
57 %display('interpRegisters3');
58 % look for where the frame was dropped
59 a = sort(d.antenna0.receiver.utc);
60 % Values with utc == 0 are flagged later.
61 % Don't bother putting these through the for loop. (MAS 27-Jan-2011)
62 f = diff(a)==0 & a(2:end) ~= 0;
63
64 % Just get the unique utc values. The old way repeated values in the
65 % following loop. (MAS 27-Jan-2011)
66 aUnique = unique(a(f));
67
68 % For loop modified to handle previous two changes. Should be much more
69 % efficient. (MAS 27-Jan-2011)
70 for m=1:length(aUnique)
71 ff = find(d.antenna0.receiver.utc == aUnique(m));
72 indRxBad(ff(2:length(ff))) = 1;
73 %display('interpRegisters4');
74 %length(ff)
75 %m
76 end
77 % display('interpRegisters5');
78 % check for zero values.
79 indRxBad = indRxBad | d.antenna0.receiver.utc==0;
80
81 % Now find the flagged regions. If several flagged points are adjacent,
82 % then this makes the following for loop much more efficient.
83 % (MAS 27-Jan-2011)
84 indRxBadStart = find(diff(indRxBad) > 0) + 1;
85 indRxBadEnd = find(diff(indRxBad) < 0);
86
87 if indRxBad(1) == 1
88 indRxBadStart = cat(1,1,indRxBadStart);
89 end
90 if indRxBad(end) == 1
91 indRxBadEnd = cat(1,indRxBadEnd,utcLength);
92 end
93
94
95 % fix the times in the servo and keep track of bad values.
96 ff = find(indRxBad);
97 timeDiff = median(diff(d.antenna0.receiver.utc(~indRxBad)));
98
99 % New for loop. Designed to be much more efficient in the case where
100 % several adjacent times are flagged. (MAS 27-Jan-2011)
101 for m=1:length(indRxBadStart)
102 interpLength = indRxBadEnd(m) - indRxBadStart(m) + 1;
103
104 if indRxBadStart(m) == 1 && indRxBadEnd(m) ~= utcLength
105 d.antenna0.receiver.utc(indRxBadStart(m):indRxBadEnd(m)) = ...
106 d.antenna0.receiver.utc(indRxBadEnd(m)+1) ...
107 - timeDiff * (interpLength:-1:1)';
108 elseif indRxBadStart(m) == 1 && indRxBadEnd(m) == utcLength
109 display('ALL OF YOUR BACKEND DATA ARE BAD');
110 display('DO NOT RELY ON THESE DATA FOR MAPMAKING');
111 d.antenna0.receiver.utc = nan(length(d.antenna0.receiver.utc), 1);
112 else
113 d.antenna0.receiver.utc(indRxBadStart(m):indRxBadEnd(m)) = ...
114 d.antenna0.receiver.utc(indRxBadStart(m)-1) ...
115 + timeDiff * (1:interpLength)';
116 end
117 end
118
119 % for m=1:length(ff)
120 % d.antenna0.receiver.utc(ff(m)) = d.antenna0.receiver.utc(ff(m)-1) + timeDiff;
121 % end
122 %display('interpRegisters5');
123 display('Number of bad backend times in track:');
124 display(sprintf('%i seconds out of %i seconds', length(ff)/100, ...
125 length(indRxBad)/100));
126
127 end
128
129 % first thing we have to do is check that the thermal and cryo times did not
130 % skip -- this happens in the servo's case when the 1PPS tick does not match
131 % the internal clock, and for the cryo when the gpib doesn't report back on
132 % time.
1 133 if(hasServo)
1 134 indServoBad = zeros(size(d.antenna0.servo.utc));
135 else
136 indServoBad = [];
137 end
138
139
1 140 if(hasServo)
141
1 142 utcLength = length(d.antenna0.servo.utc);
143
1 144 if(utcLength~=length(unique(d.antenna0.servo.utc)))
145 % this happens when the servo reports back the wrong number of samples,
146 % typically due to a 1PPS error.
147 a = sort(d.antenna0.servo.utc);
148 % Values with utc == 0 are flagged later.
149 % Don't bother putting these through the for loop. (MAS 27-Jan-2011)
150 f = diff(a)==0 & a(2:end) ~= 0;
151
152
153 % Just get the unique utc values. The old way repeated values in the
154 % following loop. (MAS 27-Jan-2011)
155 aUnique = unique(a(f));
156
157 % For loop modified to handle previous two changes. Should be much more
158 % efficient. (MAS 27-Jan-2011)
159 for m=1:length(aUnique)
160 ff = find(d.antenna0.servo.utc == aUnique(m));
161 indServoBad(ff(2:length(ff))) = 1;
162 end
163
164 % check for zero values in the time.
165 indServoBad = indServoBad | d.antenna0.servo.utc==0;
166
167
168 % Now find the flagged regions. If several flagged points are adjacent,
169 % then this makes the following for loop much more efficient.
170 % (MAS 27-Jan-2011)
171 indServoBadStart = find(diff(indServoBad) > 0) + 1;
172 indServoBadEnd = find(diff(indServoBad) < 0);
173
174 if indServoBad(1) == 1
175 indServoBadStart = cat(1,1,indServoBadStart);
176 end
177 if indServoBad(end) == 1
178 indServoBadEnd = cat(1,indServoBadEnd,utcLength);
179 end
180
181
182 % fix the times in the servo and keep track of bad values.
183 timeDiff = median(diff(d.antenna0.servo.utc(~indServoBad)));
184
185 % New for loop. Designed to be much more efficient in the case where
186 % several adjacent times are flagged. (MAS 27-Jan-2011)
187 for m=1:length(indServoBadStart)
188 interpLength = indServoBadEnd(m) - indServoBadStart(m) + 1;
189
190 if indServoBadStart(m) == 1 && indServoBadEnd(m) ~= utcLength
191 d.antenna0.servo.utc(indServoBadStart(m):indServoBadEnd(m)) = ...
192 d.antenna0.servo.utc(indServoBadEnd(m)+1) ...
193 - timeDiff * (interpLength:-1:1)';
194 elseif indServoBadStart(m) == 1 && indServoBadEnd(m) == utcLength
195 display('ALL OF YOUR SERVO DATA ARE BAD');
196 display('DO NOT RELY ON THESE DATA FOR MAPMAKING');
197 d.antenna0.servo.utc = nan(utcLength, 1);
198 else
199 d.antenna0.servo.utc(indServoBadStart(m):indServoBadEnd(m)) = ...
200 d.antenna0.servo.utc(indServoBadStart(m)-1) ...
201 + timeDiff * (1:interpLength)';
202 end
203 end
204
205 end
206
207
208 % for m=1:length(ff);
209 % d.antenna0.servo.utc(ff(m)) = d.antenna0.servo.utc(ff(m)-1) + timeDiff;
210 % end
211
1 212 ff = find(indServoBad);
213
0.01 1 214 if length(ff) ~= utcLength
215
216 % next we interpolate onto the new times, and keep track of them to flag.
1 217 utc = d.antenna0.servo.utc;
1 218 az_pos = d.antenna0.servo.fast_az_pos;
1 219 el_pos = d.antenna0.servo.fast_el_pos;
1 220 az_err = d.antenna0.servo.fast_az_err;
1 221 el_err = d.antenna0.servo.fast_el_err;
1 222 utc(ff) = [];
1 223 az_pos(ff) = [];
1 224 az_err(ff) = [];
1 225 el_pos(ff) = [];
1 226 el_err(ff) = [];
227
0.05 1 228 d.antenna0.servo.fast_az_pos = interp1(utc, az_pos, d.antenna0.servo.utc);
1 229 d.antenna0.servo.fast_az_err = interp1(utc, az_err, d.antenna0.servo.utc);
0.01 1 230 d.antenna0.servo.fast_el_pos = interp1(utc, el_pos, d.antenna0.servo.utc);
0.01 1 231 d.antenna0.servo.fast_el_err = interp1(utc, el_err, d.antenna0.servo.utc);
232 else
233
234 % In this case, these data are borked. Just put something here...
235 d.antenna0.servo.fast_az_pos = nan(utcLength,1);
236 d.antenna0.servo.fast_az_err = nan(utcLength,1);
237 d.antenna0.servo.fast_el_pos = nan(utcLength,1);
238 d.antenna0.servo.fast_el_err = nan(utcLength,1);
239 end
240
241
1 242 display('Number of bad servo times in track (due to noisy 1PPS):');
1 243 display(sprintf('%i seconds out of %i seconds', length(ff)/5, length(indServoBad)/5));
244
1 245 end
246
1 247 indCryoBad = zeros(size(d.antenna0.thermal.utc));
1 248 if(hasCryo)
249
1 250 utcLength = length(d.antenna0.thermal.utc);
251
1 252 if(utcLength~=length(unique(d.antenna0.thermal.utc)))
253 % this happens when the servo reports back the wrong number of samples,
254 % typically due to a 1PPS error.
255 a = sort(d.antenna0.thermal.utc);
256 % Values with utc == 0 are flagged later.
257 % Don't bother putting these through the for loop. (MAS 27-Jan-2011)
258 f = diff(a)==0 & a(2:end) ~= 0;
259
260
261 % Just get the unique utc values. The old way repeated values in the
262 % following loop. (MAS 27-Jan-2011)
263 aUnique = unique(a(f));
264
265 % For loop modified to handle previous two changes. Should be much more
266 % efficient. (MAS 27-Jan-2011)
267 for m=1:length(aUnique)
268 ff = find(d.antenna0.thermal.utc == aUnique(m));
269 indCryoBad(ff(2:length(ff))) = 1;
270 end
271
272
273 % check for zero values in the time.
274 indCryoBad = indCryoBad | d.antenna0.thermal.utc==0;
275
276
277 % Now find the flagged regions. If several flagged points are adjacent,
278 % then this makes the following for loop much more efficient.
279 % (MAS 27-Jan-2011)
280 indCryoBadStart = find(diff(indCryoBad) > 0) + 1;
281 indCryoBadEnd = find(diff(indCryoBad) < 0);
282
283 if indCryoBad(1) == 1
284 indCryoBadStart = cat(1,1,indCryoBadStart);
285 end
286 if indCryoBad(end) == 1
287 indCryoBadEnd = cat(1,indCryoBadEnd,utcLength);
288 end
289
290
291 % fix the times in the cryo and keep track of bad values.
292 timeDiff = median(diff(d.antenna0.thermal.utc(~indCryoBad)));
293
294 % New for loop. Designed to be much more efficient in the case where
295 % several adjacent times are flagged. (MAS 27-Jan-2011)
296 for m=1:length(indCryoBadStart)
297 interpLength = indCryoBadEnd(m) - indCryoBadStart(m) + 1;
298
299 if indCryoBadStart(m) == 1 && indCryoBadEnd(m) ~= utcLength
300 d.antenna0.thermal.utc(indCryoBadStart(m):indCryoBadEnd(m)) = ...
301 d.antenna0.thermal.utc(indCryoBadEnd(m)+1) ...
302 - timeDiff * (interpLength:-1:1)';
303 elseif indCryoBadStart(m) == 1 && indCryoBadEnd(m) == utcLength
304 display('ALL OF YOUR CRYO DATA ARE BAD');
305 display('DO NOT RELY ON THESE DATA FOR MAPMAKING');
306 d.antenna0.thermal.utc = nan(utcLength, 1);
307 else
308 d.antenna0.thermal.utc(indCryoBadStart(m):indCryoBadEnd(m)) = ...
309 d.antenna0.thermal.utc(indCryoBadStart(m)-1) ...
310 + timeDiff * (1:interpLength)';
311 end
312 end
313
314 end
315
316 % Same as before
1 317 ff = find(indCryoBad);
318
1 319 if length(ff) ~= utcLength
320
1 321 utc = d.antenna0.thermal.utc;
1 322 cryo = d.antenna0.thermal.ccTemperatureLoad;
1 323 utc(ff) = [];
1 324 cryo(ff) = [];
325
0.02 1 326 d.antenna0.thermal.ccTemperatureLoad = interp1(utc, cryo, ...
327 d.antenna0.thermal.utc);
328 else
329 d.antenna0.thermal.ccTemperatureLoad = nan(utcLength,1);
330 end
331
1 332 display('Number of bad cryocon times in track (due gpib communication dropout):');
1 333 display(sprintf('%i samples out of %i samples', length(find(indCryoBad)), length(indCryoBad)));
1 334 end
335
336 % now we have to interpolate the time of the servo utc onto the time of the
337 % thermal utc so we can match them up.
1 338 if(hasCryo && hasServo)
339 % match the missing servo times to the thermal sample, and vice-versa.
340 % this is most easily done by checking the difference between the servo
341 % and thermal utc (they should be roughly 1.05 seconds).
342
1 343 if(d.array.frame.utc(1)<55244)
344 % offset should be 0.5seconds higher
345 timeDiff = (d.antenna0.servo.utc - d.antenna0.thermal.utc)*24*60*60 - ...
346 0.45;
1 347 else
1 348 timeDiff = (d.antenna0.servo.utc - d.antenna0.thermal.utc)*24*60*60 + ...
349 0.05;
1 350 end
351
1 352 indBadBoth = abs(timeDiff)>=0.01 | indServoBad | indCryoBad;
353
1 354 indServoBad = indBadBoth;
1 355 indCryoBad = indBadBoth;
1 356 end
357
358 % we don't actually want to cut the data, we need to maintain it. we just
359 % want to flag it.
1 360 dcut = d;
361 % interpolate the servo and cryo onto the same timeframe as the receiver data
362
0.01 1 363 if(hasServo)
1 364 ff = find(indServoBad);
365 % check if all data is bad
1 366 if(length(ff) + 2 >= length(dcut.antenna0.servo.utc))
367 display('ALL OF YOUR SERVO DATA ARE BAD');
368 display('DO NOT RELY ON THESE DATA FOR MAPMAKING');
369 d.antenna0.servo.az = nan(length(d.antenna0.receiver.utc), 1);
370 d.antenna0.servo.el = nan(length(d.antenna0.receiver.utc), 1);
1 371 else
1 372 dcut.antenna0.servo.utc(ff) = [];
1 373 dcut.antenna0.servo.fast_az_pos(ff) = [];
1 374 dcut.antenna0.servo.fast_el_pos(ff) = [];
1 375 dcut.antenna0.servo.fast_az_err(ff) = [];
1 376 dcut.antenna0.servo.fast_el_err(ff) = [];
0.15 1 377 iAz = interp1(dcut.antenna0.servo.utc, dcut.antenna0.servo.fast_az_pos, ...
378 dcut.antenna0.receiver.utc);
0.13 1 379 iEl = interp1(dcut.antenna0.servo.utc, dcut.antenna0.servo.fast_el_pos, ...
380 dcut.antenna0.receiver.utc);
1 381 d.antenna0.servo.az = iAz;
1 382 d.antenna0.servo.el = iEl;
1 383 end
1 384 end
0.01 1 385 if(hasCryo)
1 386 ff = find(indCryoBad);
1 387 if(length(ff) + 2 >= length(dcut.antenna0.thermal.utc))
388 display('ALL OF YOUR CRYO DATA ARE BAD');
389 display('DO NOT RELY ON THESE DATA FOR MAPMAKING');
390 d.antenna0.thermal.coldLoad = nan(length(d.antenna0.receiver.utc), 1);
1 391 else
1 392 dcut.antenna0.thermal.utc(ff) = [];
1 393 dcut.antenna0.thermal.ccTemperatureLoad(ff) = [];
394
0.31 1 395 iLoad = interp1(dcut.antenna0.thermal.utc, ...
396 dcut.antenna0.thermal.ccTemperatureLoad,dcut.antenna0.receiver.utc, ...
397 'spline');
1 398 d.antenna0.thermal.coldLoad = iLoad;
1 399 end
1 400 end
401
402 % now we interpolate the servo and cryo con onto the same timescale.
403
1 404 dcut = d;
1 405 if(hasServo && hasCryo)
1 406 ff = find(indBadBoth);
1 407 utc = dcut.antenna0.thermal.utc;
1 408 utc(ff) = [];
1 409 load = dcut.antenna0.thermal.ccTemperatureLoad;
1 410 load(ff) = [];
411
412 % If all data are bad, if-then-else prevents crash. (MAS 27-Jan-2011).
1 413 if length(ff) ~= length(indBadBoth)
414 % interpolate the cryo onto the servo time.
1 415 iLoad2 = interp1(utc, load, dcut.antenna0.servo.utc);
1 416 d.antenna0.thermal.utc = d.antenna0.servo.utc;
1 417 d.antenna0.thermal.ccTemperatureLoad = iLoad2;
418 else
419 iLoad2 = nan(length(dcut.antenna0.servo.utc),1);
420 d.antenna0.thermal.utc = d.antenna0.servo.utc;
421 d.antenna0.thermal.ccTemperatureLoad = iLoad2;
422
423 end
0.01 1 424 end
425
1 426 if(hasServo)
1 427 d.flags.interpFlags.medium = indServoBad;
1 428 if(hasCryo)
1 429 d.flags.interpFlags.medium = indBadBoth;
1 430 end
431 elseif(hasCryo)
432 d.flags.interpFlags.medium = indCryoBad;
433 end
434
1 435 if(hasCryo)
1 436 d.flags.interpFlags.fast = indRxBad;
1 437 end
438
439
1 440 return;