AOloopControl.h

Go to the documentation of this file.

#include <stdint.h>
#include <stdio.h>
#include <time.h>

#include "AOloopControl/AOloopControl_AOcompute.h"
#include "AOloopControl/AOloopControl_aorun.h"              // AOLOOPCONF_WFSim
#include "AOloopControl_IOtools/AOloopControl_IOtools.h"
#include "AOloopControl/AOloopControl_dm.h"
#include "AOloopControl/AOloopControl_ProcessModeCoefficients.h"
#include "AOloopControl/AOloopControl_autotune.h"


#ifndef _AOLOOPCONTROL_H
#define _AOLOOPCONTROL_H





// OVERVIEW


// AOloopControl_var
// structure unique to specific process
// used for convenience to store process-specific values, for example image IDs

// AOLOOPCONTROL_CONF
// shared memory structure for sharing between processes and provide outside control and visibility




// PROCESSES
/*
 * AO loop can launch a number of processes
 *
 *
 *
 * All AO loop instances MUST start a AOloopControl_aorun() function call
 * FUNCTION: AOloopControl_aorun()
 * in file : AOloopControl_aorun.c
 * AOloopControl_aorun() -> AOcompute() -> Read_cam_frame()
 *
 *
 *
 *
 * FUNCTION: AOloopControl_ProcessModeCoefficients()
 * in file : AOloopControl_aorun.c
 *
 *
 *
 */






#define MAX_NUMBER_TIMER 100







// REAL TIME DATA LOGGING

//
// Real-time streams are updated once per loop iteration
// Realtime logging buffers are synchronized
// Two buffers are created for each stream to be logged
//
// Saving to disk is handled outside of cacao real-time
//


#define MAX_NUMBER_RTLOGSTREAM 20

#define RTSLOGindex_wfsim                  0
#define RTSLOGindex_imWFS0                 1
#define RTSLOGindex_imWFS1                 2
#define RTSLOGindex_imWFS2                 3
#define RTSLOGindex_modeval                4
#define RTSLOGindex_modeval_dm             5
#define RTSLOGindex_modeval_dm_corr        6
#define RTSLOGindex_modeval_dm_now         7
#define RTSLOGindex_modeval_dm_now_filt    8
#define RTSLOGindex_modevalPF              9
#define RTSLOGindex_modevalPFsync         10
#define RTSLOGindex_modevalPFres          11
#define RTSLOGindex_modeval_ol            12
#define RTSLOGindex_dmC                   13
#define RTSLOGindex_dmdisp                14



// Real-time streams use this struc to hold relevant info

//int   RTLOG_ON;                        // set to 1 to start logging all RT streams -> ensures synchronization
//int   RTstreamLOG_buff;                // Which buffer is currently being written (0 or 1)
//long  RTstreamLOG_frame;               // Which frame is to be written in buffer
//int   RTstreamLOG_buffSwitch;          // Goes to 1 when buffer switches. Goes back to zero on next iteration.

// For each stream, there are two data buffers and two timing buffers
// Buffer names:
//     aol%ld_<stream>_logbuff0
//     aol%ld_<stream>_logbuff1
//     aol%ld_<stream>_logbuffinfo0
//     aol%ld_<stream>_logbuffinfo1
//
// Timing buffer contains loop iteration, frame counter cnt0 and time stamps when entry is written
//

// ENABLES, ON and save are read/set up in AOloopControl_loadconfigure()

typedef struct
{
    int    active;                  // 1 if used
    char   name[100];               // stream name (excludes aol#_)
    int    ENABLE;                  // Is logging enabled ? This needs to be specified at startup, if set to zero, no RT logging will be performed
    int    INIT;                    // 1 if memory is initiated
    int    ON;                      // Is logging ON ?
    uint32_t    SIZE;                    // Max number of samples per buffer
    int    buffindex;               // which buffer (0 or 1)
    long   frameindex;              // frame index
    long   frameindexend0;          // last frame in buffer 0
    long   frameindexend1;          // last frame in buffer 1
    int    save;                    // 0: do not save, 1: save data+timing, 2: save timing only
    int    memcpToggle;             // 1 if file buffer #0 ready to be memcpied, 2 if file buffer #1 ready to be memcpied, 0 otherwise

    long   IDbuff;
    long   IDbuff0;                 // local identifier
    long   IDbuff1;                 // local identifier

    long   IDbuffinfo;
    long   IDbuffinfo0;             // local identifier
    long   IDbuffinfo1;             // local identifier

    float *srcptr;                  // source stream pointer
    long   IDsrc;                   // source ID

    char  *destptr;                 // destination pointer
    char  *destptr0;                // destination pointer 0
    char  *destptr1;                // destination pointer 1

    size_t memsize;                 // size of stream frame (byte)
    int    NBcubeSaved;             // Number of cubes to save, default = -1



    int    NBFileBuffer;            // Number of buffers per big file
    int    FileBuffer;              // File buffer index
    char   timestring[100];         // current timestring
    char   timestring0[100];        // timestring for file to be saved to

    int    tActive;                 // 1: save thread is active, 0 otherwise

} RTstreamLOG;









// LOGGING
//#define RT_LOGsize 30000



// logging
//static int loadcreateshm_log = 0; // 1 if results should be logged in ASCII file
//static FILE *loadcreateshm_fplog;










typedef struct
{

    char name[80]; // AO loop name


    // These structures are always part of AO loop control (not optional)

    // High level AO loop parameters and variables
    // includes both status and some top level control (gain, mult, max)
    AOLOOPCONF_aorun
    aorun;                // defined in AOloopControl_aorun.h

    // Wavefront sensor image
    AOLOOPCONF_WFSim
    WFSim;                // defined in AOloopControl_aorun.h

    // AO loop timing parameters
    AOloopTimingInfo
    AOtiminginfo;         // defined in AOloopControl_aorun.h

    // Computation parameters
    AOLOOPCONF_AOcompute
    AOcompute;            // defined in AOloopControl_AOcompute.h

    // DM control
    AOLOOPCONF_DMctrl
    DMctrl;               // defined in AOloopControl_dm.h

    // Modal control
    AOLOOPCONF_ProcessModeCoefficients
    AOpmodecoeffs;        // defined in AOloopControl_ProcessModeCoefficients.h

    // Automatic loop tuning (experimental)
    AOLOOPCONF_AutoTune
    AOAutoTune;           // defined in AOloopControl_autotune.h


    // Realtime logging
    long
    RTLOGsize;                                     // Number of samples per shared memory stream
    RTstreamLOG                          RTSLOGarray[MAX_NUMBER_RTLOGSTREAM];


} AOLOOPCONTROL_CONF;















typedef struct
{
    /* =============================================================================================== */
    /*                    aoconfID are global variables for convenience                                */
    /*  These variables are LOCAL to each process, and not shared between processes                    */
    /*  aoconfID can be used in other modules as well (with extern)                                    */
    /* =============================================================================================== */

    long LOOPNUMBER;// = 0; // current loop index

    // TIMING
    //struct timespec tnow; //static
    //struct timespec tdiff; //static
    //double tdiffv; //static

    //int initWFSref_GPU[100];// = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    int initcontrMcact_GPU[100];// = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    //used in AOloopControl_loop_param.c
    // static

    float GPU_alpha;
    float GPU_beta;


    int AOloopcontrol_meminit;
    // local copies to avoid reset to zero by other process
    int_fast8_t init_RM_local;                      
    int_fast8_t init_CM_local;                      
    int_fast8_t
    init_CMc_local;                     
    int COMPUTE_PIXELSTREAMING; // static. multiple pixel groups
    int PIXSTREAM_NBSLICES;// number of image slices (= pixel groups)
    int PIXSTREAM_SLICE; // slice index 0 = all pixels


    // Logging REAL TIME data (internal logging)
    // (note: non real time streams are logged externally)
    //
    // To optimize logging speed, each stream can be logged in a 3D data cube within the function where it is created.
    // 3rd axis is time
    // A timing array is also created.
    //
    // List of REAL TIME streams logged with the internal process
    //
    //
    // wfsim              logged in function  ??
    // modeval_ol         logged in function  AOloopControl_ProcessModeCoefficients
    //



    //
    // Shared between REAL TIME STREAMS:
    //
    // streamLOG_buff                   which buffer to use (0 or 1)   -> in AOLOOPCONTROL_CONF (needs to be shared and visible)
    // streamLOG_frame                  frame index within buffer      -> in AOLOOPCONTROL_CONF (needs to be shared and visible)
    // streamLOG_saveToggle             1 to force a save now          -> in AOLOOPCONTROL_CONF (needs to be shared and visible)
    //
    //
    // For each REAL TIME stream <sname> :
    //
    // aoconfLOG_<sname>_databuffID0        logging data buffer 0 ID
    // aoconfLOG_<sname>_databuffID1        logging data buffer 1 ID
    // aoconfLOG_<sname>_infobuff0          logging info buffer 0
    // aoconfLOG_<sname>_infobuff1          logging info buffer 1
    // aoconfLOG_<sname>_databuffID         active data buffer ID
    // aoconfLOG_<sname>_infobuff           active info buffer pointer
    //
    // streamLOG_<sname>_ON  - NEEDS TO BE SET UP AT STARTUP           -> in AOLOOPCONTROL_CONF (needs to be shared and visible)
    //      0 : No logging, no writing into 3D cube
    //      1 : Create 3D cube and write into it
    // streamLOG_<sname>_save           1 if saved to disk             -> in AOLOOPCONTROL_CONF (needs to be shared and visible)





    // Hardware connections

    // WFS image
    long aoconfID_wfsim;                 // identifier to stream
    uint8_t WFSatype;

    /*LOG

        long aoconfLOG_wfsim_buffID0;        // buffer 0
        long aoconfLOG_wfsim_buffID1;        // buffer 1
        long aoconfLOG_wfsim_timerbuffID0;   // timer buffer 0
        long aoconfLOG_wfsim_timerbuffID1;   // timer buffer 1
        long aoconfLOG_wfsim_buffID;         // active buffer ID
        long aoconfLOG_wfsim_timerbuffID;    // active timer buffer ID
      */

    long aoconfID_dmC;
    long aoconfID_dmRM;





    long aoconfID_wfsdark;

    long aoconfID_imWFS0;        // identifier to stream

    long aoconfID_imWFS0tot;

    long aoconfID_imWFS1;

    long aoconfID_imWFS2;


    long aoconfID_imWFSlinlimit; // WFS linearity limit

    long aoconfID_wfsref0;
    long aoconfID_wfsref;
    long long aoconfcnt0_wfsref_current;

    long aoconfID_DMmodes;
    long aoconfID_dmdisp; // to notify DMcomb that DM maps should be summed



    // Control Modes
    long aoconfID_cmd_modes;
    long aoconfID_meas_modes; // measured
    long aoconfID_RMS_modes;
    long aoconfID_AVE_modes;
    long aoconfID_modeARPFgainAuto;
    long aoconfID_modevalPF;

    // mode gains, multf, limit are set in 3 tiers
    // global gain
    // block gain
    // individual gains

    // blocks
    long aoconfID_gainb; // block modal gains
    long aoconfID_multfb; // block modal gains
    long aoconfID_limitb; // block modal gains

    // individual modesaol0PFb1comp:
    long aoconfID_DMmode_GAIN;
    long aoconfID_LIMIT_modes;
    long aoconfID_MULTF_modes;

    long aoconfID_cmd_modesRM;

    long aoconfID_wfsmask;
    long aoconfID_dmmask;

    //long aoconfID_respM;//  = -1; static
    //only in loadconfigure.c

    long aoconfID_contrM;//   pixels -> modes

    //long long aoconfcnt0_contrM_current;//  = -1; static

    long aoconfID_contrMc;// combined control matrix: pixels -> DM actuators
    long aoconfID_meas_act;
    long aoconfID_contrMcact[100];

    //static
    // pixel streaming
    long aoconfID_pixstream_wfspixindex; // index of WFS pixels

    // timing
    long aoconfID_looptiming;// control loop timing data. Pixel values correspond to time offset
    // currently has 20 timing slots
    // beginning of iteration is defined when entering "wait for image"
    // md[0].atime.ts is absolute time at beginning of iteration
    //
    // pixel 0 is dt since last iteration
    //
    // pixel 1 is time from beginning of loop to status 01
    // pixel 2 is time from beginning of loop to status 02
    // ...
    long AOcontrolNBtimers;

    long aoconfIDlogdata;
    //long aoconfIDlog0;//  = -1; static
    //long aoconfIDlog1;//  = -1; static
    // those two last don't exist in any functions


    int *WFS_active_map; // used to map WFS pixels into active array
    int *DM_active_map; // used to map DM actuators into active array
    long aoconfID_meas_act_active;
    //long aoconfID_imWFS2_active[100]; wfs_dm.c & computeCalib.c

    float normfloorcoeff;//  = 1.0; static

    //long wfsrefcnt0;//  = -1; static
    //long contrMcactcnt0[100];// static = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};;
    //both in wfs_dm.c

    // variables used by functions

    //int GPUcntMax;//  = 100; static initmem.c
    int *GPUset0; //static
    int *GPUset1; //static



    // Realtime logging, local init flag
    // will be equal to 1 only if the current process "owns" the realtime logging
    int RTSLOGarrayInitFlag[MAX_NUMBER_RTLOGSTREAM];


} AOloopControl_var;






void __attribute__((constructor)) libinit_AOloopControl();


int AOloopControl_bogusfunc();

int AOloopControl_aorun_GUI(
    long loop,
    double frequ
);












/* =============================================================================================== */
/* =============================================================================================== */
float AOloopControl_readParam_float(char *paramname, float defaultValue,
                                    FILE *fplog);

int AOloopControl_readParam_int(char *paramname, int defaultValue, FILE *fplog);

char *AOloopControl_readParam_string(char *paramname, char *defaultValue,
                                     FILE *fplog);


/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */

errno_t AOloopControl_loadconfigure(long loop, int mode, int level);


errno_t AOloopControl_InitializeMemory(
    int mode
);


/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */

errno_t AOloopControl_WFSzpupdate_loop(
    const char *IDzpdm_name,
    const char *IDzrespM_name,
    const char *IDwfszp_name
);


errno_t AOloopControl_WFSzeropoint_sum_update_loop(
    long        loopnb,
    const char *ID_WFSzp_name,
    int         NBzp,
    const char *IDwfsref0_name,
    const char *IDwfsref_name
);

int AOloopControl_aorun_RUN(char *fpsname);
int AOloopControl_aorun_FPCONF(char *fpsname, uint32_t CMDmode);
errno_t AOloopControl_aorun();



errno_t ControlMatrixMultiply(float *cm_array, float *imarray, long m, long n,
                              float *outvect);

errno_t set_DM_modes(long loop);

errno_t set_DM_modesRM(long loop);

errno_t AOcompute(long loop, int normalize);

errno_t AOloopControl_CompModes_loop(const char *ID_CM_name,
                                     const char *ID_WFSref_name, const char *ID_WFSim_name,
                                     const char *ID_WFSimtot_name, const char *ID_coeff_name);

errno_t AOloopControl_GPUmodecoeffs2dm_filt_loop(const int GPUMATMULTCONFindex,
        const char *modecoeffs_name, const char *DMmodes_name, int semTrigg,
        const char *out_name, int GPUindex, long loop, int offloadMode);

long AOloopControl_sig2Modecoeff(const char *WFSim_name,
                                 const char *IDwfsref_name, const char *WFSmodes_name, const char *outname);

long AOloopControl_computeWFSresidualimage(long loop, char *IDalpha_name);

imageID __attribute__((hot)) AOloopControl_ProcessModeCoefficients(
    long loop
);

errno_t AOloopControl_AutoTuneGains(long loop, const char *IDout_name,
                                    float GainCoeff, long NBsamples);

long AOloopControl_dm2dm_offload(const char *streamin, const char *streamout,
                                 float twait, float offcoeff, float multcoeff);



/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */

errno_t AOloopControl_setLoopNumber(long loop);

errno_t AOloopControl_setparam(long loop, const char *key, double value);


/* =============================================================================================== */
/* =============================================================================================== */

errno_t AOloopControl_loopon();

errno_t AOloopControl_loopoff();

errno_t AOloopControl_loopWFScompon();

errno_t AOloopControl_loopWFScompoff();

errno_t AOloopControl_loopkill();

errno_t AOloopControl_loopstep(long loop, long NBstep);

errno_t AOloopControl_loopreset();


/* =============================================================================================== */
/* =============================================================================================== */

// NB : doesn't exist anywhere ??
errno_t AOloopControl_logon();

errno_t AOloopControl_logoff();


/* ============================================================================================================ */
/* ============================================================================================================ */

errno_t AOloopControl_DMprimaryWrite_on();

errno_t AOloopControl_DMprimaryWrite_off();

errno_t AOloopControl_DMfilteredWrite_on();

errno_t AOloopControl_DMfilteredWrite_off();


/* ====================================================================================================== */
/* ====================================================================================================== */

errno_t AOloopControl_AUTOTUNE_LIMITS_on();

errno_t AOloopControl_AUTOTUNE_LIMITS_off();

errno_t AOloopControl_set_AUTOTUNE_LIMITS_delta(float AUTOTUNE_LIMITS_delta);
errno_t AOloopControl_set_AUTOTUNE_LIMITS_perc(float AUTOTUNE_LIMITS_perc);
errno_t AOloopControl_set_AUTOTUNE_LIMITS_mcoeff(float AUTOTUNE_LIMITS_mcoeff);

errno_t AOloopControl_AUTOTUNE_GAINS_on();

errno_t AOloopControl_AUTOTUNE_GAINS_off();

/* ======================================================================================================== */
/* ======================================================================================================== */

errno_t AOloopControl_ARPFon();

errno_t AOloopControl_ARPFoff();

/* =================================================================================================== */
/* =================================================================================================== */

errno_t AOloopControl_set_loopfrequ(float loopfrequ);

errno_t AOloopControl_set_hardwlatency_frame(float hardwlatency_frame);

errno_t AOloopControl_set_complatency_frame(float complatency_frame);

errno_t AOloopControl_set_wfsmextrlatency_frame(float wfsmextrlatency_frame);

/* ========================================================================================================= */
/* ========================================================================================================= */

errno_t AOloopControl_setRTLOG_ON();
errno_t AOloopControl_setRTLOG_OFF();

errno_t AOloopControl_setgain(float gain);

errno_t AOloopControl_setARPFgain(float gain);


errno_t AOloopControl_setARPFgainAutoMin(float val);

errno_t AOloopControl_setARPFgainAutoMax(float val);


errno_t AOloopControl_setWFSnormfloor(float WFSnormfloor);

errno_t AOloopControl_setmaxlimit(float maxlimit);

errno_t AOloopControl_setmult(float multcoeff);

errno_t AOloopControl_setframesAve(long nbframes);

errno_t AOloopControl_set_modeblock_gain(long loop, long blocknb, float gain,
        int add);// modal blocks

errno_t AOloopControl_scanGainBlock(long NBblock, long NBstep, float gainStart,
                                    float gainEnd, long NBgain);



/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */

errno_t AOloopControl_OptimizePSF_LO(const char *psfstream_name,
                                     const char *IDmodes_name, const char *dmstream_name, long delayframe,
                                     long NBframes);

errno_t AOloopControl_DMmodulateAB(const char *IDprobeA_name,
                                   const char *IDprobeB_name, const char *IDdmstream_name,
                                   const char *IDrespmat_name, const char *IDwfsrefstream_name, double delay,
                                   long NBprobes);




/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */

errno_t AOloopControl_logprocess_modeval(
    const char *IDname
);

errno_t AOloopControl_TweakRM(
    char *ZRMinname,
    char *DMinCname,
    char *WFSinCname,
    char *DMmaskname,
    char *WFSmaskname,
    char *RMoutname
);





/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */

errno_t AOloopControl_RTstreamLOG_init(
    int loop
);


errno_t AOloopControl_RTstreamLOG_setup(
    long  loop,
    long  rtlindex,
    char *streamname
);

void AOloopControl_RTstreamLOG_update(
    long   loop,
    long   rtlindex,
    struct timespec tnow
);

int AOloopControl_RTstreamLOG_printstatus(
    int loop
);

int AOloopControl_RTstreamLOG_GUI(int loop);
int AOloopControl_RTstreamLOG_saveloop(int loop, char *dirname);

int AOloopControl_RTstreamLOG_set_saveON(int loop, int rtlindex);
int AOloopControl_RTstreamLOG_set_saveOFF(int loop, int rtlindex);
int AOloopControl_RTstreamLOG_set_ON(int loop, int rtlindex);
int AOloopControl_RTstreamLOG_set_OFF(int loop, int rtlindex);

/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */
/* =============================================================================================== */

// "old" blocks (somewhat obsolete)
errno_t AOloopControl_setgainrange(long m0, long m1, float gainval);
errno_t AOloopControl_setlimitrange(long m0, long m1, float limval);
errno_t AOloopControl_setmultfrange(long m0, long m1, float multfval);
errno_t AOloopControl_setgainblock(long mb, float gainval);
errno_t AOloopControl_setlimitblock(long mb, float limitval);
errno_t AOloopControl_setmultfblock(long mb, float multfval);

errno_t AOloopControl_AutoTune();



#endif