scan_event.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" -*- */

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

#include "scan_event.h"

/*
 * Base Class for Event Data Storage
 * 
 *
 * Class: EventEntry
 */

EventEntry::EventEntry (gchar *Name, time_t Time){ 
        XSM_DEBUG (DBG_L6, "EventEntry::EventEntry");
        name = g_strdup (Name);
        time = Time;
}
 
EventEntry::~EventEntry (){ 
        XSM_DEBUG (DBG_L6, "EventEntry::~EventEntry");
        g_free (name);
}

time_t EventEntry::get_time () { return time; };

gchar* EventEntry::get_str_time () { return NULL; };

ProbeEntry::ProbeEntry (gchar *Name, time_t Time, GPtrArray *Labels, GPtrArray *Unitssymbols, int Chunk_size) : EventEntry (Name, Time){ 
        XSM_DEBUG (DBG_L6, "ProbeEntry::ProbeEntry");
        chunk_size = Chunk_size;
        data = g_array_new (FALSE, TRUE, sizeof (double));
        labels = Labels;
        unitssymbols =Unitssymbols;
        num_sets=0;
}
 
ProbeEntry::ProbeEntry (gchar *Name, NcFile *ncf, int p_index, NcVar* &evdata_var, NcVar* &evcoords_var, ScanEvent* &se, int num, int &count, ProbeEntry *pe) : EventEntry (Name, 0){ 
        gchar *tmp;

        XSM_DEBUG (DBG_L6, "ProbeEntry::ProbeEntry -- Scan NC-File for Entry" << p_index);
//      std::cout << "ProbeEntry::ProbeEntry -- Scan NC-File for Entry #" << p_index << " :" << num << std::endl;

        se = NULL;

        if (!pe){

                chunk_size = 0;
                num_sets=0;
                data = NULL;
                labels = NULL;
                unitssymbols = NULL;

                tmp = g_strdup_printf ("Event_Probe_%05d_coords", p_index);
                std::cout << " ProbeEntry::ProbeEntry scanning for #" << p_index << " :" << tmp << std::endl;
                evcoords_var = ncf->get_var(tmp); 
                g_free (tmp);

                // found that Event_Probe, else return?
                if (!evcoords_var) // not OK?
                        return;

                tmp = g_strdup_printf ("Event_Probe_%05d_data", p_index); 
                std::cout << " ProbeEntry::ProbeEntry scanning for #" << p_index << " :" << tmp << std::endl;
                evdata_var = ncf->get_var(tmp); 
                g_free (tmp);

                if (!evdata_var) // not OK?
                        return;

                // got it now.
                count      = evdata_var->get_dim(0)->size ();
                chunk_size = evdata_var->get_dim(1)->size ();
                num_sets   = evdata_var->get_dim(2)->size ();
//              std::cout << "Count:" << count << " Chunk:" << chunk_size << " NumSets:" << num_sets << std::endl;

                labels = g_ptr_array_new ();
                NcAtt *data_labels = evdata_var->get_att ("Labels");
                if (data_labels){
                        NcValues *v = data_labels->values ();
                        gchar **ss = g_strsplit (v->as_string (0), ",", chunk_size);
                        for (gchar **s = ss; *s; ++s)
                                g_ptr_array_add (labels, (gpointer) *s);
                }

                unitssymbols = g_ptr_array_new ();
                NcAtt *data_units  = evdata_var->get_att ("Units");
                if (data_units){
                        NcValues *v = data_units->values ();
                        gchar **ss = g_strsplit (v->as_string (0), ",", chunk_size);
                        for (gchar **s = ss; *s; ++s)
                                g_ptr_array_add (unitssymbols, (gpointer) *s);
                }
                
//              std::cout << " ProbeEntry::ProbeEntry Data:" << num_sets << "," << chunk_size << std::endl;
                data = g_array_sized_new (FALSE, TRUE, sizeof (double), num_sets*chunk_size);

        } else {

                chunk_size = pe->get_chunk_size ();
                num_sets = pe->get_num_sets ();
//              std::cout << " ProbeEntry::ProbeEntry DataCPY:" << num_sets << "," << chunk_size << std::endl;
                data = g_array_sized_new (FALSE, TRUE, sizeof (double), num_sets*chunk_size);
                labels = g_ptr_array_new ();
                unitssymbols =  g_ptr_array_new ();
                for (int i=0; i<chunk_size; ++i){
                        g_ptr_array_add (labels, (gpointer)pe->get_label (i));
                        g_ptr_array_add (unitssymbols, (gpointer)pe->get_unit_symbol (i));
                }
        }

        double coord[4];
        evcoords_var->set_cur (num,0);
        evcoords_var->get (coord, 1,4);

        se = new ScanEvent (coord[0], coord[1], coord[2]);
        time = (time_t) coord[3];

        float f;
        double vals[20];
        for (int n=0; n<num_sets; ++n){
                for (int j=0; j<chunk_size; ++j){
                        evdata_var->set_cur (num,j,n);
                        evdata_var->get (&f, 1, 1, 1);
                        vals[j] = (double)f;
                }
                g_array_append_vals (data, (gconstpointer)vals, chunk_size);
        }
}

ProbeEntry::~ProbeEntry (){ 
        XSM_DEBUG (DBG_L6, "ProbeEntry::~ProbeEntry");
        g_array_free (data, TRUE);
        g_ptr_array_free (labels, TRUE);
        g_ptr_array_free (unitssymbols, TRUE);
}

gchar *ProbeEntry::get_label (int j){ 
        if (j < 0)
                return "#";
        return (gchar*)g_ptr_array_index (labels,  j); 
}
        
gchar *ProbeEntry::get_unit_symbol (int j){ 
        if (j < 0)
                return " ";
        return (gchar*)g_ptr_array_index (unitssymbols,  j); 
}


int ProbeEntry::write_nc_variable_set (NcFile *ncf, int p_index, NcVar* &evdata_var, NcVar* &evcoords_var, int total_count){
        gchar *tmp;

        tmp = g_strdup_printf ("Event_Probe_%05d_dim_events", p_index); 
//      std::cout << " ProbeEntry::write_nc_variable_set #" << p_index << " :" << tmp << std::endl;
        NcDim* ev_dim_events  = ncf->add_dim (tmp, total_count);
        g_free (tmp);

        tmp = g_strdup_printf ("Event_Probe_%05d_dim_coords", p_index);
//      std::cout << " ProbeEntry::write_nc_variable_set #" << p_index << " :" << tmp << std::endl;
        NcDim* ev_dim_coords  = ncf->add_dim (tmp, 4);
        g_free (tmp);

        tmp = g_strdup_printf ("Event_Probe_%05d_dim_sets", p_index);
//      std::cout << " ProbeEntry::write_nc_variable_set #" << p_index << " :" << tmp << std::endl;
        NcDim* ev_dim_chunks  = ncf->add_dim (tmp, chunk_size);
        g_free (tmp);

        tmp = g_strdup_printf ("Event_Probe_%05d_dim_samples", p_index); 
//      std::cout << " ProbeEntry::write_nc_variable_set #" << p_index << " :" << tmp << std::endl;
        NcDim* ev_dim_samples = ncf->add_dim (tmp, num_sets);
        g_free (tmp);

        tmp = g_strdup_printf ("Event_Probe_%05d_coords", p_index); 
//      std::cout << " ProbeEntry::write_nc_variable_set #" << p_index << " :" << tmp << std::endl;
        evcoords_var = ncf->add_var (tmp, ncDouble,  ev_dim_events, ev_dim_coords);
        evcoords_var->add_att ("long_name", "Probe Event coordinates list");
        evcoords_var->add_att ("Units", "X/Y/V/t ==> Ang/Ang/Volt/Unixtime");
        g_free (tmp);
        evcoords_var->add_att ("ID", p_index);

        GString* all_labels=NULL;
        GString* all_units=NULL;
        for (int j=0; j<chunk_size; ++j){
                if (!j){
                        all_labels = g_string_new ((const gchar*)g_ptr_array_index(labels,j));
                        all_units  = g_string_new ((const gchar*)g_ptr_array_index(unitssymbols,j));
                } else {
                        all_labels = g_string_append (all_labels, ",");
                        all_labels = g_string_append (all_labels, (const gchar*)g_ptr_array_index(labels,j));
                        all_units  = g_string_append (all_units, ",");
                        all_units  = g_string_append (all_units, (const gchar*)g_ptr_array_index(unitssymbols,j));
                }
        }
        tmp = g_strdup_printf ("Event_Probe_%05d_data", p_index); 
//      std::cout << " ProbeEntry::write_nc_variable_set #" << p_index << " :" << tmp << std::endl;
        evdata_var = ncf->add_var (tmp, ncFloat, ev_dim_events, ev_dim_chunks, ev_dim_samples);
        g_free (tmp);
        evdata_var->add_att ("long_name", "Probe Event Data Set");
        evdata_var->add_att ("Name", name);
        evdata_var->add_att ("Labels", all_labels->str);
        evdata_var->add_att ("Units", all_units->str);

        g_string_free (all_labels, TRUE);
        g_string_free (all_units, TRUE);

        return 0;
}

int ProbeEntry::write_nc_data (NcVar* evdata_var, NcVar* evcoords_var, ScanEvent *se, int count){
        double coord[4];
        coord[2] = se->get_position (coord[0], coord[1]);
        coord[3] = (double)time;
//      std::cout << "Write, Coord, Data #" << count << " :XY" << coord[0] << "," << coord[1] << std::endl;
        evcoords_var->set_cur (count,0);
        evcoords_var->put (coord, 1,4);

        float f;
        for (int j=0; j<chunk_size; ++j)
                for (int n=0; n<num_sets; ++n){
                        evdata_var->set_cur (count,j,n);
                        f = (float)get (n, j);
                        evdata_var->put (&f, 1, 1, 1);
                }

        return 0;
}


void ProbeEntry::print (){
        std::cout << "ScanEvent::ProbeEntry " << name << " time: " << time << std::endl;
        std::cout << "### ";
        for (int j=0; j<chunk_size; ++j)
                std::cout << (gchar*)g_ptr_array_index(labels,j) << "[" << (gchar*)g_ptr_array_index(unitssymbols,j) << "], ";
        std::cout << std::endl;
        for (int i=0; i<num_sets; ++i){
                std::cout << i << " ";
                for (int j=0; j<chunk_size; ++j)
                        std::cout << get (i, j) << " ";
                std::cout << std::endl;
        }
}


UserEntry::UserEntry (gchar *Name, time_t Time, GPtrArray *Messages, int num) : EventEntry (Name, Time){ 
        XSM_DEBUG (DBG_L6, "UserEntry::UserEntry");
        num_sets=0;
        data = NULL;

        if (Messages && num>0){
                data = Messages;
                num_sets=num;
        } else
                data = g_ptr_array_new ();
}
 
UserEntry::UserEntry (gchar *Name, NcFile *ncf, int u_index, ScanEvent* &se) : EventEntry (Name, 0){ 
        gchar *tmp;

        XSM_DEBUG (DBG_L6, "UserEntry::UserEntry -- Scan NC-File for User Entry" << u_index);

        se = NULL;
        num_sets=0;
        data = NULL;

        tmp = g_strdup_printf ("Event_User_%05d_coords", u_index);
        std::cout << " UserEntry::UserEntry scanning for #" << u_index << " :" << tmp << std::endl;
        NcVar* evcoords_var = ncf->get_var(tmp); 
        g_free (tmp);

        // found that Event_User, else return?
        if (!evcoords_var) // not OK?
                return;

        NcAtt *data_message = evcoords_var->get_att ("Message");
        if (data_message){
                data = g_ptr_array_new ();
                add (data_message->values ()->as_string (0));
        }

        double coord[4];
        evcoords_var->get (coord, 4);

        se = new ScanEvent (coord[0], coord[1], coord[2]);
        time = (time_t) coord[3];
}

UserEntry::~UserEntry (){ 
        XSM_DEBUG (DBG_L6, "UserEntry::~UserEntry");
        g_ptr_array_free (data, TRUE);
}

void UserEntry::print (){
        std::cout << "ScanEvent::UserEntry " << name << " time: " << time 
                  << " Messages: " << std::endl;
        for (int i=0; i<num_sets; ++i)
                std::cout << i << ": " << get (i) << std::endl;
}

int UserEntry::store_event_to_nc (NcFile* ncf, int u_index, ScanEvent *se){
        gchar *tmp;

        if (!num_sets) 
                return 0;

        tmp = g_strdup_printf ("Event_User_%05d_dim_coords", u_index);
        NcDim* ev_dim_coords  = ncf->add_dim (tmp, 4);
        g_free (tmp);

        tmp = g_strdup_printf ("Event_User_%05d_coords", u_index); 
        NcVar* evcoords_var = ncf->add_var (tmp, ncDouble, ev_dim_coords);
        g_free (tmp);
        evcoords_var->add_att ("long_name", "User Event coordinates list");
        evcoords_var->add_att ("Units", "X/Y/V/t ==> Ang/Ang/Volt/Unixtime");
        evcoords_var->add_att ("Name", name);
        evcoords_var->add_att ("ID", u_index);
        evcoords_var->add_att ("Message", get (0));

        double coord[4];
        coord[2] = se->get_position (coord[0], coord[1]);
        coord[3] = (double)time;
        evcoords_var->put (coord, 4);

        return 0;
}

/*
 * Base Class implementation for one Scan Event at one Time/Location
 *
 * Class: ScanEvent
 */

void ScanEvent::eeremove (EventEntry *entry, gpointer from){
        delete entry;
}

void ScanEvent::eeprint (EventEntry *entry, int *w){
        entry->print ();
}

ScanEvent::ScanEvent (double xPos, double yPos, double Val){
        XSM_DEBUG (DBG_L6, "ScanEvent::ScanEvent");
        event_list = NULL;
        xpos = xPos;
        ypos = yPos;
        val = Val;
        flag = FALSE;
}


ScanEvent::~ScanEvent (){
        XSM_DEBUG (DBG_L6, "ScanEvent::~ScanEvent");
        g_slist_foreach(event_list, (GFunc) ScanEvent::eeremove, event_list);
        g_slist_free (event_list);
}

void ScanEvent::add_event (EventEntry *ee){
        event_list = g_slist_prepend (event_list, ee);
}

---