ATMSkyStatus.h

Go to the documentation of this file.

#ifndef _ATM_SKYSTATUS_H
#define _ATM_SKYSTATUS_H
/*******************************************************************************
 * ALMA - Atacama Large Millimiter Array
 * (c) Instituto de Estructura de la Materia, 2009
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 * "@(#) $Id: ATMSkyStatus.h Exp $"
 *
 * who       when      what
 * --------  --------  ----------------------------------------------
 * pardo     24/03/09  created
 */

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include "ATMCommon.h"
#include "ATMRefractiveIndexProfile.h"
#include "ATMWaterVaporRadiometer.h"
#include "ATMWVRMeasurement.h"

//#include <math.h>
#include <string>
#include <vector>

using std::string;
using std::vector;

ATM_NAMESPACE_BEGIN

class SkyStatus: public RefractiveIndexProfile
{
public:


  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            double airMass);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Temperature &temperatureBackground);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Length &wh2o);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Temperature &temperatureBackground,
            double airMass);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            double airMass,
            const Temperature &temperatureBackground);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Length &wh2o,
            double airMass);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            double airMass,
            const Length &wh2o);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Length &wh2o,
            const Temperature &temperatureBackground);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Temperature &temperatureBackground,
            const Length &wh2o);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Temperature &temperatureBackground,
            double airMass,
            const Length &wh2o);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Temperature &temperatureBackground,
            const Length &wh2o,
            double airMass);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            double airMass,
            const Temperature &temperatureBackground,
            const Length &wh2o);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            double airMass,
            const Length &wh2o,
            const Temperature &temperatureBackground);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Length &wh2o,
            const Temperature &temperatureBackground,
            double airMass);
  SkyStatus(const RefractiveIndexProfile &refractiveIndexProfile,
            const Length &wh2o,
            double airMass,
            const Temperature &temperatureBackground);

  SkyStatus(const SkyStatus &);

  virtual ~SkyStatus();




  Length getUserWH2O() const { return wh2o_user_; }
  void setUserWH2O(const Length &wh2o)
  {
    if(wh2o.get() == wh2o_user_.get()) {
    } else {
      wh2o_user_ = wh2o;
    }
  }
  void setUserWH2O(double dwh2o, const string &units)
  {
    Length wh2o(dwh2o, units);
    if(wh2o.get() == wh2o_user_.get()) {
    } else {
      wh2o_user_ = wh2o;
    }
  }
  double getAirMass() const { return airMass_; }
  void setAirMass(double airMass)
  {
    if(airMass == airMass_) {
    } else {
      airMass_ = airMass;
    }
  }
  Temperature getSkyBackgroundTemperature() const { return skyBackgroundTemperature_; }
  void setSkyBackgroundTemperature(const Temperature &skyBackgroundTemperature)
  {
    if(skyBackgroundTemperature.get("K") == skyBackgroundTemperature_.get("K")) {
    } else {
      skyBackgroundTemperature_
          = Temperature(skyBackgroundTemperature.get("K"), "K");
    }
  }

  Temperature getAverageTebbSky()
  {
    unsigned int n = 0;
    return getAverageTebbSky(n);
  }
  Temperature getAverageTebbSky(unsigned int spwid)
  {
    return getAverageTebbSky(spwid,
                             getUserWH2O(),
                             getAirMass(),
                             1.0,
                             getGroundTemperature());
  }
  Temperature getAverageTebbSky(const Length &wh2o) { return getAverageTebbSky(0, wh2o); }
  Temperature getAverageTebbSky(unsigned int spwid, const Length &wh2o)
  {
    return getAverageTebbSky(spwid,
                             wh2o,
                             getAirMass(),
                             1.0,
                             getGroundTemperature());
  }
  Temperature getAverageTebbSky(double airmass) { return getAverageTebbSky(0, airmass); }
  Temperature getAverageTebbSky(unsigned int spwid, double airmass)
  {
    return getAverageTebbSky(spwid,
                             getUserWH2O(),
                             airmass,
                             1.0,
                             getGroundTemperature());
  }
  Temperature getAverageTebbSky(const Length &wh2o,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTebbSky(0, wh2o, skycoupling, Tspill);
  }
  Temperature getAverageTebbSky(unsigned int spwid,
                                const Length &wh2o,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTebbSky(spwid, wh2o, getAirMass(), skycoupling, Tspill);
  }
  Temperature getAverageTebbSky(double airmass,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTebbSky(0, airmass, skycoupling, Tspill);
  }
  Temperature getAverageTebbSky(unsigned int spwid,
                                double airmass,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTebbSky(spwid, getUserWH2O(), airmass, skycoupling, Tspill);
  }
  Temperature getAverageTebbSky(double skycoupling, const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getAverageTebbSky(n, skycoupling, Tspill);
  }
  Temperature getAverageTebbSky(unsigned int spwid,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTebbSky(spwid,
                             getUserWH2O(),
                             getAirMass(),
                             skycoupling,
                             Tspill);
  }
  Temperature getAverageTebbSky(unsigned int spwid,
                                const Length &wh2o,
                                double airmass,
                                double skycoupling,
                                const Temperature &Tspill);

  Temperature getAverageTebbSky(unsigned int spwid,
                                const Length &wh2o,
                                double airmass,
                                double skycoupling,
                                double signalgain,
                                const Temperature &Tspill);

  Temperature getTebbSky()
  {
    unsigned int n = 0;
    return getTebbSky(n);
  }
  Temperature getTebbSky(unsigned int nc) // There was reported a bug at Launchpad:
                                          // that the result did not take into account
                                          // the actual column of water. But it is not true.
                                          // The column of water is taken into account as
                                          // seen in the next accessor, that is referred by this one.
  {
    unsigned int n = 0;
    return getTebbSky(n, nc);
  }
  Temperature getTebbSky(unsigned int spwid, unsigned int nc)
  {
    return getTebbSky(spwid,
                      nc,
                      getUserWH2O(),
                      getAirMass(),
                      1.0,
                      Temperature(100, "K"));
  }
  Temperature getTebbSky(double airmass)
  {
    unsigned int n = 0;
    return getTebbSky(n, airmass);
  }
  Temperature getTebbSky(unsigned int nc, double airmass)
  {
    unsigned int n = 0;
    return getTebbSky(n, nc, airmass);
  }
  Temperature getTebbSky(unsigned int spwid, unsigned int nc, double airmass)
  {
    return getTebbSky(spwid, nc, getUserWH2O(), airmass, 1.0, Temperature(100,
                                                                          "K"));
  }
  Temperature getTebbSky(const Length &wh2o)
  {
    unsigned int n = 0;
    return getTebbSky(n, wh2o);
  }
  Temperature getTebbSky(unsigned int nc, const Length &wh2o)
  {
    unsigned int n = 0;
    return getTebbSky(n, nc, wh2o);
  }
  Temperature getTebbSky(unsigned int spwid, unsigned int nc, const Length &wh2o)
  {
    return getTebbSky(spwid, nc, wh2o, getAirMass(), 1.0, Temperature(100, "K"));
  }
  Temperature getTebbSky(unsigned int nc,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getTebbSky(n, nc, skycoupling, Tspill);
  }
  Temperature getTebbSky(unsigned int spwid,
                         unsigned int nc,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    return getTebbSky(spwid,
                      nc,
                      getUserWH2O(),
                      getAirMass(),
                      skycoupling,
                      Tspill);
  }
  Temperature getTebbSky(unsigned int nc, const Length &wh2o, double airmass)
  {
    unsigned int n = 0;
    return getTebbSky(n, nc, wh2o, airmass);
  }
  Temperature getTebbSky(unsigned int spwid,
                         unsigned int nc,
                         const Length &wh2o,
                         double airmass)
  {
    return getTebbSky(spwid, nc, wh2o, airmass, 1.0, Temperature(100, "K"));
  }
  Temperature getTebbSky(unsigned int nc,
                         const Length &wh2o,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getTebbSky(n, nc, wh2o, skycoupling, Tspill);
  }
  Temperature getTebbSky(unsigned int spwid,
                         unsigned int nc,
                         const Length &wh2o,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    return getTebbSky(spwid, nc, wh2o, getAirMass(), skycoupling, Tspill);
  }
  Temperature getTebbSky(unsigned int nc,
                         double airmass,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getTebbSky(n, nc, airmass, skycoupling, Tspill);
  }
  Temperature getTebbSky(unsigned int spwid,
                         unsigned int nc,
                         double airmass,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    return getTebbSky(spwid, nc, getUserWH2O(), airmass, skycoupling, Tspill);
  }
  Temperature getTebbSky(unsigned int nc,
                         const Length &wh2o,
                         double airmass,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getTebbSky(n, nc, wh2o, airmass, skycoupling, Tspill);
  }
  Temperature getTebbSky(unsigned int spwid,
                         unsigned int nc,
                         const Length &wh2o,
                         double airmass,
                         double skycoupling,
                         const Temperature &Tspill);


  Temperature getAverageTrjSky()
  {
    unsigned int n = 0;
    return getAverageTrjSky(n);
  }
  Temperature getAverageTrjSky(unsigned int spwid)
  {
    return getAverageTrjSky(spwid,
                             getUserWH2O(),
                             getAirMass(),
                             1.0,
                             getGroundTemperature());
  }
  Temperature getAverageTrjSky(const Length &wh2o) { return getAverageTrjSky(0, wh2o); }
  Temperature getAverageTrjSky(unsigned int spwid, const Length &wh2o)
  {
    return getAverageTrjSky(spwid,
                             wh2o,
                             getAirMass(),
                             1.0,
                             getGroundTemperature());
  }
  Temperature getAverageTrjSky(double airmass) { return getAverageTrjSky(0, airmass); }
  Temperature getAverageTrjSky(unsigned int spwid, double airmass)
  {
    return getAverageTrjSky(spwid,
                             getUserWH2O(),
                             airmass,
                             1.0,
                             getGroundTemperature());
  }
  Temperature getAverageTrjSky(const Length &wh2o,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTrjSky(0, wh2o, skycoupling, Tspill);
  }
  Temperature getAverageTrjSky(unsigned int spwid,
                                const Length &wh2o,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTrjSky(spwid, wh2o, getAirMass(), skycoupling, Tspill);
  }
  Temperature getAverageTrjSky(double airmass,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTrjSky(0, airmass, skycoupling, Tspill);
  }
  Temperature getAverageTrjSky(unsigned int spwid,
                                double airmass,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTrjSky(spwid, getUserWH2O(), airmass, skycoupling, Tspill);
  }
  Temperature getAverageTrjSky(double skycoupling, const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getAverageTrjSky(n, skycoupling, Tspill);
  }
  Temperature getAverageTrjSky(unsigned int spwid,
                                double skycoupling,
                                const Temperature &Tspill)
  {
    return getAverageTrjSky(spwid,
                             getUserWH2O(),
                             getAirMass(),
                             skycoupling,
                             Tspill);
  }
  Temperature getAverageTrjSky(unsigned int spwid,
                                const Length &wh2o,
                                double airmass,
                                double skycoupling,
                                const Temperature &Tspill);

  Temperature getAverageTrjSky(unsigned int spwid,
                                const Length &wh2o,
                                double airmass,
                                double skycoupling,
                                double signalgain,
                                const Temperature &Tspill);

  Temperature getTrjSky()
  {
    unsigned int n = 0;
    return getTrjSky(n);
  }
  Temperature getTrjSky(unsigned int nc) // There was reported a bug at Launchpad:
                                          // that the result did not take into account
                                          // the actual column of water. But it is not true.
                                          // The column of water is taken into account as
                                          // seen in the next accessor, that is referred by this one.
  {
    unsigned int n = 0;
    return getTrjSky(n, nc);
  }
  Temperature getTrjSky(unsigned int spwid, unsigned int nc)
  {
    return getTrjSky(spwid,
                      nc,
                      getUserWH2O(),
                      getAirMass(),
                      1.0,
                      Temperature(100, "K"));
  }
  Temperature getTrjSky(double airmass)
  {
    unsigned int n = 0;
    return getTrjSky(n, airmass);
  }
  Temperature getTrjSky(unsigned int nc, double airmass)
  {
    unsigned int n = 0;
    return getTrjSky(n, nc, airmass);
  }
  Temperature getTrjSky(unsigned int spwid, unsigned int nc, double airmass)
  {
    return getTrjSky(spwid, nc, getUserWH2O(), airmass, 1.0, Temperature(100,
                                                                          "K"));
  }
  Temperature getTrjSky(const Length &wh2o)
  {
    unsigned int n = 0;
    return getTrjSky(n, wh2o);
  }
  Temperature getTrjSky(unsigned int nc, const Length &wh2o)
  {
    unsigned int n = 0;
    return getTrjSky(n, nc, wh2o);
  }
  Temperature getTrjSky(unsigned int spwid, unsigned int nc, const Length &wh2o)
  {
    return getTrjSky(spwid, nc, wh2o, getAirMass(), 1.0, Temperature(100, "K"));
  }
  Temperature getTrjSky(unsigned int nc,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getTrjSky(n, nc, skycoupling, Tspill);
  }
  Temperature getTrjSky(unsigned int spwid,
                         unsigned int nc,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    return getTrjSky(spwid,
                      nc,
                      getUserWH2O(),
                      getAirMass(),
                      skycoupling,
                      Tspill);
  }
  Temperature getTrjSky(unsigned int nc, const Length &wh2o, double airmass)
  {
    unsigned int n = 0;
    return getTrjSky(n, nc, wh2o, airmass);
  }
  Temperature getTrjSky(unsigned int spwid,
                         unsigned int nc,
                         const Length &wh2o,
                         double airmass)
  {
    return getTrjSky(spwid, nc, wh2o, airmass, 1.0, Temperature(100, "K"));
  }
  Temperature getTrjSky(unsigned int nc,
                         const Length &wh2o,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getTrjSky(n, nc, wh2o, skycoupling, Tspill);
  }
  Temperature getTrjSky(unsigned int spwid,
                         unsigned int nc,
                         const Length &wh2o,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    return getTrjSky(spwid, nc, wh2o, getAirMass(), skycoupling, Tspill);
  }
  Temperature getTrjSky(unsigned int nc,
                         double airmass,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getTrjSky(n, nc, airmass, skycoupling, Tspill);
  }
  Temperature getTrjSky(unsigned int spwid,
                         unsigned int nc,
                         double airmass,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    return getTrjSky(spwid, nc, getUserWH2O(), airmass, skycoupling, Tspill);
  }
  Temperature getTrjSky(unsigned int nc,
                         const Length &wh2o,
                         double airmass,
                         double skycoupling,
                         const Temperature &Tspill)
  {
    unsigned int n = 0;
    return getTrjSky(n, nc, wh2o, airmass, skycoupling, Tspill);
  }
  Temperature getTrjSky(unsigned int spwid,
                         unsigned int nc,
                         const Length &wh2o,
                         double airmass,
                         double skycoupling,
                         const Temperature &Tspill);

  
  Opacity getWetOpacity(){unsigned int n = 0; return getWetOpacity(n);}
  Opacity getWetOpacityUpTo(Length refalti){unsigned int n = 0; return getWetOpacityUpTo(n, refalti);}
  Opacity getWetOpacity(unsigned int nc){return getH2OLinesOpacity(nc) + getH2OContOpacity(nc);}
  Opacity getWetOpacityUpTo(unsigned int nc, Length refalti){return getH2OLinesOpacityUpTo(nc, refalti) + getH2OContOpacityUpTo(nc, refalti);}
  Opacity getWetOpacity(unsigned int spwid, unsigned int nc)
  {
  if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0;
    return getWetOpacity(v_transfertId_[spwid] + nc);
  }
  Opacity getWetOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti)
  {
  if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0;
  return getWetOpacityUpTo(v_transfertId_[spwid] + nc, refalti);
  }
  Opacity getAverageWetOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageWetOpacity(getGroundWH2O(),spwid)
        * ((getUserWH2O().get()) / (getGroundWH2O().get()));
  }
  Opacity getAverageH2OLinesOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageH2OLinesOpacity(getGroundWH2O(),spwid)
        * ((getUserWH2O().get()) / (getGroundWH2O().get()));
  }
  Opacity getAverageH2OContOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageH2OContOpacity(getGroundWH2O(),spwid)
        * ((getUserWH2O().get()) / (getGroundWH2O().get()));
  }

  Opacity getDryOpacity()
  {
    return RefractiveIndexProfile::getDryOpacity();
  }
  Opacity getDryOpacity(unsigned int nc)
  {
    return RefractiveIndexProfile::getDryOpacity(nc);
  }
  Opacity getDryOpacity(unsigned int spwid, unsigned int nc)
  {
    return RefractiveIndexProfile::getDryOpacity(spwid, nc);
  }
  Opacity getAverageDryOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageDryOpacity(spwid);
  }

  Opacity getAverageO2LinesOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageO2LinesOpacity(spwid);
  }
  Opacity getAverageO3LinesOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageO3LinesOpacity(spwid);
  }
  Opacity getAverageN2OLinesOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageN2OLinesOpacity(spwid);
  }
  Opacity getAverageNO2LinesOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageNO2LinesOpacity(spwid);
  }
  Opacity getAverageSO2LinesOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageSO2LinesOpacity(spwid);
  }
  Opacity getAverageCOLinesOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageCOLinesOpacity(spwid);
  }
  Opacity getAverageDryContOpacity(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageDryContOpacity(spwid);
  }

  Opacity getTotalOpacity()
  {
    return getWetOpacity() + getDryOpacity();
  }
  Opacity getTotalOpacity(unsigned int nc)
  {
    return getWetOpacity(nc) + getDryOpacity(nc);
  }
  Opacity getTotalOpacity(unsigned int spwid, unsigned int nc)
  {
    return getWetOpacity(spwid, nc) + getDryOpacity(spwid, nc);
  }
  Opacity getAverageTotalOpacity(unsigned int spwid)
  {
    return getAverageWetOpacity(spwid) + getAverageDryOpacity(spwid);
  }
  Opacity getTotalOpacityUpTo(Length refalti)
  {
    unsigned int n = 0;
    return getTotalOpacityUpTo(n, refalti);
  }
  //  Opacity getTotalOpacityUpTo(unsigned int nc, Length refalti);
  Opacity getTotalOpacityUpTo(unsigned int nc, Length refalti)
  {
    return getWetOpacityUpTo(nc,refalti) + getDryOpacityUpTo(nc,refalti);
  }
  Opacity getTotalOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti)
  {
    Opacity wrongOp(-999.0,"np");
    if(!spwidAndIndexAreValid(spwid, nc)) return wrongOp;
    return getTotalOpacityUpTo(v_transfertId_[spwid] + nc, refalti);
  }
  Opacity getH2OLinesOpacity(){ unsigned int n = 0; return getH2OLinesOpacity(n);}
  Opacity getH2OLinesOpacityUpTo(Length refalti){ unsigned int n = 0; return getH2OLinesOpacityUpTo(n, refalti);}
  Opacity getH2OLinesOpacity(unsigned int nc);
  Opacity getH2OLinesOpacityUpTo(unsigned int nc, Length refalti);  
  Opacity getH2OLinesOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getH2OLinesOpacity(v_transfertId_[spwid] + nc);}
  Opacity getH2OLinesOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getH2OLinesOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
  Opacity getH2OContOpacity(){unsigned int n = 0; return getH2OContOpacity(n);}
  Opacity getH2OContOpacityUpTo(Length refalti){unsigned int n = 0; return getH2OContOpacityUpTo(n, refalti);}
  Opacity getH2OContOpacity(unsigned int nc);
  Opacity getH2OContOpacityUpTo(unsigned int nc, Length refalti);
  Opacity getH2OContOpacity(unsigned int spwid, unsigned int nc){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getH2OContOpacity(v_transfertId_[spwid] + nc);}
  Opacity getH2OContOpacityUpTo(unsigned int spwid, unsigned int nc, Length refalti){ if(!spwidAndIndexAreValid(spwid, nc)) return (double) -999.0; return getH2OContOpacityUpTo(v_transfertId_[spwid] + nc, refalti);}
  Angle getDispersiveH2OPhaseDelay()
  {
    unsigned int n = 0;
    return getDispersiveH2OPhaseDelay(n);
  }
  Angle getDispersiveH2OPhaseDelay(unsigned int nc);
  Angle getDispersiveH2OPhaseDelay(unsigned int spwid, unsigned int nc);

  Length getDispersiveH2OPathLength()
  {
    unsigned int n = 0;
    return getDispersiveH2OPathLength(n);
  }
  Length getDispersiveH2OPathLength(unsigned int nc);
  Length getDispersiveH2OPathLength(unsigned int spwid, unsigned int nc);

  Angle getNonDispersiveH2OPhaseDelay()
  {
    unsigned int n = 0;
    return getNonDispersiveH2OPhaseDelay(n);
  }
  Angle getNonDispersiveH2OPhaseDelay(unsigned int nc);
  Angle getNonDispersiveH2OPhaseDelay(unsigned int spwid, unsigned int nc);

  Length getNonDispersiveH2OPathLength()
  {
    unsigned int n = 0;
    return getNonDispersiveH2OPathLength(n);
  }
  Length getNonDispersiveH2OPathLength(unsigned int nc);
  Length getNonDispersiveH2OPathLength(unsigned int spwid, unsigned int nc);

  Angle getAverageDispersiveH2OPhaseDelay(unsigned int spwid);
  Angle getAverageDispersiveH2OPhaseDelay()
  {
    unsigned int n = 0;
    return getAverageDispersiveH2OPhaseDelay(n);
  }
  Angle getAverageNonDispersiveH2OPhaseDelay(unsigned int spwid);
  Angle getAverageNonDispersiveH2OPhaseDelay()
  {
    unsigned int n = 0;
    return getAverageNonDispersiveH2OPhaseDelay(n);
  }

  Length getAverageDispersiveH2OPathLength(unsigned int spwid);
  Length getAverageDispersiveH2OPathLength()
  {
    unsigned int n = 0;
    return getAverageDispersiveH2OPathLength(n);
  }
  Length getAverageNonDispersiveH2OPathLength(unsigned int spwid);
  Length getAverageNonDispersiveH2OPathLength()
  {
    unsigned int n = 0;
    return getAverageNonDispersiveH2OPathLength(n);
  }

  Length getAverageH2OPathLength(unsigned int spwid)
  {
    return getAverageDispersiveH2OPathLength(spwid)
        + getAverageNonDispersiveH2OPathLength(spwid);
  }
  Length getAverageH2OPathLength()
  {
    unsigned int n = 0;
    return getAverageH2OPathLength(n);
  }
  double getAverageH2OPathLengthDerivative(unsigned int spwid)
  {
    return getAverageH2OPathLength(spwid).get("microns")
        / getUserWH2O().get("microns");
  } // in microns/micron_H2O
  double getAverageH2OPathLengthDerivative()
  {
    unsigned int n = 0;
    return getAverageH2OPathLengthDerivative(n);
  } // in microns/micron_H2O


  Angle getAverageH2OPhaseDelay(unsigned int spwid)
  {
    return getAverageDispersiveH2OPhaseDelay(spwid)
        + getAverageNonDispersiveH2OPhaseDelay(spwid);
  }
  Angle getAverageH2OPhaseDelay()
  {
    unsigned int n = 0;
    return getAverageH2OPhaseDelay(n);
  }

  Length getAverageDispersiveDryPathLength(unsigned int spwid)
  {
    return getAverageO2LinesPathLength(spwid)
        + getAverageO3LinesPathLength(spwid)
        + getAverageN2OLinesPathLength(spwid)
        + getAverageCOLinesPathLength(spwid)
        + getAverageNO2LinesPathLength(spwid)
        + getAverageSO2LinesPathLength(spwid);
  }
  Length getAverageDispersiveDryPathLength()
  {
    unsigned int n = 0;
    return getAverageDispersiveDryPathLength(n);
  }

  Length getAverageNonDispersiveDryPathLength(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageNonDispersiveDryPathLength(spwid);
  }
  Length getAverageNonDispersiveDryPathLength()
  {
    unsigned int n = 0;
    return getAverageNonDispersiveDryPathLength(n);
  }
  double
      getAverageNonDispersiveDryPathLength_GroundPressureDerivative(unsigned int spwid);
  double
      getAverageNonDispersiveDryPathLength_GroundTemperatureDerivative(unsigned int spwid);
  double
      getAverageDispersiveDryPathLength_GroundPressureDerivative(unsigned int spwid);
  double
      getAverageDispersiveDryPathLength_GroundTemperatureDerivative(unsigned int spwid);

  Length getAverageO2LinesPathLength(unsigned int spwid)
  {
    return RefractiveIndexProfile::getAverageO2LinesPathLength(spwid);
  }
  Length getAverageO2LinesPathLength()
  {
    unsigned int n = 0;
    return getAverageO2LinesPathLength(n);
  }

  bool setBasicAtmosphericParameters(const Length &altitude,
                                     const Pressure &groundPressure,
                                     const Temperature &groundTemperature,
                                     double tropoLapseRate,
                                     const Humidity &humidity,
                                     const Length &wvScaleHeight);
  bool setBasicAtmosphericParameters(const Length &altitude);
  bool setBasicAtmosphericParameters(const Temperature &groundTemperature);
  bool setBasicAtmosphericParameters(const Pressure &groundPressure);
  bool setBasicAtmosphericParameters(const Humidity &humidity);
  bool setBasicAtmosphericParameters(double tropoLapseRate);
  bool setBasicAtmosphericParameters(const Length &altitude,
                                     const Temperature &groundTemperature);
  bool setBasicAtmosphericParameters(const Length &altitude, const Pressure &groundPressure);
  bool setBasicAtmosphericParameters(const Length &altitude, const Humidity &humidity);
  bool setBasicAtmosphericParameters(const Length &altitude, double tropoLapseRate);
  bool setBasicAtmosphericParameters(const Length &altitude, const Length &wvScaleHeight);
  bool setBasicAtmosphericParameters(const Temperature &groundTemperature,
                                     const Pressure &groundPressure);
  bool setBasicAtmosphericParameters(const Pressure &groundPressure,
                                     const Temperature &groundTemperature);
  bool setBasicAtmosphericParameters(const Temperature &groundTemperature,
                                     const Humidity &humidity);
  bool setBasicAtmosphericParameters(const Humidity &humidity,
                                     const Temperature &groundTemperature);
  bool setBasicAtmosphericParameters(const Temperature &groundTemperature,
                                     double tropoLapseRate);
  bool setBasicAtmosphericParameters(double tropoLapseRate,
                                     const Temperature &groundTemperature);
  bool setBasicAtmosphericParameters(const Temperature &groundTemperature,
                                     const Length &wvScaleHeight);
  bool
      setBasicAtmosphericParameters(const Pressure &groundPressure, const Humidity &humidity);
  bool
      setBasicAtmosphericParameters(const Humidity &humidity, const Pressure &groundPressure);
  bool setBasicAtmosphericParameters(const Pressure &groundPressure,
                                     double tropoLapseRate);
  bool setBasicAtmosphericParameters(double tropoLapseRate,
                                     const Pressure &groundPressure);
  bool setBasicAtmosphericParameters(const Pressure &groundPressure,
                                     const Length &wvScaleHeight);
  bool setBasicAtmosphericParameters(const Humidity &humidity, double tropoLapseRate);
  bool setBasicAtmosphericParameters(double tropoLapseRate, const Humidity &humidity);
  bool setBasicAtmosphericParameters(const Humidity &humidity, const Length &wvScaleHeight);
  bool setBasicAtmosphericParameters(double tropoLapseRate,
                                     const Length &wvScaleHeight);

  void addNewSpectralWindow(unsigned int numChan,
                            unsigned int refChan,
                            const Frequency &refFreq,
                            const Frequency &chanSep)
  {
    RefractiveIndexProfile::add(numChan, refChan, refFreq, chanSep);
  }
  void addNewSpectralWindow(unsigned int numChan,
                            unsigned int refChan,
                            double* chanFreq,
                            const string &freqUnits)
  {
    RefractiveIndexProfile::add(numChan, refChan, chanFreq, freqUnits);
  }
  void addNewSpectralWindow(unsigned int numChan,
                            double refFreq,
                            double* chanFreq,
                            const string &freqUnits)
  {
    RefractiveIndexProfile::add(numChan, refFreq, chanFreq, freqUnits);
  }
  void addNewSpectralWindow(unsigned int numChan,
                            double refFreq,
                            const vector<double> &chanFreq,
                            const string &freqUnits)
  {
    RefractiveIndexProfile::add(numChan, refFreq, chanFreq, freqUnits);
  }
  void addNewSpectralWindow(unsigned int numChan,
                            unsigned int refChan,
                            const Frequency &refFreq,
                            const Frequency &chanSep,
                            const Frequency &intermediateFreq,
                            const SidebandSide &sbSide,
                            const SidebandType &sbType)
  {
    RefractiveIndexProfile::add(numChan,
                                refChan,
                                refFreq,
                                chanSep,
                                intermediateFreq,
                                sbSide,
                                sbType);
  }
  void addNewSpectralWindow(const vector<Frequency> &chanFreq)
  {
    RefractiveIndexProfile::add(chanFreq);
  }

  Length WaterVaporRetrieval_fromFTS(const vector<double> &v_transmission)
  {
    unsigned int spwId = 0;
    Frequency f1(-999, "GHz");
    Frequency f2(-999, "GHz");
    return WaterVaporRetrieval_fromFTS(spwId, v_transmission, f1, f2);
  }
  Length WaterVaporRetrieval_fromFTS(const vector<double> &v_transmission,
                                     const Frequency &f1,
                                     const Frequency &f2)
  {
    unsigned int spwId = 0;
    return WaterVaporRetrieval_fromFTS(spwId, v_transmission, f1, f2);
  }
  Length WaterVaporRetrieval_fromFTS(unsigned int spwId,
                                     const vector<double> &v_transmission)
  {
    Frequency f1(-999, "GHz");
    Frequency f2(-999, "GHz");
    return WaterVaporRetrieval_fromFTS(spwId, v_transmission, f1, f2);
  }
  Length WaterVaporRetrieval_fromFTS(unsigned int spwId,
                                     const vector<double> &v_transmission,
                                     const Frequency &f1,
                                     const Frequency &f2);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Percent> &signalGain,
                                      const vector<vector<Temperature> > &vv_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      double airmass,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Percent> &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      double airmass,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  /* to implement in .cpp
  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      Percent signalGain,
                                      Temperature tebb,
                                      vector<double> spwId_filter,
                                      double airmass,
                                      double skycoupling,
                                      Temperature tspill); */


  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const Percent &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      const vector<double> &spwId_filter,
                                      double airmass,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const Percent &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      double airmass,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const Percent &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      double airmass,
                                      double skycoupling,
                                      const Temperature &tspill);  // equivalent eliminating the vectors already implemented, see below

  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const vector<Temperature> &v_tebb,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<vector<Temperature> > &vv_tebb,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Temperature> &v_tebb,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  /* to be implemented in the .cpp
  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      Temperature tebb,
                                      double skycoupling,
                                      Temperature tspill); */

  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const vector<Temperature> &v_tebb,
                                      const vector<double> &spwId_filter,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<vector<Temperature> > &vv_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Temperature> &v_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  /* to be implemented in the .cpp
  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      Temperature tebb,
                                      vector<double> spwId_filters,
                                      double skycoupling,
                                      Temperature tspill); */

  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const vector<Temperature> &v_tebb,
                                      double airmass,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<vector<Temperature> > &vv_tebb,
                                      double airmass,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Temperature> &v_tebb,
                                      double airmass, 
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  /* to be implemented in the .cpp
  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId, 
                                      const Temperature &tebb,
                                      double airmass, 
                                      double skycoupling, 
                                      const Temperature &tspill);  */

  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const vector<Temperature> &v_tebb,
                                      const vector<double> &spwId_filter,
                                      double airmass,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<vector<Temperature> > &vv_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      double airmass,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Temperature> &v_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      double airmass,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  /* to be implemented in the .cpp
  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const Temperature &v_tebb,
                                      const vector<double> &spwId_filter,
                                      double airmass,
                                      double skycoupling,
                                      const Temperature &tspill);   */

  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const Percent &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Percent> &signalGain,
                                      const vector<vector<Temperature> > &vv_tebb,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Percent> &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  /* to be implemented in the .cpp
  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const Percent &signalGain,
                                      constr Temperature &v_tebb,
                                      double skycoupling,
                                      const Temperature &tspill); */

  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const Percent &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      const vector<double> &spwId_filter,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Percent> &signalGain,
                                      const vector<vector<Temperature> > &vv_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Percent> &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      const vector<vector<double> > &spwId_filters,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  /* to be implemented in the .cpp
  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const Percent &signalGain,
                                      const Temperature &v_tebb,
                                      const vector<double> &spwId_filter,
                                      double skycoupling,
                                      const Temperature &tspill); */

  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                      const Percent &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      double airmass,
                                      double skycoupling,
                                      const Temperature &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Percent> &signalGain,
                                      const vector<vector<Temperature> > &vv_tebb,
                                      double airmass,
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  Length WaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                      const vector<Percent> &signalGain,
                                      const vector<Temperature> &v_tebb,
                                      double airmass, 
                                      const vector<double> &skycoupling,
                                      const vector<Temperature> &tspill);

  // implemented 17/9/09
  Length WaterVaporRetrieval_fromTEBB(unsigned int spwId,      
                                      const Percent &signalGain,
                                      const Temperature &tebb,
                                      double airmass,
                                      double skycoupling,
                                      const Temperature &tspill);

  double SkyCouplingRetrieval_fromTEBB(unsigned int spwId,
                                       const vector<Temperature> &v_tebb,
                                       double skycoupling,
                                       const Temperature &tspill);

  double SkyCouplingRetrieval_fromTEBB(unsigned int spwId,
                                       const vector<Temperature> &v_tebb,
                                       const vector<double> &spwId_filter,
                                       double skycoupling,
                                       const Temperature &tspill);

  double SkyCouplingRetrieval_fromTEBB(unsigned int spwId,
                                       const vector<Temperature> &v_tebb,
                                       double airmass,
                                       double skycoupling,
                                       const Temperature &tspill);

  double SkyCouplingRetrieval_fromTEBB(unsigned int spwId,
                                       const vector<Temperature> &v_tebb,
                                       const vector<double> &spwId_filter,
                                       double airmass,
                                       double skycoupling,
                                       const Temperature &tspill);

  void setWaterVaporRadiometer(const WaterVaporRadiometer &waterVaporRadiometer)
  {
    waterVaporRadiometer_ = waterVaporRadiometer;
  }
  void updateSkyCoupling_fromWVR(vector<WVRMeasurement> &RadiometerData,
                                 unsigned int n,
                                 unsigned int m);
  void updateSkyCouplingChannel_fromWVR(vector<WVRMeasurement> &RadiometerData,
                                        unsigned int ichan,
                                        unsigned int n,
                                        unsigned int m);
  void updateSkyCoupling_fromWVR(vector<WVRMeasurement> &RadiometerData,
                                 unsigned int n)
  {
    updateSkyCoupling_fromWVR(RadiometerData, n, n + 1);
  }
  void updateSkyCoupling_fromWVR(vector<WVRMeasurement> &RadiometerData,
                                 unsigned int n,
                                 unsigned int m,
                                 WaterVaporRadiometer &external_wvr)
  {
    updateSkyCoupling_fromWVR(RadiometerData, n, m);
    external_wvr = waterVaporRadiometer_;
  }
  void updateSkyCoupling_fromWVR(vector<WVRMeasurement> &RadiometerData,
                                 unsigned int n,
                                 WaterVaporRadiometer &external_wvr)
  {
    updateSkyCoupling_fromWVR(RadiometerData, n, n + 1);
    external_wvr = waterVaporRadiometer_;
  }
  double getWaterVaporRadiometerSkyCoupling(int n) const
  {
    return waterVaporRadiometer_.getSkyCoupling()[n];
  }
  Percent getWaterVaporRadiometerSignalGain(int n) const
  {
    return waterVaporRadiometer_.getsignalGain()[n];
  }
  void WaterVaporRetrieval_fromWVR(vector<WVRMeasurement> &RadiometerData,
                                   unsigned int n,
                                   unsigned int m);
  void WaterVaporRetrieval_fromWVR(vector<WVRMeasurement> &RadiometerData,
                                   unsigned int n)
  {
    WaterVaporRetrieval_fromWVR(RadiometerData, n, n + 1);
  }
  void WaterVaporRetrieval_fromWVR(WVRMeasurement &RadiometerData);
  WaterVaporRadiometer getWaterVaporRadiometer() const
  {
    return waterVaporRadiometer_;
  }

  double
      sigmaSkyCouplingRetrieval_fromWVR(double par_fit,
                                        const WaterVaporRadiometer &wvr,
                                        vector<WVRMeasurement> &RadiometerData,
                                        unsigned int n,
                                        unsigned int m);
  double sigmaSkyCouplingRetrieval_fromWVR(double par_fit,
                                           const WaterVaporRadiometer &wvr,
                                           vector<WVRMeasurement> &RadiometerData,
                                           unsigned int n)
  {
    return sigmaSkyCouplingRetrieval_fromWVR(par_fit, wvr, RadiometerData, n, n
        + 1);
  }

  /*
    return the rms of the residuals for one channel ichan, as a function of the multiplicative 
    factor par_fit to this channel's coupling efficiency.
   */
  double sigmaSkyCouplingChannelRetrieval_fromWVR(double par_fit,
                                                  const WaterVaporRadiometer &wvr,
                                                  vector<WVRMeasurement> &RadiometerData,
                                                  unsigned int ichan,
                                                  unsigned int n,
                                                  unsigned int m);
  Temperature getWVRAverageSigmaTskyFit(const vector<WVRMeasurement> &RadiometerData,
                                        unsigned int n,
                                        unsigned int m);
  Temperature getWVRAverageSigmaTskyFit(const vector<WVRMeasurement> &RadiometerData,
                                        unsigned int n)
  {
    return getWVRAverageSigmaTskyFit(RadiometerData, n, n + 1);
  }
  /* 
     return the rms of fit residual for a single channel, in a measurement
  */
  Temperature getWVRSigmaChannelTskyFit(const vector<WVRMeasurement> &RadiometerData,
                                        unsigned int ichan,
                                        unsigned int n,
                                        unsigned int m);
  /*
    return the rms of water vapor retrieved values in a measurnment (n to m) 
  */
  double getSigmaTransmissionFit(unsigned int spwId,
                                 const vector<double> &v_transmission,
                                 double airm,
                                 const Frequency &f1,
                                 const Frequency &f2);
  //double getSigmaTransmissionFit(){}
  Temperature getSigmaFit(unsigned int spwId,
                          const vector<Temperature> &v_tebbspec,
                          double skyCoupling,
                          const Temperature &Tspill)
  {
    return getSigmaFit(spwId, v_tebbspec, getUserWH2O(), skyCoupling, Tspill);
  }
  Temperature getSigmaFit(unsigned int spwId,
                          const vector<Temperature> &v_tebbspec,
                          const Length &wh2o,
                          double skyCoupling,
                          const Temperature &Tspill)
  {
    return getSigmaFit(spwId,
                       v_tebbspec,
                       wh2o,
                       getAirMass(),
                       skyCoupling,
                       Tspill);
  }
  Temperature getSigmaFit(unsigned int spwId,
                          const vector<Temperature> &v_tebbspec,
                          double airmass,
                          double skyCoupling,
                          const Temperature &Tspill)
  {
    return getSigmaFit(spwId,
                       v_tebbspec,
                       getUserWH2O(),
                       airmass,
                       skyCoupling,
                       Tspill);
  }
  Temperature getSigmaFit(unsigned int spwId,
                          const vector<Temperature> &v_tebbspec,
                          const Length &wh2o,
                          double airmass,
                          double skyCoupling,
                          const Temperature &Tspill);


protected:

  double airMass_; 
  Temperature skyBackgroundTemperature_; 
  Length wh2o_user_; 
  WaterVaporRadiometer waterVaporRadiometer_; // !< Identifiers, sky coupling, and sideband gain of channels corresponding to the water vapor radiometer.


  void iniSkyStatus(); 
  bool updateProfilesAndRadiance(const Length &altitude,
                                 const Pressure &groundPressure,
                                 const Temperature &groundTemperature,
                                 double tropoLapseRate,
                                 const Humidity &relativeHumidity,
                                 const Length &wvScaleHeight);
  void rmSkyStatus(); 

  Length mkWaterVaporRetrieval_fromFTS(unsigned int spwId,
                                       const vector<double> &v_transmission,
                                       //double airm,     // unused parameter
                                       const Frequency &f1,
                                       const Frequency &f2);

  Length mkWaterVaporRetrieval_fromTEBB(unsigned int spwId,
                                        const Percent &signalGain,
                                        const vector<Temperature> &v_measuredSkyTEBB,
                                        double airm,
                                        const vector<double> &spwId_filter,
                                        double skycoupling,
                                        const Temperature &tspill)
  {
                return mkWaterVaporRetrieval_fromTEBB(
                                vector<unsigned int>(1, spwId),
                                vector<Percent>(1, signalGain),
                                vector<vector<Temperature> >(1, v_measuredSkyTEBB),
                                airm,
                                vector<vector<double> >(1, spwId_filter),
                                vector<double>(1, skycoupling),
                                vector<Temperature>(1, tspill));
  }

  Length
      mkWaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                     const vector<Percent> &signalGain,
                                     const vector<vector<Temperature> > &measuredSkyTEBB,
                                     double airm,
                                     const vector<vector<double> > &spwId_filters,
                                     const vector<double> &skycoupling,
                                     const vector<Temperature> &tspill);

  Length
      mkWaterVaporRetrieval_fromTEBB(const vector<unsigned int> &spwId,
                                     const vector<Percent> &signalGain,
                                     const vector<Temperature> &measuredAverageSkyTEBB,
                                     double airm,
                                     const vector<vector<double> > &spwId_filters,
                                     const vector<double> &skycoupling,
                                     const vector<Temperature> &tspill);

  double mkSkyCouplingRetrieval_fromTEBB(unsigned int spwId,
                                         const Percent &signalGain,
                                         const vector<Temperature> &measuredSkyTEBB,
                                         double airm,
                                         const vector<double> &spwId_filter,
                                         double skycoupling,
                                         const Temperature &tspill);

  WVRMeasurement
      mkWaterVaporRetrieval_fromWVR(const vector<Temperature> &measuredSkyBrightnessVector,
                                    const vector<unsigned int> &radiometricChannels,
                                    const vector<double> &skyCoupling,
                                    const vector<Percent> &signalGain,
                                    const Temperature &spilloverTemperature,
                                    const Angle &elevation);

  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid,
            unsigned int nc)
  {
    return RT(pfit_wh2o, skycoupling, tspill, airMass_, spwid, nc);
  }
  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid)
  {
    return RT(pfit_wh2o, skycoupling, tspill, airMass_, spwid);
  }
  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            double airmass,
            unsigned int spwId,
            unsigned int nc);

  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            double airmass,
            unsigned int spwid)
  {
    double tebb_channel = 0.0;
    for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
      tebb_channel = tebb_channel + RT(pfit_wh2o,
                                       skycoupling,
                                       tspill,
                                       airmass,
                                       spwid,
                                       n) / (v_numChan_[spwid]);
    }
    return tebb_channel;
  }

  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid,
            const Percent &signalgain)
  {
    vector<double> spwId_filter;
    for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
      spwId_filter.push_back(1.0);
    }
    return RT(pfit_wh2o,
              skycoupling,
              tspill,
              airMass_,
              spwid,
              spwId_filter,
              signalgain);
  }

  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            double airmass,
            unsigned int spwid,
            const Percent &signalgain)
  {
    vector<double> spwId_filter;
    for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
      spwId_filter.push_back(1.0);
    }
    return RT(pfit_wh2o,
              skycoupling,
              tspill,
              airmass,
              spwid,
              spwId_filter,
              signalgain);
  }

  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid,
            const vector<double> &spwId_filter)
  {
    return RT(pfit_wh2o,
              skycoupling,
              tspill,
              airMass_,
              spwid,
              spwId_filter,
              Percent(100.0, "%"));
  }

  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid,
            const vector<double> &spwId_filter,
            const Percent &signalgain)
  {
    return RT(pfit_wh2o,
              skycoupling,
              tspill,
              airMass_,
              spwid,
              spwId_filter,
              signalgain);
  }

  double RT(double pfit_wh2o,
            double skycoupling,
            double tspill,
            double airmass,
            unsigned int spwid,
            const vector<double> &spwId_filter,
            const Percent &signalgain);


  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid,
            unsigned int nc)
  {
    return RTRJ(pfit_wh2o, skycoupling, tspill, airMass_, spwid, nc);
  }
  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid)
  {
    return RTRJ(pfit_wh2o, skycoupling, tspill, airMass_, spwid);
  }
  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            double airmass,
            unsigned int spwId,
            unsigned int nc);

  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            double airmass,
            unsigned int spwid)
  {
    double trj_channel = 0.0;
    for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
      trj_channel = trj_channel + RTRJ(pfit_wh2o,
                                       skycoupling,
                                       tspill,
                                       airmass,
                                       spwid,
                                       n) / (v_numChan_[spwid]);
    }
    return trj_channel;
  }

  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid,
            const Percent &signalgain)
  {
    vector<double> spwId_filter;
    for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
      spwId_filter.push_back(1.0);
    }
    return RTRJ(pfit_wh2o,
              skycoupling,
              tspill,
              airMass_,
              spwid,
              spwId_filter,
              signalgain);
  }

  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            double airmass,
            unsigned int spwid,
            const Percent &signalgain)
  {
    vector<double> spwId_filter;
    for(unsigned int n = 0; n < v_numChan_[spwid]; n++) {
      spwId_filter.push_back(1.0);
    }
    return RTRJ(pfit_wh2o,
              skycoupling,
              tspill,
              airmass,
              spwid,
              spwId_filter,
              signalgain);
  }

  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid,
            const vector<double> &spwId_filter)
  {
    return RTRJ(pfit_wh2o,
              skycoupling,
              tspill,
              airMass_,
              spwid,
              spwId_filter,
              Percent(100.0, "%"));
  }

  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            unsigned int spwid,
            const vector<double> &spwId_filter,
            const Percent &signalgain)
  {
    return RTRJ(pfit_wh2o,
              skycoupling,
              tspill,
              airMass_,
              spwid,
              spwId_filter,
              signalgain);
  }

  double RTRJ(double pfit_wh2o,
            double skycoupling,
            double tspill,
            double airmass,
            unsigned int spwid,
            const vector<double> &spwId_filter,
            const Percent &signalgain);

  
private:

  // no accessors provided for these
  double sigma_transmission_FTSfit_;
  Temperature sigma_TEBBfit_;

}; // class SkyStatus

ATM_NAMESPACE_END

#endif