1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
#ifndef MODEL_MEASUREMENT_H
#define MODEL_MEASUREMENT_H
// #define EXTRA_ASSERTIONS 1
#include <cstring>
#include <array>
#include <aocommon/polarization.h>
namespace wsclean {
class Measurement {
public:
Measurement()
: _frequencyHz(0.0),
_bandWidthHz(0.0),
_fluxDensities{},
_fluxDensityStddevs{} {}
void operator+=(const Measurement &rhs) {
for (size_t p = 0; p != 4; ++p) {
_fluxDensities[p] += rhs._fluxDensities[p];
}
}
void AverageWidth(const Measurement &rhs) {
for (size_t p = 0; p != 4; ++p) {
_fluxDensities[p] = (_fluxDensities[p] + rhs._fluxDensities[p]) * 0.5;
}
}
void AverageWidth(const Measurement &rhs, double weight) {
for (size_t p = 0; p != 4; ++p) {
_fluxDensities[p] =
(_fluxDensities[p] * (1.0 - weight) + rhs._fluxDensities[p] * weight);
}
}
long double FrequencyHz() const { return _frequencyHz; }
void SetFrequencyHz(long double frequencyHz) { _frequencyHz = frequencyHz; }
long double FluxDensity(aocommon::PolarizationEnum polarization) const {
#ifdef EXTRA_ASSERTIONS
if (!aocommon::Polarization::IsStokes(polarization))
throw std::runtime_error("Cannot store specified polarization in model");
#endif
return _fluxDensities[aocommon::Polarization::StokesToIndex(polarization)];
}
long double FluxDensityFromIndex(size_t polarizationIndex) const {
return _fluxDensities[polarizationIndex];
}
void SetFluxDensityFromIndex(size_t polarizationIndex, long double flux) {
_fluxDensities[polarizationIndex] = flux;
}
void SetFluxDensity(aocommon::PolarizationEnum polarization,
long double flux) {
_fluxDensities[aocommon::Polarization::StokesToIndex(polarization)] = flux;
}
void SetZeroExceptSinglePol(aocommon::PolarizationEnum polarization,
long double flux) {
_fluxDensities.fill(0.0);
_fluxDensities[aocommon::Polarization::StokesToIndex(polarization)] = flux;
#ifdef EXTRA_ASSERTIONS
if (!aocommon::Polarization::IsStokes(polarization))
throw std::runtime_error("Cannot store specified polarization in model");
#endif
}
void SetFluxDensityStddevFromIndex(size_t polarizationIndex,
long double stddev) {
_fluxDensityStddevs[polarizationIndex] = stddev;
}
void SetFluxDensityStddev(aocommon::PolarizationEnum polarization,
long double stddev) {
_fluxDensityStddevs[aocommon::Polarization::StokesToIndex(polarization)] =
stddev;
#ifdef EXTRA_ASSERTIONS
if (!aocommon::Polarization::IsStokes(polarization))
throw std::runtime_error("Cannot store specified polarization in model");
#endif
}
void SetBandWidthHz(double bandwidthHz) { _bandWidthHz = bandwidthHz; }
void ToStream(std::ostream &s) const {
s << " measurement {\n"
" frequency "
<< (_frequencyHz / 1000000.0)
<< " MHz\n"
" fluxdensity Jy "
<< _fluxDensities[0] << ' ' << _fluxDensities[1] << ' '
<< _fluxDensities[2] << ' ' << _fluxDensities[3] << '\n';
if (_bandWidthHz > 0.0) s << " bandwidth " << _bandWidthHz << " Hz\n";
s << " }\n";
}
private:
double _frequencyHz;
double _bandWidthHz;
std::array<long double, 4> _fluxDensities;
std::array<long double, 4> _fluxDensityStddevs;
};
} // namespace wsclean
#endif
|
