Optical Layout

Conceptual design

• Nominal beam height from floor --> 1200 mm: It should be confirmed by R. Takahashi.

• Vertical beam steering policy
• Horizontal beam layout (with mirror wedge design)
• Detection port location and out-vacuum optical bench arrangement
• End port beam monitor
• Optical lever arrangements in each vacuum chamber

• As a general rule, all of out-vacuum beam should be steered by 2-inch or 1-inch mirrors. Maximum beam radius set to be 6 mm. (= 25.4 /3 /sqrt(2))

• Naming rules of reflection beam at each optics (including stray lights)

Tool

Usually, optical layout of an IFO is designed using a generic CAD (such as AutoCAD) or a special optical CAD (e.g. Zemax). We haven't used Zemax so I have no word on it.

Using a generic CAD was the original plan for LCGT optical layout. However, as I work on it, several problems were identified.

• It is very time consuming as we have to manually calculate the reflection and deflection angles.
• Optical path lengths also have to be manually calculated taking into account the index of refraction.
• For a high power interferometer like LCGT, one has to track not only the main beams but also the auxiliary beams such as AR reflection
  • or HR transmission and properly damp them. Therefore, the number of beams to be handled is very large for manual drawing.
• Manual calculations can easily introduce errors.
• Every time something is changed (such as BS wedge angle), the whole drawing has to be redone.
• Fulfilling multiple IFO requirements (RC optical length, ITM incident angles, etc) with an optical layout is
  • not a trivial task. Ad hoc CAD drawing is not suitable for this task. More systematic way is necessary.

Therefore I (Y. Aso) wrote a small python library to programatically create optical layouts. The library is called gtrace (meaning Gaussian ray-Tracing), and easy to use. The library features:

• Automatically calculate reflection and deflection angles when a beam hit an optical component.
• Multiple reflections inside a thick optics can be handled.
• Laser beams are treated as fully Gaussian beams.
• Beam parameters (q-parameter, width and ROC) evolve as the beam propagates.
• Optical distance is properly calculated when transmitting through optics.
• Gouy phase change is tracked.
• Beam parameters are stored in x and y directions separately. So when a beam hit a spherical surface from a diagonal direction, astigmatism is taken into account.
• Beam power changes by reflections and transmissions are automatically handled.
• Resultant layout can be exported to a DXF file. So most CAD programs can import it.

By using the library, one can turn logical requirements such as the RC optical lengths, folding angle, ITM surface normal directions (they have to be orthogonal), etc into a real optical layout in a systematic way by writing a program. Once the program is written, it is easy to change wedge angle or substrate material, because all you have to do is to re-run the program to generate a new optical layout.

An example of LCGT layout (by no means the final version) is attached: LCGT_Sample_OptLayput.pdf.

A python program used to generate the layout is also attached: OptLayout.zip.

Software requirements for using gtrace

gtrace requires the following Python modules/packages be installed in your system. For Windows users, it is easiest to install pythonxy (http://www.pythonxy.com/) as their contains all the necessary libraries. For Mac users, the 32bit version of Enthought Python Distribution (EPD) is free of charge for academic use (http://www.enthought.com/products/edudownload.php). Windows and Linux versions are also available. Most Linux distributions have the necessary libraries in their package system.

• Python 2.6 or higher

• Enthought Traints (http://code.enthought.com/projects/traits/)

• Numpy and Scipy (http://www.scipy.org/Download)

You also have to set the environmental variable PYTHONPATH to point to the OptLayout directory, which you get when you extract the zip file.

See here for more information on setting up scientific computing environment with Python.