Line data Source code
1 :
2 : #include <msvis/MSVis/VisibilityIterator2.h>
3 : #include <msvis/MSVis/ViImplementation2.h>
4 : #include <msvis/MSVis/VisBufferImpl2.h>
5 : #include <casacore/measures/Measures/MDirection.h>
6 : #include <casacore/measures/Measures/MEpoch.h>
7 : #include <casacore/casa/Quanta/MVTime.h>
8 : #include <casacore/ms/MSOper/MSDerivedValues.h>
9 : #include <casacore/casa/Arrays.h>
10 :
11 : #include <algorithm>
12 : using namespace std;
13 :
14 : using namespace casacore;
15 : namespace casa {
16 :
17 : namespace vi {
18 :
19 : // #pragma message "Change to pure abstract method before checkin."
20 : // Vector<MPosition>
21 : // ViImplementation2::antennaPositions () const
22 : // {
23 : // return Vector<MPosition> ();
24 : // }
25 :
26 :
27 : VisBuffer2 *
28 6308 : ViImplementation2::createAttachedVisBuffer(VisBufferOptions options)
29 : {
30 6308 : return new VisBufferImpl2(this, options);
31 : }
32 :
33 : VisBuffer2 *
34 1725308 : ViImplementation2::getVisBuffer(const VisibilityIterator2 * vi) const
35 : {
36 1725308 : VisBuffer2 *result = getVisBuffer();
37 1725308 : ThrowIf(result == nullptr, "VI Implementation has no VisBuffer.");
38 1725308 : result->associateWithVi2(vi);
39 1725308 : return result;
40 : }
41 :
42 : void
43 0 : ViImplementation2::azel0Calculate (Double time, MSDerivedValues & msd,
44 : MDirection & azel0, const MEpoch & mEpoch0)
45 : {
46 : // Refactored into a static method to allow VisBufferAsync to use
47 :
48 0 : MEpoch mEpoch = mEpoch0;
49 :
50 0 : mEpoch.set (MVEpoch (Quantity (time, "s")));
51 :
52 0 : msd.setEpoch (mEpoch);
53 :
54 0 : msd.setAntenna (-1);
55 :
56 0 : azel0 = msd.azel ();
57 :
58 0 : if (aips_debug) {
59 0 : cout << "At time: " << MVTime (mEpoch.getValue ()) <<
60 0 : " AzEl = " << azel0.getAngle ("deg") << endl;
61 : }
62 0 : }
63 :
64 : void
65 1131 : ViImplementation2::azelCalculate (Double time, MSDerivedValues & msd, Vector<MDirection> & azel,
66 : Int nAnt, const MEpoch & mEpoch0)
67 : {
68 : // Refactored into a static method to allow VisBufferAsync to use
69 :
70 2262 : MEpoch mEpoch = mEpoch0;
71 :
72 1131 : mEpoch.set (MVEpoch (Quantity (time, "s")));
73 :
74 1131 : msd.setEpoch (mEpoch);
75 :
76 : // Calculate az/el for all antennas.
77 :
78 1131 : azel.resize (nAnt);
79 :
80 20748 : for (Int iant = 0; iant < nAnt; iant++) {
81 :
82 19617 : msd.setAntenna (iant);
83 19617 : azel (iant) = msd.azel ();
84 :
85 19617 : if (aips_debug) {
86 :
87 0 : if (iant == 0){
88 0 : cout << "Antenna " << iant << " at time: " << MVTime (mEpoch.getValue ()) <<
89 0 : " has AzEl = " << azel (iant).getAngle ("deg") << endl;
90 : }
91 : }
92 : }
93 1131 : }
94 :
95 :
96 : Vector<Float>
97 97333 : ViImplementation2::feed_paCalculate (Double time, MSDerivedValues & msd,
98 : Int nAntennas, const MEpoch & mEpoch0,
99 : const Vector<Float> & receptor0Angle)
100 : {
101 194666 : MEpoch mEpoch = mEpoch0;
102 :
103 97333 : mEpoch.set (MVEpoch (Quantity (time, "s")));
104 :
105 97333 : msd.setEpoch (mEpoch);
106 :
107 : // Calculate pa for all antennas.
108 :
109 97333 : Vector<Float> feedpa (nAntennas);
110 :
111 1262454 : for (Int iant = 0; iant < nAntennas; iant++) {
112 :
113 1165121 : msd.setAntenna (iant);
114 1165121 : feedpa (iant) = msd.parAngle ();
115 :
116 : // add angle for receptor 0
117 :
118 1165121 : feedpa (iant) += receptor0Angle (iant);
119 :
120 1165121 : if (aips_debug && iant == 0) {
121 :
122 0 : cout << "Antenna " << iant << " at time: " << MVTime (mEpoch.getValue ()) <<
123 0 : " has PA = " << feedpa (iant) * 57.28 << endl;
124 : }
125 : }
126 :
127 194666 : return feedpa;
128 : }
129 :
130 : // MSDerivedValues
131 : // ViImplementation2::makeMsd ()
132 : // {
133 : // MSDerivedValues result;
134 :
135 : // result.setAntennaPositions (antennaPositions());
136 : // result.setAntennaMount (antennaMounts());
137 : // result.setFieldCenter (phaseCenter());
138 :
139 : // return result;
140 : // }
141 :
142 :
143 : Double
144 0 : ViImplementation2::hourangCalculate (Double time, MSDerivedValues & msd, const MEpoch & mEpoch0)
145 : {
146 0 : MEpoch mEpoch = mEpoch0;
147 :
148 0 : mEpoch.set (MVEpoch (Quantity (time, "s")));
149 :
150 0 : msd.setEpoch (mEpoch);
151 :
152 0 : msd.setAntenna (-1);
153 :
154 0 : Double hourang = msd.hourAngle ();
155 :
156 0 : return hourang;
157 : }
158 :
159 : Float
160 0 : ViImplementation2::parang0Calculate (Double time, MSDerivedValues & msd, const MEpoch & mEpoch0)
161 : {
162 0 : MEpoch mEpoch = mEpoch0;
163 :
164 0 : mEpoch.set (MVEpoch (Quantity (time, "s")));
165 0 : msd.setEpoch (mEpoch);
166 :
167 : // Calculate pa for all antennas.
168 0 : msd.setAntenna (-1);
169 0 : Float parang0 = msd.parAngle ();
170 :
171 0 : if (aips_debug)
172 0 : cout << "At time: " << MVTime (mEpoch.getValue ()) <<
173 0 : " PA = " << parang0 * 57.28 << " deg" << endl;
174 :
175 0 : return parang0;
176 : }
177 :
178 : Vector<Float>
179 0 : ViImplementation2::parangCalculate (Double time, MSDerivedValues & msd, int nAntennas, const MEpoch mEpoch0)
180 : {
181 0 : MEpoch mEpoch = mEpoch0;
182 0 : mEpoch.set (MVEpoch (Quantity (time, "s")));
183 :
184 0 : msd.setEpoch (mEpoch);
185 :
186 : // Calculate pa for all antennas.
187 :
188 0 : Vector<Float> parang (nAntennas);
189 :
190 0 : for (Int iant = 0; iant < nAntennas; iant++) {
191 :
192 0 : msd.setAntenna (iant);
193 0 : parang (iant) = msd.parAngle ();
194 :
195 0 : if (aips_debug && iant == 0) {
196 0 : cout << "Antenna " << iant << " at time: " << MVTime (mEpoch.getValue ()) <<
197 0 : " has PA = " << parang (iant) * 57.28 << endl;
198 : }
199 : }
200 :
201 0 : return parang;
202 : }
203 :
204 : void
205 0 : ViImplementation2::doWeightScaling (Bool hasWeightScaling,
206 : WeightScaling * scaling,
207 : const Array<Float>& unscaled,
208 : Array<Float>& scaled)
209 : {
210 0 : if (hasWeightScaling){
211 :
212 : // Apply the scaling function to each of the weights.
213 :
214 0 : scaled.resize (unscaled.shape());
215 :
216 : std::transform <Array<Float>::const_contiter,
217 : Array<Float>::contiter,
218 : WeightScaling &>
219 0 : (unscaled.cbegin(), unscaled.cend(), scaled.cbegin(), * scaling);
220 :
221 : }
222 : else{
223 :
224 : // No scaling function so simply copy raw weights to scaled.
225 :
226 0 : scaled.assign (unscaled);
227 : }
228 0 : }
229 :
230 : // void
231 : // ViImplementation2::setVisBufferFillable (VisBuffer2 * vb, Bool fillable)
232 : // {
233 : // // Method to allow access to protected method of VB2
234 :
235 : // vb->setFillable (fillable);
236 : // }
237 :
238 : // pair<bool, casacore::MDirection>
239 : // ViImplementation2::getPointingAngle (int antenna, double time) const
240 : // {
241 : // throw AipsError ("Not implemented");
242 : // }
243 :
244 : } // end namespace vi
245 :
246 : using namespace casacore;
247 : } // end namespace casa
|