xsmhard.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 "glbvars.h"
#include <math.h>


/* ============================================================
 * pure virtuelle Funktionen für allgemeine Steuerung 
 * ============================================================
 * - Objekt genügt für Hardwarefreien betrieb !
 * - für die implementation neuer Hardware ist von diesem Objekt ein 
 *   entsprechendes neues Objekt abzuleiten.
 *   Es müssen dann die Basisdienste, entsprechend der virtuellen Funktionen,
 *   bereitgestellt werden.
 * - Siehe Exemplarische Beispiel "class dspobj : public xsmhard{};"
 * - Dieses Basisobjekt solle tunlichst nicht verändert werden !
 */

XSM_Hardware::XSM_Hardware(){ 
        rx = ry = 0L;
        XAnz = 1L;
        Dx = Dy = 1L;
        Ny = Nx = 1L;
        rotoffx=rotoffy=0.; 
        Alpha=0.; 
        rotmyy=rotmxx=1.; rotmyx=rotmxy=0.;
        idlefunc = NULL;
        idlefunc_data = NULL;
        InfoString = g_strdup("no hardware connected");
        AddStatusString = NULL;
        SetScanMode();
        ScanDirection (1);
}

XSM_Hardware::~XSM_Hardware(){;}


void XSM_Hardware::SetOffset(long x, long y){
        XSM_DEBUG (DBG_L4, "HARD: Offset " << x << ", " << y);
        rotoffx = x; rotoffy = y;
}

void XSM_Hardware::SetDxDy(int dx, int dy){
        XSM_DEBUG (DBG_L4, "HARD: DXY " << dx << ", " << dy);
        if (dy){
                Dx = dx; Dy = dy;
        } else
                Dx = Dy = dx;
}

void XSM_Hardware::SetNxNy(long nx, long ny){ 
        if (ny){
                Nx = nx; Ny = ny;
        } else
                Ny = Nx = nx;
}

void XSM_Hardware::SetAlpha(double alpha){ 
        XSM_DEBUG (DBG_L4, "HARD: Alpha " << alpha);
        Alpha=M_PI*alpha/180.;
        rotmyy = rotmxx = cos(Alpha);
        rotmyx = -(rotmxy = sin(Alpha));
}

int XSM_Hardware::ScanDirection (int dir){
        if (dir)
                scan_direction = dir;

        return scan_direction;
}


void XSM_Hardware::MovetoXY(long x, long y){ 
        rx = x; ry = y;
        XSM_DEBUG (DBG_L4, "HARD: MOVXY: " << rx << ", " << ry);
}

/* -- surface simulation code -- */

void XSM_Hardware::ScanLineM(int yindex, int xdir, int muxmode, Mem2d *Mob[MAX_SRCS_CHANNELS], int ix0){
        double x,y;

        XSM_DEBUG (DBG_L4, "Sim Yi=" << yindex << " MuxM=" << muxmode);

        if (yindex < 0 && yindex != -1) return;

        if (!Mob[0]) return;

        Mem2d Line(Mob[0], Nx, 1);

        if (yindex < 0){ // do HS Area Capture!
                for(int j=0; j<Mob[0]->GetNy (); j++){
                        for(int i=0; i<Mob[0]->GetNx (); i++){
                                x = i*Dx*xdir + rx;
                                y = j*Dx + ry;
                                Transform(&x, &y);
                                Line.PutDataPkt(Simulate(x,y), i, 0);
                        }

                        CallIdleFunc ();
                        
                        int i=0;
                        do{
                                //    Mob[i]->PutDataLine(yindex, (void*)dummy);
                                Mob[i]->CopyFrom (&Line, 0, 0, ix0, j, Nx);
                        }while ((++i < MAX_SRCS_CHANNELS) ? Mob[i]!=NULL : FALSE);
                }
        }else{
                for(int i=0; i<Nx; i++){
                        x = i*Dx*xdir + rx;
                        y = ry;
                        Transform(&x, &y);
                        Line.PutDataPkt(Simulate(x,y), i, 0);
                }

                CallIdleFunc ();

                int i=0;
                do{
                        //    Mob[i]->PutDataLine(yindex, (void*)dummy);
                        Mob[i]->CopyFrom (&Line, 0, 0, ix0, yindex, Nx);
                }while ((++i < MAX_SRCS_CHANNELS) ? Mob[i]!=NULL : FALSE);
        }
}


void XSM_Hardware::Transform(double *x, double *y){
        double xx;
        xx = *x*rotmxx + *y*rotmxy + rotoffx;
        *y = *x*rotmyx + *y*rotmyy + rotoffy;
        *x = xx;
}

double Lorenz(double x, double y){
  double x2=x*x;
  double y2=y*y;
  double a2=0.3;
  double a0=1e4;
  return a0/pow(1.+(x2+y2)/a2, 3./2.);
}

double Gaus(double x, double y){
  double x2=x*x;
  double y2=y*y;
  double a2=.1;
  double a0=3e5;
  return a0*exp(-(x2+y2)/a2);
}

double Ground(){
  double a0=1e2;
  return a0*rand()/RAND_MAX;
}

double Steps(double x, double y){
        return atan(10*(x+3*y-16))/(M_PI/2.)
                + atan(10*(x+3*y-8))/(M_PI/2.)
                + atan(10*(x+3*y+8))/(M_PI/2.)
                + atan(10*(x+3*y+16))/(M_PI/2.)
                + atan(10*(x+3*y+32))/(M_PI/2.);
}

double Islands(double x, double y){
  double h=0.;
  //  x+=-0.5; y+=1;
  h-=atan(10*(1.8-sqrt(x*x+y*y)));
  h-=atan(10*(0.7-sqrt(2*x*x+y*y)));
  return h/(M_PI/2.);
}

// Dummy Bild
double XSM_Hardware::Simulate(double x, double y){
  static double drift=0.;
  //  static double dir=0.000003;
  //  static double creep=0.;
  x/=32767./10;
  y/=32767./10; // jetzt x,y in Volt am DA
  if(IS_SPALEED_CTRL){
    return (
            Lorenz(x,y)+Gaus(x,y)
            + Lorenz(x+1.0,y+.5)+Lorenz(x-1.0,y-.5)
            + Lorenz(x+1.0,y-.5)+Lorenz(x-1.0,y+.5)
            + Lorenz(x+5.0,y)+Gaus(x+5.0,y)
            + Lorenz(x-5.0,y)+Gaus(x-5.0,y) 
            + Lorenz(x+5.0,y+5.0)+Gaus(x+5.0,y+5.0)
            + Lorenz(x-5.0,y-5.0)+Gaus(x-5.0,y-5.0) 
            + Lorenz(x+5.0,y-5.0)+Gaus(x+5.0,y-5.0)
            + Lorenz(x-5.0,y+5.0)+Gaus(x-5.0,y+5.0) 
            + Lorenz(x,y-5.0)+Gaus(x,y-5.0)
            + Lorenz(x,y+5.0)+Gaus(x,y+5.0) 
            + Ground()
            );
  }else{
    drift += 0.000003; 
    x+=drift;
    return (512.*(sin(M_PI*x*10.)*cos(M_PI*y*10.)
                  + Steps(x,y)
                  + Islands(x,y)
                  )
            );
  }
}

// END xsmware.C

---