Line data Source code
1 : #ifndef _ATM_SKYSTATUS_H
2 : #define _ATM_SKYSTATUS_H
3 : /*******************************************************************************
4 : * ALMA - Atacama Large Millimiter Array
5 : * (c) Instituto de Estructura de la Materia, 2009
6 : *
7 : * This library is free software; you can redistribute it and/or
8 : * modify it under the terms of the GNU Lesser General Public
9 : * License as published by the Free Software Foundation; either
10 : * version 2.1 of the License, or (at your option) any later version.
11 : *
12 : * This library is distributed in the hope that it will be useful,
13 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : * Lesser General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU Lesser General Public
18 : * License along with this library; if not, write to the Free Software
19 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 : *
21 : * "@(#) $Id: ATMSkyStatus.h Exp $"
22 : *
23 : * who when what
24 : * -------- -------- ----------------------------------------------
25 : * pardo 24/03/09 created
26 : */
27 :
28 : #ifndef __cplusplus
29 : #error This is a C++ include file and cannot be used from plain C
30 : #endif
31 :
32 : #include "ATMCommon.h"
33 : #include "ATMRefractiveIndexProfile.h"
34 : #include "ATMWaterVaporRadiometer.h"
35 : #include "ATMWVRMeasurement.h"
36 :
37 : //#include <math.h>
38 : #include <string>
39 : #include <vector>
40 :
41 : using std::string;
42 : using std::vector;
43 :
44 : ATM_NAMESPACE_BEGIN
45 :
46 : /*! \brief From the layerThickness and layerTemperature arrays (from AtmProfile),
47 : * the RefractiveIndexProfile array, and a brightness temperature measured to
48 : * the sky at the corresponding frequency, this Class retrieves the water vapor
49 : * column that corresponds to the measurement.
50 : *
51 : * The strating point will therefore be an RefractiveIndexProfile object form
52 : * which the essential information will be inherited: layerThickness,
53 : * layerTemperature vectors (these two inherited themselves from AtmProfile),
54 : * and absTotalDry and absTotalWet arrays. The numerical methods
55 : * will be an iteration wh2o to match the measured brightness temperature
56 : */
57 : class SkyStatus: public RefractiveIndexProfile
58 : {
59 : public:
60 :
61 : //@{
62 :
63 : /** The basic constructor. It will allow to perform forward radiative transfer enquires in
64 : * the spectral bands of refractiveIndexProfile, and to use some of these bands for water vapor retrievals.
65 : * The basic constructor needs at least an RefractiveIndexProfile object (it brings the spectral information via the
66 : * SpectralGrid object inherited by it). Additional inputs can be the
67 : * Air mass (default 1.0), sky background temperature (default 2.73 K), and user water vapor column (default 1 mm).
68 : * Methods inside the class allow to retrieve the water vapor column and eventually update the user value to the retrieved one.
69 : * In order to perform such retrievals, the numerical methods will need as inputs the measured T_EBBs towards the sky in
70 : * some spectral bands that will be designed as water vapor radiometry channels. The sideband gains and coupling to the sky
71 : * of these vapor radiometry channels should also be inputs of the retrieval methods, otherwise they will be set to default
72 : * values. See documentation ef particular methods for more information.
73 : */
74 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile);
75 : /** Class constructor with additional inputs */
76 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
77 : double airMass);
78 : /** Class constructor with additional inputs */
79 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
80 : const Temperature &temperatureBackground);
81 : /** Class constructor with additional inputs */
82 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
83 : const Length &wh2o);
84 : /** Class constructor with additional inputs */
85 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
86 : const Temperature &temperatureBackground,
87 : double airMass);
88 : /** Class constructor with additional inputs */
89 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
90 : double airMass,
91 : const Temperature &temperatureBackground);
92 : /** Class constructor with additional inputs */
93 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
94 : const Length &wh2o,
95 : double airMass);
96 : /** Class constructor with additional inputs */
97 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
98 : double airMass,
99 : const Length &wh2o);
100 : /** Class constructor with additional inputs */
101 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
102 : const Length &wh2o,
103 : const Temperature &temperatureBackground);
104 : /** Class constructor with additional inputs */
105 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
106 : const Temperature &temperatureBackground,
107 : const Length &wh2o);
108 : /** Class constructor with additional inputs */
109 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
110 : const Temperature &temperatureBackground,
111 : double airMass,
112 : const Length &wh2o);
113 : /** Class constructor with additional inputs */
114 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
115 : const Temperature &temperatureBackground,
116 : const Length &wh2o,
117 : double airMass);
118 : /** Class constructor with additional inputs */
119 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
120 : double airMass,
121 : const Temperature &temperatureBackground,
122 : const Length &wh2o);
123 : /** Class constructor with additional inputs */
124 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
125 : double airMass,
126 : const Length &wh2o,
127 : const Temperature &temperatureBackground);
128 : /** Class constructor with additional inputs */
129 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
130 : const Length &wh2o,
131 : const Temperature &temperatureBackground,
132 : double airMass);
133 : /** Class constructor with additional inputs */
134 : SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
135 : const Length &wh2o,
136 : double airMass,
137 : const Temperature &temperatureBackground);
138 :
139 : /** A copy constructor for deep copy */
140 : SkyStatus(const SkyStatus &);
141 :
142 : virtual ~SkyStatus();
143 :
144 : //@}
145 :
146 : //@{
147 :
148 :
149 : /** Accessor to get the user water vapor column. This is the water vapor column used for forward
150 : radiative transfer calculations. It can be equal to wh2o_retrieved_ when this one is avalilable
151 : and the proper setter or update accessor (retrieveandupdateWaterVapor) has been used. */
152 11365 : Length getUserWH2O() const { return wh2o_user_; }
153 : /** Setter for user zenith water vapor column for forward radiative transfer calculations. The user
154 : zenith water vapor column equals the retrieved zenith water vapor column from H2O radiometers,
155 : every time the last one is derived with the retrieveandupdateWaterVapor accessor.*/
156 1 : void setUserWH2O(const Length &wh2o)
157 : {
158 1 : if(wh2o.get() == wh2o_user_.get()) {
159 : } else {
160 1 : wh2o_user_ = wh2o;
161 : }
162 1 : }
163 : /** Alternative form of the setter for user zenith water vapor column for forward radiative transfer calculations. The user
164 : zenith water vapor column equals the retrieved zenith water vapor column from H2O radiometers,
165 : every time the last one is derived with the retrieveandupdateWaterVapor accessor.*/
166 1 : void setUserWH2O(double dwh2o, const string &units)
167 : {
168 1 : Length wh2o(dwh2o, units);
169 1 : if(wh2o.get() == wh2o_user_.get()) {
170 : } else {
171 1 : wh2o_user_ = wh2o;
172 : }
173 1 : }
174 : /** Accessor to get airmass */
175 99 : double getAirMass() const { return airMass_; }
176 : /** Setter for air mass in SkyStatus without performing water vapor retrieval */
177 2 : void setAirMass(double airMass)
178 : {
179 2 : if(airMass == airMass_) {
180 : } else {
181 0 : airMass_ = airMass;
182 : }
183 2 : }
184 : /** Accessor to get sky background temperature */
185 : Temperature getSkyBackgroundTemperature() const { return skyBackgroundTemperature_; }
186 : /** Setter for sky background temperature in SkyStatus without
187 : performing water vapor retrieval */
188 : void setSkyBackgroundTemperature(const Temperature &skyBackgroundTemperature)
189 : {
190 : if(skyBackgroundTemperature.get(Temperature::UnitKelvin) == skyBackgroundTemperature_.get(Temperature::UnitKelvin)) {
191 : } else {
192 : skyBackgroundTemperature_
193 : = Temperature(skyBackgroundTemperature.get(Temperature::UnitKelvin), Temperature::UnitKelvin);
194 : }
195 : }
196 :
197 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window 0, for the current conditions
198 : and a perfect sky coupling */
199 : Temperature getAverageTebbSky()
200 : {
201 : unsigned int n = 0;
202 : return getAverageTebbSky(n);
203 : }
204 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window spwid, for the current conditions
205 : and a perfect sky coupling */
206 : Temperature getAverageTebbSky(unsigned int spwid)
207 : {
208 : return getAverageTebbSky(spwid,
209 : getUserWH2O(),
210 : getAirMass(),
211 : 1.0,
212 : getGroundTemperature());
213 : }
214 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window 0, for the current
215 : conditions, except water column wh2o, and a perfect sky coupling */
216 : Temperature getAverageTebbSky(const Length &wh2o) { return getAverageTebbSky(0, wh2o); }
217 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window spwid, for the current
218 : conditions, except water column wh2o, and a perfect sky coupling */
219 : Temperature getAverageTebbSky(unsigned int spwid, const Length &wh2o)
220 : {
221 : return getAverageTebbSky(spwid,
222 : wh2o,
223 : getAirMass(),
224 : 1.0,
225 : getGroundTemperature());
226 : }
227 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window 0, for the current
228 : conditions, except Air Mass airmass, and a perfect sky coupling */
229 : Temperature getAverageTebbSky(double airmass) { return getAverageTebbSky(0, airmass); }
230 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window spwid, for the current
231 : conditions, except Air Mass airmass, and a perfect sky coupling */
232 : Temperature getAverageTebbSky(unsigned int spwid, double airmass)
233 : {
234 : return getAverageTebbSky(spwid,
235 : getUserWH2O(),
236 : airmass,
237 : 1.0,
238 : getGroundTemperature());
239 : }
240 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window 0, for the current
241 : conditions, except water column wh2o, introducing a Sky Coupling and Spill Over Temperature */
242 : Temperature getAverageTebbSky(const Length &wh2o,
243 : double skycoupling,
244 : const Temperature &Tspill)
245 : {
246 : return getAverageTebbSky(0, wh2o, skycoupling, Tspill);
247 : }
248 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window spwid, for the current
249 : conditions, except water column wh2o, introducing a Sky Coupling and Spill Over Temperature */
250 : Temperature getAverageTebbSky(unsigned int spwid,
251 : const Length &wh2o,
252 : double skycoupling,
253 : const Temperature &Tspill)
254 : {
255 : return getAverageTebbSky(spwid, wh2o, getAirMass(), skycoupling, Tspill);
256 : }
257 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window 0, for the current
258 : conditions, except Air Mass airmass, introducing a Sky Coupling and Spill Over Temperature */
259 : Temperature getAverageTebbSky(double airmass,
260 : double skycoupling,
261 : const Temperature &Tspill)
262 : {
263 : return getAverageTebbSky(0, airmass, skycoupling, Tspill);
264 : }
265 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window spwid, for the current
266 : conditions, except Air Mass airmass, introducing a Sky Coupling and Spill Over Temperature */
267 : Temperature getAverageTebbSky(unsigned int spwid,
268 : double airmass,
269 : double skycoupling,
270 : const Temperature &Tspill)
271 : {
272 : return getAverageTebbSky(spwid, getUserWH2O(), airmass, skycoupling, Tspill);
273 : }
274 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window 0 for the current
275 : conditions, introducing a Sky Coupling and Spill Over Temperature */
276 : Temperature getAverageTebbSky(double skycoupling, const Temperature &Tspill)
277 : {
278 : unsigned int n = 0;
279 : return getAverageTebbSky(n, skycoupling, Tspill);
280 : }
281 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window spwid for the current
282 : conditions, introducing a Sky Coupling and Spill Over Temperature */
283 : Temperature getAverageTebbSky(unsigned int spwid,
284 : double skycoupling,
285 : const Temperature &Tspill)
286 : {
287 : return getAverageTebbSky(spwid,
288 : getUserWH2O(),
289 : getAirMass(),
290 : skycoupling,
291 : Tspill);
292 : }
293 : /** Accesor to the average Equivalent Blackbody Temperature in spectral window spwid, for Water Column
294 : wh2o, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
295 : Temperature getAverageTebbSky(unsigned int spwid,
296 : const Length &wh2o,
297 : double airmass,
298 : double skycoupling,
299 : const Temperature &Tspill);
300 :
301 : Temperature getAverageTebbSky(unsigned int spwid,
302 : const Length &wh2o,
303 : double airmass,
304 : double skycoupling,
305 : double signalgain,
306 : const Temperature &Tspill);
307 :
308 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel 0, for the currnet
309 : (user) Water Vapor Column, the current Air Mass, and perfect Sky Coupling to the sky */
310 : Temperature getTebbSky()
311 : {
312 : unsigned int n = 0;
313 : return getTebbSky(n);
314 : }
315 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel nc, for the currnet
316 : (user) Water Vapor Column, the current Air Mass, and perfect Sky Coupling to the sky */
317 98 : Temperature getTebbSky(unsigned int nc) // There was reported a bug at Launchpad:
318 : // that the result did not take into account
319 : // the actual column of water. But it is not true.
320 : // The column of water is taken into account as
321 : // seen in the next accessor, that is referred by this one.
322 : {
323 98 : unsigned int n = 0;
324 98 : return getTebbSky(n, nc);
325 : }
326 : /** Accesor to the Equivalent Blackbody Temperature in spectral window spwid and channel nc, for the currnet
327 : (user) Water Vapor Column, the current Air Mass, and perfect Sky Coupling to the sky */
328 98 : Temperature getTebbSky(unsigned int spwid, unsigned int nc)
329 : {
330 : return getTebbSky(spwid,
331 : nc,
332 196 : getUserWH2O(),
333 : getAirMass(),
334 : 1.0,
335 294 : Temperature(100, Temperature::UnitKelvin));
336 : }
337 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel 0, for the currnet
338 : (user) Water Vapor Column, Air Mass airmass, and perfect Sky Coupling to the sky */
339 : Temperature getTebbSky(double airmass)
340 : {
341 : unsigned int n = 0;
342 : return getTebbSky(n, airmass);
343 : }
344 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel nc, for the currnet
345 : (user) Water Vapor Column, Air Mass airmass, and perfect Sky Coupling to the sky */
346 : Temperature getTebbSky(unsigned int nc, double airmass)
347 : {
348 : unsigned int n = 0;
349 : return getTebbSky(n, nc, airmass);
350 : }
351 : /** Accesor to the Equivalent Blackbody Temperature in spectral window spwid and channel nc, for the currnet
352 : (user) Water Vapor Column, Air Mass airmass, and perfect Sky Coupling to the sky */
353 : Temperature getTebbSky(unsigned int spwid, unsigned int nc, double airmass)
354 : {
355 : return getTebbSky(spwid, nc, getUserWH2O(), airmass, 1.0, Temperature(100,
356 : Temperature::UnitKelvin));
357 : }
358 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel 0, for Water
359 : Vapor Column wh2o, the current Air Mass, and perfect Sky Coupling to the sky */
360 : Temperature getTebbSky(const Length &wh2o)
361 : {
362 : unsigned int n = 0;
363 : return getTebbSky(n, wh2o);
364 : }
365 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel nc, for Water
366 : Vapor Column wh2o, the current Air Mass, and perfect Sky Coupling to the sky */
367 : Temperature getTebbSky(unsigned int nc, const Length &wh2o)
368 : {
369 : unsigned int n = 0;
370 : return getTebbSky(n, nc, wh2o);
371 : }
372 : /** Accesor to the Equivalent Blackbody Temperature in spectral window spwid and channel nc, for Water
373 : Vapor Column wh2o, the current Air Mass, and perfect Sky Coupling to the sky */
374 : Temperature getTebbSky(unsigned int spwid, unsigned int nc, const Length &wh2o)
375 : {
376 : return getTebbSky(spwid, nc, wh2o, getAirMass(), 1.0, Temperature(100, Temperature::UnitKelvin));
377 : }
378 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel nc, for the current
379 : (user) Water Vapor Column and Air Mass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
380 : Temperature getTebbSky(unsigned int nc,
381 : double skycoupling,
382 : const Temperature &Tspill)
383 : {
384 : unsigned int n = 0;
385 : return getTebbSky(n, nc, skycoupling, Tspill);
386 : }
387 : /** Accesor to the Equivalent Blackbody Temperature in spectral window spwid and channel nc, for the current
388 : (user) Water Vapor Column and Air Mass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
389 : Temperature getTebbSky(unsigned int spwid,
390 : unsigned int nc,
391 : double skycoupling,
392 : const Temperature &Tspill)
393 : {
394 : return getTebbSky(spwid,
395 : nc,
396 : getUserWH2O(),
397 : getAirMass(),
398 : skycoupling,
399 : Tspill);
400 : }
401 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel nc, for Water
402 : Vapor Column wh2o, Air Mass airmass, and perfect Sky Coupling to the sky */
403 : Temperature getTebbSky(unsigned int nc, const Length &wh2o, double airmass)
404 : {
405 : unsigned int n = 0;
406 : return getTebbSky(n, nc, wh2o, airmass);
407 : }
408 : /** Accesor to the Equivalent Blackbody Temperature in spectral window spwid and channel nc, for Water
409 : Vapor Column wh2o, Air Mass airmass, and perfect Sky Coupling to the sky */
410 : Temperature getTebbSky(unsigned int spwid,
411 : unsigned int nc,
412 : const Length &wh2o,
413 : double airmass)
414 : {
415 : return getTebbSky(spwid, nc, wh2o, airmass, 1.0, Temperature(100, Temperature::UnitKelvin));
416 : }
417 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel nc, for Water
418 : Vapor Column wh2o, the current Air Mass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
419 : Temperature getTebbSky(unsigned int nc,
420 : const Length &wh2o,
421 : double skycoupling,
422 : const Temperature &Tspill)
423 : {
424 : unsigned int n = 0;
425 : return getTebbSky(n, nc, wh2o, skycoupling, Tspill);
426 : }
427 : /** Accesor to the Equivalent Blackbody Temperature in spectral window spwid and channel nc, for Water
428 : Vapor Column wh2o, the current Air Mass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
429 : Temperature getTebbSky(unsigned int spwid,
430 : unsigned int nc,
431 : const Length &wh2o,
432 : double skycoupling,
433 : const Temperature &Tspill)
434 : {
435 : return getTebbSky(spwid, nc, wh2o, getAirMass(), skycoupling, Tspill);
436 : }
437 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel nc, for the current
438 : User Water Column, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
439 : Temperature getTebbSky(unsigned int nc,
440 : double airmass,
441 : double skycoupling,
442 : const Temperature &Tspill)
443 : {
444 : unsigned int n = 0;
445 : return getTebbSky(n, nc, airmass, skycoupling, Tspill);
446 : }
447 : /** Accesor to the Equivalent Blackbody Temperature in spectral window spwid and channel nc, for the current
448 : User Water Column, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
449 : Temperature getTebbSky(unsigned int spwid,
450 : unsigned int nc,
451 : double airmass,
452 : double skycoupling,
453 : const Temperature &Tspill)
454 : {
455 : return getTebbSky(spwid, nc, getUserWH2O(), airmass, skycoupling, Tspill);
456 : }
457 : /** Accesor to the Equivalent Blackbody Temperature in spectral window 0 and channel nc, for Water Column
458 : wh2o, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
459 : Temperature getTebbSky(unsigned int nc,
460 : const Length &wh2o,
461 : double airmass,
462 : double skycoupling,
463 : const Temperature &Tspill)
464 : {
465 : unsigned int n = 0;
466 : return getTebbSky(n, nc, wh2o, airmass, skycoupling, Tspill);
467 : }
468 : /** Accesor to the Equivalent Blackbody Temperature in spectral window spwid and channel nc, for Water Column
469 : wh2o, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
470 : Temperature getTebbSky(unsigned int spwid,
471 : unsigned int nc,
472 : const Length &wh2o,
473 : double airmass,
474 : double skycoupling,
475 : const Temperature &Tspill);
476 :
477 :
478 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window 0, for the current conditions
479 : and a perfect sky coupling */
480 : Temperature getAverageTrjSky()
481 : {
482 : unsigned int n = 0;
483 : return getAverageTrjSky(n);
484 : }
485 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window spwid, for the current conditions
486 : and a perfect sky coupling */
487 : Temperature getAverageTrjSky(unsigned int spwid)
488 : {
489 : return getAverageTrjSky(spwid,
490 : getUserWH2O(),
491 : getAirMass(),
492 : 1.0,
493 : getGroundTemperature());
494 : }
495 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window 0, for the current
496 : conditions, except water column wh2o, and a perfect sky coupling */
497 : Temperature getAverageTrjSky(const Length &wh2o) { return getAverageTrjSky(0, wh2o); }
498 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window spwid, for the current
499 : conditions, except water column wh2o, and a perfect sky coupling */
500 : Temperature getAverageTrjSky(unsigned int spwid, const Length &wh2o)
501 : {
502 : return getAverageTrjSky(spwid,
503 : wh2o,
504 : getAirMass(),
505 : 1.0,
506 : getGroundTemperature());
507 : }
508 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window 0, for the current
509 : conditions, except Air Mass airmass, and a perfect sky coupling */
510 : Temperature getAverageTrjSky(double airmass) { return getAverageTrjSky(0, airmass); }
511 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window spwid, for the current
512 : conditions, except Air Mass airmass, and a perfect sky coupling */
513 : Temperature getAverageTrjSky(unsigned int spwid, double airmass)
514 : {
515 : return getAverageTrjSky(spwid,
516 : getUserWH2O(),
517 : airmass,
518 : 1.0,
519 : getGroundTemperature());
520 : }
521 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window 0, for the current
522 : conditions, except water column wh2o, introducing a Sky Coupling and Spill Over Temperature */
523 : Temperature getAverageTrjSky(const Length &wh2o,
524 : double skycoupling,
525 : const Temperature &Tspill)
526 : {
527 : return getAverageTrjSky(0, wh2o, skycoupling, Tspill);
528 : }
529 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window spwid, for the current
530 : conditions, except water column wh2o, introducing a Sky Coupling and Spill Over Temperature */
531 : Temperature getAverageTrjSky(unsigned int spwid,
532 : const Length &wh2o,
533 : double skycoupling,
534 : const Temperature &Tspill)
535 : {
536 : return getAverageTrjSky(spwid, wh2o, getAirMass(), skycoupling, Tspill);
537 : }
538 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window 0, for the current
539 : conditions, except Air Mass airmass, introducing a Sky Coupling and Spill Over Temperature */
540 : Temperature getAverageTrjSky(double airmass,
541 : double skycoupling,
542 : const Temperature &Tspill)
543 : {
544 : return getAverageTrjSky(0, airmass, skycoupling, Tspill);
545 : }
546 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window spwid, for the current
547 : conditions, except Air Mass airmass, introducing a Sky Coupling and Spill Over Temperature */
548 : Temperature getAverageTrjSky(unsigned int spwid,
549 : double airmass,
550 : double skycoupling,
551 : const Temperature &Tspill)
552 : {
553 : return getAverageTrjSky(spwid, getUserWH2O(), airmass, skycoupling, Tspill);
554 : }
555 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window 0 for the current
556 : conditions, introducing a Sky Coupling and Spill Over Temperature */
557 : Temperature getAverageTrjSky(double skycoupling, const Temperature &Tspill)
558 : {
559 : unsigned int n = 0;
560 : return getAverageTrjSky(n, skycoupling, Tspill);
561 : }
562 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window spwid for the current
563 : conditions, introducing a Sky Coupling and Spill Over Temperature */
564 : Temperature getAverageTrjSky(unsigned int spwid,
565 : double skycoupling,
566 : const Temperature &Tspill)
567 : {
568 : return getAverageTrjSky(spwid,
569 : getUserWH2O(),
570 : getAirMass(),
571 : skycoupling,
572 : Tspill);
573 : }
574 : /** Accesor to the average Rayleigh-Jeans Temperature in spectral window spwid, for Water Column
575 : wh2o, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
576 : Temperature getAverageTrjSky(unsigned int spwid,
577 : const Length &wh2o,
578 : double airmass,
579 : double skycoupling,
580 : const Temperature &Tspill);
581 :
582 : Temperature getAverageTrjSky(unsigned int spwid,
583 : const Length &wh2o,
584 : double airmass,
585 : double skycoupling,
586 : double signalgain,
587 : const Temperature &Tspill);
588 :
589 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel 0, for the currnet
590 : (user) Water Vapor Column, the current Air Mass, and perfect Sky Coupling to the sky */
591 : Temperature getTrjSky()
592 : {
593 : unsigned int n = 0;
594 : return getTrjSky(n);
595 : }
596 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel nc, for the currnet
597 : (user) Water Vapor Column, the current Air Mass, and perfect Sky Coupling to the sky */
598 0 : Temperature getTrjSky(unsigned int nc) // There was reported a bug at Launchpad:
599 : // that the result did not take into account
600 : // the actual column of water. But it is not true.
601 : // The column of water is taken into account as
602 : // seen in the next accessor, that is referred by this one.
603 : {
604 0 : unsigned int n = 0;
605 0 : return getTrjSky(n, nc);
606 : }
607 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window spwid and channel nc, for the currnet
608 : (user) Water Vapor Column, the current Air Mass, and perfect Sky Coupling to the sky */
609 0 : Temperature getTrjSky(unsigned int spwid, unsigned int nc)
610 : {
611 : return getTrjSky(spwid,
612 : nc,
613 0 : getUserWH2O(),
614 : getAirMass(),
615 : 1.0,
616 0 : Temperature(100, Temperature::UnitKelvin));
617 : }
618 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel 0, for the currnet
619 : (user) Water Vapor Column, Air Mass airmass, and perfect Sky Coupling to the sky */
620 : Temperature getTrjSky(double airmass)
621 : {
622 : unsigned int n = 0;
623 : return getTrjSky(n, airmass);
624 : }
625 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel nc, for the currnet
626 : (user) Water Vapor Column, Air Mass airmass, and perfect Sky Coupling to the sky */
627 : Temperature getTrjSky(unsigned int nc, double airmass)
628 : {
629 : unsigned int n = 0;
630 : return getTrjSky(n, nc, airmass);
631 : }
632 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window spwid and channel nc, for the currnet
633 : (user) Water Vapor Column, Air Mass airmass, and perfect Sky Coupling to the sky */
634 : Temperature getTrjSky(unsigned int spwid, unsigned int nc, double airmass)
635 : {
636 : return getTrjSky(spwid, nc, getUserWH2O(), airmass, 1.0, Temperature(100,
637 : Temperature::UnitKelvin));
638 : }
639 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel 0, for Water
640 : Vapor Column wh2o, the current Air Mass, and perfect Sky Coupling to the sky */
641 : Temperature getTrjSky(const Length &wh2o)
642 : {
643 : unsigned int n = 0;
644 : return getTrjSky(n, wh2o);
645 : }
646 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel nc, for Water
647 : Vapor Column wh2o, the current Air Mass, and perfect Sky Coupling to the sky */
648 : Temperature getTrjSky(unsigned int nc, const Length &wh2o)
649 : {
650 : unsigned int n = 0;
651 : return getTrjSky(n, nc, wh2o);
652 : }
653 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window spwid and channel nc, for Water
654 : Vapor Column wh2o, the current Air Mass, and perfect Sky Coupling to the sky */
655 : Temperature getTrjSky(unsigned int spwid, unsigned int nc, const Length &wh2o)
656 : {
657 : return getTrjSky(spwid, nc, wh2o, getAirMass(), 1.0, Temperature(100, Temperature::UnitKelvin));
658 : }
659 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel nc, for the current
660 : (user) Water Vapor Column and Air Mass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
661 : Temperature getTrjSky(unsigned int nc,
662 : double skycoupling,
663 : const Temperature &Tspill)
664 : {
665 : unsigned int n = 0;
666 : return getTrjSky(n, nc, skycoupling, Tspill);
667 : }
668 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window spwid and channel nc, for the current
669 : (user) Water Vapor Column and Air Mass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
670 : Temperature getTrjSky(unsigned int spwid,
671 : unsigned int nc,
672 : double skycoupling,
673 : const Temperature &Tspill)
674 : {
675 : return getTrjSky(spwid,
676 : nc,
677 : getUserWH2O(),
678 : getAirMass(),
679 : skycoupling,
680 : Tspill);
681 : }
682 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel nc, for Water
683 : Vapor Column wh2o, Air Mass airmass, and perfect Sky Coupling to the sky */
684 : Temperature getTrjSky(unsigned int nc, const Length &wh2o, double airmass)
685 : {
686 : unsigned int n = 0;
687 : return getTrjSky(n, nc, wh2o, airmass);
688 : }
689 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window spwid and channel nc, for Water
690 : Vapor Column wh2o, Air Mass airmass, and perfect Sky Coupling to the sky */
691 : Temperature getTrjSky(unsigned int spwid,
692 : unsigned int nc,
693 : const Length &wh2o,
694 : double airmass)
695 : {
696 : return getTrjSky(spwid, nc, wh2o, airmass, 1.0, Temperature(100, Temperature::UnitKelvin));
697 : }
698 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel nc, for Water
699 : Vapor Column wh2o, the current Air Mass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
700 : Temperature getTrjSky(unsigned int nc,
701 : const Length &wh2o,
702 : double skycoupling,
703 : const Temperature &Tspill)
704 : {
705 : unsigned int n = 0;
706 : return getTrjSky(n, nc, wh2o, skycoupling, Tspill);
707 : }
708 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window spwid and channel nc, for Water
709 : Vapor Column wh2o, the current Air Mass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
710 : Temperature getTrjSky(unsigned int spwid,
711 : unsigned int nc,
712 : const Length &wh2o,
713 : double skycoupling,
714 : const Temperature &Tspill)
715 : {
716 : return getTrjSky(spwid, nc, wh2o, getAirMass(), skycoupling, Tspill);
717 : }
718 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel nc, for the current
719 : User Water Column, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
720 : Temperature getTrjSky(unsigned int nc,
721 : double airmass,
722 : double skycoupling,
723 : const Temperature &Tspill)
724 : {
725 : unsigned int n = 0;
726 : return getTrjSky(n, nc, airmass, skycoupling, Tspill);
727 : }
728 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window spwid and channel nc, for the current
729 : User Water Column, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
730 : Temperature getTrjSky(unsigned int spwid,
731 : unsigned int nc,
732 : double airmass,
733 : double skycoupling,
734 : const Temperature &Tspill)
735 : {
736 : return getTrjSky(spwid, nc, getUserWH2O(), airmass, skycoupling, Tspill);
737 : }
738 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window 0 and channel nc, for Water Column
739 : wh2o, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
740 : Temperature getTrjSky(unsigned int nc,
741 : const Length &wh2o,
742 : double airmass,
743 : double skycoupling,
744 : const Temperature &Tspill)
745 : {
746 : unsigned int n = 0;
747 : return getTrjSky(n, nc, wh2o, airmass, skycoupling, Tspill);
748 : }
749 : /** Accesor to the Rayleigh-Jeans Temperature in spectral window spwid and channel nc, for Water Column
750 : wh2o, Air Mass airmass, Sky Coupling skycoupling, and Spill Over Temperature Tspill */
751 : Temperature getTrjSky(unsigned int spwid,
752 : unsigned int nc,
753 : const Length &wh2o,
754 : double airmass,
755 : double skycoupling,
756 : const Temperature &Tspill);
757 :
758 490 : double getSkyTransmission(unsigned int nc){return exp(-1.0*getTotalOpacity(nc).get("np"));}
759 :
760 :
761 : /** Accesor to get the integrated zenith Wet Opacity for the current conditions, for a single
762 : frequency RefractiveIndexProfile object or for the point 0 of spectral window 0 of a
763 : multi-window RefractiveIndexProfile object.
764 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
765 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
766 : Opacity getWetOpacity(){unsigned int n = 0; return getWetOpacity(n);}
767 : Opacity getWetOpacityUpTo(Length refalti){unsigned int n = 0; return getWetOpacityUpTo(n, refalti);}
768 : /** Accesor to get the integrated zenith Wet Opacity for the current conditions,
769 : for the point nc of spectral window 0.
770 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
771 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
772 980 : Opacity getWetOpacity(unsigned int nc){return getH2OLinesOpacity(nc) + getH2OContOpacity(nc);}
773 : Opacity getWetOpacityUpTo(unsigned int nc, Length refalti){return getH2OLinesOpacityUpTo(nc, refalti) + getH2OContOpacityUpTo(nc, refalti);}
774 : /** Accesor to get the integrated zenith Wet Opacity for the current conditions,
775 : for the point nc of spectral window spwid.
776 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
777 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
778 0 : Opacity getWetOpacity(unsigned int spwid, unsigned int nc)
779 : {
780 0 : if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0;
781 0 : return getWetOpacity(v_transfertId_[spwid] + nc);
782 : }
783 : Opacity getWetOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti)
784 : {
785 : if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0;
786 : return getWetOpacityUpTo(v_transfertId_[spwid] + nc, refalti);
787 : }
788 : /** Accesor to get the average Wet Opacity for the current conditions,
789 : in spectral window spwid.
790 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
791 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
792 : Opacity getAverageWetOpacity(unsigned int spwid)
793 : {
794 : return RefractiveIndexProfile::getAverageWetOpacity(getGroundWH2O(),spwid)
795 : * ((getUserWH2O().get()) / (getGroundWH2O().get()));
796 : }
797 : Opacity getAverageH2OLinesOpacity(unsigned int spwid)
798 : {
799 : return RefractiveIndexProfile::getAverageH2OLinesOpacity(getGroundWH2O(),spwid)
800 : * ((getUserWH2O().get()) / (getGroundWH2O().get()));
801 : }
802 : Opacity getAverageH2OContOpacity(unsigned int spwid)
803 : {
804 : return RefractiveIndexProfile::getAverageH2OContOpacity(getGroundWH2O(),spwid)
805 : * ((getUserWH2O().get()) / (getGroundWH2O().get()));
806 : }
807 :
808 : Opacity getDryOpacity()
809 : {
810 : return RefractiveIndexProfile::getDryOpacity();
811 : }
812 490 : Opacity getDryOpacity(unsigned int nc)
813 : {
814 490 : return RefractiveIndexProfile::getDryOpacity(nc);
815 : }
816 0 : Opacity getDryOpacity(unsigned int spwid, unsigned int nc)
817 : {
818 0 : return RefractiveIndexProfile::getDryOpacity(spwid, nc);
819 : }
820 : Opacity getAverageDryOpacity(unsigned int spwid)
821 : {
822 : return RefractiveIndexProfile::getAverageDryOpacity(spwid);
823 : }
824 :
825 : Opacity getAverageO2LinesOpacity(unsigned int spwid)
826 : {
827 : return RefractiveIndexProfile::getAverageO2LinesOpacity(spwid);
828 : }
829 : Opacity getAverageO3LinesOpacity(unsigned int spwid)
830 : {
831 : return RefractiveIndexProfile::getAverageO3LinesOpacity(spwid);
832 : }
833 : Opacity getAverageN2OLinesOpacity(unsigned int spwid)
834 : {
835 : return RefractiveIndexProfile::getAverageN2OLinesOpacity(spwid);
836 : }
837 : Opacity getAverageNO2LinesOpacity(unsigned int spwid)
838 : {
839 : return RefractiveIndexProfile::getAverageNO2LinesOpacity(spwid);
840 : }
841 : Opacity getAverageHClLinesOpacity(unsigned int spwid)
842 : {
843 : return RefractiveIndexProfile::getAverageHClLinesOpacity(spwid);
844 : }
845 : Opacity getAverageHCNLinesOpacity(unsigned int spwid)
846 : {
847 : return RefractiveIndexProfile::getAverageHCNLinesOpacity(spwid);
848 : }
849 : Opacity getAverageSO2LinesOpacity(unsigned int spwid)
850 : {
851 : return RefractiveIndexProfile::getAverageSO2LinesOpacity(spwid);
852 : }
853 : Opacity getAverageCOLinesOpacity(unsigned int spwid)
854 : {
855 : return RefractiveIndexProfile::getAverageCOLinesOpacity(spwid);
856 : }
857 : Opacity getAverageDryContOpacity(unsigned int spwid)
858 : {
859 : return RefractiveIndexProfile::getAverageDryContOpacity(spwid);
860 : }
861 :
862 : Opacity getTotalOpacity()
863 : {
864 : return getWetOpacity() + getDryOpacity();
865 : }
866 490 : Opacity getTotalOpacity(unsigned int nc)
867 : {
868 980 : return getWetOpacity(nc) + getDryOpacity(nc);
869 : }
870 : Opacity getTotalOpacity(unsigned int spwid, unsigned int nc)
871 : {
872 : return getWetOpacity(spwid, nc) + getDryOpacity(spwid, nc);
873 : }
874 : Opacity getAverageTotalOpacity(unsigned int spwid)
875 : {
876 : return getAverageWetOpacity(spwid) + getAverageDryOpacity(spwid);
877 : }
878 : Opacity getTotalOpacityUpTo(Length refalti)
879 : {
880 : unsigned int n = 0;
881 : return getTotalOpacityUpTo(n, refalti);
882 : }
883 : // Opacity getTotalOpacityUpTo(unsigned int nc, Length refalti);
884 : Opacity getTotalOpacityUpTo(unsigned int nc, Length refalti)
885 : {
886 : return getWetOpacityUpTo(nc,refalti) + getDryOpacityUpTo(nc,refalti);
887 : }
888 : Opacity getTotalOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti)
889 : {
890 : Opacity wrongOp(-999.0,Opacity::UnitNeper);
891 : if(!spwidAndIndexAreValid(spwid, nc)) return wrongOp;
892 : return getTotalOpacityUpTo(v_transfertId_[spwid] + nc, refalti);
893 : }
894 :
895 : /** Accesor to get the integrated zenith H2O Lines Opacity for the current conditions,
896 : for a single frequency RefractiveIndexProfile object or for the point 0 of spectral
897 : window 0 of a multi-window RefractiveIndexProfile object.
898 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
899 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
900 : Opacity getH2OLinesOpacity(){ unsigned int n = 0; return getH2OLinesOpacity(n);}
901 : Opacity getH2OLinesOpacityUpTo(Length refalti){ unsigned int n = 0; return getH2OLinesOpacityUpTo(n, refalti);}
902 : /** Accesor to get the integrated zenith H2O Lines Opacity for the current conditions,
903 : for the point nc of spectral window 0.
904 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
905 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
906 : Opacity getH2OLinesOpacity(unsigned int nc);
907 : Opacity getH2OLinesOpacityUpTo(unsigned int nc, Length refalti);
908 : /** Accesor to get the integrated zenith H2O Lines Opacity for the current conditions,
909 : for the point nc of spectral window spwid.
910 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
911 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
912 : Opacity getH2OLinesOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getH2OLinesOpacity(v_transfertId_[spwid] + nc);}
913 : Opacity getH2OLinesOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getH2OLinesOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
914 :
915 :
916 : /** Accesor to get the integrated zenith HH16O Lines Opacity for the current conditions,
917 : for a single frequency RefractiveIndexProfile object or for the point 0 of spectral
918 : window 0 of a multi-window RefractiveIndexProfile object.
919 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
920 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
921 : Opacity getHH16OLinesOpacity(){ unsigned int n = 0; return getHH16OLinesOpacity(n);}
922 : Opacity getHH16OLinesOpacityUpTo(Length refalti){ unsigned int n = 0; return getHH16OLinesOpacityUpTo(n, refalti);}
923 : /** Accesor to get the integrated zenith HH16O Lines Opacity for the current conditions,
924 : for the point nc of spectral window 0.
925 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
926 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
927 : Opacity getHH16OLinesOpacity(unsigned int nc);
928 : Opacity getHH16OLinesOpacityUpTo(unsigned int nc, Length refalti);
929 : /** Accesor to get the integrated zenith HH16O Lines Opacity for the current conditions,
930 : for the point nc of spectral window spwid.
931 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
932 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
933 : Opacity getHH16OLinesOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHH16OLinesOpacity(v_transfertId_[spwid] + nc);}
934 : Opacity getHH16OLinesOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHH16OLinesOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
935 :
936 :
937 :
938 : /** Accesor to get the integrated zenith HH16OV2 Lines Opacity for the current conditions,
939 : for a single frequency RefractiveIndexProfile object or for the point 0 of spectral
940 : window 0 of a multi-window RefractiveIndexProfile object.
941 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
942 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
943 : Opacity getHH16OV2LinesOpacity(){ unsigned int n = 0; return getHH16OV2LinesOpacity(n);}
944 : Opacity getHH16OV2LinesOpacityUpTo(Length refalti){ unsigned int n = 0; return getHH16OV2LinesOpacityUpTo(n, refalti);}
945 : /** Accesor to get the integrated zenith HH16OV2 Lines Opacity for the current conditions,
946 : for the point nc of spectral window 0.
947 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
948 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
949 : Opacity getHH16OV2LinesOpacity(unsigned int nc);
950 : Opacity getHH16OV2LinesOpacityUpTo(unsigned int nc, Length refalti);
951 : /** Accesor to get the integrated zenith HH16OV2 Lines Opacity for the current conditions,
952 : for the point nc of spectral window spwid.
953 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
954 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
955 : Opacity getHH16OV2LinesOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHH16OV2LinesOpacity(v_transfertId_[spwid] + nc);}
956 : Opacity getHH16OV2LinesOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHH16OV2LinesOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
957 :
958 :
959 : /** Accesor to get the integrated zenith HH18O Lines Opacity for the current conditions,
960 : for a single frequency RefractiveIndexProfile object or for the point 0 of spectral
961 : window 0 of a multi-window RefractiveIndexProfile object.
962 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
963 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
964 : Opacity getHH18OLinesOpacity(){ unsigned int n = 0; return getHH18OLinesOpacity(n);}
965 : Opacity getHH18OLinesOpacityUpTo(Length refalti){ unsigned int n = 0; return getHH18OLinesOpacityUpTo(n, refalti);}
966 : /** Accesor to get the integrated zenith HH18O Lines Opacity for the current conditions,
967 : for the point nc of spectral window 0.
968 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
969 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
970 : Opacity getHH18OLinesOpacity(unsigned int nc);
971 : Opacity getHH18OLinesOpacityUpTo(unsigned int nc, Length refalti);
972 : /** Accesor to get the integrated zenith HH18O Lines Opacity for the current conditions,
973 : for the point nc of spectral window spwid.
974 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
975 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
976 : Opacity getHH18OLinesOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHH18OLinesOpacity(v_transfertId_[spwid] + nc);}
977 : Opacity getHH18OLinesOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHH18OLinesOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
978 :
979 :
980 : /** Accesor to get the integrated zenith HH17O Lines Opacity for the current conditions,
981 : for a single frequency RefractiveIndexProfile object or for the point 0 of spectral
982 : window 0 of a multi-window RefractiveIndexProfile object.
983 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
984 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
985 : Opacity getHH17OLinesOpacity(){ unsigned int n = 0; return getHH17OLinesOpacity(n);}
986 : Opacity getHH17OLinesOpacityUpTo(Length refalti){ unsigned int n = 0; return getHH17OLinesOpacityUpTo(n, refalti);}
987 : /** Accesor to get the integrated zenith HH17O Lines Opacity for the current conditions,
988 : for the point nc of spectral window 0.
989 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
990 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
991 : Opacity getHH17OLinesOpacity(unsigned int nc);
992 : Opacity getHH17OLinesOpacityUpTo(unsigned int nc, Length refalti);
993 : /** Accesor to get the integrated zenith HH17O Lines Opacity for the current conditions,
994 : for the point nc of spectral window spwid.
995 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
996 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
997 : Opacity getHH17OLinesOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHH17OLinesOpacity(v_transfertId_[spwid] + nc);}
998 : Opacity getHH17OLinesOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHH17OLinesOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
999 :
1000 :
1001 : /** Accesor to get the integrated zenith HDO Lines Opacity for the current conditions,
1002 : for a single frequency RefractiveIndexProfile object or for the point 0 of spectral
1003 : window 0 of a multi-window RefractiveIndexProfile object.
1004 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1005 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1006 : Opacity getHDOLinesOpacity(){ unsigned int n = 0; return getHDOLinesOpacity(n);}
1007 : Opacity getHDOLinesOpacityUpTo(Length refalti){ unsigned int n = 0; return getHDOLinesOpacityUpTo(n, refalti);}
1008 : /** Accesor to get the integrated zenith HDO Lines Opacity for the current conditions,
1009 : for the point nc of spectral window 0.
1010 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1011 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1012 : Opacity getHDOLinesOpacity(unsigned int nc);
1013 : Opacity getHDOLinesOpacityUpTo(unsigned int nc, Length refalti);
1014 : /** Accesor to get the integrated zenith HDO Lines Opacity for the current conditions,
1015 : for the point nc of spectral window spwid.
1016 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1017 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1018 : Opacity getHDOLinesOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHDOLinesOpacity(v_transfertId_[spwid] + nc);}
1019 : Opacity getHDOLinesOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getHDOLinesOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
1020 :
1021 :
1022 :
1023 :
1024 : /** Accesor to get the integrated zenith H2O Continuum Opacity for the current conditions,
1025 : for a single frequency RefractiveIndexProfile object or for the point 0 of spectral
1026 : window 0 of a multi-window RefractiveIndexProfile object.
1027 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1028 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1029 : Opacity getH2OContOpacity(){unsigned int n = 0; return getH2OContOpacity(n);}
1030 : Opacity getH2OContOpacityUpTo(Length refalti){unsigned int n = 0; return getH2OContOpacityUpTo(n, refalti);}
1031 : /** Accesor to get the integrated zenith H2O Continuum Opacity for the current conditions,
1032 : for the point nc of spectral window 0.
1033 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1034 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1035 : Opacity getH2OContOpacity(unsigned int nc);
1036 : Opacity getH2OContOpacityUpTo(unsigned int nc, Length refalti);
1037 : /** Accesor to get the integrated zenith H2O Continuum Opacity for the current conditions,
1038 : for the point nc of spectral window spwid.
1039 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1040 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1041 : Opacity getH2OContOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getH2OContOpacity(v_transfertId_[spwid] + nc);}
1042 : Opacity getH2OContOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getH2OContOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
1043 : /** Accesor to get the integrated zenith H2O Atmospheric Phase Delay (Dispersive part)
1044 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1045 : for the point 0 of spectral window 0 of a multi-window RefractiveIndexProfile object.
1046 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1047 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1048 : Angle getDispersiveH2OPhaseDelay()
1049 : {
1050 : unsigned int n = 0;
1051 : return getDispersiveH2OPhaseDelay(n);
1052 : }
1053 : /** Accesor to get the integrated zenith H2O Atmospheric Phase Delay (Dispersive part)
1054 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1055 : for the point nc of spectral window 0.
1056 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1057 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1058 : Angle getDispersiveH2OPhaseDelay(unsigned int nc);
1059 : /** Accesor to get the integrated zenith H2O Atmospheric Phase Delay (Dispersive part)
1060 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1061 : for the point nc of spectral window spwid.
1062 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1063 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1064 : Angle getDispersiveH2OPhaseDelay(unsigned int spwid, unsigned int nc);
1065 :
1066 : /** Accesor to get the integrated zenith H2O Atmospheric Path length (Dispersive part)
1067 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1068 : for the point 0 of spectral window 0 of a multi-window RefractiveIndexProfile object.
1069 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1070 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1071 : Length getDispersiveH2OPathLength()
1072 : {
1073 : unsigned int n = 0;
1074 : return getDispersiveH2OPathLength(n);
1075 : }
1076 : /** Accesor to get the integrated zenith H2O Atmospheric Path length (Dispersive part)
1077 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1078 : for the point nc of spectral window 0.
1079 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1080 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1081 : Length getDispersiveH2OPathLength(unsigned int nc);
1082 : /** Accesor to get the integrated zenith H2O Atmospheric Path length (Dispersive part)
1083 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1084 : for the point nc of spectral window spwid.
1085 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1086 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1087 : Length getDispersiveH2OPathLength(unsigned int spwid, unsigned int nc);
1088 :
1089 : /** Accesor to get the integrated zenith H2O Atmospheric Phase Delay (Non-Dispersive part)
1090 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1091 : for the point 0 of spectral window 0 of a multi-window RefractiveIndexProfile object.
1092 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1093 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1094 : Angle getNonDispersiveH2OPhaseDelay()
1095 : {
1096 : unsigned int n = 0;
1097 : return getNonDispersiveH2OPhaseDelay(n);
1098 : }
1099 : /** Accesor to get the integrated zenith H2O Atmospheric Phase Delay (Non-Dispersive part)
1100 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1101 : for the point nc of spectral window 0.
1102 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1103 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1104 : Angle getNonDispersiveH2OPhaseDelay(unsigned int nc);
1105 : /** Accesor to get the integrated zenith H2O Atmospheric Phase Delay (Non-Dispersive part)
1106 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1107 : for the point nc of spectral window spwid.
1108 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1109 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1110 : Angle getNonDispersiveH2OPhaseDelay(unsigned int spwid, unsigned int nc);
1111 :
1112 : /** Accesor to get the integrated zenith H2O Atmospheric Path length (Non-Dispersive part)
1113 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1114 : for the point 0 of spectral window 0 of a multi-window RefractiveIndexProfile object.
1115 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1116 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1117 : Length getNonDispersiveH2OPathLength()
1118 : {
1119 : unsigned int n = 0;
1120 : return getNonDispersiveH2OPathLength(n);
1121 : }
1122 : /** Accesor to get the integrated zenith H2O Atmospheric Path length (Non-Dispersive part)
1123 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1124 : for the point nc of spectral window 0.
1125 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1126 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1127 : Length getNonDispersiveH2OPathLength(unsigned int nc);
1128 : /** Accesor to get the integrated zenith H2O Atmospheric Path length (Non-Dispersive part)
1129 : for the current conditions, for a single frequency RefractiveIndexProfile object or
1130 : for the point nc of spectral window spwid.
1131 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1132 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1133 : Length getNonDispersiveH2OPathLength(unsigned int spwid, unsigned int nc);
1134 :
1135 : /** Accessor to get the average integrated zenith Atmospheric Phase Delay (Dispersive part)
1136 : for the current conditions in spectral Window spwid.
1137 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1138 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1139 : Angle getAverageDispersiveH2OPhaseDelay(unsigned int spwid);
1140 : /** Accessor to get the average integrated zenith Atmospheric Phase Delay (Dispersive part)
1141 : for the current conditions in spectral Window 0.
1142 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1143 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1144 : Angle getAverageDispersiveH2OPhaseDelay()
1145 : {
1146 : unsigned int n = 0;
1147 : return getAverageDispersiveH2OPhaseDelay(n);
1148 : }
1149 : /** Accessor to get the average integrated zenith Atmospheric Phase Delay (Non-Dispersive
1150 : part) in spectral Window spwid.
1151 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1152 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1153 : Angle getAverageNonDispersiveH2OPhaseDelay(unsigned int spwid);
1154 : /** Accessor to get the average integrated zenith Atmospheric Phase Delay (Non-Dispersive
1155 : part) in spectral Window 0.
1156 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1157 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1158 : Angle getAverageNonDispersiveH2OPhaseDelay()
1159 : {
1160 : unsigned int n = 0;
1161 : return getAverageNonDispersiveH2OPhaseDelay(n);
1162 : }
1163 :
1164 : /** Accessor to get the average integrated zenith Atmospheric Path Length (Dispersive part)
1165 : in spectral Window spwid.
1166 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1167 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1168 : Length getAverageDispersiveH2OPathLength(unsigned int spwid);
1169 : /** Accessor to get the average integrated zenith Atmospheric Path Length (Dispersive part)
1170 : in spectral Window 0.
1171 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1172 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1173 : Length getAverageDispersiveH2OPathLength()
1174 : {
1175 : unsigned int n = 0;
1176 : return getAverageDispersiveH2OPathLength(n);
1177 : }
1178 : /** Accessor to get the average integrated zenith Atmospheric Path Length (Non-Dispersive
1179 : part) in spectral Window spwid.
1180 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1181 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1182 : Length getAverageNonDispersiveH2OPathLength(unsigned int spwid);
1183 : /** Accessor to get the average integrated zenith Atmospheric Path Length (Non-Dispersive
1184 : part) in spectral Window 0.
1185 : There is overloading. The same accessor exists in RefractiveIndexProfile but in that
1186 : case the returned value corresponds to the zenith water vapor column of the AtmProfile object.*/
1187 : Length getAverageNonDispersiveH2OPathLength()
1188 : {
1189 : unsigned int n = 0;
1190 : return getAverageNonDispersiveH2OPathLength(n);
1191 : }
1192 :
1193 240 : Length getAverageH2OPathLength(unsigned int spwid)
1194 : {
1195 480 : return getAverageDispersiveH2OPathLength(spwid)
1196 720 : + getAverageNonDispersiveH2OPathLength(spwid);
1197 : }
1198 : Length getAverageH2OPathLength()
1199 : {
1200 : unsigned int n = 0;
1201 : return getAverageH2OPathLength(n);
1202 : }
1203 : double getAverageH2OPathLengthDerivative(unsigned int spwid)
1204 : {
1205 : return getAverageH2OPathLength(spwid).get(Length::UnitMicrons)
1206 : / getUserWH2O().get(Length::UnitMicrons);
1207 : } // in microns/micron_H2O
1208 : double getAverageH2OPathLengthDerivative()
1209 : {
1210 : unsigned int n = 0;
1211 : return getAverageH2OPathLengthDerivative(n);
1212 : } // in microns/micron_H2O
1213 :
1214 :
1215 : Angle getAverageH2OPhaseDelay(unsigned int spwid)
1216 : {
1217 : return getAverageDispersiveH2OPhaseDelay(spwid)
1218 : + getAverageNonDispersiveH2OPhaseDelay(spwid);
1219 : }
1220 : Angle getAverageH2OPhaseDelay()
1221 : {
1222 : unsigned int n = 0;
1223 : return getAverageH2OPhaseDelay(n);
1224 : }
1225 :
1226 240 : Length getAverageDispersiveDryPathLength(unsigned int spwid)
1227 : {
1228 240 : return getAverageO2LinesPathLength(spwid)
1229 720 : + getAverageO3LinesPathLength(spwid)
1230 960 : + getAverageN2OLinesPathLength(spwid)
1231 960 : + getAverageCOLinesPathLength(spwid)
1232 960 : + getAverageNO2LinesPathLength(spwid)
1233 960 : + getAverageSO2LinesPathLength(spwid)
1234 960 : + getAverageHClLinesPathLength(spwid)
1235 720 : + getAverageHCNLinesPathLength(spwid);
1236 : }
1237 : Length getAverageDispersiveDryPathLength()
1238 : {
1239 : unsigned int n = 0;
1240 : return getAverageDispersiveDryPathLength(n);
1241 : }
1242 :
1243 240 : Length getAverageNonDispersiveDryPathLength(unsigned int spwid)
1244 : {
1245 240 : return RefractiveIndexProfile::getAverageNonDispersiveDryPathLength(spwid);
1246 : }
1247 : Length getAverageNonDispersiveDryPathLength()
1248 : {
1249 : unsigned int n = 0;
1250 : return getAverageNonDispersiveDryPathLength(n);
1251 : }
1252 : double
1253 : getAverageNonDispersiveDryPathLength_GroundPressureDerivative(unsigned int spwid);
1254 : double
1255 : getAverageNonDispersiveDryPathLength_GroundTemperatureDerivative(unsigned int spwid);
1256 : double
1257 : getAverageDispersiveDryPathLength_GroundPressureDerivative(unsigned int spwid);
1258 : double
1259 : getAverageDispersiveDryPathLength_GroundTemperatureDerivative(unsigned int spwid);
1260 :
1261 240 : Length getAverageO2LinesPathLength(unsigned int spwid)
1262 : {
1263 240 : return RefractiveIndexProfile::getAverageO2LinesPathLength(spwid);
1264 : }
1265 : Length getAverageO2LinesPathLength()
1266 : {
1267 : unsigned int n = 0;
1268 : return getAverageO2LinesPathLength(n);
1269 : }
1270 :
1271 : /** Setter for a new set of basic atmospheric parameters. Automatically updates the AtmProfile
1272 : (if generated from this basic atmospheric parameters), RefractiveIndexProfile, and SkyStatus
1273 : objects if the one or more value differ from the previous ones (there is overloading) */
1274 : bool setBasicAtmosphericParameters(const Length &altitude,
1275 : const Pressure &groundPressure,
1276 : const Temperature &groundTemperature,
1277 : double tropoLapseRate,
1278 : const Humidity &humidity,
1279 : const Length &wvScaleHeight);
1280 : /** The same setter is available for only one parameter each time (except for "Length wvScaleHeight" due to a type
1281 : conflict with "Length altitude") */
1282 : bool setBasicAtmosphericParameters(const Length &altitude);
1283 : /** The same setter is available for only one parameter each time (except for "Length wvScaleHeight" due to a type
1284 : conflict with "Length altitude") */
1285 : bool setBasicAtmosphericParameters(const Temperature &groundTemperature);
1286 : /** The same setter is available for only one parameter each time (except for "Length wvScaleHeight" due to a type
1287 : conflict with "Length altitude") */
1288 : bool setBasicAtmosphericParameters(const Pressure &groundPressure);
1289 : /** The same setter is available for only one parameter each time (except for "Length wvScaleHeight" due to a type
1290 : conflict with "Length altitude") */
1291 : bool setBasicAtmosphericParameters(const Humidity &humidity);
1292 : /** The same setter is available for only one parameter each time (except for "Length wvScaleHeight" due to a type
1293 : conflict with "Length altitude") */
1294 : bool setBasicAtmosphericParameters(double tropoLapseRate);
1295 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1296 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1297 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1298 : bool setBasicAtmosphericParameters(const Length &altitude,
1299 : const Temperature &groundTemperature);
1300 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1301 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1302 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1303 : bool setBasicAtmosphericParameters(const Length &altitude, const Pressure &groundPressure);
1304 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1305 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1306 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1307 : bool setBasicAtmosphericParameters(const Length &altitude, const Humidity &humidity);
1308 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1309 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1310 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1311 : bool setBasicAtmosphericParameters(const Length &altitude, double tropoLapseRate);
1312 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1313 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1314 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1315 : bool setBasicAtmosphericParameters(const Length &altitude, const Length &wvScaleHeight);
1316 : /** The same setter is available for couples of parameters. The order does not matter */
1317 : bool setBasicAtmosphericParameters(const Temperature &groundTemperature,
1318 : const Pressure &groundPressure);
1319 : /** The same setter is available for couples of parameters. The order does not matter */
1320 : bool setBasicAtmosphericParameters(const Pressure &groundPressure,
1321 : const Temperature &groundTemperature);
1322 : /** The same setter is available for couples of parameters. The order does not matter */
1323 : bool setBasicAtmosphericParameters(const Temperature &groundTemperature,
1324 : const Humidity &humidity);
1325 : /** The same setter is available for couples of parameters. The order does not matter */
1326 : bool setBasicAtmosphericParameters(const Humidity &humidity,
1327 : const Temperature &groundTemperature);
1328 : /** The same setter is available for couples of parameters. The order does not matter */
1329 : bool setBasicAtmosphericParameters(const Temperature &groundTemperature,
1330 : double tropoLapseRate);
1331 : /** The same setter is available for couples of parameters. The order does not matter */
1332 : bool setBasicAtmosphericParameters(double tropoLapseRate,
1333 : const Temperature &groundTemperature);
1334 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1335 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1336 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1337 : bool setBasicAtmosphericParameters(const Temperature &groundTemperature,
1338 : const Length &wvScaleHeight);
1339 : /** The same setter is available for couples of parameters. The order does not matter */
1340 : bool
1341 : setBasicAtmosphericParameters(const Pressure &groundPressure, const Humidity &humidity);
1342 : /** The same setter is available for couples of parameters. The order does not matter */
1343 : bool
1344 : setBasicAtmosphericParameters(const Humidity &humidity, const Pressure &groundPressure);
1345 : /** The same setter is available for couples of parameters. The order does not matter */
1346 : bool setBasicAtmosphericParameters(const Pressure &groundPressure,
1347 : double tropoLapseRate);
1348 : /** The same setter is available for couples of parameters. The order does not matter */
1349 : bool setBasicAtmosphericParameters(double tropoLapseRate,
1350 : const Pressure &groundPressure);
1351 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1352 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1353 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1354 : bool setBasicAtmosphericParameters(const Pressure &groundPressure,
1355 : const Length &wvScaleHeight);
1356 : /** The same setter is available for couples of parameters. The order does not matter */
1357 : bool setBasicAtmosphericParameters(const Humidity &humidity, double tropoLapseRate);
1358 : /** The same setter is available for couples of parameters. The order does not matter */
1359 : bool setBasicAtmosphericParameters(double tropoLapseRate, const Humidity &humidity);
1360 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1361 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1362 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1363 : bool setBasicAtmosphericParameters(const Humidity &humidity, const Length &wvScaleHeight);
1364 : /** The same setter is available for couples of parameters. The order does not matter except for (Length altitude) and
1365 : (Length wvScaleHeight) because they are of the same type (Length). The convention is that if a type Length is in first
1366 : position, it represents the altitude, and if it is in second position, it represents wvScaleHeight */
1367 : bool setBasicAtmosphericParameters(double tropoLapseRate,
1368 : const Length &wvScaleHeight);
1369 :
1370 : /** Setter of new spectral windows (adds frequencies to the SpectralGrid and calculates the corresponding absorption coefficients) */
1371 : void addNewSpectralWindow(unsigned int numChan,
1372 : unsigned int refChan,
1373 : const Frequency &refFreq,
1374 : const Frequency &chanSep)
1375 : {
1376 : RefractiveIndexProfile::add(numChan, refChan, refFreq, chanSep);
1377 : }
1378 : /** Setter of new spectral windows (adds frequencies to the SpectralGrid and calculates the corresponding absorption coefficients) */
1379 : void addNewSpectralWindow(unsigned int numChan,
1380 : unsigned int refChan,
1381 : double* chanFreq,
1382 : Frequency::Units freqUnits)
1383 : {
1384 : RefractiveIndexProfile::add(numChan, refChan, chanFreq, freqUnits);
1385 : }
1386 : /** Setter of new spectral windows (adds frequencies to the SpectralGrid and calculates the corresponding absorption coefficients) */
1387 : void addNewSpectralWindow(unsigned int numChan,
1388 : double refFreq,
1389 : double* chanFreq,
1390 : Frequency::Units freqUnits)
1391 : {
1392 : RefractiveIndexProfile::add(numChan, refFreq, chanFreq, freqUnits);
1393 : }
1394 : /** Setter of new spectral windows (adds frequencies to the SpectralGrid and calculates the corresponding absorption coefficients) */
1395 : void addNewSpectralWindow(unsigned int numChan,
1396 : double refFreq,
1397 : const vector<double> &chanFreq,
1398 : Frequency::Units freqUnits)
1399 : {
1400 : RefractiveIndexProfile::add(numChan, refFreq, chanFreq, freqUnits);
1401 : }
1402 : /** Setter of new spectral windows (adds frequencies to the SpectralGrid and calculates the corresponding absorption coefficients) */
1403 : void addNewSpectralWindow(unsigned int numChan,
1404 : unsigned int refChan,
1405 : const Frequency &refFreq,
1406 : const Frequency &chanSep,
1407 : const Frequency &intermediateFreq,
1408 : const SidebandSide &sbSide,
1409 : const SidebandType &sbType)
1410 : {
1411 : RefractiveIndexProfile::add(numChan,
1412 : refChan,
1413 : refFreq,
1414 : chanSep,
1415 : intermediateFreq,
1416 : sbSide,
1417 : sbType);
1418 : }
1419 : void addNewSpectralWindow(const vector<Frequency> &chanFreq)
1420 : {
1421 : RefractiveIndexProfile::add(chanFreq);
1422 : }
1423 :
1424 : /** Zenith Water Vapor column retrieval based on fitting the vector of zenith atmospheric transmission given as input.
1425 : Requirements: A) The FTS individual frequencies must be in spectral window 0, and B) the input zenith atmospheric
1426 : transmission vector should match those frequencies (i.e. both vectors should have the same size),
1427 : C) the air mass for the retrieval is the current one. If a different one is desired, it should be
1428 : changed using the setAirMass setter. */
1429 : Length WaterVaporRetrieval_fromFTS(const vector<double> &v_transmission)
1430 : {
1431 : unsigned int spwId = 0;
1432 : Frequency f1(-999, Frequency::UnitGigaHertz);
1433 : Frequency f2(-999, Frequency::UnitGigaHertz);
1434 : return WaterVaporRetrieval_fromFTS(spwId, v_transmission, f1, f2);
1435 : }
1436 : /** Same as above but using for the retrieval only the measurements between frequencies f1 and f2>f1 */
1437 : Length WaterVaporRetrieval_fromFTS(const vector<double> &v_transmission,
1438 : const Frequency &f1,
1439 : const Frequency &f2)
1440 : {
1441 : unsigned int spwId = 0;
1442 : return WaterVaporRetrieval_fromFTS(spwId, v_transmission, f1, f2);
1443 : }
1444 : /** Zenith Water Vapor column retrieval based on fitting the vector of zenith atmospheric transmission given as input.
1445 : Requirements: A) The FTS individual frequencies must be in spectral window spwId, and B) the input zenith atmospheric
1446 : transmission vector should match those frequencies (i.e. both vectors should have the same size),
1447 : C) the air mass for the retrieval is the current one. If a different one is desired, it should be
1448 : changed using the setAirMass setter. */
1449 : Length WaterVaporRetrieval_fromFTS(unsigned int spwId,
1450 : const vector<double> &v_transmission)
1451 : {
1452 : Frequency f1(-999, Frequency::UnitGigaHertz);
1453 : Frequency f2(-999, Frequency::UnitGigaHertz);
1454 : return WaterVaporRetrieval_fromFTS(spwId, v_transmission, f1, f2);
1455 : }
1456 : /** Same as above but using for the retrieval only the measurements between frequencies f1 and f2>f1 */
1457 : Length WaterVaporRetrieval_fromFTS(unsigned int spwId,
1458 : const vector<double> &v_transmission,
1459 : const Frequency &f1,
1460 : const Frequency &f2);
1461 :
1462 : /** Zenith Water Vapor column retrieval based on fitting measured brightness temperatures of the atmosphere */
1463 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1464 : const vector<Percent> &signalGain,
1465 : const vector<vector<Temperature> > &vv_tebb,
1466 : const vector<vector<double> > &spwId_filters,
1467 : double airmass,
1468 : const vector<double> &skycoupling,
1469 : const vector<Temperature> &tspill);
1470 :
1471 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1472 : const vector<Percent> &signalGain,
1473 : const vector<Temperature> &v_tebb,
1474 : const vector<vector<double> > &spwId_filters,
1475 : double airmass,
1476 : const vector<double> &skycoupling,
1477 : const vector<Temperature> &tspill);
1478 :
1479 : /* to implement in .cpp
1480 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1481 : Percent signalGain,
1482 : Temperature tebb,
1483 : vector<double> spwId_filter,
1484 : double airmass,
1485 : double skycoupling,
1486 : Temperature tspill); */
1487 :
1488 :
1489 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1490 : const Percent &signalGain,
1491 : const vector<Temperature> &v_tebb,
1492 : const vector<double> &spwId_filter,
1493 : double airmass,
1494 : double skycoupling,
1495 : const Temperature &tspill);
1496 :
1497 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1498 : const Percent &signalGain,
1499 : const vector<Temperature> &v_tebb,
1500 : const vector<vector<double> > &spwId_filters,
1501 : double airmass,
1502 : double skycoupling,
1503 : const Temperature &tspill);
1504 :
1505 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1506 : const Percent &signalGain,
1507 : const vector<Temperature> &v_tebb,
1508 : double airmass,
1509 : double skycoupling,
1510 : const Temperature &tspill); // equivalent eliminating the vectors already implemented, see below
1511 :
1512 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1513 : const vector<Temperature> &v_tebb,
1514 : double skycoupling,
1515 : const Temperature &tspill);
1516 :
1517 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1518 : const vector<vector<Temperature> > &vv_tebb,
1519 : const vector<double> &skycoupling,
1520 : const vector<Temperature> &tspill);
1521 :
1522 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1523 : const vector<Temperature> &v_tebb,
1524 : const vector<double> &skycoupling,
1525 : const vector<Temperature> &tspill);
1526 :
1527 : /* to be implemented in the .cpp
1528 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1529 : Temperature tebb,
1530 : double skycoupling,
1531 : Temperature tspill); */
1532 :
1533 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1534 : const vector<Temperature> &v_tebb,
1535 : const vector<double> &spwId_filter,
1536 : double skycoupling,
1537 : const Temperature &tspill);
1538 :
1539 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1540 : const vector<vector<Temperature> > &vv_tebb,
1541 : const vector<vector<double> > &spwId_filters,
1542 : const vector<double> &skycoupling,
1543 : const vector<Temperature> &tspill);
1544 :
1545 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1546 : const vector<Temperature> &v_tebb,
1547 : const vector<vector<double> > &spwId_filters,
1548 : const vector<double> &skycoupling,
1549 : const vector<Temperature> &tspill);
1550 :
1551 : /* to be implemented in the .cpp
1552 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1553 : Temperature tebb,
1554 : vector<double> spwId_filters,
1555 : double skycoupling,
1556 : Temperature tspill); */
1557 :
1558 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1559 : const vector<Temperature> &v_tebb,
1560 : double airmass,
1561 : double skycoupling,
1562 : const Temperature &tspill);
1563 :
1564 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1565 : const vector<vector<Temperature> > &vv_tebb,
1566 : double airmass,
1567 : const vector<double> &skycoupling,
1568 : const vector<Temperature> &tspill);
1569 :
1570 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1571 : const vector<Temperature> &v_tebb,
1572 : double airmass,
1573 : const vector<double> &skycoupling,
1574 : const vector<Temperature> &tspill);
1575 :
1576 : /* to be implemented in the .cpp
1577 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1578 : const Temperature &tebb,
1579 : double airmass,
1580 : double skycoupling,
1581 : const Temperature &tspill); */
1582 :
1583 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1584 : const vector<Temperature> &v_tebb,
1585 : const vector<double> &spwId_filter,
1586 : double airmass,
1587 : double skycoupling,
1588 : const Temperature &tspill);
1589 :
1590 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1591 : const vector<vector<Temperature> > &vv_tebb,
1592 : const vector<vector<double> > &spwId_filters,
1593 : double airmass,
1594 : const vector<double> &skycoupling,
1595 : const vector<Temperature> &tspill);
1596 :
1597 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1598 : const vector<Temperature> &v_tebb,
1599 : const vector<vector<double> > &spwId_filters,
1600 : double airmass,
1601 : const vector<double> &skycoupling,
1602 : const vector<Temperature> &tspill);
1603 :
1604 : /* to be implemented in the .cpp
1605 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1606 : const Temperature &v_tebb,
1607 : const vector<double> &spwId_filter,
1608 : double airmass,
1609 : double skycoupling,
1610 : const Temperature &tspill); */
1611 :
1612 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1613 : const Percent &signalGain,
1614 : const vector<Temperature> &v_tebb,
1615 : double skycoupling,
1616 : const Temperature &tspill);
1617 :
1618 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1619 : const vector<Percent> &signalGain,
1620 : const vector<vector<Temperature> > &vv_tebb,
1621 : const vector<double> &skycoupling,
1622 : const vector<Temperature> &tspill);
1623 :
1624 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1625 : const vector<Percent> &signalGain,
1626 : const vector<Temperature> &v_tebb,
1627 : const vector<double> &skycoupling,
1628 : const vector<Temperature> &tspill);
1629 :
1630 : /* to be implemented in the .cpp
1631 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1632 : const Percent &signalGain,
1633 : constr Temperature &v_tebb,
1634 : double skycoupling,
1635 : const Temperature &tspill); */
1636 :
1637 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1638 : const Percent &signalGain,
1639 : const vector<Temperature> &v_tebb,
1640 : const vector<double> &spwId_filter,
1641 : double skycoupling,
1642 : const Temperature &tspill);
1643 :
1644 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1645 : const vector<Percent> &signalGain,
1646 : const vector<vector<Temperature> > &vv_tebb,
1647 : const vector<vector<double> > &spwId_filters,
1648 : const vector<double> &skycoupling,
1649 : const vector<Temperature> &tspill);
1650 :
1651 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1652 : const vector<Percent> &signalGain,
1653 : const vector<Temperature> &v_tebb,
1654 : const vector<vector<double> > &spwId_filters,
1655 : const vector<double> &skycoupling,
1656 : const vector<Temperature> &tspill);
1657 :
1658 : /* to be implemented in the .cpp
1659 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1660 : const Percent &signalGain,
1661 : const Temperature &v_tebb,
1662 : const vector<double> &spwId_filter,
1663 : double skycoupling,
1664 : const Temperature &tspill); */
1665 :
1666 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1667 : const Percent &signalGain,
1668 : const vector<Temperature> &v_tebb,
1669 : double airmass,
1670 : double skycoupling,
1671 : const Temperature &tspill);
1672 :
1673 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1674 : const vector<Percent> &signalGain,
1675 : const vector<vector<Temperature> > &vv_tebb,
1676 : double airmass,
1677 : const vector<double> &skycoupling,
1678 : const vector<Temperature> &tspill);
1679 :
1680 : Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1681 : const vector<Percent> &signalGain,
1682 : const vector<Temperature> &v_tebb,
1683 : double airmass,
1684 : const vector<double> &skycoupling,
1685 : const vector<Temperature> &tspill);
1686 :
1687 : // implemented 17/9/09
1688 : Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
1689 : const Percent &signalGain,
1690 : const Temperature &tebb,
1691 : double airmass,
1692 : double skycoupling,
1693 : const Temperature &tspill);
1694 :
1695 : double SkyCouplingRetrieval_fromTEBB(unsigned int spwId,
1696 : const vector<Temperature> &v_tebb,
1697 : double skycoupling,
1698 : const Temperature &tspill);
1699 :
1700 : double SkyCouplingRetrieval_fromTEBB(unsigned int spwId,
1701 : const vector<Temperature> &v_tebb,
1702 : const vector<double> &spwId_filter,
1703 : double skycoupling,
1704 : const Temperature &tspill);
1705 :
1706 : double SkyCouplingRetrieval_fromTEBB(unsigned int spwId,
1707 : const vector<Temperature> &v_tebb,
1708 : double airmass,
1709 : double skycoupling,
1710 : const Temperature &tspill);
1711 :
1712 : double SkyCouplingRetrieval_fromTEBB(unsigned int spwId,
1713 : const vector<Temperature> &v_tebb,
1714 : const vector<double> &spwId_filter,
1715 : double airmass,
1716 : double skycoupling,
1717 : const Temperature &tspill);
1718 :
1719 : /** (Re)setter of water vapor radiometer channels */
1720 : void setWaterVaporRadiometer(const WaterVaporRadiometer &waterVaporRadiometer)
1721 : {
1722 : waterVaporRadiometer_ = waterVaporRadiometer;
1723 : }
1724 : /** Performs a sky coupling retrieval using WVR measurement sets between n and m
1725 : (obtains the ratio between the current sky couplings of all WVR channels and the best fit that
1726 : results from WVR measurement sets between n and m, keeping the other parameters unchanged)
1727 : and uses the result to update the Skycoupling of all WVR channels */
1728 : void updateSkyCoupling_fromWVR(vector<WVRMeasurement> &RadiometerData,
1729 : unsigned int n,
1730 : unsigned int m);
1731 : /** Performs a sky coupling retrieval using WVR measurement sets between n and m
1732 : (obtains the ratio between the current sky coupling of a single WVR channel (ichan) and the best fit that
1733 : results from WVR measurement sets between n and m, keeping the other parameters unchanged)
1734 : and uses the result to update the Skycoupling of than WVR channel */
1735 : void updateSkyCouplingChannel_fromWVR(vector<WVRMeasurement> &RadiometerData,
1736 : unsigned int ichan,
1737 : unsigned int n,
1738 : unsigned int m);
1739 : void updateSkyCoupling_fromWVR(vector<WVRMeasurement> &RadiometerData,
1740 : unsigned int n)
1741 : {
1742 : updateSkyCoupling_fromWVR(RadiometerData, n, n + 1);
1743 : }
1744 : void updateSkyCoupling_fromWVR(vector<WVRMeasurement> &RadiometerData,
1745 : unsigned int n,
1746 : unsigned int m,
1747 : WaterVaporRadiometer &external_wvr)
1748 : {
1749 : updateSkyCoupling_fromWVR(RadiometerData, n, m);
1750 : external_wvr = waterVaporRadiometer_;
1751 : }
1752 : void updateSkyCoupling_fromWVR(vector<WVRMeasurement> &RadiometerData,
1753 : unsigned int n,
1754 : WaterVaporRadiometer &external_wvr)
1755 : {
1756 : updateSkyCoupling_fromWVR(RadiometerData, n, n + 1);
1757 : external_wvr = waterVaporRadiometer_;
1758 : }
1759 : /** Accessor to the sky coupling of channel n of the Water Vapor Radiometer*/
1760 : double getWaterVaporRadiometerSkyCoupling(int n) const
1761 : {
1762 : return waterVaporRadiometer_.getSkyCoupling()[n];
1763 : }
1764 : /** Accessor to the sky coupling of channel n of the Water Vapor Radiometer*/
1765 : Percent getWaterVaporRadiometerSignalGain(int n) const
1766 : {
1767 : return waterVaporRadiometer_.getsignalGain()[n];
1768 : }
1769 : /** Performs water vapor retrieval for WVR measurement sets between n and m */
1770 : void WaterVaporRetrieval_fromWVR(vector<WVRMeasurement> &RadiometerData,
1771 : unsigned int n,
1772 : unsigned int m);
1773 : void WaterVaporRetrieval_fromWVR(vector<WVRMeasurement> &RadiometerData,
1774 : unsigned int n)
1775 : {
1776 : WaterVaporRetrieval_fromWVR(RadiometerData, n, n + 1);
1777 : }
1778 : /** Performs water vapor retrieval for one WVR measurement */
1779 : void WaterVaporRetrieval_fromWVR(WVRMeasurement &RadiometerData);
1780 : /** Accessor to get or check the water vapor radiometer channels */
1781 : WaterVaporRadiometer getWaterVaporRadiometer() const
1782 : {
1783 : return waterVaporRadiometer_;
1784 : }
1785 :
1786 : double
1787 : sigmaSkyCouplingRetrieval_fromWVR(double par_fit,
1788 : const WaterVaporRadiometer &wvr,
1789 : vector<WVRMeasurement> &RadiometerData,
1790 : unsigned int n,
1791 : unsigned int m);
1792 : double sigmaSkyCouplingRetrieval_fromWVR(double par_fit,
1793 : const WaterVaporRadiometer &wvr,
1794 : vector<WVRMeasurement> &RadiometerData,
1795 : unsigned int n)
1796 : {
1797 : return sigmaSkyCouplingRetrieval_fromWVR(par_fit, wvr, RadiometerData, n, n
1798 : + 1);
1799 : }
1800 :
1801 : /*
1802 : return the rms of the residuals for one channel ichan, as a function of the multiplicative
1803 : factor par_fit to this channel's coupling efficiency.
1804 : */
1805 : double sigmaSkyCouplingChannelRetrieval_fromWVR(double par_fit,
1806 : const WaterVaporRadiometer &wvr,
1807 : vector<WVRMeasurement> &RadiometerData,
1808 : unsigned int ichan,
1809 : unsigned int n,
1810 : unsigned int m);
1811 : Temperature getWVRAverageSigmaTskyFit(const vector<WVRMeasurement> &RadiometerData,
1812 : unsigned int n,
1813 : unsigned int m);
1814 : Temperature getWVRAverageSigmaTskyFit(const vector<WVRMeasurement> &RadiometerData,
1815 : unsigned int n)
1816 : {
1817 : return getWVRAverageSigmaTskyFit(RadiometerData, n, n + 1);
1818 : }
1819 : /*
1820 : return the rms of fit residual for a single channel, in a measurement
1821 : */
1822 : Temperature getWVRSigmaChannelTskyFit(const vector<WVRMeasurement> &RadiometerData,
1823 : unsigned int ichan,
1824 : unsigned int n,
1825 : unsigned int m);
1826 : /*
1827 : return the rms of water vapor retrieved values in a measurnment (n to m)
1828 : */
1829 : double getSigmaTransmissionFit(unsigned int spwId,
1830 : const vector<double> &v_transmission,
1831 : double airm,
1832 : const Frequency &f1,
1833 : const Frequency &f2);
1834 : //double getSigmaTransmissionFit(){}
1835 : Temperature getSigmaFit(unsigned int spwId,
1836 : const vector<Temperature> &v_tebbspec,
1837 : double skyCoupling,
1838 : const Temperature &Tspill)
1839 : {
1840 : return getSigmaFit(spwId, v_tebbspec, getUserWH2O(), skyCoupling, Tspill);
1841 : }
1842 : Temperature getSigmaFit(unsigned int spwId,
1843 : const vector<Temperature> &v_tebbspec,
1844 : const Length &wh2o,
1845 : double skyCoupling,
1846 : const Temperature &Tspill)
1847 : {
1848 : return getSigmaFit(spwId,
1849 : v_tebbspec,
1850 : wh2o,
1851 : getAirMass(),
1852 : skyCoupling,
1853 : Tspill);
1854 : }
1855 : Temperature getSigmaFit(unsigned int spwId,
1856 : const vector<Temperature> &v_tebbspec,
1857 : double airmass,
1858 : double skyCoupling,
1859 : const Temperature &Tspill)
1860 : {
1861 : return getSigmaFit(spwId,
1862 : v_tebbspec,
1863 : getUserWH2O(),
1864 : airmass,
1865 : skyCoupling,
1866 : Tspill);
1867 : }
1868 : Temperature getSigmaFit(unsigned int spwId,
1869 : const vector<Temperature> &v_tebbspec,
1870 : const Length &wh2o,
1871 : double airmass,
1872 : double skyCoupling,
1873 : const Temperature &Tspill);
1874 :
1875 : //@}
1876 :
1877 : protected:
1878 :
1879 : double airMass_; //!< Air Mass used for the radiative transfer
1880 : Temperature skyBackgroundTemperature_; //!< Blackbody temperature of the sky background
1881 : Length wh2o_user_; //!< Water vapor column used for radiative transfer calculations. If not provided,
1882 : //!< the one retrieved from the water vapor radiometer channels will be used.
1883 : WaterVaporRadiometer waterVaporRadiometer_; // !< Identifiers, sky coupling, and sideband gain of channels corresponding to the water vapor radiometer.
1884 :
1885 :
1886 : void iniSkyStatus(); //!< Basic Method initialize the class when using the constructors.
1887 : bool updateProfilesAndRadiance(const Length &altitude,
1888 : const Pressure &groundPressure,
1889 : const Temperature &groundTemperature,
1890 : double tropoLapseRate,
1891 : const Humidity &relativeHumidity,
1892 : const Length &wvScaleHeight);
1893 : void rmSkyStatus(); //!< Resets retrieved water column to zero, or the default value.
1894 :
1895 : Length mkWaterVaporRetrieval_fromFTS(unsigned int spwId,
1896 : const vector<double> &v_transmission,
1897 : //double airm, // unused parameter
1898 : const Frequency &f1,
1899 : const Frequency &f2);
1900 :
1901 0 : Length mkWaterVaporRetrieval_fromTEBB(unsigned int spwId,
1902 : const Percent &signalGain,
1903 : const vector<Temperature> &v_measuredSkyTEBB,
1904 : double airm,
1905 : const vector<double> &spwId_filter,
1906 : double skycoupling,
1907 : const Temperature &tspill)
1908 : {
1909 : return mkWaterVaporRetrieval_fromTEBB(
1910 0 : vector<unsigned int>(1, spwId),
1911 0 : vector<Percent>(1, signalGain),
1912 0 : vector<vector<Temperature> >(1, v_measuredSkyTEBB),
1913 : airm,
1914 0 : vector<vector<double> >(1, spwId_filter),
1915 0 : vector<double>(1, skycoupling),
1916 0 : vector<Temperature>(1, tspill));
1917 : }
1918 :
1919 : Length
1920 : mkWaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1921 : const vector<Percent> &signalGain,
1922 : const vector<vector<Temperature> > &measuredSkyTEBB,
1923 : double airm,
1924 : const vector<vector<double> > &spwId_filters,
1925 : const vector<double> &skycoupling,
1926 : const vector<Temperature> &tspill);
1927 :
1928 : Length
1929 : mkWaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
1930 : const vector<Percent> &signalGain,
1931 : const vector<Temperature> &measuredAverageSkyTEBB,
1932 : double airm,
1933 : const vector<vector<double> > &spwId_filters,
1934 : const vector<double> &skycoupling,
1935 : const vector<Temperature> &tspill);
1936 :
1937 : double mkSkyCouplingRetrieval_fromTEBB(unsigned int spwId,
1938 : const Percent &signalGain,
1939 : const vector<Temperature> &measuredSkyTEBB,
1940 : double airm,
1941 : const vector<double> &spwId_filter,
1942 : double skycoupling,
1943 : const Temperature &tspill);
1944 :
1945 : WVRMeasurement
1946 : mkWaterVaporRetrieval_fromWVR(const vector<Temperature> &measuredSkyBrightnessVector,
1947 : const vector<unsigned int> &radiometricChannels,
1948 : const vector<double> &skyCoupling,
1949 : const vector<Percent> &signalGain,
1950 : const Temperature &spilloverTemperature,
1951 : const Angle &elevation);
1952 :
1953 : double RT(double pfit_wh2o,
1954 : double skycoupling,
1955 : double tspill,
1956 : unsigned int spwid,
1957 : unsigned int nc)
1958 : {
1959 : return RT(pfit_wh2o, skycoupling, tspill, airMass_, spwid, nc);
1960 : }
1961 : double RT(double pfit_wh2o,
1962 : double skycoupling,
1963 : double tspill,
1964 : unsigned int spwid)
1965 : {
1966 : return RT(pfit_wh2o, skycoupling, tspill, airMass_, spwid);
1967 : }
1968 : double RT(double pfit_wh2o,
1969 : double skycoupling,
1970 : double tspill,
1971 : double airmass,
1972 : unsigned int spwId,
1973 : unsigned int nc);
1974 :
1975 0 : double RT(double pfit_wh2o,
1976 : double skycoupling,
1977 : double tspill,
1978 : double airmass,
1979 : unsigned int spwid)
1980 : {
1981 0 : double tebb_channel = 0.0;
1982 0 : for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
1983 0 : tebb_channel = tebb_channel + RT(pfit_wh2o,
1984 : skycoupling,
1985 : tspill,
1986 : airmass,
1987 : spwid,
1988 0 : n) / (v_numChan_[spwid]);
1989 : }
1990 0 : return tebb_channel;
1991 : }
1992 :
1993 : double RT(double pfit_wh2o,
1994 : double skycoupling,
1995 : double tspill,
1996 : unsigned int spwid,
1997 : const Percent &signalgain)
1998 : {
1999 : vector<double> spwId_filter;
2000 : for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
2001 : spwId_filter.push_back(1.0);
2002 : }
2003 : return RT(pfit_wh2o,
2004 : skycoupling,
2005 : tspill,
2006 : airMass_,
2007 : spwid,
2008 : spwId_filter,
2009 : signalgain);
2010 : }
2011 :
2012 0 : double RT(double pfit_wh2o,
2013 : double skycoupling,
2014 : double tspill,
2015 : double airmass,
2016 : unsigned int spwid,
2017 : const Percent &signalgain)
2018 : {
2019 0 : vector<double> spwId_filter;
2020 0 : for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
2021 0 : spwId_filter.push_back(1.0);
2022 : }
2023 0 : return RT(pfit_wh2o,
2024 : skycoupling,
2025 : tspill,
2026 : airmass,
2027 : spwid,
2028 : spwId_filter,
2029 0 : signalgain);
2030 0 : }
2031 :
2032 : double RT(double pfit_wh2o,
2033 : double skycoupling,
2034 : double tspill,
2035 : unsigned int spwid,
2036 : const vector<double> &spwId_filter)
2037 : {
2038 : return RT(pfit_wh2o,
2039 : skycoupling,
2040 : tspill,
2041 : airMass_,
2042 : spwid,
2043 : spwId_filter,
2044 : Percent(100.0, Percent::UnitPercent));
2045 : }
2046 :
2047 : double RT(double pfit_wh2o,
2048 : double skycoupling,
2049 : double tspill,
2050 : unsigned int spwid,
2051 : const vector<double> &spwId_filter,
2052 : const Percent &signalgain)
2053 : {
2054 : return RT(pfit_wh2o,
2055 : skycoupling,
2056 : tspill,
2057 : airMass_,
2058 : spwid,
2059 : spwId_filter,
2060 : signalgain);
2061 : }
2062 :
2063 : double RT(double pfit_wh2o,
2064 : double skycoupling,
2065 : double tspill,
2066 : double airmass,
2067 : unsigned int spwid,
2068 : const vector<double> &spwId_filter,
2069 : const Percent &signalgain);
2070 :
2071 :
2072 : double RTRJ(double pfit_wh2o,
2073 : double skycoupling,
2074 : double tspill,
2075 : unsigned int spwid,
2076 : unsigned int nc)
2077 : {
2078 : return RTRJ(pfit_wh2o, skycoupling, tspill, airMass_, spwid, nc);
2079 : }
2080 : double RTRJ(double pfit_wh2o,
2081 : double skycoupling,
2082 : double tspill,
2083 : unsigned int spwid)
2084 : {
2085 : return RTRJ(pfit_wh2o, skycoupling, tspill, airMass_, spwid);
2086 : }
2087 : double RTRJ(double pfit_wh2o,
2088 : double skycoupling,
2089 : double tspill,
2090 : double airmass,
2091 : unsigned int spwId,
2092 : unsigned int nc);
2093 :
2094 0 : double RTRJ(double pfit_wh2o,
2095 : double skycoupling,
2096 : double tspill,
2097 : double airmass,
2098 : unsigned int spwid)
2099 : {
2100 0 : double trj_channel = 0.0;
2101 0 : for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
2102 0 : trj_channel = trj_channel + RTRJ(pfit_wh2o,
2103 : skycoupling,
2104 : tspill,
2105 : airmass,
2106 : spwid,
2107 0 : n) / (v_numChan_[spwid]);
2108 : }
2109 0 : return trj_channel;
2110 : }
2111 :
2112 : double RTRJ(double pfit_wh2o,
2113 : double skycoupling,
2114 : double tspill,
2115 : unsigned int spwid,
2116 : const Percent &signalgain)
2117 : {
2118 : vector<double> spwId_filter;
2119 : for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
2120 : spwId_filter.push_back(1.0);
2121 : }
2122 : return RTRJ(pfit_wh2o,
2123 : skycoupling,
2124 : tspill,
2125 : airMass_,
2126 : spwid,
2127 : spwId_filter,
2128 : signalgain);
2129 : }
2130 :
2131 : double RTRJ(double pfit_wh2o,
2132 : double skycoupling,
2133 : double tspill,
2134 : double airmass,
2135 : unsigned int spwid,
2136 : const Percent &signalgain)
2137 : {
2138 : vector<double> spwId_filter;
2139 : for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
2140 : spwId_filter.push_back(1.0);
2141 : }
2142 : return RTRJ(pfit_wh2o,
2143 : skycoupling,
2144 : tspill,
2145 : airmass,
2146 : spwid,
2147 : spwId_filter,
2148 : signalgain);
2149 : }
2150 :
2151 : double RTRJ(double pfit_wh2o,
2152 : double skycoupling,
2153 : double tspill,
2154 : unsigned int spwid,
2155 : const vector<double> &spwId_filter)
2156 : {
2157 : return RTRJ(pfit_wh2o,
2158 : skycoupling,
2159 : tspill,
2160 : airMass_,
2161 : spwid,
2162 : spwId_filter,
2163 : Percent(100.0, Percent::UnitPercent));
2164 : }
2165 :
2166 : double RTRJ(double pfit_wh2o,
2167 : double skycoupling,
2168 : double tspill,
2169 : unsigned int spwid,
2170 : const vector<double> &spwId_filter,
2171 : const Percent &signalgain)
2172 : {
2173 : return RTRJ(pfit_wh2o,
2174 : skycoupling,
2175 : tspill,
2176 : airMass_,
2177 : spwid,
2178 : spwId_filter,
2179 : signalgain);
2180 : }
2181 :
2182 : double RTRJ(double pfit_wh2o,
2183 : double skycoupling,
2184 : double tspill,
2185 : double airmass,
2186 : unsigned int spwid,
2187 : const vector<double> &spwId_filter,
2188 : const Percent &signalgain);
2189 :
2190 :
2191 : private:
2192 :
2193 : // no accessors provided for these
2194 : double sigma_transmission_FTSfit_;
2195 : Temperature sigma_TEBBfit_;
2196 :
2197 : }; // class SkyStatus
2198 :
2199 : ATM_NAMESPACE_END
2200 :
2201 : #endif /*!_ATM_SKYSTATUS_H*/
|
