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 182 : FlagCalTableHandler::FlagCalTableHandler(string tablename, uShort iterationApproach, Double timeInterval):
41 182 : FlagDataHandler(tablename,iterationApproach,timeInterval)
42 : {
43 182 : selectedCalTable_p = NULL;
44 182 : originalCalTable_p = NULL;
45 182 : calTableInterface_p = NULL;
46 182 : calBuffer_p = NULL;
47 182 : calIter_p = NULL;
48 182 : tableTye_p = CALIBRATION_TABLE;
49 182 : }
50 :
51 : // -----------------------------------------------------------------------
52 : // Default destructor
53 : // -----------------------------------------------------------------------
54 364 : FlagCalTableHandler::~FlagCalTableHandler()
55 : {
56 182 : logger_p->origin(LogOrigin("FlagCalTableHandler",__FUNCTION__,WHERE));
57 182 : *logger_p << LogIO::DEBUG1 << "FlagCalTableHandler::~FlagCalTableHandler()" << LogIO::POST;
58 :
59 182 : if (calBuffer_p) delete calBuffer_p;
60 182 : if (calIter_p) delete calIter_p;
61 182 : if (calTableInterface_p) delete calTableInterface_p;
62 182 : if (selectedCalTable_p) delete selectedCalTable_p;
63 182 : if (originalCalTable_p) delete originalCalTable_p;
64 364 : }
65 :
66 :
67 : // -----------------------------------------------------------------------
68 : // Open CalTable
69 : // -----------------------------------------------------------------------
70 : bool
71 182 : FlagCalTableHandler::open()
72 : {
73 182 : if (originalCalTable_p) delete originalCalTable_p;
74 182 : originalCalTable_p = new NewCalTable(tablename_p,Table::Update,Table::Plain);
75 :
76 : // Read field names
77 182 : MSFieldColumns fieldSubTable(originalCalTable_p->field());
78 182 : fieldNames_p = new Vector<String>(fieldSubTable.name().getColumn());
79 182 : *logger_p << LogIO::DEBUG1 << "Field names are " << *fieldNames_p << LogIO::POST;
80 :
81 : // Read antenna names and diameters from Antenna table
82 182 : MSAntennaColumns antennaSubTable(originalCalTable_p->antenna());
83 182 : antennaNames_p = new Vector<String>(antennaSubTable.name().getColumn());
84 182 : antennaDiameters_p = new Vector<Double>(antennaSubTable.dishDiameter().getColumn());
85 182 : antennaPositions_p = new ROScalarMeasColumn<MPosition>(antennaSubTable.positionMeas());
86 182 : *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 182 : String baseline;
90 182 : std::pair<Int,Int> ant1ant2;
91 3538 : for (Int ant1Idx=0;ant1Idx < static_cast<Int>(antennaNames_p->size());ant1Idx++)
92 : {
93 39429 : for (Int ant2Idx=ant1Idx+1;ant2Idx < static_cast<Int>(antennaNames_p->size());ant2Idx++)
94 : {
95 36073 : ant1ant2.first = ant1Idx;
96 36073 : ant1ant2.second = ant2Idx;
97 36073 : baseline = antennaNames_p->operator()(ant1Idx) + "&&" + antennaNames_p->operator()(ant2Idx);
98 36073 : baselineToAnt1Ant2_p[baseline] = ant1ant2;
99 36073 : Ant1Ant2ToBaseline_p[ant1ant2] = baseline;
100 : }
101 : }
102 :
103 : // Create "dummy" correlation products list
104 182 : corrProducts_p = new std::vector<String>();
105 182 : corrProducts_p->push_back("SOL1");
106 182 : corrProducts_p->push_back("SOL2");
107 182 : corrProducts_p->push_back("SOL3");
108 182 : corrProducts_p->push_back("SOL4");
109 :
110 182 : return true;
111 182 : }
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 179 : FlagCalTableHandler::selectData()
136 : {
137 179 : logger_p->origin(LogOrigin("FlagCalTableHandler",__FUNCTION__,WHERE));
138 :
139 179 : if (calTableInterface_p) delete calTableInterface_p;
140 179 : calTableInterface_p = new CTInterface(*originalCalTable_p);
141 :
142 179 : if (measurementSetSelection_p) delete measurementSetSelection_p;
143 179 : const String dummyExpr = String("");
144 179 : measurementSetSelection_p = new MSSelection();
145 358 : measurementSetSelection_p->reset(*calTableInterface_p,
146 179 : MSSelection::PARSE_LATE,
147 358 : (const String)timeSelection_p,
148 358 : (const String)baselineSelection_p,
149 358 : (const String)fieldSelection_p,
150 358 : (const String)spwSelection_p,
151 358 : (const String)uvwSelection_p,
152 : dummyExpr, // taqlExpr
153 358 : (const String)polarizationSelection_p,
154 358 : (const String)scanSelection_p,
155 358 : (const String)arraySelection_p,
156 358 : (const String)scanIntentSelection_p,
157 358 : (const String)observationSelection_p);
158 :
159 :
160 179 : if (selectedCalTable_p) delete selectedCalTable_p;
161 :
162 : // try
163 : // {
164 179 : TableExprNode ten = measurementSetSelection_p->toTableExprNode(calTableInterface_p);
165 179 : selectedCalTable_p = new NewCalTable();
166 181 : Bool madeSelection = getSelectedTable(*selectedCalTable_p,*originalCalTable_p,ten,String(""));
167 :
168 177 : if (madeSelection == false)
169 : {
170 151 : *logger_p << LogIO::NORMAL << "Selection not applicable, using entire MS" << LogIO::POST;
171 151 : delete selectedCalTable_p;
172 151 : 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 177 : 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 177 : *logger_p << LogIO::NORMAL << "Original CalTable has "
190 177 : << originalCalTable_p->nrow()
191 : << " rows, and selected CalTable has "
192 177 : << selectedCalTable_p->nrow()
193 177 : << " rows" << LogIO::POST;
194 : }
195 :
196 : // There is a new selected MS so iterators have to be regenerated
197 177 : iteratorGenerated_p = false;
198 177 : chunksInitialized_p = false;
199 177 : buffersInitialized_p = false;
200 177 : stopIteration_p = false;
201 :
202 177 : return true;
203 181 : }
204 :
205 :
206 : // -----------------------------------------------------------------------
207 : // Parse MSSelection expression
208 : // -----------------------------------------------------------------------
209 : bool
210 9 : FlagCalTableHandler::parseExpression(MSSelection &parser)
211 : {
212 9 : logger_p->origin(LogOrigin("FlagCalTableHandler",__FUNCTION__,WHERE));
213 9 : CTInterface tmpCTInterface(*originalCalTable_p);
214 :
215 : try
216 : {
217 9 : TableExprNode ten = parser.toTableExprNode(&tmpCTInterface);
218 9 : }
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 9 : return true;
226 9 : }
227 :
228 :
229 : // -----------------------------------------------------------------------
230 : // Generate CalIter with a given sort order and time interval
231 : // -----------------------------------------------------------------------
232 : bool
233 168 : FlagCalTableHandler::generateIterator()
234 : {
235 168 : if (!iteratorGenerated_p)
236 : {
237 : // Generate CalIterator
238 168 : if (calIter_p) delete calIter_p;
239 168 : 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 168 : if (visibilityBuffer_p) delete visibilityBuffer_p;
244 168 : calBuffer_p = new CTBuffer(calIter_p);
245 168 : visibilityBuffer_p = (vi::VisBuffer2 *)calBuffer_p;
246 :
247 168 : iteratorGenerated_p = true;
248 168 : chunksInitialized_p = false;
249 168 : buffersInitialized_p = false;
250 168 : 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 168 : 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 168 : return true;
271 : }
272 :
273 :
274 : // -----------------------------------------------------------------------
275 : // Translate sorting columns from Block<Int> format to Block<string> format
276 : // -----------------------------------------------------------------------
277 : Block<String>
278 168 : FlagCalTableHandler::getSortColumns(Block<Int> /*intCols*/)
279 : {
280 168 : Block<String> strCols(4);
281 168 : strCols[0] = "OBSERVATION_ID";
282 168 : strCols[1] = "SCAN_NUMBER";
283 168 : strCols[2] = "FIELD_ID";
284 168 : strCols[3] = "SPECTRAL_WINDOW_ID";
285 :
286 168 : return strCols;
287 0 : }
288 :
289 :
290 : // -----------------------------------------------------------------------
291 : // Move to next chunk
292 : // -----------------------------------------------------------------------
293 : bool
294 8964 : FlagCalTableHandler::nextChunk()
295 : {
296 8964 : logger_p->origin(LogOrigin("FlagCalTableHandler",__FUNCTION__,WHERE));
297 :
298 8964 : chunkCounts_p = 0;
299 8964 : bool moreChunks = false;
300 8964 : if (stopIteration_p)
301 : {
302 0 : moreChunks = false;
303 : }
304 : else
305 : {
306 8964 : if (!chunksInitialized_p)
307 : {
308 168 : if (!iteratorGenerated_p) generateIterator();
309 168 : calIter_p->reset();
310 168 : chunksInitialized_p = true;
311 168 : buffersInitialized_p = false;
312 168 : chunkNo_p++;
313 168 : bufferNo_p = 0;
314 168 : moreChunks = true;
315 : }
316 : else
317 : {
318 8796 : calIter_p->next();
319 :
320 8796 : if (!calIter_p->pastEnd())
321 : {
322 8628 : buffersInitialized_p = false;
323 8628 : moreChunks = true;
324 8628 : chunkNo_p++;
325 8628 : bufferNo_p = 0;
326 : }
327 : }
328 : }
329 :
330 8964 : if (!moreChunks)
331 : {
332 168 : *logger_p << LogIO::NORMAL << "==================================================================================== " << LogIO::POST;
333 : }
334 :
335 8964 : return moreChunks;
336 : }
337 :
338 :
339 : // -----------------------------------------------------------------------
340 : // Move to next buffer
341 : // -----------------------------------------------------------------------
342 : bool
343 17592 : FlagCalTableHandler::nextBuffer()
344 : {
345 17592 : bool moreBuffers = false;
346 17592 : if (stopIteration_p)
347 : {
348 0 : moreBuffers = false;
349 : }
350 : else
351 : {
352 17592 : if (!buffersInitialized_p)
353 : {
354 8796 : ((CTBuffer *)visibilityBuffer_p)->invalidate();
355 8796 : if (!asyncio_enabled_p) preFetchColumns();
356 8796 : if (mapPolarizations_p) generatePolarizationsMap();
357 8796 : if (mapAntennaPairs_p) generateAntennaPairMap();
358 8796 : buffersInitialized_p = true;
359 8796 : flushFlags_p = false;
360 8796 : flushFlagRow_p = false;
361 8796 : bufferNo_p++;
362 :
363 8796 : moreBuffers = true;
364 : }
365 : else
366 : {
367 : // In CalTables there is only one iteration level
368 8796 : moreBuffers = false;
369 : }
370 : }
371 :
372 : // Print chunk characteristics
373 17592 : if (moreBuffers)
374 : {
375 : // Get flag (WARNING: We have to modify the shape of the cube before re-assigning it)
376 8796 : Cube<Bool> curentFlagCube= visibilityBuffer_p->flagCube();
377 8796 : modifiedFlagCube_p.resize(curentFlagCube.shape());
378 8796 : modifiedFlagCube_p = curentFlagCube;
379 8796 : originalFlagCube_p.resize(curentFlagCube.shape());
380 8796 : 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 8796 : modifiedFlagRow_p.resize(visibilityBuffer_p->nRows());
385 8796 : originalFlagRow_p.resize(visibilityBuffer_p->nRows());
386 :
387 : // Compute total number of flags per buffer to be used for generating the agents stats
388 8796 : Int64 currentBufferCounts = curentFlagCube.shape().product();
389 8796 : chunkCounts_p += currentBufferCounts;
390 8796 : progressCounts_p += currentBufferCounts;
391 8796 : msCounts_p += currentBufferCounts;
392 :
393 : // Print chunk characteristics
394 8796 : if (bufferNo_p == 1)
395 : {
396 : // jagonzal: This is correct because in CalTables there is only one iteration level
397 8796 : processedRows_p += visibilityBuffer_p->nRows();
398 :
399 8796 : if (printChunkSummary_p)
400 : {
401 8796 : logger_p->origin(LogOrigin("FlagCalTableHandler",""));
402 8796 : Vector<Int> scan = visibilityBuffer_p->scan();
403 8796 : Vector<Int> observation = visibilityBuffer_p->observationId();
404 8796 : String corrs = "[ ";
405 26388 : for (uInt corr_i=0;corr_i<(uInt) visibilityBuffer_p->nCorrelations();corr_i++)
406 : {
407 17592 : corrs += (*polarizationIndexMap_p)[corr_i] + " ";
408 : }
409 8796 : corrs += "]";
410 :
411 8796 : Double progress = 100.0* ((Double) processedRows_p / (Double) selectedCalTable_p->nrow());
412 :
413 8796 : *logger_p << LogIO::NORMAL <<
414 8796 : "------------------------------------------------------------------------------------ " << LogIO::POST;
415 8796 : *logger_p << LogIO::NORMAL <<
416 : "Chunk = " << chunkNo_p << " [progress: " << (Int)progress << "%]"
417 8796 : ", Observation = " << observation[0] << "~" << observation[observation.size()-1] <<
418 8796 : ", Scan = " << scan[0] << "~" << scan[scan.size()-1] <<
419 26388 : ", Field = " << visibilityBuffer_p->fieldId()(0) << " (" << fieldNames_p->operator()(visibilityBuffer_p->fieldId()) << ")"
420 8796 : ", Spw = " << visibilityBuffer_p->spectralWindows()(0) <<
421 8796 : ", Channels = " << visibilityBuffer_p->nChannels() <<
422 : ", CalSolutions = " << corrs <<
423 52776 : ", Total Rows = " << visibilityBuffer_p->nRows() << LogIO::POST;
424 8796 : }
425 : }
426 8796 : }
427 :
428 17592 : 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 5622 : FlagCalTableHandler::flushFlags()
550 : {
551 5622 : if (flushFlags_p)
552 : {
553 5086 : calIter_p->setflag(modifiedFlagCube_p);
554 5086 : flushFlags_p = false;
555 : }
556 :
557 5622 : return true;
558 : }
559 :
560 :
561 : // -----------------------------------------------------------------------
562 : // Flush flags to CalTable
563 : // -----------------------------------------------------------------------
564 : String
565 9 : FlagCalTableHandler::getTableName()
566 : {
567 9 : return originalCalTable_p->tableName();
568 : }
569 :
570 : // -----------------------------------------------------------------------
571 : // Signal true when a progress summary has to be printed
572 : // -----------------------------------------------------------------------
573 : bool
574 8796 : FlagCalTableHandler::summarySignal()
575 : {
576 8796 : Double progress = 100.0* ((Double) processedRows_p / (Double) selectedCalTable_p->nrow());
577 8796 : if ((progress >= summaryThreshold_p) or (logger_p->priority() >= LogMessage::DEBUG1))
578 : {
579 8796 : summaryThreshold_p += 10;
580 8796 : printChunkSummary_p = true;
581 8796 : 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 34 : FlagCalTableHandler::checkIfColumnExists(String column)
596 : {
597 34 : return originalCalTable_p->tableDesc().isColumn(column);
598 : }
599 :
600 : //////////////////////////////////////////
601 : //////// CTBuffer implementation ////////
602 : //////////////////////////////////////////
603 :
604 168 : CTCache::CTCache(CTIter *calIter): calIter_p(calIter)
605 : {
606 168 : invalidate();
607 168 : }
608 :
609 0 : CTCache::~CTCache()
610 : {
611 :
612 0 : }
613 :
614 11970 : Int CTCache::arrayId()
615 : {
616 11970 : return -1;
617 : }
618 :
619 32802 : Int CTCache::fieldId()
620 : {
621 32802 : if (!CTfieldIdOK_p)
622 : {
623 32802 : field0_p = calIter_p->field()[0];
624 32802 : CTfieldIdOK_p = false;
625 : }
626 :
627 32802 : return field0_p;
628 : }
629 :
630 24408 : Int CTCache::spectralWindow()
631 : {
632 24408 : if (!CTspectralWindowOK_p)
633 : {
634 8796 : Vector<Int> tmp = calIter_p->spw();
635 8796 : spw_p.resize(tmp.size(),false);
636 8796 : spw_p = tmp;
637 8796 : spw0_p = spw_p[0];
638 8796 : CTspectralWindowOK_p = true;
639 8796 : }
640 :
641 24408 : return spw0_p;
642 : }
643 :
644 232812 : Vector<Int>& CTCache::scan()
645 : {
646 232812 : if (!CTscanOK_p)
647 : {
648 8796 : Vector<Int> tmp = calIter_p->scan();
649 8796 : scan_p.resize(tmp.size(),false);
650 8796 : scan_p = tmp;
651 8796 : CTscanOK_p = true;
652 8796 : }
653 :
654 232812 : return scan_p;
655 : }
656 :
657 69180 : Vector<Double>& CTCache::time()
658 : {
659 69180 : if (!CTtimeOK_p)
660 : {
661 8796 : Vector<Double> tmp = calIter_p->time();
662 8796 : time_p.resize(tmp.size(),false);
663 8796 : time_p = tmp;
664 8796 : CTtimeOK_p = true;
665 8796 : }
666 :
667 69180 : return time_p;
668 : }
669 :
670 219533 : Vector<Int>& CTCache::antenna1()
671 : {
672 219533 : if (!CTantenna1OK_p)
673 : {
674 3586 : Vector<Int> tmp = calIter_p->antenna1();
675 3586 : antenna1_p.resize(tmp.size(),false);
676 3586 : antenna1_p = tmp;
677 3586 : CTantenna1OK_p = true;
678 3586 : }
679 :
680 219533 : return antenna1_p;
681 : }
682 :
683 219158 : Vector<Int>& CTCache::antenna2()
684 : {
685 219158 : if (!CTantenna2OK_p)
686 : {
687 3586 : Vector<Int> tmp = calIter_p->antenna2();
688 3586 : if (tmp[0] < 0) tmp = calIter_p->antenna1();
689 3586 : antenna2_p.resize(tmp.size(),false);
690 3586 : antenna2_p = tmp;
691 3586 : CTantenna2OK_p = true;
692 3586 : }
693 :
694 219158 : return antenna2_p;
695 : }
696 :
697 17592 : Cube<Bool>& CTCache::flagCube()
698 : {
699 17592 : if (!CTflagCubeOk_p)
700 : {
701 8796 : Cube<Bool> tmp = calIter_p->flag();
702 8796 : flagCube_p.resize(tmp.shape(),false);
703 8796 : flagCube_p = tmp;
704 8796 : CTflagCubeOk_p = true;
705 :
706 : // Also fill shapes
707 8796 : nRow_p = flagCube_p.shape()[2];
708 8796 : nRowChunk_p = flagCube_p.shape()[2];
709 8796 : nChannel_p = flagCube_p.shape()[1];
710 8796 : nCorr_p = flagCube_p.shape()[0];
711 :
712 8796 : CTnRowOK_p = true;
713 8796 : CTnRowChunkOK_p = true;
714 8796 : CTnChannelOK_p = true;
715 8796 : CTnCorrOK_p = true;
716 8796 : }
717 :
718 17592 : return flagCube_p;
719 : }
720 :
721 20766 : Vector<Int>& CTCache::observationId()
722 : {
723 20766 : if (!CTobservationIdOK_p)
724 : {
725 8796 : Vector<Int> tmp = calIter_p->obs();
726 8796 : observationId_p.resize(tmp.size(),false);
727 8796 : observationId_p = tmp;
728 8796 : CTobservationIdOK_p = true;
729 8796 : }
730 :
731 20766 : return observationId_p;
732 : }
733 :
734 13676 : Vector<Int>& CTCache::correlationTypes()
735 : {
736 13676 : if (!CTcorrTypeOK_p)
737 : {
738 8796 : if (!CTnRowOK_p) nCorrelations();
739 8796 : corrType_p.resize(nCorr_p,false);
740 26388 : for (uInt corr_i=0;corr_i<(uInt) nCorr_p;corr_i++)
741 : {
742 17592 : corrType_p[corr_i] = Stokes::NumberOfTypes+corr_i;
743 : }
744 8796 : CTcorrTypeOK_p = true;
745 : }
746 :
747 13676 : 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 116 : Vector<Double>& CTCache::getFrequencies(Int /*rowInBuffer*/, Int /*frame*/)
764 : {
765 116 : if (!CTfrequencyOK_p)
766 : {
767 116 : Vector<Double> tmp = calIter_p->freq();
768 116 : frequency_p.resize(tmp.size(),false);
769 116 : frequency_p = tmp;
770 116 : CTfrequencyOK_p = true;
771 116 : }
772 :
773 116 : return frequency_p;
774 : }
775 :
776 1384 : Cube<Complex>& CTCache::visCube()
777 : {
778 1384 : if (!CTVisCubeOK_p)
779 : {
780 692 : Cube<Float> tmp = calIter_p->fparam();
781 :
782 : // Transform Cube<Float> into Cube<Complex>
783 692 : Cube<Complex> tmpTrans(tmp.shape());
784 2076 : for (uInt idx1=0;idx1<tmp.shape()[0];idx1++)
785 : {
786 178536 : for (uInt idx2=0;idx2<tmp.shape()[1];idx2++)
787 : {
788 1771520 : for (uInt idx3=0;idx3<tmp.shape()[2];idx3++)
789 : {
790 1594368 : tmpTrans(idx1,idx2,idx3) = Complex(tmp(idx1,idx2,idx3),0);
791 : }
792 : }
793 : }
794 :
795 692 : fparam_p.resize(tmpTrans.shape(),false);
796 692 : fparam_p = tmpTrans;
797 692 : CTVisCubeOK_p = true;
798 692 : }
799 :
800 1384 : return fparam_p;
801 : }
802 :
803 9296 : Cube<Complex>& CTCache::visCubeCorrected()
804 : {
805 9296 : if (!CTcorrectedVisCubeOK_p)
806 : {
807 838 : Cube<Complex> tmp = calIter_p->cparam();
808 838 : cparam_p.resize(tmp.shape(),false);
809 838 : cparam_p = tmp;
810 838 : CTcorrectedVisCubeOK_p = true;
811 838 : }
812 :
813 9296 : return cparam_p;
814 : }
815 :
816 232 : Cube<Complex>& CTCache::visCubeModel()
817 : {
818 232 : if (!CTmodelVisCubeOK_p)
819 : {
820 116 : Cube<Float> tmp = calIter_p->snr();
821 :
822 : // Transform Cube<Float> into Cube<Complex>
823 116 : Cube<Complex> tmpTrans(tmp.shape());
824 348 : for (uInt idx1=0;idx1<tmp.shape()[0];idx1++)
825 : {
826 22248 : for (uInt idx2=0;idx2<tmp.shape()[1];idx2++)
827 : {
828 1399040 : for (uInt idx3=0;idx3<tmp.shape()[2];idx3++)
829 : {
830 1377024 : tmpTrans(idx1,idx2,idx3) = Complex(tmp(idx1,idx2,idx3),0);
831 : }
832 : }
833 : }
834 :
835 116 : snr_p.resize(tmpTrans.shape(),false);
836 116 : snr_p = tmpTrans;
837 116 : CTmodelVisCubeOK_p = true;
838 116 : }
839 :
840 232 : 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 43980 : Int CTCache::nRows()
856 : {
857 43980 : if (!CTnRowOK_p)
858 : {
859 8796 : if (!CTflagCubeOk_p) flagCube();
860 8796 : nRow_p = flagCube_p.shape()[2];
861 8796 : CTnRowOK_p = true;
862 : }
863 :
864 43980 : return nRow_p;
865 : }
866 :
867 17592 : Int CTCache::nChannels()
868 : {
869 17592 : 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 17592 : return nChannel_p;
877 : }
878 :
879 35184 : Int CTCache::nCorrelations()
880 : {
881 35184 : 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 35184 : return nCorr_p;
889 : }
890 :
891 9132 : void CTCache::invalidate()
892 : {
893 9132 : CTfieldIdOK_p = false;
894 9132 : CTspectralWindowOK_p = false;
895 9132 : CTscanOK_p = false;
896 9132 : CTtimeOK_p = false;
897 9132 : CTantenna1OK_p = false;
898 9132 : CTantenna2OK_p = false;
899 9132 : CTflagCubeOk_p = false;
900 9132 : CTobservationIdOK_p = false;
901 9132 : CTcorrTypeOK_p = false;
902 9132 : CTchannelOK_p = false;
903 9132 : CTfrequencyOK_p = false;
904 9132 : CTVisCubeOK_p = false;
905 9132 : CTcorrectedVisCubeOK_p = false;
906 9132 : CTmodelVisCubeOK_p = false;
907 9132 : CTnRowChunkOK_p = false;
908 9132 : CTnRowOK_p = false;
909 9132 : CTnChannelOK_p = false;
910 9132 : CTnCorrOK_p = false;
911 :
912 9132 : return;
913 : }
914 :
915 :
916 : } //# NAMESPACE CASA - END
917 :
|
