Line data Source code
1 : //# SIMapperCollection.cc: Implementation of Imager.h
2 : //# Copyright (C) 1997-2008
3 : //# Associated Universities, Inc. Washington DC, USA.
4 : //#
5 : //# This program is free software; you can redistribute it and/or modify it
6 : //# under the terms of the GNU General Public License as published by the Free
7 : //# Software Foundation; either version 2 of the License, or (at your option)
8 : //# any later version.
9 : //#
10 : //# This program is distributed in the hope that it will be useful, but WITHOUT
11 : //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 : //# more details.
14 : //#
15 : //# You should have received a copy of the GNU General Public License along
16 : //# with this program; if not, write to the Free Software Foundation, Inc.,
17 : //# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 : //#
19 : //# Correspondence concerning AIPS++ should be addressed as follows:
20 : //# Internet email: casa-feedback@nrao.edu.
21 : //# Postal address: AIPS++ Project Office
22 : //# National Radio Astronomy Observatory
23 : //# 520 Edgemont Road
24 : //# Charlottesville, VA 22903-2475 USA
25 : //#
26 : //# $Id$
27 :
28 : #include <casacore/casa/Exceptions/Error.h>
29 : #include <iostream>
30 : #include <sstream>
31 :
32 : #include <casacore/casa/Arrays/Matrix.h>
33 : #include <casacore/casa/Arrays/ArrayMath.h>
34 : #include <casacore/casa/Arrays/ArrayLogical.h>
35 :
36 : #include <casacore/casa/Logging.h>
37 : #include <casacore/casa/Logging/LogIO.h>
38 : #include <casacore/casa/Logging/LogMessage.h>
39 : #include <casacore/casa/Logging/LogSink.h>
40 : #include <casacore/casa/Logging/LogMessage.h>
41 :
42 : #include <casacore/casa/OS/DirectoryIterator.h>
43 : #include <casacore/casa/OS/File.h>
44 : #include <casacore/casa/OS/Path.h>
45 :
46 : #include <casacore/casa/OS/HostInfo.h>
47 :
48 : #include <casacore/ms/MeasurementSets/MSHistoryHandler.h>
49 : #include <casacore/ms/MeasurementSets/MeasurementSet.h>
50 :
51 : #include <synthesis/ImagerObjects/SIMapperCollection.h>
52 : #include <synthesis/ImagerObjects/SynthesisUtilMethods.h>
53 :
54 : #include <synthesis/TransformMachines/VisModelData.h>
55 : #include <casacore/images/Regions/WCBox.h>
56 : #include <msvis/MSVis/VisibilityIteratorImpl2.h>
57 : #include <msvis/MSVis/VisBufferComponents2.h>
58 :
59 : #include <sys/types.h>
60 : #include <unistd.h>
61 : using namespace std;
62 :
63 : using namespace casacore;
64 : namespace casa { //# NAMESPACE CASA - BEGIN
65 :
66 : //////////////////////////////////////////////////////////////////////////////////////////////////////
67 : //////////////////////////////////////////////////////////////////////////////////////////////////////
68 :
69 0 : SIMapperCollection::SIMapperCollection()
70 : {
71 0 : LogIO os( LogOrigin("SIMapperCollection","Construct a mapperCollection",WHERE) );
72 :
73 0 : itsMappers.resize(0);
74 0 : oldMsId_p=-1;
75 0 : itsIsNonZeroModel=false;
76 :
77 0 : }
78 :
79 : //////////////////////////////////////////////////////////////////////////////////////////////////////
80 : //////////////////////////////////////////////////////////////////////////////////////////////////////
81 :
82 0 : SIMapperCollection::~SIMapperCollection()
83 : {
84 0 : }
85 :
86 : //////////////////////////////////////////////////////////////////////////////////////////////////////
87 : //////////////////////////////////////////////////////////////////////////////////////////////////////
88 :
89 0 : Bool SIMapperCollection::releaseImageLocks()
90 : {
91 0 : Bool validflag=true;
92 0 : for(Int mapperid=0;mapperid<nMappers();mapperid++ )
93 : {
94 0 : validflag &= itsMappers[mapperid]->releaseImageLocks();
95 : }
96 0 : return validflag;
97 : }
98 :
99 : //////////////////////////////////////////////////////////////////////////////////////////////////////
100 : //////////////////////////////////////////////////////////////////////////////////////////////////////
101 :
102 0 : std::vector<String> SIMapperCollection::cleanupTempFiles(const String& mess)
103 : {
104 0 : std::vector<String> outstr;
105 0 : auto appvectors = [](std::vector<String>& a, const std::vector<String> b) { a.insert(std::end(a), std::begin(b), std::end(b));};
106 0 : for(Int mapperid=0;mapperid<nMappers();mapperid++ )
107 : {
108 0 : if((itsMappers[mapperid]->getFTM2())){
109 0 : appvectors( outstr, (itsMappers[mapperid]->getFTM2(True)->cleanupTempFiles(mess)).tovector());
110 0 : appvectors(outstr, (itsMappers[mapperid]->getFTM2(False)->cleanupTempFiles(mess)).tovector());
111 : }
112 : }
113 0 : return outstr;
114 0 : }
115 :
116 : //////////////////////////////////////////////////////////////////////////////////////////////////////
117 : //////////////////////////////////////////////////////////////////////////////////////////////////////
118 :
119 : /*
120 : // Allocate Memory and open images.
121 : void SIMapperCollection::addMapper( String mappertype,
122 : CountedPtr<SIImageStore> imagestore,
123 : CountedPtr<FTMachine> ftmachine,
124 : CountedPtr<FTMachine> iftmachine)
125 : {
126 :
127 : LogIO os( LogOrigin("SIMapperCollection","addMapper",WHERE) );
128 :
129 : CountedPtr<SIMapper> localMapper=NULL;
130 : Int nMappers = itsMappers.nelements();
131 : // Check 'mappertype' for valid types....
132 : if( mappertype == "default" )
133 : {
134 : localMapper = new SIMapperSingle( imagestore, ftmachine, iftmachine, nMappers );
135 : }
136 :
137 : else if( mappertype == "multiterm" )
138 : {
139 : localMapper = new SIMapperMultiTerm( imagestore, ftmachine, iftmachine,nMappers, ntaylorterms );
140 : }
141 :
142 : else
143 : {
144 : throw ( AipsError("Internal Error : Unrecognized Mapper Type in MapperCollection.addMapper") );
145 : }
146 :
147 : // If all is well, add to the list.
148 : itsMappers.resize(nMappers+1, true);
149 : itsMappers[nMappers] = localMapper;
150 :
151 : }
152 : */
153 :
154 : //////////////////////////////////////////////////////////////////////////////////////////////////////
155 :
156 :
157 : //////////////////////////////////////////////////////////////////////////////////////////////////////
158 0 : void SIMapperCollection::addMapper( CountedPtr<SIMapper> map){
159 0 : Int nMappers = itsMappers.nelements();
160 0 : itsMappers.resize(nMappers+1, true);
161 0 : itsMappers[nMappers]=map;
162 0 : }
163 :
164 0 : Int SIMapperCollection::nMappers()
165 : {
166 0 : return itsMappers.nelements();
167 : }
168 :
169 : //////////////////////////////////////////////////////////////////////////////////////////////////////
170 : //////////////////////////////////////////////////////////////////////////////////////////////////////
171 :
172 0 : Vector<String> SIMapperCollection::getImageNames()
173 : {
174 0 : Vector<String> names( nMappers() );
175 :
176 0 : for(Int mapperid=0;mapperid<nMappers();mapperid++ )
177 : {
178 0 : names[mapperid] = itsMappers[mapperid]->getImageName();
179 : }
180 :
181 0 : return names;
182 0 : }
183 :
184 : //////////////////////////////////////////////////////////////////////////////////////////////////////
185 : /////////////////// Start VB dependent code /////////////////////////////////////////////
186 0 : void SIMapperCollection::initializeGrid(vi::VisBuffer2& vb, Bool dopsf, const Int mapperid)
187 : {
188 0 : if(mapperid<0)
189 : {
190 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
191 : {
192 0 : (itsMappers[k])->initializeGrid(vb,dopsf,true);
193 : }
194 : }
195 : else
196 : {
197 0 : if (mapperid > (Int)itsMappers.nelements())
198 0 : throw ( AipsError("Internal Error : SIMapperCollection::initializeGrid(): mapperid out of range") );
199 0 : else itsMappers[mapperid]->initializeGrid(vb, dopsf, true);
200 : }
201 0 : }
202 :
203 0 : void SIMapperCollection::initializeGrid(vi::VisibilityIterator2& vi, Bool dopsf, const Int mapperid)
204 : {
205 :
206 0 : vi::VisBuffer2 *vb=vi.getVisBuffer();
207 0 : initializeGrid(*vb, dopsf, mapperid);
208 0 : if (mapperid < 0) {
209 0 : for (uInt k=0; k < itsMappers.nelements(); ++k) {
210 0 : ((itsMappers[k])->getFTM2())->initBriggsWeightor(vi);
211 : }
212 : }
213 0 : else if (mapperid > (Int)itsMappers.nelements()) {
214 0 : throw (
215 : AipsError("Internal Error : "
216 : "SIMapperCollection::initializeGrid(): mapperid out of range")
217 0 : );
218 : }
219 : else {
220 0 : (itsMappers[mapperid]->getFTM2())->initBriggsWeightor(vi);
221 : }
222 0 : }
223 :
224 : ////////////////////////////////////////////////////////////////////////////////////
225 : /////////////////////////////////OLD vi/vb //////////////////////////////////////////////
226 0 : void SIMapperCollection::initializeGrid(VisBuffer& vb, Bool dopsf, const Int mapperid)
227 : {
228 0 : if (mapperid < 0) {
229 0 : for (uInt k=0; k < itsMappers.nelements(); ++k) {
230 0 : (itsMappers[k])->initializeGrid(vb,dopsf,true);
231 : }
232 : }
233 0 : else if (mapperid > (Int)itsMappers.nelements()) {
234 0 : throw (
235 : AipsError("Internal Error : "
236 : "SIMapperCollection::initializeGrid(): mapperid out of range")
237 0 : );
238 : }
239 : else {
240 0 : itsMappers[mapperid]->initializeGrid(vb, dopsf, true);
241 : }
242 0 : }
243 :
244 : //////////////////////////////////////////////////////////////////////////////
245 :
246 0 : void SIMapperCollection::handleNewMs(const MeasurementSet &ms, const Int mapperid)
247 : {
248 0 : if (mapperid < 0) {
249 0 : for (uInt k=0; k < itsMappers.nelements(); ++k) {
250 0 : (itsMappers[k])->handleNewMs(ms);
251 : }
252 : }
253 0 : else if (mapperid > (Int)itsMappers.nelements()) {
254 0 : throw (
255 : AipsError("Internal Error : "
256 : "SIMapperCollection::handleNewMs(): mapperid out of range")
257 0 : );
258 : }
259 : else {
260 0 : itsMappers[mapperid]->handleNewMs(ms);
261 : }
262 0 : }
263 :
264 0 : void SIMapperCollection::grid(vi::VisBuffer2& vb, Bool dopsf, refim::FTMachine::Type col,
265 : Int mapperid)
266 : {
267 0 : if( itsIsNonZeroModel == true ) // Try to subtract model visibilities only if a model exists.
268 : {
269 0 : if(col==refim::FTMachine::CORRECTED){
270 : //Dang i thought the new vb will return Data or FloatData if correctedData was
271 : //not there
272 0 : if(!vb.existsColumn(VisBufferComponent2::VisibilityCorrected)){
273 0 : col=refim::FTMachine::OBSERVED;
274 : // cerr << "Max of visCube" << max(vb.visCube()) << " model " << max(vb.modelVisCube())<< endl;
275 0 : vb.setVisCube(vb.visCube()-vb.visCubeModel());
276 : }
277 : else{
278 0 : vb.setVisCubeCorrected(vb.visCubeCorrected()-vb.visCubeModel());
279 : }
280 : }
281 0 : else if (col==refim::FTMachine::OBSERVED) {
282 0 : vb.setVisCube(vb.visCube()-vb.visCubeModel());
283 : }
284 : }// if non zero model
285 :
286 0 : if(col==refim::FTMachine::CORRECTED && !vb.existsColumn(VisBufferComponent2::VisibilityCorrected)) {
287 : //cout << "Corrected column isn't there, using data instead" << endl;
288 0 : col=refim::FTMachine::OBSERVED;
289 : }
290 :
291 0 : if (mapperid < 0)
292 : {
293 : //cout << "Using column : " << col << endl;
294 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
295 : {
296 0 : (itsMappers[k])->grid(vb, dopsf, col);
297 : }
298 : }
299 : else
300 : {
301 0 : if (mapperid > (Int)itsMappers.nelements())
302 0 : throw ( AipsError("Internal Error : SIMapperCollection::grid(): mapperid out of range") );
303 0 : else itsMappers[mapperid]->grid(vb, dopsf, col);
304 : }
305 0 : }
306 :
307 : ///////////////////
308 : ///////////////////////////////////////OLD VI/VB ///////////////////////////////////
309 0 : void SIMapperCollection::grid(VisBuffer& vb, Bool dopsf, FTMachine::Type col,
310 : Int mapperid)
311 : {
312 0 : if( itsIsNonZeroModel == true ) // Try to subtract model visibilities only if a model exists.
313 : {
314 0 : if(col==FTMachine::CORRECTED){
315 0 : if(vb.msColumns().correctedData().isNull()){
316 0 : col=FTMachine::OBSERVED;
317 : // cerr << "Max of visCube" << max(vb.visCube()) << " model " << max(vb.modelVisCube())<< endl;
318 0 : vb.visCube()-=vb.modelVisCube();
319 : }
320 : else{
321 0 : vb.correctedVisCube()-=vb.modelVisCube();
322 : }
323 : }
324 0 : else if (col==FTMachine::OBSERVED) {
325 0 : vb.visCube()-=vb.modelVisCube();
326 : }
327 : }// if non zero model
328 :
329 0 : if(col==FTMachine::CORRECTED && vb.msColumns().correctedData().isNull())
330 0 : { col=FTMachine::OBSERVED;}
331 :
332 0 : if (mapperid < 0)
333 : {
334 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
335 : {
336 0 : (itsMappers[k])->grid(vb, dopsf, col);
337 :
338 : }
339 : }
340 : else
341 : {
342 0 : if (mapperid > (Int)itsMappers.nelements())
343 0 : throw ( AipsError("Internal Error : SIMapperCollection::grid(): mapperid out of range") );
344 0 : else itsMappers[mapperid]->grid(vb, dopsf, col);
345 : }
346 0 : }
347 : ///////////////////////////////
348 : ////////////////////////////////
349 0 : void SIMapperCollection::finalizeGrid(vi::VisBuffer2& vb, Bool dopsf,const Int mapperid)
350 : {
351 0 : if(mapperid<0)
352 : {
353 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
354 : {
355 0 : (itsMappers[k])->finalizeGrid(vb, dopsf);
356 : }
357 : }
358 : else
359 : {
360 0 : if (mapperid > (Int)itsMappers.nelements())
361 0 : throw ( AipsError("Internal Error : SIMapperCollection::finalizeGrid(): mapperid out of range") );
362 0 : else itsMappers[mapperid]->finalizeGrid(vb, dopsf);
363 : }
364 0 : }
365 :
366 :
367 : ////////////////////////////////////////////////////////////////////////////////////////////////////////
368 : /////////////////////////////////////////////OLD VI/VB////////////////////////////////////////////////
369 0 : void SIMapperCollection::finalizeGrid(VisBuffer& vb, Bool dopsf,const Int mapperid)
370 : {
371 0 : if(mapperid<0)
372 : {
373 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
374 : {
375 0 : (itsMappers[k])->finalizeGrid(vb, dopsf);
376 : }
377 : }
378 : else
379 : {
380 0 : if (mapperid > (Int)itsMappers.nelements())
381 0 : throw ( AipsError("Internal Error : SIMapperCollection::finalizeGrid(): mapperid out of range") );
382 0 : else itsMappers[mapperid]->finalizeGrid(vb, dopsf);
383 : }
384 0 : }
385 :
386 :
387 : //////////////////////////////////////////////////////////////////////////////////////////////////////
388 0 : void SIMapperCollection::initializeDegrid(vi::VisBuffer2& vb, const Int mapperid)
389 : {
390 :
391 0 : itsIsNonZeroModel = anyNonZeroModels();
392 :
393 0 : if( itsIsNonZeroModel == true )
394 : {
395 : // vb.setModelVisCube( Complex(0.0,0.0) );
396 :
397 0 : if(mapperid<0)
398 : {
399 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
400 : {
401 0 : (itsMappers[k])->initializeDegrid(vb);
402 : }
403 : }
404 : else
405 : {
406 0 : if (mapperid > (Int)itsMappers.nelements())
407 0 : throw ( AipsError("Internal Error : SIMapperCollection::initializeDegrid(): mapperid out of range") );
408 0 : else itsMappers[mapperid]->initializeDegrid(vb);
409 : }
410 :
411 : }// if non zero model
412 0 : }
413 :
414 :
415 :
416 : ///////////////////////////////////////OLD VI/VB ///////////////////////////////////////////////////
417 0 : void SIMapperCollection::initializeDegrid(VisBuffer& vb, const Int mapperid)
418 : {
419 :
420 0 : itsIsNonZeroModel = anyNonZeroModels();
421 :
422 0 : if( itsIsNonZeroModel == true )
423 : {
424 : // vb.setModelVisCube( Complex(0.0,0.0) );
425 :
426 0 : if(mapperid<0)
427 : {
428 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
429 : {
430 0 : (itsMappers[k])->initializeDegrid(vb);
431 : }
432 : }
433 : else
434 : {
435 0 : if (mapperid > (Int)itsMappers.nelements())
436 0 : throw ( AipsError("Internal Error : SIMapperCollection::initializeDegrid(): mapperid out of range") );
437 0 : else itsMappers[mapperid]->initializeDegrid(vb);
438 : }
439 :
440 : }// if non zero model
441 0 : }
442 :
443 : ////////////////////////////////////////////////////////////////////////////////////////////////
444 0 : void SIMapperCollection::degrid(vi::VisBuffer2& vb, Bool saveVirtualMod, const Int mapperid)
445 : {
446 0 : if( itsIsNonZeroModel == true )
447 : {
448 0 : if(mapperid<0)
449 : {
450 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
451 : {
452 0 : (itsMappers[k])->degrid(vb);
453 : }
454 : }
455 : else
456 : {
457 0 : if (mapperid > (Int)itsMappers.nelements())
458 0 : throw ( AipsError("Internal Error : SIMapperCollection::degrid(): mapperid out of range") );
459 0 : else itsMappers[mapperid]->degrid(vb);
460 : }
461 :
462 0 : if(saveVirtualMod){
463 0 : saveVirtualModel(vb);
464 : }
465 : }// if non zero model
466 0 : }
467 :
468 0 : void SIMapperCollection::addPB(vi::VisBuffer2& vb, PBMath& pbMath, const MDirection& altDir, const Bool useAltDir)
469 : {
470 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
471 : {
472 0 : (itsMappers[k])->addPB(vb,pbMath, altDir, useAltDir);
473 :
474 : }
475 0 : }
476 :
477 :
478 : /////////////////////////////////////OLD VI/VB ////////////////////////////////////////////////////
479 0 : void SIMapperCollection::degrid(VisBuffer& vb, Bool saveVirtualMod, const Int mapperid)
480 : {
481 0 : if( itsIsNonZeroModel == true )
482 : {
483 0 : if(mapperid<0)
484 : {
485 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
486 : {
487 0 : (itsMappers[k])->degrid(vb);
488 : }
489 : }
490 : else
491 : {
492 0 : if (mapperid > (Int)itsMappers.nelements())
493 0 : throw ( AipsError("Internal Error : SIMapperCollection::degrid(): mapperid out of range") );
494 0 : else itsMappers[mapperid]->degrid(vb);
495 : }
496 :
497 0 : if(saveVirtualMod){
498 0 : saveVirtualModel(vb);
499 : }
500 : }// if non zero model
501 0 : }
502 :
503 :
504 : /////
505 : /////////////
506 0 : void SIMapperCollection::saveVirtualModel(VisBuffer& vb){
507 :
508 :
509 :
510 0 : if(vb.msId() != oldMsId_p){
511 0 : oldMsId_p=vb.msId();
512 : /*Block< Vector<Int> > blockNGroup;
513 : Block< Vector<Int> > blockStart;
514 : Block< Vector<Int> > blockWidth;
515 : Block< Vector<Int> > blockIncr;
516 : Block< Vector<Int> > blockSpw;
517 : vb.getChannelSelection(blockNGroup, blockStart, blockWidth, blockIncr, blockSpw);
518 : Vector<Int> fields = vb.msColumns().fieldId().getColumn();
519 : const Int option = Sort::HeapSort | Sort::NoDuplicates;
520 : const Sort::Order order = Sort::Ascending;
521 : Int nfields = GenSort<Int>::sort (fields, order, option);
522 :
523 : // Make sure we have the right size
524 :
525 : fields.resize(nfields, true);
526 : */
527 : //Int msid = vb.msId();
528 0 : ROVisibilityIterator *viloc=vb.getVisibilityIterator();
529 0 : for (uInt k=0; k < itsMappers.nelements(); ++k){
530 0 : Record rec;
531 0 : String modImage=viloc->ms().getPartNames()[0];
532 0 : if(!((viloc->ms()).source().isNull()))
533 0 : modImage=(viloc->ms()).source().tableName();
534 0 : modImage=File::newUniqueName(modImage, "FT_MODEL").absoluteName();
535 0 : Bool iscomp=itsMappers[k]->getCLRecord(rec);
536 0 : if(iscomp || itsMappers[k]->getFTMRecord(rec, modImage)){
537 :
538 : //VisModelData::putModel(vb.getVisibilityIterator()->ms(), rec, fields, blockSpw[msid], blockStart[msid],
539 : // blockWidth[msid], blockIncr[msid],
540 : // iscomp, true);
541 0 : VisibilityIterator * elvi=(dynamic_cast<VisibilityIterator* >(vb.getVisibilityIterator()));
542 0 : if(elvi)
543 0 : elvi->putModel(rec, iscomp, true);
544 : // VisModelData::listModel(vb.getVisibilityIterator()->ms());
545 : }
546 :
547 0 : }
548 :
549 :
550 :
551 : }
552 :
553 :
554 :
555 0 : }
556 :
557 0 : void SIMapperCollection::saveVirtualModel(vi::VisBuffer2& vb){
558 :
559 :
560 :
561 0 : if(vb.msId() != oldMsId_p){
562 0 : oldMsId_p=vb.msId();
563 :
564 0 : for (uInt k=0; k < itsMappers.nelements(); ++k){
565 0 : Record rec;
566 0 : String modImage=vb.ms().getPartNames()[0];
567 0 : if(!((vb.ms()).source().isNull()))
568 0 : modImage=(vb.ms()).source().tableName();
569 0 : modImage=File::newUniqueName(modImage, "FT_MODEL").absoluteName();
570 0 : Bool iscomp=itsMappers[k]->getCLRecord(rec);
571 0 : if(iscomp || itsMappers[k]->getFTMRecord(rec, modImage)){
572 :
573 : ////Darn not implemented
574 : //static_cast<VisibilityIteratorImpl2 *>(viloc->getImpl())->writeModel(rec, //iscomp, true);
575 :
576 0 : if(!iscomp && Table::isReadable(modImage)){
577 : //make sure complex image is of compliant size/shape
578 0 : (itsMappers[k]->imageStore())->intersectComplexImage(modImage);
579 :
580 : }
581 0 : VisibilityIterator2* vi=const_cast<VisibilityIterator2*>(vb.getVi());
582 0 : const_cast<MeasurementSet& >(vi->ms()).lock();
583 : /////TESTOO
584 : //Int CPUID;
585 : //MPI_Comm_rank(MPI_COMM_WORLD, &CPUID);
586 : //cerr << CPUID << " writing " << modImage << endl;
587 : /////////////////
588 0 : vi->writeModel(rec, iscomp, true);
589 0 : const_cast<MeasurementSet& >(vi->ms()).unlock();
590 : // VisModelData::listModel(vb.getVisibilityIterator()->ms());
591 : }
592 :
593 0 : }
594 :
595 :
596 :
597 : }
598 :
599 :
600 :
601 0 : }
602 :
603 :
604 : /////////////////////////////////////////////////////////
605 0 : void SIMapperCollection::finalizeDegrid(vi::VisBuffer2& /*vb*/, const Int mapperid)
606 : {
607 0 : if( itsIsNonZeroModel == true )
608 : {
609 0 : if(mapperid<0)
610 : {
611 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
612 : {
613 0 : (itsMappers[k])->finalizeDegrid();
614 :
615 : }
616 : }
617 : else
618 : {
619 0 : if (mapperid > (Int)itsMappers.nelements())
620 0 : throw ( AipsError("Internal Error : SIMapperCollection::finalizeDegrid(): mapperid out of range") );
621 0 : else itsMappers[mapperid]->finalizeDegrid();
622 : }
623 : }// if non zero model
624 0 : }
625 :
626 : ////////////////////////////////////////////////////////
627 0 : void SIMapperCollection::finalizeDegrid(VisBuffer& /*vb*/, const Int mapperid)
628 : {
629 0 : if( itsIsNonZeroModel == true )
630 : {
631 0 : if(mapperid<0)
632 : {
633 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
634 : {
635 0 : (itsMappers[k])->finalizeDegrid();
636 :
637 : }
638 : }
639 : else
640 : {
641 0 : if (mapperid > (Int)itsMappers.nelements())
642 0 : throw ( AipsError("Internal Error : SIMapperCollection::finalizeDegrid(): mapperid out of range") );
643 0 : else itsMappers[mapperid]->finalizeDegrid();
644 : }
645 : }// if non zero model
646 0 : }
647 :
648 :
649 0 : void SIMapperCollection::initPB()
650 : {
651 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
652 : {
653 0 : (itsMappers[k])->initPB();
654 : }
655 0 : }
656 :
657 0 : void SIMapperCollection::addPB(VisBuffer& vb, PBMath& pbMath)
658 : {
659 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
660 : {
661 0 : (itsMappers[k])->addPB(vb,pbMath);
662 :
663 : }
664 0 : }
665 :
666 : ///////////////////////////////////////////////////////////////////////////////////////////////////////
667 : //////////// End of VB dependent code.
668 : ///////////////////////////////////////////////////////////////////////////////////////////////////////
669 :
670 :
671 :
672 : ///////////////////////////////////////////////////////////////////////////////////////////////////////
673 : /////////////////////
674 0 : CountedPtr<SIImageStore> SIMapperCollection::imageStore(Int id)
675 : {
676 0 : if(uInt(id) < itsMappers.nelements())
677 : {
678 0 : return (itsMappers[id])->imageStore();
679 : }
680 0 : return make_shared<SIImageStore>( );
681 : }
682 : /////////////////////////////////////////////////////////////////////////////////////////////
683 : /////////////////////////////////////////////////////////////////////////////////////////////
684 0 : Record SIMapperCollection::getFTMRecord(Int mapperid)
685 : {
686 0 : AlwaysAssert( mapperid >=0 && mapperid < nMappers() , AipsError );
687 : //return itsMappers[mapperid]->getFTMRecord();
688 0 : Record rec;
689 0 : return rec;
690 : }
691 :
692 : //////////////////////////////////////////////////////////////////////////////////////////////////////
693 : //////////////////////////////////////////////////////////////////////////////////////////////////////
694 :
695 0 : void SIMapperCollection::checkOverlappingModels(String action)
696 : {
697 : // If nothing that overlaps, don't check.
698 0 : if(nMappers()==1) return;
699 :
700 0 : Int nmodels = nMappers();
701 :
702 : // If there is no model image (i.e. first major cycle with no starting model), don't check.
703 0 : Bool hasmodel=true;
704 0 : for (Int model=0;model<(nmodels-1); ++model)
705 0 : { hasmodel = hasmodel && ((itsMappers[model])->imageStore())->hasModel(); }
706 0 : if( hasmodel==false ) {
707 : //cout << "No model images to check overlap for." << endl;
708 0 : return;
709 : }
710 :
711 : // Internal check
712 0 : AlwaysAssert( action=="blank" || action=="restore" , AipsError );
713 :
714 0 : for (Int model=0;model<(nmodels-1); ++model)
715 : {
716 : // Connect to one image for aux info.
717 0 : LatticeLocker lockmodel (*(((itsMappers[model])->imageStore())->model()), FileLocker::Write);
718 0 : SubImage<Float> modelimage( *(((itsMappers[model])->imageStore())->model()), true );
719 :
720 0 : uInt nTaylor0 = ((itsMappers[model])->imageStore())->getNTaylorTerms();
721 :
722 0 : CoordinateSystem cs0=modelimage.coordinates();
723 0 : IPosition iblc0(modelimage.shape().nelements(),0);
724 0 : IPosition itrc0(modelimage.shape());
725 0 : itrc0=itrc0-Int(1);
726 0 : LCBox lbox0(iblc0, itrc0, modelimage.shape());
727 0 : ImageRegion imagreg0(WCBox(lbox0, cs0));
728 :
729 0 : for (Int nextmodel=model+1; nextmodel < nmodels; ++nextmodel)
730 : {
731 0 : LatticeLocker nextlockmodel (*(((itsMappers[nextmodel])->imageStore())->model()), FileLocker::Write);
732 0 : SubImage<Float> nextmodelimage( *(((itsMappers[nextmodel])->imageStore())->model()) , true);
733 :
734 0 : uInt nTaylor1 = ((itsMappers[nextmodel])->imageStore())->getNTaylorTerms();
735 :
736 0 : CoordinateSystem cs=nextmodelimage.coordinates();
737 0 : IPosition iblc(nextmodelimage.shape().nelements(),0);
738 0 : IPosition itrc(nextmodelimage.shape());
739 0 : itrc=itrc-Int(1);
740 0 : LCBox lbox(iblc, itrc, nextmodelimage.shape());
741 0 : ImageRegion imagreg(WCBox(lbox, cs));
742 :
743 : try{
744 :
745 0 : if( action.matches("blank") )
746 : {
747 :
748 : //cerr << "blank MODEL image shape " << modelimage.shape() << " " << nextmodelimage.shape() << endl;
749 :
750 0 : LatticeRegion latReg=imagreg.toLatticeRegion(modelimage.coordinates(), modelimage.shape());
751 :
752 0 : for(uInt taylor=0;taylor<min(nTaylor0,nTaylor1);taylor++)
753 : { // loop for taylor term
754 0 : SubImage<Float> modelim( *(((itsMappers[model])->imageStore())->model(taylor)), true );
755 0 : SubImage<Float> partToMask(modelim, imagreg, true);
756 0 : LatticeLocker lock1 (partToMask, FileLocker::Write);
757 0 : ArrayLattice<Bool> pixmask(latReg.get());
758 0 : LatticeExpr<Float> myexpr(iif(pixmask, 0.0, partToMask) );
759 0 : partToMask.copyData(myexpr);
760 0 : }
761 :
762 :
763 0 : }
764 : else // "restore"
765 : {
766 : //cerr << "rsetore MODEL image shape " << modelimage.shape() << " " << nextmodelimage.shape() << endl;
767 0 : LatticeRegion latReg0=imagreg0.toLatticeRegion(nextmodelimage.coordinates(), nextmodelimage.shape());
768 0 : LatticeRegion latReg=imagreg.toLatticeRegion(modelimage.coordinates(), modelimage.shape());
769 0 : ArrayLattice<Bool> pixmask(latReg.get());
770 :
771 :
772 0 : for(uInt taylor=0;taylor<min(nTaylor0,nTaylor1);taylor++)
773 : {// loop for taylor term
774 0 : SubImage<Float> modelim( *(((itsMappers[model])->imageStore())->model(taylor)), true );
775 0 : SubImage<Float> nextmodelim( *(((itsMappers[nextmodel])->imageStore())->model(taylor)), true );
776 :
777 0 : SubImage<Float> partToMerge(nextmodelim, imagreg0, true);
778 0 : SubImage<Float> partToUnmask(modelim, imagreg, true);
779 0 : LatticeLocker lock1 (partToUnmask, FileLocker::Write);
780 0 : LatticeLocker lock2 (partToMerge, FileLocker::Write);
781 0 : LatticeExpr<Float> myexpr0(iif(pixmask,partToMerge,partToUnmask));
782 0 : partToUnmask.copyData(myexpr0);
783 0 : }
784 :
785 0 : }
786 : }
787 0 : catch(AipsError &x){
788 : // cout << "Hmm.... in here : "<< x.getMesg() << endl;
789 : //no overlap you think ?
790 : /*
791 : os << LogIO::WARN
792 : << "no overlap or failure of copying the clean components"
793 : << x.getMesg()
794 : << LogIO::POST;
795 : */
796 0 : continue;
797 0 : }
798 0 : }
799 0 : }
800 : }
801 :
802 : ////////////////////////////////////////////////////////////////////////////////////////////////////
803 : ///////////////////////////////////////////////////////////////////////////////////////////////////
804 0 : Long SIMapperCollection::estimateRAM(){
805 0 : Long mem=0;
806 0 : for (uInt k=0; k < itsMappers.nelements(); ++k)
807 : {
808 0 : if(! ((itsMappers[k])->getFTM2()))
809 0 : throw(AipsError("No VI/VB2 FTMachine set"));
810 : ///IFT
811 0 : if(((itsMappers[k])->getFTM2())->estimateRAM(((itsMappers[k])->imageStore()))> 0){
812 0 : mem+=((itsMappers[k])->getFTM2())->estimateRAM(((itsMappers[k])->imageStore()));
813 : //FT
814 0 : mem+=((itsMappers[k])->getFTM2(False))->estimateRAM(((itsMappers[k])->imageStore()));
815 : }
816 : else{
817 : //Assuming double precision...ignoring padding etc.
818 0 : mem+=6*sizeof(float)*(((itsMappers[k])->imageStore())->getShape().product());
819 : }
820 : //Imagestorages
821 0 : mem+=((itsMappers[k])->imageStore())->estimateRAM();
822 : }
823 0 : return mem;
824 : }
825 :
826 : //////////////////////////////////////////////////////////////////////////////////////////////////////
827 : //////////////////////////////////////////////////////////////////////////////////////////////////////
828 :
829 0 : Bool SIMapperCollection::anyNonZeroModels()
830 : {
831 0 : Bool validmodel=false;
832 : // If any one Mapper has a valid and nonzero model, return true.
833 0 : for (Int model=0;model<nMappers(); ++model)
834 : {
835 0 : validmodel |= (! ( ((itsMappers[model])->imageStore())->isModelEmpty() ));
836 : }
837 0 : return validmodel;
838 : }
839 : //////////////////////////////////////////////////////////////////////////////////////////////////////
840 :
841 : } //# NAMESPACE CASA - END
842 :
|
