ARTS  2.4.0(git:4fb77825)
Functions | Variables
m_sensor.cc File Reference

Workspace functions related to sensor modelling variables. More...

#include <algorithm>
#include <cmath>
#include <stdexcept>
#include <string>
#include "arts.h"
#include "auto_md.h"
#include "check_input.h"
#include "interpolation_poly.h"
#include "m_select.h"
#include "math_funcs.h"
#include "messages.h"
#include "ppath.h"
#include "sensor.h"
#include "sorting.h"
#include "special_interp.h"
#include "xml_io.h"

Go to the source code of this file.

Functions

void AntennaConstantGaussian1D (Index &antenna_dim, Matrix &mblock_dlos_grid, GriddedField4 &r, Matrix &antenna_dlos, const Index &n_za_grid, const Numeric &fwhm, const Numeric &xwidth_si, const Numeric &dx_si, const Verbosity &verbosity)
 WORKSPACE METHOD: AntennaConstantGaussian1D. More...
 
void AntennaMultiBeamsToPencilBeams (Matrix &sensor_pos, Matrix &sensor_los, Matrix &antenna_dlos, Index &antenna_dim, Matrix &mblock_dlos_grid, const Index &atmosphere_dim, const Verbosity &verbosity)
 WORKSPACE METHOD: AntennaMultiBeamsToPencilBeams. More...
 
void AntennaOff (Index &antenna_dim, Matrix &mblock_dlos_grid, const Verbosity &verbosity)
 WORKSPACE METHOD: AntennaOff. More...
 
void antenna_responseGaussian (GriddedField4 &r, const Numeric &fwhm, const Numeric &xwidth_si, const Numeric &dx_si, const Index &do_2d, const Verbosity &)
 WORKSPACE METHOD: antenna_responseGaussian. More...
 
void antenna_responseVaryingGaussian (GriddedField4 &r, const Numeric &leff, const Numeric &xwidth_si, const Numeric &dx_si, const Index &nf, const Numeric &fstart, const Numeric &fstop, const Index &do_2d, const Verbosity &verbosity)
 WORKSPACE METHOD: antenna_responseVaryingGaussian. More...
 
void backend_channel_responseFlat (ArrayOfGriddedField1 &r, const Numeric &resolution, const Verbosity &)
 WORKSPACE METHOD: backend_channel_responseFlat. More...
 
void backend_channel_responseGaussian (ArrayOfGriddedField1 &r, const Vector &fwhm, const Vector &xwidth_si, const Vector &dx_si, const Verbosity &)
 WORKSPACE METHOD: backend_channel_responseGaussian. More...
 
void f_gridFromSensorAMSU (Vector &f_grid, const Vector &lo, const ArrayOfVector &f_backend, const ArrayOfArrayOfGriddedField1 &backend_channel_response, const Numeric &spacing, const Verbosity &verbosity)
 WORKSPACE METHOD: f_gridFromSensorAMSU. More...
 
void f_gridFromSensorAMSUgeneric (Vector &f_grid, const ArrayOfVector &f_backend_multi, const ArrayOfArrayOfGriddedField1 &backend_channel_response_multi, const Numeric &spacing, const Vector &verbosityVect, const Verbosity &verbosity)
 WORKSPACE METHOD: f_gridFromSensorAMSUgeneric. More...
 
void f_gridFromSensorHIRS (Vector &f_grid, const Vector &f_backend, const ArrayOfGriddedField1 &backend_channel_response, const Numeric &spacing, const Verbosity &verbosity)
 WORKSPACE METHOD: f_gridFromSensorHIRS. More...
 
void f_gridMetMM (Vector &f_grid, Vector &f_backend, ArrayOfArrayOfIndex &channel2fgrid_indexes, ArrayOfVector &channel2fgrid_weights, const Matrix &mm_back, const Vector &freq_spacing, const ArrayOfIndex &freq_number, const Numeric &freq_merge_threshold, const Verbosity &)
 WORKSPACE METHOD: f_gridMetMM. More...
 
void mblock_dlos_gridUniformCircular (Matrix &mblock_dlos_grid, const Numeric &spacing, const Numeric &width, const Index &centre, const Verbosity &)
 WORKSPACE METHOD: mblock_dlos_gridUniformCircular. More...
 
void mblock_dlos_gridUniformRectangular (Matrix &mblock_dlos_grid, const Numeric &spacing, const Numeric &za_width, const Numeric &aa_width, const Index &centre, const Verbosity &)
 WORKSPACE METHOD: mblock_dlos_gridUniformRectangular. More...
 
void sensor_responseAntenna (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Matrix &sensor_response_dlos_grid, const Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Index &atmosphere_dim, const Index &antenna_dim, const Matrix &antenna_dlos, const GriddedField4 &antenna_response, const Index &sensor_norm, const String &option_2d, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseAntenna. More...
 
void sensor_responseBackend (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Vector &f_backend, const ArrayOfGriddedField1 &backend_channel_response, const Index &sensor_norm, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseBackend. More...
 
void sensor_responseBackendFrequencySwitching (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Vector &f_backend, const ArrayOfGriddedField1 &backend_channel_response, const Index &sensor_norm, const Numeric &df1, const Numeric &df2, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseBackendFrequencySwitching. More...
 
void sensor_responseBeamSwitching (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Matrix &sensor_response_dlos_grid, const Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Numeric &w1, const Numeric &w2, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseBeamSwitching. More...
 
void sensor_responseFrequencySwitching (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseFrequencySwitching. More...
 
void sensor_responseIF2RF (Vector &sensor_response_f, Vector &sensor_response_f_grid, const Numeric &lo, const String &sideband_mode, const Verbosity &)
 WORKSPACE METHOD: sensor_responseIF2RF. More...
 
void sensor_responseFillFgrid (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Index &polyorder, const Index &nfill, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseFillFgrid. More...
 
void sensor_responseInit (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, ArrayOfIndex &sensor_response_pol_grid, Matrix &sensor_response_dlos_grid, const Vector &f_grid, const Matrix &mblock_dlos_grid, const Index &antenna_dim, const Index &atmosphere_dim, const Index &stokes_dim, const Index &sensor_norm, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseInit. More...
 
void sensorOff (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, ArrayOfIndex &sensor_response_pol_grid, Matrix &sensor_response_dlos_grid, Matrix &mblock_dlos_grid, const Index &stokes_dim, const Vector &f_grid, const Verbosity &verbosity)
 WORKSPACE METHOD: sensorOff. More...
 
void sensor_responseMixer (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Numeric &lo, const GriddedField1 &sideband_response, const Index &sensor_norm, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseMixer. More...
 
void sensor_responseMetMM (Index &antenna_dim, Matrix &mblock_dlos_grid, Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, ArrayOfIndex &sensor_response_pol_grid, Matrix &sensor_response_dlos_grid, Index &sensor_norm, const Index &atmosphere_dim, const Index &stokes_dim, const Vector &f_grid, const Vector &f_backend, const ArrayOfArrayOfIndex &channel2fgrid_indexes, const ArrayOfVector &channel2fgrid_weights, const String &iy_unit, const Matrix &antenna_dlos, const ArrayOfString &mm_pol, const Vector &mm_ant, const Index &use_antenna, const Index &mirror_dza, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseMetMM. More...
 
void sensor_responseMixerBackendPrecalcWeights (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Vector &f_backend, const ArrayOfArrayOfIndex &channel2fgrid_indexes, const ArrayOfVector &channel2fgrid_weights, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseMixerBackendPrecalcWeights. More...
 
void sensor_responseMultiMixerBackend (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Vector &lo_multi, const ArrayOfGriddedField1 &sideband_response_multi, const ArrayOfString &sideband_mode_multi, const ArrayOfVector &f_backend_multi, const ArrayOfArrayOfGriddedField1 &backend_channel_response_multi, const Index &sensor_norm, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseMultiMixerBackend. More...
 
void sensor_responsePolarisation (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, ArrayOfIndex &sensor_response_pol_grid, const Vector &sensor_response_f_grid, const Matrix &sensor_response_dlos_grid, const Index &stokes_dim, const String &iy_unit, const ArrayOfIndex &instrument_pol, const Verbosity &)
 WORKSPACE METHOD: sensor_responsePolarisation. More...
 
void sensor_responseStokesRotation (Sparse &sensor_response, const Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Index &stokes_dim, const Vector &stokes_rotation, const Verbosity &)
 WORKSPACE METHOD: sensor_responseStokesRotation. More...
 
void sensor_responseGenericAMSU (Vector &f_grid, Index &antenna_dim, Matrix &mblock_dlos_grid, Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, ArrayOfIndex &sensor_response_pol_grid, Matrix &sensor_response_dlos_grid, Index &sensor_norm, const Index &atmosphere_dim, const Index &stokes_dim, const Matrix &sensor_description_amsu, const Numeric &spacing, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseGenericAMSU. More...
 
void sensor_responseSimpleAMSU (Vector &f_grid, Index &antenna_dim, Matrix &mblock_dlos_grid, Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, ArrayOfIndex &sensor_response_pol_grid, Matrix &sensor_response_dlos_grid, Index &sensor_norm, const Index &atmosphere_dim, const Index &stokes_dim, const Matrix &sensor_description_amsu, const Numeric &spacing, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseSimpleAMSU. More...
 
void WMRFSelectChannels (Vector &f_grid, Sparse &wmrf_weights, Vector &f_backend, const ArrayOfIndex &wmrf_channels, const Verbosity &verbosity)
 WORKSPACE METHOD: WMRFSelectChannels. More...
 
void sensor_responseWMRF (Sparse &sensor_response, Vector &sensor_response_f, ArrayOfIndex &sensor_response_pol, Matrix &sensor_response_dlos, Vector &sensor_response_f_grid, const ArrayOfIndex &sensor_response_pol_grid, const Matrix &sensor_response_dlos_grid, const Sparse &wmrf_weights, const Vector &f_backend, const Verbosity &verbosity)
 WORKSPACE METHOD: sensor_responseWMRF. More...
 
void ySimpleSpectrometer (Vector &y, Vector &y_f, const Matrix &iy, const Index &stokes_dim, const Vector &f_grid, const Numeric &df, const Verbosity &verbosity)
 WORKSPACE METHOD: ySimpleSpectrometer. More...
 
void yApplySensorPol (Vector &y, Vector &y_f, ArrayOfIndex &y_pol, Matrix &y_pos, Matrix &y_los, ArrayOfVector &y_aux, Matrix &y_geo, Matrix &jacobian, const Index &stokes_dim, const Index &jacobian_do, const Matrix &sensor_pos, const Matrix &sensor_pol, const Verbosity &)
 WORKSPACE METHOD: yApplySensorPol. More...
 

Variables

const Numeric PI
 
const Numeric NAT_LOG_2
 
const Numeric DEG2RAD
 
const Numeric RAD2DEG
 
const Index GFIELD1_F_GRID
 
const Index GFIELD4_FIELD_NAMES
 
const Index GFIELD4_F_GRID
 
const Index GFIELD4_ZA_GRID
 
const Index GFIELD4_AA_GRID
 
const Numeric SPEED_OF_LIGHT
 

Detailed Description

Workspace functions related to sensor modelling variables.

Author
Mattias Ekström/Patrick Eriksson patri.nosp@m.ck.e.nosp@m.rikss.nosp@m.on@c.nosp@m.halme.nosp@m.rs.s.nosp@m.e
Date
2003-02-13

These functions are listed in the doxygen documentation as entries of the file auto_md.h.

Definition in file m_sensor.cc.

Function Documentation

◆ antenna_responseGaussian()

void antenna_responseGaussian ( GriddedField4 &  antenna_response,
const Numeric &  fwhm,
const Numeric &  xwidth_si,
const Numeric &  dx_si,
const Index &  do_2d,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: antenna_responseGaussian.

Sets up a gaussian antenna response.

The method assumes that the response is the same for all frequencies and polarisations, and that it can be modelled as gaussian.

The grid generated is approximately <br> si * [-xwidth_si:dx_si:xwidth_si] where si is the standard deviation corresponding to the FWHM. That is, width and spacing of the grid is specified in terms of number of standard deviations. If xwidth_si is set to 2, the response will cover about 95% the complete response. For xwidth_si=3, about 99% is covered. If xwidth_si/dx_si is not an integer, the end points of the grid are kept and the spacing of the grid is reduced (ie. spacing is equal or smaller dx_si).

If the 2D option is selected (do_2d), a circular antenna is assumed and the response is any direction follows the 1D case.

The antenna repsonse is not normalised.

Author
Patrick Eriksson
Parameters
[out]antenna_responseWS Output
[in]fwhmGeneric Input
[in]xwidth_siGeneric Input (Default: "3")
[in]dx_siGeneric Input (Default: "0.1")
[in]do_2dGeneric Input (Default: "0")

Definition at line 203 of file m_sensor.cc.

References GriddedField4::data, gaussian_response_autogrid(), joker, NAT_LOG_2, PI, pow(), Tensor4::resize(), GriddedField::set_grid(), GriddedField::set_grid_name(), GriddedField::set_name(), sqrt(), ARTS::Var::x(), and ARTS::Var::y().

Referenced by antenna_responseGaussian_g(), and AntennaConstantGaussian1D().

◆ antenna_responseVaryingGaussian()

void antenna_responseVaryingGaussian ( GriddedField4 &  antenna_response,
const Numeric &  leff,
const Numeric &  xwidth_si,
const Numeric &  dx_si,
const Index &  nf,
const Numeric &  fstart,
const Numeric &  fstop,
const Index &  do_2d,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: antenna_responseVaryingGaussian.

Sets up gaussian antenna responses.

Similar to antenna_responseGaussian but allows to set up responses that varies with frequency. That is, the method assumes that the response is the same for all polarisations, and that it can be modelled as a gaussian function varying with frequency.

The full width at half maximum (FWHM in radians) is calculated as: <br> fwhm = lambda / leff where lambda is the wavelength and leff is the effective size of the antenna. Normally, leff is smaller than the physical antenna size.

Antenna responses are created for nf frequencies spanning the range [fstart,fstop], with a logarithmic spacing. That is, the frequency grid of the responses is taken from VectorNLogSpace.

The responses have a common angular grid. The width, determined by xwidth_si*, is set for the lowest frequency, while the spacing (dx_si) is set for the highest frequency. This ensures that both the width and spacing are equal or better than xwidth_si and dx_si*, respectively, for all frequencies.

If the 2D option is selected (do_2d), a circular antenna is assumed and the response is any direction follows the 1D case.

The antenna repsonse is not normalised.

Author
Patrick Eriksson
Parameters
[out]antenna_responseWS Output
[in]leffGeneric Input
[in]xwidth_siGeneric Input (Default: "3")
[in]dx_siGeneric Input (Default: "0.1")
[in]nfGeneric Input
[in]fstartGeneric Input
[in]fstopGeneric Input
[in]do_2dGeneric Input (Default: "0")

Definition at line 254 of file m_sensor.cc.

References GriddedField4::data, ARTS::Var::f_grid(), gaussian_response(), gaussian_response_autogrid(), joker, NAT_LOG_2, PI, pow(), RAD2DEG, Tensor4::resize(), GriddedField::set_grid(), GriddedField::set_grid_name(), GriddedField::set_name(), SPEED_OF_LIGHT, sqrt(), VectorNLogSpace(), ARTS::Var::verbosity(), ARTS::Var::x(), and ARTS::Var::y().

Referenced by antenna_responseVaryingGaussian_g().

◆ AntennaConstantGaussian1D()

void AntennaConstantGaussian1D ( Index &  antenna_dim,
Matrix &  mblock_dlos_grid,
GriddedField4 &  antenna_response,
Matrix &  antenna_dlos,
const Index &  n_za_grid,
const Numeric &  fwhm,
const Numeric &  xwidth_si,
const Numeric &  dx_si,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: AntennaConstantGaussian1D.

Sets up a 1D gaussian antenna response and a matching mblock_dlos_grid*.

As antenna_responseGaussian, but also creates mblock_dlos_grid. For returned antenna response, see antenna_responseGaussian.

The size of mblock_dlos_grid is determined by n_za_grid. The end points of the grid are set to be the same as for the antenna response. The spacing of the grid follows the magnitude of the response; the spacing is smaller where the response is high. More precisely, the grid points are determined by dividing the cumulative sum of the response in equal steps. This makes sense if the representation error of the radiance (as a function of zenith angle) increases linearly with the grid spacing.

The WSV antenna_dlos is set to [0].

The antenna repsonse is not normalised.

Author
Patrick Eriksson
Parameters
[out]antenna_dimWS Output
[out]mblock_dlos_gridWS Output
[out]antenna_responseWS Output
[out]antenna_dlosWS Output
[in]n_za_gridGeneric Input
[in]fwhmGeneric Input
[in]xwidth_siGeneric Input (Default: "3")
[in]dx_siGeneric Input (Default: "0.1")

Definition at line 72 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), ARTS::Var::antenna_dlos(), antenna_responseGaussian(), GriddedField4::data, GriddedField::get_numeric_grid(), GFIELD4_ZA_GRID, gridpos(), interp(), interpweights(), joker, ARTS::Var::mblock_dlos_grid(), ConstVectorView::nelem(), nlinspace(), and ARTS::Var::verbosity().

Referenced by AntennaConstantGaussian1D_g().

◆ AntennaMultiBeamsToPencilBeams()

void AntennaMultiBeamsToPencilBeams ( Matrix &  sensor_pos,
Matrix &  sensor_los,
Matrix &  antenna_dlos,
Index &  antenna_dim,
Matrix &  mblock_dlos_grid,
const Index &  atmosphere_dim,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: AntennaMultiBeamsToPencilBeams.

Maps a multi-beam case to a matching pencil beam case.

Cases with overlapping beams are most efficiently handled by letting antenna_dlos have several rows. That is, there are multiple beams for each measurement block. The drawback is that many variables must be adjusted if the corresponding pencil beam spectra shall be calculated. This method makes this adjustment. That is, if you have a control file for a multiple beam case and for some reason want to avoid the antenna weighting, you add this method before sensor_responseInit, and remove the call of sensor_responseAntenna* and you will get the matching pencil beam spectra.

Author
Patrick Eriksson
Parameters
[in,out]sensor_posWS Input/Output
[in,out]sensor_losWS Input/Output
[in,out]antenna_dlosWS Input/Output
[in,out]antenna_dimWS Input/Output
[in,out]mblock_dlos_gridWS Input/Output
[in]atmosphere_dimWS Input

Definition at line 118 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), ARTS::Var::antenna_dlos(), AntennaOff(), ARTS::Var::atmosphere_dim(), chk_if_in_range(), joker, ARTS::Var::mblock_dlos_grid(), ConstMatrixView::ncols(), ARTS::Var::sensor_los(), ARTS::Var::sensor_pos(), and ARTS::Var::verbosity().

Referenced by AntennaMultiBeamsToPencilBeams_g().

◆ AntennaOff()

void AntennaOff ( Index &  antenna_dim,
Matrix &  mblock_dlos_grid,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: AntennaOff.

Sets some antenna related variables

Use this method to set antenna_dim and mblock_dlos_grid to suitable values (1 and [0], respectively) for cases when a sensor is included, but the antenna pattern is neglected.

Author
Patrick Eriksson
Parameters
[out]antenna_dimWS Output
[out]mblock_dlos_gridWS Output

Definition at line 187 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), CREATE_OUT2, and ARTS::Var::mblock_dlos_grid().

Referenced by AntennaMultiBeamsToPencilBeams(), AntennaOff_g(), sensor_responseGenericAMSU(), sensor_responseSimpleAMSU(), sensorOff(), and ySimpleSpectrometer().

◆ backend_channel_responseFlat()

void backend_channel_responseFlat ( ArrayOfGriddedField1 &  backend_channel_response,
const Numeric &  resolution,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: backend_channel_responseFlat.

Sets up a rectangular channel response.

The response of the backend channels is hee assumed to be constant inside the resolution width, and zero outside.

The method assumes that all channels have the same response.

Author
Patrick Eriksson
Parameters
[out]backend_channel_responseWS Output
[in]resolutionGeneric Input

Definition at line 323 of file m_sensor.cc.

References ARTS::Var::x().

Referenced by backend_channel_responseFlat_g(), and ySimpleSpectrometer().

◆ backend_channel_responseGaussian()

void backend_channel_responseGaussian ( ArrayOfGriddedField1 &  backend_channel_response,
const Vector &  fwhm,
const Vector &  xwidth_si,
const Vector &  dx_si,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: backend_channel_responseGaussian.

Sets up a gaussian backend channel response.

The method assumes that all channels can be modelled as gaussian.

If fwhm has only one element, all channels are assumed to be equal. If fwhm has multiple elements, xwidth_si and dx_si must have one element or the same number of elements as fwhm. If one element is given, this value will be used for all channels.

The grid generated can be written as <br> si * [-xwidth_si:dx_si:xwidth_si] where si is the standard deviation corresponding to the FWHM. That is, width and spacing of the grid is specified in terms of number of standard deviations. If xwidth_si is set to 2, the response will cover about 95% the complete response. For xwidth_si=3, about 99% is covered. If xwidth_si/dx_si is not an integer, the end points of the grid are kept and the spacing if the grid is adjusted in the downward direction (ie. spacing is. is max dx_si).

Author
Patrick Eriksson, Oliver Lemke
Parameters
[out]backend_channel_responseWS Output
[in]fwhmGeneric Input
[in]xwidth_siGeneric Input (Default: "[3]")
[in]dx_siGeneric Input (Default: "[0.1]")

Definition at line 344 of file m_sensor.cc.

References data, gaussian_response_autogrid(), ConstVectorView::nelem(), ARTS::Var::x(), and ARTS::Var::y().

Referenced by backend_channel_responseGaussian_g().

◆ f_gridFromSensorAMSU()

void f_gridFromSensorAMSU ( Vector &  f_grid,
const Vector &  lo_multi,
const ArrayOfVector &  f_backend_multi,
const ArrayOfArrayOfGriddedField1 &  backend_channel_response_multi,
const Numeric &  spacing,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: f_gridFromSensorAMSU.

Automatically calculate f_grid to match the sensor.

This method is handy if you are simulating an AMSU-type instrument, consisting of a few discrete channels. The case that channels touch, as for MHS, is handled correctly. But the case that channels overlap is not (yet) handled and results in an error message.

The method calculates f_grid to match the instrument, as given by the local oscillator frequencies lo_multi, the backend frequencies f_backend_multi, and the backend channel responses backend_channel_response_multi.

You have to specify the desired spacing in the keyword spacing, which has a default value of 100 MHz. (The actual value is 0.1e9, since our unit is Hz.)

The produced grid will not have exactly the requested spacing, but will not be coarser than requested. The algorithm starts with the band edges, then adds additional points until the spacing is at least as fine as requested.

There is a similar method for HIRS-type instruments, see f_gridFromSensorHIRS.

Author
Stefan Buehler, Mathias Milz
Parameters
[out]f_gridWS Output
[in]lo_multiWS Input
[in]f_backend_multiWS Input
[in]backend_channel_response_multiWS Input
[in]spacingGeneric Input (Default: ".1e9")

Definition at line 384 of file m_sensor.cc.

References ARTS::Var::backend_channel_response(), CREATE_OUT2, CREATE_OUT3, ARTS::Var::f_backend(), ARTS::Var::f_grid(), find_effective_channel_boundaries(), ARTS::Var::lo(), Array< base >::nelem(), Absorption::nelem(), nlinspace(), and ARTS::Var::verbosity().

Referenced by f_gridFromSensorAMSU_g(), and sensor_responseSimpleAMSU().

◆ f_gridFromSensorAMSUgeneric()

void f_gridFromSensorAMSUgeneric ( Vector &  f_grid,
const ArrayOfVector &  f_backend_multi,
const ArrayOfArrayOfGriddedField1 &  backend_channel_response_multi,
const Numeric &  spacing,
const Vector &  verbosityVect,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: f_gridFromSensorAMSUgeneric.

Automatcially calculate f_grid to match the sensor. This function is based on 'f_gridFromSensorAMSU'

The method calculates f_grid to match the instrument, as given by the backend frequencies f_backend, and the backend channel responses backend_channel_response.

You have to specify the desired spacing in the keyword spacing, which has a default value of 100 MHz. (The actual value is 0.1e9, since our unit is Hz.) The produced grid will not have exactly the requested spacing, but it will not be coarser than requested. The algorithm starts with the band edges, then adds additional points until the spacing is at least as fine as requested.

Author
Oscar Isoz
Parameters
[out]f_gridWS Output
[in]f_backend_multiWS Input
[in]backend_channel_response_multiWS Input
[in]spacingGeneric Input (Default: ".1e9")
[in]verbosityVectGeneric Input (Default: "[]")

Definition at line 516 of file m_sensor.cc.

References ARTS::Var::backend_channel_response_multi(), CREATE_OUT2, CREATE_OUT3, data, ARTS::Var::f_backend_multi(), ARTS::Var::f_grid(), find_effective_channel_boundaries(), Array< base >::nelem(), ConstVectorView::nelem(), and ARTS::Var::verbosity().

Referenced by f_gridFromSensorAMSUgeneric_g(), and sensor_responseGenericAMSU().

◆ f_gridFromSensorHIRS()

void f_gridFromSensorHIRS ( Vector &  f_grid,
const Vector &  f_backend,
const ArrayOfGriddedField1 &  backend_channel_response,
const Numeric &  spacing,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: f_gridFromSensorHIRS.

Automatically calculate f_grid to match the sensor.

This method is handy if you are simulating a HIRS-type instrument, consisting of a few discrete channels.

It calculates f_grid to match the instrument, as given by the nominal band frequencies f_backend and the spectral channel response functions given by backend_channel_response.

You have to specify the desired spacing in the keyword spacing, which has a default value of 5e8 Hz.

The produced grid will not have exactly the requested spacing, but will not be coarser than requested. The algorithm starts with the band edges, then adds additional points until the spacing is at least as fine as requested.

There is a similar method for AMSU-type instruments, see f_gridFromSensorAMSU*.

Author
Stefan Buehler
Parameters
[out]f_gridWS Output
[in]f_backendWS Input
[in]backend_channel_responseWS Input
[in]spacingGeneric Input (Default: "5e8")

Definition at line 668 of file m_sensor.cc.

References ARTS::Var::backend_channel_response(), CREATE_OUT2, CREATE_OUT3, ARTS::Var::f_backend(), ARTS::Var::f_grid(), find_effective_channel_boundaries(), Array< base >::nelem(), ConstVectorView::nelem(), nlinspace(), and ARTS::Var::verbosity().

Referenced by f_gridFromSensorHIRS_g().

◆ f_gridMetMM()

void f_gridMetMM ( Vector &  f_grid,
Vector &  f_backend,
ArrayOfArrayOfIndex &  channel2fgrid_indexes,
ArrayOfVector &  channel2fgrid_weights,
const Matrix &  met_mm_backend,
const Vector &  freq_spacing,
const ArrayOfIndex &  freq_number,
const Numeric &  freq_merge_threshold,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: f_gridMetMM.

Sets f_grid and associated variables match MetMM settings.

The method calculates f_grid to match the specifications of a met_mm_backend* table and method arguments.

You have to specify the desired spacing using the keyword freq_spacing. You can pass a Vector with one element to apply the same spacing to all channels or pass a spacing value for each channel separately.

Optionally, freq_number can be set to specify the mininum number of frequencies per passband for each channel. The frequencies are placed equally spaced in each passband. The minimum spacing resulting from freq_number* and freq_spacing will be used for the calculation. To explicitly use freq_spacing for a channel, freq_number can be set to -1 for this channel.

The number of elements in freq_number can either be the number of channels or 1. If only one element is given, this number is used for all channels. If freq_number is 1 and freq_spacing is wider than the bandwidth of the channel, one frequency is placed in the middle of each passband.

Frequencies that would be closer than freq_merge_threshold in the generated f_grid are merged together. This value should be left at the default value. This is only meant to compensate for numerical inaccuracies in the frequency calculation to merge frequency that are supposed to be identical.

Author
Oliver Lemke
Patrick Eriksson
Parameters
[out]f_gridWS Output
[out]f_backendWS Output
[out]channel2fgrid_indexesWS Output
[out]channel2fgrid_weightsWS Output
[in]met_mm_backendWS Input
[in]freq_spacingGeneric Input (Default: "[.1e9]")
[in]freq_numberGeneric Input (Default: "[-1]")
[in]freq_merge_thresholdGeneric Input (Default: "1")

Definition at line 735 of file m_sensor.cc.

References abs, ARTS::Var::channel2fgrid_indexes(), ARTS::Var::channel2fgrid_weights(), chk_met_mm_backend(), ARTS::Var::f_backend(), ARTS::Var::f_grid(), ARTS::Var::f_index(), ARTS::Var::lo(), Array< base >::nelem(), ConstVectorView::nelem(), and ConstMatrixView::nrows().

Referenced by f_gridMetMM_g().

◆ mblock_dlos_gridUniformCircular()

void mblock_dlos_gridUniformCircular ( Matrix &  mblock_dlos_grid,
const Numeric &  spacing,
const Numeric &  width,
const Index &  centre,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: mblock_dlos_gridUniformCircular.

Gives mblock_dlos_grid roughly circular coverage, with uniform spacing.

The method considers points on a regular grid with a spacing set by GIN spacing. All points inside a radius from (0,0) are included in mblock_dlos_grid*. The positions in mblock_dlos_grid thus covers a roughly circular domain, and cover the same solid beam angle. The radius is adjusted according to spacing' and *centre, but is ensured to be >= width.

Note that the method assumes that width is small and the solid beam angle does not change with distance from (0.0).

Defualt is to consider grid positions of ..., -spacing/2, spacing/2, ... If you want to have (0,0) as a point in mblock_dlos_grid, change centre* from its default value.

Author
Patrick Eriksson
Parameters
[out]mblock_dlos_gridWS Output
[in]spacingGeneric Input
[in]widthGeneric Input
[in]centreGeneric Input (Default: "0")

Definition at line 907 of file m_sensor.cc.

References linspace(), w(), and ARTS::Var::x().

Referenced by mblock_dlos_gridUniformCircular_g().

◆ mblock_dlos_gridUniformRectangular()

void mblock_dlos_gridUniformRectangular ( Matrix &  mblock_dlos_grid,
const Numeric &  spacing,
const Numeric &  za_width,
const Numeric &  aa_width,
const Index &  centre,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: mblock_dlos_gridUniformRectangular.

Gives mblock_dlos_grid rectangular coverage, with uniform spacing.

The method creates an equidistant rectangular grid. The width in zenith and azimuth can differ. Note that selected widths are half-widths (i.e. distance from (0,0), and refers to the mimumum value allowed. The actual width depends on values selected for spacing and centre.

Defualt is to consider grid positions of ..., -spacing/2, spacing/2, ... If you want to have (0,0) as a point in mblock_dlos_grid, change centre* from its default value.

Author
Patrick Eriksson
Parameters
[out]mblock_dlos_gridWS Output
[in]spacingGeneric Input
[in]za_widthGeneric Input
[in]aa_widthGeneric Input
[in]centreGeneric Input (Default: "0")

Definition at line 946 of file m_sensor.cc.

References linspace(), ARTS::Var::mblock_dlos_grid(), ConstVectorView::nelem(), and w().

Referenced by mblock_dlos_gridUniformRectangular_g().

◆ sensor_responseAntenna()

void sensor_responseAntenna ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Matrix &  sensor_response_dlos_grid,
const Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Index &  atmosphere_dim,
const Index &  antenna_dim,
const Matrix &  antenna_dlos,
const GriddedField4 &  antenna_response,
const Index &  sensor_norm,
const String &  option_2d,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseAntenna.

Includes response of the antenna.

The function returns the sensor response matrix after the antenna characteristics have been included.

The function handles "multi-beam" cases where the polarisation coordinate system is the same for all beams.

See antenna_dim, antenna_dlos and antenna_response for details on how to specify the antenna response.

The text below refers to mblock_dlos_grid despite it is not an input to the method. The method instead uses sensor_response_dlos_grid but the values in this WSV are likely coming from mblock_dlos_grid.

One dimensional antenna patterns are handled as other response functions. That is, both antenna response and radiances are treated as piece-wise linear functions, and the pencil beam calculations must cover the full sensor response (i.e. mblock_dlos_grid must be sufficiently broad).

There exist different options for two dimensional (2D) antenna patterns, see below (if 2D, the GIN option_2d must be set, the default results in an error). A normalisation is always applied for 2D antennas (i.e. sensor-norm* is ignored).

"interp_response"For this option, each direction defined by mblock_dlos_grid is considered to represent the same size in terms of solid beam angle, and the antenna pattern is interpolated to these directions. There is no check on how well mblock_dlos_grid covers the antenna response. The response is treated to be zero outside the ranges of its anular grids

"gridded_dlos"This option is more similar to the 1D case. The radiances are treated as a bi-linear function, but the antenna response is treated as step- wise constant function (in contrast to 1D). For this option mblock_dlos_grid* must match a combination of zenith and azimuth grids, and this for a particular order. If the zenith and azimuth grids have 3 and 2 values, respectively, the order shall be: <br> [(za1,aa1); (za2,aa1); (za3,aa1); (za1,aa2); (za2,aa2); (za3,aa2) ] Both these grids must be strictly increasing and as for 1D must cover the antenna response completely.

Author
Patrick Eriksson
Mattias Ekstrom
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_dlos_gridWS Input/Output
[in]sensor_response_f_gridWS Input
[in]sensor_response_pol_gridWS Input
[in]atmosphere_dimWS Input
[in]antenna_dimWS Input
[in]antenna_dlosWS Input
[in]antenna_responseWS Input
[in]sensor_normWS Input
[in]option_2dGeneric Input (Default: "-")

Definition at line 990 of file m_sensor.cc.

References antenna1d_matrix(), antenna2d_gridded_dlos(), antenna2d_interp_response(), ARTS::Var::antenna_dim(), ARTS::Var::antenna_dlos(), ARTS::Var::antenna_response(), ARTS::Var::atmosphere_dim(), chk_if_bool(), chk_if_in_range(), chk_if_increasing(), CREATE_OUT3, GFIELD4_AA_GRID, GFIELD4_F_GRID, GFIELD4_FIELD_NAMES, GFIELD4_ZA_GRID, is_decreasing(), is_increasing(), joker, last(), max, min, mult(), Sparse::ncols(), ConstVectorView::nelem(), Sparse::nrows(), sensor_aux_vectors(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), and ARTS::Var::sensor_response_pol_grid().

Referenced by sensor_responseAntenna_g().

◆ sensor_responseBackend()

void sensor_responseBackend ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Vector &  f_backend,
const ArrayOfGriddedField1 &  backend_channel_response,
const Index &  sensor_norm,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseBackend.

Includes response of the backend (spectrometer).

The function returns the sensor response matrix after the backend characteristics have been included.

See f_backend, backend_channel_response and sensor_norm for details on how to specify the backend response.

Author
Mattias Ekstrom
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]f_backendWS Input
[in]backend_channel_responseWS Input
[in]sensor_normWS Input

Definition at line 1239 of file m_sensor.cc.

References ARTS::Var::backend_channel_response(), CREATE_OUT3, ARTS::Var::f_backend(), GFIELD1_F_GRID, is_increasing(), last(), max, min, mult(), Sparse::ncols(), ConstVectorView::nelem(), Sparse::nrows(), sensor_aux_vectors(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), and spectrometer_matrix().

Referenced by sensor_responseBackend_g(), sensor_responseBackendFrequencySwitching(), sensor_responseGenericAMSU(), sensor_responseMultiMixerBackend(), and ySimpleSpectrometer().

◆ sensor_responseBackendFrequencySwitching()

void sensor_responseBackendFrequencySwitching ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Vector &  f_backend,
const ArrayOfGriddedField1 &  backend_channel_response,
const Index &  sensor_norm,
const Numeric &  df1,
const Numeric &  df2,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseBackendFrequencySwitching.

Frequency switching for a pure SSB reciever.

This function can be used for simulation of frequency switching. That is, when the final spectrum is the difference of two spectra shifted in frequency. The switching is performed by the LO, but for a pure singel sideband reciever this is most easily simulated by instead shifting the backend, as done here.

A strightforward frequency switching is modelled (no folding) The channel positions for the first measurement cycle are f_backend+df1, and for the second f_backend+df2. The first measurement cycle is given the negive weight. That is, the output is the spectrum for cycle2 minus the spectrum for cycle1. Output frequency grids are set to f_backend.

Use sensor_responseFrequencySwitching for double sideband cases.

The method has the same general functionality as, and can replace, sensor_responseBackend*.

Author
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]f_backendWS Input
[in]backend_channel_responseWS Input
[in]sensor_normWS Input
[in]df1Generic Input
[in]df2Generic Input

Definition at line 1393 of file m_sensor.cc.

References ARTS::Var::backend_channel_response(), ARTS::Var::f_backend(), sensor_aux_vectors(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), sensor_responseBackend(), sub(), and ARTS::Var::verbosity().

Referenced by sensor_responseBackendFrequencySwitching_g().

◆ sensor_responseBeamSwitching()

void sensor_responseBeamSwitching ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Matrix &  sensor_response_dlos_grid,
const Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Numeric &  w1,
const Numeric &  w2,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseBeamSwitching.

Simulation of "beam switching".

The measurement procedure is based on taking the difference between two spectra measured in different directions, and the calculation set-up must treat exactly two observation directions.

The returned spectrum is y = w1*y + w2*y2, where y1 and w1 are the spectrum and weight for the first direction, respectively (y2 and (w2 defined correspondingly for the second direction).

Zenith and azimuth angles after beam switching are set to the values of the second direction.

Author
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_dlos_gridWS Input/Output
[in]sensor_response_f_gridWS Input
[in]sensor_response_pol_gridWS Input
[in]w1Generic Input (Default: "-1")
[in]w2Generic Input (Default: "1")

Definition at line 1464 of file m_sensor.cc.

Referenced by sensor_responseBeamSwitching_g().

◆ sensor_responseFillFgrid()

void sensor_responseFillFgrid ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Index &  polyorder,
const Index &  nfill,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseFillFgrid.

Polynomial frequency interpolation of spectra.

The sensor response methods treat the spectra to be piece-wise linear functions. This method is a workaround for making methods handling the spectra in a more elaborate way: it generates spectra on a more dense grid by polynomial interpolation. The interpolation is not done explicitly, it is incorporated into sensor_response.

This method should in general increase the calculation accuracy for a given f_grid. However, the selection of (original) grid points becomes more sensitive when using this method. A poor choice of grid points can result in a decreased accuracy, or generation of negative radiances. Test calculations indicated that the error easily can increase with this method close the edge of f_grid, and it could be wise to make f_grid a bit wider than actually necessary to avoid this effect

The method shall be inserted before the antenna stage. That is, this method shall normally be called directly after sensor_responseInit.

Between each neighbouring points of f_grid, this method adds nfill* grid points. The polynomial order of the interpolation is polyorder*.

Author
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]polyorderGeneric Input (Default: "3")
[in]nfillGeneric Input (Default: "2")

Definition at line 1639 of file m_sensor.cc.

References abs, CREATE_OUT3, gridpos_poly(), interpweights(), Array< base >::nelem(), nlinspace(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol_grid(), and w().

Referenced by sensor_responseFillFgrid_g().

◆ sensor_responseFrequencySwitching()

void sensor_responseFrequencySwitching ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseFrequencySwitching.

Simulation of "frequency switching".

A general method for frequency switching. The WSM sensor_responseBackendFrequencySwitching* gives a description of this observation technique, and is also a more straightforward <br> method for pure singel sideband cases.

It is here assume that sensor_responseMultiMixerBackend has been used to calculate the spectrum for two LO positions. This method calculates the difference between these two spectra, where the second spectrum gets weight 1 and the first weight -1 (as in sensor_responseBackendFrequencySwitching*).

Output frequency grids are taken from the second spectrum.

Author
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input

Definition at line 1527 of file m_sensor.cc.

References CREATE_OUT3, Sparse::insert_row(), is_multiple(), mult(), Sparse::ncols(), Sparse::nrows(), sensor_aux_vectors(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), and ARTS::Var::sensor_response_pol_grid().

Referenced by sensor_responseFrequencySwitching_g().

◆ sensor_responseGenericAMSU()

void sensor_responseGenericAMSU ( Vector &  f_grid,
Index &  antenna_dim,
Matrix &  mblock_dlos_grid,
Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
ArrayOfIndex &  sensor_response_pol_grid,
Matrix &  sensor_response_dlos_grid,
Index &  sensor_norm,
const Index &  atmosphere_dim,
const Index &  stokes_dim,
const Matrix &  sensor_description_amsu,
const Numeric &  spacing,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseGenericAMSU.

Simplified sensor setup for an AMSU-type instrument.

This function is derived from 'sensor_responseSimpleAMSU' but is more generalized since the number of passbands in each can be in the range from 1 to 4 - in order to correctly simulate AMSU-A type sensors

This method allows quick and simple definition of AMSU-type sensors. Assumptions:

  1. Pencil beam antenna.
  2. 1-4 Passband/sidebands per channel.
  3. Sideband mode "upper"
  4. The channel response is rectangular.

Under these assumptions the only inputs needed are the LO positions, the offsets from the LO, and the IF bandwidths. They are provided in sensor_description_amsu.

Author
Oscar Isoz
Parameters
[out]f_gridWS Output
[out]antenna_dimWS Output
[out]mblock_dlos_gridWS Output
[out]sensor_responseWS Output
[out]sensor_response_fWS Output
[out]sensor_response_polWS Output
[out]sensor_response_dlosWS Output
[out]sensor_response_f_gridWS Output
[out]sensor_response_pol_gridWS Output
[out]sensor_response_dlos_gridWS Output
[out]sensor_normWS Output
[in]atmosphere_dimWS Input
[in]stokes_dimWS Input
[in]sensor_description_amsuWS Input
[in]spacingGeneric Input (Default: ".1e9")

Definition at line 2742 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), AntennaOff(), ARTS::Var::atmosphere_dim(), ARTS::Var::backend_channel_response_multi(), GriddedField1::data, ARTS::Var::f_backend_multi(), ARTS::Var::f_grid(), f_gridFromSensorAMSUgeneric(), joker, ARTS::Var::lo_multi(), ARTS::Var::mblock_dlos_grid(), ARTS::Var::ncols(), Array< base >::nelem(), ConstVectorView::nelem(), ARTS::Var::nrows(), GriddedField1::resize(), Vector::resize(), sensor_aux_vectors(), ARTS::Var::sensor_description_amsu(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), sensor_responseBackend(), sensor_responseInit(), GriddedField::set_grid(), GriddedField::set_grid_name(), GriddedField::set_name(), ARTS::Var::sideband_response_multi(), ARTS::Var::stokes_dim(), and ARTS::Var::verbosity().

Referenced by sensor_responseGenericAMSU_g().

◆ sensor_responseIF2RF()

void sensor_responseIF2RF ( Vector &  sensor_response_f,
Vector &  sensor_response_f_grid,
const Numeric &  lo,
const String &  sideband_mode,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseIF2RF.

Converts sensor response variables from IF to RF.

The function converts intermediate frequencies (IF) in sensor_response_f* and sensor_response_f_grid to radio frequencies (RF). This conversion is needed if the frequency translation of a mixer is included and the position of backend channels are specified in RF.

A direct frequency conversion is performed. Values are not sorted in any way.

Author
Patrick Eriksson
Parameters
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]loWS Input
[in]sideband_modeWS Input

Definition at line 1602 of file m_sensor.cc.

References ARTS::Var::lo(), max, ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), and ARTS::Var::sideband_mode().

Referenced by sensor_responseIF2RF_g(), and sensor_responseMultiMixerBackend().

◆ sensor_responseInit()

void sensor_responseInit ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
ArrayOfIndex &  sensor_response_pol_grid,
Matrix &  sensor_response_dlos_grid,
const Vector &  f_grid,
const Matrix &  mblock_dlos_grid,
const Index &  antenna_dim,
const Index &  atmosphere_dim,
const Index &  stokes_dim,
const Index &  sensor_norm,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseInit.

Initialises the variables summarising the sensor response.

This method sets the variables to match monochromatic pencil beam calculations, to be further modified by inclusion of sensor characteristics. Use sensorOff if pure monochromatic pencil beam calculations shall be performed.

The variables are set as follows: <br> sensor_response : Identity matrix, with size matching f_grid, <br> stokes_dim and mblock_dlos_grid. <br> sensor_response_f : Repeated values of f_grid. <br> sensor_response_pol : Data matching stokes_dim. <br> sensor_response_dlos : Repeated values of mblock_dlos_grid. <br> sensor_response_f_grid : Equal to f_grid. <br> sensor_response_pol_grid: Set to 1:stokes_dim. <br> sensor_response_dlos_grid : Equal to mblock_dlos_grid.

Author
Mattias Ekstrom
Patrick Eriksson
Parameters
[out]sensor_responseWS Output
[out]sensor_response_fWS Output
[out]sensor_response_polWS Output
[out]sensor_response_dlosWS Output
[out]sensor_response_f_gridWS Output
[out]sensor_response_pol_gridWS Output
[out]sensor_response_dlos_gridWS Output
[in]f_gridWS Input
[in]mblock_dlos_gridWS Input
[in]antenna_dimWS Input
[in]atmosphere_dimWS Input
[in]stokes_dimWS Input
[in]sensor_normWS Input

Definition at line 1761 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), ARTS::Var::atmosphere_dim(), chk_if_bool(), chk_if_in_range(), CREATE_OUT2, CREATE_OUT3, ARTS::Var::f_grid(), id_mat(), ARTS::Var::mblock_dlos_grid(), sensor_aux_vectors(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), and ARTS::Var::stokes_dim().

Referenced by sensor_responseGenericAMSU(), sensor_responseInit_g(), sensor_responseMetMM(), sensor_responseSimpleAMSU(), sensorOff(), and ySimpleSpectrometer().

◆ sensor_responseMetMM()

void sensor_responseMetMM ( Index &  antenna_dim,
Matrix &  mblock_dlos_grid,
Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
ArrayOfIndex &  sensor_response_pol_grid,
Matrix &  sensor_response_dlos_grid,
Index &  sensor_norm,
const Index &  atmosphere_dim,
const Index &  stokes_dim,
const Vector &  f_grid,
const Vector &  f_backend,
const ArrayOfArrayOfIndex &  channel2fgrid_indexes,
const ArrayOfVector &  channel2fgrid_weights,
const String &  iy_unit,
const Matrix &  antenna_dlos,
const ArrayOfString &  met_mm_polarisation,
const Vector &  met_mm_antenna,
const Index &  use_antenna,
const Index &  mirror_dza,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseMetMM.

Sensor setup for meteorological millimeter instruments.

This method is handy if you are simulating a passband-type instrument, consisting of a few discrete channels.

For flexibility, the Met-MM system is seperated in two calculation steps. To fully use the system, create f_grid (and some associated variables) by f_gridMetMM before calling this method. However, it is possible to use this method with any f_grid, as long as matching f_backend*, channel2fgrid_indexes and channel2fgrid_weights are provided.

Each scan sequence is treated as a measurement block. sensor_pos is set in the standard way. The number of rows in sensor_pos determines the number of scan sequences that will be simulated. On the other hand, sensor_los* is handled in a special way. All zenith angles must be set to 180 deg. For 3D, the given azimuth angles are taken as the direction of scanning, where the azimuth angle is defined with respect to North in standard manner. For example, if the scanning happens to move from SW to NE, the azimuth angle should be set to 45 deg. The angles of the scanning sequence are taken from antenna_dlos. This WSV is here only allowed to have a single column, holding relative zenith angles. For 3D, the azimuth angles in antenna_dlos are hard-coded to zero. As zenith angles in sensor_los are locked to 180 deg, antenna_dlos effectively holds the nadir angles. These angles can be both positive or negative, where the recommended choice is to operate with negative to end up with final zenith angles between 0 and 180 deg.

The method does not support 2D atmospheres (across-track scanning is inconsistent with 2D). For simpler switching between 1D and 3D, the argument mirror_dza is at hand. It can only be used for 3D. If set to true, the zenith angles in antenna_dlos are mapped to also cover the other side of the swath and the simulations will cover both sides of the swath.

Author
Oliver Lemke
Patrick Eriksson
Parameters
[out]antenna_dimWS Output
[out]mblock_dlos_gridWS Output
[out]sensor_responseWS Output
[out]sensor_response_fWS Output
[out]sensor_response_polWS Output
[out]sensor_response_dlosWS Output
[out]sensor_response_f_gridWS Output
[out]sensor_response_pol_gridWS Output
[out]sensor_response_dlos_gridWS Output
[out]sensor_normWS Output
[in]atmosphere_dimWS Input
[in]stokes_dimWS Input
[in]f_gridWS Input
[in]f_backendWS Input
[in]channel2fgrid_indexesWS Input
[in]channel2fgrid_weightsWS Input
[in]iy_unitWS Input
[in]antenna_dlosWS Input
[in]met_mm_polarisationWS Input
[in]met_mm_antennaWS Input
[in]use_antennaGeneric Input (Default: "0")
[in]mirror_dzaGeneric Input (Default: "0")

Definition at line 2009 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), ARTS::Var::antenna_dlos(), ARTS::Var::atmosphere_dim(), ARTS::Var::channel2fgrid_indexes(), ARTS::Var::channel2fgrid_weights(), chk_if_bool(), ARTS::Var::f_backend(), ARTS::Var::f_grid(), ARTS::Var::iy_unit(), joker, met_mm_polarisation_hmatrix(), mult(), Sparse::ncols(), Array< base >::nelem(), ConstVectorView::nelem(), ConstMatrixView::nrows(), Sparse::nrows(), Matrix::resize(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), sensor_responseInit(), sensor_responseMixerBackendPrecalcWeights(), ARTS::Var::stokes_dim(), and ARTS::Var::verbosity().

Referenced by sensor_responseMetMM_g().

◆ sensor_responseMixer()

void sensor_responseMixer ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Numeric &  lo,
const GriddedField1 &  sideband_response,
const Index &  sensor_norm,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseMixer.

Includes response of the mixer of a heterodyne system.

The function returns the sensor response matrix after the mixer characteristics have been included. Frequency variables are converted from radio frequency (RF) to intermediate frequency (IF). The returned frequency grid covers the range [0,max_if], where max_if is the highest IF covered by the sideband response grid.

See lo and sideband_response for details on how to specify the mixer response

Author
Mattias Ekstrom
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]loWS Input
[in]sideband_responseWS Input
[in]sensor_normWS Input

Definition at line 1872 of file m_sensor.cc.

References CREATE_OUT3, GFIELD1_F_GRID, is_increasing(), last(), ARTS::Var::lo(), mixer_matrix(), mult(), Sparse::ncols(), ConstVectorView::nelem(), Sparse::nrows(), sensor_aux_vectors(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), and ARTS::Var::sideband_response().

Referenced by sensor_responseMixer_g(), and sensor_responseMultiMixerBackend().

◆ sensor_responseMixerBackendPrecalcWeights()

void sensor_responseMixerBackendPrecalcWeights ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Vector &  f_backend,
const ArrayOfArrayOfIndex &  channel2fgrid_indexes,
const ArrayOfVector &  channel2fgrid_weights,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseMixerBackendPrecalcWeights.

Includes pre-calculated response covering mixer and backend.

This method acts similar to sensor_responseBackend, but uses pre-calculated weights. These weights can also include the effect of mixer and sideband filtering.

As usual, f_backend gives the frequency of the channels. This WSM has no direct influence on the result, but at least representative values must be set.

The frequency response is defined using channel2fgrid_indexes and channel2fgrid_weights*.

Both channel2fgrid_indexes and channel2fgrid_weights are assumed to be common for all viewing directions.

Author
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]f_backendWS Input
[in]channel2fgrid_indexesWS Input
[in]channel2fgrid_weightsWS Input

Definition at line 2199 of file m_sensor.cc.

References ARTS::Var::channel2fgrid_indexes(), ARTS::Var::channel2fgrid_weights(), CREATE_OUT3, ARTS::Var::f_backend(), Sparse::insert_row(), max, min, mult(), Sparse::ncols(), Absorption::nelem(), Sparse::nrows(), sensor_aux_vectors(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), and ARTS::Var::sensor_response_pol_grid().

Referenced by sensor_responseMetMM(), and sensor_responseMixerBackendPrecalcWeights_g().

◆ sensor_responseMultiMixerBackend()

void sensor_responseMultiMixerBackend ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Vector &  lo_multi,
const ArrayOfGriddedField1 &  sideband_response_multi,
const ArrayOfString &  sideband_mode_multi,
const ArrayOfVector &  f_backend_multi,
const ArrayOfArrayOfGriddedField1 &  backend_channel_response_multi,
const Index &  sensor_norm,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseMultiMixerBackend.

Handles mixer and backend parts for an instrument having multiple mixer chains.

The WSMs sensor_responseMixer, sensor_responseIF2RF and sensor_responseBackend* are called for each mixer chain, and a complete sensor_response is assembled. The instrument responses are described by lo_multi, sideband_response_multi, sideband_mode_multi*, f_backend_multi and backend_channel_response_multi*. All these WSVs must have same vector or array length. As sensor_responseIF2RF is called, f_backend_multi* must hold RF (not IF) and output frequencies will be in absolute frequency (RF).

Author
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]lo_multiWS Input
[in]sideband_response_multiWS Input
[in]sideband_mode_multiWS Input
[in]f_backend_multiWS Input
[in]backend_channel_response_multiWS Input
[in]sensor_normWS Input

Definition at line 2339 of file m_sensor.cc.

References ARTS::Var::backend_channel_response_multi(), ARTS::Var::f_backend_multi(), ARTS::Var::lo_multi(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), sensor_responseBackend(), sensor_responseIF2RF(), sensor_responseMixer(), ARTS::Var::sideband_mode_multi(), ARTS::Var::sideband_response_multi(), and ARTS::Var::verbosity().

Referenced by sensor_responseMultiMixerBackend_g(), and sensor_responseSimpleAMSU().

◆ sensor_responsePolarisation()

void sensor_responsePolarisation ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
ArrayOfIndex &  sensor_response_pol_grid,
const Vector &  sensor_response_f_grid,
const Matrix &  sensor_response_dlos_grid,
const Index &  stokes_dim,
const String &  iy_unit,
const ArrayOfIndex &  instrument_pol,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responsePolarisation.

Extraction of non-default polarisation components.

The default is to output the Stokes elements I, Q, U and V (up to stokes_dim*). This method allows to change the "polarisation" of the output. Polarisation components to be extracted are selected by instrument_pol*. This method can be applied at any step of the sensor matrix set-up.

The method can only be applied on data for I, Q, U and V. The value of stokes_dim must be sufficiently large for the selected components. For example, I+45 requires that stokes_dim is at least 3.

See instrument_pol for coding of polarisation states.

Note that the state of iy_unit is considered. This WSV must give the actual unit of the data. This as, the extraction of components is slightly different if data are radiances or brightness temperatures. In practise this means that iy_unit (as to be applied inside iy_main_agenda) must be set before calling this method.

Author
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_pol_gridWS Input/Output
[in]sensor_response_f_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]stokes_dimWS Input
[in]iy_unitWS Input
[in]instrument_polWS Input

Definition at line 2514 of file m_sensor.cc.

References Sparse::insert_row(), ARTS::Var::instrument_pol(), ARTS::Var::iy_unit(), mult(), Sparse::ncols(), Sparse::nrows(), sensor_aux_vectors(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), stokes2pol(), ARTS::Var::stokes_dim(), and w().

Referenced by sensor_responsePolarisation_g().

◆ sensor_responseSimpleAMSU()

void sensor_responseSimpleAMSU ( Vector &  f_grid,
Index &  antenna_dim,
Matrix &  mblock_dlos_grid,
Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
ArrayOfIndex &  sensor_response_pol_grid,
Matrix &  sensor_response_dlos_grid,
Index &  sensor_norm,
const Index &  atmosphere_dim,
const Index &  stokes_dim,
const Matrix &  sensor_description_amsu,
const Numeric &  spacing,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseSimpleAMSU.

Simplified sensor setup for an AMSU-type instrument.

This method allows quick and simple definition of AMSU-type sensors. Assumptions:

  1. Pencil beam antenna.
  2. Double sideband receivers.
  3. Sideband mode "upper"
  4. The channel response is rectangular.

Under these assumptions the only inputs needed are the LO positions, the offsets from the LO, and the IF bandwidths. They are provieded in sensor_description_amsu.

Author
Stefan Buehler
Parameters
[out]f_gridWS Output
[out]antenna_dimWS Output
[out]mblock_dlos_gridWS Output
[out]sensor_responseWS Output
[out]sensor_response_fWS Output
[out]sensor_response_polWS Output
[out]sensor_response_dlosWS Output
[out]sensor_response_f_gridWS Output
[out]sensor_response_pol_gridWS Output
[out]sensor_response_dlos_gridWS Output
[out]sensor_normWS Output
[in]atmosphere_dimWS Input
[in]stokes_dimWS Input
[in]sensor_description_amsuWS Input
[in]spacingGeneric Input (Default: ".1e9")

Definition at line 3101 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), AntennaOff(), ARTS::Var::atmosphere_dim(), ARTS::Var::backend_channel_response_multi(), GriddedField1::data, ARTS::Var::f_backend_multi(), ARTS::Var::f_grid(), f_gridFromSensorAMSU(), joker, ARTS::Var::lo_multi(), ARTS::Var::mblock_dlos_grid(), GriddedField1::resize(), Vector::resize(), ARTS::Var::sensor_description_amsu(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), sensor_responseInit(), sensor_responseMultiMixerBackend(), GriddedField::set_grid(), GriddedField::set_grid_name(), GriddedField::set_name(), ARTS::Var::sideband_mode_multi(), ARTS::Var::sideband_response_multi(), ARTS::Var::stokes_dim(), and ARTS::Var::verbosity().

Referenced by sensor_responseSimpleAMSU_g().

◆ sensor_responseStokesRotation()

void sensor_responseStokesRotation ( Sparse &  sensor_response,
const Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Index &  stokes_dim,
const Vector &  stokes_rotation,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseStokesRotation.

Includes a rotation of the Stokes H and V directions.

The method applies the rotations implied by stokes_rotation. See the description of that WSV for details.

This method does not change the size of sensor_response, and the auxiliary variables (sensor_response_f etc.) are not changed.

To apply the method, stokes_dim must be >= 3. The complete effect of the rotation can not be determibed with lower stokes_dim.

Author
Patrick Eriksson
Parameters
[in,out]sensor_responseWS Input/Output
[in]sensor_response_f_gridWS Input
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]stokes_dimWS Input
[in]stokes_rotationWS Input

Definition at line 2639 of file m_sensor.cc.

References chk_if_in_range(), Sparse::insert_row(), mueller_rotation(), mult(), Sparse::ncols(), Sparse::nrows(), Sparse::ro(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol_grid(), ARTS::Var::stokes_dim(), and ARTS::Var::stokes_rotation().

Referenced by sensor_responseStokesRotation_g().

◆ sensor_responseWMRF()

void sensor_responseWMRF ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
const ArrayOfIndex &  sensor_response_pol_grid,
const Matrix &  sensor_response_dlos_grid,
const Sparse &  wmrf_weights,
const Vector &  f_backend,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensor_responseWMRF.

Adds WMRF weights to sensor response.

This method adds a spectrometer response that has been calculated with the weighted mean of representative frequencies (WMRF) method. It consists of a set of selected frequencies, and associated weights.

Author
Stefan Buehler, based on Patrick Erikssons sensor_responseBackend
Parameters
[in,out]sensor_responseWS Input/Output
[in,out]sensor_response_fWS Input/Output
[in,out]sensor_response_polWS Input/Output
[in,out]sensor_response_dlosWS Input/Output
[in,out]sensor_response_f_gridWS Input/Output
[in]sensor_response_pol_gridWS Input
[in]sensor_response_dlos_gridWS Input
[in]wmrf_weightsWS Input
[in]f_backendWS Input

Definition at line 3352 of file m_sensor.cc.

References CREATE_OUT3, ARTS::Var::f_backend(), mult(), Sparse::ncols(), sensor_aux_vectors(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), and ARTS::Var::wmrf_weights().

Referenced by sensor_responseWMRF_g().

◆ sensorOff()

void sensorOff ( Sparse &  sensor_response,
Vector &  sensor_response_f,
ArrayOfIndex &  sensor_response_pol,
Matrix &  sensor_response_dlos,
Vector &  sensor_response_f_grid,
ArrayOfIndex &  sensor_response_pol_grid,
Matrix &  sensor_response_dlos_grid,
Matrix &  mblock_dlos_grid,
const Index &  stokes_dim,
const Vector &  f_grid,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: sensorOff.

Sets sensor WSVs to obtain monochromatic pencil beam values.

The variables are set as follows: <br> mblock_dlos_grid : One row with zero(s). <br> sensor_response* : As returned by sensor_responseInit.

Author
Patrick Eriksson
Parameters
[out]sensor_responseWS Output
[out]sensor_response_fWS Output
[out]sensor_response_polWS Output
[out]sensor_response_dlosWS Output
[out]sensor_response_f_gridWS Output
[out]sensor_response_pol_gridWS Output
[out]sensor_response_dlos_gridWS Output
[out]mblock_dlos_gridWS Output
[in]stokes_dimWS Input
[in]f_gridWS Input

Definition at line 1833 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), AntennaOff(), ARTS::Var::atmosphere_dim(), ARTS::Var::f_grid(), ARTS::Var::mblock_dlos_grid(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), sensor_responseInit(), ARTS::Var::stokes_dim(), and ARTS::Var::verbosity().

Referenced by sensorOff_g().

◆ WMRFSelectChannels()

void WMRFSelectChannels ( Vector &  f_grid,
Sparse &  wmrf_weights,
Vector &  f_backend,
const ArrayOfIndex &  wmrf_channels,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: WMRFSelectChannels.

Select some channels for WMRF calculation.

The HIRS fast setup consists of a precalculated frequency grid covering all HIRS channels, and associated weights for each channel, stored in a weight matrix. (A sensor_response matrix.)

If not all channels are requested for simulation, then this method can be used to remove the unwanted channels. It changes a number of variables in consistent fashion:

  • Unwanted channels are removed from f_backend.
  • Unwanted channels are removed from wmrf_weights.
  • Unnecessary frequencies are removed from f_grid.

  • Unnecessary frequencies are removed from wmrf_weights.

    Author
    Stefan Buehler
    Parameters
    [in,out]f_gridWS Input/Output
    [in,out]wmrf_weightsWS Input/Output
    [in,out]f_backendWS Input/Output
    [in]wmrf_channelsWS Input

Definition at line 3236 of file m_sensor.cc.

References chk_if_increasing(), CREATE_OUT2, CREATE_OUT3, ARTS::Var::f_backend(), ARTS::Var::f_grid(), max, min, Sparse::ncols(), Array< base >::nelem(), Sparse::nrows(), Select(), transpose(), ARTS::Var::verbosity(), ARTS::Var::wmrf_channels(), and ARTS::Var::wmrf_weights().

Referenced by WMRFSelectChannels_g().

◆ yApplySensorPol()

void yApplySensorPol ( Vector &  y,
Vector &  y_f,
ArrayOfIndex &  y_pol,
Matrix &  y_pos,
Matrix &  y_los,
ArrayOfVector &  y_aux,
Matrix &  y_geo,
Matrix &  jacobian,
const Index &  stokes_dim,
const Index &  jacobian_do,
const Matrix &  sensor_pos,
const Matrix &  sensor_pol,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: yApplySensorPol.

Extraction of arbitrary linear polarisation.

This method shall be called after yCalc and then applies sensor_pol on the outout of yCalc. See sensor_pol for definition of the polarisation responses. THe sensor_response give to yCalc can not contain any polarisation response, it must maintain original Stokes elelemnts. The value of stokes_dim muist be >= 3.

The values in sensor_pol are applied on y, and jacobian if relevant. y_pol* is set following the values in sensor_pol but is rounded to an integer value. Remaining data associated with y (e.g. y_pos) are set to the value matching the first Stokes element.

Author
Patrick Eriksson
Parameters
[in,out]yWS Input/Output
[in,out]y_fWS Input/Output
[in,out]y_polWS Input/Output
[in,out]y_posWS Input/Output
[in,out]y_losWS Input/Output
[in,out]y_auxWS Input/Output
[in,out]y_geoWS Input/Output
[in,out]jacobianWS Input/Output
[in]stokes_dimWS Input
[in]jacobian_doWS Input
[in]sensor_posWS Input
[in]sensor_polWS Input

Definition at line 3531 of file m_sensor.cc.

References ARTS::Var::jacobian(), ARTS::Var::jacobian_do(), ConstMatrixView::ncols(), ARTS::Var::sensor_pol(), ARTS::Var::sensor_pos(), ARTS::Var::stokes_dim(), ARTS::Var::y(), ARTS::Var::y_aux(), ARTS::Var::y_f(), ARTS::Var::y_geo(), ARTS::Var::y_los(), ARTS::Var::y_pol(), and ARTS::Var::y_pos().

Referenced by yApplySensorPol_g().

◆ ySimpleSpectrometer()

void ySimpleSpectrometer ( Vector &  y,
Vector &  y_f,
const Matrix &  iy,
const Index &  stokes_dim,
const Vector &  f_grid,
const Numeric &  df,
const Verbosity &  verbosity 
)

WORKSPACE METHOD: ySimpleSpectrometer.

Converts iy to y assuming a fixed frequency resolution.

This is a short-cut, avoiding yCalc, that can be used to convert monochromatic pencil beam data to spectra with a fixed resolution.

The method mimics a spectrometer with rectangular response functions, all having the same width (df). The position of the first spectrometer channel is set to f_grid[0]+df/2. The centre frequency of channels are returned as y_f.

Auxiliary variables and *jacobian*s are not handled.

Author
Patrick Eriksson
Parameters
[out]yWS Output
[out]y_fWS Output
[in]iyWS Input
[in]stokes_dimWS Input
[in]f_gridWS Input
[in]dfGeneric Input

Definition at line 3453 of file m_sensor.cc.

References ARTS::Var::antenna_dim(), AntennaOff(), ARTS::Var::atmosphere_dim(), backend_channel_responseFlat(), ARTS::Var::f_backend(), ARTS::Var::f_grid(), ARTS::Var::iy(), ARTS::Var::iyb(), joker, last(), linspace(), ARTS::Var::mblock_dlos_grid(), mult(), ARTS::Var::sensor_norm(), ARTS::Var::sensor_response(), ARTS::Var::sensor_response_dlos(), ARTS::Var::sensor_response_dlos_grid(), ARTS::Var::sensor_response_f(), ARTS::Var::sensor_response_f_grid(), ARTS::Var::sensor_response_pol(), ARTS::Var::sensor_response_pol_grid(), sensor_responseBackend(), sensor_responseInit(), ARTS::Var::stokes_dim(), ARTS::Var::verbosity(), ARTS::Var::y(), and ARTS::Var::y_f().

Referenced by ySimpleSpectrometer_g().

Variable Documentation

◆ DEG2RAD

const Numeric DEG2RAD
extern

◆ GFIELD1_F_GRID

const Index GFIELD1_F_GRID
extern

Referenced by sensor_responseBackend(), and sensor_responseMixer().

◆ GFIELD4_AA_GRID

const Index GFIELD4_AA_GRID
extern

Referenced by sensor_responseAntenna().

◆ GFIELD4_F_GRID

const Index GFIELD4_F_GRID
extern

Referenced by sensor_responseAntenna().

◆ GFIELD4_FIELD_NAMES

const Index GFIELD4_FIELD_NAMES
extern

Referenced by sensor_responseAntenna().

◆ GFIELD4_ZA_GRID

const Index GFIELD4_ZA_GRID
extern

Referenced by AntennaConstantGaussian1D(), and sensor_responseAntenna().

◆ NAT_LOG_2

const Numeric NAT_LOG_2
extern

Referenced by antenna_responseGaussian(), and antenna_responseVaryingGaussian().

◆ PI

const Numeric PI
extern

Referenced by antenna_responseGaussian(), and antenna_responseVaryingGaussian().

◆ RAD2DEG

const Numeric RAD2DEG
extern

Referenced by antenna_responseVaryingGaussian().

◆ SPEED_OF_LIGHT

const Numeric SPEED_OF_LIGHT
extern

Referenced by antenna_responseVaryingGaussian().