home software electronics optics astronomy photography miscellaneous keyword
opus - optical design software max reason

page contents

preface - what is on this page
audience - who is this documentation for
overview - overview of opus organization


preface
This web-page describes how the opus optical design and analysis source-code is organized and functions.  Another web-page contains general information and documentation about the opus application, including a short tutorial and operating instructions.  You must read the general page before this page makes sense.


audience
This documentation is intended for opus developers and advanced optical designers who need or want to understand how the opus application is organized and functions.  The information on this page is sometimes similar to C++ or XBasic source-code comments, though overall this page is more general and conversational.  This page is brief, superficial, work-in-progress, and full of errors-and-omissions.


overview
Not much written yet, but the following may be better than nothing.

Without explaining what all this means, opus computes an optical system by tracing light rays:
  *  through all surfaces (entrance-aperture  --->>   optical-surfaces  --->> focal-surface)
  *  at 16 ticks (equally spaced angles)
  *  in 9 zones (inner to outer)
  *  at 7-10 colors (3200A to 10140A)
  *  at 9 skew angles (on-axis to edge-of-field)

opus considers where and how various sets of rays intersect the surface and draws conclusions:
  *  all rays of all colors at a given skewangle correspond to a full-color image
  *  all rays of one color at a given skewangle correspond to a one-color image
  *  all rays of one color in a given zone at a given skewangle reveal aberrations
  *  ... etc ...

>  array access in C++ vs XBasic code
Due to different simplicity/efficiency trade-offs in C++ versus XBasic, arrays are indexed differently.  Every C++ array is a one-dimensional AKA linear array, while many XBasic arrays are multi-dimensional.  For example, to access a rayhit structure for a given (skew,color,zone,tick,surface), the XBasic code is: #rayhit[skew,color,zone,tick,surface].xxx while the C++ code is _rayhit[index].xxx.  During normal sequential computation, the structures are accessed linearly, so a simple, efficient index++ once per-color steps from array-element to array-element correctly.  For post-trace analysis, methods like index = rayhit_index(skew,color,zone,tick,surface) return the single array-index that corresponds to any argument combination.

>  opus application
The primary object or entity is the opus application itself.  Some properties and information apply only to the opus application as a whole, including optical glasses and one optical system [ optionally multiple ].

  >>  optical glasses
When started, the opus application loads an optical glass database file /opus/OpusGlass.txt and stores the information in an array of glass structures or class Glass objects.   OpusGlass.txt is a text file containing one line of fixed-format space-character-padded information for each optical glass, including:
  *  glass name
  *  manufacturer name
  *  index of refraction
  *  density in gm/cc
  *  thermal expansion in c/c/C
  *  resistance to acid stain / damage
  *  resistance to water stain / damage

The current format accommodates refractive-index information for 10 wavelengths from 3200A - 10140A.

  >>  optical system
Some properties and information apply only to an optical system as a whole, including:
  *  default skew
  *  default color
  *  maximum skewangle
  *  number of surfaces
  *  an array of surfaces - one per surface
  *  an array of opd structures - one per [skew, color]
  *  an array of blur structures - one per [skew, color, zone]
  *  an array of rayhit structures - one per [skew, color, zone, tick, surface]

All once-per-optical-system information in class System in the C++ code.  The XBasic code declares a SYSTEM structure to hold this information, but unfortunately this information is held in shared variables.  The XBasic source-code should be modified to move all system-wide information into a SYSTEM variable.

    >>>  array of surfaces
The fundamental component of an optical system is its array of surfaces.   Every opus optical system an entrance-aperture at surface 0 - followed by one or more optical-surfaces - ending with a focal-surface.  Thus every opus optical system has 3 or more surfaces, surface-number 0 to the focal-surface-number.

opus holds information about each surface in _surface[], an array of struct Surface structures.   Each Surface structure holds:
  *  radius
  *  position
  *  conic shape
  *  vignette-dimensions
  *  physical-dimensions
  *  surface-type (in lens, out lens, mirror, figure, cement, schmidt, etc).
  *  glass-number (converted from glass-name when design is loaded from disk)

    >>>  array of opd structures
opus considers 7-10 images formed on the focal-surface at each skewangle - one for each color computed.  Blended together, these 7-10 one-color images closely approximate the full-color image at each skewangle.  opus saves OPD and wavefront information for each one-color image (skew,color) in _opd[], an array of struct Opd structures.  Each Opd structure holds:
  *  the minimum, maximum, average x,y,z positions of rays intersecting the focal-surface
  *  total # of rays-traced, # of rays not-vignetted
  *  the computed OPD in waves for each color

    >>>  array of blur structures
To support fine-grain aberration information, opus computes aberrations for each (skew,color,zone) and saves the information in _blur[], an array of struct Blur structures.  Each Blur structure holds:
  *  the minimum, maximum, average x,y,z positions of rays intersecting the focal-surface
  *  the z position where the tangential and sagittal rays converge
  *  the average path-length at the average x,y,z position
  *  the OPD off all rays at the average x,y,z position
  *  aberrations: spherical, coma, astigmatism

    >>>  array of rayhit structures
At the lowest level, opus traces each ray from the entrance-aperture surface, through all optical-surfaces, to the focal-surface.  At each surface, opus saves information about the intersection of every ray with every surface in _rayhit[], an array of struct Rayhit structures.  Each Rayhit structure holds:
  *  the x,y,z position of where ray hit the surface
  *  the x,y,z direction of the ray when it hit the surface
  *  the cumulative optical-path-length to the intersection
  *  indication of whether the ray is valid = was traced
  *  indication of whether the ray has been vignetted



copyright 1988-2001 - all rights reserved - patents pending