Line data Source code
1 : //# DDMapper.cc: this defines DDMapper
2 : //# Copyright (C) 2000,2001,2002
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 : #include <casacore/casa/Exceptions/Error.h>
28 : #include <flagging/Flagging/DDMapper.h>
29 : #include <flagging/Flagging/RFChunkStats.h>
30 : #include <casacore/casa/Utilities/Regex.h>
31 :
32 : using namespace casacore;
33 : namespace casa { //# NAMESPACE CASA - BEGIN
34 :
35 0 : DDFunc::DDFunc( FuncSignature fsig,const String &corrstr )
36 0 : : DDMapper(),icorr(-1),func(fsig)
37 : {
38 0 : corrtype = Stokes::type( corrstr );
39 0 : valid = false;
40 0 : }
41 :
42 0 : Bool DDFunc::reset ( const Vector<Int> &corr )
43 : {
44 0 : icorr = findCorrType( corrtype,corr );
45 0 : if( icorr<0 )
46 0 : return valid=false;
47 0 : corrmask = (1<<icorr);
48 0 : return valid=true;
49 : }
50 :
51 0 : Float DDFunc::map ( const Cube<Complex> &vis,uInt ich,uInt irow ) const
52 : {
53 0 : return (*func)( vis(icorr,ich,irow) );
54 : }
55 :
56 0 : Float DDFunc::real ( const Complex &val)
57 : {
58 0 : return val.real();
59 : }
60 :
61 0 : Float DDFunc::imag ( const Complex &val)
62 : {
63 0 : return val.imag();
64 : }
65 :
66 0 : DDSumFunc::DDSumFunc( FuncSignature fsig,const String &corr1,const String &corr2 )
67 0 : : DDFunc(fsig,corr1),icorr2(-1)
68 : {
69 0 : corrtype2 = Stokes::type( corr2 );
70 0 : valid = false;
71 0 : }
72 :
73 0 : Bool DDSumFunc::reset ( const Vector<Int> &corr )
74 : {
75 : // case of "I" - look up XX+YY or RR+LL
76 0 : if( corrtype == Stokes::I )
77 : {
78 0 : icorr = findCorrType( Stokes::XX,corr );
79 0 : icorr2 = findCorrType( Stokes::YY,corr );
80 : // no XX+YY? try RR+LL
81 0 : if( icorr<0 || icorr2<0 )
82 : {
83 0 : icorr = findCorrType( Stokes::RR,corr );
84 0 : icorr2 = findCorrType( Stokes::LL,corr );
85 : }
86 : // give up if not found
87 0 : if( icorr<0 || icorr2<0 )
88 0 : return valid=false;
89 0 : corrmask = (1<<icorr)|(1<<icorr2);
90 0 : return valid=true;
91 : }
92 : // standard case - just look up correlations directly
93 : else
94 : {
95 0 : if( !DDFunc::reset(corr) )
96 0 : return false;
97 0 : icorr2 = findCorrType( corrtype2,corr );
98 0 : if( icorr2<0 )
99 0 : return valid=false;
100 0 : corrmask |= (1<<icorr2);
101 0 : return valid=true;
102 : }
103 : }
104 :
105 0 : Float DDSumFunc::map ( const Cube<Complex> &vis,uInt ich,uInt irow ) const
106 : {
107 0 : return (*func)( vis(icorr,ich,irow) ) + (*func)( vis(icorr2,ich,irow) );
108 : }
109 :
110 0 : DDFuncSum::DDFuncSum( FuncSignature fsig,const String &corr1,const String &corr2 )
111 0 : : DDSumFunc(fsig,corr1,corr2)
112 0 : {}
113 :
114 0 : Float DDFuncSum::map ( const Cube<Complex> &vis,uInt ich,uInt irow ) const
115 : {
116 0 : return (*func)( vis(icorr,ich,irow) + vis(icorr2,ich,irow) );
117 : }
118 :
119 0 : DDFuncDiff::DDFuncDiff( FuncSignature fsig,const String &corr1,const String &corr2 )
120 0 : : DDSumFunc(fsig,corr1,corr2)
121 0 : {}
122 :
123 0 : Float DDFuncDiff::map ( const Cube<Complex> &vis,uInt ich,uInt irow ) const
124 : {
125 0 : return (*func)( vis(icorr,ich,irow) - vis(icorr2,ich,irow) );
126 : }
127 :
128 0 : DDDiffFunc::DDDiffFunc( FuncSignature fsig,const String &corr1,const String &corr2 )
129 0 : : DDSumFunc(fsig,corr1,corr2)
130 0 : {}
131 :
132 0 : Float DDDiffFunc::map ( const Cube<Complex> &vis,uInt ich,uInt irow ) const
133 : {
134 0 : return (*func)( vis(icorr,ich,irow) ) - (*func)( vis(icorr2,ich,irow) );
135 : }
136 :
137 : // -----------------------------------------------------------------------
138 : // getDDFunction
139 : // Maps a string to a function pointer
140 : // -----------------------------------------------------------------------
141 0 : DDFunc::FuncSignature DDFunc::getFunction ( const String &func )
142 : {
143 : // Map of available functions
144 0 : const struct { const char *name; DDFunc::FuncSignature func; } func_map[] =
145 : { { "ABS", std::abs },
146 : { "ARG", std::arg },
147 : { "RE" , DDFunc::real },
148 : { "IM" , DDFunc::imag },
149 : { "RE" , DDFunc::real },
150 : { "NORM" , std::norm }
151 : };
152 0 : const uInt num_func_map = sizeof(func_map)/sizeof(func_map[0]);
153 :
154 0 : for( uInt i=0; i<num_func_map; i++ )
155 0 : if( func.matches( func_map[i].name ) )
156 0 : return func_map[i].func;
157 0 : return NULL;
158 : }
159 :
160 0 : static AipsError funcError ( const String &name )
161 : {
162 0 : return AipsError( String("DDMapper: unrecognized function '")+name+"'");
163 : }
164 :
165 : // -----------------------------------------------------------------------
166 : // splitExpression
167 : // helper function, converts vector of strings (or single string
168 : // w/whitespace separators) into vector of uppercase Strings.
169 : // -----------------------------------------------------------------------
170 0 : Vector<String> splitExpression( const Vector<String> &expr0 )
171 : {
172 0 : uInt nel = expr0.nelements();
173 0 : if( nel == 1 ) // if only one element, try to split it at whitespace
174 : {
175 : // split expression into array of strings
176 0 : String expr[20];
177 0 : nel = split(expr0(0),expr,20,RXwhite);
178 0 : Vector<String> out(nel);
179 0 : for( uInt i=0; i<nel; i++ )
180 0 : out(i) = upcase( expr[i] );
181 0 : return out;
182 : }
183 : // else just copy vector, converting to uppercase
184 0 : Vector<String> out(nel);
185 0 : for( uInt i=0; i<nel; i++ )
186 0 : out(i) = upcase( expr0(i) );
187 0 : return out;
188 : }
189 :
190 : // -----------------------------------------------------------------------
191 : // getDDMapper
192 : // Parses vector of strings to define a mapper
193 : // -----------------------------------------------------------------------
194 0 : DDMapper * DDFunc::getMapper ( String &descr,const Vector<String> &expr0,Bool throw_excp )
195 : {
196 : // convert to C array
197 0 : Vector<String> expr( splitExpression(expr0) );
198 0 : uInt nel = expr.nelements();
199 :
200 0 : if( nel == 1 ) // 1 element: assume it's just CORR, and use abs(CORR)
201 : {
202 0 : if( expr(0) == "I" ) // I is special (maps to XX+YY or RR+LL)
203 0 : return new DDFuncSum(&std::abs,"I","I");
204 0 : return new DDFunc(&std::abs,expr(0));
205 : }
206 0 : else if( nel == 2 ) // 2 elements: assume FUNC CC
207 : {
208 0 : DDFunc::FuncSignature func = getFunction(expr(0));
209 0 : if( !func )
210 0 : throw( funcError(expr(0)) );
211 0 : descr = expr(0)+"("+expr(1)+")";
212 0 : if( expr(1) == "I" ) // I is special (maps to XX+YY or RR+LL)
213 0 : return new DDFuncSum(func,"I","I");
214 0 : return new DDFunc(func,expr(1));
215 : }
216 0 : else if( nel == 4 ) // 4 elements: SUM FUNC CC CC or FUNC SUM CC CC
217 : {
218 : DDFunc::FuncSignature func;
219 0 : if( expr(0) == "+" || expr(0) == "-" )
220 : {
221 0 : func = getFunction(expr(1));
222 0 : if( !func )
223 0 : throw( funcError(expr(1)) );
224 0 : descr = expr(1)+"("+expr(2)+")"+expr(0)+expr(1)+"("+expr(3)+")";
225 0 : if( expr(0) == "+" )
226 0 : return new DDSumFunc(func,expr(2),expr(3));
227 : else
228 0 : return new DDDiffFunc(func,expr(2),expr(3));
229 : }
230 0 : if( expr(1) == "+" || expr(1) == "-" )
231 : {
232 0 : func = getFunction(expr(0));
233 0 : if( !func )
234 0 : throw( funcError(expr(0)) );
235 0 : descr = expr(0)+"("+expr(2)+expr(1)+expr(3)+")";
236 0 : if( expr(1) == "+" )
237 0 : return new DDFuncSum(func,expr(2),expr(3));
238 : else
239 0 : return new DDFuncDiff(func,expr(2),expr(3));
240 : }
241 : }
242 : // fall through to error report
243 0 : if( throw_excp )
244 : {
245 0 : String err("bad DDMapper expression:");
246 0 : for( uInt i=0; i<nel; i++ )
247 0 : err += String(" ")+expr(i);
248 0 : throw( AipsError(err) );
249 : }
250 0 : return NULL;
251 : }
252 :
253 :
254 : } //# NAMESPACE CASA - END
255 :
|
