Line data Source code
1 : //# CCList.cc: implementation file for CCList
2 : //# Copyright (C) 1996,1997,1998,1999
3 : //# Associated Universities, Inc. Washington DC, USA.
4 : //#
5 : //# This library is free software; you can redistribute it and/or modify it
6 : //# under the terms of the GNU Library General Public License as published by
7 : //# the Free Software Foundation; either version 2 of the License, or (at your
8 : //# option) any later version.
9 : //#
10 : //# This library 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 Library General Public
13 : //# License for more details.
14 : //#
15 : //# You should have received a copy of the GNU Library General Public License
16 : //# along with this library; if not, write to the Free Software Foundation,
17 : //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 : //#
19 : //# Correspondence concerning AIPS++ should be addressed as follows:
20 : //# Internet email: aips2-request@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 <synthesis/MeasurementEquations/CCList.h>
29 : #include <casacore/casa/Arrays/Vector.h>
30 :
31 :
32 : using namespace casacore;
33 : namespace casa { //# NAMESPACE CASA - BEGIN
34 :
35 0 : CCList::CCList()
36 : :itsPol(1),
37 : itsDim(2),
38 : itsComp(0),
39 : itsFlux(),
40 : itsPos(),
41 0 : itsSuspendOKCheck(false)
42 : {
43 0 : DebugAssert(ok(), AipsError);
44 0 : };
45 :
46 0 : CCList::CCList(const uInt nPol, const uInt nDim, const uInt nComp)
47 : :itsPol(nPol),
48 : itsDim(nDim),
49 : itsComp(0),
50 0 : itsFlux(nPol*nComp),
51 0 : itsPos(nDim*nComp),
52 0 : itsSuspendOKCheck(false)
53 : {
54 0 : DebugAssert(ok(), AipsError);
55 0 : };
56 :
57 0 : CCList::CCList(const CCList & other)
58 0 : :itsPol(other.itsPol),
59 0 : itsDim(other.itsDim),
60 0 : itsComp(other.itsComp),
61 0 : itsFlux(other.itsFlux),
62 0 : itsPos(other.itsPos),
63 0 : itsSuspendOKCheck(false)
64 : {
65 0 : DebugAssert(ok(), AipsError);
66 0 : };
67 :
68 0 : CCList::~CCList() {
69 0 : DebugAssert(ok(), AipsError);
70 0 : };
71 :
72 0 : CCList & CCList::operator=(const CCList & other){
73 0 : if (this != &other) {
74 0 : itsPol = other.itsPol;
75 0 : itsDim = other.itsDim;
76 0 : itsComp = other.itsComp;
77 0 : itsFlux = other.itsFlux;
78 0 : itsPos = other.itsPos;
79 0 : itsSuspendOKCheck = other.itsSuspendOKCheck;
80 : }
81 0 : DebugAssert(ok(), AipsError);
82 0 : return *this;
83 : };
84 :
85 0 : Int * CCList::positionPtr() {
86 0 : DebugAssert(ok(), AipsError)
87 0 : return itsPos.storage();
88 : };
89 :
90 0 : const Int * CCList::positionPtr() const {
91 0 : DebugAssert(ok(), AipsError);
92 0 : return itsPos.storage();
93 : };
94 :
95 0 : Float * CCList::fluxPtr() {
96 0 : DebugAssert(ok(), AipsError);
97 0 : return itsFlux.storage();
98 : };
99 :
100 0 : const Float * CCList::fluxPtr() const {
101 0 : DebugAssert(ok(), AipsError);
102 0 : return itsFlux.storage();
103 : };
104 :
105 0 : Int * CCList::freePositionPtr() {
106 0 : DebugAssert(ok(), AipsError);
107 0 : return itsPos.storage() + nComp()*nDim();
108 : };
109 :
110 0 : const Int * CCList::freePositionPtr() const {
111 0 : DebugAssert(ok(), AipsError);
112 0 : return itsPos.storage() + nComp()*nDim();
113 : };
114 :
115 0 : Float * CCList::freeFluxPtr() {
116 0 : DebugAssert(ok(), AipsError);
117 0 : return itsFlux.storage() + nComp()*nPol();
118 : };
119 :
120 0 : const Float * CCList::freeFluxPtr() const {
121 0 : DebugAssert(ok(), AipsError);
122 0 : return itsFlux.storage() + nComp()*nPol();
123 : };
124 :
125 0 : uInt CCList::maxComp() const {
126 0 : DebugAssert(ok(), AipsError)
127 0 : return itsPos.nelements()/nDim();
128 : };
129 :
130 0 : uInt CCList::freeComp() const {
131 0 : DebugAssert(ok(), AipsError);
132 0 : return maxComp() - nComp();
133 : };
134 :
135 0 : void CCList::resize(const uInt newSize) {
136 0 : suspendOKCheck();
137 0 : Block<Int> pr(itsPos);
138 0 : Block<Float> fr(itsFlux);
139 0 : itsPos.resize(nDim()*newSize);
140 0 : itsFlux.resize(nPol() * newSize);
141 0 : for (uInt i=0; i< nComp()*nDim(); i++) {
142 0 : itsPos[i] = pr[i];
143 : }
144 0 : for (uInt i=0; i< nComp()*nPol(); i++) {
145 0 : itsFlux[i] = fr[i];
146 : }
147 0 : reactivateOKCheck();
148 :
149 0 : DebugAssert(ok(), AipsError);
150 0 : };
151 :
152 0 : void CCList::addComp(const Block<Float> & flux, const Block<Int> & position) {
153 :
154 0 : if (nComp() >= maxComp() ) {
155 0 : resize(2*nComp()+1);
156 : }
157 0 : Int * pos_p = freePositionPtr();
158 0 : Float * flux_p = freeFluxPtr();
159 0 : uInt n = flux.nelements();
160 0 : for (uInt i=0;i<n;i++) {
161 0 : *(flux_p+i) = flux[i];
162 : }
163 0 : *(pos_p) = position[0];
164 0 : *(pos_p+1) = position[1];
165 0 : nComp()++;
166 0 : };
167 :
168 :
169 0 : Bool CCList::ok() const {
170 0 : if (itsSuspendOKCheck) {
171 0 : return true;
172 : }
173 : // Be arbitary: disallow more than 4-D Clean Components
174 0 : if ((itsDim < 1) || (itsDim > 4)) {
175 0 : return false;
176 : }
177 0 : if ((itsPol != 1) && (itsPol != 2) && (itsPol != 4)) {
178 0 : return false;
179 : }
180 0 : if (itsComp*itsDim > itsPos.nelements()) {
181 0 : return false;
182 : }
183 0 : if (itsComp*itsPol > itsFlux.nelements()) {
184 0 : return false;
185 : }
186 0 : if (itsPos.nelements()/itsDim != itsFlux.nelements()/itsPol) {
187 0 : return false;
188 : }
189 0 : return true;
190 : };
191 :
192 0 : Int * CCList::pixelPosition(const uInt whichPixel) {
193 0 : DebugAssert(whichPixel < nComp(), AipsError);
194 0 : DebugAssert(ok(), AipsError);
195 0 : return itsPos.storage() + whichPixel*nDim();
196 : };
197 :
198 0 : Float * CCList::pixelFlux(const uInt whichPixel) {
199 0 : DebugAssert(whichPixel < nComp(), AipsError);
200 0 : DebugAssert(ok(), AipsError);
201 0 : return itsFlux.storage() + whichPixel*nPol();
202 : };
203 :
204 0 : void CCList::tiledSort(const IPosition & tileShape) {
205 0 : if (nComp() == 0) {
206 0 : return;
207 : }
208 0 : Vector<uInt> index(nComp());
209 0 : Block<Int> tileNumber(nComp());
210 0 : const Int tx = tileShape(0);
211 0 : const Int ty = tileShape(1);
212 : // const Int tileArea = tx * tileShape(1);
213 : Int * posPtr;
214 : Int x, y;
215 : Int it, jt;
216 0 : for (uInt c = 0; c < nComp(); c++) {
217 0 : posPtr = pixelPosition(c);
218 0 : x = *posPtr;
219 0 : posPtr++;
220 0 : y = *posPtr;
221 : // tileNumber[c] = (x + tx * y) % tileArea; old algorithm
222 0 : it = (Int)(x/tx);
223 0 : jt = (Int)(y/ty);
224 0 : tileNumber[c] = jt*10000 + it;
225 : }
226 :
227 0 : AlwaysAssert(genSort(index, tileNumber) == nComp(), AipsError);
228 :
229 0 : Int * sortedPos = new Int[nDim()*nComp()];
230 0 : Float * sortedFlux = new Float[nPol()*nComp()];
231 : uInt whichElem, newElem;
232 0 : for (uInt c = 0; c < nComp(); c++) {
233 0 : whichElem = nDim()*index(c);
234 0 : newElem = nDim()*c;
235 0 : sortedPos[newElem] = itsPos[whichElem];
236 0 : whichElem++; newElem++;
237 0 : sortedPos[newElem] = itsPos[whichElem];
238 0 : whichElem = nPol()*index(c);
239 0 : newElem = nPol()*c;
240 0 : for (uInt k = 0; k < nPol(); k++) {
241 0 : sortedFlux[newElem] = itsFlux[whichElem];
242 0 : whichElem++; newElem++;
243 : }
244 : }
245 :
246 0 : suspendOKCheck();
247 0 : itsPos.replaceStorage((nDim()*nComp()), sortedPos);
248 0 : itsFlux.replaceStorage((nPol()*nComp()), sortedFlux);
249 0 : reactivateOKCheck();
250 0 : ok();
251 : };
252 :
253 0 : void CCList::suspendOKCheck() {
254 0 : itsSuspendOKCheck = true;
255 0 : };
256 :
257 0 : void CCList::reactivateOKCheck() {
258 0 : itsSuspendOKCheck = false;
259 0 : };
260 :
261 :
262 : } //# NAMESPACE CASA - END
263 :
|
