Line data Source code
1 : /*
2 : * VisBufferImpl2Internal.h
3 : *
4 : * Created on: Aug 22, 2013
5 : * Author: jjacobs
6 : */
7 :
8 : #ifndef VISBUFFERIMPL2INTERNAL_H_
9 : #define VISBUFFERIMPL2INTERNAL_H_
10 :
11 : #include <msvis/MSVis/ViImplementation2.h>
12 : #include <cassert>
13 : #include <sstream>
14 :
15 : namespace casa {
16 :
17 : namespace ms {
18 : class Vbi2MsRow;
19 : }
20 :
21 : namespace vi {
22 :
23 : //////////////////////////////////////////////////////////
24 : //
25 : // Auxiliary Classes are contained in the "vb" namespace.
26 : //
27 : // These include VbCacheItemBase, VbCacheItem, VisBufferCache
28 : // and VisBufferState.
29 :
30 :
31 :
32 :
33 : // Possible array shapes of data coming from the main table cells.
34 :
35 : typedef enum {NoCheck, Nr, NfNr, NcNr, NcNfNr, Ns, NsNcNr, NsNcNfNr, NcNfNcatNr, I3Nr, N_ShapePatterns} ShapePattern;
36 :
37 : class VisBufferCache;
38 :
39 : class VbCacheItemBase {
40 :
41 : // Provides a common base class for all of the cached value classes.
42 : // This is required because the actualy value classes use a template
43 : // to capture the underlying value type.
44 :
45 : friend class VisBufferImpl2;
46 :
47 : public:
48 :
49 1102 : VbCacheItemBase (bool isMutable)
50 1102 : : isKey_p (false),
51 1102 : isMutable_p (isMutable),
52 1102 : vbComponent_p (VisBufferComponent2::Unknown),
53 1102 : vb_p (0) {}
54 :
55 1102 : virtual ~VbCacheItemBase () {}
56 :
57 : virtual void appendRows (casacore::rownr_t nRowsToAdd, casacore::Bool truncate = false) = 0;
58 : virtual void clear (casacore::Bool clearStatusOnly = false) = 0;
59 : virtual void clearDirty () = 0;
60 : virtual void copyRowElement (casacore::Int sourceRow, casacore::Int destinationRow) = 0;
61 : virtual void fill () const = 0;
62 : VisBufferComponent2
63 0 : getComponent () const
64 : {
65 0 : return vbComponent_p;
66 : }
67 : virtual casacore::Bool isArray () const = 0;
68 : virtual casacore::Bool isDirty () const = 0;
69 : virtual casacore::Bool isPresent () const = 0;
70 : virtual casacore::Bool isShapeOk () const = 0;
71 0 : virtual void resize (casacore::Bool /*copyValues*/) {}
72 : virtual void setDirty () = 0;
73 : virtual casacore::String shapeErrorMessage () const = 0;
74 :
75 : protected:
76 :
77 : virtual void copy (const VbCacheItemBase * other, casacore::Bool fetchIfNeeded) = 0;
78 :
79 19803 : VisBufferImpl2 * getVb () const
80 : {
81 19803 : return vb_p;
82 : }
83 :
84 : virtual void initialize (VisBufferCache * cache, VisBufferImpl2 * vb, VisBufferComponent2 component,
85 : casacore::Bool isKey = true);
86 :
87 1800 : casacore::Bool isKey () const { return isKey_p;}
88 1200 : bool isMutable () const { return isMutable_p; }
89 :
90 : virtual void setAsPresent (casacore::Bool isPresent = true) const = 0;
91 1064 : void setIsKey (casacore::Bool isKey)
92 : {
93 1064 : isKey_p = isKey;
94 1064 : }
95 :
96 : private:
97 :
98 : casacore::Bool isKey_p;
99 : const bool isMutable_p;
100 : VisBufferComponent2 vbComponent_p;
101 : VisBufferImpl2 * vb_p; // [use]
102 :
103 : };
104 :
105 : typedef std::vector<VbCacheItemBase *> CacheRegistry;
106 :
107 : template <typename T, casacore::Bool IsComputed = false>
108 : class VbCacheItem : public VbCacheItemBase {
109 :
110 : friend class VisBufferImpl2;
111 :
112 : public:
113 :
114 : typedef T DataType;
115 : typedef void (VisBufferImpl2::* Filler) (T &) const;
116 :
117 1102 : VbCacheItem (bool isMutable = false)
118 1102 : : VbCacheItemBase (isMutable), isPresent_p (false)
119 1102 : {}
120 :
121 1102 : virtual ~VbCacheItem () {}
122 :
123 0 : virtual void appendRows (casacore::rownr_t, casacore::Bool)
124 : {
125 : // Noop for scalars
126 0 : }
127 :
128 : virtual void
129 291984 : clear (casacore::Bool clearStatusOnly)
130 : {
131 291984 : if (! clearStatusOnly) {
132 291984 : clearValue (item_p);
133 : }
134 291984 : setAsPresent (false);
135 291984 : clearDirty ();
136 291984 : }
137 :
138 : virtual void
139 291984 : clearDirty ()
140 : {
141 291984 : isDirty_p = false;
142 291984 : }
143 :
144 0 : virtual void copyRowElement (casacore::Int /*sourceRow*/, casacore::Int /*destinationRow*/) {} // noop
145 :
146 :
147 : virtual void
148 17403 : fill () const
149 : {
150 17403 : const VisBufferImpl2 * vb = getVb();
151 :
152 17403 : ThrowIf (! vb->isAttached (),
153 : casacore::String::format ("Can't fill VisBuffer component %s: Not attached to VisibilityIterator",
154 : VisBufferComponents2::name (getComponent()).c_str()));
155 :
156 17403 : ThrowIf (! IsComputed && ! vb->isFillable (),
157 : casacore::String::format ("Cannot fill VisBuffer component %s: %s",
158 : VisBufferComponents2::name (getComponent()).c_str(),
159 : vb->getFillErrorMessage ().c_str()));
160 :
161 17403 : (vb ->* filler_p) (item_p);
162 17403 : }
163 :
164 : const T &
165 2995545 : get () const
166 : {
167 2995545 : if (! isPresent()){
168 17403 : fill ();
169 17403 : setAsPresent ();
170 17403 : isDirty_p = false;
171 : }
172 :
173 2995545 : return item_p;
174 : }
175 :
176 : T &
177 0 : getRef (casacore::Bool fillIfAbsent = true)
178 : {
179 0 : if (! isPresent() && fillIfAbsent){
180 0 : fill ();
181 : }
182 0 : setAsPresent();
183 :
184 : // Caller is getting a modifiabled reference to the
185 : // datum (otherwise they would use "get"): assume
186 : // that it will be used to modify the datum and mark
187 : // it as dirty.
188 :
189 0 : isDirty_p = true;
190 :
191 0 : return item_p;
192 : }
193 :
194 : void
195 1064 : initialize (VisBufferCache * cache, VisBufferImpl2 * vb, Filler filler,
196 : VisBufferComponent2 component = VisBufferComponent2::Unknown,
197 : casacore::Bool isKey = true)
198 : {
199 1064 : VbCacheItemBase::initialize (cache, vb, component, isKey);
200 1064 : filler_p = filler;
201 1064 : }
202 :
203 0 : casacore::Bool isArray () const
204 : {
205 0 : return false;
206 : }
207 :
208 : casacore::Bool
209 0 : isDirty () const
210 : {
211 0 : return isDirty_p;
212 : }
213 :
214 : casacore::Bool
215 2995545 : isPresent () const
216 : {
217 2995545 : return isPresent_p;
218 : }
219 :
220 : virtual casacore::Bool
221 0 : isShapeOk () const
222 : {
223 0 : return true;
224 : }
225 :
226 : virtual void
227 600 : set (const T & newItem)
228 : {
229 600 : ThrowIf (! isMutable () && ! getVb()->isWritable (), "This VisBuffer is readonly");
230 :
231 600 : ThrowIf (isKey() && ! getVb()->isRekeyable (),
232 : "This VisBuffer is does not allow row key values to be changed.");
233 :
234 : // Set operations to a rekeyable VB are allowed to change the shapes of the
235 : // values. When T derives from casacore::Array, the assign method will use casacore::Array::assign
236 : // which resizes the destination value to match the source value. For nonkeyable
237 : // VBs, the normal operator= method is used which for Arrays will throw an
238 : // exception when a shape incompatibility exists between the source and destination.
239 :
240 600 : if (isKey ()){
241 0 : assign (item_p, newItem);
242 : }
243 : else{
244 600 : item_p = newItem;
245 : }
246 :
247 600 : ThrowIf (! isShapeOk (), shapeErrorMessage() );
248 :
249 600 : setAsPresent();
250 600 : isDirty_p = true;
251 600 : }
252 :
253 :
254 : template <typename U>
255 : void
256 0 : set (const U & newItem)
257 : {
258 0 : ThrowIf (! isMutable () && ! getVb()->isWritable (), "This VisBuffer is readonly");
259 :
260 0 : ThrowIf (isKey () && ! getVb()->isRekeyable (),
261 : "This VisBuffer is does not allow row key values to be changed.");
262 :
263 0 : item_p = newItem;
264 :
265 0 : ThrowIf (! isShapeOk (), shapeErrorMessage() );
266 :
267 0 : setAsPresent();
268 0 : isDirty_p = true;
269 0 : }
270 :
271 : template <typename U>
272 : void
273 22722 : setSpecial (const U & newItem)
274 : {
275 : // For internal use for items which aren't really demand-fetched
276 :
277 22722 : item_p = newItem;
278 22722 : setAsPresent();
279 22722 : isDirty_p = false;
280 22722 : }
281 :
282 : virtual void
283 0 : setDirty ()
284 : {
285 0 : isDirty_p = true;
286 0 : }
287 :
288 : virtual casacore::String
289 0 : shapeErrorMessage () const
290 : {
291 0 : ThrowIf (true, "Scalar shapes should not have shape errors.");
292 :
293 0 : return casacore::String();
294 : }
295 :
296 : protected:
297 :
298 : void
299 0 : assign (T & lhs, const T & rhs)
300 : {
301 0 : lhs = rhs;
302 0 : }
303 :
304 : template <typename E>
305 250272 : static void clearValue (casacore::Array <E> & value){
306 250272 : value.resize();
307 250272 : }
308 :
309 36498 : static void clearValue (casacore::Int & value){
310 36498 : value = 0;
311 36498 : }
312 :
313 5214 : static void clearValue (casacore::MDirection & value){
314 5214 : value = casacore::MDirection ();
315 5214 : }
316 :
317 :
318 : // virtual void
319 : // copy (const VbCacheItemBase * otherRaw, casacore::Bool markAsCached)
320 : // {
321 : // // Convert generic pointer to one pointint to this
322 : // // cache item type.
323 : //
324 : // const VbCacheItem * other = dynamic_cast <const VbCacheItem *> (otherRaw);
325 : // Assert (other != 0);
326 : //
327 : // // Capture the cached status of the other item
328 : //
329 : // isPresent_p = other->isPresent_p;
330 : //
331 : // // If the other item was cached then copy it over
332 : // // otherwise clear out this item.
333 : //
334 : // if (isPresent_p){
335 : // item_p = other->item_p;
336 : // }
337 : // else {
338 : // item_p = T ();
339 : //
340 : // if (markAsCached){
341 : // isPresent_p = true;
342 : // }
343 : // }
344 : // }
345 :
346 : virtual void
347 0 : copy (const VbCacheItemBase * otherRaw, casacore::Bool fetchIfNeeded)
348 : {
349 0 : const VbCacheItem<T, IsComputed> * other =
350 0 : dynamic_cast <const VbCacheItem<T, IsComputed> *> (otherRaw);
351 0 : copyAux (other, fetchIfNeeded);
352 0 : }
353 :
354 : void
355 0 : copyAux (const VbCacheItem<T, IsComputed> * other, bool fetchIfNeeded)
356 : {
357 0 : if (other->isPresent()){
358 :
359 0 : item_p = other->item_p;
360 0 : setAsPresent ();
361 0 : isDirty_p = false;
362 : }
363 0 : else if (fetchIfNeeded){
364 0 : set (other->get());
365 : }
366 : else {
367 :
368 0 : setAsPresent (false);
369 0 : isDirty_p = false;
370 : }
371 0 : }
372 :
373 : T &
374 600 : getItem () const
375 : {
376 600 : return item_p;
377 : }
378 :
379 : void
380 332709 : setAsPresent (casacore::Bool isPresent = true) const
381 : {
382 332709 : isPresent_p = isPresent;
383 332709 : }
384 :
385 : private:
386 :
387 : Filler filler_p;
388 : mutable casacore::Bool isDirty_p;
389 : mutable casacore::Bool isPresent_p;
390 : mutable T item_p;
391 : };
392 :
393 : template <typename T, casacore::Bool IsComputed = false>
394 : class VbCacheItemArray : public VbCacheItem<T, IsComputed> {
395 : public:
396 :
397 : typedef typename VbCacheItem<T>::Filler Filler;
398 : typedef typename T::IteratorSTL::value_type ElementType;
399 :
400 703 : VbCacheItemArray(bool isMutable = false)
401 703 : : VbCacheItem<T, IsComputed> (isMutable), capacity_p (0), shapePattern_p (NoCheck) {}
402 703 : virtual ~VbCacheItemArray () {}
403 :
404 0 : virtual void appendRows (casacore::rownr_t nRows, casacore::Bool truncate)
405 : {
406 :
407 : // Only used when time averaging
408 :
409 0 : casacore::IPosition shape = this->getItem().shape();
410 0 : casacore::Int nDims = shape.size();
411 :
412 0 : if (nDims == 0 || shapePattern_p == NoCheck){
413 : // This item is empty or unfillable so leave it alone.
414 : }
415 0 : else if (truncate){
416 :
417 : // Make any excess rows disappear with a little hack to
418 : // avoid a copy. This leaves the storage unchanged and merely
419 : // changes the associated bookkeeping values.
420 :
421 0 : AssertCc ((ssize_t)nRows <= shape.last());
422 :
423 0 : shape.last() = nRows;
424 :
425 0 : this->getItem().adjustLastAxis (shape);
426 :
427 : }
428 : else{
429 :
430 : // The array needs to resized to hold nRows worth of data. If the
431 : // shape of the existing array is the same as the existing one ignoring
432 : // the number of rows then we expect the array
433 :
434 0 : this->setAsPresent(); // This VB is being filled manually
435 0 : casacore::IPosition desiredShape = this->getVb()->getValidShape (shapePattern_p);
436 0 : casacore::IPosition currentShape = getShape();
437 :
438 : // Determine if the existing shape is the same as the desired shape
439 : // ignoring rows. If is the same, then the existing data will need
440 : // to be copied in the event that the array needs to be resized
441 : // (i.e., reallocated).
442 :
443 0 : casacore::Bool shapeOk = true; // will ignore last dimension
444 0 : for (casacore::uInt i = 0; i < currentShape.nelements() - 1; i++){
445 0 : shapeOk = shapeOk && desiredShape [i] == currentShape [i];
446 : }
447 :
448 0 : desiredShape.last() = nRows;
449 :
450 0 : if (shapeOk){
451 :
452 : // Only the number of rows differs from the current shape.
453 : // This call will preserve any existing data.
454 :
455 0 : this->getItem().adjustLastAxis (desiredShape, 20);
456 : }
457 : else {
458 :
459 : // Since the core shape is changing, the existing data is
460 : // not useful; this call will not preserve it.
461 :
462 0 : this->getItem().reformOrResize (desiredShape);
463 : }
464 0 : }
465 0 : }
466 :
467 0 : virtual void copyRowElement (casacore::Int sourceRow, casacore::Int destinationRow)
468 : {
469 0 : copyRowElementAux (this->getItem(), sourceRow, destinationRow);
470 0 : }
471 :
472 0 : virtual casacore::IPosition getShape() const
473 : {
474 0 : return this->getItem().shape();
475 : }
476 :
477 :
478 : void
479 684 : initialize (VisBufferCache * cache,
480 : VisBufferImpl2 * vb,
481 : Filler filler,
482 : VisBufferComponent2 component,
483 : ShapePattern shapePattern,
484 : casacore::Bool isKey)
485 : {
486 684 : VbCacheItem<T, IsComputed>::initialize (cache, vb, filler, component, isKey);
487 684 : shapePattern_p = shapePattern;
488 684 : }
489 :
490 :
491 : virtual casacore::Bool
492 600 : isShapeOk () const
493 : {
494 : // Check to see if the shape of this data item is consistent
495 : // with the expected shape.
496 :
497 1200 : casacore::Bool result = shapePattern_p == NoCheck ||
498 1200 : this->getItem().shape() == this->getVb()->getValidShape (shapePattern_p);
499 :
500 600 : return result;
501 : }
502 :
503 :
504 0 : casacore::Bool isArray () const
505 : {
506 0 : return true;
507 : }
508 :
509 : void
510 0 : resize (casacore::Bool copyValues)
511 : {
512 0 : if (shapePattern_p != NoCheck){
513 :
514 0 : casacore::IPosition desiredShape = this->getVb()->getValidShape (shapePattern_p);
515 :
516 0 : this->getItem().resize (desiredShape, copyValues);
517 0 : capacity_p = desiredShape.last();
518 :
519 0 : if (! copyValues){
520 : //this->getItem() = typename T::value_type();
521 0 : std::fill(this->getItem().begin( ),this->getItem().end( ),typename T::value_type());
522 : }
523 :
524 0 : }
525 0 : }
526 :
527 : virtual void
528 600 : set (const T & newItem)
529 : {
530 600 : ThrowIf (! this->isMutable() && ! this->getVb()->isWritable (), "This VisBuffer is readonly");
531 :
532 600 : ThrowIf (this->isKey() && ! this->getVb()->isRekeyable (),
533 : "This VisBuffer is does not allow row key values to be changed.");
534 :
535 : // Now check for a conformant shape.
536 :
537 600 : casacore::IPosition itemShape = newItem.shape();
538 1200 : casacore::Bool parameterShapeOk = shapePattern_p == NoCheck ||
539 1200 : itemShape == this->getVb()->getValidShape (shapePattern_p);
540 600 : ThrowIf (! parameterShapeOk,
541 : "Invalid parameter shape:: " + shapeErrorMessage (& itemShape));
542 :
543 600 : VbCacheItem<T,IsComputed>::set (newItem);
544 600 : }
545 :
546 : template <typename U>
547 : void
548 0 : set (const U & newItem)
549 : {
550 0 : if (! this->isPresent()){ // Not present so give it a shape
551 0 : set (T (this->getVb()->getValidShape (shapePattern_p)));
552 : }
553 :
554 0 : VbCacheItem<T,IsComputed>::set (newItem);
555 0 : }
556 :
557 : virtual casacore::String
558 0 : shapeErrorMessage (const casacore::IPosition * badShape = 0) const
559 : {
560 :
561 0 : ThrowIf (shapePattern_p == NoCheck,
562 : "No shape error message for NoCheck type array");
563 :
564 0 : ThrowIf (isShapeOk () && badShape == 0,
565 : "Shape is OK so no error message.");
566 :
567 0 : casacore::String badShapeString = (badShape != 0) ? badShape->toString()
568 0 : : this->getItem().shape().toString();
569 :
570 0 : std::ostringstream os;
571 :
572 0 : os << "VisBuffer::ShapeError: "
573 0 : << VisBufferComponents2::name (this->getComponent())
574 : << " should have shape "
575 0 : << this->getVb()->getValidShape(shapePattern_p).toString()
576 0 : << " but had shape "
577 0 : << badShapeString;
578 :
579 0 : return os.str();
580 0 : }
581 :
582 : protected:
583 :
584 : void
585 : assign (T & dst, const T & src)
586 : {
587 : dst.assign (src);
588 : }
589 :
590 : static void
591 0 : copyRowElementAux (casacore::Cube<typename T::value_type> & cube, casacore::Int sourceRow, casacore::Int destinationRow)
592 : {
593 0 : casacore::IPosition shape = cube.shape();
594 0 : casacore::Int nI = shape(1);
595 0 : casacore::Int nJ = shape(0);
596 :
597 0 : for (casacore::Int i = 0; i < nI; i++){
598 0 : for (casacore::Int j = 0; j < nJ; j++){
599 0 : cube (j, i, destinationRow) = cube (j, i, sourceRow);
600 : }
601 : }
602 0 : }
603 :
604 : static void
605 0 : copyRowElementAux (casacore::Matrix<typename T::value_type> & matrix, casacore::Int sourceRow, casacore::Int destinationRow)
606 : {
607 0 : casacore::IPosition shape = matrix.shape();
608 0 : casacore::Int nJ = shape(0);
609 :
610 0 : for (casacore::Int j = 0; j < nJ; j++){
611 0 : matrix (j, destinationRow) = matrix (j, sourceRow);
612 : }
613 0 : }
614 :
615 : static void
616 0 : copyRowElementAux (casacore::Array<typename T::value_type> & array, casacore::Int sourceRow, casacore::Int destinationRow)
617 : {
618 0 : casacore::IPosition shape = array.shape();
619 0 : AssertCc (shape.nelements() == 4);
620 :
621 0 : casacore::Int nH = shape(2);
622 0 : casacore::Int nI = shape(1);
623 0 : casacore::Int nJ = shape(0);
624 :
625 0 : for (casacore::Int h = 0; h < nH; h++){
626 0 : for (casacore::Int i = 0; i < nI; i++){
627 0 : for (casacore::Int j = 0; j < nJ; j++){
628 0 : array (casacore::IPosition (4, j, i, h, destinationRow)) =
629 0 : array (casacore::IPosition (4, j, i, h, sourceRow));
630 : }
631 : }
632 : }
633 0 : }
634 :
635 : static void
636 0 : copyRowElementAux (casacore::Vector<typename T::value_type> & vector, casacore::Int sourceRow, casacore::Int destinationRow)
637 : {
638 0 : vector (destinationRow) = vector (sourceRow);
639 0 : }
640 :
641 : private:
642 :
643 : casacore::Int capacity_p;
644 : ShapePattern shapePattern_p;
645 : };
646 :
647 : template <typename T, casacore::Bool IsComputed = false>
648 : class VbCacheItemVectorInt : public VbCacheItem<T, IsComputed> {
649 : public:
650 :
651 : typedef typename VbCacheItem<T>::Filler Filler;
652 : typedef typename T::value_type ElementType;
653 :
654 57 : VbCacheItemVectorInt(bool isMutable = false)
655 57 : : VbCacheItem<T, IsComputed> (isMutable), shapePattern_p (NoCheck) {}
656 57 : virtual ~VbCacheItemVectorInt () {}
657 :
658 0 : virtual void appendRows (casacore::Int nRows, casacore::Bool truncate) {(void)nRows;(void)truncate;} // no-op
659 :
660 0 : virtual void copyRowElement (casacore::Int sourceRow, casacore::Int destinationRow) {(void)sourceRow;(void)destinationRow;} //no-op
661 :
662 : void
663 57 : initialize (VisBufferCache * cache,
664 : VisBufferImpl2 * vb,
665 : Filler filler,
666 : VisBufferComponent2 component,
667 : ShapePattern shapePattern,
668 : casacore::Bool isKey) //DONE
669 : {
670 57 : VbCacheItem<T, IsComputed>::initialize (cache, vb, filler, component, isKey);
671 57 : shapePattern_p = shapePattern;
672 57 : }
673 :
674 :
675 : virtual casacore::Bool
676 0 : isShapeOk () const //DONE
677 : {
678 : // Check to see if the shape of this data item is consistent
679 : // with the expected shape.
680 :
681 0 : casacore::Bool result = shapePattern_p == NoCheck;
682 0 : result = result || this->getItem().size() ==
683 0 : this->getVb()->getValidVectorShapes(shapePattern_p).size();
684 0 : return result;
685 : }
686 :
687 :
688 0 : casacore::Bool isArray () const
689 : {
690 0 : return false;
691 : }
692 :
693 : void
694 0 : resize (casacore::Bool copyValues) //DONE
695 : {
696 0 : if (shapePattern_p != NoCheck){
697 :
698 0 : auto desiredShape = this->getVb()->getValidVectorShapes (shapePattern_p);
699 :
700 0 : this->getItem().resize(desiredShape.size(), copyValues);
701 :
702 0 : if (! copyValues){
703 0 : this->getItem() = typename T::value_type();
704 : }
705 :
706 0 : }
707 0 : }
708 :
709 : virtual void
710 0 : set (const T & newItem) //DONE
711 : {
712 0 : ThrowIf (! this->isMutable() && ! this->getVb()->isWritable (), "This VisBuffer is readonly");
713 :
714 0 : ThrowIf (this->isKey() && ! this->getVb()->isRekeyable (),
715 : "This VisBuffer is does not allow row key values to be changed.");
716 :
717 : // Now check for a conformant shape.
718 0 : if(shapePattern_p != NoCheck)
719 0 : ThrowIf (this->getItem().size() != newItem.size(),
720 : "Invalid parameter shape:: " + sizeErrorMessage (newItem.size()));
721 :
722 0 : VbCacheItem<T,IsComputed>::set (newItem);
723 0 : }
724 :
725 : template <typename U>
726 : void
727 : set (const U & newItem) //DONE
728 : {
729 : if (! this->isPresent()){ // Not present so give it a shape
730 : auto desiredShape = this->getVb()->getValidVectorShapes (shapePattern_p);
731 : T item(desiredShape.size());
732 : set (T (item));
733 : }
734 :
735 : VbCacheItem<T,IsComputed>::set (newItem);
736 : }
737 :
738 : protected:
739 :
740 :
741 : virtual casacore::String
742 0 : sizeErrorMessage (casacore::Int badSize) const
743 : {
744 0 : std::ostringstream os;
745 :
746 0 : os << "VisBuffer::ShapeError: "
747 0 : << VisBufferComponents2::name (this->getComponent())
748 0 : << " should have shape "
749 0 : << this->getVb()->getValidVectorShapes(shapePattern_p).size()
750 0 : << " but had shape "
751 0 : << badSize;
752 :
753 0 : return os.str();
754 0 : }
755 :
756 : void
757 : assign (T & dst, const T & src) //DONE
758 : {
759 : dst.assign (src);
760 : }
761 :
762 : private:
763 :
764 : ShapePattern shapePattern_p;
765 : };
766 :
767 : template <typename T, casacore::Bool IsComputed = false>
768 : class VbCacheItemVectorArray : public VbCacheItem<T, IsComputed> {
769 : public:
770 :
771 : typedef typename VbCacheItem<T>::Filler Filler;
772 : typedef typename T::value_type::value_type ElementType;
773 :
774 171 : VbCacheItemVectorArray(bool isMutable = false)
775 171 : : VbCacheItem<T, IsComputed> (isMutable), shapePattern_p (NoCheck) {}
776 171 : virtual ~VbCacheItemVectorArray () {}
777 :
778 0 : virtual void appendRows (casacore::Int nRows, casacore::Bool truncate)
779 : {
780 0 : casacore::IPosition shape = this->getItem().shape();
781 : (void)truncate;
782 : // Only used when time averaging
783 0 : if (shapePattern_p == NoCheck){
784 : // This item is empty or unfillable so leave it alone.
785 : }
786 : else
787 : {
788 0 : resize(true);
789 0 : resizeRows(nRows);
790 : }
791 0 : }
792 :
793 0 : virtual void copyRowElement (casacore::Int sourceRow, casacore::Int destinationRow)
794 : {
795 0 : copyRowElementAux (this->getItem(), sourceRow, destinationRow);
796 0 : }
797 :
798 : void
799 171 : initialize (VisBufferCache * cache,
800 : VisBufferImpl2 * vb,
801 : Filler filler,
802 : VisBufferComponent2 component,
803 : ShapePattern shapePattern,
804 : casacore::Bool isKey)
805 : {
806 171 : VbCacheItem<T, IsComputed>::initialize (cache, vb, filler, component, isKey);
807 171 : shapePattern_p = shapePattern;
808 171 : }
809 :
810 :
811 : virtual casacore::Bool
812 0 : isShapeOk () const
813 : {
814 : // Check to see if the shape of this data item is consistent
815 : // with the expected shape.
816 :
817 0 : casacore::Bool result = shapePattern_p == NoCheck;
818 0 : result = result || this->getItem().size() ==
819 0 : this->getVb()->getValidVectorShapes(shapePattern_p).size();
820 0 : if (result)
821 : {
822 0 : for (size_t iElem = 0 ; iElem < this->getItem().size(); ++iElem)
823 0 : result = result ||
824 0 : this->getItem()[iElem].shape() == this->getVb()->getValidVectorShapes (shapePattern_p)[iElem];
825 : }
826 0 : return result;
827 : }
828 :
829 :
830 0 : casacore::Bool isArray () const
831 : {
832 0 : return true;
833 : }
834 :
835 : void
836 0 : resize (casacore::Bool copyValues)
837 : {
838 0 : if (shapePattern_p != NoCheck){
839 :
840 0 : auto desiredShape = this->getVb()->getValidVectorShapes (shapePattern_p);
841 :
842 0 : this->getItem().resize(desiredShape.size(), copyValues);
843 0 : for (size_t iElem = 0 ; iElem < this->getItem().size(); ++iElem)
844 0 : this->getItem()[iElem].resize(desiredShape[iElem], copyValues);
845 :
846 0 : if (! copyValues){
847 0 : for (size_t iElem = 0 ; iElem < this->getItem().size(); ++iElem)
848 0 : this->getItem()[iElem] = typename T::value_type::value_type();
849 : }
850 :
851 0 : }
852 0 : }
853 :
854 : void
855 0 : resizeRows (casacore::Int newNRows)
856 : {
857 0 : if (shapePattern_p != NoCheck){
858 : // This will count the rows of each array and as soon as the number of rows exceeds
859 : // the requested one it will resize (shrink) that array. If the total number of rows is
860 : // less than the requested one, then the last array is resized (expanded).
861 0 : int nCumRows=0;
862 : size_t iElem;
863 0 : for (iElem = 0 ; iElem < this->getItem().size(); ++iElem)
864 : {
865 0 : auto & thisShape = this->getItem()[iElem].shape();
866 0 : nCumRows += thisShape.last();
867 0 : if (nCumRows > newNRows)
868 : {
869 0 : casacore::IPosition newShape = thisShape;
870 0 : newShape.last() = newNRows - (nCumRows - thisShape.last());
871 0 : this->getItem()[iElem].resize (newShape, true);
872 0 : break;
873 0 : }
874 : }
875 0 : if (nCumRows < newNRows)
876 : {
877 0 : casacore::IPosition lastArrayShape = this->getItem()[this->getItem().size()-1].shape();
878 0 : casacore::IPosition newShape = lastArrayShape;
879 0 : newShape.last() = newNRows - nCumRows;
880 0 : this->getItem()[this->getItem().size()-1].resize (newShape, true);
881 0 : }
882 : else
883 0 : this->getItem().resize(iElem, true);
884 :
885 0 : this->setDirty();
886 : }
887 0 : }
888 :
889 : virtual void
890 0 : set (const T & newItem)
891 : {
892 0 : ThrowIf (! this->isMutable() && ! this->getVb()->isWritable (), "This VisBuffer is readonly");
893 :
894 0 : ThrowIf (this->isKey() && ! this->getVb()->isRekeyable (),
895 : "This VisBuffer is does not allow row key values to be changed.");
896 :
897 : // Now check for a conformant shape.
898 0 : if(shapePattern_p != NoCheck)
899 : {
900 0 : ThrowIf (this->getItem().size() != newItem.size(),
901 : "Invalid parameter shape:: " + sizeErrorMessage (newItem.size()));
902 0 : for (size_t iElem = 0 ; iElem < this->getItem().size(); ++iElem)
903 0 : ThrowIf (this->getItem()[iElem].shape() != newItem[iElem].shape(),
904 : "Invalid parameter shape:: " + shapeErrorMessage (iElem, &(newItem[iElem].shape())));
905 : }
906 :
907 0 : VbCacheItem<T,IsComputed>::set (newItem);
908 0 : }
909 :
910 : template <typename U>
911 : void
912 : set (const U & newItem)
913 : {
914 : if (! this->isPresent()){ // Not present so give it a shape
915 : auto desiredShape = this->getVb()->getValidVectorShape (shapePattern_p);
916 : T item(desiredShape.size());
917 : for (size_t iElem = 0 ; iElem < item.size(); ++iElem)
918 : item[iElem].resize(desiredShape[iElem]);
919 :
920 : set (T (item));
921 : }
922 :
923 : VbCacheItem<T,IsComputed>::set (newItem);
924 : }
925 :
926 : protected:
927 :
928 : virtual casacore::String
929 0 : shapeErrorMessage (casacore::Int i, const casacore::IPosition * badShape = 0) const
930 : {
931 :
932 0 : ThrowIf (shapePattern_p == NoCheck,
933 : "No shape error message for NoCheck type array");
934 :
935 0 : ThrowIf (isShapeOk () && badShape == 0,
936 : "Shape is OK so no error message.");
937 :
938 0 : casacore::String badShapeString = (badShape != 0) ? badShape->toString()
939 0 : : this->getItem()[i].shape().toString();
940 :
941 0 : std::ostringstream os;
942 :
943 0 : os << "VisBuffer::ShapeError: "
944 0 : << VisBufferComponents2::name (this->getComponent())
945 : << " should have shape "
946 0 : << this->getVb()->getValidVectorShapes(shapePattern_p)[i].toString()
947 0 : << " but had shape "
948 0 : << badShapeString;
949 :
950 0 : return os.str();
951 0 : }
952 :
953 : virtual casacore::String
954 0 : sizeErrorMessage (casacore::Int badSize) const
955 : {
956 0 : std::ostringstream os;
957 :
958 0 : os << "VisBuffer::ShapeError: "
959 0 : << VisBufferComponents2::name (this->getComponent())
960 0 : << " should have shape "
961 0 : << this->getVb()->getValidVectorShapes(shapePattern_p).size()
962 0 : << " but had shape "
963 0 : << badSize;
964 :
965 0 : return os.str();
966 0 : }
967 :
968 : static void
969 0 : copyRowElementAux (casacore::Vector<casacore::Cube<typename T::value_type::value_type>> & cubeVector, casacore::Int sourceRow, casacore::Int destinationRow)
970 : {
971 0 : int nCumRows=0, sourceCube =-1, destinationCube = -1;
972 0 : int sourceCubeRow = 0, destinationCubeRow = 0;
973 0 : for (size_t iCube = 0 ; iCube < cubeVector.size(); ++iCube)
974 : {
975 0 : auto & thisShape = cubeVector[iCube].shape();
976 0 : nCumRows += thisShape.last();
977 0 : if (nCumRows < sourceCube)
978 : {
979 0 : sourceCube = iCube;
980 0 : sourceCubeRow = sourceRow - nCumRows;
981 : }
982 0 : if (nCumRows < destinationCube)
983 : {
984 0 : destinationCube = iCube;
985 0 : destinationCubeRow = destinationRow - nCumRows;
986 : }
987 : }
988 :
989 0 : ThrowIf (sourceCube != destinationCube || sourceCube == -1 || destinationCube == -1,
990 : "Copying rows between incompatible cubes is not allowed");
991 :
992 0 : casacore::IPosition shape = cubeVector[sourceCube].shape();
993 0 : casacore::Int nI = shape(1);
994 0 : casacore::Int nJ = shape(0);
995 :
996 0 : for (casacore::Int i = 0; i < nI; i++){
997 0 : for (casacore::Int j = 0; j < nJ; j++){
998 0 : cubeVector[destinationCube] (j, i, destinationCubeRow) = cubeVector[sourceCube] (j, i, sourceCubeRow);
999 : }
1000 : }
1001 0 : }
1002 :
1003 : static void
1004 0 : copyRowElementAux (casacore::Vector<casacore::Matrix<typename T::value_type::value_type>> & matrixVector, casacore::Int sourceRow, casacore::Int destinationRow)
1005 : {
1006 0 : int nCumRows=0, sourceMatrix =-1, destinationMatrix = -1;
1007 0 : casacore::rownr_t sourceMatrixRow = 0, destinationMatrixRow = 0;
1008 0 : for (casacore::rownr_t iMatrix = 0 ; iMatrix < matrixVector.size(); ++iMatrix)
1009 : {
1010 0 : auto & thisShape = matrixVector[iMatrix].shape();
1011 0 : nCumRows += thisShape.last();
1012 0 : if (nCumRows < sourceMatrix)
1013 : {
1014 0 : sourceMatrix = iMatrix;
1015 0 : sourceMatrixRow = sourceRow - nCumRows;
1016 : }
1017 0 : if (nCumRows < destinationMatrix)
1018 : {
1019 0 : destinationMatrix = iMatrix;
1020 0 : destinationMatrixRow = destinationRow - nCumRows;
1021 : }
1022 : }
1023 :
1024 0 : ThrowIf (sourceMatrix != destinationMatrix || sourceMatrix == -1 || destinationMatrix == -1,
1025 : "Copying rows between incompatible matrices is not allowed");
1026 :
1027 0 : casacore::IPosition shape = matrixVector[sourceMatrix].shape();
1028 0 : casacore::Int nJ = shape(0);
1029 :
1030 0 : for (casacore::Int j = 0; j < nJ; j++){
1031 0 : matrixVector[destinationMatrix] (j, destinationMatrixRow) = matrixVector[sourceMatrix] (j, sourceMatrixRow);
1032 : }
1033 0 : }
1034 :
1035 : static void
1036 : copyRowElementAux (casacore::Vector<casacore::Vector<typename T::value_type::value_type>> & vectorVector, casacore::Int sourceRow, casacore::Int destinationRow)
1037 : {
1038 : int nCumRows=0, sourceVector =-1, destinationVector = -1;
1039 : int sourceVectorRow, destinationVectorRow;
1040 : for (size_t iVector = 0 ; iVector < vectorVector.size(); ++iVector)
1041 : {
1042 : auto & thisShape = vectorVector[iVector].shape();
1043 : nCumRows += thisShape.last();
1044 : if (nCumRows < sourceVector)
1045 : {
1046 : sourceVector = iVector;
1047 : sourceVectorRow = sourceRow - nCumRows;
1048 : }
1049 : if (nCumRows < destinationVector)
1050 : {
1051 : destinationVector = iVector;
1052 : destinationVectorRow = destinationRow - nCumRows;
1053 : }
1054 : }
1055 :
1056 : ThrowIf (sourceVector != destinationVector || sourceVector == -1 || destinationVector == -1,
1057 : "Copying rows between incompatible matrices is not allowed");
1058 :
1059 : vectorVector[destinationVector] (destinationVectorRow) = vectorVector[sourceVector] (sourceVectorRow);
1060 : }
1061 :
1062 :
1063 : private:
1064 :
1065 : ShapePattern shapePattern_p;
1066 : };
1067 :
1068 :
1069 :
1070 :
1071 : class VisBufferCache {
1072 :
1073 : // Holds the cached values for a VisBuffer object.
1074 :
1075 : public:
1076 :
1077 : VisBufferCache (VisBufferImpl2 * vb);
1078 :
1079 : void appendComplete ();
1080 : casacore::Int appendRow ();
1081 : void initialize (VisBufferImpl2 * vb);
1082 : void registerItem (VbCacheItemBase * item);
1083 :
1084 : // The values that are potentially cached.
1085 :
1086 : VbCacheItemArray <casacore::Vector<casacore::Int> > antenna1_p;
1087 : VbCacheItemArray <casacore::Vector<casacore::Int> > antenna2_p;
1088 : VbCacheItemArray <casacore::Vector<casacore::Int> > arrayId_p;
1089 : VbCacheItemArray <casacore::Vector<casacore::SquareMatrix<casacore::Complex, 2> >, true> cjones_p;
1090 : VbCacheItemArray <casacore::Cube<casacore::Complex> > correctedVisCube_p;
1091 : VbCacheItemVectorArray <casacore::Vector<casacore::Cube<casacore::Complex>>> correctedVisCubes_p;
1092 : // VbCacheItemArray <casacore::Matrix<CStokesVector> > correctedVisibility_p;
1093 : VbCacheItemArray <casacore::Vector<casacore::Int> > corrType_p;
1094 : VbCacheItem <casacore::Int> dataDescriptionId_p;
1095 : VbCacheItemArray <casacore::Vector<casacore::Int> > dataDescriptionIds_p;
1096 : VbCacheItemArray <casacore::Vector<casacore::MDirection> > direction1_p; //where the first antenna/feed is pointed to
1097 : VbCacheItemArray <casacore::Vector<casacore::MDirection> > direction2_p; //where the second antenna/feed is pointed to
1098 : VbCacheItemArray <casacore::Vector<casacore::Double> > exposure_p;
1099 : VbCacheItemArray <casacore::Vector<casacore::Int> > feed1_p;
1100 : VbCacheItemArray <casacore::Vector<casacore::Float> > feed1Pa_p;
1101 : VbCacheItemArray <casacore::Vector<casacore::Int> > feed2_p;
1102 : VbCacheItemArray <casacore::Vector<casacore::Float> > feed2Pa_p;
1103 : VbCacheItemArray <casacore::Vector<casacore::Int> > fieldId_p;
1104 : // VbCacheItemArray <casacore::Matrix<casacore::Bool> > flag_p;
1105 : VbCacheItemArray <casacore::Array<casacore::Bool> > flagCategory_p;
1106 : VbCacheItemArray <casacore::Vector<casacore::Array<casacore::Bool>>> flagCategories_p;
1107 : VbCacheItemArray <casacore::Cube<casacore::Bool> > flagCube_p;
1108 : VbCacheItemVectorArray <casacore::Vector<casacore::Cube<casacore::Bool>>> flagCubes_p;
1109 : VbCacheItemArray <casacore::Vector<casacore::Bool> > flagRow_p;
1110 : VbCacheItemArray <casacore::Cube<casacore::Float> > floatDataCube_p;
1111 : VbCacheItemVectorArray <casacore::Vector<casacore::Cube<casacore::Float>>> floatDataCubes_p;
1112 : VbCacheItemArray <casacore::Matrix<casacore::Float> > imagingWeight_p;
1113 : VbCacheItemArray <casacore::Cube<casacore::Complex> > modelVisCube_p;
1114 : VbCacheItemVectorArray <casacore::Vector<casacore::Cube<casacore::Complex>>> modelVisCubes_p;
1115 : // VbCacheItemArray <casacore::Matrix<CStokesVector> > modelVisibility_p;
1116 : VbCacheItem <casacore::Int> nAntennas_p;
1117 : VbCacheItem <casacore::Int> nChannels_p;
1118 : VbCacheItem <casacore::Int> nCorrelations_p;
1119 : VbCacheItem <casacore::Int> nRows_p;
1120 : VbCacheItem <casacore::Int> nShapes_p;
1121 : VbCacheItemVectorInt <casacore::Vector<casacore::rownr_t>> nRowsPerShape_p;
1122 : VbCacheItemVectorInt <casacore::Vector<casacore::Int>> nChannelsPerShape_p;
1123 : VbCacheItemVectorInt <casacore::Vector<casacore::Int>> nCorrelationsPerShape_p;
1124 : VbCacheItemArray <casacore::Vector<casacore::Int> > observationId_p;
1125 : VbCacheItem <casacore::MDirection> phaseCenter_p;
1126 : VbCacheItem <casacore::Int> polFrame_p;
1127 : VbCacheItem <casacore::Int> polarizationId_p;
1128 : VbCacheItemArray <casacore::Vector<casacore::Int> > processorId_p;
1129 : VbCacheItemArray <casacore::Vector<casacore::rownr_t> > rowIds_p;
1130 : VbCacheItemArray <casacore::Vector<casacore::Int> > scan_p;
1131 : VbCacheItemArray <casacore::Matrix<casacore::Float> > sigma_p;
1132 : VbCacheItemVectorArray <casacore::Vector<casacore::Matrix<casacore::Float>>> sigmas_p;
1133 : //VbCacheItemArray <casacore::Matrix<casacore::Float> > sigmaMat_p;
1134 : VbCacheItemArray <casacore::Vector<casacore::Int> > spectralWindows_p;
1135 : VbCacheItemArray <casacore::Vector<casacore::Int> > stateId_p;
1136 : VbCacheItemArray <casacore::Vector<casacore::Double> > time_p;
1137 : VbCacheItemArray <casacore::Vector<casacore::Double> > timeCentroid_p;
1138 : VbCacheItemArray <casacore::Vector<casacore::Double> > timeInterval_p;
1139 : VbCacheItemArray <casacore::Matrix<casacore::Double> > uvw_p;
1140 : VbCacheItemArray <casacore::Cube<casacore::Complex> > visCube_p;
1141 : VbCacheItemVectorArray <casacore::Vector<casacore::Cube<casacore::Complex>>> visCubes_p;
1142 : // VbCacheItemArray <casacore::Matrix<CStokesVector> > visibility_p;
1143 : VbCacheItemArray <casacore::Matrix<casacore::Float> > weight_p;
1144 : VbCacheItemVectorArray <casacore::Vector<casacore::Matrix<casacore::Float>>> weights_p;
1145 : //VbCacheItemArray <casacore::Matrix<casacore::Float> > weightMat_p;
1146 : VbCacheItemArray <casacore::Cube<casacore::Float> > weightSpectrum_p;
1147 : VbCacheItemVectorArray <casacore::Vector<casacore::Cube<casacore::Float>>> weightSpectra_p;
1148 : VbCacheItemArray <casacore::Cube<casacore::Float> > sigmaSpectrum_p;
1149 : VbCacheItemVectorArray <casacore::Vector<casacore::Cube<casacore::Float>>> sigmaSpectra_p;
1150 :
1151 : CacheRegistry registry_p;
1152 :
1153 : template <typename T, typename U>
1154 : static void
1155 0 : sortCorrelationItem (vi::VbCacheItem<T> & dataItem, casacore::IPosition & blc, casacore::IPosition & trc,
1156 : casacore::IPosition & mat, U & tmp, casacore::Bool sort)
1157 : {
1158 :
1159 0 : T & data = dataItem.getRef ();
1160 0 : U p1, p2, p3;
1161 :
1162 0 : if (dataItem.isPresent() && data.nelements() > 0) {
1163 :
1164 0 : blc(0) = trc(0) = 1;
1165 0 : p1.reference(data (blc, trc).reform(mat));
1166 :
1167 0 : blc(0) = trc(0) = 2;
1168 0 : p2.reference(data (blc, trc).reform(mat));
1169 :
1170 0 : blc(0) = trc(0) = 3;
1171 0 : p3.reference(data (blc, trc).reform(mat));
1172 :
1173 0 : if (sort){ // casacore::Sort correlations: (PP,QQ,PQ,QP) -> (PP,PQ,QP,QQ)
1174 :
1175 0 : tmp = p1;
1176 0 : p1 = p2;
1177 0 : p2 = p3;
1178 0 : p3 = tmp;
1179 : }
1180 : else { // Unsort correlations: (PP,PQ,QP,QQ) -> (PP,QQ,PQ,QP)
1181 :
1182 0 : tmp = p3;
1183 0 : p3 = p2;
1184 0 : p2 = p1;
1185 0 : p1 = tmp;
1186 : }
1187 : }
1188 0 : }
1189 : };
1190 :
1191 : class VisBufferState {
1192 :
1193 : public:
1194 :
1195 : template<typename T>
1196 : class FrequencyCache {
1197 : public:
1198 :
1199 : typedef casacore::Vector<T> (ViImplementation2::* Updater) (casacore::Double, casacore::Int, casacore::Int, casacore::Int) const;
1200 :
1201 38 : FrequencyCache (Updater updater)
1202 38 : : frame_p (-1),
1203 38 : msId_p (-1),
1204 38 : spectralWindowId_p (-1),
1205 38 : time_p (-1),
1206 38 : updater_p (updater)
1207 38 : {}
1208 :
1209 : casacore::Int frame_p;
1210 : casacore::Int msId_p;
1211 : casacore::Int spectralWindowId_p;
1212 : casacore::Double time_p;
1213 : Updater updater_p;
1214 : casacore::Vector<T> values_p;
1215 :
1216 : void
1217 6492 : flush ()
1218 : {
1219 6492 : time_p = -1; // will be enough to cause a reload
1220 6492 : }
1221 :
1222 : void
1223 6219 : updateCacheIfNeeded (const ViImplementation2 * rovi,
1224 : casacore::Int rowInBuffer,
1225 : casacore::Int frame,
1226 : const VisBufferImpl2 * vb)
1227 : {
1228 6219 : casacore::Int msId = vb->msId();
1229 6219 : casacore::Int spectralWindowId = vb->spectralWindows()(rowInBuffer);
1230 6219 : casacore::Double time = vb->time()(rowInBuffer);
1231 :
1232 6219 : if (time == time_p && frame == frame_p && msId == msId_p &&
1233 5013 : spectralWindowId == spectralWindowId_p){
1234 5013 : return;
1235 : }
1236 :
1237 1206 : time_p = time;
1238 1206 : frame_p = frame;
1239 1206 : msId_p = msId;
1240 1206 : spectralWindowId_p = spectralWindowId;
1241 :
1242 1206 : values_p.assign ((rovi ->* updater_p) (time_p, frame_p, spectralWindowId_p, msId_p));
1243 : }
1244 : };
1245 :
1246 19 : VisBufferState ()
1247 19 : : appendCapacity_p (0),
1248 19 : appendSize_p (0),
1249 19 : areCorrelationsSorted_p (false),
1250 19 : channelNumbers_p (& ViImplementation2::getChannels),
1251 19 : dirtyComponents_p (),
1252 19 : frequencies_p (& ViImplementation2::getFrequencies),
1253 19 : isAttached_p (false),
1254 19 : isFillable_p (false),
1255 19 : isNewMs_p (false),
1256 19 : isNewArrayId_p (false),
1257 19 : isNewFieldId_p (false),
1258 19 : isNewSpectralWindow_p (false),
1259 19 : isRekeyable_p (false),
1260 19 : isWritable_p (false),
1261 19 : msId_p (-1),
1262 19 : pointingTableLastRow_p (-1),
1263 19 : validShapes_p (N_ShapePatterns),
1264 19 : validVectorShapes_p (N_ShapePatterns),
1265 19 : vi_p (0),
1266 19 : visModelData_p (0),
1267 57 : weightScaling_p ( )
1268 19 : {}
1269 :
1270 : casacore::Int appendCapacity_p;
1271 : casacore::Int appendSize_p;
1272 : casacore::Bool areCorrelationsSorted_p; // Have correlations been sorted by sortCorr?
1273 : FrequencyCache<casacore::Int> channelNumbers_p;
1274 : casacore::Vector<casacore::Int> correlations_p;
1275 : casacore::Vector<casacore::Stokes::StokesTypes> correlationsDefined_p;
1276 : casacore::Vector<casacore::Stokes::StokesTypes> correlationsSelected_p;
1277 : VisBufferComponents2 dirtyComponents_p;
1278 : FrequencyCache<casacore::Double> frequencies_p;
1279 : casacore::Bool isAttached_p;
1280 : casacore::Bool isFillable_p;
1281 : casacore::Bool isNewMs_p;
1282 : casacore::Bool isNewArrayId_p;
1283 : casacore::Bool isNewFieldId_p;
1284 : casacore::Bool isNewSpectralWindow_p;
1285 : casacore::Bool isRekeyable_p;
1286 : casacore::Bool isWritable_p;
1287 : casacore::Int msId_p;
1288 : casacore::String msName_p;
1289 : casacore::Bool newMs_p;
1290 : mutable casacore::Int pointingTableLastRow_p;
1291 : Subchunk subchunk_p;
1292 : casacore::Vector<casacore::IPosition> validShapes_p;
1293 : casacore::Vector<casacore::Vector<casacore::IPosition>> validVectorShapes_p;
1294 : ViImplementation2 * vi_p; // [use]
1295 : mutable VisModelDataI * visModelData_p;
1296 : casacore::CountedPtr <WeightScaling> weightScaling_p;
1297 : };
1298 :
1299 :
1300 : }
1301 :
1302 : }
1303 :
1304 :
1305 : #endif /* VISBUFFERIMPL2INTERNAL_H_ */
|
