sranger_hwi_eventhandling.C

Go to the documentation of this file.

/* Gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 * 
 * Copyright (C) 1999,2000,2001,2002,2003 Percy Zahl
 *
 * Authors: Percy Zahl <zahl@users.sf.net>
 * additional features: Andreas Klust <klust@users.sf.net>
 * WWW Home: http://gxsm.sf.net
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 */

/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 8 c-style: "K&R" -*- */

/* ignore this module for docuscan
% PlugInModuleIgnore
*/



#include <locale.h>
#include <libintl.h>

#include <time.h>

#include "glbvars.h"
#include "plug-ins/hard/modules/dsp.h"
#include <fcntl.h>
#include <sys/ioctl.h>

#include "gxsm/action_id.h"

#include "dsp-pci32/xsm/xsmcmd.h"

#include "sranger_hwi_control.h"
#include "sranger_hwi.h"
#include "gtkspinbuttonsci.h"
#include "../plug-ins/hard/modules/sranger_ioctl.h"

#define UTF8_DEGREE    "\302\260"
#define UTF8_MU        "\302\265"
#define UTF8_ANGSTROEM "\303\205"

#define CONV_16(X) X = sranger_hwi_hardware->int_2_sranger_int (X)
#define CONV_32(X) X = sranger_hwi_hardware->long_2_sranger_long (X)

extern GxsmPlugin sranger_hwi_pi;
extern sranger_hwi_dev *sranger_hwi_hardware;

// SR specific conversions and lookups

#define SRV2     (2.05/32767.)
#define SRV10    (10.0/32767.)
#define PhaseFac (1./16.)
#define BiasFac  (gapp->xsm->Inst->Dig2VoltOut (1.) / gapp->xsm->Inst->BiasV2V (1.))
#define ZAngFac  (gapp->xsm->Inst->Dig2ZA (1))
#define XAngFac  (gapp->xsm->Inst->Dig2XA (1))
#define YAngFac  (gapp->xsm->Inst->Dig2YA (1))

#define MAX_NUM_CHANNELS 25

static int   msklookup[] = { 0x0000020, 0x0000040, 0x0000080, 0x0000100, 0x0000200, 0x0000010, 0x0000400, 0, 
                             0x0000001, 0x0000002, 
                             0x0000800, 0x0001000, 0x0002000, 0x0004000, 0x0008000,
                             0x0100000, 0x0200000, 0x0400000, 0x0800000, 0x1000000, 0x2000000, 0x4000000,
                             -1 
};

static int   expdi_lookup[] = { PROBEDATA_ARRAY_AIC0, PROBEDATA_ARRAY_AIC1, PROBEDATA_ARRAY_AIC2, PROBEDATA_ARRAY_AIC3,
                                PROBEDATA_ARRAY_AIC4, PROBEDATA_ARRAY_AIC5_FBS, PROBEDATA_ARRAY_AIC6, PROBEDATA_ARRAY_AIC7,
                                PROBEDATA_ARRAY_AIC5OUT_ZMON, PROBEDATA_ARRAY_AIC6OUT_UMON, 
                                PROBEDATA_ARRAY_LCK0, PROBEDATA_ARRAY_LCK1A, PROBEDATA_ARRAY_LCK1B, PROBEDATA_ARRAY_LCK2A, PROBEDATA_ARRAY_LCK2B,
                                PROBEDATA_ARRAY_TIME, PROBEDATA_ARRAY_XS, PROBEDATA_ARRAY_YS, PROBEDATA_ARRAY_ZS,  PROBEDATA_ARRAY_U, PROBEDATA_ARRAY_PHI,
                                PROBEDATA_ARRAY_SEC,
                                0
};

static char* lablookup[]  = { "ADC0", "ADC1", "ADC2", "ADC3", "ADC4", "ADC5-I","ADC6","ADC7",
                              "Zmon", "Umon", 
                              "LockIn0", "LockIn1stA", "LockIn1stB", "LockIn2ndA", "LockIn2ndB",
                              "Time", "XS",   "YS",   "ZS",   "Bias", "Phase", "VP-Section",
                              NULL
};

static char* unitlookup[] = { "V",   "V",    "V",    "V",    "V",    "V",     "V",   "V",
                              UTF8_ANGSTROEM,   "V",    
                              "V", "dV", "dV",  "ddV", "ddV",
                              "ms", UTF8_ANGSTROEM, UTF8_ANGSTROEM, UTF8_ANGSTROEM, "V", "deg", "#",
                              NULL
};



int DSPControl::Probing_eventcheck_callback( GtkWidget *widget, DSPControl *dspc){
        static int warm=FALSE;
        static ProfileControl *pc[MAX_NUM_CHANNELS][MAX_NUM_CHANNELS];
        int popped=0;
        GArray **garr;
        double DAC2Ulookup[]={ SRV10, SRV10,  SRV10,  SRV10,  SRV10,  SRV10,   SRV10,  SRV10,
                               ZAngFac, BiasFac, SRV10,  SRV10,  SRV10, SRV10,  SRV10,  
                               1e3/dspc->frq_ref, XAngFac, YAngFac, ZAngFac, BiasFac, PhaseFac, 1.,
                               0.
        };

        // initialize only once, reuse later
        if (!warm){
                for (int i=0; i<MAX_NUM_CHANNELS; ++i)
                        for (int j=0; j<MAX_NUM_CHANNELS; ++j)
                                pc[i][j]=NULL;
                warm=TRUE;
        }

        // pop off all available data from stack
        while ((garr = dspc->pop_probedata_arrays ()) != NULL){
                ++popped;
                
// atach event to active channel, if one exists -- raster mode ------------------------------

                ScanEvent *se = NULL;
                if (gapp->xsm->ActiveScan){
                        // find first section header and take this X,Y coordinates as reference -- start of probe event
                        int sec = 0;
                        for (int j=0; j<dspc->last_probe_data_index; ++j){
                                int s = (int) g_array_index (garr [PROBEDATA_ARRAY_SEC], double, j);
                                if (s < (sec-1)) 
                                        sec = s;
                                if (s >= sec || j == dspc->last_probe_data_index-1 || j == 0){
                                        sec = s+1;
                                } else
                                        continue;
                                
                                se = new ScanEvent (
                                        gapp->xsm->Inst->Dig2XA ((long) round (
                                                       g_array_index (garr [PROBEDATA_ARRAY_X0], double, j)
                                                     + g_array_index (garr [PROBEDATA_ARRAY_XS], double, j))
                                                ),
                                        gapp->xsm->Inst->Dig2YA ((long) round (
                                                       g_array_index (garr [PROBEDATA_ARRAY_Y0], double, j)
                                                     + g_array_index (garr [PROBEDATA_ARRAY_YS], double, j))
                                                ),
                                        gapp->xsm->Inst->Dig2ZA ((long) round (
//                                                     g_array_index (garr [PROBEDATA_ARRAY_Z0], double, j)
                                                       0.
                                                     + g_array_index (garr [PROBEDATA_ARRAY_ZS], double, j))
                                                )
                                        );
                                gapp->xsm->ActiveScan->mem2d->AttachScanEvent (se);
                                break;
                        }
                }

                // if we have attached an scan event, so fill it with data now
                if (se){
                        // find chunksize (total # data sources)
                        int chunksize = 0;
                        GPtrArray *glabarray = g_ptr_array_new ();
                        GPtrArray *gsymarray = g_ptr_array_new ();

                        for (int src=0; msklookup[src]>=0 && src < MAX_NUM_CHANNELS; ++src)
                                if (dspc->Source & msklookup[src]){
                                        g_ptr_array_add (glabarray, (gpointer) lablookup[src]);
                                        g_ptr_array_add (gsymarray, (gpointer) unitlookup[src]);
                                        ++chunksize;
                                }
                
                        if (chunksize > 0 && chunksize < MAX_NUM_CHANNELS){
                                double dataset[MAX_NUM_CHANNELS];
                                ProbeEntry *pe = new ProbeEntry ("Probe", time(0), glabarray, gsymarray, chunksize);
                                for (int i = 0; i < dspc->last_probe_data_index; i++){
                                        int j=0;
                                        for (int src=0; msklookup[src]>=0 && src < MAX_NUM_CHANNELS; ++src){
                                                if (dspc->Source & msklookup[src])
                                                        dataset[j++] = DAC2Ulookup[src] * g_array_index (garr [expdi_lookup[src]], double, i);
                                        }
                                        pe->add ((double*)&dataset);
                                }
                                se->add_event (pe);
                        }
                }

// on-the-fly visualisation graphs update ------------------------------

                if (dspc->raster_auto_flags & FLAG_AUTO_PLOT){

                        for (int xmap=0; msklookup[xmap]>=0; ++xmap){
                                if ((dspc->XSource & msklookup[xmap]) && (dspc->Source & msklookup[xmap]))
                                        for (int src=0; msklookup[src]>=0; ++src){
                                                if ((dspc->PSource & msklookup[src]) && (dspc->Source & msklookup[src])){

                                                        UnitObj *UXaxis = new UnitObj(unitlookup[xmap], " ", "g", lablookup[xmap]);
                                                        UnitObj *UYaxis = new UnitObj(unitlookup[src],  " ", "g", lablookup[src]);
                                                        double xmult = DAC2Ulookup[xmap];
                                                        double ymult = DAC2Ulookup[src];
                                                        double xmin, xmax, x;

                                                        // find min and max X limit
                                                        xmin = xmax = xmult * g_array_index (garr [expdi_lookup[xmap]], double, 0);
                                                        for(int i = 1; i < dspc->last_probe_data_index; i++){
                                                                x = xmult * g_array_index (garr [expdi_lookup[xmap]], double, i);
                                                                if (x > xmax) xmax = x;
                                                                if (x < xmin) xmin = x;
                                                        }

                                                        UXaxis->SetAlias (lablookup[xmap]);
                                                        UYaxis->SetAlias (lablookup[src]);
                                                        if (!pc[xmap][src]){
                                                                gchar   *title  = g_strdup_printf ("Raster Vector Probe, Channel: %s", lablookup[src]);
                                                                pc[xmap][src] = new ProfileControl (title, 
                                                                                                    dspc->last_probe_data_index, 
                                                                                                    UXaxis, UYaxis, 
                                                                                                    xmin, xmax,
                                                                                                    lablookup[src]);
                                                                g_free (title);
                                                        } else {
                                                                pc[xmap][src]->scan1d->mem2d->Resize (dspc->last_probe_data_index, 1);
                                                                pc[xmap][src]->SetXrange (xmin, xmax);
                                                        }
                        
                                                        for(int i = 0; i < dspc->last_probe_data_index; i++){
                                                                pc[xmap][src]->SetPoint (i, 
                                                                                         xmult * g_array_index (garr [expdi_lookup[xmap]], double, i),
                                                                                         ymult * g_array_index (garr [expdi_lookup[src]], double, i));
                                                        }
                                                        sranger_hwi_pi.app->xsm->AddProfile (pc[xmap][src]); // give it to Surface, it takes care about removing it...
        
                                                        pc[xmap][src]->drawScans ();
                                                        pc[xmap][src]->UpdateArea ();
                                                        pc[xmap][src]->show ();
//                                      pc[xmap][src]->unref (); // nothing depends on it, so decrement refcount
//                                      pc[xmap][src] = NULL; // get rid of it now
                                                }
                                        }
                        }
                }
                
                free_probedata_array_set (garr, dspc);  
        }

        if (popped > 0)
                if (gapp->xsm->ActiveScan)
                        gapp->xsm->ActiveScan->view->update_events ();

        return 0;
}

int DSPControl::Probing_graph_callback( GtkWidget *widget, DSPControl *dspc){
// show and update data pv graph
        static int warm=FALSE;
        static ProfileControl *pc[MAX_NUM_CHANNELS][MAX_NUM_CHANNELS];
        
        if (!warm){
                for (int i=0; i<MAX_NUM_CHANNELS; ++i)
                        for (int j=0; j<MAX_NUM_CHANNELS; ++j)
                                pc[i][j]=NULL;
                warm=TRUE;
        }

        if (!dspc->current_probe_data_index) 
                return 0;
        

        double DAC2Ulookup[]={ SRV10, SRV10,  SRV10,  SRV10,  SRV10,  SRV10,   SRV10,  SRV10,
                               ZAngFac, BiasFac, SRV10,  SRV10,  SRV10, SRV10,  SRV10,  
                               1e3/dspc->frq_ref, XAngFac, YAngFac, ZAngFac, BiasFac, PhaseFac, 1.,
                               0.
        };
                

//xxxxxxxxxxxxx atach event to active channel, if one exists -- manual mode xxxxxxxxxxxxxxxxxxxxx
        ScanEvent *se = NULL;
        if (gapp->xsm->ActiveScan){
                // find first section header and take this X,Y coordinates as reference -- start of probe event
                int sec = 0;
                for (int j=0; j<dspc->current_probe_data_index; ++j){
                        int s = (int) g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_SEC], double, j);
                        if (s < (sec-1)) 
                                sec = s;
                        if (s >= sec || j == dspc->current_probe_data_index-1 || j == 0)
                                sec = s+1;
                        else
                                continue;
                        

//                      se = new ScanEvent (
//                              gapp->xsm->data.s.x0 + gapp->xsm->Inst->Dig2XA ((int)g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_XS], double, j)),
//                              gapp->xsm->data.s.y0 + gapp->xsm->Inst->Dig2YA ((int)g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_YS], double, j))
//                              );

                        se = new ScanEvent (
                                gapp->xsm->Inst->Dig2XA ((long) round (
                                                                 g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_X0], double, j)
                                                                 + g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_XS], double, j))
                                        ),
                                gapp->xsm->Inst->Dig2YA ((long) round (
                                                                 g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_Y0], double, j)
                                                                 + g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_YS], double, j))
                                        ),
                                gapp->xsm->Inst->Dig2ZA ((long) round (
//                                                               g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_Z0], double, j)
                                                                 0.
                                                                 + g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_ZS], double, j))
                                        )
                                );
                        gapp->xsm->ActiveScan->mem2d->AttachScanEvent (se);
                        break;
                }
        }

        // if we have attached an scan event, so fill it with data now
        if (se){
                // find chunksize (total # data sources)
                int chunksize = 0;
                GPtrArray *glabarray = g_ptr_array_new ();
                GPtrArray *gsymarray = g_ptr_array_new ();

                for (int src=0; msklookup[src]>=0 && src < MAX_NUM_CHANNELS; ++src)
                        if (dspc->Source & msklookup[src]){
                                g_ptr_array_add (glabarray, (gpointer) lablookup[src]);
                                g_ptr_array_add (gsymarray, (gpointer) unitlookup[src]);
                                ++chunksize;
                        }
                
                if (chunksize > 0 && chunksize < MAX_NUM_CHANNELS){
                        double dataset[MAX_NUM_CHANNELS];
                        ProbeEntry *pe = new ProbeEntry ("Probe", time(0), glabarray, gsymarray, chunksize);
                        for (int i = 0; i < dspc->current_probe_data_index; i++){
                                int j=0;
                                for (int src=0; msklookup[src]>=0 && src < MAX_NUM_CHANNELS; ++src){
                                        if (dspc->Source & msklookup[src])
                                                dataset[j++] = DAC2Ulookup[src] * g_array_index (dspc->garray_probedata [expdi_lookup[src]], double, i);
                                }
                                pe->add ((double*)&dataset);
                        }
                        se->add_event (pe);
                }
                gapp->xsm->ActiveScan->view->update_events ();
        }

// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

// on-the-fly visualisation graphs update
        for (int xmap=0; msklookup[xmap]>=0; ++xmap){
                if ((dspc->XSource & msklookup[xmap]) && (dspc->Source & msklookup[xmap]))
                        for (int src=0; msklookup[src]>=0; ++src){
                                if ((dspc->PSource & msklookup[src]) && (dspc->Source & msklookup[src])){

                                        UnitObj *UXaxis = new UnitObj(unitlookup[xmap], " ", "g", lablookup[xmap]);
                                        UnitObj *UYaxis = new UnitObj(unitlookup[src],  " ", "g", lablookup[src]);
                                        double xmult = DAC2Ulookup[xmap];
                                        double ymult = DAC2Ulookup[src];
                                        double xmin, xmax, x;

                                        // find min and max X limit
                                        xmin = xmax = xmult * g_array_index (dspc->garray_probedata [expdi_lookup[xmap]], double, 0);
                                        for(int i = 1; i < dspc->current_probe_data_index; i++){
                                                x = xmult * g_array_index (dspc->garray_probedata [expdi_lookup[xmap]], double, i);
                                                if (x > xmax) xmax = x;
                                                if (x < xmin) xmin = x;
                                        }

                                        UXaxis->SetAlias (lablookup[xmap]);
                                        UYaxis->SetAlias (lablookup[src]);
                                        if (!pc[xmap][src]){
                                                gchar   *title  = g_strdup_printf ("Vector Probe, Channel: %s", lablookup[src]);
                                                pc[xmap][src] = new ProfileControl (title, 
                                                                                    dspc->current_probe_data_index, 
                                                                                    UXaxis, UYaxis, 
                                                                                    xmin, xmax,
                                                                                    lablookup[src]);
                                                g_free (title);
                                        } else {
                                                pc[xmap][src]->scan1d->mem2d->Resize (dspc->current_probe_data_index, 1);
                                                pc[xmap][src]->SetXrange (xmin, xmax);
                                        }
//                                      std::cout << "SRPCP Xlimits: " << xmin << " :: " << xmax << std::endl;
                        
                                        for(int i = 0; i < dspc->current_probe_data_index; i++){
                                                pc[xmap][src]->SetPoint (i, 
                                                                         xmult * g_array_index (dspc->garray_probedata [expdi_lookup[xmap]], double, i),
                                                                         ymult * g_array_index (dspc->garray_probedata [expdi_lookup[src]], double, i));
                                        }
                                        sranger_hwi_pi.app->xsm->AddProfile (pc[xmap][src]); // give it to Surface, it takes care about removing it...
        
                                        pc[xmap][src]->drawScans ();
                                        pc[xmap][src]->UpdateArea ();
                                        pc[xmap][src]->show ();
//                                      pc[xmap][src]->unref (); // nothing depends on it, so decrement refcount
//                                      pc[xmap][src] = NULL; // get rid of it now
                                }
                        }
        }

        return 0;
}

void DSPControl::add_user_event_now (gchar* message, gint addflag){
        static  UserEntry *pe=NULL;

        if (!gapp->xsm->ActiveScan){
                pe=NULL;
                return;
        }

        if (pe && addflag){
                pe->add (message);
        } else {
                static ANALOG_VALUES    dsp_analog;
                lseek (sranger_hwi_hardware->dsp_alternative, sranger_hwi_hardware->magic_data.AIC_in, SRANGER_SEEK_DATA_SPACE);
                read  (sranger_hwi_hardware->dsp_alternative, &dsp_analog, sizeof (dsp_analog));

                // from DSP to PC
                CONV_16 (dsp_analog.x_scan);
                CONV_16 (dsp_analog.y_scan);
                CONV_16 (dsp_analog.z_scan);

                CONV_16 (dsp_analog.x_offset);
                CONV_16 (dsp_analog.y_offset);
                CONV_16 (dsp_analog.z_offset);

                double xy[3] = {
                        gapp->xsm->Inst->Dig2XA ((long) round (dsp_analog.x_scan + dsp_analog.x_offset)),
                        gapp->xsm->Inst->Dig2YA ((long) round (dsp_analog.y_scan + dsp_analog.y_offset)),
                        gapp->xsm->Inst->Dig2ZA ((long) round (dsp_analog.z_scan + dsp_analog.z_offset))
                };

                GSList *events_close_by = gapp->xsm->ActiveScan->mem2d->ReportScanEvents (NULL, NULL, xy);
                ScanEvent* se = NULL;
                if (events_close_by){
                        if (fabs (((ScanEvent*)(events_close_by->data))->distance (xy)) < 0.1) // if closer than 0.1A, take this to add!
                                se = (ScanEvent*)(events_close_by->data);
                        g_slist_free (events_close_by);
                }
                if (!se){
                        se = new ScanEvent (xy[0], xy[1], xy[2]);
                        gapp->xsm->ActiveScan->mem2d->AttachScanEvent (se);
                }
                UserEntry *pe = new UserEntry ("User", time(0));
                pe->add (message);
                se->add_event (pe);
        }
        gapp->xsm->ActiveScan->view->update_events ();
}

int DSPControl::Probing_save_callback( GtkWidget *widget, DSPControl *dspc){
        int sec;
// show and update data pv graph
        if (!dspc->current_probe_data_index) 
                return 0;
        

        double DAC2Ulookup[]={ SRV10, SRV10,  SRV10,  SRV10,  SRV10,  SRV10,   SRV10,  SRV10,
                               ZAngFac, BiasFac, SRV10,  SRV10,  SRV10,   SRV10,  SRV10,   
                               1e3/dspc->frq_ref, XAngFac, YAngFac, ZAngFac, BiasFac, PhaseFac, 1.,
                               0.
        };
               
        gchar *separator = "\t";

        std::ofstream f;
        gchar *fntmp = g_strdup_printf ("%s%03d-%s.vpdata", gapp->xsm->data.ui.basename, ++gapp->xsm->counter, "VP");
        
        f.open (fntmp);

        f << "# GXSM Vector Probe Data :: VPVersion=00.01 vdate=20040117" << std::endl;
        f << "# Date                   :: date=" << "N/A" << std::endl;
        f << "# FileName               :: name=" << fntmp << std::endl;
        f << "# GXSM-Main-Offset       :: X0=" << gapp->xsm->data.s.x0 << " Ang" <<  "  Y0=" << gapp->xsm->data.s.y0 << " Ang" << std::endl;
        gchar *tmp = g_strdup(gapp->xsm->data.ui.comment);
        
        f << "# GXSM-Main-Comment      :: comment=\n\"" << tmp << "\"" << std::endl;
        g_free (tmp);
        f << "# Probe Data Number      :: N=" << dspc->current_probe_data_index << std::endl;
        f << "# Data Sources Mask      :: Source=" << dspc->Source << std::endl;
        f << "# X-map Sources Mask     :: XSource=" << dspc->XSource << std::endl;
        f << "#C " << std::endl;
        f << "#C VP Channel Map and Units lookup table used:=table [## msk expdi, lab, DAC2U, unit/DAC, Active]" << std::endl;

        for (int i=0; msklookup[i] >= 0; ++i)
                f << "# Cmap[" << i << "]" << separator 
                  << msklookup[i] << separator 
                  << expdi_lookup[i] << separator 
                  << lablookup[i] << separator 
                  << DAC2Ulookup[i] << separator 
                  << unitlookup[i] << "/DAC" << separator 
                  << (dspc->Source & msklookup[i] ? "Yes":"No") << std::endl;

        f << "#C " << std::endl;
        f << "#C Full Position Vector List at Section boundaries follows :: PositionVectorList" << std::endl;
        sec = 0;
        for (int j=0; j<dspc->current_probe_data_index; ++j){
                int s = (int) g_array_index (dspc->garray_probedata [PROBEDATA_ARRAY_SEC], double, j);
                if (s < (sec-1)) 
                        sec = s;
                if (s >= sec || j == dspc->current_probe_data_index-1 || j == 0){
                        f << "# S[" << s << "]  :: VP[" << j <<"]=(";
                        sec = s+1;
                } else
                        continue;

                for (int i=13; msklookup[i]>=0; ++i){
                        double ymult = DAC2Ulookup[i];
                        if (i>13) 
                                f << ", ";
                        f << " \"" << lablookup[i] << "\"="
                          << (ymult * g_array_index (dspc->garray_probedata [expdi_lookup[i]], double, j))
                          << " " << unitlookup[i];
                }
                f << ")" << std::endl;
        }

        f << "#C " << std::endl;
        f << "#C Data Table             :: data=" << std::endl;

        for (int i = -1; i < dspc->current_probe_data_index; i++){
                if (i == -1)
                        f << "#C Index" << separator;
                else
                        f << i << separator;

                for (int xmap=0; msklookup[xmap]>=0; ++xmap)
                        if ((dspc->XSource & msklookup[xmap]) && (dspc->Source & msklookup[xmap])){
                                double xmult = DAC2Ulookup[xmap];
                                if (i == -1)
                                        f << "\"" << lablookup[xmap] << " (" << unitlookup[xmap] << ")\"" << separator;
                                else
                                        f << (xmult * g_array_index (dspc->garray_probedata [expdi_lookup[xmap]], double, i)) << separator;
                        }

                for (int src=0; msklookup[src]>=0; ++src)
                        if (dspc->Source & msklookup[src]){
                                double ymult = DAC2Ulookup[src];
                                if (i == -1)
                                        f << "\"" << lablookup[src] << " (" << unitlookup[src] << ")\"" << separator;
                                else
                                        f << (ymult * g_array_index (dspc->garray_probedata [expdi_lookup[src]], double, i)) << separator;
                        }

                f << std::endl;
        }
        f << "#C " << std::endl;
        f << "#C END." << std::endl;
        f.close ();

        // update counter on main window!
        gapp->spm_update_all();
        gapp->SetStatus(N_("Saved VP data: "), fntmp);
        gchar *bbt = g_strdup_printf ("Save now - last: %s", fntmp);
        gtk_button_set_label (GTK_BUTTON (dspc->save_button), bbt);
        g_free (bbt);
        g_free (fntmp);

        
        return 0;
}



#define DEFAULT_PROBE_LEN 256 // can increase automatically, just more efficient

void DSPControl::push_probedata_arrays (){
        GArray **garr = new GArray*[NUM_PROBEDATA_ARRAYS];
        for (int i=0; i<NUM_PROBEDATA_ARRAYS; ++i){
                garr [i] = garray_probedata [i];
                garray_probedata [i] = g_array_sized_new (FALSE, TRUE, sizeof (double), DEFAULT_PROBE_LEN); // preallocated, can increase
        }
        probedata_list =  g_slist_prepend (probedata_list, garr); // push on list
        last_probe_data_index = current_probe_data_index;

        ++num_probe_events;
}

// return last dataset and removed it from list, does not touch data itself
GArray** DSPControl::pop_probedata_arrays (){
        if (probedata_list){
                GSList *last = g_slist_last (probedata_list);
                if (last){
                        GArray **garr = (GArray **) (last->data);
                        probedata_list = g_slist_delete_link (probedata_list, last);
                        return garr;
                }
        }
        return NULL;
}

void DSPControl::free_probedata_array_set (GArray** garr, DSPControl *dc){
        for (int i=0; i<NUM_PROBEDATA_ARRAYS; ++i)
                g_array_free (garr[i], TRUE);
}

void DSPControl::free_probedata_arrays (){
        if (!probedata_list) 
                return;
        g_slist_foreach (probedata_list, (GFunc) DSPControl::free_probedata_array_set, this);
        g_slist_free (probedata_list);
        probedata_list = NULL;  
        num_probe_events = 0;
}

void DSPControl::init_probedata_arrays (){
        for (int i=0; i<NUM_PROBEDATA_ARRAYS; ++i){
                if (!garray_probedata[i]){
                        garray_probedata [i] = g_array_sized_new (FALSE, TRUE, sizeof (double), DEFAULT_PROBE_LEN); // preallocated, can increase
                }
                else
                        g_array_set_size (garray_probedata [i], 0);
        }
        current_probe_data_index = 0;
        nun_valid_data_sections = 0;
}

void DSPControl::add_probedata(double data[13]){ 
        int i,j;
        for (i = PROBEDATA_ARRAY_AIC5OUT_ZMON, j=0; i <= PROBEDATA_ARRAY_LCK2B; ++i, ++j){
                if (i == PROBEDATA_ARRAY_AIC6){
                        double dummy=0.;
                        // skip AIC6,7
                        g_array_append_val (garray_probedata[i++], dummy);
                        g_array_append_val (garray_probedata[i++], dummy);
                }
                g_array_append_val (garray_probedata[i], data[j]);
        }

#ifdef TTY_DEBUG
        std::cout << "pvd[" << current_probe_data_index << "][M[zu]AIC[50123467]L[120]]: ";
        for (i = PROBEDATA_ARRAY_AIC5OUT_ZMON, j=0; i <= PROBEDATA_ARRAY_LCK2B; ++i, ++j)
                std::cout << data[j] << ", ";
        std::cout << std::endl;
#endif

        current_probe_data_index++;     
}

void DSPControl::add_probevector(){ 
        int i,j, sec;
        double ds, val, multi, fixptm;
        sec =  (int) (ds = g_array_index (garray_probedata [PROBEDATA_ARRAY_SEC], double, current_probe_data_index-1));
        g_array_append_val (garray_probedata [PROBEDATA_ARRAY_SEC], ds);
        g_array_append_val (garray_probedata [PROBEDATA_ARRAY_INDEX], current_probe_data_index);
        multi = dsp_vector_list[sec].dnx + 1;
        fixptm = 1./(1<<16);

#ifdef TTY_DEBUG
        std::cout << "+pv[" << current_probe_data_index << "] (m=" << multi << "): ";
#endif
        for (i = PROBEDATA_ARRAY_TIME, j=0; i < PROBEDATA_ARRAY_SEC; ++i, ++j){
                val = g_array_index (garray_probedata[i], double, current_probe_data_index-1);
                switch (i){
                case PROBEDATA_ARRAY_TIME:
                        val += multi;
                        break;
                case PROBEDATA_ARRAY_X0:
                        val += dsp_vector_list[sec].f_dx0*multi*fixptm;
                        break;
                case PROBEDATA_ARRAY_Y0:
                        val += dsp_vector_list[sec].f_dy0*multi*fixptm;
                        break;
                case PROBEDATA_ARRAY_PHI:
                        val += dsp_vector_list[sec].f_dphi*multi*fixptm;
                        break;
                case PROBEDATA_ARRAY_XS:
                        val -= dsp_vector_list[sec].f_dx*multi*fixptm;
                        break;
                case PROBEDATA_ARRAY_YS:
                        val -= dsp_vector_list[sec].f_dy*multi*fixptm;
                        break;
                case PROBEDATA_ARRAY_ZS:
                        val -= dsp_vector_list[sec].f_dz*multi*fixptm;
                        break;
                case PROBEDATA_ARRAY_U:
                        val += dsp_vector_list[sec].f_du*multi*fixptm;
                        break;
                default:
                        break; // error!!!!
                }
                g_array_append_val (garray_probedata[i], val);
#ifdef TTY_DEBUG
                std::cout << val << ", ";
#endif
        }
        ++nun_valid_data_sections;

#ifdef TTY_DEBUG
        std::cout << sec << std::endl;
#endif
}

void DSPControl::set_probevector(double pv[9]){ 
        int i,j;
        g_array_append_val (garray_probedata [PROBEDATA_ARRAY_INDEX], current_probe_data_index);
        for (i = PROBEDATA_ARRAY_TIME, j=0; i <= PROBEDATA_ARRAY_SEC; ++i, ++j)
                g_array_append_val (garray_probedata[i], pv[j]);

        
#ifdef TTY_DEBUG
        std::cout << "pv[" << current_probe_data_index << "]_[txyz0xyzSus]set: ";
        for (i = PROBEDATA_ARRAY_TIME, j=0; i <= PROBEDATA_ARRAY_SEC; ++i, ++j)
                std::cout << pv[j] << ", ";
        std::cout << std::endl;
#endif
}

---