Line data Source code
1 : /*******************************************************************************
2 : * ALMA - Atacama Large Millimiter Array
3 : * (c) Instituto de Estructura de la Materia, 2009
4 : *
5 : * This library is free software; you can redistribute it and/or
6 : * modify it under the terms of the GNU Lesser General Public
7 : * License as published by the Free Software Foundation; either
8 : * version 2.1 of the License, or (at your option) any later version.
9 : *
10 : * This library is distributed in the hope that it will be useful,
11 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 : * Lesser General Public License for more details.
14 : *
15 : * You should have received a copy of the GNU Lesser General Public
16 : * License along with this library; if not, write to the Free Software
17 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 : *
19 : * "@(#) $Id: ATMRefractiveIndexProfile.cpp Exp $"
20 : *
21 : * who when what
22 : * -------- -------- ----------------------------------------------
23 : * pardo 24/03/09 created
24 : */
25 :
26 : #include "ATMRefractiveIndexProfile.h"
27 :
28 : #include <iostream>
29 : #include <math.h>
30 : #include <string>
31 : #include <vector>
32 :
33 :
34 :
35 : ATM_NAMESPACE_BEGIN
36 :
37 : // Constructors
38 :
39 1 : RefractiveIndexProfile::RefractiveIndexProfile(const Frequency &freq,
40 1 : const AtmProfile &atmProfile) :
41 1 : AtmProfile(atmProfile), SpectralGrid(freq)
42 : {
43 1 : mkRefractiveIndexProfile();
44 1 : }
45 :
46 101 : RefractiveIndexProfile::RefractiveIndexProfile(const SpectralGrid &spectralGrid,
47 101 : const AtmProfile &atmProfile) :
48 101 : AtmProfile(atmProfile), SpectralGrid(spectralGrid)
49 : {
50 101 : mkRefractiveIndexProfile();
51 101 : }
52 :
53 100 : RefractiveIndexProfile::RefractiveIndexProfile(const RefractiveIndexProfile & a) : AtmProfile(a), SpectralGrid(a)
54 : {
55 : // std::cout<<"Enter RefractiveIndexProfile copy constructor version Fri May 20 00:59:47 CEST 2005"<<endl;
56 :
57 : // level AtmProfile
58 :
59 : // type_ = a.type_;
60 : // prLimit_ = a.prLimit_;
61 : /*
62 : v_hx_.reserve(a.v_hx_.size());
63 : v_px_.reserve(a.v_px_.size());
64 : v_tx_.reserve(a.v_tx_.size());
65 : for(unsigned int n=0; n<a.v_hx_.size(); n++){
66 : v_hx_.push_back(a.v_hx_[n]);
67 : v_px_.push_back(a.v_px_[n]);
68 : v_tx_.push_back(a.v_tx_[n]);
69 : }
70 : */
71 :
72 100 : typeAtm_ = a.typeAtm_;
73 100 : groundTemperature_ = a.groundTemperature_;
74 100 : tropoLapseRate_ = a.tropoLapseRate_;
75 100 : groundPressure_ = a.groundPressure_;
76 100 : relativeHumidity_ = a.relativeHumidity_;
77 100 : wvScaleHeight_ = a.wvScaleHeight_;
78 100 : pressureStep_ = a.pressureStep_;
79 100 : pressureStepFactor_ = a.pressureStepFactor_;
80 100 : altitude_ = a.altitude_;
81 100 : topAtmProfile_ = a.topAtmProfile_;
82 100 : numLayer_ = a.numLayer_;
83 100 : newBasicParam_ = a.newBasicParam_;
84 :
85 : // copy thresholds
86 100 : altitudeThreshold_ = a.altitudeThreshold_;
87 100 : groundPressureThreshold_ = a.groundPressureThreshold_;
88 100 : groundTemperatureThreshold_ = a.groundTemperatureThreshold_;
89 100 : tropoLapseRateThreshold_ = a.tropoLapseRateThreshold_;
90 100 : relativeHumidityThreshold_ = a.relativeHumidityThreshold_;
91 100 : wvScaleHeightThreshold_ = a.wvScaleHeightThreshold_;
92 :
93 100 : v_layerThickness_.reserve(numLayer_);
94 100 : v_layerTemperature_.reserve(numLayer_);
95 100 : v_layerWaterVapor_.reserve(numLayer_);
96 100 : v_layerCO_.reserve(numLayer_);
97 100 : v_layerO3_.reserve(numLayer_);
98 100 : v_layerN2O_.reserve(numLayer_);
99 100 : v_layerNO2_.reserve(numLayer_);
100 100 : v_layerSO2_.reserve(numLayer_);
101 100 : v_layerHCl_.reserve(numLayer_);
102 100 : v_layerHCN_.reserve(numLayer_);
103 :
104 :
105 4285 : for(unsigned int n = 0; n < numLayer_; n++) {
106 4185 : v_layerThickness_.push_back(a.v_layerThickness_[n]);
107 4185 : v_layerTemperature_.push_back(a.v_layerTemperature_[n]);
108 : //cout << "n=" << n << std::endl;
109 4185 : v_layerWaterVapor_.push_back(a.v_layerWaterVapor_[n]);
110 4185 : v_layerPressure_.push_back(a.v_layerPressure_[n]);
111 4185 : v_layerCO_.push_back(a.v_layerCO_[n]);
112 4185 : v_layerO3_.push_back(a.v_layerO3_[n]);
113 4185 : v_layerN2O_.push_back(a.v_layerN2O_[n]);
114 4185 : v_layerNO2_.push_back(a.v_layerNO2_[n]);
115 4185 : v_layerSO2_.push_back(a.v_layerSO2_[n]);
116 4185 : v_layerHCl_.push_back(a.v_layerHCl_[n]);
117 4185 : v_layerHCN_.push_back(a.v_layerHCN_[n]);
118 : }
119 :
120 : // level Spectral Grid
121 100 : freqUnits_ = a.freqUnits_;
122 100 : v_chanFreq_ = a.v_chanFreq_;
123 :
124 100 : v_numChan_ = a.v_numChan_;
125 100 : v_refChan_ = a.v_refChan_;
126 100 : v_refFreq_ = a.v_refFreq_;
127 100 : v_chanSep_ = a.v_chanSep_;
128 100 : v_maxFreq_ = a.v_maxFreq_;
129 100 : v_minFreq_ = a.v_minFreq_;
130 100 : v_intermediateFrequency_ = a.v_intermediateFrequency_;
131 100 : v_loFreq_ = a.v_loFreq_;
132 :
133 100 : v_sidebandSide_ = a.v_sidebandSide_;
134 100 : v_sidebandType_ = a.v_sidebandType_;
135 :
136 100 : vv_assocSpwId_ = a.vv_assocSpwId_;
137 100 : vv_assocNature_ = a.vv_assocNature_;
138 :
139 100 : v_transfertId_ = a.v_transfertId_;
140 :
141 : // level Absorption Profile
142 100 : vv_N_H2OLinesPtr_.reserve(a.v_chanFreq_.size());
143 100 : vv_N_HH16OLinesPtr_.reserve(a.v_chanFreq_.size());
144 100 : vv_N_HH16OV2LinesPtr_.reserve(a.v_chanFreq_.size());
145 100 : vv_N_HH17OLinesPtr_.reserve(a.v_chanFreq_.size());
146 100 : vv_N_HH18OLinesPtr_.reserve(a.v_chanFreq_.size());
147 100 : vv_N_HDOLinesPtr_.reserve(a.v_chanFreq_.size());
148 :
149 :
150 100 : vv_N_H2OContPtr_.reserve(a.v_chanFreq_.size());
151 100 : vv_N_O2LinesPtr_.reserve(a.v_chanFreq_.size());
152 100 : vv_N_16O16OLinesPtr_.reserve(a.v_chanFreq_.size());
153 100 : vv_N_16O16OVIBLinesPtr_.reserve(a.v_chanFreq_.size());
154 100 : vv_N_16O18OLinesPtr_.reserve(a.v_chanFreq_.size());
155 100 : vv_N_16O17OLinesPtr_.reserve(a.v_chanFreq_.size());
156 :
157 100 : vv_N_DryContPtr_.reserve(a.v_chanFreq_.size());
158 :
159 100 : vv_N_O3LinesPtr_.reserve(a.v_chanFreq_.size());
160 100 : vv_N_16O16O16OLinesPtr_.reserve(a.v_chanFreq_.size());
161 100 : vv_N_16O16O16OV1LinesPtr_.reserve(a.v_chanFreq_.size());
162 100 : vv_N_16O16O16OV2LinesPtr_.reserve(a.v_chanFreq_.size());
163 100 : vv_N_16O16O16OV3LinesPtr_.reserve(a.v_chanFreq_.size());
164 100 : vv_N_16O16O18OLinesPtr_.reserve(a.v_chanFreq_.size());
165 100 : vv_N_16O16O17OLinesPtr_.reserve(a.v_chanFreq_.size());
166 100 : vv_N_16O18O16OLinesPtr_.reserve(a.v_chanFreq_.size());
167 100 : vv_N_16O17O16OLinesPtr_.reserve(a.v_chanFreq_.size());
168 :
169 100 : vv_N_COLinesPtr_.reserve(a.v_chanFreq_.size());
170 100 : vv_N_N2OLinesPtr_.reserve(a.v_chanFreq_.size());
171 100 : vv_N_NO2LinesPtr_.reserve(a.v_chanFreq_.size());
172 100 : vv_N_SO2LinesPtr_.reserve(a.v_chanFreq_.size());
173 100 : vv_N_HClLinesPtr_.reserve(a.v_chanFreq_.size());
174 100 : vv_N_HCNLinesPtr_.reserve(a.v_chanFreq_.size());
175 :
176 : std::vector<std::complex<double> >* v_N_H2OLinesPtr;
177 : std::vector<std::complex<double> >* v_N_HH16OLinesPtr;
178 : std::vector<std::complex<double> >* v_N_HH16OV2LinesPtr;
179 : std::vector<std::complex<double> >* v_N_HH17OLinesPtr;
180 : std::vector<std::complex<double> >* v_N_HH18OLinesPtr;
181 : std::vector<std::complex<double> >* v_N_HDOLinesPtr;
182 :
183 :
184 : std::vector<std::complex<double> >* v_N_H2OContPtr;
185 : std::vector<std::complex<double> >* v_N_O2LinesPtr;
186 : std::vector<std::complex<double> >* v_N_16O16OLinesPtr;
187 : std::vector<std::complex<double> >* v_N_16O16OVIBLinesPtr;
188 : std::vector<std::complex<double> >* v_N_16O17OLinesPtr;
189 : std::vector<std::complex<double> >* v_N_16O18OLinesPtr;
190 :
191 : std::vector<std::complex<double> >* v_N_DryContPtr;
192 : std::vector<std::complex<double> >* v_N_O3LinesPtr;
193 : std::vector<std::complex<double> >* v_N_16O16O16OLinesPtr;
194 : std::vector<std::complex<double> >* v_N_16O16O16OV1LinesPtr;
195 : std::vector<std::complex<double> >* v_N_16O16O16OV2LinesPtr;
196 : std::vector<std::complex<double> >* v_N_16O16O16OV3LinesPtr;
197 : std::vector<std::complex<double> >* v_N_16O16O17OLinesPtr;
198 : std::vector<std::complex<double> >* v_N_16O16O18OLinesPtr;
199 : std::vector<std::complex<double> >* v_N_16O17O16OLinesPtr;
200 : std::vector<std::complex<double> >* v_N_16O18O16OLinesPtr;
201 : std::vector<std::complex<double> >* v_N_COLinesPtr;
202 : std::vector<std::complex<double> >* v_N_N2OLinesPtr;
203 : std::vector<std::complex<double> >* v_N_NO2LinesPtr;
204 : std::vector<std::complex<double> >* v_N_SO2LinesPtr;
205 : std::vector<std::complex<double> >* v_N_HClLinesPtr;
206 : std::vector<std::complex<double> >* v_N_HCNLinesPtr;
207 :
208 514 : for(unsigned int nc = 0; nc < v_chanFreq_.size(); nc++) {
209 :
210 414 : v_N_H2OLinesPtr = new std::vector<std::complex<double> > ;
211 414 : v_N_H2OLinesPtr->reserve(numLayer_);
212 414 : v_N_HH16OLinesPtr = new std::vector<std::complex<double> > ;
213 414 : v_N_HH16OLinesPtr->reserve(numLayer_);
214 414 : v_N_HH16OV2LinesPtr = new std::vector<std::complex<double> > ;
215 414 : v_N_HH16OV2LinesPtr->reserve(numLayer_);
216 414 : v_N_HH17OLinesPtr = new std::vector<std::complex<double> > ;
217 414 : v_N_HH17OLinesPtr->reserve(numLayer_);
218 414 : v_N_HH18OLinesPtr = new std::vector<std::complex<double> > ;
219 414 : v_N_HH18OLinesPtr->reserve(numLayer_);
220 414 : v_N_HDOLinesPtr = new std::vector<std::complex<double> > ;
221 414 : v_N_HDOLinesPtr->reserve(numLayer_);
222 :
223 :
224 414 : v_N_H2OContPtr = new std::vector<std::complex<double> > ;
225 414 : v_N_H2OContPtr->reserve(numLayer_);
226 414 : v_N_O2LinesPtr = new std::vector<std::complex<double> > ;
227 414 : v_N_O2LinesPtr->reserve(numLayer_);
228 414 : v_N_16O16OLinesPtr = new std::vector<std::complex<double> > ;
229 414 : v_N_16O16OLinesPtr->reserve(numLayer_);
230 414 : v_N_16O16OVIBLinesPtr = new std::vector<std::complex<double> > ;
231 414 : v_N_16O16OVIBLinesPtr->reserve(numLayer_);
232 414 : v_N_16O17OLinesPtr = new std::vector<std::complex<double> > ;
233 414 : v_N_16O17OLinesPtr->reserve(numLayer_);
234 414 : v_N_16O18OLinesPtr = new std::vector<std::complex<double> > ;
235 414 : v_N_16O18OLinesPtr->reserve(numLayer_);
236 :
237 414 : v_N_DryContPtr = new std::vector<std::complex<double> > ;
238 414 : v_N_DryContPtr->reserve(numLayer_);
239 414 : v_N_O3LinesPtr = new std::vector<std::complex<double> > ;
240 414 : v_N_O3LinesPtr->reserve(numLayer_);
241 414 : v_N_16O16O16OLinesPtr = new std::vector<std::complex<double> > ;
242 414 : v_N_16O16O16OLinesPtr->reserve(numLayer_);
243 414 : v_N_16O16O16OV1LinesPtr = new std::vector<std::complex<double> > ;
244 414 : v_N_16O16O16OV1LinesPtr->reserve(numLayer_);
245 414 : v_N_16O16O16OV2LinesPtr = new std::vector<std::complex<double> > ;
246 414 : v_N_16O16O16OV2LinesPtr->reserve(numLayer_);
247 414 : v_N_16O16O16OV3LinesPtr = new std::vector<std::complex<double> > ;
248 414 : v_N_16O16O16OV3LinesPtr->reserve(numLayer_);
249 :
250 414 : v_N_16O16O17OLinesPtr = new std::vector<std::complex<double> > ;
251 414 : v_N_16O16O17OLinesPtr->reserve(numLayer_);
252 414 : v_N_16O16O18OLinesPtr = new std::vector<std::complex<double> > ;
253 414 : v_N_16O16O18OLinesPtr->reserve(numLayer_);
254 414 : v_N_16O17O16OLinesPtr = new std::vector<std::complex<double> > ;
255 414 : v_N_16O17O16OLinesPtr->reserve(numLayer_);
256 414 : v_N_16O18O16OLinesPtr = new std::vector<std::complex<double> > ;
257 414 : v_N_16O18O16OLinesPtr->reserve(numLayer_);
258 414 : v_N_COLinesPtr = new std::vector<std::complex<double> > ;
259 414 : v_N_COLinesPtr->reserve(numLayer_);
260 414 : v_N_N2OLinesPtr = new std::vector<std::complex<double> > ;
261 414 : v_N_N2OLinesPtr->reserve(numLayer_);
262 414 : v_N_NO2LinesPtr = new std::vector<std::complex<double> > ;
263 414 : v_N_NO2LinesPtr->reserve(numLayer_);
264 414 : v_N_SO2LinesPtr = new std::vector<std::complex<double> > ;
265 414 : v_N_SO2LinesPtr->reserve(numLayer_);
266 414 : v_N_HClLinesPtr = new std::vector<std::complex<double> > ;
267 414 : v_N_HClLinesPtr->reserve(numLayer_);
268 414 : v_N_HCNLinesPtr = new std::vector<std::complex<double> > ;
269 414 : v_N_HCNLinesPtr->reserve(numLayer_);
270 :
271 17502 : for(unsigned int n = 0; n < numLayer_; n++) {
272 :
273 : // std::cout << "numLayer_=" << nc << " " << n << std::endl; // COMMENTED OUT BY JUAN MAY/16/2005
274 :
275 17088 : v_N_H2OLinesPtr->push_back(a.vv_N_H2OLinesPtr_[nc]->at(n));
276 17088 : v_N_HH16OLinesPtr->push_back(a.vv_N_HH16OLinesPtr_[nc]->at(n));
277 17088 : v_N_HH16OV2LinesPtr->push_back(a.vv_N_HH16OV2LinesPtr_[nc]->at(n));
278 17088 : v_N_HH17OLinesPtr->push_back(a.vv_N_HH17OLinesPtr_[nc]->at(n));
279 17088 : v_N_HH18OLinesPtr->push_back(a.vv_N_HH18OLinesPtr_[nc]->at(n));
280 17088 : v_N_HDOLinesPtr->push_back(a.vv_N_HDOLinesPtr_[nc]->at(n));
281 :
282 :
283 17088 : v_N_H2OContPtr->push_back(a.vv_N_H2OContPtr_[nc]->at(n));
284 17088 : v_N_O2LinesPtr->push_back(a.vv_N_O2LinesPtr_[nc]->at(n));
285 17088 : v_N_16O16OLinesPtr->push_back(a.vv_N_16O16OLinesPtr_[nc]->at(n));
286 17088 : v_N_16O16OVIBLinesPtr->push_back(a.vv_N_16O16OVIBLinesPtr_[nc]->at(n));
287 17088 : v_N_16O18OLinesPtr->push_back(a.vv_N_16O18OLinesPtr_[nc]->at(n));
288 17088 : v_N_16O17OLinesPtr->push_back(a.vv_N_16O17OLinesPtr_[nc]->at(n));
289 :
290 :
291 :
292 17088 : v_N_DryContPtr->push_back(a.vv_N_DryContPtr_[nc]->at(n));
293 17088 : v_N_O3LinesPtr->push_back(a.vv_N_O3LinesPtr_[nc]->at(n));
294 17088 : v_N_16O16O16OLinesPtr->push_back(a.vv_N_16O16O16OLinesPtr_[nc]->at(n));
295 17088 : v_N_16O16O16OV1LinesPtr->push_back(a.vv_N_16O16O16OV1LinesPtr_[nc]->at(n));
296 17088 : v_N_16O16O16OV2LinesPtr->push_back(a.vv_N_16O16O16OV2LinesPtr_[nc]->at(n));
297 17088 : v_N_16O16O16OV3LinesPtr->push_back(a.vv_N_16O16O16OV3LinesPtr_[nc]->at(n));
298 17088 : v_N_16O16O17OLinesPtr->push_back(a.vv_N_16O16O17OLinesPtr_[nc]->at(n));
299 17088 : v_N_16O16O18OLinesPtr->push_back(a.vv_N_16O16O18OLinesPtr_[nc]->at(n));
300 17088 : v_N_16O17O16OLinesPtr->push_back(a.vv_N_16O17O16OLinesPtr_[nc]->at(n));
301 17088 : v_N_16O18O16OLinesPtr->push_back(a.vv_N_16O18O16OLinesPtr_[nc]->at(n));
302 17088 : v_N_COLinesPtr->push_back(a.vv_N_COLinesPtr_[nc]->at(n));
303 17088 : v_N_N2OLinesPtr->push_back(a.vv_N_N2OLinesPtr_[nc]->at(n));
304 17088 : v_N_NO2LinesPtr->push_back(a.vv_N_NO2LinesPtr_[nc]->at(n));
305 17088 : v_N_SO2LinesPtr->push_back(a.vv_N_SO2LinesPtr_[nc]->at(n));
306 17088 : v_N_HClLinesPtr->push_back(a.vv_N_HClLinesPtr_[nc]->at(n));
307 17088 : v_N_HCNLinesPtr->push_back(a.vv_N_HCNLinesPtr_[nc]->at(n));
308 :
309 : }
310 :
311 414 : vv_N_H2OLinesPtr_.push_back(v_N_H2OLinesPtr);
312 414 : vv_N_HH16OLinesPtr_.push_back(v_N_HH16OLinesPtr);
313 414 : vv_N_HH16OV2LinesPtr_.push_back(v_N_HH16OV2LinesPtr);
314 414 : vv_N_HH17OLinesPtr_.push_back(v_N_HH17OLinesPtr);
315 414 : vv_N_HH18OLinesPtr_.push_back(v_N_HH18OLinesPtr);
316 414 : vv_N_HDOLinesPtr_.push_back(v_N_HDOLinesPtr);
317 :
318 414 : vv_N_H2OContPtr_.push_back(v_N_H2OContPtr);
319 414 : vv_N_O2LinesPtr_.push_back(v_N_O2LinesPtr);
320 414 : vv_N_16O16OLinesPtr_.push_back(v_N_16O16OLinesPtr);
321 414 : vv_N_16O16OVIBLinesPtr_.push_back(v_N_16O16OVIBLinesPtr);
322 414 : vv_N_16O18OLinesPtr_.push_back(v_N_16O18OLinesPtr);
323 414 : vv_N_16O17OLinesPtr_.push_back(v_N_16O17OLinesPtr);
324 :
325 :
326 :
327 414 : vv_N_DryContPtr_.push_back(v_N_DryContPtr);
328 414 : vv_N_O3LinesPtr_.push_back(v_N_O3LinesPtr);
329 414 : vv_N_16O16O16OLinesPtr_.push_back(v_N_16O16O16OLinesPtr);
330 414 : vv_N_16O16O16OV1LinesPtr_.push_back(v_N_16O16O16OV1LinesPtr);
331 414 : vv_N_16O16O16OV2LinesPtr_.push_back(v_N_16O16O16OV2LinesPtr);
332 414 : vv_N_16O16O16OV3LinesPtr_.push_back(v_N_16O16O16OV3LinesPtr);
333 414 : vv_N_16O16O17OLinesPtr_.push_back(v_N_16O16O17OLinesPtr);
334 414 : vv_N_16O16O18OLinesPtr_.push_back(v_N_16O16O18OLinesPtr);
335 414 : vv_N_16O17O16OLinesPtr_.push_back(v_N_16O17O16OLinesPtr);
336 414 : vv_N_16O18O16OLinesPtr_.push_back(v_N_16O18O16OLinesPtr);
337 414 : vv_N_COLinesPtr_.push_back(v_N_COLinesPtr);
338 414 : vv_N_N2OLinesPtr_.push_back(v_N_N2OLinesPtr);
339 414 : vv_N_NO2LinesPtr_.push_back(v_N_NO2LinesPtr);
340 414 : vv_N_SO2LinesPtr_.push_back(v_N_SO2LinesPtr);
341 414 : vv_N_HClLinesPtr_.push_back(v_N_HClLinesPtr);
342 414 : vv_N_HCNLinesPtr_.push_back(v_N_HCNLinesPtr);
343 :
344 : }
345 :
346 100 : }
347 :
348 0 : RefractiveIndexProfile::RefractiveIndexProfile()
349 : {
350 0 : }
351 :
352 202 : RefractiveIndexProfile::~RefractiveIndexProfile()
353 : {
354 202 : rmRefractiveIndexProfile();
355 202 : }
356 :
357 322 : void RefractiveIndexProfile::rmRefractiveIndexProfile()
358 : {
359 : // for every frequency channel delete the pointer to the absorption profile
360 3601 : for(unsigned int nc = 0; nc < v_chanFreq_.size(); nc++) {
361 3279 : delete vv_N_H2OLinesPtr_[nc];
362 3279 : delete vv_N_HH16OLinesPtr_[nc];
363 3279 : delete vv_N_HH16OV2LinesPtr_[nc];
364 3279 : delete vv_N_HH17OLinesPtr_[nc];
365 3279 : delete vv_N_HH18OLinesPtr_[nc];
366 3279 : delete vv_N_HDOLinesPtr_[nc];
367 :
368 3279 : delete vv_N_H2OContPtr_[nc];
369 3279 : delete vv_N_O2LinesPtr_[nc];
370 3279 : delete vv_N_16O16OLinesPtr_[nc];
371 3279 : delete vv_N_16O16OVIBLinesPtr_[nc];
372 3279 : delete vv_N_16O18OLinesPtr_[nc];
373 3279 : delete vv_N_16O17OLinesPtr_[nc];
374 :
375 :
376 :
377 3279 : delete vv_N_DryContPtr_[nc];
378 3279 : delete vv_N_O3LinesPtr_[nc];
379 3279 : delete vv_N_16O16O16OLinesPtr_[nc];
380 3279 : delete vv_N_16O16O16OV1LinesPtr_[nc];
381 3279 : delete vv_N_16O16O16OV2LinesPtr_[nc];
382 3279 : delete vv_N_16O16O16OV3LinesPtr_[nc];
383 3279 : delete vv_N_16O16O17OLinesPtr_[nc];
384 3279 : delete vv_N_16O16O18OLinesPtr_[nc];
385 3279 : delete vv_N_16O17O16OLinesPtr_[nc];
386 3279 : delete vv_N_16O18O16OLinesPtr_[nc];
387 3279 : delete vv_N_COLinesPtr_[nc];
388 3279 : delete vv_N_N2OLinesPtr_[nc];
389 3279 : delete vv_N_NO2LinesPtr_[nc];
390 3279 : delete vv_N_SO2LinesPtr_[nc];
391 3279 : delete vv_N_HClLinesPtr_[nc];
392 3279 : delete vv_N_HCNLinesPtr_[nc];
393 : }
394 322 : }
395 :
396 120 : bool RefractiveIndexProfile::updateRefractiveIndexProfile(const Length &altitude,
397 : const Pressure &groundPressure,
398 : const Temperature &groundTemperature,
399 : double tropoLapseRate,
400 : const Humidity &relativeHumidity,
401 : const Length &wvScaleHeight)
402 : {
403 :
404 120 : bool updated = false;
405 120 : bool mkNewAtmProfile = updateAtmProfile(altitude,
406 : groundPressure,
407 : groundTemperature,
408 : tropoLapseRate,
409 : relativeHumidity,
410 : wvScaleHeight);
411 120 : unsigned int numLayer = getNumLayer();
412 :
413 120 : if(vv_N_H2OLinesPtr_.size() < v_chanFreq_.size()) {
414 0 : mkNewAtmProfile = true;
415 0 : std::cout << " RefractiveIndexProfile: number of spectral windows has increased"
416 0 : << std::endl;
417 : }
418 120 : if(mkNewAtmProfile) {
419 120 : if(numLayer) {
420 120 : mkRefractiveIndexProfile();
421 120 : updated = true;
422 : } else {
423 0 : std::cout << " RefractiveIndexProfile: ERROR: getNumLayer() returns 0"
424 0 : << std::endl;
425 : }
426 : }
427 120 : return updated;
428 : }
429 :
430 : // NB: this interface is required because the sub-class .... overrides this method.
431 0 : bool RefractiveIndexProfile::setBasicAtmosphericParameters(const Length &altitude,
432 : const Pressure &groundPressure,
433 : const Temperature &groundTemperature,
434 : double tropoLapseRate,
435 : const Humidity &relativeHumidity,
436 : const Length &wvScaleHeight)
437 : {
438 0 : bool updated = updateRefractiveIndexProfile(altitude,
439 : groundPressure,
440 : groundTemperature,
441 : tropoLapseRate,
442 : relativeHumidity,
443 : wvScaleHeight);
444 0 : return updated;
445 : }
446 :
447 222 : void RefractiveIndexProfile::mkRefractiveIndexProfile()
448 : {
449 :
450 : // static const double abun_18o=0.0020439;
451 : // static const double abun_17o=0.0003750;
452 : // static const double abun_D=0.000298444;
453 : // static const double o2_mixing_ratio=0.2092;
454 : // static const double mmol_h2o=18.005059688; // 20*0.0020439+19*(0.0003750+2*0.000298444)+18*(1-0.0020439-0.0003750-2*0.000298444)
455 :
456 : // static bool first = true; // [-Wunused_but_set_variable]
457 :
458 : double abun_O3, abun_CO, abun_N2O, abun_NO2, abun_SO2, abun_HCl, abun_HCN;
459 : double wvt, wv;
460 : // double t; // [-Wunused_but_set_variable]
461 : double nu;
462 : // double nu2, nu_pi; // [-Wunused_but_set_variable]
463 : // double width;
464 : // unsigned int npoints;
465 222 : RefractiveIndex atm;
466 : // double sumAbsO3Lines1, sumAbsCOLines1, sumAbsN2OLines1, sumAbsNO2Lines1, sumAbsSO2Lines1, sumAbsHClLines1, sumAbsHCNLines1;
467 :
468 :
469 : //TODO we will have to put numLayer_ and v_chanFreq_.size() const
470 : //we do not want to resize! ==> pas de setter pour SpectralGrid
471 :
472 : //cout << "vv_N_H2OLinesPtr_.size()=" << vv_N_H2OLinesPtr_.size() << std::endl;
473 222 : if(vv_N_H2OLinesPtr_.size() == 0) { // first time
474 102 : vv_N_H2OLinesPtr_.reserve(v_chanFreq_.size());
475 102 : vv_N_HH16OLinesPtr_.reserve(v_chanFreq_.size());
476 102 : vv_N_HH16OV2LinesPtr_.reserve(v_chanFreq_.size());
477 102 : vv_N_HH17OLinesPtr_.reserve(v_chanFreq_.size());
478 102 : vv_N_HH18OLinesPtr_.reserve(v_chanFreq_.size());
479 102 : vv_N_HDOLinesPtr_.reserve(v_chanFreq_.size());
480 :
481 102 : vv_N_H2OContPtr_.reserve(v_chanFreq_.size());
482 102 : vv_N_O2LinesPtr_.reserve(v_chanFreq_.size());
483 102 : vv_N_16O16OLinesPtr_.reserve(v_chanFreq_.size());
484 102 : vv_N_16O16OVIBLinesPtr_.reserve(v_chanFreq_.size());
485 102 : vv_N_16O17OLinesPtr_.reserve(v_chanFreq_.size());
486 102 : vv_N_16O18OLinesPtr_.reserve(v_chanFreq_.size());
487 :
488 :
489 :
490 102 : vv_N_DryContPtr_.reserve(v_chanFreq_.size());
491 102 : vv_N_O3LinesPtr_.reserve(v_chanFreq_.size());
492 102 : vv_N_16O16O16OLinesPtr_.reserve(v_chanFreq_.size());
493 102 : vv_N_16O16O16OV1LinesPtr_.reserve(v_chanFreq_.size());
494 102 : vv_N_16O16O16OV2LinesPtr_.reserve(v_chanFreq_.size());
495 102 : vv_N_16O16O16OV3LinesPtr_.reserve(v_chanFreq_.size());
496 102 : vv_N_16O16O17OLinesPtr_.reserve(v_chanFreq_.size());
497 102 : vv_N_16O16O18OLinesPtr_.reserve(v_chanFreq_.size());
498 102 : vv_N_16O17O16OLinesPtr_.reserve(v_chanFreq_.size());
499 102 : vv_N_16O18O16OLinesPtr_.reserve(v_chanFreq_.size());
500 102 : vv_N_COLinesPtr_.reserve(v_chanFreq_.size());
501 102 : vv_N_N2OLinesPtr_.reserve(v_chanFreq_.size());
502 102 : vv_N_NO2LinesPtr_.reserve(v_chanFreq_.size());
503 102 : vv_N_SO2LinesPtr_.reserve(v_chanFreq_.size());
504 102 : vv_N_HClLinesPtr_.reserve(v_chanFreq_.size());
505 102 : vv_N_HCNLinesPtr_.reserve(v_chanFreq_.size());
506 : } else {
507 120 : if(vv_N_H2OLinesPtr_.size() == v_chanFreq_.size()) // there are new basic param
508 120 : rmRefractiveIndexProfile(); // delete all the layer profiles for all the frequencies
509 : }
510 :
511 : std::vector<std::complex<double> >* v_N_H2OLinesPtr;
512 : std::vector<std::complex<double> >* v_N_HH16OLinesPtr;
513 : std::vector<std::complex<double> >* v_N_HH16OV2LinesPtr;
514 : std::vector<std::complex<double> >* v_N_HH17OLinesPtr;
515 : std::vector<std::complex<double> >* v_N_HH18OLinesPtr;
516 : std::vector<std::complex<double> >* v_N_HDOLinesPtr;
517 :
518 : std::vector<std::complex<double> >* v_N_H2OContPtr;
519 : std::vector<std::complex<double> >* v_N_O2LinesPtr;
520 : std::vector<std::complex<double> >* v_N_16O16OLinesPtr;
521 : std::vector<std::complex<double> >* v_N_16O16OVIBLinesPtr;
522 : std::vector<std::complex<double> >* v_N_16O17OLinesPtr;
523 : std::vector<std::complex<double> >* v_N_16O18OLinesPtr;
524 :
525 : std::vector<std::complex<double> >* v_N_DryContPtr;
526 : std::vector<std::complex<double> >* v_N_O3LinesPtr;
527 : std::vector<std::complex<double> >* v_N_16O16O16OLinesPtr;
528 : std::vector<std::complex<double> >* v_N_16O16O16OV1LinesPtr;
529 : std::vector<std::complex<double> >* v_N_16O16O16OV2LinesPtr;
530 : std::vector<std::complex<double> >* v_N_16O16O16OV3LinesPtr;
531 : std::vector<std::complex<double> >* v_N_16O16O17OLinesPtr;
532 : std::vector<std::complex<double> >* v_N_16O16O18OLinesPtr;
533 : std::vector<std::complex<double> >* v_N_16O17O16OLinesPtr;
534 : std::vector<std::complex<double> >* v_N_16O18O16OLinesPtr;
535 : std::vector<std::complex<double> >* v_N_COLinesPtr;
536 : std::vector<std::complex<double> >* v_N_N2OLinesPtr;
537 : std::vector<std::complex<double> >* v_N_NO2LinesPtr;
538 : std::vector<std::complex<double> >* v_N_SO2LinesPtr;
539 : std::vector<std::complex<double> >* v_N_HClLinesPtr;
540 : std::vector<std::complex<double> >* v_N_HCNLinesPtr;
541 :
542 : // std::cout << "v_chanFreq_.size()=" << v_chanFreq_.size() << std::endl;
543 : // std::cout << "numLayer_=" << numLayer_ << std::endl;
544 : // std::cout << "v_chanFreq_[0]=" << v_chanFreq_[0] << std::endl;
545 : // check if new spectral windows have been added
546 : unsigned int ncmin;
547 : /* std::cout << "vv_N_H2OLinesPtr_.size()="<<vv_N_H2OLinesPtr_.size()<<endl; */
548 222 : ncmin = vv_N_H2OLinesPtr_.size(); // will be > 0 if spectral window(s) have been added
549 222 : if(newBasicParam_) ncmin = 0;
550 :
551 : // std::cout << "ncmin=" << ncmin << std::endl;
552 :
553 3087 : for(unsigned int nc = ncmin; nc < v_chanFreq_.size(); nc++) {
554 :
555 2865 : v_N_H2OLinesPtr = new std::vector<std::complex<double> > ;
556 2865 : v_N_HH16OLinesPtr = new std::vector<std::complex<double> > ;
557 2865 : v_N_HH16OV2LinesPtr = new std::vector<std::complex<double> > ;
558 2865 : v_N_HH17OLinesPtr = new std::vector<std::complex<double> > ;
559 2865 : v_N_HH18OLinesPtr = new std::vector<std::complex<double> > ;
560 2865 : v_N_HDOLinesPtr = new std::vector<std::complex<double> > ;
561 :
562 2865 : v_N_H2OContPtr = new std::vector<std::complex<double> > ;
563 2865 : v_N_O2LinesPtr = new std::vector<std::complex<double> > ;
564 2865 : v_N_16O16OLinesPtr = new std::vector<std::complex<double> > ;
565 2865 : v_N_16O16OVIBLinesPtr = new std::vector<std::complex<double> > ;
566 2865 : v_N_16O17OLinesPtr = new std::vector<std::complex<double> > ;
567 2865 : v_N_16O18OLinesPtr = new std::vector<std::complex<double> > ;
568 :
569 2865 : v_N_DryContPtr = new std::vector<std::complex<double> > ;
570 2865 : v_N_O3LinesPtr = new std::vector<std::complex<double> > ;
571 2865 : v_N_16O16O16OLinesPtr = new std::vector<std::complex<double> > ;
572 2865 : v_N_16O16O16OV1LinesPtr = new std::vector<std::complex<double> > ;
573 2865 : v_N_16O16O16OV2LinesPtr = new std::vector<std::complex<double> > ;
574 2865 : v_N_16O16O16OV3LinesPtr = new std::vector<std::complex<double> > ;
575 2865 : v_N_16O16O17OLinesPtr = new std::vector<std::complex<double> > ;
576 2865 : v_N_16O16O18OLinesPtr = new std::vector<std::complex<double> > ;
577 2865 : v_N_16O17O16OLinesPtr = new std::vector<std::complex<double> > ;
578 2865 : v_N_16O18O16OLinesPtr = new std::vector<std::complex<double> > ;
579 2865 : v_N_COLinesPtr = new std::vector<std::complex<double> > ;
580 2865 : v_N_N2OLinesPtr = new std::vector<std::complex<double> > ;
581 2865 : v_N_NO2LinesPtr = new std::vector<std::complex<double> > ;
582 2865 : v_N_SO2LinesPtr = new std::vector<std::complex<double> > ;
583 2865 : v_N_HClLinesPtr = new std::vector<std::complex<double> > ;
584 2865 : v_N_HCNLinesPtr = new std::vector<std::complex<double> > ;
585 :
586 :
587 2865 : v_N_H2OLinesPtr->reserve(numLayer_);
588 2865 : v_N_HH16OLinesPtr->reserve(numLayer_);
589 2865 : v_N_HH16OV2LinesPtr->reserve(numLayer_);
590 2865 : v_N_HH17OLinesPtr->reserve(numLayer_);
591 2865 : v_N_HH18OLinesPtr->reserve(numLayer_);
592 2865 : v_N_HDOLinesPtr->reserve(numLayer_);
593 :
594 2865 : v_N_H2OContPtr->reserve(numLayer_);
595 2865 : v_N_O2LinesPtr->reserve(numLayer_);
596 2865 : v_N_16O16OLinesPtr->reserve(numLayer_);
597 2865 : v_N_16O16OVIBLinesPtr->reserve(numLayer_);
598 2865 : v_N_16O17OLinesPtr->reserve(numLayer_);
599 2865 : v_N_16O18OLinesPtr->reserve(numLayer_);
600 :
601 2865 : v_N_DryContPtr->reserve(numLayer_);
602 2865 : v_N_O3LinesPtr->reserve(numLayer_);
603 2865 : v_N_16O16O16OLinesPtr->reserve(numLayer_);
604 2865 : v_N_16O16O16OV1LinesPtr->reserve(numLayer_);
605 2865 : v_N_16O16O16OV2LinesPtr->reserve(numLayer_);
606 2865 : v_N_16O16O16OV3LinesPtr->reserve(numLayer_);
607 2865 : v_N_16O16O17OLinesPtr->reserve(numLayer_);
608 2865 : v_N_16O16O18OLinesPtr->reserve(numLayer_);
609 2865 : v_N_16O17O16OLinesPtr->reserve(numLayer_);
610 2865 : v_N_16O18O16OLinesPtr->reserve(numLayer_);
611 2865 : v_N_COLinesPtr->reserve(numLayer_);
612 2865 : v_N_N2OLinesPtr->reserve(numLayer_);
613 2865 : v_N_NO2LinesPtr->reserve(numLayer_);
614 2865 : v_N_SO2LinesPtr->reserve(numLayer_);
615 2865 : v_N_HClLinesPtr->reserve(numLayer_);
616 2865 : v_N_HCNLinesPtr->reserve(numLayer_);
617 :
618 2865 : nu = 1.0E-9 * v_chanFreq_[nc]; // ATM uses GHz units
619 :
620 : // std::cout << "freq. points =" << v_chanFreq_.size() << std::endl;
621 :
622 : /* TO BE IMPLEMENTED IN NEXT RELEASE
623 :
624 : if (v_chanFreq_.size()>1){
625 : if(nc==0){
626 : width = fabs(v_chanFreq_[nc+1]-v_chanFreq_[nc])*1e-9; // width en GHz para ATM
627 : npoints=(unsigned int)round(width*100); // One point every 10 MHz
628 : }else{
629 : if(nc==v_chanFreq_.size()-1){
630 : width = fabs(v_chanFreq_[nc]-v_chanFreq_[nc-1])*1e-9; // width en GHz para ATM
631 : npoints=(unsigned int)round(width*100); // One point every 10 MHz
632 : }else{
633 : width = fabs((v_chanFreq_[nc+1]-v_chanFreq_[nc-1])/2.0)*1e-9; // width en GHz para ATM
634 : npoints=(unsigned int)round(width*100); // One point every 10 MHz
635 : }
636 : }
637 : }else{
638 : width = 0.001; // default width = 1 MHz = 0.001 GHz
639 : npoints=1;
640 : }
641 :
642 : if(npoints==0){npoints=1;}
643 :
644 : */
645 :
646 :
647 :
648 : // std::cout << "nc =" << nc << " nu=" << nu << " width=" << width << " GHz npoints=" << npoints << std::endl;
649 :
650 : // nu2 = nu * nu; // [-Wunused_but_set_variable]
651 : // nu_pi = nu / M_PI; // [-Wunused_but_set_variable]
652 :
653 86218 : for(unsigned int j = 0; j < numLayer_; j++) {
654 :
655 83353 : wv = v_layerWaterVapor_[j] * 1000.0; // se multiplica por 10**3 por cuestión de unidades en las rutinas fortran.
656 83353 : wvt = wv * v_layerTemperature_[j] / 217.0; // v_layerWaterVapor_[j] está en kg/m**3
657 : // t = v_layerTemperature_[j] / 300.0; // [-Wunused_but_set_variable]
658 :
659 :
660 : // std::cout <<"ATMRefractiveIndexProfile: " << v_layerTemperature_[j] << " K " << v_layerPressure_[j] << " mb " << nu << " GHz " << std::endl;
661 : // std::cout <<"ATMRefractiveIndexProfile: O2" << atm.getRefractivity_o2(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu) << std::endl;
662 : // std::cout << "ATMRefractiveIndexProfile: O2" << atm.getRefractivity_o2(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu,width,npoints) << std::endl;
663 : // std::cout << "ATMRefractiveIndexProfile: H2O" << atm.getRefractivity_h2o(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu) << std::endl;
664 : // std::cout << "ATMRefractiveIndexProfile: H2O" << atm.getRefractivity_h2o(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu,width,npoints) << std::endl;
665 : // std::cout <<"ATMRefractiveIndexProfile: O3" << atm.getRefractivity_o3(v_layerTemperature_[j],v_layerPressure_[j],nu,v_layerO3_[j]) << std::endl;
666 : // std::cout << "ATMRefractiveIndexProfile: O3" << atm.getRefractivity_o3(v_layerTemperature_[j],v_layerPressure_[j],nu,width,npoints,v_layerO3_[j]) << std::endl;
667 : // std::cout <<"ATMRefractiveIndexProfile: CO" << atm.getSpecificRefractivity_co(v_layerTemperature_[j],v_layerPressure_[j],nu) << std::endl;
668 : // std::cout << "ATMRefractiveIndexProfile: CO" << atm.getSpecificRefractivity_co(v_layerTemperature_[j],v_layerPressure_[j],nu,width,npoints) << std::endl;
669 :
670 83353 : v_N_O2LinesPtr->push_back(atm.getRefractivity_o2(v_layerTemperature_[j], v_layerPressure_[j], wvt, nu)); // ,width,npoints)); TO BE IMPLEMENTED IN NEXT RELEASE
671 83353 : v_N_16O16OLinesPtr->push_back(atm.getRefractivity_16o16o(v_layerTemperature_[j], v_layerPressure_[j], wvt, nu)); // ,width,npoints)); TO BE IMPLEMENTED IN NEXT RELEASE
672 83353 : v_N_16O16OVIBLinesPtr->push_back(atm.getRefractivity_16o16o_vib(v_layerTemperature_[j], v_layerPressure_[j], wvt, nu)); // ,width,npoints)); TO BE IMPLEMENTED IN NEXT RELEASE
673 83353 : v_N_16O18OLinesPtr->push_back(atm.getRefractivity_16o18o(v_layerTemperature_[j], v_layerPressure_[j], wvt, nu)); // ,width,npoints)); TO BE IMPLEMENTED IN NEXT RELEASE
674 83353 : v_N_16O17OLinesPtr->push_back(atm.getRefractivity_16o17o(v_layerTemperature_[j], v_layerPressure_[j], wvt, nu)); // ,width,npoints)); TO BE IMPLEMENTED IN NEXT RELEASE
675 :
676 : std::complex<double> cont_h2o =
677 83353 : atm.getRefractivity_cnth2o(v_layerTemperature_[j],
678 83353 : v_layerPressure_[j],
679 : wvt,
680 : nu); // ,width,npoints); TO BE IMPLEMENTED IN NEXT RELEASE
681 : std::complex<double> cont_dry =
682 83353 : atm.getRefractivity_cntdry(v_layerTemperature_[j],
683 83353 : v_layerPressure_[j],
684 : wvt,
685 : nu); // ,width,npoints); TO BE IMPLEMENTED IN NEXT RELEASE
686 :
687 83353 : v_N_H2OContPtr->push_back(cont_h2o);
688 83353 : v_N_DryContPtr->push_back(cont_dry);
689 :
690 83353 : if(v_layerWaterVapor_[j] > 0) {
691 :
692 83353 : v_N_H2OLinesPtr->push_back(atm.getRefractivity_h2o(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu)); // ,width,npoints)); TO BE IMPLEMENTED IN NEXT RELEASE
693 83353 : v_N_HH16OLinesPtr->push_back(atm.getRefractivity_hh16o(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu));
694 83353 : v_N_HH16OV2LinesPtr->push_back(atm.getRefractivity_hh16ov2(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu));
695 83353 : v_N_HH17OLinesPtr->push_back(atm.getRefractivity_hh17o(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu));
696 83353 : v_N_HH18OLinesPtr->push_back(atm.getRefractivity_hh18o(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu));
697 83353 : v_N_HDOLinesPtr->push_back(atm.getRefractivity_hdo(v_layerTemperature_[j],v_layerPressure_[j],wvt,nu));
698 :
699 : } else {
700 0 : v_N_H2OLinesPtr->push_back(0.0);
701 0 : v_N_HH16OLinesPtr->push_back(0.0);
702 0 : v_N_HH16OV2LinesPtr->push_back(0.0);
703 0 : v_N_HH17OLinesPtr->push_back(0.0);
704 0 : v_N_HH18OLinesPtr->push_back(0.0);
705 0 : v_N_HDOLinesPtr->push_back(0.0);
706 : }
707 :
708 : // if(v_layerO3_[j]<0.0||j==10){cout << "v_layerO3_[" << j << "]=" << v_layerO3_[j] << std::endl;}
709 :
710 83353 : if(v_layerO3_[j] > 0) {
711 :
712 83353 : abun_O3 = v_layerO3_[j] * 1E-6;
713 83353 : v_N_O3LinesPtr->push_back(atm.getRefractivity_o3(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6)); // width for nu, npoints, TO BE IMPLEMENTED
714 83353 : v_N_16O16O16OLinesPtr->push_back(atm.getRefractivity_16o16o16o(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6));
715 83353 : v_N_16O16O16OV1LinesPtr->push_back(atm.getRefractivity_16o16o16o_v1(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6));
716 83353 : v_N_16O16O16OV2LinesPtr->push_back(atm.getRefractivity_16o16o16o_v2(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6));
717 83353 : v_N_16O16O16OV3LinesPtr->push_back(atm.getRefractivity_16o16o16o_v3(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6));
718 83353 : v_N_16O16O17OLinesPtr->push_back(atm.getRefractivity_16o16o17o(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6));
719 83353 : v_N_16O16O18OLinesPtr->push_back(atm.getRefractivity_16o16o18o(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6));
720 83353 : v_N_16O17O16OLinesPtr->push_back(atm.getRefractivity_16o17o16o(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6));
721 83353 : v_N_16O18O16OLinesPtr->push_back(atm.getRefractivity_16o18o16o(v_layerTemperature_[j], v_layerPressure_[j], nu, abun_O3 * 1e6));
722 : // 29JUL2024 29JUL2024 29JUL2024
723 : } else {
724 0 : v_N_O3LinesPtr->push_back(0.0);
725 : }
726 :
727 83353 : if(v_layerCO_[j] > 0) {
728 83353 : abun_CO = v_layerCO_[j] * 1E-6; // in cm^-3
729 166706 : v_N_COLinesPtr->push_back(atm.getEarthSpecificRefractivity_co(v_layerTemperature_[j],
730 83353 : v_layerPressure_[j],
731 : nu) // ,width,npoints) TO BE IMPLEMENTED IN NEXT RELEASE
732 250059 : * abun_CO * 1e6); // m^2 * m^-3 = m^-1
733 : } else {
734 0 : v_N_COLinesPtr->push_back(0.0);
735 : }
736 :
737 83353 : if(v_layerN2O_[j] > 0) {
738 83353 : abun_N2O = v_layerN2O_[j] * 1E-6;
739 166706 : v_N_N2OLinesPtr->push_back(atm.getEarthSpecificRefractivity_n2o(v_layerTemperature_[j],
740 83353 : v_layerPressure_[j],
741 : nu) // ,width,npoints) TO BE IMPLEMENTED IN NEXT RELEASE
742 250059 : * abun_N2O * 1e6); // m^2 * m^-3 = m^-1
743 : } else {
744 0 : v_N_N2OLinesPtr->push_back(0.0);
745 : }
746 :
747 83353 : if(v_layerNO2_[j] > 0) {
748 83353 : abun_NO2 = v_layerNO2_[j] * 1E-6;
749 : // std::cout << "abun_NO2[" << j << "]=" << abun_NO2 << " opacity=" << atm.getSpecificRefractivity_no2(v_layerTemperature_[j], v_layerPressure_[j], nu) * abun_NO2 * 1e6 << std::endl;
750 83353 : v_N_NO2LinesPtr->push_back(atm.getEarthSpecificRefractivity_no2(v_layerTemperature_[j], v_layerPressure_[j], nu) * abun_NO2 * 1e6); // m^2 * m^-3 = m^-1
751 : } else {
752 0 : v_N_NO2LinesPtr->push_back(0.0);
753 : }
754 :
755 83353 : if(v_layerHCl_[j] > 0) {
756 83353 : abun_HCl = v_layerHCl_[j] * 1E-6;
757 166706 : v_N_HClLinesPtr->push_back(atm.getEarthSpecificRefractivity_hcl(v_layerTemperature_[j],
758 83353 : v_layerPressure_[j],
759 : nu) // ,width,npoints) TO BE IMPLEMENTED IN NEXT RELEASE
760 250059 : * abun_HCl * 1e6); // m^2 * m^-3 = m^-1
761 : } else {
762 0 : v_N_HClLinesPtr->push_back(0.0);
763 : }
764 :
765 83353 : if(v_layerHCN_[j] > 0) {
766 83353 : abun_HCN = v_layerHCN_[j] * 1E-6;
767 166706 : v_N_HCNLinesPtr->push_back(atm.getEarthSpecificRefractivity_hcn(v_layerTemperature_[j],
768 83353 : v_layerPressure_[j],
769 : nu) // ,width,npoints) TO BE IMPLEMENTED IN NEXT RELEASE
770 250059 : * abun_HCN * 1e6); // m^2 * m^-3 = m^-1
771 : } else {
772 0 : v_N_HCNLinesPtr->push_back(0.0);
773 : }
774 :
775 83353 : if(v_layerSO2_[j] > 0) {
776 83353 : abun_SO2 = v_layerSO2_[j] * 1E-6;
777 166706 : v_N_SO2LinesPtr->push_back(atm.getEarthSpecificRefractivity_so2(v_layerTemperature_[j],
778 83353 : v_layerPressure_[j],
779 : nu) // ,width,npoints) TO BE IMPLEMENTED IN NEXT RELEASE
780 250059 : * abun_SO2 * 1e6); // m^2 * m^-3 = m^-1
781 : } else {
782 0 : v_N_SO2LinesPtr->push_back(0.0);
783 : }
784 : }
785 :
786 : // if(vv_N_H2OLinesPtr_.size() == 0) first = true; // [-Wunused_but_set_variable]
787 :
788 2865 : if(vv_N_H2OLinesPtr_.size() < v_chanFreq_.size()) {
789 465 : vv_N_H2OLinesPtr_.push_back(v_N_H2OLinesPtr);
790 465 : vv_N_HH16OLinesPtr_.push_back(v_N_HH16OLinesPtr);
791 465 : vv_N_HH16OV2LinesPtr_.push_back(v_N_HH16OV2LinesPtr);
792 465 : vv_N_HH17OLinesPtr_.push_back(v_N_HH17OLinesPtr);
793 465 : vv_N_HH18OLinesPtr_.push_back(v_N_HH18OLinesPtr);
794 465 : vv_N_HDOLinesPtr_.push_back(v_N_HDOLinesPtr);
795 :
796 465 : vv_N_H2OContPtr_.push_back(v_N_H2OContPtr);
797 465 : vv_N_O2LinesPtr_.push_back(v_N_O2LinesPtr);
798 465 : vv_N_16O16OLinesPtr_.push_back(v_N_16O16OLinesPtr);
799 465 : vv_N_16O16OVIBLinesPtr_.push_back(v_N_16O16OVIBLinesPtr);
800 465 : vv_N_16O18OLinesPtr_.push_back(v_N_16O18OLinesPtr);
801 465 : vv_N_16O17OLinesPtr_.push_back(v_N_16O17OLinesPtr);
802 :
803 :
804 :
805 465 : vv_N_DryContPtr_.push_back(v_N_DryContPtr);
806 465 : vv_N_O3LinesPtr_.push_back(v_N_O3LinesPtr);
807 465 : vv_N_16O16O16OLinesPtr_.push_back(v_N_16O16O16OLinesPtr);
808 465 : vv_N_16O16O16OV1LinesPtr_.push_back(v_N_16O16O16OV1LinesPtr);
809 465 : vv_N_16O16O16OV2LinesPtr_.push_back(v_N_16O16O16OV2LinesPtr);
810 465 : vv_N_16O16O16OV3LinesPtr_.push_back(v_N_16O16O16OV3LinesPtr);
811 465 : vv_N_16O16O17OLinesPtr_.push_back(v_N_16O16O17OLinesPtr);
812 465 : vv_N_16O16O18OLinesPtr_.push_back(v_N_16O16O18OLinesPtr);
813 465 : vv_N_16O17O16OLinesPtr_.push_back(v_N_16O17O16OLinesPtr);
814 465 : vv_N_16O18O16OLinesPtr_.push_back(v_N_16O18O16OLinesPtr);
815 465 : vv_N_COLinesPtr_.push_back(v_N_COLinesPtr);
816 465 : vv_N_N2OLinesPtr_.push_back(v_N_N2OLinesPtr);
817 465 : vv_N_NO2LinesPtr_.push_back(v_N_NO2LinesPtr);
818 465 : vv_N_SO2LinesPtr_.push_back(v_N_SO2LinesPtr);
819 465 : vv_N_HClLinesPtr_.push_back(v_N_HClLinesPtr);
820 465 : vv_N_HCNLinesPtr_.push_back(v_N_HCNLinesPtr);
821 : } else {
822 2400 : vv_N_H2OLinesPtr_[nc] = v_N_H2OLinesPtr;
823 2400 : vv_N_HH16OLinesPtr_[nc] = v_N_HH16OLinesPtr;
824 2400 : vv_N_HH16OV2LinesPtr_[nc] = v_N_HH16OV2LinesPtr;
825 2400 : vv_N_HH17OLinesPtr_[nc] = v_N_HH17OLinesPtr;
826 2400 : vv_N_HH18OLinesPtr_[nc] = v_N_HH18OLinesPtr;
827 2400 : vv_N_HDOLinesPtr_[nc] = v_N_HDOLinesPtr;
828 :
829 2400 : vv_N_H2OContPtr_[nc] = v_N_H2OContPtr;
830 2400 : vv_N_O2LinesPtr_[nc] = v_N_O2LinesPtr;
831 2400 : vv_N_16O16OLinesPtr_[nc] = v_N_16O16OLinesPtr;
832 2400 : vv_N_16O16OVIBLinesPtr_[nc] = v_N_16O16OVIBLinesPtr;
833 2400 : vv_N_16O18OLinesPtr_[nc] = v_N_16O18OLinesPtr;
834 2400 : vv_N_16O17OLinesPtr_[nc] = v_N_16O17OLinesPtr;
835 :
836 :
837 :
838 2400 : vv_N_DryContPtr_[nc] = v_N_DryContPtr;
839 2400 : vv_N_O3LinesPtr_[nc] = v_N_O3LinesPtr;
840 2400 : vv_N_16O16O16OLinesPtr_[nc] = v_N_16O16O16OLinesPtr;
841 2400 : vv_N_16O16O16OV1LinesPtr_[nc] = v_N_16O16O16OV1LinesPtr;
842 2400 : vv_N_16O16O16OV2LinesPtr_[nc] = v_N_16O16O16OV2LinesPtr;
843 2400 : vv_N_16O16O16OV3LinesPtr_[nc] = v_N_16O16O16OV3LinesPtr;
844 2400 : vv_N_16O16O17OLinesPtr_[nc] = v_N_16O16O17OLinesPtr;
845 2400 : vv_N_16O16O18OLinesPtr_[nc] = v_N_16O16O18OLinesPtr;
846 2400 : vv_N_16O17O16OLinesPtr_[nc] = v_N_16O17O16OLinesPtr;
847 2400 : vv_N_16O18O16OLinesPtr_[nc] = v_N_16O18O16OLinesPtr;
848 2400 : vv_N_COLinesPtr_[nc] = v_N_COLinesPtr;
849 2400 : vv_N_N2OLinesPtr_[nc] = v_N_N2OLinesPtr;
850 2400 : vv_N_NO2LinesPtr_[nc] = v_N_NO2LinesPtr;
851 2400 : vv_N_SO2LinesPtr_[nc] = v_N_SO2LinesPtr;
852 2400 : vv_N_HClLinesPtr_[nc] = v_N_HClLinesPtr;
853 2400 : vv_N_HCNLinesPtr_[nc] = v_N_HCNLinesPtr;
854 : }
855 :
856 : }
857 :
858 222 : newBasicParam_ = false;
859 : // first = false; // [-Wunused_but_set_variable]
860 222 : }
861 :
862 :
863 0 : Opacity RefractiveIndexProfile::getDryOpacityUpTo(unsigned int nc, Length refalti)
864 : {
865 0 : unsigned int ires; unsigned int numlayerold; Length alti; double fractionLast;
866 0 : Opacity opacityout0; Opacity opacityout1; Opacity zeroOp(0.0,Opacity::UnitNeper);
867 :
868 0 : if(refalti.get(Length::UnitKiloMeter) <= altitude_.get(Length::UnitKiloMeter)) {
869 0 : return zeroOp;
870 : }else{
871 0 : fractionLast = 1.0; numlayerold = numLayer_;
872 0 : opacityout0=getDryOpacity(nc); ires=numlayerold-1; alti=altitude_;
873 0 : for(unsigned int i=0; i<numLayer_; i++){
874 0 : if(alti.get(Length::UnitKiloMeter) < refalti.get(Length::UnitKiloMeter) && (alti.get(Length::UnitKiloMeter)+v_layerThickness_[i]/1000.0) >= refalti.get(Length::UnitKiloMeter))
875 0 : { ires=i; fractionLast = (refalti.get(Length::UnitMeter)-alti.get(Length::UnitMeter))/v_layerThickness_[i]; }
876 0 : alti = alti + Length(v_layerThickness_[i],Length::UnitMeter);
877 : }
878 0 : numLayer_ = ires;
879 0 : opacityout0=getDryOpacity(nc);
880 0 : numLayer_ = ires+1;
881 0 : opacityout1=getDryOpacity(nc);
882 0 : numLayer_ = numlayerold;
883 0 : return opacityout0+(opacityout1-opacityout0)*fractionLast;
884 : }
885 0 : }
886 491 : Opacity RefractiveIndexProfile::getDryOpacity(unsigned int nc)
887 : {
888 491 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
889 491 : double kv = 0;
890 21106 : for(unsigned int j = 0; j < numLayer_; j++) {
891 41230 : kv = kv + imag(vv_N_O2LinesPtr_[nc]->at(j) + vv_N_DryContPtr_[nc]->at(j)
892 41230 : + vv_N_O3LinesPtr_[nc]->at(j) + vv_N_COLinesPtr_[nc]->at(j)
893 41230 : + vv_N_N2OLinesPtr_[nc]->at(j) + vv_N_NO2LinesPtr_[nc]->at(j)
894 61845 : + vv_N_SO2LinesPtr_[nc]->at(j) + vv_N_HClLinesPtr_[nc]->at(j) + vv_N_HCNLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
895 : }
896 491 : return Opacity(kv);
897 : }
898 :
899 :
900 0 : Opacity RefractiveIndexProfile::getAverageDryOpacity(unsigned int spwid)
901 : {
902 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
903 0 : Opacity totalaverage;
904 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
905 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
906 0 : totalaverage = totalaverage + getDryOpacity(spwid, nc);
907 : }
908 0 : totalaverage = totalaverage / getNumChan(spwid);
909 0 : return totalaverage;
910 0 : }
911 :
912 0 : Opacity RefractiveIndexProfile::getAverageO2LinesOpacity(unsigned int spwid)
913 : {
914 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
915 0 : Opacity totalaverage;
916 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
917 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
918 0 : totalaverage = totalaverage + getO2LinesOpacity(spwid, nc);
919 : }
920 0 : totalaverage = totalaverage / getNumChan(spwid);
921 0 : return totalaverage;
922 0 : }
923 :
924 0 : Opacity RefractiveIndexProfile::getAverageO3LinesOpacity(unsigned int spwid)
925 : {
926 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
927 0 : Opacity totalaverage;
928 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
929 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
930 : /* std::cout << " Freq = " << getChanFreq(spwid,nc).get(Frequency::UnitGigaHertz)
931 : << " O3 opacity = " << getO3LinesOpacity(spwid,nc).get(Opacity::UnitNeper)
932 : << " O3 pathlength = " << getO3LinesPathLength(spwid,nc).get(Length::Microns)
933 : << " O2 opacity = " << getO2LinesOpacity(spwid,nc).get(Opacity::UnitNeper)
934 : << " O2 pathlength = " << getO2LinesPathLength(spwid,nc).get(Length::Microns)
935 : << std::endl; */
936 0 : totalaverage = totalaverage + getO3LinesOpacity(spwid, nc);
937 : }
938 0 : totalaverage = totalaverage / getNumChan(spwid);
939 0 : return totalaverage;
940 0 : }
941 :
942 0 : Opacity RefractiveIndexProfile::getAverageN2OLinesOpacity(unsigned int spwid)
943 : {
944 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
945 0 : Opacity totalaverage;
946 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
947 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
948 0 : totalaverage = totalaverage + getN2OLinesOpacity(spwid, nc);
949 : }
950 0 : totalaverage = totalaverage / getNumChan(spwid);
951 0 : return totalaverage;
952 0 : }
953 :
954 0 : Opacity RefractiveIndexProfile::getAverageNO2LinesOpacity(unsigned int spwid)
955 : {
956 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
957 0 : Opacity totalaverage;
958 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
959 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
960 0 : totalaverage = totalaverage + getNO2LinesOpacity(spwid, nc);
961 : }
962 0 : totalaverage = totalaverage / getNumChan(spwid);
963 0 : return totalaverage;
964 0 : }
965 :
966 0 : Opacity RefractiveIndexProfile::getAverageHClLinesOpacity(unsigned int spwid)
967 : {
968 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
969 0 : Opacity totalaverage;
970 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
971 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
972 0 : totalaverage = totalaverage + getHClLinesOpacity(spwid, nc);
973 : }
974 0 : totalaverage = totalaverage / getNumChan(spwid);
975 0 : return totalaverage;
976 0 : }
977 :
978 0 : Opacity RefractiveIndexProfile::getAverageHCNLinesOpacity(unsigned int spwid)
979 : {
980 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
981 0 : Opacity totalaverage;
982 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
983 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
984 0 : totalaverage = totalaverage + getHCNLinesOpacity(spwid, nc);
985 : }
986 0 : totalaverage = totalaverage / getNumChan(spwid);
987 0 : return totalaverage;
988 0 : }
989 :
990 0 : Opacity RefractiveIndexProfile::getAverageSO2LinesOpacity(unsigned int spwid)
991 : {
992 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
993 0 : Opacity totalaverage;
994 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
995 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
996 0 : totalaverage = totalaverage + getSO2LinesOpacity(spwid, nc);
997 : }
998 0 : totalaverage = totalaverage / getNumChan(spwid);
999 0 : return totalaverage;
1000 0 : }
1001 :
1002 :
1003 :
1004 :
1005 0 : Opacity RefractiveIndexProfile::getAverageCOLinesOpacity(unsigned int spwid)
1006 : {
1007 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
1008 0 : Opacity totalaverage;
1009 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
1010 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
1011 0 : totalaverage = totalaverage + getCOLinesOpacity(spwid, nc);
1012 : }
1013 0 : totalaverage = totalaverage / getNumChan(spwid);
1014 0 : return totalaverage;
1015 0 : }
1016 :
1017 0 : Opacity RefractiveIndexProfile::getAverageDryContOpacity(unsigned int spwid)
1018 : {
1019 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
1020 0 : Opacity totalaverage;
1021 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
1022 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
1023 0 : totalaverage = totalaverage + getDryContOpacity(spwid, nc);
1024 : }
1025 0 : totalaverage = totalaverage / getNumChan(spwid);
1026 0 : return totalaverage;
1027 0 : }
1028 :
1029 1 : Opacity RefractiveIndexProfile::getDryContOpacity()
1030 : {
1031 1 : return getDryContOpacity(0);
1032 : }
1033 :
1034 99 : Opacity RefractiveIndexProfile::getDryContOpacity(unsigned int nc)
1035 : {
1036 99 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1037 99 : double kv = 0;
1038 4250 : for(unsigned int j = 0; j < numLayer_; j++) {
1039 4151 : kv = kv + imag(vv_N_DryContPtr_[nc]->at(j)) * v_layerThickness_[j];
1040 : }
1041 99 : return Opacity(kv);
1042 : }
1043 :
1044 0 : Opacity RefractiveIndexProfile::getDryContOpacity(unsigned int spwid,
1045 : unsigned int nc)
1046 : {
1047 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1048 0 : return getDryContOpacity(v_transfertId_[spwid] + nc);
1049 : }
1050 :
1051 :
1052 :
1053 1 : Opacity RefractiveIndexProfile::getO2LinesOpacity()
1054 1 : { return getO2LinesOpacity(0); }
1055 99 : Opacity RefractiveIndexProfile::getO2LinesOpacity(unsigned int nc)
1056 99 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1057 99 : double kv = 0;
1058 4250 : for(unsigned int j = 0; j < numLayer_; j++){kv = kv + imag(vv_N_O2LinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1059 99 : return Opacity(kv);
1060 : }
1061 0 : Opacity RefractiveIndexProfile::getO2LinesOpacity(unsigned int spwid, unsigned int nc)
1062 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1063 0 : return getO2LinesOpacity(v_transfertId_[spwid] + nc); }
1064 :
1065 0 : Opacity RefractiveIndexProfile::get16O16OLinesOpacity()
1066 0 : { return get16O16OLinesOpacity(0); }
1067 98 : Opacity RefractiveIndexProfile::get16O16OLinesOpacity(unsigned int nc)
1068 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1069 98 : double kv = 0;
1070 4214 : for(unsigned int j = 0; j < numLayer_; j++){kv = kv + imag(vv_N_16O16OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1071 98 : return Opacity(kv);
1072 : }
1073 0 : Opacity RefractiveIndexProfile::get16O16OLinesOpacity(unsigned int spwid, unsigned int nc)
1074 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1075 0 : return get16O16OLinesOpacity(v_transfertId_[spwid] + nc); }
1076 :
1077 0 : Opacity RefractiveIndexProfile::get16O16OVIBLinesOpacity()
1078 0 : { return get16O16OVIBLinesOpacity(0); }
1079 98 : Opacity RefractiveIndexProfile::get16O16OVIBLinesOpacity(unsigned int nc)
1080 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1081 98 : double kv = 0;
1082 4214 : for(unsigned int j = 0; j < numLayer_; j++){kv = kv + imag(vv_N_16O16OVIBLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1083 98 : return Opacity(kv);
1084 : }
1085 0 : Opacity RefractiveIndexProfile::get16O16OVIBLinesOpacity(unsigned int spwid, unsigned int nc)
1086 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1087 0 : return get16O16OVIBLinesOpacity(v_transfertId_[spwid] + nc); }
1088 :
1089 0 : Opacity RefractiveIndexProfile::get16O18OLinesOpacity()
1090 0 : { return get16O18OLinesOpacity(0); }
1091 98 : Opacity RefractiveIndexProfile::get16O18OLinesOpacity(unsigned int nc)
1092 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1093 98 : double kv = 0;
1094 4214 : for(unsigned int j = 0; j < numLayer_; j++){kv = kv + imag(vv_N_16O18OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1095 98 : return Opacity(kv);
1096 : }
1097 0 : Opacity RefractiveIndexProfile::get16O18OLinesOpacity(unsigned int spwid, unsigned int nc)
1098 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1099 0 : return get16O18OLinesOpacity(v_transfertId_[spwid] + nc); }
1100 :
1101 0 : Opacity RefractiveIndexProfile::get16O17OLinesOpacity()
1102 0 : { return get16O17OLinesOpacity(0); }
1103 98 : Opacity RefractiveIndexProfile::get16O17OLinesOpacity(unsigned int nc)
1104 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1105 98 : double kv = 0;
1106 4214 : for(unsigned int j = 0; j < numLayer_; j++){kv = kv + imag(vv_N_16O17OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1107 98 : return Opacity(kv);
1108 : }
1109 0 : Opacity RefractiveIndexProfile::get16O17OLinesOpacity(unsigned int spwid, unsigned int nc)
1110 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1111 0 : return get16O17OLinesOpacity(v_transfertId_[spwid] + nc); }
1112 :
1113 :
1114 :
1115 1 : Opacity RefractiveIndexProfile::getCOLinesOpacity()
1116 : {
1117 1 : return getCOLinesOpacity(0);
1118 : }
1119 :
1120 99 : Opacity RefractiveIndexProfile::getCOLinesOpacity(unsigned int nc)
1121 : {
1122 99 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1123 99 : double kv = 0;
1124 4250 : for(unsigned int j = 0; j < numLayer_; j++) {
1125 4151 : kv = kv + imag(vv_N_COLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1126 : }
1127 99 : return Opacity(kv);
1128 : }
1129 :
1130 0 : Opacity RefractiveIndexProfile::getCOLinesOpacity(unsigned int spwid,
1131 : unsigned int nc)
1132 : {
1133 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1134 0 : return getCOLinesOpacity(v_transfertId_[spwid] + nc);
1135 : }
1136 :
1137 1 : Opacity RefractiveIndexProfile::getN2OLinesOpacity()
1138 : {
1139 1 : return getN2OLinesOpacity(0);
1140 : }
1141 :
1142 99 : Opacity RefractiveIndexProfile::getN2OLinesOpacity(unsigned int nc)
1143 : {
1144 99 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1145 99 : double kv = 0;
1146 4250 : for(unsigned int j = 0; j < numLayer_; j++) {
1147 4151 : kv = kv + imag(vv_N_N2OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1148 : }
1149 99 : return Opacity(kv);
1150 : }
1151 :
1152 0 : Opacity RefractiveIndexProfile::getN2OLinesOpacity(unsigned int spwid,
1153 : unsigned int nc)
1154 : {
1155 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1156 0 : return getN2OLinesOpacity(v_transfertId_[spwid] + nc);
1157 : }
1158 :
1159 0 : Opacity RefractiveIndexProfile::getNO2LinesOpacity()
1160 : {
1161 0 : return getNO2LinesOpacity(0);
1162 : }
1163 :
1164 0 : Opacity RefractiveIndexProfile::getNO2LinesOpacity(unsigned int nc)
1165 : {
1166 0 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1167 0 : double kv = 0;
1168 0 : for(unsigned int j = 0; j < numLayer_; j++) {
1169 0 : kv = kv + imag(vv_N_NO2LinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1170 : }
1171 0 : return Opacity(kv);
1172 : }
1173 :
1174 0 : Opacity RefractiveIndexProfile::getNO2LinesOpacity(unsigned int spwid,
1175 : unsigned int nc)
1176 : {
1177 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1178 0 : return getNO2LinesOpacity(v_transfertId_[spwid] + nc);
1179 : }
1180 :
1181 0 : Opacity RefractiveIndexProfile::getHClLinesOpacity()
1182 : {
1183 0 : return getHClLinesOpacity(0);
1184 : }
1185 :
1186 98 : Opacity RefractiveIndexProfile::getHClLinesOpacity(unsigned int nc)
1187 : {
1188 98 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1189 98 : double kv = 0;
1190 4214 : for(unsigned int j = 0; j < numLayer_; j++) {
1191 4116 : kv = kv + imag(vv_N_HClLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1192 : }
1193 98 : return Opacity(kv);
1194 : }
1195 :
1196 0 : Opacity RefractiveIndexProfile::getHClLinesOpacity(unsigned int spwid,
1197 : unsigned int nc)
1198 : {
1199 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1200 0 : return getHClLinesOpacity(v_transfertId_[spwid] + nc);
1201 : }
1202 :
1203 0 : Opacity RefractiveIndexProfile::getHCNLinesOpacity()
1204 : {
1205 0 : return getHCNLinesOpacity(0);
1206 : }
1207 :
1208 98 : Opacity RefractiveIndexProfile::getHCNLinesOpacity(unsigned int nc)
1209 : {
1210 98 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1211 98 : double kv = 0;
1212 4214 : for(unsigned int j = 0; j < numLayer_; j++) {
1213 4116 : kv = kv + imag(vv_N_HCNLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1214 : }
1215 98 : return Opacity(kv);
1216 : }
1217 :
1218 0 : Opacity RefractiveIndexProfile::getHCNLinesOpacity(unsigned int spwid,
1219 : unsigned int nc)
1220 : {
1221 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1222 0 : return getHCNLinesOpacity(v_transfertId_[spwid] + nc);
1223 : }
1224 :
1225 :
1226 0 : Opacity RefractiveIndexProfile::getSO2LinesOpacity()
1227 : {
1228 0 : return getSO2LinesOpacity(0);
1229 : }
1230 :
1231 0 : Opacity RefractiveIndexProfile::getSO2LinesOpacity(unsigned int nc)
1232 : {
1233 0 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1234 0 : double kv = 0;
1235 0 : for(unsigned int j = 0; j < numLayer_; j++) {
1236 0 : kv = kv + imag(vv_N_SO2LinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1237 : }
1238 0 : return Opacity(kv);
1239 : }
1240 :
1241 0 : Opacity RefractiveIndexProfile::getSO2LinesOpacity(unsigned int spwid,
1242 : unsigned int nc)
1243 : {
1244 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1245 0 : return getSO2LinesOpacity(v_transfertId_[spwid] + nc);
1246 : }
1247 :
1248 :
1249 1 : Opacity RefractiveIndexProfile::getO3LinesOpacity()
1250 : {
1251 1 : return getO3LinesOpacity(0);
1252 : }
1253 99 : Opacity RefractiveIndexProfile::getO3LinesOpacity(unsigned int nc)
1254 : {
1255 99 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1256 99 : double kv = 0;
1257 4250 : for(unsigned int j = 0; j < numLayer_; j++) {
1258 4151 : kv = kv + imag(vv_N_O3LinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1259 : }
1260 99 : return Opacity(kv);
1261 : }
1262 :
1263 0 : Opacity RefractiveIndexProfile::getO3LinesOpacity(unsigned int spwid,
1264 : unsigned int nc)
1265 : {
1266 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1267 0 : return getO3LinesOpacity(v_transfertId_[spwid] + nc);
1268 : }
1269 :
1270 :
1271 0 : Opacity RefractiveIndexProfile::get16O16O16OLinesOpacity()
1272 : {
1273 0 : return get16O16O16OLinesOpacity(0);
1274 : }
1275 :
1276 98 : Opacity RefractiveIndexProfile::get16O16O16OLinesOpacity(unsigned int nc)
1277 : {
1278 98 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1279 98 : double kv = 0;
1280 4214 : for(unsigned int j = 0; j < numLayer_; j++) {
1281 4116 : kv = kv + imag(vv_N_16O16O16OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1282 : }
1283 98 : return Opacity(kv);
1284 : }
1285 :
1286 0 : Opacity RefractiveIndexProfile::get16O16O16OLinesOpacity(unsigned int spwid,
1287 : unsigned int nc)
1288 : {
1289 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1290 0 : return get16O16O16OLinesOpacity(v_transfertId_[spwid] + nc);
1291 : }
1292 :
1293 0 : Opacity RefractiveIndexProfile::get16O16O16OV1LinesOpacity()
1294 0 : {return get16O16O16OV1LinesOpacity(0);}
1295 98 : Opacity RefractiveIndexProfile::get16O16O16OV1LinesOpacity(unsigned int nc)
1296 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0); double kv = 0;
1297 4214 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_16O16O16OV1LinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1298 98 : return Opacity(kv);}
1299 0 : Opacity RefractiveIndexProfile::get16O16O16OV1LinesOpacity(unsigned int spwid, unsigned int nc)
1300 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1301 0 : return get16O16O16OV1LinesOpacity(v_transfertId_[spwid] + nc);}
1302 :
1303 0 : Opacity RefractiveIndexProfile::get16O16O16OV2LinesOpacity()
1304 0 : {return get16O16O16OV2LinesOpacity(0);}
1305 98 : Opacity RefractiveIndexProfile::get16O16O16OV2LinesOpacity(unsigned int nc)
1306 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0); double kv = 0;
1307 4214 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_16O16O16OV2LinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1308 98 : return Opacity(kv);}
1309 0 : Opacity RefractiveIndexProfile::get16O16O16OV2LinesOpacity(unsigned int spwid, unsigned int nc)
1310 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1311 0 : return get16O16O16OV2LinesOpacity(v_transfertId_[spwid] + nc);}
1312 :
1313 0 : Opacity RefractiveIndexProfile::get16O16O16OV3LinesOpacity()
1314 0 : {return get16O16O16OV3LinesOpacity(0);}
1315 98 : Opacity RefractiveIndexProfile::get16O16O16OV3LinesOpacity(unsigned int nc)
1316 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0); double kv = 0;
1317 4214 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_16O16O16OV3LinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1318 98 : return Opacity(kv);}
1319 0 : Opacity RefractiveIndexProfile::get16O16O16OV3LinesOpacity(unsigned int spwid, unsigned int nc)
1320 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1321 0 : return get16O16O16OV3LinesOpacity(v_transfertId_[spwid] + nc);}
1322 :
1323 0 : Opacity RefractiveIndexProfile::get16O16O17OLinesOpacity()
1324 0 : {return get16O16O17OLinesOpacity(0);}
1325 98 : Opacity RefractiveIndexProfile::get16O16O17OLinesOpacity(unsigned int nc)
1326 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0); double kv = 0;
1327 4214 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_16O16O17OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1328 98 : return Opacity(kv);}
1329 0 : Opacity RefractiveIndexProfile::get16O16O17OLinesOpacity(unsigned int spwid, unsigned int nc)
1330 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1331 0 : return get16O16O17OLinesOpacity(v_transfertId_[spwid] + nc);}
1332 :
1333 0 : Opacity RefractiveIndexProfile::get16O16O18OLinesOpacity()
1334 0 : {return get16O16O18OLinesOpacity(0);}
1335 98 : Opacity RefractiveIndexProfile::get16O16O18OLinesOpacity(unsigned int nc)
1336 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0); double kv = 0;
1337 4214 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_16O16O18OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1338 98 : return Opacity(kv);}
1339 0 : Opacity RefractiveIndexProfile::get16O16O18OLinesOpacity(unsigned int spwid, unsigned int nc)
1340 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1341 0 : return get16O16O18OLinesOpacity(v_transfertId_[spwid] + nc);}
1342 :
1343 0 : Opacity RefractiveIndexProfile::get16O17O16OLinesOpacity()
1344 0 : {return get16O17O16OLinesOpacity(0);}
1345 98 : Opacity RefractiveIndexProfile::get16O17O16OLinesOpacity(unsigned int nc)
1346 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0); double kv = 0;
1347 4214 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_16O17O16OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1348 98 : return Opacity(kv);}
1349 0 : Opacity RefractiveIndexProfile::get16O17O16OLinesOpacity(unsigned int spwid, unsigned int nc)
1350 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1351 0 : return get16O17O16OLinesOpacity(v_transfertId_[spwid] + nc);}
1352 :
1353 0 : Opacity RefractiveIndexProfile::get16O18O16OLinesOpacity()
1354 0 : {return get16O18O16OLinesOpacity(0);}
1355 98 : Opacity RefractiveIndexProfile::get16O18O16OLinesOpacity(unsigned int nc)
1356 98 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0); double kv = 0;
1357 4214 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_16O18O16OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1358 98 : return Opacity(kv);}
1359 0 : Opacity RefractiveIndexProfile::get16O18O16OLinesOpacity(unsigned int spwid, unsigned int nc)
1360 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1361 0 : return get16O18O16OLinesOpacity(v_transfertId_[spwid] + nc);}
1362 :
1363 :
1364 :
1365 1 : Opacity RefractiveIndexProfile::getWetOpacity(const Length &integratedwatercolumn)
1366 : {
1367 : // std::cout << "1 integratedwatercolumn.get()=" << integratedwatercolumn.get() << std::endl;
1368 : // std::cout << "2 getGroundWH2O().get()=" << getGroundWH2O().get() << std::endl;
1369 : // std::cout << "3 getWetOpacity()=" << std::endl;
1370 : // std::cout << "4 " << std::endl;
1371 2 : return getWetOpacity(getGroundWH2O(),0)*(integratedwatercolumn.get()/getGroundWH2O().get());
1372 :
1373 : // 2010_SEP02: return getWetOpacity(integratedwatercolumn,0)*(integratedwatercolumn.get()/getGroundWH2O().get());
1374 : }
1375 :
1376 1 : Opacity RefractiveIndexProfile::getWetOpacity(const Length &integratedwatercolumn,
1377 : unsigned int nc)
1378 : {
1379 1 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1380 1 : double kv = 0;
1381 : /* std::cout<<"nc="<<nc<<endl; */
1382 36 : for(unsigned int j = 0; j < numLayer_; j++) {
1383 35 : kv = kv + imag(vv_N_H2OLinesPtr_[nc]->at(j) + vv_N_H2OContPtr_[nc]->at(j))
1384 35 : * v_layerThickness_[j];
1385 :
1386 : }
1387 2 : return Opacity(kv*(integratedwatercolumn.get()/getGroundWH2O().get()));
1388 : }
1389 :
1390 0 : Opacity RefractiveIndexProfile::getWetOpacity(const Length & integratedwatercolumn,
1391 : unsigned int spwid,
1392 : unsigned int nc)
1393 : {
1394 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1395 0 : return getWetOpacity(integratedwatercolumn,v_transfertId_[spwid] + nc);
1396 : }
1397 :
1398 0 : Opacity RefractiveIndexProfile::getAverageWetOpacity(const Length &integratedwatercolumn,
1399 : unsigned int spwid)
1400 : {
1401 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
1402 0 : Opacity totalaverage;
1403 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
1404 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
1405 0 : totalaverage = totalaverage + getWetOpacity(integratedwatercolumn, spwid, nc);
1406 : }
1407 0 : totalaverage = totalaverage / getNumChan(spwid);
1408 0 : return totalaverage;
1409 0 : }
1410 :
1411 1 : Opacity RefractiveIndexProfile::getH2OLinesOpacity(const Length &integratedwatercolumn)
1412 1 : { return getH2OLinesOpacity(integratedwatercolumn,0);}
1413 :
1414 1 : Opacity RefractiveIndexProfile::getH2OLinesOpacity(const Length &integratedwatercolumn, unsigned int nc)
1415 1 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1416 1 : double kv = 0;
1417 36 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_H2OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1418 2 : return Opacity(kv*(integratedwatercolumn.get()/getGroundWH2O().get()));
1419 : }
1420 0 : Opacity RefractiveIndexProfile::getH2OLinesOpacity(const Length &integratedwatercolumn, unsigned int spwid, unsigned int nc)
1421 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1422 0 : return getH2OLinesOpacity(integratedwatercolumn,v_transfertId_[spwid] + nc);}
1423 :
1424 0 : Opacity RefractiveIndexProfile::getAverageH2OLinesOpacity(const Length &integratedwatercolumn,unsigned int spwid)
1425 0 : { if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
1426 0 : Opacity totalaverage; totalaverage = Opacity(0.0, Opacity::UnitNeper);
1427 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
1428 0 : totalaverage = totalaverage + getH2OLinesOpacity(integratedwatercolumn,spwid, nc);}
1429 0 : totalaverage = totalaverage / getNumChan(spwid);
1430 0 : return totalaverage;
1431 0 : }
1432 :
1433 0 : Opacity RefractiveIndexProfile::getHH16OLinesOpacity(const Length &integratedwatercolumn)
1434 0 : { return getHH16OLinesOpacity(integratedwatercolumn,0);}
1435 :
1436 0 : Opacity RefractiveIndexProfile::getHH16OLinesOpacity(const Length &integratedwatercolumn, unsigned int nc)
1437 0 : { if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1438 0 : double kv = 0;
1439 0 : for(unsigned int j = 0; j < numLayer_; j++) { kv = kv + imag(vv_N_HH16OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];}
1440 0 : return Opacity(kv*(integratedwatercolumn.get()/getGroundWH2O().get()));
1441 : }
1442 0 : Opacity RefractiveIndexProfile::getHH16OLinesOpacity(const Length &integratedwatercolumn, unsigned int spwid, unsigned int nc)
1443 0 : { if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1444 0 : return getHH16OLinesOpacity(integratedwatercolumn,v_transfertId_[spwid] + nc);}
1445 :
1446 0 : Opacity RefractiveIndexProfile::getAverageHH16OLinesOpacity(const Length &integratedwatercolumn,unsigned int spwid)
1447 0 : { if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
1448 0 : Opacity totalaverage; totalaverage = Opacity(0.0, Opacity::UnitNeper);
1449 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
1450 0 : totalaverage = totalaverage + getHH16OLinesOpacity(integratedwatercolumn,spwid, nc);}
1451 0 : totalaverage = totalaverage / getNumChan(spwid);
1452 0 : return totalaverage;
1453 0 : }
1454 :
1455 :
1456 :
1457 :
1458 1 : Opacity RefractiveIndexProfile::getH2OContOpacity(const Length &integratedwatercolumn)
1459 : {
1460 1 : return getH2OContOpacity(integratedwatercolumn,0);
1461 : }
1462 :
1463 :
1464 1 : Opacity RefractiveIndexProfile::getH2OContOpacity(const Length &integratedwatercolumn,
1465 : unsigned int nc)
1466 : {
1467 1 : if(!chanIndexIsValid(nc)) return Opacity(-999.0);
1468 1 : double kv = 0;
1469 36 : for(unsigned int j = 0; j < numLayer_; j++) {
1470 35 : kv = kv + imag(vv_N_H2OContPtr_[nc]->at(j)) * v_layerThickness_[j];
1471 : }
1472 2 : return Opacity(kv*(integratedwatercolumn.get()/getGroundWH2O().get()));
1473 : }
1474 :
1475 :
1476 0 : Opacity RefractiveIndexProfile::getH2OContOpacity(const Length &integratedwatercolumn,
1477 : unsigned int spwid,
1478 : unsigned int nc)
1479 : {
1480 0 : if(!spwidAndIndexAreValid(spwid, nc)) return Opacity(-999.0);
1481 0 : return getH2OContOpacity(integratedwatercolumn,v_transfertId_[spwid] + nc);
1482 : }
1483 :
1484 :
1485 :
1486 0 : Opacity RefractiveIndexProfile::getAverageH2OContOpacity(const Length &integratedwatercolumn,
1487 : unsigned int spwid)
1488 : {
1489 0 : if(!spwidAndIndexAreValid(spwid, 0)) return Opacity(-999.0);
1490 0 : Opacity totalaverage;
1491 0 : totalaverage = Opacity(0.0, Opacity::UnitNeper);
1492 0 : for(unsigned int nc = 0; nc < getNumChan(spwid); nc++) {
1493 0 : totalaverage = totalaverage + getH2OContOpacity(integratedwatercolumn,spwid, nc);
1494 : }
1495 0 : totalaverage = totalaverage / getNumChan(spwid);
1496 0 : return totalaverage;
1497 0 : }
1498 :
1499 0 : Angle RefractiveIndexProfile::getDispersiveH2OPhaseDelay(const Length &integratedwatercolumn)
1500 : {
1501 0 : return getDispersiveH2OPhaseDelay(integratedwatercolumn,0);
1502 : }
1503 :
1504 2 : Length RefractiveIndexProfile::getDispersiveH2OPathLength(const Length &integratedwatercolumn)
1505 : {
1506 2 : return getDispersiveH2OPathLength(integratedwatercolumn,0);
1507 : }
1508 :
1509 2 : Angle RefractiveIndexProfile::getDispersiveH2OPhaseDelay(const Length &integratedwatercolumn,
1510 : unsigned int nc)
1511 : {
1512 2 : if(!chanIndexIsValid(nc)) {
1513 0 : return Angle(-999.0, Angle::UnitDegree);
1514 : }
1515 2 : double kv = 0;
1516 72 : for(unsigned int j = 0; j < numLayer_; j++) {
1517 70 : kv = kv + real(vv_N_H2OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1518 : }
1519 2 : Angle aa(kv*(integratedwatercolumn.get()/getGroundWH2O().get())* 57.29578, Angle::UnitDegree);
1520 2 : return aa;
1521 2 : }
1522 :
1523 2 : Length RefractiveIndexProfile::getDispersiveH2OPathLength(const Length &integratedwatercolumn,
1524 : unsigned int nc)
1525 : {
1526 2 : if(!chanIndexIsValid(nc)) {
1527 0 : return Length(-999.0, Length::UnitMeter);
1528 : }
1529 2 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
1530 2 : Length ll((wavelength / 360.0) * getDispersiveH2OPhaseDelay(integratedwatercolumn,nc).get(Angle::UnitDegree),
1531 2 : Length::UnitMeter);
1532 2 : return ll;
1533 2 : }
1534 :
1535 0 : Angle RefractiveIndexProfile::getDispersiveH2OPhaseDelay(const Length &integratedwatercolumn,
1536 : unsigned int spwid,
1537 : unsigned int nc)
1538 : {
1539 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1540 0 : return Angle(-999.0, Angle::UnitDegree);
1541 : }
1542 0 : return getDispersiveH2OPhaseDelay(integratedwatercolumn,v_transfertId_[spwid] + nc);
1543 : }
1544 :
1545 0 : Angle RefractiveIndexProfile::getAverageDispersiveH2OPhaseDelay(const Length &integratedwatercolumn,
1546 : unsigned int spwid)
1547 : {
1548 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
1549 0 : return Angle(-999.0, Angle::UnitDegree);
1550 : }
1551 0 : double av = 0.0;
1552 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1553 0 : av = av + getDispersiveH2OPhaseDelay(integratedwatercolumn,v_transfertId_[spwid] + i).get(Angle::UnitDegree);
1554 : }
1555 0 : av = av / getNumChan(spwid);
1556 0 : Angle average(av, Angle::UnitDegree);
1557 0 : return average;
1558 0 : }
1559 :
1560 0 : Length RefractiveIndexProfile::getDispersiveH2OPathLength(const Length &integratedwatercolumn,
1561 : unsigned int spwid,
1562 : unsigned int nc)
1563 : {
1564 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1565 0 : return Length(-999.0, Length::UnitMeter);
1566 : }
1567 0 : return getDispersiveH2OPathLength(integratedwatercolumn,v_transfertId_[spwid] + nc);
1568 : }
1569 :
1570 0 : Length RefractiveIndexProfile::getAverageDispersiveH2OPathLength(const Length &integratedwatercolumn,
1571 : unsigned int spwid)
1572 : {
1573 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
1574 0 : return Length(-999.0, Length::UnitMeter);
1575 : }
1576 0 : double av = 0.0;
1577 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1578 0 : av = av + getDispersiveH2OPathLength(integratedwatercolumn,v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
1579 : }
1580 0 : av = av / getNumChan(spwid);
1581 0 : Length average(av, Length::UnitMilliMeter);
1582 0 : return average;
1583 0 : }
1584 :
1585 0 : Angle RefractiveIndexProfile::getNonDispersiveDryPhaseDelay()
1586 : {
1587 0 : return getNonDispersiveDryPhaseDelay(0);
1588 : }
1589 :
1590 1 : Length RefractiveIndexProfile::getNonDispersiveDryPathLength()
1591 : {
1592 1 : return getNonDispersiveDryPathLength(0);
1593 : }
1594 :
1595 0 : Angle RefractiveIndexProfile::getDispersiveDryPhaseDelay()
1596 : {
1597 0 : return getDispersiveDryPhaseDelay(0);
1598 : }
1599 :
1600 0 : Length RefractiveIndexProfile::getDispersiveDryPathLength()
1601 : {
1602 0 : return getDispersiveDryPathLength(0);
1603 : }
1604 :
1605 4801 : Angle RefractiveIndexProfile::getNonDispersiveDryPhaseDelay(unsigned int nc)
1606 : {
1607 4801 : if(!chanIndexIsValid(nc)) {
1608 0 : return Angle(-999.0, Angle::UnitDegree);
1609 : }
1610 4801 : double kv = 0;
1611 133796 : for(unsigned int j = 0; j < numLayer_; j++) {
1612 128995 : kv = kv + real(vv_N_DryContPtr_[nc]->at(j)) * v_layerThickness_[j];
1613 : }
1614 4801 : Angle aa(kv * 57.29578, Angle::UnitDegree);
1615 4801 : return aa;
1616 4801 : }
1617 :
1618 0 : Angle RefractiveIndexProfile::getDispersiveDryPhaseDelay(unsigned int nc)
1619 : {
1620 : // std::cout << "getO2LinesPhaseDelay(" << nc << ")=" << getO2LinesPhaseDelay(nc).get(Angle::UnitDegree) << std::endl;
1621 : // std::cout << "getO3LinesPhaseDelay(" << nc << ")=" << getO3LinesPhaseDelay(nc).get(Angle::UnitDegree) << std::endl;
1622 : // std::cout << "getN2OLinesPhaseDelay(" << nc << ")=" << getN2OLinesPhaseDelay(nc).get(Angle::UnitDegree) << std::endl;
1623 : // std::cout << "getNO2LinesPhaseDelay(" << nc << ")=" << getNO2LinesPhaseDelay(nc).get(Angle::UnitDegree) << std::endl;
1624 : // std::cout << "getHClLinesPhaseDelay(" << nc << ")=" << getHClLinesPhaseDelay(nc).get(Angle::UnitDegree) << std::endl;
1625 : // std::cout << "getHCNLinesPhaseDelay(" << nc << ")=" << getHCNLinesPhaseDelay(nc).get(Angle::UnitDegree) << std::endl;
1626 : // std::cout << "getSO2LinesPhaseDelay(" << nc << ")=" << getSO2LinesPhaseDelay(nc).get(Angle::UnitDegree) << std::endl;
1627 : // std::cout << "getCOLinesPhaseDelay(" << nc << ")=" << getCOLinesPhaseDelay(nc).get(Angle::UnitDegree) << std::endl;
1628 0 : return getO2LinesPhaseDelay(nc) + getO3LinesPhaseDelay(nc)
1629 0 : + getN2OLinesPhaseDelay(nc) + getCOLinesPhaseDelay(nc)
1630 0 : + getNO2LinesPhaseDelay(nc) + getSO2LinesPhaseDelay(nc)
1631 0 : + getHClLinesPhaseDelay(nc) + getHCNLinesPhaseDelay(nc);
1632 : }
1633 :
1634 4801 : Length RefractiveIndexProfile::getNonDispersiveDryPathLength(unsigned int nc)
1635 : {
1636 4801 : if(!chanIndexIsValid(nc)) {
1637 0 : return Length(-999.0, Length::UnitMeter);
1638 : }
1639 4801 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
1640 : Length
1641 4801 : ll((wavelength / 360.0) * getNonDispersiveDryPhaseDelay(nc).get(Angle::UnitDegree),
1642 4801 : Length::UnitMeter);
1643 4801 : return ll;
1644 4801 : }
1645 :
1646 0 : Angle RefractiveIndexProfile::getNonDispersiveDryPhaseDelay(unsigned int spwid,
1647 : unsigned int nc)
1648 : {
1649 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1650 0 : return Angle(-999.0, Angle::UnitDegree);
1651 : }
1652 0 : return getNonDispersiveDryPhaseDelay(v_transfertId_[spwid] + nc);
1653 : }
1654 :
1655 0 : Length RefractiveIndexProfile::getDispersiveDryPathLength(unsigned int nc)
1656 : {
1657 0 : if(!chanIndexIsValid(nc)) {
1658 0 : return Length(-999.0, Length::UnitMeter);
1659 : }
1660 0 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
1661 0 : Length ll((wavelength / 360.0) * getDispersiveDryPhaseDelay(nc).get(Angle::UnitDegree),
1662 0 : Length::UnitMeter);
1663 0 : return ll;
1664 0 : }
1665 :
1666 0 : Angle RefractiveIndexProfile::getDispersiveDryPhaseDelay(unsigned int spwid,
1667 : unsigned int nc)
1668 : {
1669 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1670 0 : return Angle(-999.0, Angle::UnitDegree);
1671 : }
1672 0 : return getDispersiveDryPhaseDelay(v_transfertId_[spwid] + nc);
1673 : }
1674 :
1675 0 : Angle RefractiveIndexProfile::getAverageNonDispersiveDryPhaseDelay(unsigned int spwid)
1676 : {
1677 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
1678 0 : return Angle(-999.0, Angle::UnitDegree);
1679 : }
1680 0 : double av = 0.0;
1681 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1682 0 : av = av
1683 0 : + getNonDispersiveDryPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
1684 : }
1685 0 : av = av / getNumChan(spwid);
1686 0 : Angle average(av, Angle::UnitDegree);
1687 0 : return average;
1688 0 : }
1689 :
1690 0 : Angle RefractiveIndexProfile::getAverageDispersiveDryPhaseDelay(unsigned int spwid)
1691 : {
1692 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
1693 0 : return Angle(-999.0, Angle::UnitDegree);
1694 : }
1695 0 : double av = 0.0;
1696 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1697 0 : av = av + getDispersiveDryPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
1698 : }
1699 0 : av = av / getNumChan(spwid);
1700 0 : Angle average(av, Angle::UnitDegree);
1701 0 : return average;
1702 0 : }
1703 :
1704 0 : Length RefractiveIndexProfile::getNonDispersiveDryPathLength(unsigned int spwid,
1705 : unsigned int nc)
1706 : {
1707 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1708 0 : return Length(-999.0, Length::UnitMeter);
1709 : }
1710 0 : return getNonDispersiveDryPathLength(v_transfertId_[spwid] + nc);
1711 : }
1712 :
1713 0 : Length RefractiveIndexProfile::getDispersiveDryPathLength(unsigned int spwid,
1714 : unsigned int nc)
1715 : {
1716 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1717 0 : return Length(-999.0, Length::UnitMeter);
1718 : }
1719 0 : return getDispersiveDryPathLength(v_transfertId_[spwid] + nc);
1720 : }
1721 :
1722 240 : Length RefractiveIndexProfile::getAverageNonDispersiveDryPathLength(unsigned int spwid)
1723 : {
1724 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
1725 0 : return Length(-999.0, Length::UnitMeter);
1726 : }
1727 240 : double av = 0.0;
1728 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1729 4800 : av = av
1730 4800 : + getNonDispersiveDryPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
1731 : }
1732 240 : av = av / getNumChan(spwid);
1733 240 : Length average(av, Length::UnitMilliMeter);
1734 240 : return average;
1735 240 : }
1736 :
1737 0 : Length RefractiveIndexProfile::getAverageDispersiveDryPathLength(unsigned int spwid)
1738 : {
1739 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
1740 0 : return Length(-999.0, Length::UnitMeter);
1741 : }
1742 0 : double av = 0.0;
1743 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1744 0 : av = av + getDispersiveDryPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
1745 : }
1746 :
1747 0 : av = av / getNumChan(spwid);
1748 0 : Length average(av, Length::UnitMilliMeter);
1749 0 : return average;
1750 0 : }
1751 :
1752 0 : Angle RefractiveIndexProfile::getO2LinesPhaseDelay()
1753 : {
1754 0 : return getO2LinesPhaseDelay(0);
1755 : }
1756 :
1757 1 : Length RefractiveIndexProfile::getO2LinesPathLength()
1758 : {
1759 1 : return getO2LinesPathLength(0);
1760 : }
1761 :
1762 4801 : Angle RefractiveIndexProfile::getO2LinesPhaseDelay(unsigned int nc)
1763 : {
1764 4801 : if(!chanIndexIsValid(nc)) {
1765 0 : return Angle(-999.0, Angle::UnitDegree);
1766 : }
1767 4801 : double kv = 0;
1768 133796 : for(unsigned int j = 0; j < numLayer_; j++) {
1769 128995 : kv = kv + real(vv_N_O2LinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1770 : }
1771 4801 : Angle aa(kv * 57.29578, Angle::UnitDegree);
1772 4801 : return aa;
1773 4801 : }
1774 :
1775 4801 : Length RefractiveIndexProfile::getO2LinesPathLength(unsigned int nc)
1776 : {
1777 4801 : if(!chanIndexIsValid(nc)) {
1778 0 : return Length(-999.0, Length::UnitMeter);
1779 : }
1780 4801 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
1781 4801 : Length ll((wavelength / 360.0) * getO2LinesPhaseDelay(nc).get(Angle::UnitDegree), Length::UnitMeter);
1782 4801 : return ll;
1783 4801 : }
1784 :
1785 0 : Angle RefractiveIndexProfile::getO2LinesPhaseDelay(unsigned int spwid,
1786 : unsigned int nc)
1787 : {
1788 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1789 0 : return Angle(-999.0, Angle::UnitDegree);
1790 : }
1791 0 : return getO2LinesPhaseDelay(v_transfertId_[spwid] + nc);
1792 : }
1793 :
1794 0 : Angle RefractiveIndexProfile::getAverageO2LinesPhaseDelay(unsigned int spwid)
1795 : {
1796 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
1797 0 : return Angle(-999.0, Angle::UnitDegree);
1798 : }
1799 0 : double av = 0.0;
1800 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1801 0 : av = av + getO2LinesPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
1802 : }
1803 0 : av = av / getNumChan(spwid);
1804 0 : Angle average(av, Angle::UnitDegree);
1805 0 : return average;
1806 0 : }
1807 :
1808 0 : Length RefractiveIndexProfile::getO2LinesPathLength(unsigned int spwid,
1809 : unsigned int nc)
1810 : {
1811 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1812 0 : return Length(-999.0, Length::UnitMeter);
1813 : }
1814 0 : return getO2LinesPathLength(v_transfertId_[spwid] + nc);
1815 : }
1816 :
1817 240 : Length RefractiveIndexProfile::getAverageO2LinesPathLength(unsigned int spwid)
1818 : {
1819 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
1820 0 : return Length(-999.0, Length::UnitMeter);
1821 : }
1822 240 : double av = 0.0;
1823 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1824 4800 : av = av + getO2LinesPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
1825 : }
1826 240 : av = av / getNumChan(spwid);
1827 240 : Length average(av, Length::UnitMilliMeter);
1828 240 : return average;
1829 240 : }
1830 :
1831 0 : Angle RefractiveIndexProfile::getO3LinesPhaseDelay()
1832 : {
1833 0 : return getO3LinesPhaseDelay(0);
1834 : }
1835 :
1836 1 : Length RefractiveIndexProfile::getO3LinesPathLength()
1837 : {
1838 1 : return getO3LinesPathLength(0);
1839 : }
1840 :
1841 4801 : Angle RefractiveIndexProfile::getO3LinesPhaseDelay(unsigned int nc)
1842 : {
1843 4801 : if(!chanIndexIsValid(nc)) {
1844 0 : return Angle(-999.0, Angle::UnitDegree);
1845 : }
1846 4801 : double kv = 0;
1847 :
1848 : // if(nc=66){cout << "vv_N_O3LinesPtr_" << ".size()=" << vv_N_O3LinesPtr_.size() << std::endl;}
1849 :
1850 133796 : for(unsigned int j = 0; j < numLayer_; j++) {
1851 : /* if(nc=66){
1852 : std::cout << "j=" << j << " vv_N_O3LinesPtr_[" << nc << "]->at(" << j << ")=" << vv_N_O3LinesPtr_[nc]->at(j) << std::endl;
1853 : } */
1854 128995 : kv = kv + real(vv_N_O3LinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1855 : }
1856 4801 : Angle aa(kv * 57.29578, Angle::UnitDegree);
1857 4801 : return aa;
1858 4801 : }
1859 :
1860 4801 : Length RefractiveIndexProfile::getO3LinesPathLength(unsigned int nc)
1861 : {
1862 4801 : if(!chanIndexIsValid(nc)) {
1863 0 : return Length(-999.0, Length::UnitMeter);
1864 : }
1865 4801 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
1866 4801 : Length ll((wavelength / 360.0) * getO3LinesPhaseDelay(nc).get(Angle::UnitDegree), Length::UnitMeter);
1867 4801 : return ll;
1868 4801 : }
1869 :
1870 0 : Angle RefractiveIndexProfile::getO3LinesPhaseDelay(unsigned int spwid,
1871 : unsigned int nc)
1872 : {
1873 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1874 0 : return Angle(-999.0, Angle::UnitDegree);
1875 : }
1876 0 : return getO3LinesPhaseDelay(v_transfertId_[spwid] + nc);
1877 : }
1878 :
1879 0 : Angle RefractiveIndexProfile::getAverageO3LinesPhaseDelay(unsigned int spwid)
1880 : {
1881 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
1882 0 : return Angle(-999.0, Angle::UnitDegree);
1883 : }
1884 0 : double av = 0.0;
1885 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1886 0 : av = av + getO3LinesPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
1887 : }
1888 0 : av = av / getNumChan(spwid);
1889 0 : Angle average(av, Angle::UnitDegree);
1890 0 : return average;
1891 0 : }
1892 :
1893 0 : Length RefractiveIndexProfile::getO3LinesPathLength(unsigned int spwid,
1894 : unsigned int nc)
1895 : {
1896 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1897 0 : return Length(-999.0, Length::UnitMeter);
1898 : }
1899 0 : return getO3LinesPathLength(v_transfertId_[spwid] + nc);
1900 : }
1901 :
1902 240 : Length RefractiveIndexProfile::getAverageO3LinesPathLength(unsigned int spwid)
1903 : {
1904 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
1905 0 : return Length(-999.0, Length::UnitMeter);
1906 : }
1907 240 : double av = 0.0;
1908 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1909 4800 : av = av + getO3LinesPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
1910 : }
1911 240 : av = av / getNumChan(spwid);
1912 240 : Length average(av, Length::UnitMilliMeter);
1913 240 : return average;
1914 240 : }
1915 :
1916 0 : Angle RefractiveIndexProfile::getCOLinesPhaseDelay()
1917 : {
1918 0 : return getCOLinesPhaseDelay(0);
1919 : }
1920 :
1921 1 : Length RefractiveIndexProfile::getCOLinesPathLength()
1922 : {
1923 1 : return getCOLinesPathLength(0);
1924 : }
1925 :
1926 4801 : Angle RefractiveIndexProfile::getCOLinesPhaseDelay(unsigned int nc)
1927 : {
1928 4801 : if(!chanIndexIsValid(nc)) {
1929 0 : return Angle(-999.0, Angle::UnitDegree);
1930 : }
1931 4801 : double kv = 0;
1932 133796 : for(unsigned int j = 0; j < numLayer_; j++) {
1933 128995 : kv = kv + real(vv_N_COLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
1934 : }
1935 4801 : Angle aa(kv * 57.29578, Angle::UnitDegree);
1936 4801 : return aa;
1937 4801 : }
1938 :
1939 4801 : Length RefractiveIndexProfile::getCOLinesPathLength(unsigned int nc)
1940 : {
1941 4801 : if(!chanIndexIsValid(nc)) {
1942 0 : return Length(-999.0, Length::UnitMeter);
1943 : }
1944 4801 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
1945 4801 : Length ll((wavelength / 360.0) * getCOLinesPhaseDelay(nc).get(Angle::UnitDegree), Length::UnitMeter);
1946 4801 : return ll;
1947 4801 : }
1948 :
1949 0 : Angle RefractiveIndexProfile::getCOLinesPhaseDelay(unsigned int spwid,
1950 : unsigned int nc)
1951 : {
1952 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1953 0 : return Angle(-999.0, Angle::UnitDegree);
1954 : }
1955 0 : return getCOLinesPhaseDelay(v_transfertId_[spwid] + nc);
1956 : }
1957 :
1958 0 : Angle RefractiveIndexProfile::getAverageCOLinesPhaseDelay(unsigned int spwid)
1959 : {
1960 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
1961 0 : return Angle(-999.0, Angle::UnitDegree);
1962 : }
1963 0 : double av = 0.0;
1964 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1965 0 : av = av + getCOLinesPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
1966 : }
1967 0 : av = av / getNumChan(spwid);
1968 0 : Angle average(av, Angle::UnitDegree);
1969 0 : return average;
1970 0 : }
1971 :
1972 0 : Length RefractiveIndexProfile::getCOLinesPathLength(unsigned int spwid,
1973 : unsigned int nc)
1974 : {
1975 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
1976 0 : return Length(-999.0, Length::UnitMeter);
1977 : }
1978 0 : return getCOLinesPathLength(v_transfertId_[spwid] + nc);
1979 : }
1980 :
1981 240 : Length RefractiveIndexProfile::getAverageCOLinesPathLength(unsigned int spwid)
1982 : {
1983 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
1984 0 : return Length(-999.0, Length::UnitMeter);
1985 : }
1986 240 : double av = 0.0;
1987 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
1988 4800 : av = av + getCOLinesPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
1989 : }
1990 240 : av = av / getNumChan(spwid);
1991 240 : Length average(av, Length::UnitMilliMeter);
1992 240 : return average;
1993 240 : }
1994 :
1995 0 : Angle RefractiveIndexProfile::getN2OLinesPhaseDelay()
1996 : {
1997 0 : return getN2OLinesPhaseDelay(0);
1998 : }
1999 :
2000 1 : Length RefractiveIndexProfile::getN2OLinesPathLength()
2001 : {
2002 1 : return getN2OLinesPathLength(0);
2003 : }
2004 :
2005 4801 : Angle RefractiveIndexProfile::getN2OLinesPhaseDelay(unsigned int nc)
2006 : {
2007 4801 : if(!chanIndexIsValid(nc)) {
2008 0 : return Angle(-999.0, Angle::UnitDegree);
2009 : }
2010 4801 : double kv = 0;
2011 133796 : for(unsigned int j = 0; j < numLayer_; j++) {
2012 128995 : kv = kv + real(vv_N_N2OLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
2013 : }
2014 4801 : Angle aa(kv * 57.29578, Angle::UnitDegree);
2015 4801 : return aa;
2016 4801 : }
2017 :
2018 4801 : Length RefractiveIndexProfile::getN2OLinesPathLength(unsigned int nc)
2019 : {
2020 4801 : if(!chanIndexIsValid(nc)) {
2021 0 : return Length(-999.0, Length::UnitMeter);
2022 : }
2023 4801 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
2024 4801 : Length ll((wavelength / 360.0) * getN2OLinesPhaseDelay(nc).get(Angle::UnitDegree), Length::UnitMeter);
2025 4801 : return ll;
2026 4801 : }
2027 :
2028 0 : Angle RefractiveIndexProfile::getN2OLinesPhaseDelay(unsigned int spwid,
2029 : unsigned int nc)
2030 : {
2031 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2032 0 : return Angle(-999.0, Angle::UnitDegree);
2033 : }
2034 0 : return getN2OLinesPhaseDelay(v_transfertId_[spwid] + nc);
2035 : }
2036 :
2037 0 : Angle RefractiveIndexProfile::getAverageN2OLinesPhaseDelay(unsigned int spwid)
2038 : {
2039 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
2040 0 : return Angle(-999.0, Angle::UnitDegree);
2041 : }
2042 0 : double av = 0.0;
2043 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2044 0 : av = av + getN2OLinesPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
2045 : }
2046 0 : av = av / getNumChan(spwid);
2047 0 : Angle average(av, Angle::UnitDegree);
2048 0 : return average;
2049 0 : }
2050 :
2051 0 : Length RefractiveIndexProfile::getN2OLinesPathLength(unsigned int spwid,
2052 : unsigned int nc)
2053 : {
2054 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2055 0 : return Length(-999.0, Length::UnitMeter);
2056 : }
2057 0 : return getN2OLinesPathLength(v_transfertId_[spwid] + nc);
2058 : }
2059 :
2060 240 : Length RefractiveIndexProfile::getAverageN2OLinesPathLength(unsigned int spwid)
2061 : {
2062 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
2063 0 : return Length(-999.0, Length::UnitMeter);
2064 : }
2065 240 : double av = 0.0;
2066 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2067 4800 : av = av + getN2OLinesPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
2068 : }
2069 240 : av = av / getNumChan(spwid);
2070 240 : Length average(av, Length::UnitMilliMeter);
2071 240 : return average;
2072 240 : }
2073 :
2074 :
2075 :
2076 :
2077 :
2078 :
2079 0 : Angle RefractiveIndexProfile::getNO2LinesPhaseDelay()
2080 : {
2081 0 : return getNO2LinesPhaseDelay(0);
2082 : }
2083 :
2084 0 : Length RefractiveIndexProfile::getNO2LinesPathLength()
2085 : {
2086 0 : return getNO2LinesPathLength(0);
2087 : }
2088 :
2089 4800 : Angle RefractiveIndexProfile::getNO2LinesPhaseDelay(unsigned int nc)
2090 : {
2091 4800 : if(!chanIndexIsValid(nc)) {
2092 0 : return Angle(-999.0, Angle::UnitDegree);
2093 : }
2094 4800 : double kv = 0;
2095 133760 : for(unsigned int j = 0; j < numLayer_; j++) {
2096 128960 : kv = kv + real(vv_N_NO2LinesPtr_[nc]->at(j)) * v_layerThickness_[j];
2097 : }
2098 4800 : Angle aa(kv * 57.29578, Angle::UnitDegree);
2099 4800 : return aa;
2100 4800 : }
2101 :
2102 4800 : Length RefractiveIndexProfile::getNO2LinesPathLength(unsigned int nc)
2103 : {
2104 4800 : if(!chanIndexIsValid(nc)) {
2105 0 : return Length(-999.0, Length::UnitMeter);
2106 : }
2107 4800 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
2108 4800 : Length ll((wavelength / 360.0) * getNO2LinesPhaseDelay(nc).get(Angle::UnitDegree), Length::UnitMeter);
2109 4800 : return ll;
2110 4800 : }
2111 :
2112 0 : Angle RefractiveIndexProfile::getNO2LinesPhaseDelay(unsigned int spwid,
2113 : unsigned int nc)
2114 : {
2115 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2116 0 : return Angle(-999.0, Angle::UnitDegree);
2117 : }
2118 0 : return getNO2LinesPhaseDelay(v_transfertId_[spwid] + nc);
2119 : }
2120 :
2121 0 : Angle RefractiveIndexProfile::getAverageNO2LinesPhaseDelay(unsigned int spwid)
2122 : {
2123 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
2124 0 : return Angle(-999.0, Angle::UnitDegree);
2125 : }
2126 0 : double av = 0.0;
2127 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2128 0 : av = av + getNO2LinesPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
2129 : }
2130 0 : av = av / getNumChan(spwid);
2131 0 : Angle average(av, Angle::UnitDegree);
2132 0 : return average;
2133 0 : }
2134 :
2135 0 : Length RefractiveIndexProfile::getNO2LinesPathLength(unsigned int spwid,
2136 : unsigned int nc)
2137 : {
2138 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2139 0 : return Length(-999.0, Length::UnitMeter);
2140 : }
2141 0 : return getNO2LinesPathLength(v_transfertId_[spwid] + nc);
2142 : }
2143 :
2144 240 : Length RefractiveIndexProfile::getAverageNO2LinesPathLength(unsigned int spwid)
2145 : {
2146 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
2147 0 : return Length(-999.0, Length::UnitMeter);
2148 : }
2149 240 : double av = 0.0;
2150 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2151 4800 : av = av + getNO2LinesPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
2152 : }
2153 240 : av = av / getNumChan(spwid);
2154 240 : Length average(av, Length::UnitMilliMeter);
2155 240 : return average;
2156 240 : }
2157 :
2158 :
2159 :
2160 :
2161 :
2162 :
2163 :
2164 :
2165 0 : Angle RefractiveIndexProfile::getSO2LinesPhaseDelay()
2166 : {
2167 0 : return getSO2LinesPhaseDelay(0);
2168 : }
2169 :
2170 0 : Length RefractiveIndexProfile::getSO2LinesPathLength()
2171 : {
2172 0 : return getSO2LinesPathLength(0);
2173 : }
2174 :
2175 4800 : Angle RefractiveIndexProfile::getSO2LinesPhaseDelay(unsigned int nc)
2176 : {
2177 4800 : if(!chanIndexIsValid(nc)) {
2178 0 : return Angle(-999.0, Angle::UnitDegree);
2179 : }
2180 4800 : double kv = 0;
2181 133760 : for(unsigned int j = 0; j < numLayer_; j++) {
2182 128960 : kv = kv + real(vv_N_SO2LinesPtr_[nc]->at(j)) * v_layerThickness_[j];
2183 : }
2184 4800 : Angle aa(kv * 57.29578, Angle::UnitDegree);
2185 4800 : return aa;
2186 4800 : }
2187 :
2188 4800 : Length RefractiveIndexProfile::getSO2LinesPathLength(unsigned int nc)
2189 : {
2190 4800 : if(!chanIndexIsValid(nc)) {
2191 0 : return Length(-999.0, Length::UnitMeter);
2192 : }
2193 4800 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
2194 4800 : Length ll((wavelength / 360.0) * getSO2LinesPhaseDelay(nc).get(Angle::UnitDegree), Length::UnitMeter);
2195 4800 : return ll;
2196 4800 : }
2197 :
2198 0 : Angle RefractiveIndexProfile::getSO2LinesPhaseDelay(unsigned int spwid,
2199 : unsigned int nc)
2200 : {
2201 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2202 0 : return Angle(-999.0, Angle::UnitDegree);
2203 : }
2204 0 : return getSO2LinesPhaseDelay(v_transfertId_[spwid] + nc);
2205 : }
2206 :
2207 0 : Angle RefractiveIndexProfile::getAverageSO2LinesPhaseDelay(unsigned int spwid)
2208 : {
2209 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
2210 0 : return Angle(-999.0, Angle::UnitDegree);
2211 : }
2212 0 : double av = 0.0;
2213 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2214 0 : av = av + getSO2LinesPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
2215 : }
2216 0 : av = av / getNumChan(spwid);
2217 0 : Angle average(av, Angle::UnitDegree);
2218 0 : return average;
2219 0 : }
2220 :
2221 0 : Length RefractiveIndexProfile::getSO2LinesPathLength(unsigned int spwid,
2222 : unsigned int nc)
2223 : {
2224 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2225 0 : return Length(-999.0, Length::UnitMeter);
2226 : }
2227 0 : return getSO2LinesPathLength(v_transfertId_[spwid] + nc);
2228 : }
2229 :
2230 240 : Length RefractiveIndexProfile::getAverageSO2LinesPathLength(unsigned int spwid)
2231 : {
2232 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
2233 0 : return Length(-999.0, Length::UnitMeter);
2234 : }
2235 240 : double av = 0.0;
2236 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2237 4800 : av = av + getSO2LinesPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
2238 : }
2239 240 : av = av / getNumChan(spwid);
2240 240 : Length average(av, Length::UnitMilliMeter);
2241 240 : return average;
2242 240 : }
2243 :
2244 :
2245 :
2246 0 : Angle RefractiveIndexProfile::getHClLinesPhaseDelay()
2247 : {
2248 0 : return getHClLinesPhaseDelay(0);
2249 : }
2250 :
2251 0 : Length RefractiveIndexProfile::getHClLinesPathLength()
2252 : {
2253 0 : return getHClLinesPathLength(0);
2254 : }
2255 :
2256 4800 : Angle RefractiveIndexProfile::getHClLinesPhaseDelay(unsigned int nc)
2257 : {
2258 4800 : if(!chanIndexIsValid(nc)) {
2259 0 : return Angle(-999.0, Angle::UnitDegree);
2260 : }
2261 4800 : double kv = 0;
2262 133760 : for(unsigned int j = 0; j < numLayer_; j++) {
2263 128960 : kv = kv + real(vv_N_HClLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
2264 : }
2265 4800 : Angle aa(kv * 57.29578, Angle::UnitDegree);
2266 4800 : return aa;
2267 4800 : }
2268 :
2269 4800 : Length RefractiveIndexProfile::getHClLinesPathLength(unsigned int nc)
2270 : {
2271 4800 : if(!chanIndexIsValid(nc)) {
2272 0 : return Length(-999.0, Length::UnitMeter);
2273 : }
2274 4800 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
2275 4800 : Length ll((wavelength / 360.0) * getHClLinesPhaseDelay(nc).get(Angle::UnitDegree), Length::UnitMeter);
2276 4800 : return ll;
2277 4800 : }
2278 :
2279 0 : Angle RefractiveIndexProfile::getHClLinesPhaseDelay(unsigned int spwid,
2280 : unsigned int nc)
2281 : {
2282 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2283 0 : return Angle(-999.0, Angle::UnitDegree);
2284 : }
2285 0 : return getHClLinesPhaseDelay(v_transfertId_[spwid] + nc);
2286 : }
2287 :
2288 0 : Angle RefractiveIndexProfile::getAverageHClLinesPhaseDelay(unsigned int spwid)
2289 : {
2290 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
2291 0 : return Angle(-999.0, Angle::UnitDegree);
2292 : }
2293 0 : double av = 0.0;
2294 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2295 0 : av = av + getHClLinesPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
2296 : }
2297 0 : av = av / getNumChan(spwid);
2298 0 : Angle average(av, Angle::UnitDegree);
2299 0 : return average;
2300 0 : }
2301 :
2302 0 : Length RefractiveIndexProfile::getHClLinesPathLength(unsigned int spwid,
2303 : unsigned int nc)
2304 : {
2305 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2306 0 : return Length(-999.0, Length::UnitMeter);
2307 : }
2308 0 : return getHClLinesPathLength(v_transfertId_[spwid] + nc);
2309 : }
2310 :
2311 240 : Length RefractiveIndexProfile::getAverageHClLinesPathLength(unsigned int spwid)
2312 : {
2313 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
2314 0 : return Length(-999.0, Length::UnitMeter);
2315 : }
2316 240 : double av = 0.0;
2317 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2318 4800 : av = av + getHClLinesPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
2319 : }
2320 240 : av = av / getNumChan(spwid);
2321 240 : Length average(av, Length::UnitMilliMeter);
2322 240 : return average;
2323 240 : }
2324 :
2325 :
2326 :
2327 :
2328 :
2329 0 : Angle RefractiveIndexProfile::getHCNLinesPhaseDelay()
2330 : {
2331 0 : return getHCNLinesPhaseDelay(0);
2332 : }
2333 :
2334 0 : Length RefractiveIndexProfile::getHCNLinesPathLength()
2335 : {
2336 0 : return getHCNLinesPathLength(0);
2337 : }
2338 :
2339 4800 : Angle RefractiveIndexProfile::getHCNLinesPhaseDelay(unsigned int nc)
2340 : {
2341 4800 : if(!chanIndexIsValid(nc)) {
2342 0 : return Angle(-999.0, Angle::UnitDegree);
2343 : }
2344 4800 : double kv = 0;
2345 133760 : for(unsigned int j = 0; j < numLayer_; j++) {
2346 128960 : kv = kv + real(vv_N_HCNLinesPtr_[nc]->at(j)) * v_layerThickness_[j];
2347 : }
2348 4800 : Angle aa(kv * 57.29578, Angle::UnitDegree);
2349 4800 : return aa;
2350 4800 : }
2351 :
2352 4800 : Length RefractiveIndexProfile::getHCNLinesPathLength(unsigned int nc)
2353 : {
2354 4800 : if(!chanIndexIsValid(nc)) {
2355 0 : return Length(-999.0, Length::UnitMeter);
2356 : }
2357 4800 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
2358 4800 : Length ll((wavelength / 360.0) * getHCNLinesPhaseDelay(nc).get(Angle::UnitDegree), Length::UnitMeter);
2359 4800 : return ll;
2360 4800 : }
2361 :
2362 0 : Angle RefractiveIndexProfile::getHCNLinesPhaseDelay(unsigned int spwid,
2363 : unsigned int nc)
2364 : {
2365 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2366 0 : return Angle(-999.0, Angle::UnitDegree);
2367 : }
2368 0 : return getHCNLinesPhaseDelay(v_transfertId_[spwid] + nc);
2369 : }
2370 :
2371 0 : Angle RefractiveIndexProfile::getAverageHCNLinesPhaseDelay(unsigned int spwid)
2372 : {
2373 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
2374 0 : return Angle(-999.0, Angle::UnitDegree);
2375 : }
2376 0 : double av = 0.0;
2377 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2378 0 : av = av + getHCNLinesPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
2379 : }
2380 0 : av = av / getNumChan(spwid);
2381 0 : Angle average(av, Angle::UnitDegree);
2382 0 : return average;
2383 0 : }
2384 :
2385 0 : Length RefractiveIndexProfile::getHCNLinesPathLength(unsigned int spwid,
2386 : unsigned int nc)
2387 : {
2388 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2389 0 : return Length(-999.0, Length::UnitMeter);
2390 : }
2391 0 : return getHCNLinesPathLength(v_transfertId_[spwid] + nc);
2392 : }
2393 :
2394 240 : Length RefractiveIndexProfile::getAverageHCNLinesPathLength(unsigned int spwid)
2395 : {
2396 240 : if(!spwidAndIndexAreValid(spwid, 0)) {
2397 0 : return Length(-999.0, Length::UnitMeter);
2398 : }
2399 240 : double av = 0.0;
2400 5040 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2401 4800 : av = av + getHCNLinesPathLength(v_transfertId_[spwid] + i).get(Length::UnitMilliMeter);
2402 : }
2403 240 : av = av / getNumChan(spwid);
2404 240 : Length average(av, Length::UnitMilliMeter);
2405 240 : return average;
2406 240 : }
2407 :
2408 :
2409 :
2410 :
2411 :
2412 0 : Angle RefractiveIndexProfile::getNonDispersiveH2OPhaseDelay(const Length &integratedwatercolumn)
2413 : {
2414 0 : return getNonDispersiveH2OPhaseDelay(integratedwatercolumn,0);
2415 : }
2416 :
2417 2 : Length RefractiveIndexProfile::getNonDispersiveH2OPathLength(const Length &integratedwatercolumn)
2418 : {
2419 2 : return getNonDispersiveH2OPathLength(integratedwatercolumn,0);
2420 : }
2421 :
2422 2 : Angle RefractiveIndexProfile::getNonDispersiveH2OPhaseDelay(const Length &integratedwatercolumn,
2423 : unsigned int nc)
2424 : {
2425 2 : double kv = 0;
2426 2 : if(!chanIndexIsValid(nc)) {
2427 0 : return Angle(-999.0, Angle::UnitDegree);
2428 : }
2429 72 : for(unsigned int j = 0; j < numLayer_; j++) {
2430 70 : kv = kv + real(vv_N_H2OContPtr_[nc]->at(j)) * v_layerThickness_[j];
2431 : }
2432 2 : Angle aa(kv*(integratedwatercolumn.get()/getGroundWH2O().get())* 57.29578, Angle::UnitDegree);
2433 2 : return aa;
2434 2 : }
2435 :
2436 2 : Length RefractiveIndexProfile::getNonDispersiveH2OPathLength(const Length &integratedwatercolumn,
2437 : unsigned int nc)
2438 : {
2439 2 : if(!chanIndexIsValid(nc)) {
2440 0 : return Length(-999.0, Length::UnitMeter);
2441 : }
2442 2 : double wavelength = 299792458.0 / v_chanFreq_[nc]; // in m
2443 2 : Length ll((wavelength / 360.0) * getNonDispersiveH2OPhaseDelay(integratedwatercolumn,nc).get(Angle::UnitDegree),Length::UnitMeter);
2444 2 : return ll;
2445 2 : }
2446 :
2447 0 : Angle RefractiveIndexProfile::getNonDispersiveH2OPhaseDelay(const Length &integratedwatercolumn,
2448 : unsigned int spwid,
2449 : unsigned int nc)
2450 : {
2451 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2452 0 : return Angle(-999.0, Angle::UnitDegree);
2453 : }
2454 0 : return getNonDispersiveH2OPhaseDelay(integratedwatercolumn,v_transfertId_[spwid] + nc);
2455 : }
2456 :
2457 0 : Angle RefractiveIndexProfile::getAverageNonDispersiveH2OPhaseDelay(const Length &integratedwatercolumn,
2458 : unsigned int spwid)
2459 : {
2460 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
2461 0 : return Angle(-999.0, Angle::UnitDegree);
2462 : }
2463 0 : double av = 0.0;
2464 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2465 0 : av = av
2466 0 : + getNonDispersiveH2OPhaseDelay(v_transfertId_[spwid] + i).get(Angle::UnitDegree);
2467 : }
2468 0 : av = av / getNumChan(spwid);
2469 0 : Angle average(av*(integratedwatercolumn.get()/getGroundWH2O().get()), Angle::UnitDegree);
2470 0 : return average;
2471 0 : }
2472 :
2473 0 : Length RefractiveIndexProfile::getNonDispersiveH2OPathLength(const Length &integratedwatercolumn,
2474 : unsigned int spwid,
2475 : unsigned int nc)
2476 : {
2477 0 : if(!spwidAndIndexAreValid(spwid, nc)) {
2478 0 : return Length(-999.0);
2479 : }
2480 0 : return getNonDispersiveH2OPathLength(integratedwatercolumn,v_transfertId_[spwid] + nc);
2481 : }
2482 :
2483 0 : Length RefractiveIndexProfile::getAverageNonDispersiveH2OPathLength(const Length &integratedwatercolumn,
2484 : unsigned int spwid)
2485 : {
2486 0 : if(!spwidAndIndexAreValid(spwid, 0)) {
2487 0 : return Length(-999.0);
2488 : }
2489 0 : double av = 0.0;
2490 0 : for(unsigned int i = 0; i < getNumChan(spwid); i++) {
2491 0 : av = av
2492 0 : + getNonDispersiveH2OPathLength(integratedwatercolumn,v_transfertId_[spwid] + i).get(Length::UnitMeter);
2493 : }
2494 0 : av = av / getNumChan(spwid);
2495 0 : Length average(av, Length::UnitMeter);
2496 0 : return average;
2497 0 : }
2498 :
2499 : // NB: the function chanIndexIsValid will be overrided by ....
2500 112383 : bool RefractiveIndexProfile::chanIndexIsValid(unsigned int nc)
2501 : {
2502 112383 : if(nc < vv_N_H2OLinesPtr_.size()) return true;
2503 0 : if(nc < v_chanFreq_.size()) {
2504 : std::cout
2505 0 : << " RefractiveIndexProfile: Requested index in a new spectral window ==> update profile"
2506 0 : << std::endl;
2507 0 : mkRefractiveIndexProfile();
2508 : // std::cout << "...and we return" << std::endl;
2509 0 : return true;
2510 : }
2511 0 : std::cout << " RefractiveIndexProfile: ERROR: Invalid channel frequency index"
2512 0 : << std::endl;
2513 0 : return false;
2514 : }
2515 :
2516 : // NB: the function spwidAndIndexAreValid will be overrided by ...
2517 2738 : bool RefractiveIndexProfile::spwidAndIndexAreValid(unsigned int spwid,
2518 : unsigned int idx)
2519 : {
2520 :
2521 2738 : if(spwid > getNumSpectralWindow() - 1) {
2522 : std::cout
2523 0 : << " RefractiveIndexProfile: ERROR: spectral window identifier out of range "
2524 0 : << std::endl;
2525 0 : return false;
2526 : }
2527 2738 : if(idx > getNumChan(spwid) - 1) {
2528 0 : std::cout << " RefractiveIndexProfile: ERROR: channel index out of range "
2529 0 : << std::endl;
2530 0 : return false;
2531 : }
2532 2738 : unsigned int nc = v_transfertId_[spwid] + idx;
2533 2738 : bool valid = chanIndexIsValid(nc);
2534 2738 : return valid;
2535 : }
2536 :
2537 0 : void RefractiveIndexProfile::updateNewSpectralWindows()
2538 : {
2539 0 : mkRefractiveIndexProfile();
2540 0 : }
2541 :
2542 : ATM_NAMESPACE_END
|
