lenslet_array.h

Go to the documentation of this file.

/*
Arroyo - software for the simulation of electromagnetic wave propagation
through turbulence and optics.

Copyright (c) 2000-2004 California Institute of Technology.  Written by
Dr. Matthew Britton.  For comments or questions about this software,
please contact the author at mbritton@astro.caltech.edu.

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as  published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.

This program is provided "as is" and distributed in the hope that it
will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  In no
event shall California Institute of Technology be liable to any party
for direct, indirect, special, incidental or consequential damages,
including lost profits, arising out of the use of this software and its
documentation, even if the California Institute of Technology has been
advised of the possibility of such damage.   The California Institute of
Technology has no obligation to provide maintenance, support, updates,
enhancements or modifications.  See the GNU General Public License for
more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*/

#ifndef LENSLET_ARRAY_H
#define LENSLET_ARRAY_H

#include "optic.h"

namespace Arroyo {

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


  class lenslet_array_base :
    public plane_optic,
    public one_to_one_optic {

    public:

    lenslet_array_base(){};

    lenslet_array_base(const lenslet_array_base & labase);

    virtual ~lenslet_array_base(){};

    virtual void write(iofits & iof) const = 0;

    lenslet_array_base & operator=(const lenslet_array_base & labase);

    static lenslet_array_base * lenslet_array_base_factory(const char * filename);

    static lenslet_array_base * lenslet_array_base_factory(const iofits & iof);

  };


  class square_lenslet_array :
    public lenslet_array_base {

    private:

    static const bool factory_registration;

    string unique_name() const {return(string("square lenslet array"));};
    
    template<class T>
      void private_transform(diffractive_wavefront<T> & wf) const;

    protected:

    vector<long> axes;

    double focal_length;
    
    double lenslet_pitch;

    double final_wavefront_propagation_distance;
    
    long final_wavefront_pixels_per_lenslet;

    long final_wavefront_pixels_per_transform;

    square_lenslet_array(){};

    public:

    square_lenslet_array(const square_lenslet_array & sq_lns_arr);

    square_lenslet_array(const char * filename);

    square_lenslet_array(const iofits & iof);

    square_lenslet_array(vector<long> array_axes,
                         double flength,
                         double lnslt_pitch,
                         long pix_per_lenslet,
                         long pix_per_xform);

    ~square_lenslet_array(){};

    square_lenslet_array & operator=(const square_lenslet_array & sq_lns_arr);

    void read(const char * filename);

    void read(const iofits & iof);
 
    void write(const char * filename) const;

    void write(iofits & iof) const;

    void print(ostream & os, const char * prefix="") const;

    double get_final_wavefront_propagation_distance() const {return final_wavefront_propagation_distance;};
   
    void set_final_wavefront_propagation_distance(double wf_prop_dist) {final_wavefront_propagation_distance = wf_prop_dist;};
   
    long get_final_wavefront_pixels_per_lenslet() const {return final_wavefront_pixels_per_lenslet;};
   
    void set_final_wavefront_pixels_per_lenslet(long pix_per_lnslt);
   
    long get_final_wavefront_pixels_per_transform() const {return final_wavefront_pixels_per_transform;};
   
    void set_final_wavefront_pixels_per_transform(long pix_per_xform);
   
    vector<long> get_axes() const {return(axes);};
   
    double get_lenslet_pitch() const {return(lenslet_pitch);};
   
    double get_focal_length() const {return(focal_length);};
   
    rectangular_region get_covering_region(const three_frame & tf) const;

    void transform(diffractive_wavefront<float> & wf) const;

    void transform(diffractive_wavefront<double> & wf) const;

  };
}

#endif

---