unit.h

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

#ifndef __UNIT_H
#define __UNIT_H

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include <libgnome/libgnome.h>
#include <gdk/gdk.h>

class UnitObj;

// Object UnitObj:
typedef enum { UNIT_SM_NORMAL, UNIT_SM_PS } UNIT_MODES;

class UnitObj{
public:
  UnitObj(UnitObj &usrc){
    sym   = g_strdup(usrc.sym); 
    pssym = g_strdup(usrc.pssym); 
    prec  = g_strdup(usrc.prec);
    label = g_strdup(usrc.label);
    if (usrc.alias)
            alias = g_strdup(usrc.alias);
    else
            alias = NULL;
  };
  UnitObj(const gchar *s, const gchar *pss){ 
    sym   = g_strdup(s); 
    pssym = g_strdup(pss); 
    prec  = g_strdup("g");
    label = g_strdup(" ");
    alias = NULL;
  };
  UnitObj(const gchar *s, const gchar *pss, const gchar *precc){ 
    sym   = g_strdup(s); 
    pssym = g_strdup(pss); 
    prec  = g_strdup(precc);
    label = g_strdup(" ");
    alias = NULL;
  };
  UnitObj(const gchar *s, const gchar *pss, const gchar *precc, const gchar *lab){ 
    sym   = g_strdup(s); 
    pssym = g_strdup(pss); 
    prec  = g_strdup(precc);
    label = g_strdup(lab);
    alias = NULL;
  };
  virtual ~UnitObj(){ 
          g_free(sym); g_free(pssym); g_free(prec); g_free(label); 
          if(alias) g_free(alias);
  };

  virtual UnitObj* Copy(){ return new UnitObj(*this); };

  void SetAlias(const gchar *a){ 
          if(alias == NULL)
                  alias = g_strdup(a);
  };

  void ChangeSym(gchar *s, gchar *pss){ 
    g_free(sym); g_free(pssym); 
    sym=g_strdup(s); pssym=g_strdup(pss); 
  };

  void ChangePrec(gchar *precc){ 
    g_free(prec);
    prec = g_strdup(precc);
  };

  void SetLabel(gchar *lab){ 
    g_free(label);
    label = g_strdup(lab);
  };

  /* Unit Symbol */
  /* do not g_free this return string !!! */
  gchar *Symbol(UNIT_MODES um=UNIT_SM_NORMAL){
    switch(um){
    case UNIT_SM_NORMAL: return sym; 
    case UNIT_SM_PS: return pssym; 
    }
    return sym; 
  };     
  gchar *psSymbol(){ return pssym; }; /* Symbol for Postscript use */
  gchar *Label(){ return label; }; /* Name/Label for this Unit */
  gchar *Alias(){ return alias; }; /* Units Aliasname */
  gchar *MakeLongLabel( UNIT_MODES um=UNIT_SM_NORMAL ){ /* free this later !! */
    return g_strconcat(label, " [", Symbol(um), "]", NULL);
  };

  virtual double Usr2Base(double u){ return u; }; /* Usr -> Base */
  virtual double Base2Usr(double b){ return b; }; /* Usr <- Base */
  virtual void Change(double x, int n=0){};

  /* do g_free this returned string !!! */
  gchar *UsrString(double b, UNIT_MODES um=UNIT_SM_NORMAL){
    gchar *fmt = g_strconcat("%",prec," ",Symbol(um),NULL);
    gchar *txt;
    txt = g_strdup_printf(fmt, Base2Usr(b));
    g_free(fmt);
    return txt;
  };
  gchar *UsrStringSqr(double b, UNIT_MODES um=UNIT_SM_NORMAL){
//    gchar *fmt = g_strconcat("%",prec," ",Symbol(um),"^2",NULL);
    gchar *fmt = g_strconcat("%",prec," ",Symbol(um),"\302\262",NULL);
    gchar *txt;
    txt = g_strdup_printf(fmt, Base2Usr(Base2Usr(b)));
    g_free(fmt);
    return txt;
  };
  virtual void setval(gchar *name, double x){};
 protected:
  gchar *sym, *pssym, *prec;
  gchar *label;
  gchar *alias;
 private:
};

class LinUnit;

class LinUnit : public UnitObj{
public:
  LinUnit(LinUnit &usrc)
    :UnitObj(usrc){ fac=usrc.fac; off=usrc.off; };
  LinUnit(const gchar *s, const gchar *pss, double f=1., double o=0.)
    :UnitObj(s, pss){ fac=f; off=o; };
  LinUnit(const gchar *s, const gchar *pss, const gchar *lab, double f=1., double o=0.)
    :UnitObj(s, pss, "g", lab){ fac=f; off=o; };

  virtual UnitObj* Copy(){ return new LinUnit(*this); };
  virtual void setval(const gchar *name, double x){
    switch(*name){
    case 'f': fac=x; break;
    case 'o': off=x; break;
    }
  };

  virtual double Usr2Base(double u){ return (u*fac+off); };   /* Usr -> Base */
  virtual double Base2Usr(double b){ return ((b-off)/fac); }; /* Usr <- Base */

private:
  double fac, off;
};

// % BZ (Brilluin Zone) auf der Basis von Volt (Oktopol Ablenspannung)
class BZUnit;

class BZUnit : public UnitObj{
public:
  BZUnit(BZUnit &usrc):UnitObj(usrc){ En=usrc.En; Sens=usrc.Sens; };
  BZUnit(const gchar *s, const gchar *pss, double sensi=50., double energy=100.)
    :UnitObj(s, pss, "g", "k"){ Sens=sensi; En=energy; };
  BZUnit(const gchar *s, const gchar *pss, const gchar *lab, double sensi=50., double energy=100.)
    :UnitObj(s, pss, "g", lab){ Sens=sensi; En=energy; };

  virtual UnitObj* Copy(){ return new BZUnit(*this); };

  virtual double Usr2Base(double bz){ return (bz/Sens*sqrt(En)); }; /* Usr (BZ) -> Base (V) */
  virtual double Base2Usr(double  u){ return ( u*Sens/sqrt(En)); }; /* Usr (BZ) <- Base (V) */

  double GetE() { return En; };
  void SetE(double E) { En=E; };
  double GetSens() { return Sens; };
  void CalcSens(double volt, double bz){
    Sens = bz/volt*sqrt(En);
  };
private:
  double En, Sens;
};


// Phase S auf der Basis von Energy [eV], d0 Lagenabstand
class SUnit;

class SUnit : public UnitObj{
public:
  SUnit(SUnit &usrc):UnitObj(usrc){ d0=usrc.d0; cth=usrc.cth; };
  SUnit(const gchar *s, const gchar *pss, double dd0=3.141, double theta=5.)
    :UnitObj(s, pss, "g", "Phase"){ 
    d0=dd0; cth=cos(theta*M_PI/180.);
  };
  SUnit(const gchar *s, const gchar *pss, const gchar *lab, double dd0=3.141, double theta=5.)
    :UnitObj(s, pss, "g", lab){ 
    d0=dd0; cth=cos(theta*M_PI/180.);
  };

  virtual UnitObj* Copy(){ return new SUnit(*this); };

  virtual double Usr2Base(double  S){  /* Usr (S) -> Base (eV) */
    double sdc=S/d0/cth;
    return (37.6*sdc*sdc);
  };
  virtual double Base2Usr(double En){  /* Usr (S) <- Base (eV) */
    return (d0*cth*sqrt(En/37.6));
  };

private:
  double d0, cth;
};

// % CPSCNTUnit (Counts Per Second) needs Gatetime in ms
class CPSCNTUnit;

class CPSCNTUnit : public UnitObj{
public:
  CPSCNTUnit(CPSCNTUnit &usrc):UnitObj(usrc){ gt=usrc.gt; };
  CPSCNTUnit(const gchar *s, const gchar *pss, double Gt=1.)
    :UnitObj(s, pss, "g", "CPS"){ gt=Gt; };
  CPSCNTUnit(const gchar *s, const gchar *pss, const gchar *lab, double Gt=1.)
    :UnitObj(s, pss, "g", lab){ gt=Gt; };

  virtual UnitObj* Copy(){ return new CPSCNTUnit(*this); };

  virtual double Usr2Base(double cps){ return (cps*gt) ; }; /* Usr (CPS) -> Base (CNT) */
  virtual double Base2Usr(double cnt){ return (cnt/gt) ; }; /* Usr (CPS) <- Base (CNT) */
  virtual void Change(double x, int n=0){ SetGatetime(x); };

  double GetGatetime() { return gt; };
  void SetGatetime(double Gt) { gt=Gt; };
private:
  double gt;
};

class LogUnit : public UnitObj{
public:
  LogUnit(LogUnit &usrc)
    :UnitObj(usrc){ fac=usrc.fac; off=usrc.off; };
  LogUnit(const gchar *s, const gchar *pss, double f=1., double o=1.)
    :UnitObj(s, pss){ fac=f; off=o; };
  LogUnit(const gchar *s, const gchar *pss, const gchar *lab, double f=1., double o=1.)
    :UnitObj(s, pss, "g", lab){ fac=f; off=o; };

  virtual UnitObj* Copy(){ return new LogUnit(*this); };
  virtual void setval(const gchar *name, double x){
    switch(*name){
    case 'f': fac=x; break;
    case 'o': off=x; break;
    }
  };
  virtual double Usr2Base(double u){ return (off * log10 (u/fac) ); };   /* Usr -> Base */
  virtual double Base2Usr(double b){ return (fac * pow (10., b/off)); }; /* Usr <- Base */

private:
  double fac, off;
};

class InvUnit : public UnitObj{
public:
  InvUnit(InvUnit &usrc)
    :UnitObj(usrc){ fac=usrc.fac; off=usrc.off; };
  InvUnit(const gchar *s, const gchar *pss, double f=1., double o=0.)
    :UnitObj(s, pss){ fac=f; off=o; };
  InvUnit(const gchar *s, const gchar *pss, const gchar *lab, double f=1., double o=0.)
    :UnitObj(s, pss, "g", lab){ fac=f; off=o; };

  virtual UnitObj* Copy(){ return new InvUnit(*this); };
  virtual void setval(const gchar *name, double x){
    switch(*name){
    case 'f': fac=x; break;
    case 'o': off=x; break;
    }
  };
  virtual double Usr2Base(double u){ return (fac/u+off); };   /* Usr -> Base */
  virtual double Base2Usr(double b){ return (fac/(b-off)); }; /* Usr <- Base */

private:
  double fac, off;
};



#endif

---