Line data Source code
1 : //# FlagCalTableHandler.h: This file contains the implementation of the FlagCalTableHandler class.
2 : //#
3 : //# CASA - Common Astronomy Software Applications (http://casa.nrao.edu/)
4 : //# Copyright (C) Associated Universities, Inc. Washington DC, USA 2011, All rights reserved.
5 : //# Copyright (C) European Southern Observatory, 2011, All rights reserved.
6 : //#
7 : //# This library is free software; you can redistribute it and/or
8 : //# modify it under the terms of the GNU Lesser General Public
9 : //# License as published by the Free software Foundation; either
10 : //# version 2.1 of the License, or (at your option) any later version.
11 : //#
12 : //# This library is distributed in the hope that it will be useful,
13 : //# but WITHOUT ANY WARRANTY, without even the implied warranty of
14 : //# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : //# Lesser General Public License for more details.
16 : //#
17 : //# You should have received a copy of the GNU Lesser General Public
18 : //# License along with this library; if not, write to the Free Software
19 : //# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20 : //# MA 02111-1307 USA
21 : //# $Id: $
22 :
23 : #include <flagging/Flagging/FlagCalTableHandler.h>
24 :
25 : #include <synthesis/CalTables/NewCalTable.h>
26 : #include <synthesis/CalTables/CTInterface.h>
27 : #include <synthesis/CalTables/CTIter.h>
28 : #include <synthesis/CalTables/CalBuffer.h>
29 :
30 : using namespace casacore;
31 : namespace casa { //# NAMESPACE CASA - BEGIN
32 :
33 : //////////////////////////////////////////
34 : /// FlagCalTableHandler implementation ///
35 : //////////////////////////////////////////
36 :
37 : // -----------------------------------------------------------------------
38 : // Default constructor
39 : // -----------------------------------------------------------------------
40 0 : FlagCalTableHandler::FlagCalTableHandler(string tablename, uShort iterationApproach, Double timeInterval):
41 0 : FlagDataHandler(tablename,iterationApproach,timeInterval)
42 : {
43 0 : selectedCalTable_p = NULL;
44 0 : originalCalTable_p = NULL;
45 0 : calTableInterface_p = NULL;
46 0 : calBuffer_p = NULL;
47 0 : calIter_p = NULL;
48 0 : tableTye_p = CALIBRATION_TABLE;
49 0 : }
50 :
51 : // -----------------------------------------------------------------------
52 : // Default destructor
53 : // -----------------------------------------------------------------------
54 0 : FlagCalTableHandler::~FlagCalTableHandler()
55 : {
56 0 : logger_p->origin(LogOrigin("FlagCalTableHandler",__FUNCTION__,WHERE));
57 0 : *logger_p << LogIO::DEBUG1 << "FlagCalTableHandler::~FlagCalTableHandler()" << LogIO::POST;
58 :
59 0 : if (calBuffer_p) delete calBuffer_p;
60 0 : if (calIter_p) delete calIter_p;
61 0 : if (calTableInterface_p) delete calTableInterface_p;
62 0 : if (selectedCalTable_p) delete selectedCalTable_p;
63 0 : if (originalCalTable_p) delete originalCalTable_p;
64 0 : }
65 :
66 :
67 : // -----------------------------------------------------------------------
68 : // Open CalTable
69 : // -----------------------------------------------------------------------
70 : bool
71 0 : FlagCalTableHandler::open()
72 : {
73 0 : if (originalCalTable_p) delete originalCalTable_p;
74 0 : originalCalTable_p = new NewCalTable(tablename_p,Table::Update,Table::Plain);
75 :
76 : // Read field names
77 0 : MSFieldColumns fieldSubTable(originalCalTable_p->field());
78 0 : fieldNames_p = new Vector<String>(fieldSubTable.name().getColumn());
79 0 : *logger_p << LogIO::DEBUG1 << "Field names are " << *fieldNames_p << LogIO::POST;
80 :
81 : // Read antenna names and diameters from Antenna table
82 0 : MSAntennaColumns antennaSubTable(originalCalTable_p->antenna());
83 0 : antennaNames_p = new Vector<String>(antennaSubTable.name().getColumn());
84 0 : antennaDiameters_p = new Vector<Double>(antennaSubTable.dishDiameter().getColumn());
85 0 : antennaPositions_p = new ROScalarMeasColumn<MPosition>(antennaSubTable.positionMeas());
86 0 : *logger_p << LogIO::DEBUG1 << "There are " << antennaNames_p->size() << " antennas with names: " << *antennaNames_p << LogIO::POST;
87 :
88 : // File the baseline to Ant1xAnt2 map
89 0 : String baseline;
90 0 : std::pair<Int,Int> ant1ant2;
91 0 : for (Int ant1Idx=0;ant1Idx < static_cast<Int>(antennaNames_p->size());ant1Idx++)
92 : {
93 0 : for (Int ant2Idx=ant1Idx+1;ant2Idx < static_cast<Int>(antennaNames_p->size());ant2Idx++)
94 : {
95 0 : ant1ant2.first = ant1Idx;
96 0 : ant1ant2.second = ant2Idx;
97 0 : baseline = antennaNames_p->operator()(ant1Idx) + "&&" + antennaNames_p->operator()(ant2Idx);
98 0 : baselineToAnt1Ant2_p[baseline] = ant1ant2;
99 0 : Ant1Ant2ToBaseline_p[ant1ant2] = baseline;
100 : }
101 : }
102 :
103 : // Create "dummy" correlation products list
104 0 : corrProducts_p = new std::vector<String>();
105 0 : corrProducts_p->push_back("SOL1");
106 0 : corrProducts_p->push_back("SOL2");
107 0 : corrProducts_p->push_back("SOL3");
108 0 : corrProducts_p->push_back("SOL4");
109 :
110 0 : return true;
111 0 : }
112 :
113 :
114 : // -----------------------------------------------------------------------
115 : // Close CalTable
116 : // -----------------------------------------------------------------------
117 : bool
118 0 : FlagCalTableHandler::close()
119 : {
120 0 : if (selectedCalTable_p)
121 : {
122 0 : selectedCalTable_p->flush();
123 0 : selectedCalTable_p->relinquishAutoLocks(true);
124 0 : selectedCalTable_p->unlock();
125 : }
126 :
127 0 : return true;
128 : }
129 :
130 :
131 : // -----------------------------------------------------------------------
132 : // Generate selected CalTable
133 : // -----------------------------------------------------------------------
134 : bool
135 0 : FlagCalTableHandler::selectData()
136 : {
137 0 : logger_p->origin(LogOrigin("FlagCalTableHandler",__FUNCTION__,WHERE));
138 :
139 0 : if (calTableInterface_p) delete calTableInterface_p;
140 0 : calTableInterface_p = new CTInterface(*originalCalTable_p);
141 :
142 0 : if (measurementSetSelection_p) delete measurementSetSelection_p;
143 0 : const String dummyExpr = String("");
144 0 : measurementSetSelection_p = new MSSelection();
145 0 : measurementSetSelection_p->reset(*calTableInterface_p,
146 0 : MSSelection::PARSE_LATE,
147 0 : (const String)timeSelection_p,
148 0 : (const String)baselineSelection_p,
149 0 : (const String)fieldSelection_p,
150 0 : (const String)spwSelection_p,
151 0 : (const String)uvwSelection_p,
152 : dummyExpr, // taqlExpr
153 0 : (const String)polarizationSelection_p,
154 0 : (const String)scanSelection_p,
155 0 : (const String)arraySelection_p,
156 0 : (const String)scanIntentSelection_p,
157 0 : (const String)observationSelection_p);
158 :
159 :
160 0 : if (selectedCalTable_p) delete selectedCalTable_p;
161 :
162 : // try
163 : // {
164 0 : TableExprNode ten = measurementSetSelection_p->toTableExprNode(calTableInterface_p);
165 0 : selectedCalTable_p = new NewCalTable();
166 0 : Bool madeSelection = getSelectedTable(*selectedCalTable_p,*originalCalTable_p,ten,String(""));
167 :
168 0 : if (madeSelection == false)
169 : {
170 0 : *logger_p << LogIO::NORMAL << "Selection not applicable, using entire MS" << LogIO::POST;
171 0 : delete selectedCalTable_p;
172 0 : selectedCalTable_p = new NewCalTable(*originalCalTable_p);
173 : }
174 : // }
175 : // catch (MSSelectionError &ex)
176 : // {
177 : // *logger_p << LogIO::WARN << "Selection not supported, using entire MS (" << ex.getMesg() << ")" << LogIO::POST;
178 : // delete selectedCalTable_p;
179 : // selectedCalTable_p = new NewCalTable(*originalCalTable_p);
180 : // }
181 :
182 : // Check if selected CalTable has rows...
183 0 : if (selectedCalTable_p->nrow() == 0)
184 : {
185 0 : *logger_p << LogIO::WARN << "Selected CalTable doesn't have any rows " << LogIO::POST;
186 : }
187 : else
188 : {
189 0 : *logger_p << LogIO::NORMAL << "Original CalTable has "
190 0 : << originalCalTable_p->nrow()
191 : << " rows, and selected CalTable has "
192 0 : << selectedCalTable_p->nrow()
193 0 : << " rows" << LogIO::POST;
194 : }
195 :
196 : // There is a new selected MS so iterators have to be regenerated
197 0 : iteratorGenerated_p = false;
198 0 : chunksInitialized_p = false;
199 0 : buffersInitialized_p = false;
200 0 : stopIteration_p = false;
201 :
202 0 : return true;
203 0 : }
204 :
205 :
206 : // -----------------------------------------------------------------------
207 : // Parse MSSelection expression
208 : // -----------------------------------------------------------------------
209 : bool
210 0 : FlagCalTableHandler::parseExpression(MSSelection &parser)
211 : {
212 0 : logger_p->origin(LogOrigin("FlagCalTableHandler",__FUNCTION__,WHERE));
213 0 : CTInterface tmpCTInterface(*originalCalTable_p);
214 :
215 : try
216 : {
217 0 : TableExprNode ten = parser.toTableExprNode(&tmpCTInterface);
218 0 : }
219 0 : catch (MSSelectionError &ex)
220 : {
221 0 : *logger_p << LogIO::WARN << "Selection not supported, canceling filtering (" << ex.getMesg() << ")" << LogIO::POST;
222 0 : return false;
223 0 : }
224 :
225 0 : return true;
226 0 : }
227 :
228 :
229 : // -----------------------------------------------------------------------
230 : // Generate CalIter with a given sort order and time interval
231 : // -----------------------------------------------------------------------
232 : bool
233 0 : FlagCalTableHandler::generateIterator()
234 : {
235 0 : if (!iteratorGenerated_p)
236 : {
237 : // Generate CalIterator
238 0 : if (calIter_p) delete calIter_p;
239 0 : calIter_p = new CTIter(*selectedCalTable_p,getSortColumns(sortOrder_p));
240 :
241 : // Create CalBuffer and put VisBuffer wrapper around
242 : // NOTE: VisBuferAutoPtr destructor also deletes the VisBuffer inside
243 0 : if (visibilityBuffer_p) delete visibilityBuffer_p;
244 0 : calBuffer_p = new CTBuffer(calIter_p);
245 0 : visibilityBuffer_p = (vi::VisBuffer2 *)calBuffer_p;
246 :
247 0 : iteratorGenerated_p = true;
248 0 : chunksInitialized_p = false;
249 0 : buffersInitialized_p = false;
250 0 : stopIteration_p = false;
251 : }
252 : else
253 : {
254 0 : chunksInitialized_p = false;
255 0 : buffersInitialized_p = false;
256 0 : stopIteration_p = false;
257 : }
258 :
259 : // Do quack pre-swap
260 0 : if (mapScanStartStop_p)
261 : {
262 0 : calIter_p->reset();
263 0 : while (!calIter_p->pastEnd())
264 : {
265 0 : generateScanStartStopMap();
266 0 : calIter_p->next();
267 : }
268 : }
269 :
270 0 : return true;
271 : }
272 :
273 :
274 : // -----------------------------------------------------------------------
275 : // Translate sorting columns from Block<Int> format to Block<string> format
276 : // -----------------------------------------------------------------------
277 : Block<String>
278 0 : FlagCalTableHandler::getSortColumns(Block<Int> /*intCols*/)
279 : {
280 0 : Block<String> strCols(4);
281 0 : strCols[0] = "OBSERVATION_ID";
282 0 : strCols[1] = "SCAN_NUMBER";
283 0 : strCols[2] = "FIELD_ID";
284 0 : strCols[3] = "SPECTRAL_WINDOW_ID";
285 :
286 0 : return strCols;
287 0 : }
288 :
289 :
290 : // -----------------------------------------------------------------------
291 : // Move to next chunk
292 : // -----------------------------------------------------------------------
293 : bool
294 0 : FlagCalTableHandler::nextChunk()
295 : {
296 0 : logger_p->origin(LogOrigin("FlagCalTableHandler",__FUNCTION__,WHERE));
297 :
298 0 : chunkCounts_p = 0;
299 0 : bool moreChunks = false;
300 0 : if (stopIteration_p)
301 : {
302 0 : moreChunks = false;
303 : }
304 : else
305 : {
306 0 : if (!chunksInitialized_p)
307 : {
308 0 : if (!iteratorGenerated_p) generateIterator();
309 0 : calIter_p->reset();
310 0 : chunksInitialized_p = true;
311 0 : buffersInitialized_p = false;
312 0 : chunkNo_p++;
313 0 : bufferNo_p = 0;
314 0 : moreChunks = true;
315 : }
316 : else
317 : {
318 0 : calIter_p->next();
319 :
320 0 : if (!calIter_p->pastEnd())
321 : {
322 0 : buffersInitialized_p = false;
323 0 : moreChunks = true;
324 0 : chunkNo_p++;
325 0 : bufferNo_p = 0;
326 : }
327 : }
328 : }
329 :
330 0 : if (!moreChunks)
331 : {
332 0 : *logger_p << LogIO::NORMAL << "==================================================================================== " << LogIO::POST;
333 : }
334 :
335 0 : return moreChunks;
336 : }
337 :
338 :
339 : // -----------------------------------------------------------------------
340 : // Move to next buffer
341 : // -----------------------------------------------------------------------
342 : bool
343 0 : FlagCalTableHandler::nextBuffer()
344 : {
345 0 : bool moreBuffers = false;
346 0 : if (stopIteration_p)
347 : {
348 0 : moreBuffers = false;
349 : }
350 : else
351 : {
352 0 : if (!buffersInitialized_p)
353 : {
354 0 : ((CTBuffer *)visibilityBuffer_p)->invalidate();
355 0 : if (!asyncio_enabled_p) preFetchColumns();
356 0 : if (mapPolarizations_p) generatePolarizationsMap();
357 0 : if (mapAntennaPairs_p) generateAntennaPairMap();
358 0 : buffersInitialized_p = true;
359 0 : flushFlags_p = false;
360 0 : flushFlagRow_p = false;
361 0 : bufferNo_p++;
362 :
363 0 : moreBuffers = true;
364 : }
365 : else
366 : {
367 : // In CalTables there is only one iteration level
368 0 : moreBuffers = false;
369 : }
370 : }
371 :
372 : // Print chunk characteristics
373 0 : if (moreBuffers)
374 : {
375 : // Get flag (WARNING: We have to modify the shape of the cube before re-assigning it)
376 0 : Cube<Bool> curentFlagCube= visibilityBuffer_p->flagCube();
377 0 : modifiedFlagCube_p.resize(curentFlagCube.shape());
378 0 : modifiedFlagCube_p = curentFlagCube;
379 0 : originalFlagCube_p.resize(curentFlagCube.shape());
380 0 : originalFlagCube_p = curentFlagCube;
381 :
382 : // Get flag row (WARNING: We have to modify the shape of the cube before re-assigning it)
383 : // NOTE: There is no FlagRow in CalTables yet, but we have it here for compatibility reasons
384 0 : modifiedFlagRow_p.resize(visibilityBuffer_p->nRows());
385 0 : originalFlagRow_p.resize(visibilityBuffer_p->nRows());
386 :
387 : // Compute total number of flags per buffer to be used for generating the agents stats
388 0 : Int64 currentBufferCounts = curentFlagCube.shape().product();
389 0 : chunkCounts_p += currentBufferCounts;
390 0 : progressCounts_p += currentBufferCounts;
391 0 : msCounts_p += currentBufferCounts;
392 :
393 : // Print chunk characteristics
394 0 : if (bufferNo_p == 1)
395 : {
396 : // jagonzal: This is correct because in CalTables there is only one iteration level
397 0 : processedRows_p += visibilityBuffer_p->nRows();
398 :
399 0 : if (printChunkSummary_p)
400 : {
401 0 : logger_p->origin(LogOrigin("FlagCalTableHandler",""));
402 0 : Vector<Int> scan = visibilityBuffer_p->scan();
403 0 : Vector<Int> observation = visibilityBuffer_p->observationId();
404 0 : String corrs = "[ ";
405 0 : for (uInt corr_i=0;corr_i<(uInt) visibilityBuffer_p->nCorrelations();corr_i++)
406 : {
407 0 : corrs += (*polarizationIndexMap_p)[corr_i] + " ";
408 : }
409 0 : corrs += "]";
410 :
411 0 : Double progress = 100.0* ((Double) processedRows_p / (Double) selectedCalTable_p->nrow());
412 :
413 0 : *logger_p << LogIO::NORMAL <<
414 0 : "------------------------------------------------------------------------------------ " << LogIO::POST;
415 0 : *logger_p << LogIO::NORMAL <<
416 : "Chunk = " << chunkNo_p << " [progress: " << (Int)progress << "%]"
417 0 : ", Observation = " << observation[0] << "~" << observation[observation.size()-1] <<
418 0 : ", Scan = " << scan[0] << "~" << scan[scan.size()-1] <<
419 0 : ", Field = " << visibilityBuffer_p->fieldId()(0) << " (" << fieldNames_p->operator()(visibilityBuffer_p->fieldId()) << ")"
420 0 : ", Spw = " << visibilityBuffer_p->spectralWindows()(0) <<
421 0 : ", Channels = " << visibilityBuffer_p->nChannels() <<
422 : ", CalSolutions = " << corrs <<
423 0 : ", Total Rows = " << visibilityBuffer_p->nRows() << LogIO::POST;
424 0 : }
425 : }
426 0 : }
427 :
428 0 : return moreBuffers;
429 : }
430 :
431 :
432 : // -----------------------------------------------------------------------
433 : // Generate scan start stop map
434 : // -----------------------------------------------------------------------
435 : void
436 0 : FlagCalTableHandler::generateScanStartStopMap()
437 : {
438 : Int scan;
439 : Double start,stop;
440 0 : Vector<Int> scans;
441 0 : Vector<Double> times;
442 :
443 0 : Cube<Bool> flags;
444 : uInt scanStartRow;
445 : uInt scanStopRow;
446 : uInt ncorrs,nchannels,nrows;
447 : Bool stopSearch;
448 :
449 0 : if (scanStartStopMap_p == NULL) scanStartStopMap_p = new scanStartStopMap();
450 :
451 0 : scans = calIter_p->scan();
452 0 : times = calIter_p->time();
453 :
454 : // Check if anything is flagged in this buffer
455 0 : scanStartRow = 0;
456 0 : scanStopRow = times.size()-1;
457 0 : if (mapScanStartStopFlagged_p)
458 : {
459 0 : calIter_p->flag(flags);
460 0 : IPosition shape = flags.shape();
461 0 : ncorrs = shape[0];
462 0 : nchannels = shape[1];
463 0 : nrows = shape[2];
464 :
465 : // Look for effective scan start
466 0 : stopSearch = false;
467 0 : for (uInt row_i=0;row_i<nrows;row_i++)
468 : {
469 0 : if (stopSearch) break;
470 :
471 0 : for (uInt channel_i=0;channel_i<nchannels;channel_i++)
472 : {
473 0 : if (stopSearch) break;
474 :
475 0 : for (uInt corr_i=0;corr_i<ncorrs;corr_i++)
476 : {
477 0 : if (stopSearch) break;
478 :
479 0 : if (!flags(corr_i,channel_i,row_i))
480 : {
481 0 : scanStartRow = row_i;
482 0 : stopSearch = true;
483 : }
484 : }
485 : }
486 : }
487 :
488 : // If none of the rows were un-flagged we don't continue checking from the end
489 : // As a consequence of this some scans may not be present in the map, and have
490 : // to be skipped in the flagging process because they are already flagged.
491 0 : if (!stopSearch) return;
492 :
493 : // Look for effective scan stop
494 0 : stopSearch = false;
495 0 : for (uInt row_i=0;row_i<nrows;row_i++)
496 : {
497 0 : if (stopSearch) break;
498 :
499 0 : for (uInt channel_i=0;channel_i<nchannels;channel_i++)
500 : {
501 0 : if (stopSearch) break;
502 :
503 0 : for (uInt corr_i=0;corr_i<ncorrs;corr_i++)
504 : {
505 0 : if (stopSearch) break;
506 :
507 0 : if (!flags(corr_i,channel_i,nrows-1-row_i))
508 : {
509 0 : scanStopRow = nrows-1-row_i;
510 0 : stopSearch = true;
511 : }
512 : }
513 : }
514 : }
515 0 : }
516 :
517 : // Check scan start/stop times
518 0 : scan = scans[0];
519 0 : start = times[scanStartRow];
520 0 : stop = times[scanStopRow];
521 :
522 0 : if (scanStartStopMap_p->find(scan) == scanStartStopMap_p->end())
523 : {
524 0 : (*scanStartStopMap_p)[scan].push_back(start);
525 0 : (*scanStartStopMap_p)[scan].push_back(stop);
526 : }
527 : else
528 : {
529 : // Check if we have a better start time
530 0 : if ((*scanStartStopMap_p)[scan][0] > start)
531 : {
532 0 : (*scanStartStopMap_p)[scan][0] = start;
533 : }
534 : // Check if we have a better stop time
535 0 : if ((*scanStartStopMap_p)[scan][1] < stop)
536 : {
537 0 : (*scanStartStopMap_p)[scan][1] = stop;
538 : }
539 : }
540 :
541 0 : return;
542 0 : }
543 :
544 :
545 : // -----------------------------------------------------------------------
546 : // Flush flags to CalTable
547 : // -----------------------------------------------------------------------
548 : bool
549 0 : FlagCalTableHandler::flushFlags()
550 : {
551 0 : if (flushFlags_p)
552 : {
553 0 : calIter_p->setflag(modifiedFlagCube_p);
554 0 : flushFlags_p = false;
555 : }
556 :
557 0 : return true;
558 : }
559 :
560 :
561 : // -----------------------------------------------------------------------
562 : // Flush flags to CalTable
563 : // -----------------------------------------------------------------------
564 : String
565 0 : FlagCalTableHandler::getTableName()
566 : {
567 0 : return originalCalTable_p->tableName();
568 : }
569 :
570 : // -----------------------------------------------------------------------
571 : // Signal true when a progress summary has to be printed
572 : // -----------------------------------------------------------------------
573 : bool
574 0 : FlagCalTableHandler::summarySignal()
575 : {
576 0 : Double progress = 100.0* ((Double) processedRows_p / (Double) selectedCalTable_p->nrow());
577 0 : if ((progress >= summaryThreshold_p) or (logger_p->priority() >= LogMessage::DEBUG1))
578 : {
579 0 : summaryThreshold_p += 10;
580 0 : printChunkSummary_p = true;
581 0 : return true;
582 : }
583 : else
584 : {
585 0 : printChunkSummary_p = false;
586 0 : return false;
587 : }
588 : }
589 :
590 :
591 : // -----------------------------------------------------------------------
592 : // Check what data columns exist
593 : // -----------------------------------------------------------------------
594 : bool
595 0 : FlagCalTableHandler::checkIfColumnExists(String column)
596 : {
597 0 : return originalCalTable_p->tableDesc().isColumn(column);
598 : }
599 :
600 : //////////////////////////////////////////
601 : //////// CTBuffer implementation ////////
602 : //////////////////////////////////////////
603 :
604 0 : CTCache::CTCache(CTIter *calIter): calIter_p(calIter)
605 : {
606 0 : invalidate();
607 0 : }
608 :
609 0 : CTCache::~CTCache()
610 : {
611 :
612 0 : }
613 :
614 0 : Int CTCache::arrayId()
615 : {
616 0 : return -1;
617 : }
618 :
619 0 : Int CTCache::fieldId()
620 : {
621 0 : if (!CTfieldIdOK_p)
622 : {
623 0 : field0_p = calIter_p->field()[0];
624 0 : CTfieldIdOK_p = false;
625 : }
626 :
627 0 : return field0_p;
628 : }
629 :
630 0 : Int CTCache::spectralWindow()
631 : {
632 0 : if (!CTspectralWindowOK_p)
633 : {
634 0 : Vector<Int> tmp = calIter_p->spw();
635 0 : spw_p.resize(tmp.size(),false);
636 0 : spw_p = tmp;
637 0 : spw0_p = spw_p[0];
638 0 : CTspectralWindowOK_p = true;
639 0 : }
640 :
641 0 : return spw0_p;
642 : }
643 :
644 0 : Vector<Int>& CTCache::scan()
645 : {
646 0 : if (!CTscanOK_p)
647 : {
648 0 : Vector<Int> tmp = calIter_p->scan();
649 0 : scan_p.resize(tmp.size(),false);
650 0 : scan_p = tmp;
651 0 : CTscanOK_p = true;
652 0 : }
653 :
654 0 : return scan_p;
655 : }
656 :
657 0 : Vector<Double>& CTCache::time()
658 : {
659 0 : if (!CTtimeOK_p)
660 : {
661 0 : Vector<Double> tmp = calIter_p->time();
662 0 : time_p.resize(tmp.size(),false);
663 0 : time_p = tmp;
664 0 : CTtimeOK_p = true;
665 0 : }
666 :
667 0 : return time_p;
668 : }
669 :
670 0 : Vector<Int>& CTCache::antenna1()
671 : {
672 0 : if (!CTantenna1OK_p)
673 : {
674 0 : Vector<Int> tmp = calIter_p->antenna1();
675 0 : antenna1_p.resize(tmp.size(),false);
676 0 : antenna1_p = tmp;
677 0 : CTantenna1OK_p = true;
678 0 : }
679 :
680 0 : return antenna1_p;
681 : }
682 :
683 0 : Vector<Int>& CTCache::antenna2()
684 : {
685 0 : if (!CTantenna2OK_p)
686 : {
687 0 : Vector<Int> tmp = calIter_p->antenna2();
688 0 : if (tmp[0] < 0) tmp = calIter_p->antenna1();
689 0 : antenna2_p.resize(tmp.size(),false);
690 0 : antenna2_p = tmp;
691 0 : CTantenna2OK_p = true;
692 0 : }
693 :
694 0 : return antenna2_p;
695 : }
696 :
697 0 : Cube<Bool>& CTCache::flagCube()
698 : {
699 0 : if (!CTflagCubeOk_p)
700 : {
701 0 : Cube<Bool> tmp = calIter_p->flag();
702 0 : flagCube_p.resize(tmp.shape(),false);
703 0 : flagCube_p = tmp;
704 0 : CTflagCubeOk_p = true;
705 :
706 : // Also fill shapes
707 0 : nRow_p = flagCube_p.shape()[2];
708 0 : nRowChunk_p = flagCube_p.shape()[2];
709 0 : nChannel_p = flagCube_p.shape()[1];
710 0 : nCorr_p = flagCube_p.shape()[0];
711 :
712 0 : CTnRowOK_p = true;
713 0 : CTnRowChunkOK_p = true;
714 0 : CTnChannelOK_p = true;
715 0 : CTnCorrOK_p = true;
716 0 : }
717 :
718 0 : return flagCube_p;
719 : }
720 :
721 0 : Vector<Int>& CTCache::observationId()
722 : {
723 0 : if (!CTobservationIdOK_p)
724 : {
725 0 : Vector<Int> tmp = calIter_p->obs();
726 0 : observationId_p.resize(tmp.size(),false);
727 0 : observationId_p = tmp;
728 0 : CTobservationIdOK_p = true;
729 0 : }
730 :
731 0 : return observationId_p;
732 : }
733 :
734 0 : Vector<Int>& CTCache::correlationTypes()
735 : {
736 0 : if (!CTcorrTypeOK_p)
737 : {
738 0 : if (!CTnRowOK_p) nCorrelations();
739 0 : corrType_p.resize(nCorr_p,false);
740 0 : for (uInt corr_i=0;corr_i<(uInt) nCorr_p;corr_i++)
741 : {
742 0 : corrType_p[corr_i] = Stokes::NumberOfTypes+corr_i;
743 : }
744 0 : CTcorrTypeOK_p = true;
745 : }
746 :
747 0 : return corrType_p;
748 : }
749 :
750 0 : Vector<Int>& CTCache::getChannelNumbers(Int /*rowInBuffer*/)
751 : {
752 0 : if (!CTchannelOK_p)
753 : {
754 0 : Vector<Int> tmp = calIter_p->chan();
755 0 : channel_p.resize(tmp.size(),false);
756 0 : channel_p = tmp;
757 0 : CTchannelOK_p = true;
758 0 : }
759 :
760 0 : return channel_p;
761 : }
762 :
763 0 : Vector<Double>& CTCache::getFrequencies(Int /*rowInBuffer*/, Int /*frame*/)
764 : {
765 0 : if (!CTfrequencyOK_p)
766 : {
767 0 : Vector<Double> tmp = calIter_p->freq();
768 0 : frequency_p.resize(tmp.size(),false);
769 0 : frequency_p = tmp;
770 0 : CTfrequencyOK_p = true;
771 0 : }
772 :
773 0 : return frequency_p;
774 : }
775 :
776 0 : Cube<Complex>& CTCache::visCube()
777 : {
778 0 : if (!CTVisCubeOK_p)
779 : {
780 0 : Cube<Float> tmp = calIter_p->fparam();
781 :
782 : // Transform Cube<Float> into Cube<Complex>
783 0 : Cube<Complex> tmpTrans(tmp.shape());
784 0 : for (uInt idx1=0;idx1<tmp.shape()[0];idx1++)
785 : {
786 0 : for (uInt idx2=0;idx2<tmp.shape()[1];idx2++)
787 : {
788 0 : for (uInt idx3=0;idx3<tmp.shape()[2];idx3++)
789 : {
790 0 : tmpTrans(idx1,idx2,idx3) = Complex(tmp(idx1,idx2,idx3),0);
791 : }
792 : }
793 : }
794 :
795 0 : fparam_p.resize(tmpTrans.shape(),false);
796 0 : fparam_p = tmpTrans;
797 0 : CTVisCubeOK_p = true;
798 0 : }
799 :
800 0 : return fparam_p;
801 : }
802 :
803 0 : Cube<Complex>& CTCache::visCubeCorrected()
804 : {
805 0 : if (!CTcorrectedVisCubeOK_p)
806 : {
807 0 : Cube<Complex> tmp = calIter_p->cparam();
808 0 : cparam_p.resize(tmp.shape(),false);
809 0 : cparam_p = tmp;
810 0 : CTcorrectedVisCubeOK_p = true;
811 0 : }
812 :
813 0 : return cparam_p;
814 : }
815 :
816 0 : Cube<Complex>& CTCache::visCubeModel()
817 : {
818 0 : if (!CTmodelVisCubeOK_p)
819 : {
820 0 : Cube<Float> tmp = calIter_p->snr();
821 :
822 : // Transform Cube<Float> into Cube<Complex>
823 0 : Cube<Complex> tmpTrans(tmp.shape());
824 0 : for (uInt idx1=0;idx1<tmp.shape()[0];idx1++)
825 : {
826 0 : for (uInt idx2=0;idx2<tmp.shape()[1];idx2++)
827 : {
828 0 : for (uInt idx3=0;idx3<tmp.shape()[2];idx3++)
829 : {
830 0 : tmpTrans(idx1,idx2,idx3) = Complex(tmp(idx1,idx2,idx3),0);
831 : }
832 : }
833 : }
834 :
835 0 : snr_p.resize(tmpTrans.shape(),false);
836 0 : snr_p = tmpTrans;
837 0 : CTmodelVisCubeOK_p = true;
838 0 : }
839 :
840 0 : return snr_p;
841 : }
842 :
843 0 : Int CTCache::nRowChunk()
844 : {
845 0 : if (!CTnRowChunkOK_p)
846 : {
847 0 : if (!CTflagCubeOk_p) flagCube();
848 0 : nRowChunk_p = flagCube_p.shape()[2];
849 0 : CTnRowChunkOK_p = true;
850 : }
851 :
852 0 : return nRowChunk_p;
853 : }
854 :
855 0 : Int CTCache::nRows()
856 : {
857 0 : if (!CTnRowOK_p)
858 : {
859 0 : if (!CTflagCubeOk_p) flagCube();
860 0 : nRow_p = flagCube_p.shape()[2];
861 0 : CTnRowOK_p = true;
862 : }
863 :
864 0 : return nRow_p;
865 : }
866 :
867 0 : Int CTCache::nChannels()
868 : {
869 0 : if (!CTnChannelOK_p)
870 : {
871 0 : if (!CTflagCubeOk_p) flagCube();
872 0 : nChannel_p = flagCube_p.shape()[1];
873 0 : CTnChannelOK_p = true;
874 : }
875 :
876 0 : return nChannel_p;
877 : }
878 :
879 0 : Int CTCache::nCorrelations()
880 : {
881 0 : if (!CTnCorrOK_p)
882 : {
883 0 : if (!CTflagCubeOk_p) flagCube();
884 0 : nCorr_p = flagCube_p.shape()[0];
885 0 : CTnCorrOK_p = true;
886 : }
887 :
888 0 : return nCorr_p;
889 : }
890 :
891 0 : void CTCache::invalidate()
892 : {
893 0 : CTfieldIdOK_p = false;
894 0 : CTspectralWindowOK_p = false;
895 0 : CTscanOK_p = false;
896 0 : CTtimeOK_p = false;
897 0 : CTantenna1OK_p = false;
898 0 : CTantenna2OK_p = false;
899 0 : CTflagCubeOk_p = false;
900 0 : CTobservationIdOK_p = false;
901 0 : CTcorrTypeOK_p = false;
902 0 : CTchannelOK_p = false;
903 0 : CTfrequencyOK_p = false;
904 0 : CTVisCubeOK_p = false;
905 0 : CTcorrectedVisCubeOK_p = false;
906 0 : CTmodelVisCubeOK_p = false;
907 0 : CTnRowChunkOK_p = false;
908 0 : CTnRowOK_p = false;
909 0 : CTnChannelOK_p = false;
910 0 : CTnCorrOK_p = false;
911 :
912 0 : return;
913 : }
914 :
915 :
916 : } //# NAMESPACE CASA - END
917 :
|
