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 0 : Vbi2MsRow::Vbi2MsRow (rownr_t row, const VisBufferImpl2 * vb)
27 : : MsRow (row, vb),
28 : correctedCache_p (& VisBufferImpl2::visCubeCorrected),
29 : flagCache_p (& VisBufferImpl2::flagCube),
30 : modelCache_p(& VisBufferImpl2::visCubeModel),
31 : observedCache_p(&VisBufferImpl2::visCube),
32 : sigmaCache_p (&VisBufferImpl2::sigma),
33 : sigmaSpectrumCache_p(& VisBufferImpl2::sigmaSpectrum),
34 : weightCache_p (&VisBufferImpl2::weight),
35 : weightSpectrumCache_p(& VisBufferImpl2::weightSpectrum),
36 0 : vbi2_p (const_cast<VisBufferImpl2 *> (vb))
37 : {
38 0 : configureArrayCaches ();
39 0 : }
40 :
41 :
42 0 : Vbi2MsRow::Vbi2MsRow (rownr_t row, VisBufferImpl2 * vb)
43 : : MsRow (row, vb),
44 : correctedCache_p (& VisBufferImpl2::visCubeCorrected),
45 : flagCache_p (& VisBufferImpl2::flagCube),
46 : modelCache_p(& VisBufferImpl2::visCubeModel),
47 : observedCache_p(&VisBufferImpl2::visCube),
48 : sigmaCache_p (&VisBufferImpl2::sigma),
49 : sigmaSpectrumCache_p(& VisBufferImpl2::sigmaSpectrum),
50 : weightCache_p (&VisBufferImpl2::weight),
51 : weightSpectrumCache_p(& VisBufferImpl2::weightSpectrum),
52 0 : vbi2_p (vb)
53 : {
54 0 : configureArrayCaches ();
55 0 : }
56 :
57 : void
58 0 : Vbi2MsRow::configureArrayCaches ()
59 : {
60 0 : arrayCaches_p.push_back (& correctedCache_p);
61 0 : arrayCaches_p.push_back (& flagCache_p);
62 0 : arrayCaches_p.push_back (& modelCache_p);
63 0 : arrayCaches_p.push_back (& observedCache_p);
64 0 : arrayCaches_p.push_back (& sigmaCache_p);
65 0 : arrayCaches_p.push_back (& sigmaSpectrumCache_p);
66 0 : arrayCaches_p.push_back (& weightCache_p);
67 0 : arrayCaches_p.push_back (& weightSpectrumCache_p);
68 0 : }
69 :
70 : void
71 0 : Vbi2MsRow::clearArrayCaches ()
72 : {
73 0 : for (std::vector<CachedArrayBase *>::iterator i = arrayCaches_p.begin();
74 0 : i != arrayCaches_p.end();
75 0 : i ++){
76 0 : (* i)->clearCache();
77 : }
78 0 : }
79 :
80 : void
81 0 : Vbi2MsRow::changeRow (rownr_t row)
82 : {
83 0 : MsRow::changeRow (row);
84 0 : clearArrayCaches ();
85 0 : }
86 :
87 : ////////////////////////////////////////////////////////////
88 : //
89 : // Scalar getters
90 : //
91 :
92 : Int
93 0 : Vbi2MsRow::antenna1 () const
94 : {
95 0 : return vbi2_p->antenna1 () (row ());
96 : }
97 :
98 : Int
99 0 : Vbi2MsRow::antenna2 () const
100 : {
101 0 : return vbi2_p->antenna2 () (row ());
102 : }
103 :
104 : Int
105 0 : Vbi2MsRow::arrayId () const
106 : {
107 0 : 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 0 : Vbi2MsRow::copyIf (Bool copyThis, Vbi2MsRow * other,
120 : void (Vbi2MsRow::* setter) (T),
121 : U (Vbi2MsRow::* getter) () const)
122 : {
123 0 : if (copyThis){
124 0 : (this ->* setter) ((other ->* getter) ());
125 : }
126 0 : }
127 :
128 : void
129 0 : Vbi2MsRow::copy (Vbi2MsRow * other,
130 : const VisBufferComponents2 & componentsToCopy)
131 : {
132 : // Copy the data contents of the other row into this one
133 :
134 0 : setAntenna1 (other->antenna1 ());
135 0 : setAntenna2 (other->antenna2 ());
136 0 : setArrayId (other->arrayId ());
137 0 : setDataDescriptionId (other->dataDescriptionId ());
138 0 : setExposure (other->exposure ());
139 0 : setFeed1 (other->feed1 ());
140 0 : setFeed2 (other->feed2 ());
141 0 : setFieldId (other->fieldId ());
142 0 : setFlags (other->flags ());
143 0 : setInterval (other->interval ());
144 0 : setObservationId (other->observationId ());
145 0 : setProcessorId (other->processorId ());
146 0 : setRowFlag (other->isRowFlagged());
147 0 : setRowId (other->rowId());
148 0 : setScanNumber (other->scanNumber ());
149 0 : setSigma (other->sigma ());
150 0 : setSpectralWindow (other->spectralWindow());
151 0 : setStateId (other->stateId ());
152 0 : setTime (other->time ());
153 0 : setTimeCentroid (other->timeCentroid ());
154 0 : setUvw (other->uvw ());
155 0 : setWeight (other->weight ());
156 :
157 : // Optionally copied fields
158 :
159 0 : copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeCorrected), other,
160 : & Vbi2MsRow::setCorrected, & Vbi2MsRow::corrected );
161 0 : copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeModel), other,
162 : & Vbi2MsRow::setModel, & Vbi2MsRow::model );
163 0 : copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeObserved), other,
164 : & Vbi2MsRow::setObserved, & Vbi2MsRow::observed );
165 0 : copyIf (componentsToCopy.contains (VisBufferComponent2::VisibilityCubeFloat), other,
166 : & Vbi2MsRow::setSingleDishData, & Vbi2MsRow::singleDishData );
167 0 : copyIf (componentsToCopy.contains (VisBufferComponent2::WeightSpectrum), other,
168 : & Vbi2MsRow::setWeightSpectrum, & Vbi2MsRow::weightSpectrum );
169 0 : copyIf (componentsToCopy.contains (VisBufferComponent2::SigmaSpectrum), other,
170 : & Vbi2MsRow::setSigmaSpectrum, & Vbi2MsRow::sigmaSpectrum );
171 0 : }
172 :
173 :
174 : Int
175 0 : Vbi2MsRow::dataDescriptionId () const
176 : {
177 0 : return vbi2_p->dataDescriptionIds () (row ());
178 : }
179 :
180 : Int
181 0 : Vbi2MsRow::feed1 () const
182 : {
183 0 : return vbi2_p->feed1 () (row ());
184 : }
185 :
186 : Int
187 0 : Vbi2MsRow::feed2 () const
188 : {
189 0 : return vbi2_p->feed2 () (row ());
190 : }
191 :
192 : Int
193 0 : Vbi2MsRow::fieldId () const
194 : {
195 0 : return vbi2_p->fieldId () (row ());
196 : }
197 :
198 : VisBufferImpl2 *
199 0 : Vbi2MsRow::getVbi () const
200 : {
201 0 : return vbi2_p;
202 : }
203 :
204 :
205 : Bool
206 0 : Vbi2MsRow::isRowFlagged () const
207 : {
208 0 : return vbi2_p->flagRow () (row ());
209 : }
210 :
211 : const Matrix<Bool> &
212 0 : Vbi2MsRow::flags () const
213 : {
214 0 : return flagCache_p.getCachedPlane (vbi2_p, row());
215 : }
216 :
217 : Matrix<Bool> &
218 0 : Vbi2MsRow::flagsMutable ()
219 : {
220 0 : 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 0 : Vbi2MsRow::observationId () const
232 : {
233 0 : return vbi2_p->observationId () (row ());
234 : }
235 :
236 : Int
237 0 : Vbi2MsRow::processorId () const
238 : {
239 0 : return vbi2_p->processorId () (row ());
240 : }
241 :
242 : Int
243 0 : Vbi2MsRow::scanNumber () const
244 : {
245 0 : return vbi2_p->scan () (row ());
246 : }
247 :
248 : Int
249 0 : Vbi2MsRow::stateId () const
250 : {
251 0 : return vbi2_p->stateId () (row ());
252 : }
253 :
254 : Double
255 0 : Vbi2MsRow::exposure () const
256 : {
257 0 : return vbi2_p->exposure () (row ());
258 : }
259 :
260 : Double
261 0 : Vbi2MsRow::interval () const
262 : {
263 0 : return vbi2_p->timeInterval () (row ());
264 : }
265 :
266 : Int
267 0 : Vbi2MsRow::rowId () const
268 : {
269 0 : return vbi2_p->rowIds() (row());
270 : }
271 :
272 : Float
273 0 : Vbi2MsRow::sigma (Int correlation) const
274 : {
275 0 : return vbi2_p->sigma () (correlation, row ());
276 : }
277 :
278 : Int
279 0 : Vbi2MsRow::spectralWindow () const
280 : {
281 0 : return vbi2_p->spectralWindows() (row());
282 : }
283 :
284 :
285 : Double
286 0 : Vbi2MsRow::time () const
287 : {
288 0 : return vbi2_p->time () (row ());
289 : }
290 : Double
291 0 : Vbi2MsRow::timeCentroid () const
292 : {
293 0 : return vbi2_p->timeCentroid () (row ());
294 : }
295 :
296 : Float
297 0 : Vbi2MsRow::weight (Int correlation) const
298 : {
299 0 : return vbi2_p->weight () (correlation, row ());
300 : }
301 :
302 :
303 : ////////////////////////////////////////////////////////////
304 : //
305 : // Scalar setters
306 : //
307 :
308 : void
309 0 : Vbi2MsRow::setAntenna1 (Int value)
310 : {
311 0 : AssertWritable();
312 :
313 0 : vbi2_p->cache_p->antenna1_p.getRef (false) (row ()) = value;
314 0 : }
315 :
316 : void
317 0 : Vbi2MsRow::setAntenna2 (Int value)
318 : {
319 0 : AssertWritable();
320 :
321 0 : vbi2_p->cache_p->antenna2_p.getRef (false)(row ()) = value;
322 0 : }
323 :
324 : void
325 0 : Vbi2MsRow::setArrayId (Int value)
326 : {
327 0 : AssertWritable();
328 :
329 0 : vbi2_p->cache_p->arrayId_p.getRef (false)(row ()) = value;
330 0 : }
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 0 : Vbi2MsRow::setDataDescriptionId (Int value)
344 : {
345 0 : AssertWritable();
346 :
347 0 : vbi2_p->cache_p->dataDescriptionIds_p.getRef (false)(row ()) = value;
348 0 : }
349 :
350 : void
351 0 : Vbi2MsRow::setFeed1 (Int value)
352 : {
353 0 : AssertWritable();
354 :
355 0 : vbi2_p->cache_p->feed1_p.getRef (false)(row ()) = value;
356 0 : }
357 :
358 : void
359 0 : Vbi2MsRow::setFeed2 (Int value)
360 : {
361 0 : AssertWritable();
362 :
363 0 : vbi2_p->cache_p->feed2_p.getRef (false)(row ()) = value;
364 0 : }
365 :
366 : void
367 0 : Vbi2MsRow::setFieldId (Int value)
368 : {
369 0 : AssertWritable();
370 :
371 0 : vbi2_p->cache_p->fieldId_p.getRef (false)(row ()) = value;
372 0 : }
373 :
374 : void
375 0 : Vbi2MsRow::setRowId (Int value)
376 : {
377 0 : AssertWritable();
378 :
379 0 : vbi2_p->cache_p->rowIds_p.getRef (false) (row ()) = value;
380 0 : }
381 :
382 : void
383 0 : Vbi2MsRow::setRowFlag (Bool isFlagged)
384 : {
385 0 : AssertWritable ();
386 :
387 0 : vbi2_p->cache_p->flagRow_p.getRef (false)(row ()) = isFlagged;
388 0 : }
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 0 : Vbi2MsRow::setFlags (const Matrix<Bool> & value)
400 : {
401 0 : AssertWritable ();
402 :
403 0 : Matrix<Bool> & flags = flagCache_p.getCachedPlane (vbi2_p, row());
404 0 : flags = value;
405 0 : }
406 :
407 : void
408 0 : Vbi2MsRow::setObservationId (Int value)
409 : {
410 0 : AssertWritable();
411 :
412 0 : vbi2_p->cache_p->observationId_p.getRef (false)(row ()) = value;
413 0 : }
414 :
415 : void
416 0 : Vbi2MsRow::setProcessorId (Int value)
417 : {
418 0 : AssertWritable();
419 :
420 0 : vbi2_p->cache_p->processorId_p.getRef (false)(row ()) = value;
421 0 : }
422 :
423 : void
424 0 : Vbi2MsRow::setScanNumber (Int value)
425 : {
426 0 : AssertWritable();
427 :
428 0 : vbi2_p->cache_p->scan_p.getRef (false)(row ()) = value;
429 0 : }
430 :
431 : void
432 0 : Vbi2MsRow::setSpectralWindow (Int value)
433 : {
434 0 : vbi2_p->cache_p->spectralWindows_p.getRef (false)(row ()) = value;
435 0 : }
436 :
437 : void
438 0 : Vbi2MsRow::setStateId (Int value)
439 : {
440 0 : AssertWritable();
441 :
442 0 : vbi2_p->cache_p->stateId_p.getRef (false)(row ()) = value;
443 0 : }
444 :
445 : void
446 0 : Vbi2MsRow::setExposure (Double value)
447 : {
448 0 : AssertWritable();
449 :
450 0 : vbi2_p->cache_p->exposure_p.getRef (false)(row ()) = value;
451 0 : }
452 :
453 : void
454 0 : Vbi2MsRow::setInterval (Double value)
455 : {
456 0 : AssertWritable();
457 :
458 0 : vbi2_p->cache_p->timeInterval_p.getRef (false)(row ()) = value;
459 0 : }
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 0 : Vbi2MsRow::setTime (Double value)
471 : {
472 0 : AssertWritable();
473 :
474 0 : vbi2_p->cache_p->time_p.getRef (false)(row ()) = value;
475 0 : }
476 :
477 : void
478 0 : Vbi2MsRow::setTimeCentroid (Double value)
479 : {
480 0 : AssertWritable();
481 :
482 0 : vbi2_p->cache_p->timeCentroid_p.getRef (false)(row ()) = value;
483 0 : }
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 0 : Vbi2MsRow::uvw () const
539 : {
540 0 : return vbi2_p->uvw ().column (row());
541 : }
542 :
543 : void
544 0 : Vbi2MsRow::setUvw (const Vector<Double> & value)
545 : {
546 0 : vbi2_p->cache_p->uvw_p.getRef(false).column (row()) = value;
547 0 : }
548 :
549 : const Matrix<Complex> &
550 0 : Vbi2MsRow::corrected () const
551 : {
552 0 : return correctedCache_p.getCachedPlane (vbi2_p, row());
553 : }
554 :
555 : Matrix<Complex> &
556 0 : Vbi2MsRow::correctedMutable ()
557 : {
558 0 : return correctedCache_p.getCachedPlane (vbi2_p, row());
559 : }
560 :
561 : void
562 0 : Vbi2MsRow::setCorrected (const Matrix<Complex> & value)
563 : {
564 0 : AssertWritable();
565 :
566 0 : Matrix<Complex> & corrected = correctedCache_p.getCachedPlane (vbi2_p, row());
567 0 : corrected = value;
568 0 : }
569 :
570 : const Matrix<Complex> &
571 0 : Vbi2MsRow::model () const
572 : {
573 0 : return modelCache_p.getCachedPlane (vbi2_p, row());
574 : }
575 :
576 : Matrix<Complex> &
577 0 : Vbi2MsRow::modelMutable ()
578 : {
579 0 : return modelCache_p.getCachedPlane (vbi2_p, row());
580 : }
581 :
582 : void
583 0 : Vbi2MsRow::setModel (const Matrix<Complex> & value)
584 : {
585 0 : AssertWritable();
586 :
587 0 : Matrix<Complex> & model = modelCache_p.getCachedPlane (vbi2_p, row());
588 0 : model = value;
589 0 : }
590 :
591 : const Matrix<Complex> &
592 0 : Vbi2MsRow::observed () const
593 : {
594 0 : return observedCache_p.getCachedPlane (vbi2_p, row());
595 : }
596 :
597 : Matrix<Complex> &
598 0 : Vbi2MsRow::observedMutable ()
599 : {
600 0 : return observedCache_p.getCachedPlane (vbi2_p, row());
601 : }
602 :
603 : void
604 0 : Vbi2MsRow::setObserved (const Matrix<Complex> & value)
605 : {
606 0 : AssertWritable();
607 :
608 0 : Matrix<Complex> & observed = observedCache_p.getCachedPlane (vbi2_p, row());
609 0 : observed = value;
610 0 : }
611 :
612 : const Vector<Float> &
613 0 : Vbi2MsRow::sigma () const
614 : {
615 0 : return sigmaCache_p.getCachedColumn (vbi2_p, row());
616 : }
617 :
618 : Vector<Float> &
619 0 : Vbi2MsRow::sigmaMutable () const
620 : {
621 0 : return sigmaCache_p.getCachedColumn (vbi2_p, row());
622 : }
623 :
624 : void
625 0 : Vbi2MsRow::setSigma (const Vector<Float> & value)
626 : {
627 0 : AssertWritable();
628 :
629 0 : Vector<Float> & sigma = sigmaCache_p.getCachedColumn (vbi2_p, row());
630 0 : sigma = value;
631 0 : }
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 0 : Vbi2MsRow::weight () const
654 : {
655 0 : return weightCache_p.getCachedColumn (vbi2_p, row());
656 : }
657 :
658 : Vector<Float> &
659 0 : Vbi2MsRow::weightMutable () const
660 : {
661 0 : return weightCache_p.getCachedColumn (vbi2_p, row());
662 : }
663 :
664 : void
665 0 : Vbi2MsRow::setWeight (const Vector<Float> & value)
666 : {
667 0 : AssertWritable();
668 :
669 0 : Vector<Float> & weight = weightCache_p.getCachedColumn (vbi2_p, row());
670 0 : weight = value;
671 0 : }
672 :
673 : void
674 0 : Vbi2MsRow::setWeightSpectrum (const Matrix<Float> & value)
675 : {
676 0 : AssertWritable();
677 :
678 0 : Matrix<Float> & weightSpectrum = weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
679 0 : weightSpectrum = value;
680 0 : }
681 :
682 : const Matrix<Float> &
683 0 : Vbi2MsRow::weightSpectrum () const
684 : {
685 0 : return weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
686 : }
687 :
688 : Matrix<Float> &
689 0 : Vbi2MsRow::weightSpectrumMutable () const
690 : {
691 0 : return weightSpectrumCache_p.getCachedPlane (vbi2_p, row());
692 : }
693 :
694 : const Matrix<Float> &
695 0 : Vbi2MsRow::sigmaSpectrum () const
696 : {
697 0 : return sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
698 : }
699 :
700 : Matrix<Float> &
701 0 : Vbi2MsRow::sigmaSpectrumMutable () const
702 : {
703 0 : return sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
704 : }
705 :
706 : void
707 0 : Vbi2MsRow::setSigmaSpectrum (const Matrix<Float> & value)
708 : {
709 0 : AssertWritable();
710 :
711 0 : Matrix<Float> & sigmaSpectrum = sigmaSpectrumCache_p.getCachedPlane (vbi2_p, row());
712 0 : sigmaSpectrum = value;
713 0 : }
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 :
|
