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 844 : CCList::CCList(const uInt nPol, const uInt nDim, const uInt nComp)
47 : :itsPol(nPol),
48 : itsDim(nDim),
49 : itsComp(0),
50 844 : itsFlux(nPol*nComp),
51 844 : itsPos(nDim*nComp),
52 844 : itsSuspendOKCheck(false)
53 : {
54 844 : DebugAssert(ok(), AipsError);
55 844 : };
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 844 : CCList::~CCList() {
69 844 : DebugAssert(ok(), AipsError);
70 844 : };
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 2834 : Int * CCList::positionPtr() {
86 2834 : DebugAssert(ok(), AipsError)
87 2834 : 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 2834 : Float * CCList::fluxPtr() {
96 2834 : DebugAssert(ok(), AipsError);
97 2834 : return itsFlux.storage();
98 : };
99 :
100 3256 : const Float * CCList::fluxPtr() const {
101 3256 : DebugAssert(ok(), AipsError);
102 3256 : return itsFlux.storage();
103 : };
104 :
105 3678 : Int * CCList::freePositionPtr() {
106 3678 : DebugAssert(ok(), AipsError);
107 3678 : 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 3678 : Float * CCList::freeFluxPtr() {
116 3678 : DebugAssert(ok(), AipsError);
117 3678 : 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 4522 : uInt CCList::maxComp() const {
126 4522 : DebugAssert(ok(), AipsError)
127 4522 : return itsPos.nelements()/nDim();
128 : };
129 :
130 844 : uInt CCList::freeComp() const {
131 844 : DebugAssert(ok(), AipsError);
132 844 : return maxComp() - nComp();
133 : };
134 :
135 677 : void CCList::resize(const uInt newSize) {
136 677 : suspendOKCheck();
137 1354 : Block<Int> pr(itsPos);
138 1354 : Block<Float> fr(itsFlux);
139 677 : itsPos.resize(nDim()*newSize);
140 677 : itsFlux.resize(nPol() * newSize);
141 1641 : for (uInt i=0; i< nComp()*nDim(); i++) {
142 964 : itsPos[i] = pr[i];
143 : }
144 1159 : for (uInt i=0; i< nComp()*nPol(); i++) {
145 482 : itsFlux[i] = fr[i];
146 : }
147 677 : reactivateOKCheck();
148 :
149 677 : DebugAssert(ok(), AipsError);
150 677 : };
151 :
152 2834 : void CCList::addComp(const Block<Float> & flux, const Block<Int> & position) {
153 :
154 2834 : if (nComp() >= maxComp() ) {
155 255 : resize(2*nComp()+1);
156 : }
157 2834 : Int * pos_p = freePositionPtr();
158 2834 : Float * flux_p = freeFluxPtr();
159 2834 : uInt n = flux.nelements();
160 5668 : for (uInt i=0;i<n;i++) {
161 2834 : *(flux_p+i) = flux[i];
162 : }
163 2834 : *(pos_p) = position[0];
164 2834 : *(pos_p+1) = position[1];
165 2834 : nComp()++;
166 2834 : };
167 :
168 :
169 4249292 : Bool CCList::ok() const {
170 4249292 : if (itsSuspendOKCheck) {
171 8642 : return true;
172 : }
173 : // Be arbitary: disallow more than 4-D Clean Components
174 4240650 : if ((itsDim < 1) || (itsDim > 4)) {
175 0 : return false;
176 : }
177 4240650 : if ((itsPol != 1) && (itsPol != 2) && (itsPol != 4)) {
178 0 : return false;
179 : }
180 4240650 : if (itsComp*itsDim > itsPos.nelements()) {
181 0 : return false;
182 : }
183 4240650 : if (itsComp*itsPol > itsFlux.nelements()) {
184 0 : return false;
185 : }
186 4240650 : if (itsPos.nelements()/itsDim != itsFlux.nelements()/itsPol) {
187 0 : return false;
188 : }
189 4240650 : return true;
190 : };
191 :
192 1036128 : Int * CCList::pixelPosition(const uInt whichPixel) {
193 1036128 : DebugAssert(whichPixel < nComp(), AipsError);
194 1036128 : DebugAssert(ok(), AipsError);
195 1036128 : return itsPos.storage() + whichPixel*nDim();
196 : };
197 :
198 2834 : Float * CCList::pixelFlux(const uInt whichPixel) {
199 2834 : DebugAssert(whichPixel < nComp(), AipsError);
200 2834 : DebugAssert(ok(), AipsError);
201 2834 : return itsFlux.storage() + whichPixel*nPol();
202 : };
203 :
204 422 : void CCList::tiledSort(const IPosition & tileShape) {
205 422 : if (nComp() == 0) {
206 0 : return;
207 : }
208 844 : Vector<uInt> index(nComp());
209 844 : Block<Int> tileNumber(nComp());
210 422 : const Int tx = tileShape(0);
211 422 : const Int ty = tileShape(1);
212 : // const Int tileArea = tx * tileShape(1);
213 : Int * posPtr;
214 : Int x, y;
215 : Int it, jt;
216 3256 : for (uInt c = 0; c < nComp(); c++) {
217 2834 : posPtr = pixelPosition(c);
218 2834 : x = *posPtr;
219 2834 : posPtr++;
220 2834 : y = *posPtr;
221 : // tileNumber[c] = (x + tx * y) % tileArea; old algorithm
222 2834 : it = (Int)(x/tx);
223 2834 : jt = (Int)(y/ty);
224 2834 : tileNumber[c] = jt*10000 + it;
225 : }
226 :
227 422 : AlwaysAssert(genSort(index, tileNumber) == nComp(), AipsError);
228 :
229 422 : Int * sortedPos = new Int[nDim()*nComp()];
230 422 : Float * sortedFlux = new Float[nPol()*nComp()];
231 : uInt whichElem, newElem;
232 3256 : for (uInt c = 0; c < nComp(); c++) {
233 2834 : whichElem = nDim()*index(c);
234 2834 : newElem = nDim()*c;
235 2834 : sortedPos[newElem] = itsPos[whichElem];
236 2834 : whichElem++; newElem++;
237 2834 : sortedPos[newElem] = itsPos[whichElem];
238 2834 : whichElem = nPol()*index(c);
239 2834 : newElem = nPol()*c;
240 5668 : for (uInt k = 0; k < nPol(); k++) {
241 2834 : sortedFlux[newElem] = itsFlux[whichElem];
242 2834 : whichElem++; newElem++;
243 : }
244 : }
245 :
246 422 : suspendOKCheck();
247 422 : itsPos.replaceStorage((nDim()*nComp()), sortedPos);
248 422 : itsFlux.replaceStorage((nPol()*nComp()), sortedFlux);
249 422 : reactivateOKCheck();
250 422 : ok();
251 : };
252 :
253 1099 : void CCList::suspendOKCheck() {
254 1099 : itsSuspendOKCheck = true;
255 1099 : };
256 :
257 1099 : void CCList::reactivateOKCheck() {
258 1099 : itsSuspendOKCheck = false;
259 1099 : };
260 :
261 :
262 : } //# NAMESPACE CASA - END
263 :
|
