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