dmPokeXCorr.hpp

Go to the documentation of this file.

/** \file dmPokeXCorr.hpp
 * \brief The MagAO-X DM Poke Centering header file
 *
 * \ingroup dmPokeXCorr_files
 */
 
#ifndef dmPokeXCorr_hpp
#define dmPokeXCorr_hpp
 
#include <mx/improc/imageFilters.hpp>
#include <mx/improc/imageXCorrFFT.hpp>
using namespace mx::improc;
 
#include <mx/math/fit/fitGaussian.hpp>
 
#include "../../libMagAOX/libMagAOX.hpp" //Note this is included on command line to trigger pch
#include "../../magaox_git_version.h"
 
/** \defgroup dmPokeXCorr
 * \brief The MagAO-X application to center a DM pupil by poking actuators
 *
 * <a href="../handbook/operating/software/apps/dmPokeXCorr.html">Application Documentation</a>
 *
 * \ingroup apps
 *
 */
 
/** \defgroup dmPokeXCorr_files
 * \ingroup dmPokeXCorr
 */
 
namespace MagAOX
{
namespace app
{
 
struct zrespShmimT
{
    static std::string configSection()
    {
        return "zrespM";
    };
    static std::string indiPrefix()
    {
        return "zrespM";
    };
};
 
/// The MagAO-X DM to PWFS alignment Application
/**
 * \ingroup dmPokeXCorr
 */
class dmPokeXCorr : public MagAOXApp<true>,
                    public dev::dmPokeWFS<dmPokeXCorr>,
                    public dev::shmimMonitor<dmPokeXCorr, dev::dmPokeWFS<dmPokeXCorr>::wfsShmimT>,
                    public dev::shmimMonitor<dmPokeXCorr, dev::dmPokeWFS<dmPokeXCorr>::darkShmimT>,
                    public dev::shmimMonitor<dmPokeXCorr, zrespShmimT>,
                    public dev::telemeter<dmPokeXCorr>
{
    // Give the test harness access.
    friend class dmPokeXCorr_test;
 
    friend class dev::dmPokeWFS<dmPokeXCorr>;
 
    typedef dev::dmPokeWFS<dmPokeXCorr> dmPokeWFST;
 
    friend class dev::shmimMonitor<dmPokeXCorr, dev::dmPokeWFS<dmPokeXCorr>::wfsShmimT>;
 
    typedef dev::shmimMonitor<dmPokeXCorr, dev::dmPokeWFS<dmPokeXCorr>::wfsShmimT> shmimMonitorT;
 
    friend class dev::shmimMonitor<dmPokeXCorr, dev::dmPokeWFS<dmPokeXCorr>::darkShmimT>;
 
    typedef dev::shmimMonitor<dmPokeXCorr, dev::dmPokeWFS<dmPokeXCorr>::darkShmimT> darkShmimMonitorT;
 
    friend class dev::shmimMonitor<dmPokeXCorr, zrespShmimT>;
 
    typedef dev::shmimMonitor<dmPokeXCorr, zrespShmimT> zrespShmimMonitorT;
 
    friend class dev::telemeter<dmPokeXCorr>;
 
    typedef dev::telemeter<dmPokeXCorr> telemeterT;
 
  protected:
    /** \name Configurable Parameters
     *@{
     */
 
    std::string m_zRespMFile;
 
    ///@}
 
    mx::improc::imageXCorrFFT<eigenImage<float>> m_xcorr;
 
    mx::improc::milkImage<float> m_refIm;
 
  public:
    /// Default c'tor.
    dmPokeXCorr();
 
    /// D'tor, declared and defined for noexcept.
    ~dmPokeXCorr() noexcept
    {
    }
 
    /**\name MagAOX Interface
     *
     * @{
     */
    virtual void setupConfig();
 
    /// Implementation of loadConfig logic, separated for testing.
    /** This is called by loadConfig().
     */
    int loadConfigImpl(
        mx::app::appConfigurator &_config /**< [in] an application configuration from which to load values*/ );
 
    virtual void loadConfig();
 
    /// Startup function
    /**
     *
     */
    virtual int appStartup();
 
    /// Implementation of the FSM for dmPokeXCorr.
    /**
     * \returns 0 on no critical error
     * \returns -1 on an error requiring shutdown
     */
    virtual int appLogic();
 
    /// Shutdown the app.
    /**
     *
     */
    virtual int appShutdown();
 
    ///@}
 
    shmimMonitorT &shmimMonitor()
    {
        return *dynamic_cast<shmimMonitorT *>( this );
    }
 
    darkShmimMonitorT &darkShmimMonitor()
    {
        return *static_cast<darkShmimMonitorT *>( this );
    }
 
    /** \name zrespShmimMonitorT inteface
     * @{
     */
 
    int allocate( const zrespShmimT &dummy );
 
    int processImage( void *curr_src, const zrespShmimT &dummy );
 
    using dmPokeWFST::allocate;
 
    using dmPokeWFST::processImage;
 
    ///@}
 
    /** \name dmPokeWFS Interface
     * @{
     */
 
    /// Run the sensor steps
    /** Coordinates the actions of poking and collecting images.
     * Upon completion this calls runSensor.  If \p firstRun == true, one time
     * actions such as taking a dark can be executed.
     *
     * \returns 0 on success
     * \returns < 0 on an error
     */
    int runSensor( bool firstRun /**< [in] flag indicating this is the first call.  triggers taking a dark if true.*/ );
 
    /// Analyze the poke image
    /** This analyzes the resulting poke image and reports the results.
     *
     * \returns 0 on success
     * \returns < 0 on an error
     */
    int analyzeSensor();
 
    ///@}
 
    /** \name INDI Interface
     * @{
     */
  protected:
    ///@}
 
    /** \name Telemeter Interface
     *
     * @{
     */
    int checkRecordTimes();
 
    ///@}
};
 
dmPokeXCorr::dmPokeXCorr() : MagAOXApp( MAGAOX_CURRENT_SHA1, MAGAOX_REPO_MODIFIED )
{
    darkShmimMonitorT::m_getExistingFirst  = true;
    zrespShmimMonitorT::m_getExistingFirst = true;
 
    return;
}
 
void dmPokeXCorr::setupConfig()
{
    DMPOKEWFS_SETUP_CONFIG( config );
 
    SHMIMMONITORT_SETUP_CONFIG( zrespShmimMonitorT, config );
 
    TELEMETER_SETUP_CONFIG( config );
}
 
int dmPokeXCorr::loadConfigImpl( mx::app::appConfigurator &_config )
{
    DMPOKEWFS_LOAD_CONFIG( _config );
 
    SHMIMMONITORT_LOAD_CONFIG( zrespShmimMonitorT, _config );
 
    TELEMETER_LOAD_CONFIG( _config );
 
    return 0;
}
 
void dmPokeXCorr::loadConfig()
{
    if( loadConfigImpl( config ) < 0 )
    {
        m_shutdown = true;
    }
}
 
int dmPokeXCorr::appStartup()
{
    DMPOKEWFS_APP_STARTUP;
 
    SHMIMMONITORT_APP_STARTUP( zrespShmimMonitorT );
 
    TELEMETER_APP_STARTUP;
 
    // Gotta connect to the DM stream to find out its size
    mx::improc::milkImage<float> mdm;
    try
    {
        mdm.open( m_dmChan );
    }
    catch( const std::exception &e ) // this can check for invalid_argument and distinguish not existing
    {
        return log<software_error, -1>( { __FILE__, __LINE__, std::string( "exception opening DM: " ) + e.what() } );
    }
 
    state( stateCodes::READY );
 
    return 0;
}
 
int dmPokeXCorr::appLogic()
{
    DMPOKEWFS_APP_LOGIC;
 
    SHMIMMONITORT_APP_LOGIC( zrespShmimMonitorT );
    SHMIMMONITORT_UPDATE_INDI( zrespShmimMonitorT );
    SHMIMMONITORT_UPDATE_INDI( shmimMonitorT );
    SHMIMMONITORT_UPDATE_INDI( darkShmimMonitorT );
 
    TELEMETER_APP_LOGIC;
 
    return 0;
}
 
int dmPokeXCorr::appShutdown()
{
    DMPOKEWFS_APP_SHUTDOWN;
 
    SHMIMMONITORT_APP_SHUTDOWN( zrespShmimMonitorT );
 
    TELEMETER_APP_SHUTDOWN;
 
    return 0;
}
 
int dmPokeXCorr::allocate( const zrespShmimT &dummy )
{
    static_cast<void>( dummy );
 
    if( m_refIm.rows() != zrespShmimMonitorT::m_width || m_refIm.cols() != zrespShmimMonitorT::m_height )
    {
        m_refIm.create( m_configName + "_refIm", zrespShmimMonitorT::m_width, zrespShmimMonitorT::m_height );
    }
 
    return 0;
}
 
int dmPokeXCorr::processImage( void *curr_src, const zrespShmimT &dummy )
{
    static_cast<void>( dummy );
 
    // Gotta connect to the DM stream to find out its size
    // can't assume that we have connected anywhere else.
    mx::improc::milkImage<float> mdm;
    try
    {
        mdm.open( m_dmChan );
    }
    catch( const std::exception &e )
    {
        return log<software_error, -1>( { __FILE__, __LINE__, std::string( "exception opening DM: " ) + e.what() } );
    }
 
    mx::improc::eigenCube<float> zRespM(
        (float *)curr_src, zrespShmimMonitorT::m_width, zrespShmimMonitorT::m_height, zrespShmimMonitorT::m_depth );
 
    mx::improc::eigenImage<float> refIm;
    refIm.resize( zRespM.rows(), zRespM.cols() );
    refIm.setZero();
 
    for( size_t n = 0; n < m_poke_x.size(); ++n )
    {
        int actno = m_poke_y[n] * mdm.rows() + m_poke_x[n];
 
        refIm += zRespM.image( actno );
    }
 
    m_refIm = refIm;
 
    std::cerr << "Got reference: " << refIm.rows() << " x " << refIm.cols() << '\n';
    try
    {
        m_xcorr.peakMethod( xcorrPeakMethod::mftOversamp );
        m_xcorr.normalize( true );
        m_xcorr.maxLag( 10 );
        m_xcorr.tol( 0.001 );
 
        m_xcorr.refIm( refIm, 1 );
 
    }
    catch( const std::exception &e )
    {
        return log<software_error, -1>( { __FILE__, __LINE__, std::string( "exception caught: \n" ) + e.what() } );
    }
    return 0;
}
 
int dmPokeXCorr::runSensor( bool firstRun )
{
    static_cast<void>( firstRun );
 
    int rv = dmPokeWFST::basicRunSensor();
 
    if( rv > 0 )
    {
        return 0;
    }
    else if( rv < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return rv;
    }
 
    return 0;
}
 
int dmPokeXCorr::analyzeSensor()
{
    if( m_xcorr.refIm().rows() != m_pokeImage().rows() || m_xcorr.refIm().cols() != m_pokeImage().cols() )
    {
        std::cerr << "refIm:  " << m_xcorr.refIm().rows() << " x " << m_xcorr.refIm().cols() << '\n';
        std::cerr << "pokeIm: " << m_pokeImage().rows() << " x " << m_pokeImage().cols() << '\n';
        return log<software_error, -1>( { __FILE__, __LINE__, "reference is not valid" } );
    }
 
    float xs, ys;
 
    try
    {
        m_xcorr( xs, ys, m_pokeImage() );
    }
    catch( const std::exception &e )
    {
        return log<software_error, -1>( { __FILE__, __LINE__, std::string( "exception caught: \n" ) + e.what() } );
    }
 
    std::cerr.precision( 5 );
    std::cerr << "dmPokeXCorr::analyzeSensor: " << xs << " " << ys << "\n";
 
    if( updateMeasurement( xs, ys ) < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__, "error from dmPokeWFS::updateMeasurement" } );
    }
 
    return 0;
}
 
int dmPokeXCorr::checkRecordTimes()
{
    return telemeterT::checkRecordTimes( telem_pokeloop() );
}
 
} // namespace app
} // namespace MagAOX
 
#endif // dmPokeXCorr_hpp