Line data Source code
1 : //# Flux.cc:
2 : //# Copyright (C) 1998,1999,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: 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: Flux.tcc 21292 2012-11-28 14:58:19Z gervandiepen $
27 :
28 : #include <components/ComponentModels/Flux.h>
29 : #include <casacore/casa/Arrays/Array.h>
30 : #include <casacore/casa/Arrays/ArrayMath.h>
31 : #include <casacore/casa/Arrays/ArrayLogical.h>
32 : #include <casacore/casa/Containers/RecordInterface.h>
33 : #include <casacore/casa/Exceptions/Error.h>
34 : #include <casacore/casa/Logging/LogIO.h>
35 : #include <casacore/casa/Logging/LogOrigin.h>
36 : #include <casacore/casa/BasicSL/Complex.h>
37 : #include <casacore/casa/BasicSL/Constants.h>
38 : #include <casacore/measures/Measures/Stokes.h>
39 : #include <casacore/casa/Quanta/Quantum.h>
40 : #include <casacore/casa/Quanta/QuantumHolder.h>
41 : #include <casacore/casa/Utilities/Assert.h>
42 : #include <casacore/casa/Utilities/DataType.h>
43 : #include <casacore/casa/BasicSL/String.h>
44 : #include <iostream>
45 :
46 : namespace casa { //# NAMESPACE CASA - BEGIN
47 :
48 : template<class T> const std::vector<casacore::Unit> FluxRep<T>::_allowedUnits {"Jy", "Jy.km/s", "K.rad2"};
49 :
50 2611205 : template<class T> FluxRep<T>::
51 : FluxRep()
52 2611205 : :itsVal(4, typename casacore::NumericTraits<T>::ConjugateType(0,0)),
53 2611205 : itsPol(ComponentType::STOKES),
54 2611205 : itsUnit("Jy"),
55 2611205 : itsErr(4, typename casacore::NumericTraits<T>::ConjugateType(0,0))
56 : {
57 2611205 : itsVal(0) = 1;
58 2611205 : }
59 :
60 0 : template<class T> FluxRep<T>::
61 : FluxRep(T i)
62 0 : :itsVal(4, typename casacore::NumericTraits<T>::ConjugateType(0,0)),
63 0 : itsPol(ComponentType::STOKES),
64 0 : itsUnit("Jy"),
65 0 : itsErr(4, typename casacore::NumericTraits<T>::ConjugateType(0,0))
66 : {
67 0 : itsVal(0) = i;
68 0 : }
69 :
70 4 : template<class T> FluxRep<T>::
71 : FluxRep(T i, T q, T u, T v)
72 4 : :itsVal(4, typename casacore::NumericTraits<T>::ConjugateType(0,0)),
73 4 : itsPol(ComponentType::STOKES),
74 4 : itsUnit("Jy"),
75 4 : itsErr(4, typename casacore::NumericTraits<T>::ConjugateType(0,0))
76 : {
77 4 : itsVal(0) = i;
78 4 : itsVal(1) = q;
79 4 : itsVal(2) = u;
80 4 : itsVal(3) = v;
81 4 : }
82 :
83 : template<class T> FluxRep<T>::
84 : FluxRep(typename casacore::NumericTraits<T>::ConjugateType xx,
85 : typename casacore::NumericTraits<T>::ConjugateType xy,
86 : typename casacore::NumericTraits<T>::ConjugateType yx,
87 : typename casacore::NumericTraits<T>::ConjugateType yy,
88 : ComponentType::Polarisation pol)
89 : :itsVal(4),
90 : itsPol(pol),
91 : itsUnit("Jy"),
92 : itsErr(4, typename casacore::NumericTraits<T>::ConjugateType(0,0))
93 : {
94 : itsVal(0) = xx;
95 : itsVal(1) = xy;
96 : itsVal(2) = yx;
97 : itsVal(3) = yy;
98 : }
99 :
100 2639712 : template<class T> FluxRep<T>::
101 : FluxRep(const casacore::Vector<T>& flux)
102 2639712 : :itsVal(4, typename casacore::NumericTraits<T>::ConjugateType(0,0)),
103 2639712 : itsPol(ComponentType::STOKES),
104 2639712 : itsUnit("Jy"),
105 2639712 : itsErr(4, typename casacore::NumericTraits<T>::ConjugateType(0,0))
106 : {
107 13198560 : for (casacore::uInt i = 0 ; i < 4; i++) {
108 10558848 : itsVal(i) = flux(i);
109 : }
110 2639712 : }
111 :
112 56943 : template<class T> FluxRep<T>::
113 : FluxRep(const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& flux,
114 : ComponentType::Polarisation pol)
115 56943 : :itsVal(flux.copy()),
116 56943 : itsPol(pol),
117 56943 : itsUnit("Jy"),
118 56943 : itsErr(4, typename casacore::NumericTraits<T>::ConjugateType(0,0))
119 : {
120 56943 : }
121 :
122 : template<class T> FluxRep<T>::
123 : FluxRep(const casacore::Quantum<casacore::Vector<T> >& flux)
124 : :itsVal(4, typename casacore::NumericTraits<T>::ConjugateType(0,0)),
125 : itsPol(ComponentType::STOKES),
126 : itsUnit(flux.getFullUnit()),
127 : itsErr(4, typename casacore::NumericTraits<T>::ConjugateType(0,0))
128 : {
129 : const casacore::Vector<T>& fluxVal(flux.getValue());
130 : convertArray(itsVal, fluxVal);
131 : }
132 :
133 : template<class T> FluxRep<T>::
134 : FluxRep(const casacore::Quantum<casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> >& flux,
135 : ComponentType::Polarisation pol)
136 : :itsVal(flux.getValue().copy()),
137 : itsPol(pol),
138 : itsUnit(flux.getFullUnit()),
139 : itsErr(4, typename casacore::NumericTraits<T>::ConjugateType(0,0))
140 : {
141 : }
142 :
143 879 : template<class T> FluxRep<T>::
144 : FluxRep(const FluxRep<T>& other)
145 879 : :itsVal(other.itsVal.copy()),
146 879 : itsPol(other.itsPol),
147 879 : itsUnit(other.itsUnit),
148 879 : itsErr(other.itsErr)
149 : {
150 879 : }
151 :
152 5197609 : template<class T> FluxRep<T>::
153 : ~FluxRep() {
154 5197609 : }
155 :
156 : template<class T> FluxRep<T>& FluxRep<T>::
157 : operator=(const FluxRep<T>& other) {
158 : if (this != &other) {
159 : itsVal = other.itsVal;
160 : itsPol = other.itsPol;
161 : itsUnit = other.itsUnit;
162 : itsErr = other.itsErr;
163 : }
164 : return *this;
165 : }
166 :
167 104799 : template<class T> const casacore::Unit& FluxRep<T>::
168 : unit() const {
169 104799 : return itsUnit;
170 : }
171 :
172 : template<class T> void FluxRep<T>::
173 : unit(casacore::Unit& unit) const {
174 : unit = itsUnit;
175 : }
176 :
177 95484 : template<class T> void FluxRep<T>::
178 : setUnit(const casacore::Unit& unit) {
179 95484 : itsUnit = unit;
180 95484 : }
181 :
182 30276 : template<class T> void FluxRep<T>::
183 : convertUnit(const casacore::Unit& unit) {
184 30276 : if (unit.getName() != itsUnit.getName()) {
185 0 : T factor = itsUnit.getValue().getFac()/unit.getValue().getFac();
186 0 : for (casacore::uInt i = 0; i < 4; i++) {
187 0 : itsVal(i) *= factor;
188 0 : itsErr(i) *= factor;
189 : }
190 0 : itsUnit = unit;
191 : }
192 30276 : }
193 :
194 2715732 : template<class T> ComponentType::Polarisation FluxRep<T>::
195 : pol() const {
196 2715732 : return itsPol;
197 : }
198 :
199 : template<class T> void FluxRep<T>::
200 : pol(ComponentType::Polarisation& pol) const {
201 : pol = itsPol;
202 : }
203 :
204 2753002 : template<class T> void FluxRep<T>::
205 : setPol(ComponentType::Polarisation pol) {
206 2753002 : itsPol = pol;
207 2753002 : }
208 :
209 2729118 : template<class T> void FluxRep<T>::
210 : convertPol(ComponentType::Polarisation pol) {
211 2729118 : if (itsPol != pol) {
212 2714461 : switch (pol){
213 43131 : case ComponentType::STOKES:
214 43131 : if (itsPol == ComponentType::LINEAR) {
215 15437 : Flux<T>::linearToStokes(itsVal, itsVal);
216 : } else {
217 27694 : Flux<T>::circularToStokes(itsVal, itsVal);
218 : }
219 43131 : break;
220 83239 : case ComponentType::LINEAR:
221 83239 : if (itsPol == ComponentType::STOKES) {
222 80748 : Flux<T>::stokesToLinear(itsVal, itsVal);
223 : } else {
224 2491 : Flux<T>::circularToLinear(itsVal, itsVal);
225 : }
226 83239 : break;
227 2588091 : case ComponentType::CIRCULAR:
228 2588091 : if (itsPol == ComponentType::STOKES) {
229 2587694 : Flux<T>::stokesToCircular(itsVal, itsVal);
230 : } else {
231 397 : Flux<T>::linearToCircular(itsVal, itsVal);
232 : }
233 2588091 : break;
234 0 : default:
235 0 : throw(casacore::AipsError("FluxRep<T>::convertPol(...) - bad polarisation type"));
236 : };
237 :
238 2714461 : setPol(pol); // New pol rep label
239 :
240 2714461 : if (!allNearAbs(itsErr, typename casacore::NumericTraits<T>::ConjugateType(0,0),
241 : casacore::C::dbl_epsilon)) {
242 0 : casacore::LogIO logErr(casacore::LogOrigin("FluxRep", "convertPol()"));
243 : logErr << casacore::LogIO::WARN
244 : << "The change in flux representation means the numerical values"
245 : << " have changed" << std::endl
246 : << "But the errors in the flux are not being changed "
247 : << "and are probably now incorrect"
248 0 : << casacore::LogIO::POST;
249 0 : }
250 : }
251 2729118 : }
252 :
253 : template<class T>
254 67433 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& FluxRep<T>::
255 : value() const {
256 67433 : return itsVal;
257 : }
258 :
259 : template<class T>
260 121949900 : const typename casacore::NumericTraits<T>::ConjugateType& FluxRep<T>::
261 : value(casacore::uInt p) const {
262 121949900 : return itsVal(p);
263 : }
264 :
265 54418 : template<class T> void FluxRep<T>::
266 : value(casacore::Vector<T>& value) {
267 54418 : const casacore::uInt len = value.nelements();
268 54418 : if (len == 0) value.resize(4);
269 54418 : convertPol(ComponentType::STOKES);
270 272090 : for (casacore::uInt s = 0 ; s < 4; s++) {
271 217672 : value(s) = itsVal(s).real();
272 : }
273 54418 : }
274 :
275 : template<class T> void FluxRep<T>::
276 : value(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& value) const {
277 : value = itsVal;
278 : }
279 :
280 879 : template<class T> void FluxRep<T>::
281 : value(casacore::Quantum<casacore::Vector<T> >& value) {
282 879 : const casacore::Unit& curUnit = value.getFullUnit();
283 879 : if (curUnit != itsUnit) {
284 879 : value.setUnit(itsUnit);
285 : }
286 879 : convertPol(ComponentType::STOKES);
287 879 : casacore::Vector<T>& newValue = value.getValue();
288 879 : if (newValue.nelements() != 4) newValue.resize(4);
289 4395 : for (casacore::uInt s = 0 ; s < 4; s++) {
290 3516 : newValue(s) = itsVal(s).real();
291 : }
292 879 : }
293 :
294 9344 : template<class T> casacore::Quantum<T> FluxRep<T>::
295 : value (casacore::Stokes::StokesTypes stokes, casacore::Bool toJy)
296 : {
297 18688 : casacore::LogIO os(casacore::LogOrigin("FluxRep", "value(Stokes::StokesTypes)"));
298 :
299 : // Get the vector of values that we are holding
300 :
301 9344 : casacore::Vector<T> values;
302 9344 : value(values);
303 :
304 : // Make a quantum for the result
305 :
306 9344 : casacore::Quantum<T> value;
307 9344 : value.setUnit(unit());
308 :
309 : // Fish it out
310 :
311 9344 : ComponentType::Polarisation cPol = pol();
312 9344 : if ( (stokes==casacore::Stokes::I || stokes==casacore::Stokes::Q ||
313 9344 : stokes==casacore::Stokes::U || stokes==casacore::Stokes::V) &&
314 : cPol==ComponentType::STOKES) {
315 : //
316 9344 : casacore::String error("Failed to extract Flux from SkyComponent because not enough Stokes values");
317 9344 : if (stokes==casacore::Stokes::I) {
318 2336 : if (values.nelements()<1) os << error << casacore::LogIO::EXCEPTION;
319 2336 : value.setValue(values(0));
320 7008 : } else if (stokes==casacore::Stokes::Q) {
321 2336 : if (values.nelements()<2) os << error << casacore::LogIO::EXCEPTION;
322 2336 : value.setValue(values(1));
323 4672 : } else if (stokes==casacore::Stokes::U) {
324 2336 : if (values.nelements()<3) os << error << casacore::LogIO::EXCEPTION;
325 2336 : value.setValue(values(2));
326 2336 : } else if (stokes==casacore::Stokes::V) {
327 2336 : if (values.nelements()<4) os << error << casacore::LogIO::EXCEPTION;
328 2336 : value.setValue(values(3));
329 : }
330 9344 : } else {
331 0 : os << "It is not possible currently to extract the flux value" << std::endl;
332 0 : os << "for Stokes type " << casacore::Stokes::name(stokes) << " from the SkyComponent" << casacore::LogIO::EXCEPTION;
333 : }
334 : //
335 9344 : if (toJy) value.convert(casacore::Unit("Jy"));
336 18688 : return value;
337 9344 : }
338 :
339 397 : template<class T> void FluxRep<T>::
340 : value(casacore::Quantum<casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> >&
341 : value) const {
342 397 : const casacore::Unit& curUnit = value.getFullUnit();
343 397 : if (curUnit != itsUnit) {
344 397 : value.setUnit(itsUnit);
345 : }
346 397 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& newValue = value.getValue();
347 397 : if (newValue.nelements() != 4) newValue.resize(4);
348 1985 : for (casacore::uInt s = 0 ; s < 4; s++) {
349 1588 : newValue(s) = itsVal(s);
350 : }
351 397 : }
352 :
353 0 : template<class T> void FluxRep<T>::
354 : setValue(T value) {
355 0 : for (casacore::uInt i = 0; i < 4; i++) {
356 0 : itsVal(i) = 0.0;
357 : }
358 0 : itsVal(0) = value;
359 0 : itsPol = ComponentType::STOKES;
360 0 : }
361 :
362 2491 : template<class T> void FluxRep<T>::
363 : setValue(const casacore::Vector<T>& value) {
364 12455 : for (casacore::uInt i = 0; i < 4; i++) {
365 9964 : itsVal(i) = value(i);
366 : }
367 2491 : itsPol = ComponentType::STOKES;
368 2491 : }
369 :
370 43523 : template<class T> void FluxRep<T>::
371 : setValue(const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& value) {
372 43523 : itsVal = value;
373 43523 : }
374 :
375 : template<class T> void FluxRep<T>::
376 : setValue(const casacore::Quantum<casacore::Vector<T> >& value) {
377 : const casacore::Vector<T>& val = value.getValue();
378 : for (casacore::uInt s = 0; s < 4; s++) {
379 : itsVal(s) = val(s);
380 : }
381 : itsUnit = value.getFullUnit();
382 : itsPol = ComponentType::STOKES;
383 : }
384 :
385 : template<class T> void FluxRep<T>::
386 : setValue(const
387 : casacore::Quantum<casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> >& value,
388 : ComponentType::Polarisation pol) {
389 : itsVal = value.getValue();
390 : itsUnit = value.getFullUnit();
391 : itsPol = pol;
392 : }
393 :
394 26400 : template<class T> casacore::Unit FluxRep<T>::_getConversionUnit(const casacore::Unit& unit) {
395 26400 : auto iter = _allowedUnits.begin();
396 26400 : auto end = _allowedUnits.end();
397 26400 : for (; iter!=end; ++iter) {
398 26400 : if (unit.getValue() == iter->getValue()) {
399 52800 : return *iter;
400 : }
401 : }
402 0 : std::ostringstream oss;
403 : using casacore::AipsError;
404 0 : ThrowCc(
405 : "The flux unit "
406 : + unit.getName()
407 : + " has dimensions that are not supported"
408 : );
409 0 : }
410 :
411 0 : template<class T> void FluxRep<T>::setValue(
412 : const casacore::Quantum<T>& value, casacore::Stokes::StokesTypes stokes
413 : ) {
414 0 : casacore::LogIO os(casacore::LogOrigin("FluxRep", "setValue(const Quantum<Double>&, Stokes::StokesTypes)"));
415 0 : casacore::Vector<T> tmp(4, 0.0);
416 0 : auto conversionUnit = _getConversionUnit(value.getUnit()) ;
417 0 : if (stokes==casacore::Stokes::I || stokes==casacore::Stokes::Q || stokes==casacore::Stokes::U || stokes==casacore::Stokes::V) {
418 0 : if (stokes==casacore::Stokes::I) {
419 0 : tmp(0) = value.getValue(casacore::Unit(conversionUnit));
420 0 : } else if (stokes==casacore::Stokes::Q) {
421 0 : tmp(1) = value.getValue(casacore::Unit(conversionUnit));
422 0 : } else if (stokes==casacore::Stokes::U) {
423 0 : tmp(2) = value.getValue(casacore::Unit(conversionUnit));
424 0 : } else if (stokes==casacore::Stokes::V) {
425 0 : tmp(3) = value.getValue(casacore::Unit(conversionUnit));
426 : }
427 : }
428 : else {
429 0 : os << casacore::LogIO::WARN << "Can only properly handle I,Q,U,V presently." << std::endl;
430 0 : os << "The brightness is assumed to be Stokes I" << casacore::LogIO::POST;
431 0 : tmp(0) = value.getValue(casacore::Unit("Jy"));
432 : }
433 0 : setValue(tmp);
434 0 : }
435 :
436 0 : template<class T> void FluxRep<T>::
437 : scaleValue(const T& factor) {
438 0 : itsVal(0) *= factor;
439 0 : }
440 :
441 2491 : template<class T> void FluxRep<T>::
442 : scaleValue(const T& factor0, const T& factor1,
443 : const T& factor2, const T& factor3) {
444 2491 : itsVal(0) *= factor0;
445 2491 : itsVal(1) *= factor1;
446 2491 : itsVal(2) *= factor2;
447 2491 : itsVal(3) *= factor3;
448 2491 : }
449 :
450 : template<class T> void FluxRep<T>::
451 : scaleValue(const typename casacore::NumericTraits<T>::ConjugateType& factor) {
452 : itsVal(0) *= factor;
453 : }
454 :
455 : template<class T> void FluxRep<T>::
456 : scaleValue(const typename casacore::NumericTraits<T>::ConjugateType& factor0,
457 : const typename casacore::NumericTraits<T>::ConjugateType& factor1,
458 : const typename casacore::NumericTraits<T>::ConjugateType& factor2,
459 : const typename casacore::NumericTraits<T>::ConjugateType& factor3) {
460 : itsVal(0) *= factor0;
461 : itsVal(1) *= factor1;
462 : itsVal(2) *= factor2;
463 : itsVal(3) *= factor3;
464 : }
465 :
466 38541 : template<class T> void FluxRep<T>::
467 : setErrors(const typename casacore::NumericTraits<T>::ConjugateType& error0,
468 : const typename casacore::NumericTraits<T>::ConjugateType& error1,
469 : const typename casacore::NumericTraits<T>::ConjugateType& error2,
470 : const typename casacore::NumericTraits<T>::ConjugateType& error3) {
471 38541 : itsErr(0) = error0;
472 38541 : itsErr(1) = error1;
473 38541 : itsErr(2) = error2;
474 38541 : itsErr(3) = error3;
475 38541 : }
476 :
477 : template<class T> void FluxRep<T>::setErrors(
478 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& errors
479 : ) {
480 : itsErr = errors;
481 : }
482 :
483 :
484 : template<class T> const
485 1405 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& FluxRep<T>::errors() const {
486 1405 : return itsErr;
487 : }
488 :
489 38383 : template<class T> casacore::Bool FluxRep<T>::
490 : fromRecord(casacore::String& errorMessage, const casacore::RecordInterface& record) {
491 38383 : ComponentType::Polarisation newPol = ComponentType::UNKNOWN_POLARISATION;
492 : {
493 38383 : const casacore::String polarisationString("polarisation");
494 38383 : if (!record.isDefined(polarisationString)) {
495 0 : casacore::LogIO logErr(casacore::LogOrigin("FluxRep", "fromRecord()"));
496 : logErr << casacore::LogIO::WARN
497 : << "The flux does not have a 'polarisation' field." << std::endl
498 : << "Using the default of Stokes"
499 0 : << casacore::LogIO::POST;
500 0 : setPol(ComponentType::STOKES);
501 0 : } else {
502 38383 : const casacore::RecordFieldId polarisation(polarisationString);
503 : // Maybe the polarisation field should contain ["I", "Q", "U", "V"]. This
504 : // is harder to parse but more flexible for the future.
505 38383 : if (record.dataType(polarisation) != casacore::TpString) {
506 0 : errorMessage += "The 'polarisation' field must be a record\n";
507 0 : return false;
508 : }
509 38383 : if (record.shape(polarisation) != casacore::IPosition(1,1)) {
510 0 : errorMessage += "The 'polarisation' field must have only 1 element\n";
511 0 : return false;
512 : }
513 38383 : const casacore::String polVal = record.asString(polarisation);
514 38383 : newPol = ComponentType::polarisation(polVal);
515 38383 : if (newPol == ComponentType::UNKNOWN_POLARISATION) {
516 0 : errorMessage += casacore::String("The polarisation type is not known.\n") +
517 0 : casacore::String("Allowed values are 'Stokes', 'Linear' & 'Circular'\n");
518 0 : return false;
519 : }
520 38383 : }
521 38383 : }
522 38383 : setPol(newPol);
523 : {
524 38383 : casacore::QuantumHolder qh;
525 38383 : if (!qh.fromRecord(errorMessage, record)) {
526 0 : errorMessage += "Could not parse the flux record\n";
527 0 : return false;
528 : }
529 38383 : if (qh.isScalar() && pol() == ComponentType::STOKES) {
530 0 : if (qh.isReal()) {
531 0 : const casacore::Quantum<casacore::Double>& qVal = qh.asQuantumDouble();
532 0 : setValue(qVal.getValue());
533 0 : setUnit(qVal.getFullUnit());
534 : } else {
535 0 : const casacore::Quantum<casacore::DComplex>& qVal = qh.asQuantumDComplex();
536 0 : const casacore::DComplex& val = qVal.getValue();
537 0 : if (! casacore::nearAbs(val.imag(), 0.0, casacore::NumericTraits<T>::minimum)) {
538 0 : errorMessage += "I value cannot be complex\n";
539 0 : return false;
540 : }
541 0 : setValue(T(val.real()));
542 0 : setUnit(qVal.getFullUnit());
543 : }
544 0 : casacore::LogIO logErr(casacore::LogOrigin("FluxRep", "fromRecord()"));
545 : logErr << casacore::LogIO::WARN
546 : << "Only the I flux specified. Assuming Q, U, & V are zero\n"
547 0 : << casacore::LogIO::POST;
548 0 : } else {
549 38383 : if (qh.nelements() != 4u) {
550 0 : errorMessage += casacore::String("Must specify all 4 flux values\n")
551 0 : + casacore::String("if the polarisation representation is not Stokes\n");
552 0 : return false;
553 : }
554 38383 : if (qh.isQuantumVectorDouble()) {
555 25679 : const casacore::Quantum<casacore::Vector<casacore::Double> > qVal = qh.asQuantumVectorDouble();
556 25679 : setUnit(qVal.getFullUnit());
557 25679 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> val(4);
558 25679 : convertArray(val, qVal.getValue());
559 25679 : setValue(val);
560 38383 : } else if (qh.isQuantumVectorDComplex()) {
561 12704 : const casacore::Quantum<casacore::Vector<casacore::DComplex> >& qVal = qh.asQuantumVectorDComplex();
562 12704 : setUnit(qVal.getFullUnit());
563 12704 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> val(4);
564 12704 : convertArray(val, qVal.getValue());
565 12704 : setValue(val);
566 12704 : } else if (qh.isQuantumVectorComplex()) {
567 0 : const casacore::Quantum<casacore::Vector<casacore::Complex> >& qVal = qh.asQuantumVectorComplex();
568 0 : setUnit(qVal.getFullUnit());
569 0 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> val(4);
570 0 : convertArray(val, qVal.getValue());
571 0 : setValue(val);
572 0 : } else if (qh.isQuantumVectorFloat()) {
573 0 : const casacore::Quantum<casacore::Vector<casacore::Float> >& qVal = qh.asQuantumVectorFloat();
574 0 : setUnit(qVal.getFullUnit());
575 0 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> val(4);
576 0 : convertArray(val, qVal.getValue());
577 0 : setValue(val);
578 0 : } else if (qh.isQuantumVectorInt()) {
579 0 : const casacore::Quantum<casacore::Vector<casacore::Int> >& qVal = qh.asQuantumVectorInt();
580 0 : setUnit(qVal.getFullUnit());
581 0 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> val(4);
582 0 : convertArray(val, qVal.getValue());
583 0 : setValue(val);
584 0 : } else {
585 0 : errorMessage += "value field must be a real or complex vector\n";
586 0 : return false;
587 : }
588 : }
589 38383 : }
590 : {
591 38383 : const casacore::String errorString("error");
592 38383 : if (record.isDefined(errorString)) {
593 38383 : const casacore::RecordFieldId error(errorString);
594 38383 : casacore::Vector<casacore::DComplex> err(4, casacore::DComplex(0.0, 0.0));
595 38383 : if (record.shape(error) != casacore::IPosition(1,4)) {
596 0 : errorMessage +=
597 : "The 'error' field must be a vector with 4 elements\n";
598 0 : return false;
599 : }
600 38383 : if (record.dataType(error) == casacore::TpArrayDouble &&
601 : newPol == ComponentType::STOKES) {
602 25679 : convertArray(err, record.asArrayDouble(error));
603 12704 : } else if (record.dataType(error) == casacore::TpArrayDComplex) {
604 12704 : err = record.asArrayDComplex(error);
605 : } else {
606 0 : errorMessage +=
607 : "The 'error' field must be a complex vector with 4 elements\n";
608 0 : return false;
609 : }
610 38383 : setErrors(err(0), err(1), err(2), err(3));
611 38383 : }
612 38383 : }
613 38383 : if (unit() != casacore::Unit("Jy") && unit() != casacore::Unit("K.rad.rad")) {
614 0 : errorMessage += "The dimensions of the units must be same as the Jy\n";
615 0 : return false;
616 : }
617 38383 : if (!ok()) {
618 0 : errorMessage += "Inconsistencies in the FluxRep object\n";
619 0 : return false;
620 : }
621 38383 : return true;
622 : }
623 :
624 1276 : template<class T> casacore::Bool FluxRep<T>::
625 : toRecord(casacore::String& errorMessage, casacore::RecordInterface& record) const {
626 1276 : if (!ok()) {
627 0 : errorMessage += "Inconsistancies in the FluxRep object\n";
628 0 : return false;
629 : }
630 1276 : casacore::QuantumHolder qh;
631 1276 : if (pol() == ComponentType::STOKES) {
632 879 : FluxRep<T> fluxCopy = *this;
633 879 : casacore::Quantum<casacore::Vector<T> > qVal;
634 879 : fluxCopy.value(qVal);
635 879 : qh = casacore::QuantumHolder(qVal);
636 879 : } else {
637 397 : casacore::Quantum<casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> > qVal;
638 397 : value(qVal);
639 397 : qh = casacore::QuantumHolder(qVal);
640 397 : }
641 1276 : if (!qh.toRecord(errorMessage, record)) {
642 0 : errorMessage += "Problem generating the flux record\n";
643 0 : return false;
644 : }
645 1276 : record.define(casacore::RecordFieldId("polarisation"), ComponentType::name(pol()));
646 1276 : if (pol() != ComponentType::STOKES) {
647 397 : record.define(casacore::RecordFieldId("error"), errors());
648 : } else {
649 879 : casacore::Vector<T> realErr(4);
650 879 : real(realErr, errors());
651 879 : record.define(casacore::RecordFieldId("error"), realErr);
652 879 : }
653 1276 : return true;
654 1276 : }
655 :
656 :
657 26400 : template<class T> casacore::Bool FluxRep<T>::ok() const {
658 : // The casacore::LogIO class is only constructed if an Error is detected for
659 : // performance reasons. Both function static and file static variables
660 : // where considered and rejected for this purpose.
661 26400 : if (itsVal.nelements() != 4) {
662 0 : casacore::LogIO logErr(casacore::LogOrigin("FluxRep", "ok()"));
663 : logErr << casacore::LogIO::SEVERE << "The flux does not have 4 elements"
664 : << " (corresponding to four polarisations)"
665 0 : << casacore::LogIO::POST;
666 0 : return false;
667 0 : }
668 26400 : _getConversionUnit(itsUnit);
669 26400 : return true;
670 : }
671 :
672 2611205 : template<class T> Flux<T>::
673 : Flux()
674 2611205 : :itsFluxPtr(new FluxRep<T>)
675 : {
676 2611205 : }
677 :
678 0 : template<class T> Flux<T>::
679 : Flux(T i)
680 0 : :itsFluxPtr(new FluxRep<T>(i))
681 : {
682 0 : }
683 :
684 4 : template<class T> Flux<T>::
685 : Flux(T i, T q, T u, T v)
686 4 : :itsFluxPtr(new FluxRep<T>(i, q, u, v))
687 : {
688 4 : }
689 :
690 : template<class T> Flux<T>::
691 : Flux(typename casacore::NumericTraits<T>::ConjugateType xx,
692 : typename casacore::NumericTraits<T>::ConjugateType xy,
693 : typename casacore::NumericTraits<T>::ConjugateType yx,
694 : typename casacore::NumericTraits<T>::ConjugateType yy,
695 : ComponentType::Polarisation pol)
696 : :itsFluxPtr(new FluxRep<T>(xx, xy, yx, yy, pol))
697 : {
698 : }
699 :
700 2639712 : template<class T> Flux<T>::
701 : Flux(const casacore::Vector<T>& flux)
702 2639712 : :itsFluxPtr(new FluxRep<T>(flux))
703 : {
704 2639712 : }
705 :
706 56943 : template<class T> Flux<T>::
707 : Flux(const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& flux,
708 : ComponentType::Polarisation pol)
709 56943 : :itsFluxPtr(new FluxRep<T>(flux, pol))
710 : {
711 56943 : }
712 :
713 : template<class T> Flux<T>::
714 : Flux(const casacore::Quantum<casacore::Vector<T> >& flux)
715 : :itsFluxPtr(new FluxRep<T>(flux))
716 : {
717 : }
718 :
719 4982 : template<class T> Flux<T>::
720 : Flux(const Flux<T>& other)
721 4982 : :itsFluxPtr(other.itsFluxPtr)
722 : {
723 4982 : }
724 :
725 5324820 : template<class T> Flux<T>::
726 : ~Flux() {
727 5324820 : }
728 :
729 2642207 : template<class T> Flux<T>& Flux<T>::
730 : operator=(const Flux<T>& other) {
731 2642207 : if (this != &other) {
732 2642207 : itsFluxPtr = other.itsFluxPtr;
733 : }
734 2642207 : return *this;
735 : }
736 :
737 56943 : template<class T> Flux<T> Flux<T>::
738 : copy() const {
739 56943 : Flux<T> newFlux(value(), pol());
740 56943 : newFlux.setUnit(unit());
741 56943 : return newFlux;
742 0 : }
743 :
744 57072 : template<class T> const casacore::Unit& Flux<T>::
745 : unit() const {
746 57072 : return itsFluxPtr->unit();
747 : }
748 :
749 : template<class T> void Flux<T>::
750 : unit(casacore::Unit& unit) const {
751 : itsFluxPtr->unit(unit);
752 : }
753 :
754 57101 : template<class T> void Flux<T>::
755 : setUnit(const casacore::Unit& unit) {
756 57101 : itsFluxPtr->setUnit(unit);
757 57101 : }
758 :
759 30276 : template<class T> void Flux<T>::
760 : convertUnit(const casacore::Unit& unit) {
761 30276 : itsFluxPtr->convertUnit(unit);
762 30276 : }
763 :
764 2702560 : template<class T> ComponentType::Polarisation Flux<T>::
765 : pol() const {
766 2702560 : return itsFluxPtr->pol();
767 : }
768 :
769 : template<class T> void Flux<T>::
770 : pol(ComponentType::Polarisation& pol) const {
771 : itsFluxPtr->pol(pol);
772 : }
773 :
774 158 : template<class T> void Flux<T>::
775 : setPol(ComponentType::Polarisation pol) {
776 158 : itsFluxPtr->setPol(pol);
777 158 : }
778 :
779 2673821 : template<class T> void Flux<T>::
780 : convertPol(ComponentType::Polarisation pol) {
781 2673821 : itsFluxPtr->convertPol(pol);
782 2673821 : }
783 :
784 : template<class T> const
785 67433 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& Flux<T>::value() const {
786 67433 : return itsFluxPtr->value();
787 : }
788 :
789 121949900 : template<class T> const typename casacore::NumericTraits<T>::ConjugateType& Flux<T>::
790 : value(casacore::uInt p) const {
791 121949900 : return itsFluxPtr->value(p);
792 : }
793 :
794 45074 : template<class T> void Flux<T>::
795 : value(casacore::Vector<T>& value) {
796 45074 : itsFluxPtr->value(value);
797 45074 : }
798 :
799 : template<class T> void Flux<T>::
800 : value(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& value) const {
801 : itsFluxPtr->value(value);
802 : }
803 :
804 : template<class T> void Flux<T>::
805 : value(casacore::Quantum<casacore::Vector<T> >& value) {
806 : itsFluxPtr->value(value);
807 : }
808 :
809 0 : template<class T> void Flux<T>::
810 : value(casacore::Quantum<casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> >&
811 : value) const {
812 0 : itsFluxPtr->value(value);
813 0 : }
814 :
815 9344 : template<class T> casacore::Quantum<T> Flux<T>::
816 : value (casacore::Stokes::StokesTypes stokes, casacore::Bool toJy)
817 : {
818 9344 : return itsFluxPtr->value(stokes, toJy);
819 : }
820 :
821 :
822 :
823 0 : template<class T> void Flux<T>::
824 : setValue(T value) {
825 0 : itsFluxPtr->setValue(value);
826 0 : }
827 :
828 2491 : template<class T> void Flux<T>::
829 : setValue(const casacore::Vector<T>& value) {
830 2491 : itsFluxPtr->setValue(value);
831 2491 : }
832 :
833 5140 : template<class T> void Flux<T>::
834 : setValue(const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& value) {
835 5140 : itsFluxPtr->setValue(value);
836 5140 : }
837 :
838 : template<class T> void Flux<T>::
839 : setValue(const casacore::Quantum<casacore::Vector<T> >& value) {
840 : itsFluxPtr->setValue(value);
841 : }
842 :
843 : template<class T> void Flux<T>::
844 : setValue(const
845 : casacore::Quantum<casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType> >& value,
846 : ComponentType::Polarisation pol) {
847 : itsFluxPtr->setValue(value, pol);
848 : }
849 :
850 0 : template<class T> void Flux<T>::
851 : setValue(const casacore::Quantum<T>& value, casacore::Stokes::StokesTypes stokes)
852 : {
853 0 : itsFluxPtr->setValue(value, stokes);
854 0 : }
855 :
856 0 : template<class T> void Flux<T>::
857 : scaleValue(const T& factor) {
858 0 : itsFluxPtr->scaleValue(factor);
859 0 : }
860 :
861 2491 : template<class T> void Flux<T>::
862 : scaleValue(const T& factor0, const T& factor1,
863 : const T& factor2, const T& factor3) {
864 2491 : itsFluxPtr->scaleValue(factor0, factor1, factor2, factor3);
865 2491 : }
866 :
867 : template<class T> void Flux<T>::
868 : scaleValue(const typename casacore::NumericTraits<T>::ConjugateType& factor) {
869 : itsFluxPtr->scaleValue(factor);
870 : }
871 :
872 : template<class T> void Flux<T>::
873 : scaleValue(const typename casacore::NumericTraits<T>::ConjugateType& factor0,
874 : const typename casacore::NumericTraits<T>::ConjugateType& factor1,
875 : const typename casacore::NumericTraits<T>::ConjugateType& factor2,
876 : const typename casacore::NumericTraits<T>::ConjugateType& factor3) {
877 : itsFluxPtr->scaleValue(factor0, factor1, factor2, factor3);
878 : }
879 :
880 158 : template<class T> void Flux<T>::
881 : setErrors(const typename casacore::NumericTraits<T>::ConjugateType& error0,
882 : const typename casacore::NumericTraits<T>::ConjugateType& error1,
883 : const typename casacore::NumericTraits<T>::ConjugateType& error2,
884 : const typename casacore::NumericTraits<T>::ConjugateType& error3) {
885 158 : itsFluxPtr->setErrors(error0, error1, error2, error3);
886 158 : }
887 :
888 : template<class T> void Flux<T>::setErrors(
889 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& errors
890 : ) {
891 : itsFluxPtr->setErrors(errors);
892 : }
893 :
894 :
895 : template<class T> const
896 129 : casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& Flux<T>::errors() const {
897 129 : return itsFluxPtr->errors();
898 : }
899 :
900 38383 : template<class T> casacore::Bool Flux<T>::
901 : fromRecord(casacore::String& errorMessage, const casacore::RecordInterface& record) {
902 38383 : return itsFluxPtr->fromRecord(errorMessage, record);
903 : }
904 :
905 1276 : template<class T> casacore::Bool Flux<T>::
906 : toRecord(casacore::String& errorMessage, casacore::RecordInterface& record) const {
907 1276 : return itsFluxPtr->toRecord(errorMessage, record);
908 : }
909 :
910 : template<class T> casacore::Bool Flux<T>::
911 : ok() const {
912 : if (itsFluxPtr.null() == true) {
913 : casacore::LogIO logErr(casacore::LogOrigin("Flux", "ok()"));
914 : logErr << casacore::LogIO::SEVERE << "Internal pointer is not pointing to anything"
915 : << casacore::LogIO::POST;
916 : return false;
917 : }
918 : if (itsFluxPtr->ok() == false) {
919 : casacore::LogIO logErr(casacore::LogOrigin("Flux", "ok()"));
920 : logErr << casacore::LogIO::SEVERE << "Flux representation is not ok"
921 : << casacore::LogIO::POST;
922 : return false;
923 : }
924 : return true;
925 : }
926 :
927 : template<class T> void Flux<T>::
928 : stokesToCircular(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& out,
929 : const casacore::Vector<T>& in) {
930 : const T i = in(0);
931 : const T q = in(1);
932 : const T u = in(2);
933 : const T v = in(3);
934 : out(0) = typename casacore::NumericTraits<T>::ConjugateType(i + v);
935 : out(1) = typename casacore::NumericTraits<T>::ConjugateType(q, u);
936 : out(2) = typename casacore::NumericTraits<T>::ConjugateType(q, -u);
937 : out(3) = typename casacore::NumericTraits<T>::ConjugateType(i - v);
938 : }
939 :
940 2587694 : template<class T> void Flux<T>::
941 : stokesToCircular(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& out,
942 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& in) {
943 2587694 : const typename casacore::NumericTraits<T>::ConjugateType i = in(0);
944 2587694 : const typename casacore::NumericTraits<T>::ConjugateType q = in(1);
945 2587694 : const typename casacore::NumericTraits<T>::ConjugateType& u = in(2);
946 2587694 : const typename casacore::NumericTraits<T>::ConjugateType ju(-u.imag(), u.real());
947 2587694 : const typename casacore::NumericTraits<T>::ConjugateType v = in(3);
948 2587694 : out(0) = i + v;
949 2587694 : out(1) = q + ju;
950 2587694 : out(2) = q - ju;
951 2587694 : out(3) = i - v;
952 2587694 : }
953 :
954 : template<class T> void Flux<T>::
955 : circularToStokes(casacore::Vector<T>& out,
956 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& in) {
957 : const T rr = in(0).real();
958 : const typename casacore::NumericTraits<T>::ConjugateType rl = in(1);
959 : const typename casacore::NumericTraits<T>::ConjugateType lr = in(2);
960 : const T ll = in(3).real();
961 : const T two(2);
962 : out(0) = (rr + ll)/two;
963 : out(1) = (rl.real() + lr.real())/two;
964 : out(2) = (rl.imag() - lr.imag())/two;
965 : out(3) = (rr - ll)/two;
966 : }
967 :
968 25600 : template<class T> void Flux<T>::
969 : circularToStokes(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& out,
970 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& in) {
971 25600 : const typename casacore::NumericTraits<T>::ConjugateType rr = in(0);
972 25600 : const typename casacore::NumericTraits<T>::ConjugateType rl = in(1);
973 25600 : const typename casacore::NumericTraits<T>::ConjugateType lr = in(2);
974 25600 : const typename casacore::NumericTraits<T>::ConjugateType ll = in(3);
975 25600 : const T two(2);
976 25600 : out(0) = (rr + ll)/two;
977 25600 : out(1) = (rl + lr)/two;
978 25600 : out(2) = typename casacore::NumericTraits<T>::ConjugateType((rl.imag()-lr.imag())/two,
979 25600 : (lr.real()-rl.real())/two);
980 25600 : out(3) = (rr - ll)/two;
981 25600 : }
982 :
983 : template<class T> void Flux<T>::
984 : stokesToLinear(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& out,
985 : const casacore::Vector<T>& in) {
986 : const T i = in(0);
987 : const T q = in(1);
988 : const T u = in(2);
989 : const T v = in(3);
990 : out(0) = typename casacore::NumericTraits<T>::ConjugateType(i + q);
991 : out(1) = typename casacore::NumericTraits<T>::ConjugateType(u, v);
992 : out(2) = typename casacore::NumericTraits<T>::ConjugateType(u, -v);
993 : out(3) = typename casacore::NumericTraits<T>::ConjugateType(i - q);
994 : }
995 :
996 80748 : template<class T> void Flux<T>::
997 : stokesToLinear(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& out,
998 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& in) {
999 80748 : const typename casacore::NumericTraits<T>::ConjugateType i = in(0);
1000 80748 : const typename casacore::NumericTraits<T>::ConjugateType q = in(1);
1001 80748 : const typename casacore::NumericTraits<T>::ConjugateType u = in(2);
1002 80748 : const typename casacore::NumericTraits<T>::ConjugateType& v = in(3);
1003 80748 : const typename casacore::NumericTraits<T>::ConjugateType jv(-v.imag(), v.real());
1004 80748 : out(0) = i + q;
1005 80748 : out(1) = u + jv;
1006 80748 : out(2) = u - jv;
1007 80748 : out(3) = i - q;
1008 80748 : }
1009 :
1010 : template<class T> void Flux<T>::
1011 : linearToStokes(casacore::Vector<T>& out,
1012 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& in) {
1013 : const T xx = in(0).real();
1014 : const typename casacore::NumericTraits<T>::ConjugateType xy = in(1);
1015 : const typename casacore::NumericTraits<T>::ConjugateType yx = in(2);
1016 : const T yy = in(3).real();
1017 : const T two(2);
1018 : out(0) = (xx + yy)/two;
1019 : out(1) = (xx - yy)/two;
1020 : out(2) = (xy.real() + xy.real())/two;
1021 : out(3) = (xy.imag() - yx.imag())/two;
1022 : }
1023 :
1024 0 : template<class T> void Flux<T>::
1025 : linearToStokes(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& out,
1026 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& in) {
1027 0 : const typename casacore::NumericTraits<T>::ConjugateType xx = in(0);
1028 0 : const typename casacore::NumericTraits<T>::ConjugateType xy = in(1);
1029 0 : const typename casacore::NumericTraits<T>::ConjugateType yx = in(2);
1030 0 : const typename casacore::NumericTraits<T>::ConjugateType yy = in(3);
1031 0 : const T two(2);
1032 0 : out(0) = (xx + yy)/two;
1033 0 : out(1) = (xx - yy)/two;
1034 0 : out(2) = (xy + yx)/two;
1035 0 : out(3) = typename casacore::NumericTraits<T>::ConjugateType((xy.imag()-yx.imag())/two,
1036 0 : (yx.real()-xy.real())/two);
1037 0 : }
1038 :
1039 397 : template<class T> void Flux<T>::
1040 : linearToCircular(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& out,
1041 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& in) {
1042 397 : const typename casacore::NumericTraits<T>::ConjugateType xx = in(0);
1043 397 : const typename casacore::NumericTraits<T>::ConjugateType& xy = in(1);
1044 397 : const typename casacore::NumericTraits<T>::ConjugateType jxy(-xy.imag(), xy.real());
1045 397 : const typename casacore::NumericTraits<T>::ConjugateType& yx = in(2);
1046 397 : const typename casacore::NumericTraits<T>::ConjugateType jyx(-yx.imag(), yx.real());
1047 397 : const typename casacore::NumericTraits<T>::ConjugateType yy = in(3);
1048 397 : const T two(2);
1049 397 : out(0) = (xx - jxy + jyx + yy)/two;
1050 397 : out(1) = (xx + jxy + jyx - yy)/two;
1051 397 : out(2) = (xx - jxy - jyx - yy)/two;
1052 397 : out(3) = (xx + jxy - jyx + yy)/two;
1053 397 : }
1054 :
1055 2491 : template<class T> void Flux<T>::
1056 : circularToLinear(casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& out,
1057 : const casacore::Vector<typename casacore::NumericTraits<T>::ConjugateType>& in) {
1058 2491 : const typename casacore::NumericTraits<T>::ConjugateType rr = in(0);
1059 2491 : const typename casacore::NumericTraits<T>::ConjugateType rl = in(1);
1060 2491 : const typename casacore::NumericTraits<T>::ConjugateType lr = in(2);
1061 2491 : const typename casacore::NumericTraits<T>::ConjugateType ll = in(3);
1062 2491 : const T two(2);
1063 2491 : out(0) = (rr + rl + lr + ll)/two;
1064 2491 : out(1) = typename casacore::NumericTraits<T>::ConjugateType(
1065 2491 : (-rr.imag() + rl.imag() - lr.imag() + ll.imag())/two,
1066 2491 : ( rr.real() - rl.real() + lr.real() - ll.real())/two);
1067 2491 : out(2) = typename casacore::NumericTraits<T>::ConjugateType(
1068 2491 : ( rr.imag() + rl.imag() - lr.imag() - ll.imag())/two,
1069 2491 : (-rr.real() - rl.real() + lr.real() + ll.real())/two);
1070 2491 : out(3) = (rr - rl - lr + ll)/two;
1071 2491 : }
1072 : // Local Variables:
1073 : // compile-command: "gmake Flux"
1074 : // End:
1075 :
1076 : } //# NAMESPACE CASA - END
1077 :
|
