optic.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 OPTIC_H
#define OPTIC_H

#include "AO_sim_base.h"
#include "fits_header_data.h"
#include "three_frame.h"

namespace Arroyo {

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

  class iofits;
  class rectangular_region;
  class three_vector;
  class three_scaling;
  class wavefront_header;
  template<typename T> class diffractive_wavefront;


  class optic :
    virtual public AO_sim_base {

    protected:
    
    bool foreshortening;

    public:

    optic(){foreshortening = true;};

    optic(const optic & op);

    virtual ~optic(){};

    optic & operator=(const optic & op);

    bool get_foreshortening() const {return(foreshortening);};

    void set_foreshortening(bool fshrtn) {foreshortening = fshrtn;};

    virtual void read(const iofits & iof);
 
    virtual void write(iofits & iof) const;

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

    virtual rectangular_region get_covering_region(const three_frame & tf) const = 0;

    virtual three_point get_point_of_intersection(const three_point & tp, 
                                                  const three_vector & tv) const = 0;

    static int verbose_level;

    static optic * optic_factory(const char * filename);

    static optic * optic_factory(const iofits & iof);

  };


  class plane_optic :
    virtual public optic, 
    public three_frame {

    protected:

    template<class T>
      void get_projected_wavefront_pixel_spacing(const diffractive_wavefront<T> & wf, 
                                                 three_vector & origin_offset, 
                                                 three_vector & dx, 
                                                 three_vector & dy) const;
  
    public:

    plane_optic(){};

    plane_optic(const plane_optic & plane_op);

    virtual ~plane_optic(){};

    plane_optic & operator=(const plane_optic & plane_op);

    virtual void read(const iofits & iof);
 
    virtual void write(iofits & iof) const;

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

    virtual three_point get_point_of_intersection(const three_point & tp, 
                                                  const three_vector & tv) const;

    static plane_optic * plane_optic_factory(const char * filename);

    static plane_optic * plane_optic_factory(const iofits & iof);

  };

  template<class T>
  void plane_optic::get_projected_wavefront_pixel_spacing(const diffractive_wavefront<T> & wf, 
                                                          three_vector & origin_offset, 
                                                          three_vector & dx, 
                                                          three_vector & dy) const {

    // First, ensure that wavefront normal is not orthogonal to the
    // plane_optic normal
    if(fabs(dot_product(wf.three_frame::z(), this->three_frame::z()))<three_frame::precision){
      cerr << "plane_optic::get_projected_wavefront_pixel_spacing error - "
           << "diffractive_wavefront orthogonal to circular plane_optic normal\n";
      throw(string("plane_optic::get_projected_wavefront_pixel_spacing"));
    }
  
    // Next, ensure that the wavefront origin lies in the transverse
    // frame of the optic.
    origin_offset = static_cast<three_point>(wf) - static_cast<const three_point>(*this);

    if(fabs(dot_product(origin_offset, this->three_frame::z()))>three_frame::precision){
      cerr << "plane_optic::get_projected_wavefront_pixel_spacing error - "
           << "diffractive_wavefront center not in transverse plane of circular plane_optic\n";
      throw(string("plane_optic::get_projected_wavefront_pixel_spacing"));
    }

    double wf_pixel_scale = wf.get_pixel_scale();
    dx = wf.three_frame::x()*wf_pixel_scale;
    dy = wf.three_frame::y()*wf_pixel_scale;

    try{
      dx = parallel_projection(dx, this->z(), wf.z());
      dy = parallel_projection(dy, this->z(), wf.z());
    } catch(...){
      cerr << "plane_optic::get_projected_wavefront_pixel_spacing error - "
           << "could not form parallel projection\n";
      throw(string("plane_optic::get_projected_wavefront_pixel_spacing"));
    }
    
    // If there's no foreshortening, we explicitly set the length to be
    // equal to the wf pixel scale
    if(!foreshortening){
      dx = (wf_pixel_scale/dx.length())*dx;
      dy = (wf_pixel_scale/dy.length())*dy;
    }
  }



  class one_to_one_optic :
    virtual public optic {

    protected:

    template<class T>
      T * get_wavefront_data(diffractive_wavefront<T> & wf) const {
      return(wf.wfdata);
    };

    template<class T>
      bool is_real_imag_storage(const diffractive_wavefront<T> & wf) const {
      return(wf.real_imag);
    };

    template<class T>
      bool is_interleaved_storage(const diffractive_wavefront<T> & wf) const {
      return(wf.interleaved);
    };

    template<class T>
      void wavefont_real_imag_conversion(diffractive_wavefront<T> & wf) const {
      wf.real_imag_conversion();
    };
  
    template<class T>
      void wavefront_amp_phase_conversion(diffractive_wavefront<T> & wf) const {
      wf.amp_phase_conversion();
    };

    // geometric_ray * get_wavefront_data(const geometric_wavefront & gwf) const;

    public:

    one_to_one_optic(){};

    virtual ~one_to_one_optic(){};

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

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

    //virtual void transform(geometric_wavefront & gwf) const = 0;

  };


  class one_to_many_optic :
    virtual public optic {

    protected:

    template<class T>
      const T * const get_wavefront_data(const diffractive_wavefront<T> & wf) const {
      return(wf.wfdata);
    };

    template<class T>
      bool real_imag_storage(const diffractive_wavefront<T> & wf) const {
      return(wf.real_imag);
    };

    template<class T>
      bool interleaved_storage(const diffractive_wavefront<T> & wf) const {
      return(wf.interleaved);
    };

    public:
  
    one_to_many_optic(){};

    virtual ~one_to_many_optic(){};

    virtual long number_of_outputs() const = 0;


    virtual vector<diffractive_wavefront<float> > transform(const diffractive_wavefront<float> & wf) const = 0;

    virtual vector<diffractive_wavefront<double> > transform(const diffractive_wavefront<double> & wf) const = 0;

    //virtual vector<geometric_wavefront> transform(const geometric_wavefront & gwf) const = 0;

  };


}

#endif

---