pressurebroadeningdata.h

Go to the documentation of this file.

/* Copyright (C) 2014
 R ichard Larsson <ric.larsson@gmail.com>
 
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2, or (at your option) any
 later version.
 
 This program 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 General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 USA. */

#ifndef pressurebroadeningdata_h
#define pressurebroadeningdata_h

#include <cmath>
#include "array.h"
#include "messages.h"
#include "matpackI.h"
#include "complex.h"
#include "jacobian.h"


class PressureBroadeningData
{
public:
    
    enum PB_Type : Index {
        PB_NONE,                          // No pressure broadening
        PB_AIR_BROADENING,                // Air broadening and self broadening only
        PB_AIR_AND_WATER_BROADENING,      // Air, water, and self broadening
        PB_PLANETARY_BROADENING,          // Gas broadening as done for solar system planets
        PB_SD_AIR_VOLUME,                 // HTP in air for SD limit
        PB_HTP_AIR_VOLUME,                // HTP in air
        PB_VOIGT_TEST_WATER,              // Voigt parameters for testing
        PB_SD_TEST_WATER,                 // SD parameters for testing
        PB_PURELY_FOR_TESTING             // Testing tag for new input structures --- can be changed by anyone...
    };
    
    enum class TestParams : Index { sg0=0, sn0, sd0, sm, sA, sg2, sn2, sd2, 
                                    ag0,   an0, ad0, am, aA, ag2, an2, ad2, COUNT };
    
    // Defining an object with no data and no broadening
    PressureBroadeningData() : mtype(PB_NONE), mdata(), mdataerror() {}
    
    // Use these to get the raw data from this class
    const PB_Type& Type() const {return mtype;}
    const ArrayOfVector& Data() const {return mdata;}
    const ArrayOfVector& DataError() const {return mdataerror;}
    
    //  The functions below this point sets up pressure broadening schemes from external catalogs and old ARTSCAT
    
    void SetAirBroadeningFromCatalog(const Numeric& sgam, 
                                     const Numeric& nself,
                                     const Numeric& agam,
                                     const Numeric& nair,
                                     const Numeric& air_pressure_DF,
                                     const Numeric& dsgam, 
                                     const Numeric& dnself,
                                     const Numeric& dagam,
                                     const Numeric& dnair,
                                     const Numeric& dair_pressure_DF);
    
    void SetAirAndWaterBroadeningFromCatalog(const Numeric& sgam, 
                                             const Numeric& sn, 
                                             const Numeric& sdelta, 
                                             const Numeric& agam,
                                             const Numeric& an,
                                             const Numeric& adelta,
                                             const Numeric& wgam,
                                             const Numeric& wn,
                                             const Numeric& wdelta);
    
    
    void SetPlanetaryBroadeningFromCatalog(const Numeric& sgam, 
                                        const Numeric& nself,
                                        const Vector&  foreign_gamma,
                                        const Vector&  n_foreign,
                                        const Vector&  foreign_pressure_DF);
    
    void SetSDAirFromCatalog(const Numeric& gamma0,
                             const Numeric& gamma0_exp,
                             const Numeric& gamma2,
                             const Numeric& gamma2_exp,
                             const Numeric& delta0,
                             const Numeric& delta0_exp,
                             const Numeric& delta2,
                             const Numeric& delta2_exp);
    
    void SetHTPAirFromCatalog(const Numeric& gamma0,
                              const Numeric& gamma0_exp,
                              const Numeric& gamma2,
                              const Numeric& gamma2_exp,
                              const Numeric& delta0,
                              const Numeric& delta0_exp,
                              const Numeric& delta2,
                              const Numeric& delta2_exp,
                              const Numeric& fvc,
                              const Numeric& fvc_exp,
                              const Numeric& eta,
                              const Numeric& eta_exp);
    
    void SetTestFromCatalog(const Numeric& gamma0_air,
                            const Numeric& gamma0_air_exp,
                            const Numeric& gamma0_water,
                            const Numeric& gamma0_water_exp,
                            const Numeric& gamma2_air,
                            const Numeric& gamma2_water,
                            const Numeric& delta0_air,
                            const Numeric& delta0_water);
    void GetTestBroadening(Numeric& gamma0,
                           Numeric& gamma2,
                           Numeric& delta0,
                           ConstVectorView vmrs,
                           const Numeric& theta,
                           const Numeric& pressure,
                           const Index h2o_index) const;
    
    void SetInternalDerivatives(ComplexVector& derivatives,
                                const ArrayOfRetrievalQuantity& ppd,
                                const QuantumIdentifier& QI,
                                const Numeric& theta,
                                const Numeric& pressure,
                                const Numeric& self_pressure,
                                const Index    this_species,
                                const Index    h2o_species,
                                ConstVectorView vmrs) const;
    
    // Get the Planetary foreign broadening data vector
    ConstVectorView PlanetaryGammaForeign() const { assert(mtype == PB_PLANETARY_BROADENING); return mdata[2]; }
    
    // Get the Planetary foreign broadening exponent data vector
    ConstVectorView PlanetaryNForeign() const { assert(mtype == PB_PLANETARY_BROADENING); return mdata[3]; }
    
    // Get the Planetary foreign shift data vector
    ConstVectorView PlanetaryDeltaForeign() const { assert(mtype == PB_PLANETARY_BROADENING); return mdata[4]; }
    
    // Get the Planetary foreign broadening data from one position
    Numeric PlanetaryGammaForeign(Index ii) const { assert(mtype == PB_PLANETARY_BROADENING); return mdata[2][ii]; }
    
    // Get the Planetary foreign broadening exponent data from one position
    Numeric PlanetaryNForeign(Index ii) const { assert(mtype == PB_PLANETARY_BROADENING); return mdata[3][ii]; }
    
    // Get the Planetary foreign shift data from one position
    Numeric PlanetaryDeltaForeign(Index ii) const {  assert(mtype == PB_PLANETARY_BROADENING); return mdata[4][ii]; }
    
    // Get the Air broadening air pressure broadening
    Numeric AirBroadeningAgam() const { assert(mtype == PB_AIR_BROADENING);  return mdata[2][0]; }
    
    // Get the Air broadening air pressure broadening exponent
    Numeric AirBroadeningNair() const { assert(mtype == PB_AIR_BROADENING);  return mdata[3][0]; }
    
    // Get the Air broadening air pressure shift
    Numeric AirBroadeningPsf()  const { assert(mtype == PB_AIR_BROADENING);  return mdata[4][0]; }
    
    // Get the self pressure broadening
    Numeric Sgam() const { assert(mdata.nelem() != 0); assert(mdata[0].nelem() != 0); return mdata[0][0]; }
    
    // Get the self pressure broadening exponent
    Numeric Nself() const { assert(mdata.nelem() > 0); assert(mdata[1].nelem() != 0); return mdata[1][0]; }
    
    // Get the Air broadening air pressure broadening error
    Numeric AirBroadeningDAgam() const { assert(mtype == PB_AIR_BROADENING);  return mdataerror[2][0]; }
    
    // Get the Air broadening air pressure broadening exponent error
    Numeric AirBroadeningDNair() const { assert(mtype == PB_AIR_BROADENING);  return mdataerror[3][0]; }
    
    // Get the Air broadening air pressure shift error
    Numeric AirBroadeningDPsf()  const { assert(mtype == PB_AIR_BROADENING);  return mdataerror[4][0]; }
    
    // Get the Air broadening self pressure broadening error
    Numeric dSgam()  const { assert(mtype == PB_AIR_BROADENING);  return mdataerror[0][0]; }
    
    // Get the Air broadening self pressure broadening exponent error
    Numeric dNself() const { assert(mtype == PB_AIR_BROADENING);  return mdataerror[1][0]; }
    
    void ChangeSelf(const Numeric& change, 
                    const Index this_species, 
                    const Index h2o_species, 
                    const ArrayOfIndex& broad_spec_locations);
    
    void ChangeSelfExponent(const Numeric& change, 
                            const Index this_species, 
                            const Index h2o_species, 
                            const ArrayOfIndex& broad_spec_locations);
    
    void SetSelf(const Numeric& new_value, 
                 const Index this_species, 
                 const Index h2o_species, 
                 const ArrayOfIndex& broad_spec_locations);
    
    void SetSelfExponent(const Numeric& new_value, 
                         const Index this_species, 
                         const Index h2o_species, 
                         const ArrayOfIndex& broad_spec_locations);
    
    void ChangeSelfRelative(const Numeric& change, 
                            const Index this_species, 
                            const Index h2o_species, 
                            const ArrayOfIndex& broad_spec_locations);
    
    void ChangeSelfExponentRelative(const Numeric& change, 
                                    const Index this_species, 
                                    const Index h2o_species, 
                                    const ArrayOfIndex& broad_spec_locations);
    
    void ChangeForeign(const Numeric& change, 
                       const ArrayOfIndex& broad_spec_locations);
    
    void ChangeForeignExponent(const Numeric& change, 
                               const ArrayOfIndex& broad_spec_locations);
    
    void SetForeign(const Numeric& new_value, 
                    const ArrayOfIndex& broad_spec_locations);
    
    void SetForeignExponent(const Numeric& new_value, 
                            const ArrayOfIndex& broad_spec_locations);
    
    void ChangeForeignRelative(const Numeric& change, 
                               const ArrayOfIndex& broad_spec_locations);
    
    void ChangeForeignExponentRelative(const Numeric& change, 
                                       const ArrayOfIndex& broad_spec_locations);
    
    void ChangeForeignShiftRelative(const Numeric& change, 
                                    const ArrayOfIndex& broad_spec_locations);
    
    void ChangeForeignShift(const Numeric& change, 
                            const ArrayOfIndex& broad_spec_locations);
    
    // Use these to return data in the format required by the line shape calculator
    
    void GetAirBroadening(Numeric& gamma,
                          Numeric& deltaf,
                          const Numeric& theta,
                          const Numeric& pressure,
                          const Numeric& self_pressure) const;
    void GetAirBroadening_dT(Numeric& dgamma_dT,
                             Numeric& ddeltaf_dT,
                             const Numeric& T,
                             const Numeric& T0,
                             const Numeric& pressure,
                             const Numeric& self_pressure) const;
    void GetAirBroadening_dSelfGamma(Numeric& gamma_dSelf,
                                     const Numeric& theta,
                                     const Numeric& self_pressure) const;
    void GetAirBroadening_dForeignGamma(Numeric& gamma_dForeign,
                                        const Numeric& theta,
                                        const Numeric& pressure,
                                        const Numeric& self_pressure) const;
    void GetAirBroadening_dForeignPsf(Numeric& psf_dForeign,
                                      const Numeric& theta,
                                      const Numeric& pressure) const;
    void GetAirBroadening_dSelfExponent(Numeric& gamma_dSelfExponent,
                                        Numeric& psf_dSelfExponent,
                                        const Numeric& theta,
                                        const Numeric& self_pressure) const;
    void GetAirBroadening_dForeignExponent(Numeric& gamma_dForeignExponent,
                                           Numeric& psf_dForeignExponent,
                                           const Numeric& theta,
                                           const Numeric& pressure,
                                           const Numeric& self_pressure) const;
    void GetPressureBroadeningParams_dSelfVMR(Numeric& gamma_dvmr,
                                              Numeric& split_dvmr,
                                              const Numeric& theta,
                                              const Numeric& pressure) const;

    void GetAirAndWaterBroadening(Numeric& gamma,
                                  Numeric& deltaf,
                                  const Numeric& theta,
                                  const Numeric& pressure,
                                  const Numeric& self_pressure,
                                  const Index    this_species,
                                  const Index    h2o_species,
                                  ConstVectorView vmrs) const;
    void GetAirAndWaterBroadening_dT(Numeric& dgamma_dT,
                                     Numeric& ddeltaf_dT,
                                     const Numeric& T,
                                     const Numeric& T0,
                                     const Numeric& pressure,
                                     const Numeric& self_pressure,
                                     const Index    this_species,
                                     const Index    h2o_species,
                                     ConstVectorView vmrs) const;
    void GetAirAndWaterBroadening_dSelfGamma(Numeric& dgamma_dSelf,
                                             const Numeric& theta,
                                             const Numeric& self_pressure) const;
    void GetAirAndWaterBroadening_dForeignGamma(Numeric& dgamma_dForeign,
                                                const Numeric& theta,
                                                const Numeric& pressure,
                                                const Numeric& self_pressure,
                                                const Index    this_species,
                                                const Index    h2o_species,
                                                ConstVectorView vmrs) const;
    void GetAirAndWaterBroadening_dWaterGamma(Numeric& gamma_dWater,
                                              const Numeric& theta,
                                              const Numeric& pressure,
                                              const Index    this_species,
                                              const Index    h2o_species,
                                              ConstVectorView vmrs) const;
    void GetAirAndWaterBroadening_dSelfPsf(Numeric& dpsf_dSelf,
                                           const Numeric& theta,
                                           const Numeric& self_pressure) const;
    void GetAirAndWaterBroadening_dForeignPsf(Numeric& dpsf_dForeign,
                                              const Numeric& theta,
                                              const Numeric& pressure,
                                              const Numeric& self_pressure,
                                              const Index    this_species,
                                              const Index    h2o_species,
                                              ConstVectorView vmrs) const;
    void GetAirAndWaterBroadening_dWaterPsf(Numeric& psf_dWater,
                                            const Numeric& theta,
                                            const Numeric& pressure,
                                            const Index    this_species,
                                            const Index    h2o_species,
                                            ConstVectorView vmrs) const;
    void GetAirAndWaterBroadening_dSelfExponent(Numeric& dgamma_dSelfExponent,
                                                Numeric& dpsf_dSelfExponent,
                                                const Numeric& theta,
                                                const Numeric& self_pressure) const;
    void GetAirAndWaterBroadening_dForeignExponent(Numeric& dgamma_dForeignExponent,
                                                   Numeric& dpsf_dForeignExponent,
                                                   const Numeric& theta,
                                                   const Numeric& pressure,
                                                   const Numeric& self_pressure,
                                                   const Index    this_species,
                                                   const Index    h2o_species,
                                                   ConstVectorView vmrs) const;
    void GetAirAndWaterBroadening_dWaterExponent(Numeric& gamma_dWaterExponent,
                                                 Numeric& psf_dWaterExponent,
                                                 const Numeric& theta,
                                                 const Numeric& pressure,
                                                 const Index    this_species,
                                                 const Index    h2o_species,
                                                 ConstVectorView vmrs) const;
    
    void GetPlanetaryBroadening(Numeric& gamma,
                             Numeric& deltaf,
                             const Numeric& theta,
                             const Numeric& pressure,
                             const Numeric& self_pressure,
                             const ArrayOfIndex& broad_spec_locations,
                             ConstVectorView vmrs) const;
    void GetPlanetaryBroadening_dT(Numeric& dgamma_dT,
                                Numeric& ddeltaf_dT,
                                const Numeric& T,
                                const Numeric& T0,
                                const Numeric& pressure,
                                const Numeric& self_pressure,
                                const ArrayOfIndex& broad_spec_locations,
                                ConstVectorView vmrs) const;
    
     void GetPressureBroadeningParams(Numeric& gamma_0,
                                      Numeric& gamma_2,
                                      Numeric& eta,
                                      Numeric& df_0,
                                      Numeric& df_2,
                                      Numeric& f_VC,
                                      const Numeric& T,
                                      const Numeric& T0,
                                      const Numeric& pressure,
                                      const Numeric& self_pressure,
                                      const Index    this_species,
                                      const Index    h2o_species,
                                      const ArrayOfIndex& broad_spec_locations,
                                      ConstVectorView vmrs) const;
    void GetPressureBroadeningParams_dT(Numeric& dgamma_0_dT,
                                        Numeric& dgamma_2_dT,
                                        Numeric& deta_dT,
                                        Numeric& ddf_0_dT,
                                        Numeric& ddf_2_dT,
                                        Numeric& df_VC_dT,
                                        const Numeric& T,
                                        const Numeric& T0,
                                        const Numeric& pressure,
                                        const Numeric& self_pressure,
                                        const Index    this_species,
                                        const Index    h2o_species,
                                        const ArrayOfIndex& broad_spec_locations,
                                        ConstVectorView vmrs) const;
    void GetPressureBroadeningParams_dSelfGamma(Numeric& gamma_dSelf,
                                                const Numeric& theta,
                                                const Numeric& self_pressure) const;
    void GetPressureBroadeningParams_dForeignGamma(Numeric& gamma_dForeign,
                                                   const Numeric& theta,
                                                   const Numeric& pressure,
                                                   const Numeric& self_pressure,
                                                   const Index    this_species,
                                                   const Index    h2o_species,
                                                   ConstVectorView vmrs) const;
    void GetPressureBroadeningParams_dWaterGamma(Numeric& gamma_dWater,
                                                 const Numeric& theta,
                                                 const Numeric& pressure,
                                                 const Index    this_species,
                                                 const Index    h2o_species,
                                                 ConstVectorView vmrs) const;
    void GetPressureBroadeningParams_dSelfPsf(Numeric& psf_dSelf,
                                              const Numeric& theta,
                                              const Numeric& self_pressure) const;
    void GetPressureBroadeningParams_dForeignPsf(Numeric& psf_dForeign,
                                                 const Numeric& theta,
                                                 const Numeric& pressure,
                                                 const Numeric& self_pressure,
                                                 const Index    this_species,
                                                 const Index    h2o_species,
                                                 ConstVectorView vmrs) const;
    void GetPressureBroadeningParams_dWaterPsf(Numeric& psf_dWater,
                                               const Numeric& theta,
                                               const Numeric& pressure,
                                               const Index    this_species,
                                               const Index    h2o_species,
                                               ConstVectorView vmrs) const;
    void GetPressureBroadeningParams_dSelfExponent(Numeric& gamma_dSelfExponent,
                                                   Numeric& psf_dSelfExponent,
                                                   const Numeric& theta,
                                                   const Numeric& self_pressure) const;
    void GetPressureBroadeningParams_dForeignExponent(Numeric& gamma_dForeignExponent,
                                                      Numeric& psf_dForeignExponent,
                                                      const Numeric& theta,
                                                      const Numeric& pressure,
                                                      const Numeric& self_pressure,
                                                      const Index    this_species,
                                                      const Index    h2o_species,
                                                      ConstVectorView vmrs) const;
    void GetPressureBroadeningParams_dWaterExponent(Numeric& gamma_dWaterExponent,
                                                    Numeric& psf_dWaterExponent,
                                                    const Numeric& theta,
                                                    const Numeric& pressure,
                                                    const Index    this_species,
                                                    const Index    h2o_species,
                                                    ConstVectorView vmrs) const;

    void GetSDAirBroadening(Numeric& gamma0,
                            Numeric& gamma2,
                            Numeric& delta0,
                            Numeric& delta2,
                            const Numeric& theta,
                            const Numeric& pressure) const;
    void GetSDAirBroadening_dT(Numeric& dgamma0,
                               Numeric& dgamma2,
                               Numeric& ddelta0,
                               Numeric& ddelta2,
                               const Numeric& T,
                               const Numeric& T0,
                               const Numeric& pressure) const;

    void GetHTPAirBroadening(Numeric& gamma0,
                             Numeric& gamma2,
                             Numeric& delta0,
                             Numeric& delta2,
                             Numeric& fvc,
                             Numeric& eta,
                             const Numeric& theta,
                             const Numeric& pressure) const;
    void GetHTPAirBroadening_dT(Numeric& dgamma0,
                                Numeric& dgamma2,
                                Numeric& ddelta0,
                                Numeric& ddelta2,
                                Numeric& dfvc,
                                Numeric& deta,
                                const Numeric& T,
                                const Numeric& T0,
                                const Numeric& pressure) const;
    
   // Sets the pressure broadening PB_type from String input
   void StorageTag2SetType(const String& input);
   
   // Sets the pressure broadening PB_type from String input
   void SetTypeFromIndex(const Index& type) {mtype = PB_Type(type);};
   
   // Returns length of the vector that is supposed to be input
   Index ExpectedVectorLengthFromType() const;
   
   // Sets the data of the class from vector input
   void SetDataFromVectorWithKnownType(ConstVectorView input);
   
   // Gets the vector from the data of the class
   void GetVectorFromData(Vector& output) const;
   
   // Returns the String tag for this PB_type
   String Type2StorageTag() const;
   
private:
    // mtype identifies the type of of pressure broadening and the other variables
    // are containers
    PB_Type       mtype;
    ArrayOfVector mdata;
    ArrayOfVector mdataerror;
};

#endif //pressurebroadeningdata_h