AOloopControl.h

Go to the documentation of this file.

#ifndef _AOLOOPCONTROL_H
#define _AOLOOPCONTROL_H






#define maxNBMB 100         // maximum number of mode blocks
#define MAXNBMODES 10000    // maximum number of control modes
#define MAX_NUMBER_TIMER 100


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




typedef struct
{   
    /* =============================================================================================== */
    float loopfrequ;                          
    // Hardware latency = time from DM command issued to WFS response changed 
    float hardwlatency;                       
    float hardwlatency_frame;                 
    // Computation time for direct WFS->DM mode through single matrix multiplication
    float complatency;                        
    float complatency_frame;                  
    // Computation time for full computation including open loop computation
    float wfsmextrlatency;                    
    float wfsmextrlatency_frame;              
    int_fast8_t status;                       
    int_fast8_t statusM;                      
    int_fast8_t statusM1;                     
    int_fast8_t GPUstatus[50];                
    uint_fast16_t NBtimer;                    
    struct timespec timer[MAX_NUMBER_TIMER];  
    /* =============================================================================================== */



    /* =============================================================================================== */
    int_fast8_t init;                         
    uint_fast64_t cnt;                        
    uint_fast64_t cntmax;                     
    uint_fast64_t DMupdatecnt;                
    int_fast8_t kill;                         
    char name[80];

    int_fast8_t init_RM;                      
    int_fast8_t init_CM;                      
    int_fast8_t init_CMc;                     
    int_fast8_t initmapping;
    char respMname[80];
    char contrMname[80];
  
    /* =============================================================================================== */



    /* =============================================================================================== */
    char WFSname[80];                        
    
    uint_fast32_t sizexWFS;                   
    uint_fast32_t sizeyWFS;                   
    uint_fast32_t sizeWFS;                    
    uint_fast32_t activeWFScnt;               
    uint_fast32_t sizeWFS_active[100];        
    uint_fast64_t WFScnt;                     
    uint_fast64_t WFScntRM;                   
    int_fast8_t WFSnormalize;                 
    float WFSnormfloor;                       
    float WFStotalflux;                       
    /* =============================================================================================== */



    /* =============================================================================================== */
    char dmCname[80];
    char dmdispname[80];
    char dmRMname[80];
    uint_fast8_t DMMODE;                      
    uint_fast32_t sizexDM;                    
    uint_fast32_t sizeyDM;                    
    uint_fast32_t sizeDM;                     
    uint_fast32_t activeDMcnt;                
    uint_fast32_t sizeDM_active;              
    /* =============================================================================================== */



    /* =============================================================================================== */
    char DMmodesname[80];
     // BLOCKS OF MODES
    uint_fast16_t DMmodesNBblock;             
    uint_fast16_t NBmodes_block[100];         
    uint_fast16_t modeBlockIndex[MAXNBMODES]; 
    uint_fast16_t indexmaxMB[maxNBMB]; 

    uint_fast16_t NBDMmodes;

    int_fast8_t init_wfsref0;    // WFS reference image loaded

    float maxlimit; // maximum absolute value for mode values
    float mult; // multiplication coefficient to be applied at each loop iteration
 
    /* =============================================================================================== */




    /* =============================================================================================== */
    int_fast8_t on;                           
    float gain;                               
    uint_fast16_t framesAve;                  
    int_fast8_t DMprimaryWriteON;             
    int_fast8_t CMMODE;                       
    int_fast8_t DMfilteredWriteON;            
    // MODAL AUTOTUNING 
    // limits
    int_fast8_t AUTOTUNE_LIMITS_ON;
    float AUTOTUNE_LIMITS_perc; // percentile limit for autotuning
    float AUTOTUNE_LIMITS_mcoeff; // multiplicative coeff 
    float AUTOTUNE_LIMITS_delta; // autotune loop increment 

    int_fast8_t AUTOTUNE_GAINS_ON;
    float AUTOTUNEGAINS_updateGainCoeff;      
    float AUTOTUNEGAINS_evolTimescale;        
    long AUTOTUNEGAINS_NBsamples;            
    /* =============================================================================================== */

 
 
    /* =============================================================================================== */
    int_fast8_t ARPFon; // 1 if auto-regressive predictive filter is ON
    float ARPFgain; 
    /* =============================================================================================== */



    /* =============================================================================================== */
    int_fast8_t GPU0; // NB of GPU devices in set 0. 1+ if matrix multiplication done by GPU (set 0)
    int_fast8_t GPU1; // NB of GPU devices in set 1. 1+ if matrix multiplication done by GPU (set 1)
    int_fast8_t GPU2; // NB of GPU devices in set 2. 1+ if matrix multiplication done by GPU (set 2)
    int_fast8_t GPU3; // NB of GPU devices in set 3. 1+ if matrix multiplication done by GPU (set 3)    
    int_fast8_t GPU4; // NB of GPU devices in set 4. 1+ if matrix multiplication done by GPU (set 4)
    int_fast8_t GPU5; // NB of GPU devices in set 5. 1+ if matrix multiplication done by GPU (set 5)
    int_fast8_t GPU6; // NB of GPU devices in set 6. 1+ if matrix multiplication done by GPU (set 6)
    int_fast8_t GPU7; // NB of GPU devices in set 7. 1+ if matrix multiplication done by GPU (set 7)
            
    int_fast8_t GPUall; // 1 if scaling computations done by GPU
    int_fast8_t GPUusesem; // 1 if using semaphores to control GPU
    int_fast8_t AOLCOMPUTE_TOTAL_ASYNC; // 1 if performing image total in separate thread (runs faster, but image total dates from last frame)
  
    /* =============================================================================================== */
    

    


    /* =============================================================================================== */
    // COMPUTED BY OPEN LOOP RETRIEVAL PROCESS
    double RMSmodes;
    double RMSmodesCumul;
    uint_fast64_t RMSmodesCumulcnt;

    // block statistics (instantaneous)
    double block_PFresrms[100]; // Prediction residual, meas RMS
    double block_OLrms[100]; // open loop RMS
    double block_Crms[100]; // correction RMS
    double block_WFSrms[100]; // WFS residual RMS
    double block_limFrac[100]; // fraction of mode coefficients exceeding limit
    
    double ALL_OLrms; // open loop RMS
    double ALL_Crms; // correction RMS
    double ALL_WFSrms; // WFS residual RMS
    double ALL_limFrac; // fraction of mode coefficients exceeding limit
    
    // averaged
    uint_fast32_t AveStats_NBpt; // averaging interval
    double blockave_PFresrms[100]; // open loop RMS
    double blockave_OLrms[100]; // open loop RMS
    double blockave_Crms[100]; // correction RMS
    double blockave_WFSrms[100]; // WFS residual RMS
    double blockave_limFrac[100]; // fraction of mode coefficients exceeding limit

    double ALLave_OLrms; // open loop RMS
    double ALLave_Crms; // correction RMS
    double ALLave_WFSrms; // WFS residual RMS
    double ALLave_limFrac; // fraction of mode coefficients exceeding limit

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

    // semaphores for communication with GPU computing threads
    //sem_t *semptr; // semaphore for this image

} AOLOOPCONTROL_CONF;

























int_fast8_t init_AOloopControl();







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


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


int_fast8_t AOloopControl_InitializeMemory();












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


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


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

int_fast8_t AOloopControl_run();


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

int_fast8_t set_DM_modes(long loop);

int_fast8_t set_DM_modesRM(long loop);

int_fast8_t AOcompute(long loop, int normalize);

int_fast8_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);

int_fast8_t AOloopControl_GPUmodecoeffs2dm_filt_loop(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);

long AOloopControl_ComputeOpenLoopModes(long loop);

int_fast8_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);






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

int_fast8_t AOloopControl_setLoopNumber(long loop);

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


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

int_fast8_t AOloopControl_loopon();

int_fast8_t AOloopControl_loopoff();

int_fast8_t AOloopControl_loopkill();

int_fast8_t AOloopControl_loopstep(long loop, long NBstep);

int_fast8_t AOloopControl_loopreset();


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

int_fast8_t AOloopControl_logon();

int_fast8_t AOloopControl_logoff();


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

int_fast8_t AOloopControl_DMprimaryWrite_on();

int_fast8_t AOloopControl_DMprimaryWrite_off();

int_fast8_t AOloopControl_DMfilteredWrite_on();

int_fast8_t AOloopControl_DMfilteredWrite_off();


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

int_fast8_t AOloopControl_AUTOTUNE_LIMITS_on();

int_fast8_t AOloopControl_AUTOTUNE_LIMITS_off();

int_fast8_t AOloopControl_set_AUTOTUNE_LIMITS_delta(float AUTOTUNE_LIMITS_delta);

int_fast8_t AOloopControl_set_AUTOTUNE_LIMITS_perc(float AUTOTUNE_LIMITS_perc);

int_fast8_t AOloopControl_set_AUTOTUNE_LIMITS_mcoeff(float AUTOTUNE_LIMITS_mcoeff);

int_fast8_t AOloopControl_AUTOTUNE_GAINS_on();

int_fast8_t AOloopControl_AUTOTUNE_GAINS_off();

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

int_fast8_t AOloopControl_ARPFon();

int_fast8_t AOloopControl_ARPFoff();

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

int_fast8_t AOloopControl_set_loopfrequ(float loopfrequ);

int_fast8_t AOloopControl_set_hardwlatency_frame(float hardwlatency_frame);

int_fast8_t AOloopControl_set_complatency_frame(float complatency_frame);

int_fast8_t AOloopControl_set_wfsmextrlatency_frame(float wfsmextrlatency_frame);

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

int_fast8_t AOloopControl_setgain(float gain);

int_fast8_t AOloopControl_setARPFgain(float gain);

int_fast8_t AOloopControl_setWFSnormfloor(float WFSnormfloor);

int_fast8_t AOloopControl_setmaxlimit(float maxlimit);

int_fast8_t AOloopControl_setmult(float multcoeff);

int_fast8_t AOloopControl_setframesAve(long nbframes);

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

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









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

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

int_fast8_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);




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

int_fast8_t AOloopControl_logprocess_modeval(const char *IDname);














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

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

int_fast8_t AOloopControl_AutoTune();



#endif