Changeset 4481 for trunk/MagicSoft/AMC

Timestamp:

08/04/04 16:35:17 (20 years ago)

Author:

merck

Message:

MMerck: Laser positions are now doubles.

Location:

trunk/MagicSoft/AMC/activemirrorcontrol/activemirrorcontrol

Files:

• amcmirrorpanel.cpp (modified) (2 diffs)
• amcmirrorpanel.h (modified) (5 diffs)

trunk/MagicSoft/AMC/activemirrorcontrol/activemirrorcontrol/amcmirrorpanel.cpp

@@ -15 +15 @@
 
 #include "amcmirrorpanel.h"
+#include <math.h>
+#include <qstring.h>
 
 AMCMirrorPanel::AMCMirrorPanel( int i, int j, int iType, int iPort, int iBox, int iDriver)
                 : m_i(i), m_j(j), m_iType(iType), m_iPort(iPort), m_iBox(iBox), m_iDriver(iDriver)
 {
+        m_zReversed = false;
         m_zLaserOn = false;
         m_zMotorPower = true;
         m_iX = m_iY = 0;
         m_iRefX = m_iRefY = 0;
-        m_iLaserX = m_iLaserY = 0;
+        m_dLaserX = m_dLaserY = 0.0;
         m_dAxisX = m_dAxisY = 0.0;
         m_dSlopeX = m_dSlopeY = 0.0;
@@ -31 +34 @@
 AMCMirrorPanel::~AMCMirrorPanel(){
 }
+
+
+/**
+ * Here we calculation a correction for the laser spot position.
+ *
+ * The correction is composed of to components.
+ * The first component cimes from the parabolic shape of the mirror.
+ * Each mirror has a different focal length for the roque lamp spot
+ * depending on its radial distance from the center of the mirror.
+ * Correction one corrects for the error we introduce by moving the
+ * mirror spot to a fixed focal plane during the roque lamp focusing.
+ *
+ * The second correction is to take into account the different position
+ * of the plane where the roque lamp focusing is done and the plaane of the
+ * winston cones.
+ *
+ * All calculations are done in mm.
+ * We return the correction in milimeters we hace to move the laser spot along
+ * the projection of the mirror center vector onto the camera plane.
+ * This coorection is half the movement of the mirror spot.
+ */
+double AMCMirrorPanel::calcCorrection()
+{
+        // First we define some constants used in the calculation
+        const double kDistMirror = 17000.0;             // Distance from camera to mirror center
+                                                                                                                                                                        // Nominal focal length for infinity focusing
+        const double kDistRoque = 980000.0;     // Distance from the MAGIC telescope to the
+                                                                                                                                                                        // Roque lamp.
+        const double kFocPlaneRoque = 300.1;    // change of focal plane for roque lamp focusing.
+        const double kDistWinstonCones = 35.0;  // Distance from the plane of focusing ( white
+                                                                                                                                                                        // paper or styropor surface) to the PMT camera
+                                                                                                                                                                        // plane (front of winston cone surface)
+
+        /*
+   * First we calculate the distance of the center of this panel to the center of the
+         * mirror.
+         */
+  double dMirrorRadius = sqrt( pow( m_i*1000.0, 2 ) + pow( m_j*1000.0, 2 ) );
+
+        /*
+   * dHeightMirror is the height of the center of the selected mirror panel over the
+   * tangential plane to the parabolas vertex.
+   * Using the equation for a parabola open to the right:
+   *                         y^2 = 4ax
+         *    a is the distance from the vertex to the focal point), or focal length of the parabola.
+   *
+         * This height is calculated to:
+         *                        x = y^2 / 4a;
+   * or
+         *                        dHeightMirror = SQR( dMirrorRadius ) / dLatusRectum;
+   *
+   * where we used the latus rectum of the parabooa: dLatusRectum = 4 * a.
+   *
+   * See: http://mathworld.wolfram.com/Parabola.html
+   */
+        double dLatusRectum = 4.0 * kDistMirror;
+        double dHeightMirror = pow( dMirrorRadius, 2. ) / dLatusRectum;
+
+  /*
+   * Alpha is the angle betweeen the optical axis and the connection line
+         * between the mirror center and the focal point of the parabola.
+         * (The focal point of the parabola)
+   *
+         *
+         *                                             ____-\         -
+         *                                     ____----               ^
+         *                             ____----                   dMirrorRadius
+         *                                                                               ____----      dAlpha                   v
+         *                 x------------------------------------|     -
+         *
+   *                 <------------ kDistMirror ------------>
+   *                                                   <--->   dHeightMirror
+   */
+   double dAlpha = atan( dMirrorRadius / ( kDistMirror - dHeightMirror ) );
+
+        /*
+         * For the Roque Lamp focusing the ray from the roque lamp is seen at the panels
+   * center under an angle dDelta.
+         *                   dDelta = atan( dMirrorRadius / (kDistRoque - dHeightMirror) );
+         *
+   *                                                           ________-\         -
+         *                                           ________--------     __--          ^
+         *                           ________--------                 __--        dMirrorRadius
+         *                                       ________--------      dDelta                __--     dGamma        v           
+   *   x-------------------------------------------------x--*-------------|       -
+         *
+   *   <--------------------------- kDistRoque --------------------------->
+   *                                                     <- dFocusRoque -->
+   *                                                                    <-kDistMirror->
+   *                                                                    <->   dHeightMirror
+   *
+   * The reflected ray intersects the optical axis at a focal distance dFocusRoque
+   * which is longer then focal length of the parabola.
+   * For a spherical mirror (Davis-Cotton design like CT1) this difference would be
+   * 300.1 mm which is the distance we shift the camera plane back for the roque lamp
+   * focusing.
+   * The angle at which this reflected ray intersects the optical axis is:
+         *      dGamma = dAlpha - dDelta;
+   *
+   * For the parabola this distance is only correct for the vertex and bigger as farer the
+   * mirror is away from the vertex. We calculate now the focal length at roque focusing
+   * for this mirror dFocusRoque and the difference dDiffFocusRQ between the roque focusing
+   * plane amd this focal length.
+   */
+        double dDelta = atan( dMirrorRadius / ( kDistRoque - dHeightMirror) );
+        double dGamma = dAlpha - dDelta;
+  double dFocusRoque = (dMirrorRadius / tan( dGamma )) + dHeightMirror;
+        double dDiffFocusRQ = dFocusRoque - kFocPlaneRoque - kDistMirror;
+
+  /*
+   * The correction we have to apply results from the error we made by forcing the spots of
+   * the individual mirrors onto the focal spot of the vertex for the roque lamp distance.
+         *
+   *                                                        ____-\              -
+         *                                                ____---- ..                 ^
+         *                                        ____----     ....                   |
+         *                                                            ____----________________________            |
+         *                        ____----    |        ....              ^       dMirrorRadius
+         *                ____----            |    ....              dCorrection      |
+         *                        ____----                        |....                      V            V
+   *   x--------------------------------*---------------------------------|     -
+   *
+   *   <--------------------------- dFocusRoque -------------------------->
+   *                                    <- kDistMirror + kFocPlaneRoque -->
+   *   <---  dDiffFocusRQ ------------->                         <--------> dHeightMirror
+   *   <-------------- dFocusRoque - dHeightMirror ------------->
+   *
+   * Using the rule of three we get
+   *
+         *         dCorrection / dDiffFocusRQ = dMirrorRadius / ( dFocusRoque - dHeightMirror )
+   * or:
+   *         dCorrection = (dMirrorRadius / (dFocusRoque- dHeightMirror) ) * dDiffFocusRQ
+   */
+        double dCorrection1 = (dMirrorRadius / (dFocusRoque- dHeightMirror) ) * dDiffFocusRQ;
+
+  /*
+   * The second correction needs to be applied because we can not use the front of the
+   * winston cones as reference plane but a plane defined py the styropor panel put on
+   * top of the plexiglas window of the camera.
+   * This reference plane is 35 mm (kDistWinstonCones) infornt of the real focal plane we
+   * should have used.
+   * Looking at the scetch below we forced the ray to follow the line with stars, but
+   * should have focus the mirror in such a way that it would have followed the dashed
+   * line.
+         *
+   *                                                        ____--\              -
+         *                                                ____---- ***                 ^
+         *                                        ____----     ****                   |
+         *                                                            ____----         ****         ---   |
+         *                        ____----    |        ****              ^       dMirrorRadius
+         *                ____----            |    ****              dCorrection      |
+         *                        ____----                        |****                      V            V
+   *   x--------------------------------*---------------------------------|     -
+   *
+   *                                    <- kDistMirror + kFocPlaneRoque -->
+   *   <----- kDistWinstonCones ------->                             <----> dHeightMirror
+   *                                                                                                                                    <- dFocus - dHeightMirror -->
+   *
+   * Using the rule of three we get
+   *
+         *         dCorrection / kDistWinstonCones = dMirrorRadius / ( dFocus - dHeightMirror - kDistWinstonCones )
+   * or:
+   *         dCorrection = (dMirrorRadius / (dFocus - dHeightMirror - kDistWinstonCones) ) * kDistWinstonCones
+   */
+  double dFocus = kDistMirror + kFocPlaneRoque;
+  double dCorrection2 = (dMirrorRadius / (dFocus - dHeightMirror - kDistWinstonCones) ) * kDistWinstonCones;
+
+        return ( (dCorrection1 + dCorrection2) / 2.0 );
+}
+
+/** No descriptions */
+void AMCMirrorPanel::calcSteps( double p_dX, double p_dY, int& p_iStepsX, int& p_iStepsY )
+{
+        double dX = p_dX;
+        double dY = p_dY;
+        if( m_zReversed )
+        {
+                dX = p_dY;
+                dY = p_dX;
+        }
+//      qDebug("Dx Dy: %4.0f %4.0f", dX, dY );  
+
+        double dAlpha1 = atan( getSlopeX() );
+        double dAlpha2 = atan( getSlopeY() );
+//      qDebug("alpha1, alpha2: %7.2f %7.2f", dAlpha1 * 180.0 / 3.1415, dAlpha2 * 180.0 / 3.1415 );     
+
+        double dSinA1 = sin( dAlpha1 );
+        double dSinA2 = sin( dAlpha2 );
+        double dCosA1 = cos( dAlpha1 );
+        double dCosA2 = cos( dAlpha2 );
+
+        double dFacX = dX - ( dY * dCosA2 / dSinA2 );
+        dFacX /= ( dCosA1 - dSinA1 * dCosA2 / dSinA2 );
+        double dFacY = ( dY - dFacX * dSinA1 ) / dSinA2;
+//      qDebug("Factor x,y: %8.2f %8.2f", dFacX, dFacY );       
+
+        if( m_zReversed )
+        {
+                p_iStepsY = (int) ( dFacY * getConversionY() );
+                p_iStepsX = (int) ( dFacX * getConversionX() );
+        }
+        else
+        {
+                p_iStepsX = (int) ( dFacX * getConversionX() );
+                p_iStepsY = (int) ( dFacY * getConversionY() );
+        }
+
+  // convert number of steps to an even number
+        p_iStepsX = (p_iStepsX >> 1) << 1;
+        p_iStepsY = (p_iStepsY >> 1) << 1;
+}
+
+/**
+ * Get the Reference position corrected for the errors introduced by trying
+ * to focus with the roque lamp at a finite distance nad using the wrong
+ * plane for the focusing procedure
+ */
+void AMCMirrorPanel::getCorrectedRef( double& p_dRefX, double& p_dRefY )
+{
+        const double  kPixelperMMX = 0.44;
+        const double  kPixelperMMY = 0.44;
+
+        p_dRefX = getLaserX();
+        p_dRefY = getLaserY();
+        qDebug( "Laser spot position befor applying correction:   %f %f", p_dRefX, p_dRefY );
+
+  double dCorrection = calcCorrection();
+        /*
+         * The angle zeta is the angle of the mirror panel relative to the mirror center.
+         * 0 degrees corresponds to panels (0,x) with x being a positve number.
+         * The other angles are definedclockwise (positive) if looking onto the
+         * mirror plane from the camera.
+         */
+        double dZeta = atan2( m_i * 1000.0, m_j * 1000.0 );
+
+        /*      
+         * We assumethat the video camera is horizontally alligned with mirror dish.
+         * If we have a rotation of the video image in respect to the mirror frame we
+         * must add an extra correction here.
+         * As the coordinate system of the video image has a reversed Y axis ( 0rign being
+         * the upper left corner) we have to multiply the Y correction with -1. to get the right
+         * sign.
+         */
+        double dCorrSpotX =        sin( dZeta ) * dCorrection;
+        double dCorrSpotY = -1.0 * cos( dZeta ) * dCorrection;
+
+        p_dRefX += dCorrSpotY * kPixelperMMX;
+        p_dRefY += dCorrSpotY * kPixelperMMY;
+        qDebug( "Laser spot position after applying correction:   %f %f", p_dRefX, p_dRefY );
+}

trunk/MagicSoft/AMC/activemirrorcontrol/activemirrorcontrol/amcmirrorpanel.h

@@ -44 +44 @@
         /** mark this panel as installed in the dish */
         void setInstalled( bool zInst) { m_zInstalled = zInst; }
+        /** query if this panel is reversed for the axis */
+        bool isReversed() const { return m_zReversed; }
+        /** mark this panel as reversed for the axis */
+        void setReversed( bool zRev) { m_zReversed = zRev; }
         /** query if laser is on */
         bool isLaserOn() const { return m_zLaserOn; }
@@ -69 +73 @@
         void setRefY( int p_iY ) { m_iRefY = p_iY; }
         /** get laser position X for reference position of motors */
-        int getLaserX() const { return m_iLaserX; }
+        double getLaserX() const { return m_dLaserX; }
         /** set laser position X for reference position of motors */
-        void setLaserX( int p_iX ) { m_iLaserX = p_iX; }
+        void setLaserX( double p_dX ) { m_dLaserX = p_dX; }
         /** get laser position Y for reference position of motors */
-        int getLaserY() const { return m_iLaserY; }
+        double getLaserY() const { return m_dLaserY; }
         /** set laser position Y for reference position of motors */
-        void setLaserY( int p_iY ) { m_iLaserY = p_iY; }
+        void setLaserY( double p_dY ) { m_dLaserY = p_dY; }
         /** get laser position Y for reference position of motors */
         double getAxisX() const { return m_dAxisX; }
@@ -108 +112 @@
         /** set laser position Y for reference position of motors */
         void setStepsY( int p_iY ) { m_iStepsY = p_iY; }
+  /** Here we calculation a correction for the laser spot position.
+ */
+  double calcCorrection();
+  /** No descriptions */
+  void calcSteps( double p_dX, double p_dY, int& p_iStepsX, int& p_iStepsY );
+  /** No descriptions */
+  void getCorrectedRef( double& p_dRefX, double& p_dRefY );
 
 private: // Public attributes
@@ -118 +129 @@
         int m_iDriver;
         bool m_zInstalled;
+        bool m_zReversed;
         /** Hold information if laser is on */
         bool m_zLaserOn;
@@ -131 +143 @@
         int m_iRefY;
         /** Laser X position position for reference position. */
-        int m_iLaserX;
+        double m_dLaserX;
         /** Laser Y position position for reference position. */
-        int m_iLaserY;
+        double m_dLaserY;
         /** X axis of regression line for X motor. */
         double m_dAxisX;