SpectralFits

java.lang.Object
- astro.SpectralFits

```
public abstract class SpectralFits
extends Object
```
This class deals with FITS file received as output from the SES spectrograph. This is a three dimensional fits file, where the x-coordinate (first axis) is along the echell order, 2043 pixel, the second axis is the order number, 82, and the third one indicates the image. In index zero, the reduced spectrum is found, in index 1 the raw extracted spectrum and in index 2 a sigma map of the pixel. The data typoe is float.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class SpectralFits.Slice
Class for ordering beam.index number to wavelength.

Nested Classes
Modifier and Type	Class and Description
`private static class`	`SpectralFits.Slice` Class for ordering beam.index number to wavelength.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`LINEAR` Multiple beam in one aperture: interpolate linear to main beam.
`private double`	`ltm` Convert image pixel to physical pixels used for further processing.
`private static String`	`LTM` Header keyword for apertures.
`private double`	`ltv` Convert image pixel to physical pixels used for further processing.
`private static String`	`LTV` Header keyword for apertures.
`private int`	`multimethod` The method of interpolation on multiple beams per apertue.
`private int`	`npix`
`private int`	`nspec`
`private float[][]`	`raw` After construction, we have these arrays available.
`private float[][]`	`reduced` After construction, we have these arrays available.
`private float[][]`	`sigma` After construction, we have these arrays available.
`static int`	`SORT` Multiple beam in one aperture: sort and keep all.
`private Function[]`	`wavelength` The wavelength solution for the orders, parsed from the header.

Constructor Summary

Constructors
Modifier Constructor and Description

protected SpectralFits(File io)
Constructs a SesFits from a file.

Constructors
Modifier	Constructor and Description
`protected`	`SpectralFits(File io)` Constructs a SesFits from a file.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`getCentralOrderFromAngstrom(double lambda)` Return the orders where the specified wavelength fits best or -1 if no such order is available.
`int`	`getHighestOrder()` Returns the array size, -1 if undefined.
`protected int[]`	`getIndexOfOrder(int order)` Default implementation says aperture number equals order number.
`int`	`getLowestOrder()` Default implementation return 0 for lowest order number, -1 if undefined.
`int`	`getMultiMethod()` In image slicers, we might have multiple beams per aperture.
`protected int`	`getOrderOfIndex(int index)` Default implementation says aperture number equals order number.
`int[]`	`getOrdersFromAngstrom(double lambda)` Return all orders where the specified wavelength can be found.
`Vector3D[]`	`getRawOrder(int order)` Returns the specified order as an array of wavelength vs.
`Vector3D[]`	`getReducedOrder(int order)` Returns the specified order as an array of wavelength vs.
`private float[]`	`interpolate(float[] beam, Function lambda, double[] wavgrid)`
`private Vector3D[]`	`interpolatedMultipleBeam(float[][] v2d, int[] nn)` An order (aperture) consists of multiple beams.
`protected Vector3D[]`	`multipleBeam(float[][] v2d, int[] nn)` An order (aperture) consists of multiple beams.
`protected abstract Function[]`	`parseWavelengthSolution(MHeader h)` Parses the wavelength soultion from the header.
`void`	`setMultiMethod(int multimethod)` Sets the method of choice on averaging multiple beams per aperture, a situation that may be encountered in image slicers.
`protected Vector3D[]`	`singleBeam(float[][] v2d, int n)` Single beam.
`private Vector3D[]`	`sortedMultipleBeam(float[][] v2d, int[] nn)` An order (aperture) consists of multiple beams.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - SORT
```
public static final int SORT
```
    Multiple beam in one aperture: sort and keep all.
    
    See Also:
    
    Constant Field Values
  - LINEAR
```
public static final int LINEAR
```
    Multiple beam in one aperture: interpolate linear to main beam.
    
    See Also:
    
    Constant Field Values
  - LTV
```
private static final String LTV
```
    Header keyword for apertures.
    
    See Also:
    
    Constant Field Values
  - LTM
```
private static final String LTM
```
    Header keyword for apertures.
    
    See Also:
    
    Constant Field Values
  - ltv
```
private double ltv
```
    Convert image pixel to physical pixels used for further processing.
  - ltm
```
private double ltm
```
    Convert image pixel to physical pixels used for further processing.
  - reduced
```
private float[][] reduced
```
    After construction, we have these arrays available.
  - raw
```
private float[][] raw
```
    After construction, we have these arrays available.
  - sigma
```
private float[][] sigma
```
    After construction, we have these arrays available.
  - wavelength
```
private Function[] wavelength
```
    The wavelength solution for the orders, parsed from the header.
  - npix
```
private int npix
```
  - nspec
```
private int nspec
```
  - multimethod
```
private int multimethod
```
    The method of interpolation on multiple beams per apertue.
- Constructor Detail
  - SpectralFits
```
protected SpectralFits(File io)
                throws BasicFitsException,
                       HeaderParsingException
```
    Constructs a SesFits from a file. Note this throws FitsException if file was not found or data could not be read due to I/O. The fits is expected to be composed of a three-dimensional float array
    
    Throws:
    
    HeaderParsingException
    
    BasicFitsException
- Method Detail
  - getIndexOfOrder
```
protected int[] getIndexOfOrder(int order)
```
    Default implementation says aperture number equals order number.
  - getOrderOfIndex
```
protected int getOrderOfIndex(int index)
```
    Default implementation says aperture number equals order number.
  - getLowestOrder
```
public int getLowestOrder()
```
    Default implementation return 0 for lowest order number, -1 if undefined.
  - getHighestOrder
```
public int getHighestOrder()
```
    Returns the array size, -1 if undefined.
  - getCentralOrderFromAngstrom
```
public int getCentralOrderFromAngstrom(double lambda)
```
    Return the orders where the specified wavelength fits best or -1 if no such order is available.
    
    Parameters:
    
    lambda - The wavelength in Angstrom.
    
    Returns:
    
    The best order number
  - getOrdersFromAngstrom
```
public int[] getOrdersFromAngstrom(double lambda)
```
    Return all orders where the specified wavelength can be found.
    
    Parameters:
    
    lambda - The wavelength in Angstrom.
    
    Returns:
    
    Either zero length, a single-element int or a bi-element int for overlapping regions
  - getReducedOrder
```
public Vector3D[] getReducedOrder(int order)
```
    Returns the specified order as an array of wavelength vs. intensity plus error. Note that the image pixel number in dispersion direction (1...NAXIS1) is first converted to physical coordinates using the LTV1 and LTM1_1 keywords. This physical coordinate (in most cases identical to the image pixel number) is then used in the wavelength solution to get to lambda, normally in Angstrom.
    
    Throws:
    
    FitsException - If the requested order cannot be reached
  - singleBeam
```
protected Vector3D[] singleBeam(float[][] v2d,
                                int n)
```
    Single beam. There is only one spectrum (beam) per aperture (order).
    
    Parameters:
    
    v2d - Data array, index number, intensity
    
    n - index
    
    Returns:
  - getMultiMethod
```
public int getMultiMethod()
```
    In image slicers, we might have multiple beams per aperture. This flag is linked to the known methods SORT and LINEAR.
    
    Returns:
    
    the index of the method on treating multiple beams per aperture.
  - setMultiMethod
```
public void setMultiMethod(int multimethod)
```
    Sets the method of choice on averaging multiple beams per aperture, a situation that may be encountered in image slicers. Only the known methods SORT and LINEAR.
    
    Parameters:
    
    multimethod - the multimethod to set
  - multipleBeam
```
protected Vector3D[] multipleBeam(float[][] v2d,
                                  int[] nn)
```
    An order (aperture) consists of multiple beams. The basic version simple calls sort on the big array consisting of all beams, ordered for lambda.
    
    Parameters:
    
    v2d - Data array, index number, intensity
    
    nn - The indices of all beams
    
    Returns:
  - sortedMultipleBeam
```
private Vector3D[] sortedMultipleBeam(float[][] v2d,
                                      int[] nn)
```
    An order (aperture) consists of multiple beams. This version simple returns a big array consisting of all beams, ordered for lambda.
    
    Parameters:
    
    v2d - Data array, index number, intensity
    
    nn - The indices of all beams
    
    Returns:
  - interpolatedMultipleBeam
```
private Vector3D[] interpolatedMultipleBeam(float[][] v2d,
                                            int[] nn)
```
    An order (aperture) consists of multiple beams. This version simple returns a big array consisting of all beams, ordered for lambda.
    
    Parameters:
    
    v2d - Data array, index number, intensity
    
    nn - The indices of all beams
    
    Returns:
  - interpolate
```
private float[] interpolate(float[] beam,
                            Function lambda,
                            double[] wavgrid)
```
    Parameters:
    
    beam - The pixel-to-pixel intensities
    
    lambda - The wavelength solution converting indices to angstroem
    
    wavgrid - The intensities should be interpolated at these wavelength.
    
    Returns:
    
    An array of dimension wavgrid, NaN at non-interpolational points.
  - getRawOrder
```
public Vector3D[] getRawOrder(int order)
```
    Returns the specified order as an array of wavelength vs. intensity plus error. Note that the image pixel number in dispersion direction (1...NAXIS1) is first converted to physical coordinates using the LTV1 and LTM1_1 keywords. This physical coordinate (in most cases identical to the image pixel number) is then used in the wavelength solution to get to lambda, normally in Angstrom.
  - parseWavelengthSolution
```
protected abstract Function[] parseWavelengthSolution(MHeader h)
                                               throws HeaderParsingException
```
    Parses the wavelength soultion from the header.
    
    Throws:
    
    HeaderParsingException

Class SpectralFits

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SORT

LINEAR

LTV

LTM

ltv

ltm

reduced

raw

sigma

wavelength

npix

nspec

multimethod

Constructor Detail

SpectralFits

Method Detail

getIndexOfOrder

getOrderOfIndex

getLowestOrder

getHighestOrder

getCentralOrderFromAngstrom

getOrdersFromAngstrom

getReducedOrder

singleBeam

getMultiMethod

setMultiMethod

multipleBeam

sortedMultipleBeam

interpolatedMultipleBeam

interpolate

getRawOrder

parseWavelengthSolution