conic_section.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 CONIC_SECTION_H
#define CONIC_SECTION_H

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

namespace Arroyo {

  class conic_section :
    virtual public AO_sim_base {

  private:
    
    static const bool factory_registration;

    string unique_name() const {return(string("conic section"));};

  protected:

    // Plane wave flag
    bool plane_wave;

    // The vertex of the conic section
    three_point vertex;

    // The focus of the conic section closest to the vertex
    three_point focus;

    // The eccentricity:
    // For a spherical mirror, eccentricity = 0
    // For an elliptical mirror, 0 < eccentricity < 1
    // For a parabolic mirror, eccentricity = 1
    // For a hyperbolic mirror, eccentricity > 1
    double eccentricity;

  public:

    conic_section(){
      this->eccentricity = -1;
    };

    conic_section(const conic_section & cmr);

    conic_section(const char * filename);

    conic_section(const iofits & iof);

    conic_section(const three_point & vertex, 
                  const three_point & focus, 
                  double eccty);

    ~conic_section(){};

    conic_section & operator=(const conic_section & cmr);

    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_eccentricity() const {
      return(this->eccentricity);
    };

    three_point get_vertex() const {
      return(this->vertex);
    };

    three_point get_near_focus() const {
      return(this->focus);
    };

    three_point get_far_focus() const {
      if(this->eccentricity==1){
        cerr << "conic_section::get_far_focus error - this instance is a parabola, and the focus is at infinity\n";
        throw(string("conic_section::get_far_focus"));
      }
      double dist = this->get_latus_rectum()/2./(1-this->eccentricity);
      three_vector unit_vector = this->focus - this->vertex;
      unit_vector = (1/unit_vector.length())*unit_vector;
      return(this->vertex + dist*unit_vector);
    };

    double get_latus_rectum() const {
      return(2*(this->focus - this->vertex).length()*(1+this->eccentricity));
    };

    double get_local_curvature(three_point & tp) const;

    bool on_conic(const three_point & tp) const;

    void raytrace(const three_point & tp, 
                  const three_vector & tv,
                  double & distance_to_conic,
                  three_point & point_of_intersection,
                  three_vector & conic_unit_normal,
                  double & R_squared,
                  double & V) const;

    static int verbose_level;

  };

}

#endif
  

---