Arroyo Namespace Reference

Classes
class	Arroyo::AO_sim_base
class	Arroyo::aperture
class	Arroyo::circular_aperture
class	Arroyo::annular_aperture
class	Arroyo::rectangular_aperture
class	Arroyo::spidered_annular_aperture
class	Arroyo::hexagonal_aperture
class	Arroyo::tiled_hexagonal_aperture
class	Arroyo::a_plusplus_reconstructor
class	Arroyo::arcadia_mcao_reconstructor
class	Arroyo::arroyo_least_squares_reconstructor< T >
class	Arroyo::colormap
class	Arroyo::sao_colormap
class	Arroyo::conic_mirror_base
class	Arroyo::conic_mirror< aperture_type >
class	Arroyo::conic_section
class	Arroyo::phase_covariance< precision, aperture_type >
class	Arroyo::phase_covariance< precision, circular_aperture >
class	Arroyo::tilt_covariance< precision, aperture_type >
class	Arroyo::tilt_covariance< precision, circular_aperture >
class	Arroyo::deformable_mirror_base
class	Arroyo::ideal_deformable_mirror< aperture_type >
class	Arroyo::DereferencedEqual< T >
class	Arroyo::DereferencedGreater< T >
class	Arroyo::DereferencedLess< T >
class	Arroyo::diffractive_wavefront< T >
class	Arroyo::Ellerbroek_Cerro_Pachon_model
class	Arroyo::Ellerbroek_Mauna_Kea_model
class	Arroyo::emitter
class	Arroyo::plane_wave_emitter
class	Arroyo::spherical_wave_emitter
class	Arroyo::fft_manager< T >
class	Arroyo::rfft_manager< T >
class	Arroyo::fits_keyval_entry
class	Arroyo::fits_keyval_set
class	Arroyo::fits_factory< abstract_product >
class	Arroyo::fits_scale_factor
class	Arroyo::fits_header_data< T >
class	Arroyo::Gemini_GLAO_study_model
class	Arroyo::Hufnagel_Valley_model
class	Arroyo::iofits
class	Arroyo::lenslet_array_base
class	Arroyo::square_lenslet_array
class	Arroyo::modal_expansion
class	Arroyo::NGAO_system_design_model
class	Arroyo::observation_base
class	Arroyo::basic_observation< precision >
class	Arroyo::basic_otf< precision >
class	Arroyo::optic
class	Arroyo::plane_optic
class	Arroyo::one_to_one_optic
class	Arroyo::one_to_many_optic
class	Arroyo::PALAO_reconstructor
class	Arroyo::Palomar_DIMM_MASS_model
class	Arroyo::pixel_amp_array< precision >
class	Arroyo::pixel_array< T >
class	Arroyo::pixel_phase_array< T >
class	Arroyo::inner_scale
class	Arroyo::null_inner_scale
class	Arroyo::exponential_inner_scale
class	Arroyo::frehlich_inner_scale
class	Arroyo::power_law
class	Arroyo::von_karman_power_law
class	Arroyo::greenwood_power_law
class	Arroyo::power_spectrum
class	Arroyo::isotropic_power_law_spectrum< power_law_type, inner_scale_type >
class	Arroyo::profile_timeseries
class	Arroyo::propagation_plan
class	Arroyo::geometric_propagation_plan
class	Arroyo::near_field_fresnel_propagation_plan
class	Arroyo::proportional_integral_controller< input, output, proportional_gain, integral_gain >
class	Arroyo::refractive_atmospheric_model
class	Arroyo::refractive_atmospheric_layer< T >
class	Arroyo::region_base
class	Arroyo::rectangular_region
class	Arroyo::Shack_Hartmann_centroids
class	Arroyo::alloc_size
class	Arroyo::SLCSAT_day_model
class	Arroyo::SLCSAT_night_model
class	Arroyo::structure_function
class	Arroyo::subharmonic_method
class	Arroyo::null_subharmonic_method
class	Arroyo::generalized_subharmonic_method
class	Arroyo::Lane_subharmonic_method
class	Arroyo::Johansson_Gavel_subharmonic_method
class	Arroyo::quad_pixel_subharmonic_method
class	Arroyo::three_frame
class	Arroyo::three_point
class	Arroyo::three_transformation
class	Arroyo::three_orthonormal_transformation
class	Arroyo::three_translation
class	Arroyo::three_rotation
class	Arroyo::three_reflection
class	Arroyo::three_scaling
class	Arroyo::three_vector
class	Arroyo::time_val
class	Arroyo::tip_tilt_mirror_base
class	Arroyo::ideal_tip_tilt_mirror< aperture_type >
class	Arroyo::TMT_SRD_v13_Cn2_model
class	Arroyo::pseudo_open_loop_tomographic_reconstructor< precision >
class	Arroyo::wavefront
class	Arroyo::wavefront_header
class	Arroyo::diffractive_wavefront_header< T >
class	Arroyo::wavefront_phase_estimate< precision, aperture_type >
class	Arroyo::wind_model
class	Arroyo::Hardy_wind_model
class	Arroyo::zernike
class	Arroyo::zernike_projected_zonal_reconstructor
Functions
double	chisq_2gf (const vector< float > &data, vector< double > &centers, vector< double > &widths, vector< double > &amps, double &dcconst, int verbose=0)
void	twogauss_fit (const vector< float > &data, vector< double > &centers, vector< double > &widths, vector< double > &amps, double &dcconst)
void	box_mueller (double &r1, double &r2)
template<class U, class V>
void	fit_straight_line (const long &nelems, const double *x, const U *y, const V *wts, double &slope, double &sigsq_slope, double &yintercept, double &sigsq_yintercept, double &chisq)
template<class T>
void	cyclic_permutation (vector< long > axes, long xshift, long yshift, T *data)
template<class T>
void	complex_cyclic_permutation (vector< long > axes, long xshift, long yshift, T *data)
void	write_arcadia_input_file (const Arroyo::refractive_atmospheric_model &ref_atm_model, const Arroyo::circular_aperture &circ_ap, const std::vector< Arroyo::emitter * > &guide_stars, const std::vector< Arroyo::square_lenslet_array > &lenslet_arrays, const std::vector< bool > &tilt_removal_flags, const std::vector< Arroyo::ideal_tip_tilt_mirror< circular_aperture > > &ttms, const std::vector< Arroyo::ideal_deformable_mirror< circular_aperture > > &dms, const std::vector< double > &slaving_thresholds, const char *filename)
std::vector< Arroyo::three_point >	get_line_segment_intersection (const three_point &a1, const three_point &a2, const three_point &b1, const three_point &b2)
Arroyo::three_point	get_ray_ray_intersection (const Arroyo::three_point &o_a, const Arroyo::three_vector &n_a, const Arroyo::three_point &o_b, const Arroyo::three_vector &n_b)
Arroyo::three_point	get_ray_plane_intersection (const Arroyo::three_point &o_a, const Arroyo::three_vector &n_a, const Arroyo::three_point &o_b, const Arroyo::three_vector &n_b)
double	get_area_of_polygon (const std::vector< Arroyo::three_point > &polygon_vertices)
bool	point_within_polygon (const three_point &tp, const vector< three_point > &vertices, bool &point_on_edge, bool &point_on_vertex)
bool	point_within_polygon (const three_point &tp, const vector< three_point > &vtp)
vector< three_point >	get_convex_polygon_intersection (const vector< three_point > &first_polygon_vertices, const vector< three_point > &second_polygon_vertices, int verbose=0)
vector< three_point >	get_line_segment_circle_intersection (const three_point &a1, const three_point &a2, const three_point &circle_origin, const double &radius, vector< bool > &intersection_point_on_boundary, int verbose=0)
vector< three_point >	get_convex_polygon_circle_intersection (const vector< three_point > &polygon_vertices, const three_frame &circle_tf, double radius)
template<class T>
void	convex_polygon_integration (const three_frame &tf, const vector< three_point > &polygon_vertices, T &x_intgrl, T &y_intgrl, int verbose=0)
template<class T>
bool	operator== (const diffractive_wavefront< T > &p1, const diffractive_wavefront< T > &p2)
template<class T>
bool	operator!= (const diffractive_wavefront< T > &p1, const diffractive_wavefront< T > &p2)
template<class T, class U>
diffractive_wavefront< T > &	operator+= (diffractive_wavefront< T > &lhs_wf, const diffractive_wavefront< U > &rhs_wf)
template<class T, class U>
diffractive_wavefront< T > &	operator-= (diffractive_wavefront< T > &lhs_wf, const diffractive_wavefront< U > &rhs_wf)
template<class T, class U>
diffractive_wavefront< T > &	operator *= (diffractive_wavefront< T > &lhs_wf, const diffractive_wavefront< U > &rhs_wf)
template<class T, class U>
diffractive_wavefront< T > &	operator/= (diffractive_wavefront< T > &lhs_wf, const diffractive_wavefront< U > &rhs_wf)
template<class T, class U>
diffractive_wavefront< T >	operator+ (const diffractive_wavefront< T > &wf1, const diffractive_wavefront< U > &wf2)
template<class T, class U>
diffractive_wavefront< T >	operator- (const diffractive_wavefront< T > &wf1, const diffractive_wavefront< U > &wf2)
template<class T, class U>
diffractive_wavefront< T >	operator * (const diffractive_wavefront< T > &wf1, const diffractive_wavefront< U > &wf2)
template<class T, class U>
diffractive_wavefront< T >	operator/ (const diffractive_wavefront< T > &wf1, const diffractive_wavefront< U > &wf2)
template<class T, class U>
diffractive_wavefront< T >	operator+ (const diffractive_wavefront< T > &wf1, std::complex< U > c)
template<class T, class U>
diffractive_wavefront< T >	operator- (const diffractive_wavefront< T > &wf1, std::complex< U > c)
template<class T, class U>
diffractive_wavefront< T >	operator * (const diffractive_wavefront< T > &wf1, std::complex< U > c)
template<class T, class U>
diffractive_wavefront< T >	operator/ (const diffractive_wavefront< T > &wf1, std::complex< U > c)
bool	operator!= (const plane_wave_emitter &pwe1, const plane_wave_emitter &pwe2)
bool	operator!= (const spherical_wave_emitter &swe1, const spherical_wave_emitter &swe2)
template<class U, class V>
bool	operator== (const fits_header_data< U > &fhd1, const fits_header_data< V > &fhd2)
template<class U, class V>
bool	operator!= (const fits_header_data< U > &fhd1, const fits_header_data< V > &fhd2)
void	usage_ref_atm_model ()
refractive_atmospheric_model *	parse_ref_atm_model (int argc, char *const argv[], three_frame tf)
template<class T>
void	singular_value_decomposition (char *jobu, char *jobvt, int &m, int &n, T *a, int &lda, T *s, T *u, int &ldu, T *vt, int &ldvt, T *work, int &lwork, int &info)
template<class precision>
basic_otf< precision >	operator * (const basic_otf< precision > &p1, double &fac)
template<class precision>
basic_otf< precision >	operator * (const basic_otf< precision > &p1, const basic_otf< precision > &p2)
template<class precision>
basic_otf< precision >	operator/ (const basic_otf< precision > &p1, const basic_otf< precision > &p2)
template<class precision>
basic_otf< precision >	operator+ (const basic_otf< precision > &p1, const basic_otf< precision > &p2)
template<class precision>
basic_otf< precision >	operator- (const basic_otf< precision > &p1, const basic_otf< precision > &p2)
template<class precision>
bool	operator== (const pixel_amp_array< precision > &p1, const pixel_amp_array< precision > &p2)
template<class precision>
bool	operator!= (const pixel_amp_array< precision > &p1, const pixel_amp_array< precision > &p2)
template<class precision>
pixel_amp_array< precision >	operator+ (const pixel_amp_array< precision > &p1, const pixel_amp_array< precision > &p2)
template<class precision>
pixel_amp_array< precision >	operator- (const pixel_amp_array< precision > &p1, const pixel_amp_array< precision > &p2)
template<class precision>
pixel_amp_array< precision >	operator * (const pixel_amp_array< precision > &p1, const pixel_amp_array< precision > &p2)
template<class precision>
pixel_amp_array< precision >	operator/ (const pixel_amp_array< precision > &p1, const pixel_amp_array< precision > &p2)
template<class precision>
pixel_amp_array< precision >	operator+ (const pixel_amp_array< precision > &p1, double &fac)
template<class precision>
pixel_amp_array< precision >	operator- (const pixel_amp_array< precision > &p1, double &fac)
template<class precision>
pixel_amp_array< precision >	operator * (const pixel_amp_array< precision > &p1, double &fac)
template<class precision>
pixel_amp_array< precision >	operator/ (const pixel_amp_array< precision > &p1, double &fac)
template<class T>
pixel_array< T >	operator+ (const pixel_array< T > &p1, const pixel_array< T > &p2)
template<class T>
pixel_array< T >	operator- (const pixel_array< T > &p1, const pixel_array< T > &p2)
template<class T>
pixel_array< T >	operator * (const pixel_array< T > &p1, const pixel_array< T > &p2)
template<class T>
pixel_array< T >	operator/ (const pixel_array< T > &p1, const pixel_array< T > &p2)
template<class T>
pixel_array< T >	operator+ (const pixel_array< T > &p1, double &fac)
template<class T>
pixel_array< T >	operator- (const pixel_array< T > &p1, double &fac)
template<class T>
pixel_array< T >	operator * (const pixel_array< T > &p1, double &fac)
template<class T>
pixel_array< T >	operator/ (const pixel_array< T > &p1, double &fac)
template<class T>
bool	operator== (const pixel_array< T > &p1, const pixel_array< T > &p2)
template<class T>
bool	operator!= (const pixel_array< T > &p1, const pixel_array< T > &p2)
template<>
pixel_array< long > &	operator+=< long, float > (pixel_array< long > &lhs, const pixel_array< float > &rhs)
template<>
pixel_array< long > &	operator+=< long, double > (pixel_array< long > &lhs, const pixel_array< double > &rhs)
template<class T, class U>
pixel_array< T > &	operator+= (pixel_array< T > &lhs, const pixel_array< U > &rhs)
template<>
pixel_array< long > &	operator-=< long, float > (pixel_array< long > &lhs, const pixel_array< float > &rhs)
template<>
pixel_array< long > &	operator-=< long, double > (pixel_array< long > &lhs, const pixel_array< double > &rhs)
template<class T, class U>
pixel_array< T > &	operator-= (pixel_array< T > &lhs, const pixel_array< U > &rhs)
template<>
pixel_array< long > &	operator *=< long, float > (pixel_array< long > &lhs, const pixel_array< float > &rhs)
template<>
pixel_array< long > &	operator *=< long, double > (pixel_array< long > &lhs, const pixel_array< double > &rhs)
template<class T, class U>
pixel_array< T > &	operator *= (pixel_array< T > &lhs, const pixel_array< U > &rhs)
template<>
pixel_array< long > &	operator/=< long, float > (pixel_array< long > &lhs, const pixel_array< float > &rhs)
template<>
pixel_array< long > &	operator/=< long, double > (pixel_array< long > &lhs, const pixel_array< double > &rhs)
template<class T, class U>
pixel_array< T > &	operator/= (pixel_array< T > &lhs, const pixel_array< U > &rhs)
template<class T>
pixel_phase_array< T >	operator+ (const pixel_phase_array< T > &p1, const pixel_phase_array< T > &p2)
template<class T>
pixel_phase_array< T >	operator- (const pixel_phase_array< T > &p1, const pixel_phase_array< T > &p2)
template<class T>
pixel_phase_array< T >	operator * (const pixel_phase_array< T > &p1, const pixel_phase_array< T > &p2)
template<class T>
pixel_phase_array< T >	operator/ (const pixel_phase_array< T > &p1, const pixel_phase_array< T > &p2)
template<class T>
pixel_phase_array< T >	operator+ (const pixel_phase_array< T > &p1, double &fac)
template<class T>
pixel_phase_array< T >	operator- (const pixel_phase_array< T > &p1, double &fac)
template<class T>
pixel_phase_array< T >	operator * (const pixel_phase_array< T > &p1, double &fac)
template<class T>
pixel_phase_array< T >	operator/ (const pixel_phase_array< T > &p1, double &fac)
template<class T>
int	operator!= (const pixel_phase_array< T > &p1, const pixel_phase_array< T > &p2)
bool	operator!= (const null_inner_scale &eis1, const null_inner_scale &eis2)
bool	operator!= (const exponential_inner_scale &eis1, const exponential_inner_scale &eis2)
bool	operator!= (const frehlich_inner_scale &fis1, const frehlich_inner_scale &fis2)
bool	operator!= (const power_law &plaw1, const power_law &plaw2)
bool	operator!= (const von_karman_power_law &vkplaw1, const von_karman_power_law &vkplaw2)
bool	operator!= (const greenwood_power_law &gwplaw1, const greenwood_power_law &gwplaw2)
template<class power_law_type, class inner_scale_type>
bool	operator== (const isotropic_power_law_spectrum< power_law_type, inner_scale_type > &iso1, const isotropic_power_law_spectrum< power_law_type, inner_scale_type > &iso2)
template<class power_law_type, class inner_scale_type>
bool	operator!= (const isotropic_power_law_spectrum< power_law_type, inner_scale_type > &iso1, const isotropic_power_law_spectrum< power_law_type, inner_scale_type > &iso2)
template<class T>
void	initialize_frequency_array (T *data, const power_spectrum *pspectrum, const vector< long > &axes, double pixscale, bool random, const subharmonic_method &subm)
template<class T>
void	halfpixel_fft (const vector< long > &axes, T *data, fft_manager< T > &fft_mgr)
bool	operator!= (const rectangular_region &rec_region1, const rectangular_region &rec_region2)
ostream &	operator<< (ostream &, const alloc_size &)
void	fresnel_integral (double x, double &cf, double &sf)
diffractive_wavefront< double >	propagation_from_rectangular_aperture (vector< double > aperture_physical_dimensions, vector< long > final_axes, double dist, double wavelength, double pixel_scale)
template<class T>
void	goertzel_reinsch_recursor (int dimen, T *data, double angle, T &real, T &imag)
template<class T>
void	goertzel_reinsch_transform (vector< long > initial_axes, vector< long > final_axes, double sampling_factor, T *initial_data, T *final_data)
double	gamma_function (double arg)
double	generalized_hypergeometric_function (double arg, const std::vector< double > &numerator_vals, const std::vector< double > &denominator_vals, double error_tolerance=1e-10)
double	bessel_Jnu (double order, double arg)
double	bessel_Knu (double order, double arg)
double	get_Xi ()
bool	operator!= (const subharmonic_method &subm1, const subharmonic_method &subm2)
bool	operator!= (const three_frame &tf1, const three_frame &tf2)
bool	operator!= (const three_point &tp1, const three_point &tp2)
three_point	operator+ (const three_point &tp, const three_vector &tv)
three_point	operator- (const three_point &tp, const three_vector &tv)
bool	operator!= (const three_transformation &tv1, const three_transformation &tv2)
three_transformation	operator * (const three_transformation &tt1, const three_transformation &tt2)
bool	operator!= (const three_vector &tv1, const three_vector &tv2)
three_vector	operator+ (const three_vector &tv1, const three_vector &tv2)
three_vector	operator- (const three_vector &tv1, const three_vector &tv2)
three_vector	operator * (double d, const three_vector &tv)
three_vector	operator * (const three_vector &tv, double d)
double	dot_product (const three_vector &tv1, const three_vector &tv2)
three_vector	cross_product (const three_vector &tv1, const three_vector &tv2)
three_vector	parallel_projection (const three_vector &tv, const three_vector &nrml, const three_vector &drctn)
time_t	my_timegm (struct tm *tm)
bool	operator!= (const wavefront_header &wfh1, const wavefront_header &wfh2)
template<class T>
bool	operator!= (const diffractive_wavefront_header< T > &dwfh1, const diffractive_wavefront_header< T > &dwfh2)

---

Function Documentation

double bessel_Jnu (  double  order, double  arg )

Returns the Bessel function of the first kind for arbitrary order evaluated at arg This function uses the representation in terms of generalized hypergeometric functions from Sasiela Table 1.2

double bessel_Knu (  double  order, double  arg )

Returns the Bessel function of the third kind for arbitrary order evaluated at arg This function uses the representation in terms of generalized hypergeometric functions.

void box_mueller (  double &  r1, double &  r2 )  [inline]

return a random variable with 2d gaussian distribution

double chisq_2gf (  const vector< float > &  data, vector< double > &  centers, vector< double > &  widths, vector< double > &  amps, double &  dcconst, int  verbose = 0 )

function used in twogauss_fit

template<class T> void complex_cyclic_permutation (  vector< long >  axes, long  xshift, long  yshift, T *  data )

This isn't a particularly safe function... It cyclically permutes data by xshift and yshift. The zeroth element of the axes vector corresponds to the y direction, and the first element of the axes vector corresponds to the x direction

template<class T> void convex_polygon_integration (  const three_frame &  tf, const vector< three_point > &  polygon_vertices, T &  x_intgrl, T &  y_intgrl, int  verbose = 0 )

This function analytically integrates x and y over a region of support defined by the convex polygon. The three frame tf is used to define x and y, and the origin of this frame defines the zero point. All vertices of the polygon must lie in the x-y plane of this three frame. The results of the integration are returned in x_intgrl and y_intgrl, respectively. This function is used to compute elements of the geometry matrix for pyramidal actuator influence functions

three_vector cross_product (  const three_vector &  tv1, const three_vector &  tv2 )  [inline]

Return the cross product of two vectors

template<class T> void cyclic_permutation (  vector< long >  axes, long  xshift, long  yshift, T *  data )

This isn't a particularly safe function... It cyclically permutes data by xshift and yshift. The zeroth element of the axes vector corresponds to the y direction, and the first element of the axes vector corresponds to the x direction

double dot_product (  const three_vector &  tv1, const three_vector &  tv2 )  [inline]

Return the dot product of two vectors

template<class U, class V> void fit_straight_line (  const long &  nelems, const double *  x, const U *  y, const V *  wts, double &  slope, double &  sigsq_slope, double &  yintercept, double &  sigsq_yintercept, double &  chisq )

Modification of numerical recipes algorithm for fitting a straight line

void fresnel_integral (  double  x, double &  cf, double &  sf )

Returns the fresnel sin and cos integrals for the value x Modified from the numerical recipes in C routine. Warning - the text version of the NRC routine contains bugs.

double gamma_function (  double  arg  )

Returns the gamma function evaluated at arg This function uses the series expansion from Abramowitz and Stegun, section 6.1.34 This function throws an error if arg is a negative integer or is equal to zero

double generalized_hypergeometric_function (  double  arg, const std::vector< double > &  numerator_vals, const std::vector< double > &  denominator_vals, double  error_tolerance = 1e-10 )

Returns the generalized hypergeometric function p_F_q evaluated at arg. Here p and q are the sizes of the vectors numerator_vals and denominator_vals, respectively. Specifically, this function computes p_F_q(arg) = sum over k=0 to infinity of (a1,k*a2,k*...*ap,k)/(b1,k*b2,k*...*bq,k)*(arg^{k}/k!) where the factors an,k = gamma_function(n+k)/gamma_function(n) are the elements of the vector numerator_vals. Similarly, the factors bn,k are the elements of the vector denominator_vals and are likewise defined. Convergence criteria: according to Sasiela section 1.3, p < q + 1 converges for all arg values p = q + 1 converges for abs(arg) <= 1 p > q + 1 does not converge See Sasiela eqn 1.3.1 for a full definition The series will be evaluated until successive contributions fall below the error tolerance. This function throws an error if abs(arg) >= 1

double get_area_of_polygon (  const std::vector< Arroyo::three_point > &  polygon_vertices  )

vector<three_point> get_convex_polygon_circle_intersection (  const vector< three_point > &  polygon_vertices, const three_frame &  circle_tf, double  radius )

Find the overlap between a convex polygon with vertices polygon_vertices and a circular region with the given radius. The origin of the reference frame is taken to be the center of the circle, which is assumed to be in the x-y plane of this reference frame. The polygon vertices must lie in this plane or this function throws an error. If the number of vertices in the polygon is less than three, an error is thrown. This function is meant to apply to the case when the polygon is much smaller than the circle, so that we can assume that polygons which overlap the circular border are divided by a chord of the circle rather than an arc. The function returns the vertices of the resulting convex polygon.

vector<three_point> get_convex_polygon_intersection (  const vector< three_point > &  first_polygon_vertices, const vector< three_point > &  second_polygon_vertices, int  verbose = 0 )

Partially based on "Computational Geometry in C" by O'Rourke Section 7.4. This function returns the vertices of a convex polygon formed from the intersection of two convex polygons, each specified by their vertices. The first_polygon_vertices and second_polygon_vertices must each contain at least three unique three_points, no three of which may be collinear. The vertices of each polygon must be ordered in the same sense of rotation. If either of these conditions are violated, this function throws an error. WARNING: this function can return inaccurate results due to numerical roundoff. Quantifying the limits of validity of this function is a work in progress.

vector<three_point> get_line_segment_circle_intersection (  const three_point &  a1, const three_point &  a2, const three_point &  circle_origin, const double &  radius, vector< bool > &  intersection_point_on_boundary, int  verbose = 0 )

std::vector<Arroyo::three_point> get_line_segment_intersection (  const three_point &  a1, const three_point &  a2, const three_point &  b1, const three_point &  b2 )

Arroyo::three_point get_ray_plane_intersection (  const Arroyo::three_point &  o_a, const Arroyo::three_vector &  n_a, const Arroyo::three_point &  o_b, const Arroyo::three_vector &  n_b )

Return the point of intersection between a ray extending from o_a in the direction n_a and a plane defined by normal n_b and origin o_b.

Arroyo::three_point get_ray_ray_intersection (  const Arroyo::three_point &  o_a, const Arroyo::three_vector &  n_a, const Arroyo::three_point &  o_b, const Arroyo::three_vector &  n_b )

Return the point of intersection between a ray extending from o_a in the direction n_a, and a ray extending from o_b in the direction n_b.

double get_Xi (   )

Returns the numerical constant (1/5)*(1/2)^{7/3}*(gamma_function(1/6))^{2}/gamma_function(1/3) This constant appears frequently in phase covariance calculations

template<class T> void goertzel_reinsch_recursor (  int  dimen, T *  data, double  angle, T &  real, T &  imag )

This function effects the Goertzel-Reinsch recursion relation for computing the values data*cos(angle) and data*sin(angle) summed over dimen data elements. The algorithm is described on page 84 of Stoer & Burlisch, "Introduction to Numerical Analysis" 2nd edition (Springer-Verlag 1993) Time scale: This routine requires order 3*dimen additions and dimen multiplications to compute these sums. Arguments: dimen is the dimensionality of the data data is a pointer to the beginning of the data Angle is in radians

template<class T> void goertzel_reinsch_transform (  vector< long >  initial_axes, vector< long >  final_axes, double  sampling_factor, T *  initial_data, T *  final_data )

The user must allocate memory for the final data array before calling this function

template<class T> void halfpixel_fft (  const vector< long > &  axes, T *  data, fft_manager< T > &  fft_mgr )

template<class T> void initialize_frequency_array (  T *  data, const power_spectrum *  pspectrum, const vector< long > &  axes, double  pixscale, bool  random, const subharmonic_method &  subm )

time_t my_timegm (  struct tm *  tm  )

three_vector operator * (  const three_vector &  tv, double  d )

three_vector operator * (  double  d, const three_vector &  tv )

three_transformation operator * (  const three_transformation &  tt1, const three_transformation &  tt2 )

Multiply two transformations to yield a 3rd. The application of these transformations to a point, vector, or frame is defined in the sense that first the transformation tt2 is applied, and then the transformation tt1 is applied. In matrix form, this means that this function performs a left matrix multiply of the transformation tt2 by the transformation tt1. That is, the arguments are read right to left.

template<class T> pixel_phase_array<T> operator * (  const pixel_phase_array< T > &  p1, double &  fac )

template<class T> pixel_phase_array<T> operator * (  const pixel_phase_array< T > &  p1, const pixel_phase_array< T > &  p2 )

template<class T> pixel_array< T > Arroyo::operator * (  const pixel_array< T > &  p1, double &  fac )

template<class T> pixel_array< T > Arroyo::operator * (  const pixel_array< T > &  p1, const pixel_array< T > &  p2 )

template<class precision> pixel_amp_array<precision> operator * (  const pixel_amp_array< precision > &  p1, double &  fac )

template<class precision> pixel_amp_array<precision> operator * (  const pixel_amp_array< precision > &  p1, const pixel_amp_array< precision > &  p2 )

template<class precision> basic_otf< precision > Arroyo::operator * (  const basic_otf< precision > &  p1, const basic_otf< precision > &  p2 )

template<class precision> basic_otf< precision > Arroyo::operator * (  const basic_otf< precision > &  p1, double &  fac )

template<class T, class U> diffractive_wavefront<T> operator * (  const diffractive_wavefront< T > &  wf1, std::complex< U >  c )

template<class T, class U> diffractive_wavefront<T> operator * (  const diffractive_wavefront< T > &  wf1, const diffractive_wavefront< U > &  wf2 )

template<class T, class U> pixel_array<T>& operator *= (  pixel_array< T > &  lhs, const pixel_array< U > &  rhs )

template<class T, class U> diffractive_wavefront<T>& operator *= (  diffractive_wavefront< T > &  lhs_wf, const diffractive_wavefront< U > &  rhs_wf )

template<> pixel_array<long>& operator *=< long, double > (  pixel_array< long > &  lhs, const pixel_array< double > &  rhs )

template<> pixel_array<long>& operator *=< long, float > (  pixel_array< long > &  lhs, const pixel_array< float > &  rhs )

template<class T> bool operator!= (  const diffractive_wavefront_header< T > &  dwfh1, const diffractive_wavefront_header< T > &  dwfh2 )

Operator!= for diffractive wavefront headers

bool operator!= (  const wavefront_header &  wfh1, const wavefront_header &  wfh2 )

Function to compare wavefront_headers for unequal timestamps

bool operator!= (  const three_vector &  tv1, const three_vector &  tv2 )

Operator!=

bool operator!= (  const three_transformation &  tv1, const three_transformation &  tv2 )

Operator!=

bool operator!= (  const three_point &  tp1, const three_point &  tp2 )

Operator!=

bool operator!= (  const three_frame &  tf1, const three_frame &  tf2 )

Operator!=

bool operator!= (  const subharmonic_method &  subm1, const subharmonic_method &  subm2 )

bool operator!= (  const rectangular_region &  rec_region1, const rectangular_region &  rec_region2 )

template<class power_law_type, class inner_scale_type> bool operator!= (  const isotropic_power_law_spectrum< power_law_type, inner_scale_type > &  iso1, const isotropic_power_law_spectrum< power_law_type, inner_scale_type > &  iso2 )

Check for inequality of two isotropic power law spectra

bool operator!= (  const greenwood_power_law &  gwplaw1, const greenwood_power_law &  gwplaw2 )

operator != - returns true if power laws are not equal

bool operator!= (  const von_karman_power_law &  vkplaw1, const von_karman_power_law &  vkplaw2 )

operator != - returns true if power laws are not equal

bool operator!= (  const power_law &  plaw1, const power_law &  plaw2 )

operator != - returns true if power laws are not equal

bool operator!= (  const frehlich_inner_scale &  fis1, const frehlich_inner_scale &  fis2 )

operator != - returns true if inner scales are not equal

bool operator!= (  const exponential_inner_scale &  eis1, const exponential_inner_scale &  eis2 )

operator != - returns true if inner scales are not equal

bool operator!= (  const null_inner_scale &  eis1, const null_inner_scale &  eis2 )

operator != - always returns false for null inner scales

template<class T> int operator!= (  const pixel_phase_array< T > &  p1, const pixel_phase_array< T > &  p2 )

template<class T> bool Arroyo::operator!= (  const pixel_array< T > &  p1, const pixel_array< T > &  p2 )

Operator != for pixel_amp_array

template<class precision> bool Arroyo::operator!= (  const pixel_amp_array< precision > &  p1, const pixel_amp_array< precision > &  p2 )

Operator == for pixel_amp_array

template<class U, class V> bool operator!= (  const fits_header_data< U > &  fhd1, const fits_header_data< V > &  fhd2 )

Operator != for fits_header_data

bool operator!= (  const spherical_wave_emitter &  swe1, const spherical_wave_emitter &  swe2 )

bool operator!= (  const plane_wave_emitter &  pwe1, const plane_wave_emitter &  pwe2 )

template<class T> bool Arroyo::operator!= (  const diffractive_wavefront< T > &  p1, const diffractive_wavefront< T > &  p2 )

three_vector operator+ (  const three_vector &  tv1, const three_vector &  tv2 )

three_point operator+ (  const three_point &  tp, const three_vector &  tv )

template<class T> pixel_phase_array<T> operator+ (  const pixel_phase_array< T > &  p1, double &  fac )

template<class T> pixel_phase_array<T> operator+ (  const pixel_phase_array< T > &  p1, const pixel_phase_array< T > &  p2 )

template<class T> pixel_array< T > Arroyo::operator+ (  const pixel_array< T > &  p1, double &  fac )

template<class T> pixel_array< T > Arroyo::operator+ (  const pixel_array< T > &  p1, const pixel_array< T > &  p2 )

template<class precision> pixel_amp_array<precision> operator+ (  const pixel_amp_array< precision > &  p1, double &  fac )

template<class precision> pixel_amp_array<precision> operator+ (  const pixel_amp_array< precision > &  p1, const pixel_amp_array< precision > &  p2 )

template<class precision> basic_otf< precision > Arroyo::operator+ (  const basic_otf< precision > &  p1, const basic_otf< precision > &  p2 )

template<class T, class U> diffractive_wavefront<T> operator+ (  const diffractive_wavefront< T > &  wf1, std::complex< U >  c )

template<class T, class U> diffractive_wavefront<T> operator+ (  const diffractive_wavefront< T > &  wf1, const diffractive_wavefront< U > &  wf2 )

template<class T, class U> pixel_array<T>& operator+= (  pixel_array< T > &  lhs, const pixel_array< U > &  rhs )

template<class T, class U> diffractive_wavefront<T>& operator+= (  diffractive_wavefront< T > &  lhs_wf, const diffractive_wavefront< U > &  rhs_wf )

template<> pixel_array<long>& operator+=< long, double > (  pixel_array< long > &  lhs, const pixel_array< double > &  rhs )

template<> pixel_array<long>& operator+=< long, float > (  pixel_array< long > &  lhs, const pixel_array< float > &  rhs )

three_vector operator- (  const three_vector &  tv1, const three_vector &  tv2 )

three_point operator- (  const three_point &  tp, const three_vector &  tv )

template<class T> pixel_phase_array<T> operator- (  const pixel_phase_array< T > &  p1, double &  fac )

template<class T> pixel_phase_array<T> operator- (  const pixel_phase_array< T > &  p1, const pixel_phase_array< T > &  p2 )

template<class T> pixel_array< T > Arroyo::operator- (  const pixel_array< T > &  p1, double &  fac )

template<class T> pixel_array< T > Arroyo::operator- (  const pixel_array< T > &  p1, const pixel_array< T > &  p2 )

template<class precision> pixel_amp_array<precision> operator- (  const pixel_amp_array< precision > &  p1, double &  fac )

template<class precision> pixel_amp_array<precision> operator- (  const pixel_amp_array< precision > &  p1, const pixel_amp_array< precision > &  p2 )

template<class precision> basic_otf<precision> operator- (  const basic_otf< precision > &  p1, const basic_otf< precision > &  p2 )

template<class T, class U> diffractive_wavefront<T> operator- (  const diffractive_wavefront< T > &  wf1, std::complex< U >  c )

template<class T, class U> diffractive_wavefront<T> operator- (  const diffractive_wavefront< T > &  wf1, const diffractive_wavefront< U > &  wf2 )

template<class T, class U> pixel_array<T>& operator-= (  pixel_array< T > &  lhs, const pixel_array< U > &  rhs )

template<class T, class U> diffractive_wavefront<T>& operator-= (  diffractive_wavefront< T > &  lhs_wf, const diffractive_wavefront< U > &  rhs_wf )

template<> pixel_array<long>& operator-=< long, double > (  pixel_array< long > &  lhs, const pixel_array< double > &  rhs )

template<> pixel_array<long>& operator-=< long, float > (  pixel_array< long > &  lhs, const pixel_array< float > &  rhs )

template<class T> pixel_phase_array<T> operator/ (  const pixel_phase_array< T > &  p1, double &  fac )

template<class T> pixel_phase_array<T> operator/ (  const pixel_phase_array< T > &  p1, const pixel_phase_array< T > &  p2 )

template<class T> pixel_array< T > Arroyo::operator/ (  const pixel_array< T > &  p1, double &  fac )

template<class T> pixel_array< T > Arroyo::operator/ (  const pixel_array< T > &  p1, const pixel_array< T > &  p2 )

template<class precision> pixel_amp_array<precision> operator/ (  const pixel_amp_array< precision > &  p1, double &  fac )

template<class precision> pixel_amp_array<precision> operator/ (  const pixel_amp_array< precision > &  p1, const pixel_amp_array< precision > &  p2 )

template<class precision> basic_otf< precision > Arroyo::operator/ (  const basic_otf< precision > &  p1, const basic_otf< precision > &  p2 )

template<class T, class U> diffractive_wavefront<T> operator/ (  const diffractive_wavefront< T > &  wf1, std::complex< U >  c )

template<class T, class U> diffractive_wavefront<T> operator/ (  const diffractive_wavefront< T > &  wf1, const diffractive_wavefront< U > &  wf2 )

template<class T, class U> pixel_array<T>& operator/= (  pixel_array< T > &  lhs, const pixel_array< U > &  rhs )

template<class T, class U> diffractive_wavefront<T>& operator/= (  diffractive_wavefront< T > &  lhs_wf, const diffractive_wavefront< U > &  rhs_wf )

template<> pixel_array<long>& operator/=< long, double > (  pixel_array< long > &  lhs, const pixel_array< double > &  rhs )

template<> pixel_array<long>& operator/=< long, float > (  pixel_array< long > &  lhs, const pixel_array< float > &  rhs )

ostream& operator<< (  ostream &  , const alloc_size &  )

template<class power_law_type, class inner_scale_type> bool operator== (  const isotropic_power_law_spectrum< power_law_type, inner_scale_type > &  iso1, const isotropic_power_law_spectrum< power_law_type, inner_scale_type > &  iso2 )

Check for equality of two isotropic power law spectra

template<class T> bool operator== (  const pixel_array< T > &  p1, const pixel_array< T > &  p2 )

Friend operator == for pixel_array

template<class precision> bool operator== (  const pixel_amp_array< precision > &  p1, const pixel_amp_array< precision > &  p2 )

Friend operator == for pixel_amp_array

template<class U, class V> bool operator== (  const fits_header_data< U > &  fhd1, const fits_header_data< V > &  fhd2 )

Operator == for fits_header_data

template<class T> bool operator== (  const diffractive_wavefront< T > &  p1, const diffractive_wavefront< T > &  p2 )

Friend operator == for diffractive_wavefronts

three_vector parallel_projection (  const three_vector &  tv, const three_vector &  nrml, const three_vector &  drctn )

Return the projection of the three vector tv into a plane orthogonal to the vector nrml, along the direction specified by the three vector drctn. If drctn==normal then the parallel projection yields the component of tv in the plane orthogonal to nrml.

refractive_atmospheric_model* parse_ref_atm_model (  int  argc, char *const   argv[], three_frame  tf )

bool point_within_polygon (  const three_point &  tp, const vector< three_point > &  vtp )

Same as above, but no degeneracy information

bool point_within_polygon (  const three_point &  tp, const vector< three_point > &  vertices, bool &  point_on_edge, bool &  point_on_vertex )

Modified from "Ray Tracing News Volume 5, Number 3. Some explanation also appears on page 117 of "Object oriented ray tracing in C++" by Nicholas Wilt Shoot a test ray along +X axis and count the crossings Note: the points in vtp are interpreted as ordered vertices of the polygon. They may be ordered clockwise or counterclockwise If the point lies at a distance less than three_frame::precision from a vertex or a segment edge of the polygon, it is defined as lying within the polygon. These two cases are indicated by the value of the booleans passed to the function WARNING: this function can return inaccurate results due to numerical roundoff. Quantifying the limits of validity of this function is a work in progress.

diffractive_wavefront<double> propagation_from_rectangular_aperture (  vector< double >  aperture_physical_dimensions, vector< long >  final_axes, double  dist, double  wavelength, double  pixel_scale )

Returns a wavefront constructed via the analytic solution for wave propagation through a rectangular aperture. The initial physical dimension is that of the aperture, in meters The final physical dimension specifies the dimensions of the final wavefront, in meters distance is measured from the aperture,in meters wavelength is in meters pixel scale of the final wavefront is in meters/pixel

template<class T> void singular_value_decomposition (  char *  jobu, char *  jobvt, int &  m, int &  n, T *  a, int &  lda, T *  s, T *  u, int &  ldu, T *  vt, int &  ldvt, T *  work, int &  lwork, int &  info )

void twogauss_fit (  const vector< float > &  data, vector< double > &  centers, vector< double > &  widths, vector< double > &  amps, double &  dcconst )

fit gaussians

void usage_ref_atm_model (   )

void write_arcadia_input_file (  const Arroyo::refractive_atmospheric_model &  ref_atm_model, const Arroyo::circular_aperture &  circ_ap, const std::vector< Arroyo::emitter * > &  guide_stars, const std::vector< Arroyo::square_lenslet_array > &  lenslet_arrays, const std::vector< bool > &  tilt_removal_flags, const std::vector< Arroyo::ideal_tip_tilt_mirror< circular_aperture > > &  ttms, const std::vector< Arroyo::ideal_deformable_mirror< circular_aperture > > &  dms, const std::vector< double > &  slaving_thresholds, const char *  filename )

---