Line data Source code
1 : /*
2 : * Vbi2MsRow.cc
3 : *
4 : * Created on: Aug 22, 2013
5 : * Author: jjacobs
6 : */
7 :
8 : #include <casacore/casa/Exceptions.h>
9 : #include <casacore/measures/Measures/MDirection.h>
10 : #include <msvis/MSVis/Vbi2MsRow.h>
11 : #include <msvis/MSVis/VisibilityIterator2.h>
12 : #include <msvis/MSVis/VisModelDataI.h>
13 : #include <msvis/MSVis/VisBufferImpl2.h>
14 : #include <msvis/MSVis/VisBufferImpl2Internal.h>
15 :
16 : #define AssertWritable() ThrowIf (! isWritable (), "Cannot write to this MsRow object")
17 :
18 : using casa::vi::VisBufferImpl2;
19 :
20 : using namespace casacore;
21 : namespace casa {
22 :
23 : namespace ms {
24 :
25 :
26 1148 : Vbi2MsRow::Vbi2MsRow (rownr_t row, const VisBufferImpl2 * vb)
27 : : MsRow (row, vb),
28 1148 : correctedCache_p (& VisBufferImpl2::visCubeCorrected),
29 1148 : flagCache_p (& VisBufferImpl2::flagCube),
30 1148 : modelCache_p(& VisBufferImpl2::visCubeModel),
31 1148 : observedCache_p(&VisBufferImpl2::visCube),
32 1148 : sigmaCache_p (&VisBufferImpl2::sigma),
33 1148 : sigmaSpectrumCache_p(& VisBufferImpl2::sigmaSpectrum),
34 1148 : weightCache_p (&VisBufferImpl2::weight),
35 1148 : weightSpectrumCache_p(& VisBufferImpl2::weightSpectrum),
36 2296 : vbi2_p (const_cast<VisBufferImpl2 *> (vb))
37 : {
38 1148 : configureArrayCaches ();
39 1148 : }
40 :
41 :
42 1267 : Vbi2MsRow::Vbi2MsRow (rownr_t row, VisBufferImpl2 * vb)
43 : : MsRow (row, vb),
44 1267 : correctedCache_p (& VisBufferImpl2::visCubeCorrected),
45 1267 : flagCache_p (& VisBufferImpl2::flagCube),
46 1267 : modelCache_p(& VisBufferImpl2::visCubeModel),
47 1267 : observedCache_p(&VisBufferImpl2::visCube),
48 1267 : sigmaCache_p (&VisBufferImpl2::sigma),
49 1267 : sigmaSpectrumCache_p(& VisBufferImpl2::sigmaSpectrum),
50 1267 : weightCache_p (&VisBufferImpl2::weight),
51 1267 : weightSpectrumCache_p(& VisBufferImpl2::weightSpectrum),
52 2534 : vbi2_p (vb)
53 : {
54 1267 : configureArrayCaches ();
55 1267 : }
56 :
57 : void
58 2415 : Vbi2MsRow::configureArrayCaches ()
59 : {
60 2415 : arrayCaches_p.push_back (& correctedCache_p);
61 2415 : arrayCaches_p.push_back (& flagCache_p);
62 2415 : arrayCaches_p.push_back (& modelCache_p);
63 2415 : arrayCaches_p.push_back (& observedCache_p);
64 2415 : arrayCaches_p.push_back (& sigmaCache_p);
65 2415 : arrayCaches_p.push_back (& sigmaSpectrumCache_p);
66 2415 : arrayCaches_p.push_back (& weightCache_p);
67 2415 : arrayCaches_p.push_back (& weightSpectrumCache_p);
68 2415 : }
69 :
70 : void
71 61375 : Vbi2MsRow::clearArrayCaches ()
72 : {
73 61375 : for (std::vector<CachedArrayBase *>::iterator i = arrayCaches_p.begin();
74 578256 : i != arrayCaches_p.end();
75 516881 : i ++){
76 516881 : (* i)->clearCache();
77 : }
78 61375 : }
79 :
80 : void
81 61375 : Vbi2MsRow::changeRow (rownr_t row)
82 : {
83 61375 : MsRow::changeRow (row);
84 61375 : clearArrayCaches ();
85 61375 : }
86 :
87 : ////////////////////////////////////////////////////////////
88 : //
89 : // Scalar getters
90 : //
91 :
92 : Int
93 45678 : Vbi2MsRow::antenna1 () const
94 : {
95 45678 : return vbi2_p->antenna1 () (row ());
96 : }
97 :
98 : Int
99 45678 : Vbi2MsRow::antenna2 () const
100 : {
101 45678 : return vbi2_p->antenna2 () (row ());
102 : }
103 :
104 : Int
105 20368 : Vbi2MsRow::arrayId () const
106 : {
107 20368 : return vbi2_p->arrayId () (row ());
108 : }
109 :
110 : Int
111 0 : Vbi2MsRow::correlationType () const
112 : {
113 0 : return vbi2_p->correlationTypes () (row ());
114 : }
115 :
116 :
117 : template <typename T, typename U>
118 : void
119 61104 : Vbi2MsRow::copyIf (Bool copyThis, Vbi2MsRow * other,
120 : void (Vbi2MsRow::* setter) (T),
121 : U (Vbi2MsRow::* getter) () const)
122 : {
123 61104 : if (copyThis){
124 31848 : (this ->* setter) ((other ->* getter) ());
125 : }
126 61104 : }
127 :
128 : void
129 10184 : Vbi2MsRow::copy (Vbi2MsRow * other,
130 : const VisBufferComponents2 & componentsToCopy)
131 : {
132 : // Copy the data contents of the other row into this one
133 :
134 10184 : setAntenna1 (other->antenna1 ());
135 10184 : setAntenna2 (other->antenna2 ());
136 10184 : setArrayId (other->arrayId ());
137 10184 : setDataDescriptionId (other->dataDescriptionId ());
138 10184 : setExposure (other->exposure ());
139 10184 : setFeed1 (other->feed1 ());
140 10184 : setFeed2 (other->feed2 ());
141 10184 : setFieldId (other->fieldId ());
142 10184 : setFlags (other->flags ());
143 10184 : setInterval (other->interval ());
144 10184 : setObservationId (other->observationId ());
145 10184 : setProcessorId (other->processorId ());
146 10184 : setRowFlag (other->isRowFlagged());
147 10184 : setRowId (other->rowId());
148 10184 : setScanNumber (other->scanNumber ());
149 10184 : setSigma (other->sigma ());
150 10184 : setSpectralWindow (other->spectralWindow());
151 10184 : setStateId (other->stateId ());
152 10184 : setTime (other->time ());
153 10184 : setTimeCentroid (other->timeCentroid ());
154 10184 : setUvw (other->uvw ());
155 10184 : setWeight (other->weight ());
156 :
157 : // Optionally copied fields
158 :
159 10184 : copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeCorrected), other,
160 : & Vbi2MsRow::setCorrected, & Vbi2MsRow::corrected );
161 10184 : copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeModel), other,
162 : & Vbi2MsRow::setModel, & Vbi2MsRow::model );
163 10184 : copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeObserved), other,
164 : & Vbi2MsRow::setObserved, & Vbi2MsRow::observed );
165 10184 : copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeFloat), other,
166 : & Vbi2MsRow::setSingleDishData, & Vbi2MsRow::singleDishData );
167 10184 : copyIf (componentsToCopy.contains (VisBufferComponent2::WeightSpectrum), other,
168 : & Vbi2MsRow::setWeightSpectrum, & Vbi2MsRow::weightSpectrum );
169 10184 : copyIf (componentsToCopy.contains (VisBufferComponent2::SigmaSpectrum), other,
170 : & Vbi2MsRow::setSigmaSpectrum, & Vbi2MsRow::sigmaSpectrum );
171 10184 : }
172 :
173 :
174 : Int
175 20368 : Vbi2MsRow::dataDescriptionId () const
176 : {
177 20368 : return vbi2_p->dataDescriptionIds () (row ());
178 : }
179 :
180 : Int
181 20368 : Vbi2MsRow::feed1 () const
182 : {
183 20368 : return vbi2_p->feed1 () (row ());
184 : }
185 :
186 : Int
187 20368 : Vbi2MsRow::feed2 () const
188 : {
189 20368 : return vbi2_p->feed2 () (row ());
190 : }
191 :
192 : Int
193 20368 : Vbi2MsRow::fieldId () const
194 : {
195 20368 : return vbi2_p->fieldId () (row ());
196 : }
197 :
198 : VisBufferImpl2 *
199 35494 : Vbi2MsRow::getVbi () const
200 : {
201 35494 : return vbi2_p;
202 : }
203 :
204 :
205 : Bool
206 35494 : Vbi2MsRow::isRowFlagged () const
207 : {
208 35494 : return vbi2_p->flagRow () (row ());
209 : }
210 :
211 : const Matrix<Bool> &
212 81604 : Vbi2MsRow::flags () const
213 : {
214 81604 : return flagCache_p.getCachedPlane (vbi2_p, row());
215 : }
216 :
217 : Matrix<Bool> &
218 50620 : Vbi2MsRow::flagsMutable ()
219 : {
220 50620 : return flagCache_p.getCachedPlane (vbi2_p, row());
221 : }
222 :
223 : Bool
224 0 : Vbi2MsRow::isFlagged (Int correlation, Int channel) const
225 : {
226 0 : return vbi2_p->flagCube () (correlation,channel, row ());
227 : }
228 :
229 :
230 : Int
231 20368 : Vbi2MsRow::observationId () const
232 : {
233 20368 : return vbi2_p->observationId () (row ());
234 : }
235 :
236 : Int
237 20368 : Vbi2MsRow::processorId () const
238 : {
239 20368 : return vbi2_p->processorId () (row ());
240 : }
241 :
242 : Int
243 20368 : Vbi2MsRow::scanNumber () const
244 : {
245 20368 : return vbi2_p->scan () (row ());
246 : }
247 :
248 : Int
249 20368 : Vbi2MsRow::stateId () const
250 : {
251 20368 : return vbi2_p->stateId () (row ());
252 : }
253 :
254 : Double
255 60804 : Vbi2MsRow::exposure () const
256 : {
257 60804 : return vbi2_p->exposure () (row ());
258 : }
259 :
260 : Double
261 55721 : Vbi2MsRow::interval () const
262 : {
263 55721 : return vbi2_p->timeInterval () (row ());
264 : }
265 :
266 : Int
267 10184 : Vbi2MsRow::rowId () const
268 : {
269 10184 : return vbi2_p->rowIds() (row());
270 : }
271 :
272 : Float
273 75464 : Vbi2MsRow::sigma (Int correlation) const
274 : {
275 75464 : return vbi2_p->sigma () (correlation, row ());
276 : }
277 :
278 : Int
279 45678 : Vbi2MsRow::spectralWindow () const
280 : {
281 45678 : return vbi2_p->spectralWindows() (row());
282 : }
283 :
284 :
285 : Double
286 80859 : Vbi2MsRow::time () const
287 : {
288 80859 : return vbi2_p->time () (row ());
289 : }
290 : Double
291 70988 : Vbi2MsRow::timeCentroid () const
292 : {
293 70988 : return vbi2_p->timeCentroid () (row ());
294 : }
295 :
296 : Float
297 25776 : Vbi2MsRow::weight (Int correlation) const
298 : {
299 25776 : return vbi2_p->weight () (correlation, row ());
300 : }
301 :
302 :
303 : ////////////////////////////////////////////////////////////
304 : //
305 : // Scalar setters
306 : //
307 :
308 : void
309 20368 : Vbi2MsRow::setAntenna1 (Int value)
310 : {
311 20368 : AssertWritable();
312 :
313 20368 : vbi2_p->cache_p->antenna1_p.getRef (false) (row ()) = value;
314 20368 : }
315 :
316 : void
317 20368 : Vbi2MsRow::setAntenna2 (Int value)
318 : {
319 20368 : AssertWritable();
320 :
321 20368 : vbi2_p->cache_p->antenna2_p.getRef (false)(row ()) = value;
322 20368 : }
323 :
324 : void
325 20368 : Vbi2MsRow::setArrayId (Int value)
326 : {
327 20368 : AssertWritable();
328 :
329 20368 : vbi2_p->cache_p->arrayId_p.getRef (false)(row ()) = value;
330 20368 : }
331 :
332 : void
333 0 : Vbi2MsRow::setCorrelationType (Int value)
334 : {
335 0 : AssertWritable();
336 :
337 0 : vbi2_p->cache_p->corrType_p.getRef (false)(row ()) = value;
338 0 : }
339 :
340 :
341 :
342 : void
343 20368 : Vbi2MsRow::setDataDescriptionId (Int value)
344 : {
345 20368 : AssertWritable();
346 :
347 20368 : vbi2_p->cache_p->dataDescriptionIds_p.getRef (false)(row ()) = value;
348 20368 : }
349 :
350 : void
351 20368 : Vbi2MsRow::setFeed1 (Int value)
352 : {
353 20368 : AssertWritable();
354 :
355 20368 : vbi2_p->cache_p->feed1_p.getRef (false)(row ()) = value;
356 20368 : }
357 :
358 : void
359 20368 : Vbi2MsRow::setFeed2 (Int value)
360 : {
361 20368 : AssertWritable();
362 :
363 20368 : vbi2_p->cache_p->feed2_p.getRef (false)(row ()) = value;
364 20368 : }
365 :
366 : void
367 20368 : Vbi2MsRow::setFieldId (Int value)
368 : {
369 20368 : AssertWritable();
370 :
371 20368 : vbi2_p->cache_p->fieldId_p.getRef (false)(row ()) = value;
372 20368 : }
373 :
374 : void
375 20368 : Vbi2MsRow::setRowId (Int value)
376 : {
377 20368 : AssertWritable();
378 :
379 20368 : vbi2_p->cache_p->rowIds_p.getRef (false) (row ()) = value;
380 20368 : }
381 :
382 : void
383 55862 : Vbi2MsRow::setRowFlag (Bool isFlagged)
384 : {
385 55862 : AssertWritable ();
386 :
387 55862 : vbi2_p->cache_p->flagRow_p.getRef (false)(row ()) = isFlagged;
388 55862 : }
389 :
390 : void
391 0 : Vbi2MsRow::setFlags (Bool isFlagged, Int correlation, Int channel)
392 : {
393 0 : AssertWritable ();
394 :
395 0 : vbi2_p->cache_p->flagCube_p.getRef (false)(correlation,channel, row ()) = isFlagged;
396 0 : }
397 :
398 : void
399 20368 : Vbi2MsRow::setFlags (const Matrix<Bool> & value)
400 : {
401 20368 : AssertWritable ();
402 :
403 20368 : Matrix<Bool> & flags = flagCache_p.getCachedPlane (vbi2_p, row());
404 20368 : flags = value;
405 20368 : }
406 :
407 : void
408 20368 : Vbi2MsRow::setObservationId (Int value)
409 : {
410 20368 : AssertWritable();
411 :
412 20368 : vbi2_p->cache_p->observationId_p.getRef (false)(row ()) = value;
413 20368 : }
414 :
415 : void
416 20368 : Vbi2MsRow::setProcessorId (Int value)
417 : {
418 20368 : AssertWritable();
419 :
420 20368 : vbi2_p->cache_p->processorId_p.getRef (false)(row ()) = value;
421 20368 : }
422 :
423 : void
424 20368 : Vbi2MsRow::setScanNumber (Int value)
425 : {
426 20368 : AssertWritable();
427 :
428 20368 : vbi2_p->cache_p->scan_p.getRef (false)(row ()) = value;
429 20368 : }
430 :
431 : void
432 20368 : Vbi2MsRow::setSpectralWindow (Int value)
433 : {
434 20368 : vbi2_p->cache_p->spectralWindows_p.getRef (false)(row ()) = value;
435 20368 : }
436 :
437 : void
438 20368 : Vbi2MsRow::setStateId (Int value)
439 : {
440 20368 : AssertWritable();
441 :
442 20368 : vbi2_p->cache_p->stateId_p.getRef (false)(row ()) = value;
443 20368 : }
444 :
445 : void
446 35494 : Vbi2MsRow::setExposure (Double value)
447 : {
448 35494 : AssertWritable();
449 :
450 35494 : vbi2_p->cache_p->exposure_p.getRef (false)(row ()) = value;
451 35494 : }
452 :
453 : void
454 30411 : Vbi2MsRow::setInterval (Double value)
455 : {
456 30411 : AssertWritable();
457 :
458 30411 : vbi2_p->cache_p->timeInterval_p.getRef (false)(row ()) = value;
459 30411 : }
460 :
461 : void
462 0 : Vbi2MsRow::setSigma (Int correlation, Float value)
463 : {
464 0 : AssertWritable();
465 :
466 0 : vbi2_p->cache_p->sigma_p.getRef (false)(correlation, row ()) = value;
467 0 : }
468 :
469 : void
470 20368 : Vbi2MsRow::setTime (Double value)
471 : {
472 20368 : AssertWritable();
473 :
474 20368 : vbi2_p->cache_p->time_p.getRef (false)(row ()) = value;
475 20368 : }
476 :
477 : void
478 55862 : Vbi2MsRow::setTimeCentroid (Double value)
479 : {
480 55862 : AssertWritable();
481 :
482 55862 : vbi2_p->cache_p->timeCentroid_p.getRef (false)(row ()) = value;
483 55862 : }
484 :
485 : void
486 0 : Vbi2MsRow::setWeight (Int correlation, Float value)
487 : {
488 0 : AssertWritable();
489 :
490 0 : vbi2_p->cache_p->weight_p.getRef (false)(correlation, row ()) = value;
491 0 : }
492 :
493 : ////////////////////////////////////////////////////////////
494 : //
495 : // Nonscalar getters
496 : //
497 :
498 : const Complex &
499 0 : Vbi2MsRow::corrected (Int correlation, Int channel) const
500 : {
501 0 : return vbi2_p->visCubeCorrected () (correlation, channel, row ());
502 : }
503 :
504 :
505 : Float
506 0 : Vbi2MsRow::weightSpectrum (Int correlation, Int channel) const
507 : {
508 0 : return vbi2_p->weightSpectrum () (correlation, channel, row ());
509 : }
510 :
511 :
512 : Float
513 0 : Vbi2MsRow::sigmaSpectrum (Int correlation, Int channel) const
514 : {
515 0 : return vbi2_p->sigmaSpectrum () (correlation, channel, row ());
516 : }
517 :
518 :
519 : const Complex &
520 0 : Vbi2MsRow::model (Int correlation, Int channel) const
521 : {
522 0 : return vbi2_p->visCubeModel () (correlation, channel, row ());
523 : }
524 :
525 :
526 : const Complex &
527 0 : Vbi2MsRow::observed (Int correlation, Int channel) const
528 : {
529 0 : return vbi2_p->visCube () (correlation, channel, row ());
530 : }
531 :
532 0 : const Float & Vbi2MsRow::singleDishData (Int correlation, Int channel) const
533 : {
534 0 : return vbi2_p->visCubeFloat () (correlation, channel, row ());
535 : }
536 :
537 : const Vector<Double>
538 81172 : Vbi2MsRow::uvw () const
539 : {
540 81172 : return vbi2_p->uvw ().column (row());
541 : }
542 :
543 : void
544 45678 : Vbi2MsRow::setUvw (const Vector<Double> & value)
545 : {
546 45678 : vbi2_p->cache_p->uvw_p.getRef(false).column (row()) = value;
547 45678 : }
548 :
549 : const Matrix<Complex> &
550 7308 : Vbi2MsRow::corrected () const
551 : {
552 7308 : return correctedCache_p.getCachedPlane (vbi2_p, row());
553 : }
554 :
555 : Matrix<Complex> &
556 7308 : Vbi2MsRow::correctedMutable ()
557 : {
558 7308 : return correctedCache_p.getCachedPlane (vbi2_p, row());
559 : }
560 :
561 : void
562 864 : Vbi2MsRow::setCorrected (const Matrix<Complex> & value)
563 : {
564 864 : AssertWritable();
565 :
566 864 : Matrix<Complex> & corrected = correctedCache_p.getCachedPlane (vbi2_p, row());
567 864 : corrected = value;
568 864 : }
569 :
570 : const Matrix<Complex> &
571 7308 : Vbi2MsRow::model () const
572 : {
573 7308 : return modelCache_p.getCachedPlane (vbi2_p, row());
574 : }
575 :
576 : Matrix<Complex> &
577 7308 : Vbi2MsRow::modelMutable ()
578 : {
579 7308 : return modelCache_p.getCachedPlane (vbi2_p, row());
580 : }
581 :
582 : void
583 864 : Vbi2MsRow::setModel (const Matrix<Complex> & value)
584 : {
585 864 : AssertWritable();
586 :
587 864 : Matrix<Complex> & model = modelCache_p.getCachedPlane (vbi2_p, row());
588 864 : model = value;
589 864 : }
590 :
591 : const Matrix<Complex> &
592 31840 : Vbi2MsRow::observed () const
593 : {
594 31840 : return observedCache_p.getCachedPlane (vbi2_p, row());
595 : }
596 :
597 : Matrix<Complex> &
598 31840 : Vbi2MsRow::observedMutable ()
599 : {
600 31840 : return observedCache_p.getCachedPlane (vbi2_p, row());
601 : }
602 :
603 : void
604 9752 : Vbi2MsRow::setObserved (const Matrix<Complex> & value)
605 : {
606 9752 : AssertWritable();
607 :
608 9752 : Matrix<Complex> & observed = observedCache_p.getCachedPlane (vbi2_p, row());
609 9752 : observed = value;
610 9752 : }
611 :
612 : const Vector<Float> &
613 45246 : Vbi2MsRow::sigma () const
614 : {
615 45246 : return sigmaCache_p.getCachedColumn (vbi2_p, row());
616 : }
617 :
618 : Vector<Float> &
619 25310 : Vbi2MsRow::sigmaMutable () const
620 : {
621 25310 : return sigmaCache_p.getCachedColumn (vbi2_p, row());
622 : }
623 :
624 : void
625 10616 : Vbi2MsRow::setSigma (const Vector<Float> & value)
626 : {
627 10616 : AssertWritable();
628 :
629 10616 : Vector<Float> & sigma = sigmaCache_p.getCachedColumn (vbi2_p, row());
630 10616 : sigma = value;
631 10616 : }
632 :
633 0 : const Matrix<Float> Vbi2MsRow::singleDishData () const
634 : {
635 0 : return vbi2_p->visCubeFloat ().xyPlane (row());
636 : }
637 :
638 : Matrix<Float>
639 0 : Vbi2MsRow::singleDishDataMutable ()
640 : {
641 0 : return vbi2_p->visCubeFloat ().xyPlane (row());
642 : }
643 :
644 : void
645 0 : Vbi2MsRow::setSingleDishData (const Matrix<Float> & value)
646 : {
647 0 : vbi2_p->cache_p->floatDataCube_p.getRef(false).xyPlane (row()) = value;
648 0 : }
649 :
650 :
651 :
652 : const Vector<Float> &
653 45246 : Vbi2MsRow::weight () const
654 : {
655 45246 : return weightCache_p.getCachedColumn (vbi2_p, row());
656 : }
657 :
658 : Vector<Float> &
659 25310 : Vbi2MsRow::weightMutable () const
660 : {
661 25310 : return weightCache_p.getCachedColumn (vbi2_p, row());
662 : }
663 :
664 : void
665 30552 : Vbi2MsRow::setWeight (const Vector<Float> & value)
666 : {
667 30552 : AssertWritable();
668 :
669 30552 : Vector<Float> & weight = weightCache_p.getCachedColumn (vbi2_p, row());
670 30552 : weight = value;
671 30552 : }
672 :
673 : void
674 20368 : Vbi2MsRow::setWeightSpectrum (const Matrix<Float> & value)
675 : {
676 20368 : AssertWritable();
677 :
678 20368 : Matrix<Float> & weightSpectrum = weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
679 20368 : weightSpectrum = value;
680 20368 : }
681 :
682 : const Matrix<Float> &
683 47612 : Vbi2MsRow::weightSpectrum () const
684 : {
685 47612 : return weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
686 : }
687 :
688 : Matrix<Float> &
689 25310 : Vbi2MsRow::weightSpectrumMutable () const
690 : {
691 25310 : return weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
692 : }
693 :
694 : const Matrix<Float> &
695 43320 : Vbi2MsRow::sigmaSpectrum () const
696 : {
697 43320 : return sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
698 : }
699 :
700 : Matrix<Float> &
701 25310 : Vbi2MsRow::sigmaSpectrumMutable () const
702 : {
703 25310 : return sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
704 : }
705 :
706 : void
707 20368 : Vbi2MsRow::setSigmaSpectrum (const Matrix<Float> & value)
708 : {
709 20368 : AssertWritable();
710 :
711 20368 : Matrix<Float> & sigmaSpectrum = sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
712 20368 : sigmaSpectrum = value;
713 20368 : }
714 :
715 : ////////////////////////////////////////////////////////////
716 : //
717 : // Nonscalar setters
718 : //
719 :
720 : void
721 0 : Vbi2MsRow::setCorrected (Int correlation, Int channel, const Complex & value)
722 : {
723 0 : AssertWritable();
724 :
725 0 : vbi2_p->cache_p->correctedVisCube_p.getRef (false)(correlation, channel, row ()) = value;
726 0 : }
727 :
728 : void
729 0 : Vbi2MsRow::setWeightSpectrum (Int correlation, Int channel, Float value)
730 : {
731 0 : AssertWritable();
732 :
733 0 : vbi2_p->cache_p->weightSpectrum_p.getRef (false)(correlation, channel, row ()) = value;
734 0 : }
735 :
736 :
737 : void
738 0 : Vbi2MsRow::setSigmaSpectrum (Int correlation, Int channel, Float value)
739 : {
740 0 : AssertWritable();
741 :
742 0 : vbi2_p->cache_p->sigmaSpectrum_p.getRef (false)(correlation, channel, row ()) = value;
743 0 : }
744 :
745 :
746 : void
747 0 : Vbi2MsRow::setModel (Int correlation, Int channel, const Complex & value)
748 : {
749 0 : AssertWritable();
750 :
751 0 : vbi2_p->cache_p->modelVisCube_p.getRef (false)(correlation, channel, row ()) = value;
752 0 : }
753 :
754 : void
755 0 : Vbi2MsRow::setObserved (Int correlation, Int channel, const Complex & value)
756 : {
757 0 : AssertWritable();
758 :
759 0 : vbi2_p->cache_p->visCube_p.getRef (false)(correlation, channel, row ()) = value;
760 0 : }
761 :
762 : void
763 0 : Vbi2MsRow::setSingleDishData (Int correlation, Int channel, const Float & value)
764 : {
765 0 : AssertWritable();
766 :
767 0 : vbi2_p->cache_p->floatDataCube_p.getRef (false)(correlation, channel, row ()) = value;
768 0 : }
769 :
770 :
771 :
772 : }
773 : }
774 :
775 :
|
