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