// $Source: /usr/local/SimSoft/Sfx3D/src/gsl/sfxprg.cpp,v $
// $Revision: 1.2 $
// $Author: baum $
// $Date: 2001/11/29 15:18:10 $
//
// Login name of the user who locked the revision
// $Locker:  $
// Tag name used to checkout the file
// $Name: Release-14 $
// State assigned to revision
// $State: Exp $
//
//
// $Log: sfxprg.cpp,v $
// Revision 1.2  2001/11/29 15:18:10  baum
// -Realzeitsteuerung eingebaut
// -Handsteuerung eingebaut
//

#include <stdlib.h>
#include <string.h>
#include <float.h>

#include "Kalender.h"

#define _SFXPRG_CPP
#include "modell.h"
#include "sfxprg.h"
#include "sfxhla.h"

/*#include "transp.h"
#include "baustein.h"
#include "prozess.h"
#include "programm.h"
#include "arbplan.h"
#include "ereignis.h"
#include "fts.h"
#include "maschine.h"
#include "vwagen.h"
#include "regal.h"
#include "mehrfachlader.h"
#include "laufkran.h"
#include "staufoer.h"
#include "realzeit.h"
*/

//---------------------------------------------------------
// class UserData
//---------------------------------------------------------

UserData::UserData ()
 : ObjLabelString  (),
   ObjParaString  ()
 { }

/*virtual*/ UserData::~UserData ()
 { }

/*virtual*/ char *UserData::LabelString () {
  return NULL;
}

/*virtual*/ char *UserData::ParaString () {
  return NULL;
}

//---------------------------------------------------------
//---------------- Bausteinattribute ----------------------
//---------------------------------------------------------

unsigned BstNr () {
  return PrgModul->getProgBst ()->Nummer ();
}

unsigned BstTyp (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Basistyp() :
    sim_error ("SFXPRG", "BstTyp", "Bst nicht vorhanden", bstNr, FATAL));
}

unsigned Zustand (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Zustand() :
    sim_error ("SFXPRG", "Zustand", "Bst nicht vorhanden", bstNr, FATAL));
}

unsigned Belegung (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Belegung() :
    sim_error ("SFXPRG", "Belegung", "Bst nicht vorhanden", bstNr, FATAL));
}

unsigned Kapazitaet (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Kapazitaet() :
    sim_error ("SFXPRG", "Kapazitaet", "Bst nicht vorhanden", bstNr, FATAL));
}

bool hasKapazitaet (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->hasKapazitaet (NULL) :
    (bool) sim_error ("SFXPRG", "hasKapazitaet", "Bst nicht vorhanden", 
                      bstNr, FATAL));
}

unsigned setKapazitaet (unsigned bstNr, unsigned kap) {
  return ((baustein [bstNr]) ? baustein [bstNr]->setKapazitaet (kap) :
    sim_error ("SFXPRG", "setKapazitaet", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

unsigned Meldungen(unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->AnzahlMeldungen () :
    sim_error ("SFXPRG", "Meldungen", "Bst nicht vorhanden", bstNr, FATAL));
}

SimTime Aufnahmezeit (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Aufnahmezeit():
    (SimTime) sim_error ("SFXPRG", "Aufnahmezeit", "Bst nicht vorhanden", 
                         bstNr, FATAL));
}

void setAufnahmezeit (unsigned bstNr, const SimTime& zeit) {
  if (baustein [bstNr])
    baustein [bstNr]->setAufnahmezeit (zeit);
  else
    sim_error ("SFXPRG", "setAufnahmezeit", "Bst nicht vorhanden", 
               bstNr, FATAL);
}

unsigned Strategie (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Strategie() :
    sim_error ("SFXPRG", "Strategie", "Bst nicht vorhanden", bstNr, FATAL));
}

void setStrategie (unsigned bstNr, unsigned strat) {
  (baustein [bstNr]) ? (void) (baustein [bstNr]->setStrategie (strat)) :
    (void) sim_error ("SFXPRG", "setStrategie", "Bst nicht vorhanden", 
                      bstNr, FATAL);
}


//Transportbestellsystem

void bestelleBstHolenAnfangGliedern (unsigned werBstNr, unsigned zielBstNr, unsigned palPlatz) {
   if (MySFXModel->PrgDebug()) {
      dprintf ("PRG bestelleBstHolenAnfangGliedern auf Bst %d ZielBst %d PalPlatz %d\n", werBstNr, zielBstNr, palPlatz);
   }
   (baustein[werBstNr]) ? (void) (baustein [werBstNr]->bestelleBstHolenAnfangGliedern(zielBstNr, palPlatz)) :
   (void) sim_error ("SFXPRG", "bestelleBstHolenAnfangGliedern", "Bst nicht vorhanden", werBstNr, FATAL);
}

void bestelleBstHolen (unsigned werBstNr, unsigned zielBstNr, unsigned palPlatz) {
   if (MySFXModel->PrgDebug()) {
      dprintf ("PRG bestelleBstHolen auf Bst %d ZielBst %d PalPlatz %d\n", werBstNr, zielBstNr, palPlatz);
   }
   (baustein[werBstNr]) ? (void) (baustein [werBstNr]->bestelleBstHolen(zielBstNr, palPlatz)) :
   (void) sim_error ("SFXPRG", "bestelleBstHolen", "Bst nicht vorhanden", werBstNr, FATAL);
}

void bestelleBstBringenAnfangGliedern (unsigned werBstNr, unsigned zielBstNr, unsigned palPlatz) {
   if (MySFXModel->PrgDebug()) {
      dprintf ("PRG bestelleBstBringenAnfangGliedern auf Bst %d ZielBst %d PalPlatz %d\n", werBstNr, zielBstNr, palPlatz);
   }
   (baustein[werBstNr]) ? (void) (baustein [werBstNr]->bestelleBstBringenAnfangGliedern(zielBstNr, palPlatz)) :
   (void) sim_error ("SFXPRG", "bestelleBstBringenAnfangGliedern", "Bst nicht vorhanden", werBstNr, FATAL);	
}

void bestelleBstBringen (unsigned werBstNr, unsigned zielBstNr, unsigned palPlatz) {
   if (MySFXModel->PrgDebug()) {
      dprintf ("PRG bestelleBstBringen auf Bst %d ZielBst %d PalPlatz %d\n", werBstNr, zielBstNr, palPlatz);
   }
   (baustein[werBstNr]) ? (void) (baustein [werBstNr]->bestelleBstBringen(zielBstNr, palPlatz)) :
   (void) sim_error ("SFXPRG", "bestelleBstBringen", "Bst nicht vorhanden", werBstNr, FATAL);	
}

void loescheBestellungHolen (unsigned werBstNr, unsigned zielBstNr, unsigned palPlatz) {
   if (MySFXModel->PrgDebug()) {
      dprintf ("PRG loescheBestellungHolen auf Bst %d ZielBst %d PalPlatz %d\n", werBstNr, zielBstNr, palPlatz);
   }
   (baustein[werBstNr]) ? (void) (baustein [werBstNr]->loescheBestellungHolen(zielBstNr, palPlatz)) :
   (void) sim_error ("SFXPRG", "loescheBestellungHolen", "Bst nicht vorhanden", werBstNr, FATAL);	
}

void loescheBestellungBringen (unsigned werBstNr, unsigned zielBstNr, unsigned palPlatz) {
   if (MySFXModel->PrgDebug()) {
      dprintf ("PRG loescheBestellungBringen auf Bst %d ZielBst %d PalPlatz %d\n", werBstNr, zielBstNr, palPlatz);
   }
   (baustein[werBstNr]) ? (void) (baustein [werBstNr]->loescheBestellungBringen(zielBstNr, palPlatz)) :
   (void) sim_error ("SFXPRG", "loescheBestellungBringen", "Bst nicht vorhanden", werBstNr, FATAL);	
}

void loescheAlleBestellungen (unsigned werBstNr) {
   if (MySFXModel->PrgDebug()) {
      dprintf ("PRG loescheAlleBestellungen auf Bst %d\n", werBstNr);
   }
   (baustein[werBstNr]) ? (void) (baustein [werBstNr]->loescheAlleBestellungen()) :
   (void) sim_error ("SFXPRG", "loescheAlleBestellungen", "Bst nicht vorhanden", werBstNr, FATAL);	
}

//Transportbestellsystem Ende


int Prioritaet (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Prioritaet() :
    sim_error ("SFXPRG", "Prioritaet", "Bst nicht vorhanden", bstNr, FATAL));
}

void setPrioritaet (unsigned bstNr, int prio) {
  (baustein [bstNr]) ? (void) (baustein [bstNr]->setPrioritaet(prio)) :
    (void) sim_error ("SFXPRG", "setPrioritaet", "Bst nicht vorhanden", 
                      bstNr, FATAL);
}

SimTime Zustandszeit (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->ZustandZeit() :
    sim_error ("SFXPRG", "Zustandzeit", "Bst nicht vorhanden", bstNr, FATAL));
}

int AnzDirAvisIst (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Avis ()->DirIstAnzahl() :
    sim_error ("SFXPRG", "AnzDirAvisIst", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

int AnzIndAvisIst (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Avis ()->IndIstAnzahl() :
    sim_error ("SFXPRG", "AnzIndAvisIst", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

int AnzDirAvisSoll (unsigned bstNr) {
return ((baustein [bstNr]) ? baustein [bstNr]->Avis ()->DirSollAnzahl() :
    sim_error ("SFXPRG", "AnzDirAvisSoll", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

int AnzIndAvisSoll (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->Avis ()->IndSollAnzahl() :
    sim_error ("SFXPRG", "AnzIndAvisSoll", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

void setAnzDirAvisSoll (unsigned bstNr, int anz) {
  (baustein [bstNr]) ? baustein [bstNr]->Avis ()->setDirSollAnzahl(anz) :
    sim_error ("SFXPRG", "setAnzDirAvisSoll", "Bst nicht vorhanden", 
               bstNr, FATAL);
}

void setAnzIndAvisSoll (unsigned bstNr, int anz) {
  (baustein [bstNr]) ? baustein [bstNr]->Avis ()->setIndSollAnzahl(anz) :
    sim_error ("SFXPRG", "setAnzIndAvisSoll", "Bst nicht vorhanden", 
               bstNr, FATAL);
}

UserData *BstUserData (unsigned bstNr) {
  return ((baustein [bstNr]) ? baustein [bstNr]->getUserData () :
    (UserData*) sim_error ("SFXPRG", "BstUserData", "Bst nicht vorhanden",
                           bstNr, FATAL));
}

void setBstUserData (unsigned bstNr, UserData *Data) {
  (baustein [bstNr]) ? baustein [bstNr]->setUserData (Data) :
    (void) sim_error ("SFXPRG", "setBstUserData", "Bst nicht vorhanden", 
                      bstNr, FATAL);
}

typTransportEinheit* gibProjektIDTE (unsigned bstNr, unsigned artNr /*=0*/, unsigned projektid /*= 0*/,
                                     unsigned suchid /*= 0*/) {
  return ((baustein[bstNr]) ? 
    baustein[bstNr]->GibProjektIDTE(artNr, projektid, suchid) :
    (typTransportEinheit*) sim_error ("SFXPRG", "gibProjektIDTE", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

unsigned AnzBestArbeitsplan (unsigned bstNr, unsigned arbNr, 
                             unsigned istVorg) {
  return ((baustein [bstNr]) ? 
    baustein [bstNr]->AnzahlArbeitsplanBestellbar (arbNr, istVorg) :
    sim_error ("SFXPRG", "AnzBestArbeitsplan", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

unsigned AnzBestArtikel (unsigned bstNr, unsigned artNr, unsigned istVorg) {
  return ((baustein [bstNr]) ? 
    baustein [bstNr]->AnzahlArtikelBestellbar (artNr, istVorg) :
    sim_error ("SFXPRG", "AnzBestArtikel", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

unsigned AnzBestProjektID (unsigned bstNr, unsigned artNr, unsigned suchID) {
  return ((baustein [bstNr]) ?
    baustein [bstNr]->AnzahlProjektIDBestellbar (artNr, suchID) :
    sim_error ("SFXPRG", "AnzBestArtikel", "Bst nicht vorhanden",
               bstNr, FATAL));
}

double MengeBestArbeitsplan (unsigned bstNr, unsigned arbNr, 
                             unsigned istVorg) {
  return ((baustein [bstNr]) ? 
    baustein [bstNr]->MengeArbeitsplanBestellbar (arbNr, istVorg) :
    sim_error ("SFXPRG", "ArbeitsplanMenge", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

double MengeBestArtikel (unsigned bstNr, unsigned artNr, unsigned istVorg) {
  return ((baustein [bstNr]) ? 
    baustein [bstNr]->MengeArtikelBestellbar (artNr, istVorg) :
    sim_error ("SFXPRG", "ArtikelMenge", "Bst nicht vorhanden", bstNr, FATAL));
}

unsigned AnzArbeitsplanBelegung (unsigned bstNr, unsigned arbNr, 
                                 unsigned istVorg /*= 0*/) {
  return ((baustein [bstNr]) ? 
    baustein [bstNr]->AnzahlArbeitsplanVorhanden (arbNr, istVorg) :
    sim_error ("SFXPRG", "AnzArbeitsplanBelegung", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

unsigned AnzArtikelBelegung (unsigned bstNr, unsigned artNr, 
                             unsigned istVorg /*= 0*/) {
  return ((baustein [bstNr]) ? 
    baustein [bstNr]->AnzahlArtikelVorhanden (artNr, istVorg) :
    sim_error ("SFXPRG", "AnzArtikelBelegung", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

double MengeArbeitsplanBelegung (unsigned bstNr, unsigned arbNr, 
                                 unsigned istVorg /*= 0*/) {
  return ((baustein [bstNr]) ? 
    baustein [bstNr]->MengeArbeitsplanVorhanden (arbNr, istVorg) :
    sim_error ("SFXPRG", "MengeArbeitsplanBelegung", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

double MengeArtikelBelegung (unsigned bstNr, unsigned artNr, 
                             unsigned istVorg /*= 0*/) {
  return ((baustein [bstNr]) ? 
    baustein [bstNr]->MengeArtikelVorhanden (artNr, istVorg) :
    sim_error ("SFXPRG", "MengeArtikelBelegung", "Bst nicht vorhanden", 
               bstNr, FATAL));
}

unsigned ArbeitsplanNrVonLagerplatz (unsigned bstNr, unsigned platzNr) {
  if ((baustein [bstNr]->Basistyp () != tRegaleinheit) &&
      (baustein [bstNr]->Basistyp () != tAbstrakteRegaleinheit))
    sim_error ("SFXPRG", "ArbeitsplanNrVonLagerplatz", 
               "Bst ist keine Regaleinheit", bstNr, FATAL);
  return ((typRegaleinheit*) baustein [bstNr])->ArbNrVonPlatz (platzNr);
}

unsigned ArtikelNrVonLagerplatz (unsigned bstNr, unsigned platzNr) {
  if ((baustein [bstNr]->Basistyp () != tRegaleinheit) &&
      (baustein [bstNr]->Basistyp () != tAbstrakteRegaleinheit))
    sim_error ("SFXPRG", "ArtikelNrVonLagerplatz", 
               "Bst ist keine Regaleinheit", bstNr, FATAL);
  return ((typRegaleinheit*) baustein [bstNr])->ArtNrVonPlatz (platzNr);
}

unsigned VorgNrVonLagerplatz (unsigned bstNr, unsigned platzNr) {
  if ((baustein [bstNr]->Basistyp () != tRegaleinheit) &&
      (baustein [bstNr]->Basistyp () != tAbstrakteRegaleinheit))
    sim_error ("SFXPRG", "ArtikelNrVonLagerplatz", 
               "Bst ist keine Regaleinheit", bstNr, FATAL);
  return ((typRegaleinheit*) baustein [bstNr])->VorgNrVonPlatz (platzNr);
}

//---------------------------------------------------------
//------------ VerteilWagen-Parameter----------------------
//---------------------------------------------------------

double setGeschwindigkeit (unsigned bstNr, double geschw) {
  if (baustein [bstNr]) {
      switch (baustein [bstNr]->Basistyp ()) {
      case tVerteilwagen   : return ((typVerteilwagen*) baustein [bstNr])->setGeschwindigkeit (geschw);
      case tMehrfachLader  : return ((typMehrfachLader*) baustein [bstNr])->setGeschwindigkeit (geschw);
      case tLaufkran       : return ((typLaufkran*) baustein [bstNr])->setGeschwindigkeit (geschw);
      case tStaufoerderer  : return ((typStaufoerderer*) baustein [bstNr])->setGeschwindigkeit (geschw);
      case tFtsWagen       : return ((typFtsWagen*) baustein [bstNr])->setGeschwindigkeit (geschw);
      default : sim_error ("SFXPRG", "setGeschwindigkeit", 
                "Bst ist kein Wagen, Kran, Mehrfachlader, Staufoerderer oder FTS", bstNr, FATAL);
  }
}
  return sim_error ("SFXPRG", "setGeschwindigkeit", 
                         "Bst nicht vorhanden", bstNr, FATAL);
  
}

void setFahrBeschleunigung (unsigned bstNr, double beschl) {
  if (baustein [bstNr]) {
     if (baustein [bstNr]->Basistyp () == tVerteilwagen)
       ((typVerteilwagen*) baustein [bstNr])->setFahrBeschleunigung (beschl);
     else if (baustein [bstNr]->Basistyp () == tLaufkran)
       ((typLaufkran*) baustein [bstNr])->setFahrBeschleunigung (beschl);
     else if (baustein [bstNr]->Basistyp () == tMehrfachLader)
       ((typMehrfachLader*) baustein [bstNr])->setFahrBeschleunigung (beschl);
     else sim_error ("SFXPRG", "setFahrBeschleunigung", 
                     "Bst ist kein Wagen, MehrfachLader oder Kran", bstNr, FATAL);
  }
  else (void) sim_error ("SFXPRG", "setFahrBeschleunigung", 
                         "Bst nicht vorhanden", bstNr, FATAL);
}

void setFahrVerzoegerung (unsigned bstNr, double verz) {
  if (baustein [bstNr]) {
    if (baustein [bstNr]->Basistyp () == tVerteilwagen)
      ((typVerteilwagen*) baustein [bstNr])->setFahrVerzoegerung (verz);
    else if (baustein [bstNr]->Basistyp () == tLaufkran)
      ((typLaufkran*) baustein [bstNr])->setFahrVerzoegerung (verz);
    else if (baustein [bstNr]->Basistyp () == tMehrfachLader)
      ((typMehrfachLader*) baustein [bstNr])->setFahrVerzoegerung (verz);    
    else sim_error ("SFXPRG", "setFahrVerzoegerung", 
                    "Bst ist kein Wagen, MehrfachLader oder Kran", bstNr, FATAL);
  }
  else (void) sim_error ("SFXPRG", "setFahrVerzoegerung", 
                         "Bst nicht vorhanden", bstNr, FATAL);
}

void setHubGeschwindigkeit (unsigned bstNr, double geschw) {
  if (baustein [bstNr]) {
     if (baustein [bstNr]->Basistyp () == tVerteilwagen)
       ((typVerteilwagen*) baustein [bstNr])->setHubGeschwindigkeit (geschw);
     else if (baustein [bstNr]->Basistyp () == tLaufkran)
      ((typLaufkran*) baustein [bstNr])->setHubGeschwindigkeit (geschw);
     else if (baustein [bstNr]->Basistyp () == tMehrfachLader)
      ((typMehrfachLader*) baustein [bstNr])->setHubGeschwindigkeit (geschw);
     else sim_error ("SFXPRG", "setHubGeschwindigkeit", 
                     "Bst ist kein Wagen, MehrfachLader oder Kran", bstNr, FATAL);
  }
  else (void) sim_error ("SFXPRG", "setHubGeschwindigkeit", 
                         "Bst nicht vorhanden", bstNr, FATAL);
}

void setHubBeschleunigung (unsigned bstNr, double beschl) {
  if (baustein [bstNr]) {
     if (baustein [bstNr]->Basistyp() == tVerteilwagen)
       ((typVerteilwagen*) baustein [bstNr])->setHubBeschleunigung (beschl);
     else if (baustein [bstNr]->Basistyp () == tLaufkran)
      ((typLaufkran*) baustein [bstNr])->setHubBeschleunigung (beschl);
     else if (baustein [bstNr]->Basistyp () == tMehrfachLader)
      ((typMehrfachLader*) baustein [bstNr])->setHubBeschleunigung (beschl);
     else sim_error ("SFXPRG", "setHubBeschleunigung", 
                     "Bst ist kein Wagen, MehrfachLader oder Kran", bstNr, FATAL);
  }
  else (void) sim_error ("SFXPRG", "setHubBeschleunigung", 
                         "Bst nicht vorhanden", bstNr, FATAL);
}

void setHubVerzoegerung (unsigned bstNr, double verz) {
  if (baustein [bstNr]) {
    if (baustein [bstNr]->Basistyp() == tVerteilwagen)
      ((typVerteilwagen*) baustein [bstNr])->setHubVerzoegerung (verz);
    else if (baustein [bstNr]->Basistyp () == tLaufkran)
      ((typLaufkran*) baustein [bstNr])->setHubVerzoegerung (verz);
    else if (baustein [bstNr]->Basistyp () == tMehrfachLader)
      ((typMehrfachLader*) baustein [bstNr])->setHubVerzoegerung (verz);
    else sim_error ("SFXPRG", "setHubVerzoegerung", 
                    "Bst ist kein Wagen, MehrfachLader oder Kran", bstNr, FATAL);
  }
  else (void) sim_error ("SFXPRG", "setHubVerzoegerung", 
                         "Bst nicht vorhanden", bstNr, FATAL);
}


void setQuerGeschwindigkeit (unsigned bstNr, double geschw) {
  if (baustein [bstNr]) {
     if (baustein [bstNr]->Basistyp () == tMehrfachLader)
      ((typMehrfachLader*) baustein [bstNr])->setQuerGeschwindigkeit (geschw);
      /*
     else if (baustein [bstNr]->Basistyp () == tVerteilwagen)
       ((typVerteilwagen*) baustein [bstNr])->setQuerGeschwindigkeit (geschw);
     else if (baustein [bstNr]->Basistyp () == tLaufkran)
      ((typLaufkran*) baustein [bstNr])->setQuerGeschwindigkeit (geschw);
     */
     else sim_error ("SFXPRG", "setHubGeschwindigkeit", 
                     "Bst ist kein Wagen, MehrfachLader oder Kran", bstNr, FATAL);
  }
  else (void) sim_error ("SFXPRG", "setHubGeschwindigkeit", 
                         "Bst nicht vorhanden", bstNr, FATAL);
}

void setQuerBeschleunigung (unsigned bstNr, double beschl) {
  if (baustein [bstNr]) {
     if (baustein [bstNr]->Basistyp () == tMehrfachLader)
      ((typMehrfachLader*) baustein [bstNr])->setQuerBeschleunigung (beschl);
     
     /*else if (baustein [bstNr]->Basistyp() == tVerteilwagen)
       ((typVerteilwagen*) baustein [bstNr])->setQuerBeschleunigung (beschl);
     else if (baustein [bstNr]->Basistyp () == tLaufkran)
      ((typLaufkran*) baustein [bstNr])->setQuerBeschleunigung (beschl);
     */
     else sim_error ("SFXPRG", "setHubBeschleunigung", 
                     "Bst ist kein Wagen, MehrfachLader oder Kran", bstNr, FATAL);
  }
  else (void) sim_error ("SFXPRG", "setHubBeschleunigung", 
                         "Bst nicht vorhanden", bstNr, FATAL);
}

void setQuerVerzoegerung (unsigned bstNr, double verz) {
  if (baustein [bstNr]) {
    if (baustein [bstNr]->Basistyp () == tMehrfachLader)
      ((typMehrfachLader*) baustein [bstNr])->setQuerVerzoegerung (verz);
    /*
    else if (baustein [bstNr]->Basistyp() == tVerteilwagen)
      ((typVerteilwagen*) baustein [bstNr])->setQuerVerzoegerung (verz);
    else if (baustein [bstNr]->Basistyp () == tLaufkran)
      ((typLaufkran*) baustein [bstNr])->setQuerVerzoegerung (verz);
    */
    else sim_error ("SFXPRG", "setHubVerzoegerung", 
                    "Bst ist kein Wagen, MehrfachLader oder Kran", bstNr, FATAL);
  }
  else (void) sim_error ("SFXPRG", "setHubVerzoegerung", 
                         "Bst nicht vorhanden", bstNr, FATAL);
}




//---------------------------------------------------------
//-------------------- ArbeitsplanBde----------------------
//---------------------------------------------------------

unsigned AnzArbeitsplaeneEin (unsigned arbNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  return (zA ? zA->TempEin () : 
    sim_error ("SFXPRG", "AnzArbeitsplaeneEin", 
               "Arbeitsplan nicht vorhanden", arbNr, FATAL));
}

unsigned AnzArbeitsplaeneAus (unsigned arbNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  return (zA ? zA->TempAus () : 
    sim_error ("SFXPRG", "AnzArbeitsplaeneAus", 
               "Arbeitsplan nicht vorhanden", arbNr, FATAL));
}

SimTime SummeVorgangszeiten  (unsigned arbNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  return (zA ? zA->SummeVorgangszeit () :
    (SimTime) sim_error ("SFXPRG", "SummeVorgangszeiten",
               "Arbeitsplan nicht vorhanden", arbNr, FATAL));
}

SimTime MinDurchlaufzeit (unsigned arbNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  return ((zA && zA->DlzRegister ()) ?
    SimTime ((zA->DlzRegister ()->Min () == DBL_MAX ?
             0.0 : 
             zA->DlzRegister ()->Min () * SimTime::SecondsPerMinute ())) :
    (SimTime) sim_error ("SFXPRG", "MinDurchlaufzeit",
              "Arbeitsplan nicht vorhanden oder hat keine Messwerterfassung",
              arbNr, FATAL));
}

SimTime MitDurchlaufzeit (unsigned arbNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  return ((zA && zA->DlzRegister ()) ?
     SimTime (zA->DlzRegister ()->Mittel () * SimTime::SecondsPerMinute ()) :
    (SimTime) sim_error ("SFXPRG", "MitDurchlaufzeit",
              "Arbeitsplan nicht vorhanden oder hat keine Messwerterfassung",
              arbNr, FATAL));
}

SimTime MaxDurchlaufzeit (unsigned arbNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  return ((zA && zA->DlzRegister ()) ?
  SimTime ((zA->DlzRegister ()->Max () == -DBL_MAX ?
             0.0 : 
             zA->DlzRegister ()->Max () * SimTime::SecondsPerMinute ())) :
  (SimTime) sim_error ("SFXPRG", "MaxDurchlaufzeit",
            "Arbeitsplan nicht vorhanden oder hat keine Messwerterfassung",
            arbNr, FATAL));
}

void resetDurchlaufzeit (unsigned arbNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  if (zA && zA->DlzRegister ()) zA->DlzRegister ()->reset ();
  else
    sim_error ("SFXPRG", "resetDurchlaufzeit", 
    "Arbeitsplan oder Messwerterfassung nicht vorhanden", arbNr, FATAL);
}

void compressDurchlaufzeit (unsigned arbNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  if (zA && zA->DlzRegister ()) zA->DlzRegister ()->compress ();
  else
    sim_error ("SFXPRG", "compressDurchlaufzeit", 
    "Arbeitsplan oder Messwerterfassung nicht vorhanden", arbNr, FATAL);
}

//---------------------------------------------------------
//-------------------- BausteinBde-------------------------
//---------------------------------------------------------

double MinAuslastung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->AuslGeschichte ())
          ? (baustein [bstNr]->AuslGeschichte ()->Min () == DBL_MAX) ?
            0.0 : baustein [bstNr]->AuslGeschichte ()->Min ()
          : sim_error ("SFXPRG", "MinAuslastung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

double MitAuslastung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->AuslGeschichte ())
          ? baustein [bstNr]->AuslGeschichte ()->Mittel ()
          : sim_error ("SFXPRG", "MitAuslastung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

double MaxAuslastung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->AuslGeschichte ())
          ? (baustein [bstNr]->AuslGeschichte ()->Max () == -DBL_MAX) ?
            0.0 : baustein [bstNr]->AuslGeschichte ()->Max ()
          : sim_error ("SFXPRG", "MaxAuslastung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

void resetAuslastung (unsigned bstNr) {
  if (baustein [bstNr] && baustein [bstNr]->AuslGeschichte ())
    baustein [bstNr]->AuslGeschichte ()->reset ();
  else
    sim_error ("SFXPRG", "resetAuslastung", 
               "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

void compressAuslastung (unsigned bstNr) {
  if (baustein [bstNr] && baustein [bstNr]->AuslGeschichte ())
    baustein [bstNr]->AuslGeschichte ()->compress ();
  else
    sim_error ("SFXPRG", "compressAuslastung", 
               "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

double MinBelegung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->BelGeschichte ())
      ? (baustein [bstNr]->BelGeschichte ()->Min () == DBL_MAX) ?
            0.0 : baustein [bstNr]->BelGeschichte ()->Min ()
      : sim_error ("SFXPRG", "MinBelegung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

double MitBelegung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->BelGeschichte ())
          ? baustein [bstNr]->BelGeschichte ()->Mittel ()
          : sim_error ("SFXPRG", "MitBelegung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

double MaxBelegung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->BelGeschichte ())
          ? (baustein [bstNr]->BelGeschichte ()->Max () == -DBL_MAX) ?
             0.0 : baustein [bstNr]->BelGeschichte ()->Max ()
          : sim_error ("SFXPRG", "MaxBelegung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

void resetBelegung (unsigned bstNr) {
  if (baustein [bstNr] && baustein [bstNr]->BelGeschichte ())
    baustein [bstNr]->BelGeschichte ()->reset ();
  else
    sim_error ("SFXPRG", "resetBelegung", 
               "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

void compressBelegung (unsigned bstNr) {
  if (baustein [bstNr] && baustein [bstNr]->BelGeschichte ())
    baustein [bstNr]->BelGeschichte ()->compress ();
  else
    sim_error ("SFXPRG", "compressBelegung", 
               "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

double MinStoerung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->StoerGeschichte ())
          ? (baustein [bstNr]->StoerGeschichte ()->Min () == DBL_MAX) ?
             0.0 : baustein [bstNr]->StoerGeschichte ()->Min ()
          : sim_error ("SFXPRG", "MinStoerung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

double MitStoerung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->StoerGeschichte ())
          ? baustein [bstNr]->StoerGeschichte ()->Mittel ()
          : sim_error ("SFXPRG", "MitStoerung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

double MaxStoerung (unsigned bstNr) {
  return (baustein [bstNr] && baustein [bstNr]->StoerGeschichte ())
          ? (baustein [bstNr]->StoerGeschichte ()->Max () == -DBL_MAX) ?
             0.0 : baustein [bstNr]->StoerGeschichte ()->Max ()
          : sim_error ("SFXPRG", "MaxStoerung", 
            "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

void resetStoerung (unsigned bstNr) {
  if (baustein [bstNr] && baustein [bstNr]->StoerGeschichte ())
    baustein [bstNr]->StoerGeschichte ()->reset ();
  else
    sim_error ("SFXPRG", "resetStoerung", 
               "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}

void compressStoerung (unsigned bstNr) {
  if (baustein [bstNr] && baustein [bstNr]->StoerGeschichte ())
    baustein [bstNr]->StoerGeschichte ()->compress ();
  else
    sim_error ("SFXPRG", "compressStoerung", 
               "Bst oder Messwerterfassung nicht vorhanden", bstNr, FATAL);
}
//---------------------------------------------------------
//-------- Attribute der Arbeitsplaene      ---------------
//---------------------------------------------------------

SimTime ArbVorgangszeit (unsigned arbNr, unsigned vorgNr) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  if (!zA) sim_error ("SFXPRG", "ArbVorgangszeit", 
           "Arbeitsplan nicht vorhanden", arbNr, FATAL);
  typVorgang* zV = zA->findeVorgang (vorgNr);
  if (!zV) sim_error ("SFXPRG", "ArbVorgangszeit", 
           "Vorgang nicht vorhanden", vorgNr, FATAL);
  return zV->Dauer ();
}

void setArbVorgangszeit (unsigned arbNr, unsigned vorgNr, const SimTime& zeit) {
  typArbeitsplan* zA = MySFXModel->findWorkSchedule (arbNr);
  if (!zA) sim_error ("SFXPRG", "setArbVorgangszeit", 
           "Arbeitsplan nicht vorhanden", arbNr, FATAL);
  typVorgang* zV = zA->findeVorgang (vorgNr);
  if (!zV) sim_error ("SFXPRG", "setArbVorgangszeit", 
           "Vorgang nicht vorhanden", vorgNr, FATAL);
  zV->setDauer (zeit);
}

//---------------------------------------------------------
//-------- Attribute der Transporteinheiten ---------------
//---------------------------------------------------------

SimTime Vorgangszeit (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? TE->Vorgang ()->Dauer () :
    (SimTime) sim_error ("SFXPRG", "Vorgangszeit",
              "Transporteinheit nicht vorhanden", BstNr (), FATAL));
}

unsigned VorgangsNr (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? TE->Vorgang ()->Nummer () :
    sim_error ("SFXPRG", "VorgangsNr", "Transporteinheit nicht vorhanden",
                BstNr (), FATAL));
}

SimTime TELaufzeit (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? TE->Laufzeit () :
    (SimTime) sim_error ("SFXPRG", "Laufzeit",
              "Transporteinheit nicht vorhanden", BstNr (), FATAL));
}

SimTime TEStartzeit (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? (Modellzeit () - TE->Laufzeit ()) :
    (SimTime) sim_error ("SFXPRG", "Startzeit",
              "Transporteinheit nicht vorhanden", BstNr (), FATAL));
}

unsigned ArbeitsplanNr (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? TE->Arbeitsplan()->Nummer () :
    sim_error ("SFXPRG", "ArbeitsplanNr", "Transporteinheit nicht vorhanden",
                BstNr (), FATAL));
}

unsigned ArtikelNr (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? TE->Artikel () :
    sim_error ("SFXPRG", "ArtikelNr", "Transporteinheit nicht vorhanden",
                BstNr (), FATAL));
}

void setArtikelNr (unsigned bstNr, unsigned artNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  if (TE) TE->setArtikel (artNr);
  else (void) sim_error ("SFXPRG", "setArtikelNr", 
              "Transporteinheit nicht vorhanden", BstNr (), FATAL);
}

unsigned TEVariante (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? TE->Variante () :
    sim_error ("SFXPRG", "TEVariante", "Transporteinheit nicht vorhanden",
                BstNr (), FATAL));
  //return ((TE) ? TE->Arbeitsplan ()->Palettenvariante () :
  //  sim_error ("SFXPRG", "TEVariante", "Transporteinheit nicht vorhanden",
  //              BstNr (), FATAL));
}

void setTEVariante (unsigned bstNr, unsigned vari, unsigned unterVari /*= 1*/) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  if (TE) TE->setVariante (vari, unterVari);
  else sim_error ("SFXPRG", "setTEVariante", 
                  "Transporteinheit nicht vorhanden", BstNr (), FATAL);
}

int TEPrioritaet (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? TE->Prioritaet () :
    sim_error ("SFXPRG", "TEPrioritaet", "Transporteinheit nicht vorhanden",
                BstNr (), FATAL));
}

void setTEPrioritaet (unsigned bstNr, int prio) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  if (TE) TE->setPrioritaet (prio);
  else (void) sim_error ("SFXPRG", "setTEPrioritaet", 
              "Transporteinheit nicht vorhanden", BstNr (), FATAL);
}

double TEMenge (unsigned bstNr) {
  return ((baustein [bstNr] && baustein [bstNr]->TransportEinheit ())
           ? baustein [bstNr]->TransportEinheit ()->Menge ()
           : sim_error ("SFXPRG", "Menge", 
             "Bst nicht vorhanden oder hat kein TransportEinheit", 
             bstNr, FATAL));
}

double incTEMenge (unsigned bstNr, double menge /*= 1.0*/) {
  return ((baustein [bstNr] && baustein [bstNr]->TransportEinheit ())
           ? baustein [bstNr]->TransportEinheit ()->incMenge (menge)
           : sim_error ("SFXPRG", "incMenge", 
             "Bst nicht vorhanden oder hat kein TransportEinheit",
             bstNr, FATAL));
}

double decTEMenge (unsigned bstNr, double menge /*= 1.0*/) {
  return ((baustein [bstNr] && baustein [bstNr]->TransportEinheit ())
           ? baustein [bstNr]->TransportEinheit ()->decMenge (menge)
           : sim_error ("SFXPRG", "decMenge", 
             "Bst nicht vorhanden oder hat kein TransportEinheit", 
             bstNr, FATAL));
}

unsigned TEProgrammNr (unsigned bstNr) {
  typTransportEinheit *TE = baustein [bstNr]->TransportEinheit ();
  return ((TE) ? TE->Vorgang ()->ProgNr () :
    sim_error ("SFXPRG", "TEProgrammNr", "Transporteinheit nicht vorhanden",
                BstNr (), FATAL));
}

double setTEMenge (unsigned bstNr, double menge) {
  return ((baustein [bstNr] && baustein [bstNr]->TransportEinheit ())
           ? baustein [bstNr]->TransportEinheit ()->setMenge (menge)
           : sim_error ("SFXPRG", "setMenge",
             "Bst nicht vorhanden oder hat keine TransportEinheit", 
             bstNr, FATAL));
}

UserData *TEUserData (unsigned bstNr) {
  return ((baustein [bstNr]->TransportEinheit ()) ?
    baustein [bstNr]->TransportEinheit ()->getUserData () :
    (UserData*) sim_error ("SFXPRG", "TeUserData", 
                "TransportEinheit nicht vorhanden", bstNr, FATAL));
}

void setTEUserData (unsigned bstNr, UserData *Data) {
  (baustein [bstNr]->TransportEinheit ()) ?
    baustein [bstNr]->TransportEinheit ()->setUserData (Data) :
    (void) sim_error ("SFXPRG", "setTeUserData", 
                      "Transporteinheit nicht vorhanden", bstNr, FATAL);
}

// !!!!!!!!!!! Sicherheitsluecke !!!!!!!!!!!!!

// Dies sollte in der jeweiligen ModellDatei geschehen
// Wer was anlegt, sollte es auch selber wieder loeschen und
// seine eigenen Zeiger auch wieder zuruecksetzen koennen !!!
void loescheTEUserData (unsigned bstNr) {
  if (baustein [bstNr]->TransportEinheit ()) {
    if (baustein [bstNr]->TransportEinheit ()->getUserData ())
      delete baustein [bstNr]->TransportEinheit ()->resetUserData ();
  }
  else
    (void) sim_error ("SFXPRG", "loescheTeUserData", 
                      "Transporteinheit nicht vorhanden", bstNr, FATAL);
}

void dreheTE (unsigned bstNr, const Angle& ang) {
  if (baustein [bstNr] && baustein [bstNr]->TransportEinheit ())
    baustein [bstNr]->TransportEinheit ()->drehen (ang);
  else sim_error ("SFXPRG", "dreheTE",
                  "Bst nicht vorhanden oder hat keine TransportEinheit",
                  bstNr, FATAL);
}

void ausrichtenTE (unsigned bstNr, const Angle& ang) {
  if (baustein [bstNr] && baustein [bstNr]->TransportEinheit ())
    baustein [bstNr]->TransportEinheit ()->ausrichten (ang);
  else sim_error ("SFXPRG", "ausrichtenTE",
                  "Bst nicht vorhanden oder hat keine TransportEinheit",
                   bstNr, FATAL);
}

void bewegeTE (unsigned bstNr, const Vec3D& v) {
  if (baustein [bstNr] && baustein [bstNr]->TransportEinheit ())
    baustein [bstNr]->TransportEinheit ()->bewegen (v);
  else sim_error ("SFXPRG", "bewegeTE",
                  "Bst nicht vorhanden oder hat keine TransportEinheit",
                  bstNr, FATAL);
}

void positioniereTE (unsigned bstNr, const Vec3D& v) {
  if (baustein [bstNr] && baustein [bstNr]->TransportEinheit ())
    baustein [bstNr]->TransportEinheit ()->positionieren (v);
  else sim_error ("SFXPRG", "positioniereTE",
                  "Bst nicht vorhanden oder hat keine TransportEinheit",
                  bstNr, FATAL);
}

//---------------------------------------------------------
//-------------------- Anweisungen ------------------------
//---------------------------------------------------------

void aufnehmen () {
  if (MySFXModel->PrgDebug ()) 
    dprintf ("PRG AUFNEHMEN auf Bst %d\n", BstNr ());
  planesofort (ETaaufnehmen, BstNr ());
  PrgModul->interruptUserProg ();
}

void arbeiten (SimTime arbZeit, unsigned ncprognr) {
  if (MySFXModel->PrgDebug ()) dprintf ("PRG ARBEITEN auf Bst %d\n", BstNr ());
  ((typPrgBaustein*) PrgModul->getProgBst ())->setPRG_ArbZeit (arbZeit);
  planesofort (ETaarbeiten, BstNr (), ncprognr);
  PrgModul->interruptUserProg ();
}

void abgeben (unsigned vorgNr) {
  if (MySFXModel->PrgDebug ()) dprintf ("PRG ABGEBEN auf Bst %d\n", BstNr ());
  if (vorgNr)
    PrgModul->getProgBst ()->TransportEinheit ()->schalteVorgang (vorgNr);
  planesofort (ETameldewarten, BstNr ());
  PrgModul->interruptUserProg ();
}

void schlafen (SimTime zeit) {
  if (MySFXModel->PrgDebug ()) dprintf ("PRG SCHLAFEN auf Bst %d\n", BstNr ());
  PrgModul->getProgBst ()->setZustand (SCHLAFEN);
  planedelta (zeit, ETwecken, BstNr (), 0);
  PrgModul->interruptUserProg ();
}

void warten () {
  if (MySFXModel->PrgDebug ()) dprintf ("PRG WARTEN auf Bst %d\n",  BstNr ());
  PrgModul->getProgBst ()->setZustand (PRGWARTEN);
  PrgModul->interruptUserProg ();
}

// aktivieren wurde erweitert um eine Zeit: -1.0 bedeutet gliedere das Aktivieren vor alle anderen
// Zeit: 0.0 gliedere das Aktivieren hinter alle mit der Zeit 0.0
void aktivieren (unsigned bstNr, SimTime delta /* = -1.0 */, unsigned vonbstNr /* = 0 */) {
  if (MySFXModel->PrgDebug ()) dprintf ("PRG AKTIVIEREN auf Bst %d\n", bstNr);
  if (delta < SimTime (0.0)) planesofort (ETaktivieren, bstNr, vonbstNr);
  else planedelta (delta, ETaktivieren, bstNr, vonbstNr);
}

void bestelleArbeitsplan (unsigned arbNr, unsigned bstNr, 
                          unsigned wieoft   /* = 1 */, 
                          unsigned istVorg  /* = 0 */ , 
                          unsigned sollVorg /* = 0 */) {
  if (MySFXModel->PrgDebug ())
    dprintf (
   "PRG BESTELLE Arbeitsplan %d auf Bst %d wieoft %i istVorg %i sollVorg %i\n",
    arbNr, bstNr, wieoft, istVorg, sollVorg);
  if (baustein [bstNr])
    baustein [bstNr]->ArbBestellung (arbNr, istVorg, sollVorg, wieoft);
  else
    sim_error ("SFXPRG", "bestelleArbeitsplan", "Bst nicht vorhanden", 
               bstNr, FATAL);
}

void bestelleTE (typTransportEinheit *TE, unsigned bstNr, unsigned sollVorg /* = 0 */) {
  if (MySFXModel->PrgDebug ())
    dprintf (
      "PRG BESTELLE TE %i auf Bst %d sollVorg %i\n",
      TE->ID(), bstNr, sollVorg);
  if (baustein [bstNr])
    baustein [bstNr]->TEBestellung(TE, sollVorg);
  else
    sim_error ("SFXPRG", "TEBestellung", "Bst nicht vorhanden",
               bstNr, FATAL);
}

void bestelleArtikel (unsigned artNr, unsigned bstNr, unsigned wieoft /* = 1*/,
                  unsigned istVorg /* = 0 */, unsigned sollVorg /* = 0 */) {
  if (MySFXModel->PrgDebug ())
    dprintf (
      "PRG BESTELLE ARTIKEL %d auf Bst %d wieoft %i istVorg %i sollVorg %i\n",
      artNr, bstNr, wieoft, istVorg, sollVorg);
  if (baustein [bstNr])
    baustein [bstNr]->ArtBestellung (artNr, istVorg, sollVorg, wieoft);
  else
    sim_error ("SFXPRG", "bestelleArtikel", "Bst nicht vorhanden",
               bstNr, FATAL);
}

void storniereArbeitsplan (unsigned arbNr, unsigned bstNr,
                           unsigned istVorg /* = 0 */) {
  if (MySFXModel->PrgDebug ())
    dprintf ("PRG STORNIERE Arbeitsplan %i auf Bst %d istVorg %i\n",
             arbNr, bstNr, istVorg);
  if (baustein [bstNr])
    baustein [bstNr]->loescheArbBestellung (arbNr, istVorg);
  else
    sim_error ("SFXPRG", "storniereArbeitsplan", "Baustein nicht vorhanden",
               bstNr, FATAL);
}

void storniereTE (typTransportEinheit *TE, unsigned bstNr) {
  if (MySFXModel->PrgDebug ())
    dprintf ("PRG STORNIERE TE %i auf Bst %d\n",
             TE->ID(), bstNr);
  if (baustein [bstNr])
    baustein [bstNr]->loescheTEBestellung (TE);
  else
    sim_error ("SFXPRG", "storniereTE", "Baustein nicht vorhanden",
               bstNr, FATAL);
}

void storniereArtikel (unsigned artNr, unsigned bstNr,
                       unsigned istVorg /* = 0 */) {
  if (MySFXModel->PrgDebug ())
    dprintf ("PRG STORNIERE ARTIKEL %i auf Bst %d istVorg %i\n",
             artNr, bstNr, istVorg);
  if (baustein [bstNr])
    baustein [bstNr]->loescheArtBestellung (artNr, istVorg);
  else
    sim_error ("SFXPRG", "storniereArtikel", "Baustein nicht vorhanden",
               bstNr, FATAL);
}

void zuweisenArbeitsplan (unsigned arbNr, unsigned vonBstNr,
                          unsigned nachBstNr, unsigned wieoft /* = 1 */,
                          unsigned istVorg /* = 0 */,
                          unsigned sollVorg /* = 0 */) {
  if (MySFXModel->PrgDebug ())
    dprintf ("PRG ZUWEISUNG ARBEITSPLAN %i von Bst %i nach Bst %i wieoft %i istVorg %i sollVorg %i\n",
             arbNr, vonBstNr, nachBstNr, wieoft, istVorg, sollVorg);
  if (baustein [vonBstNr])
    baustein [vonBstNr]->ArbZuweisen (arbNr, nachBstNr, istVorg, sollVorg,
                                      wieoft);
  else
    sim_error ("SFXPRG", "ZuweisungArbeitsplan", "Bst nicht vorhanden",
               vonBstNr, FATAL);
}

void zuweisenArtikel (unsigned artNr, unsigned vonBstNr, unsigned nachBstNr,
                      unsigned wieoft /* = 1 */, unsigned istVorg /* = 0 */,
                      unsigned sollVorg /* = 0 */) {
  if (MySFXModel->PrgDebug ())
    dprintf ("PRG ZUWEISUNG ARTIKEL %i von Bst %i nach Bst %i wieoft %i istVorg %i sollVorg %i\n",
             artNr, vonBstNr, nachBstNr, wieoft, istVorg, sollVorg);
  if (baustein [vonBstNr])
    baustein [vonBstNr]->ArtZuweisen (artNr, nachBstNr, istVorg, sollVorg,
                                      wieoft);
  else
    sim_error ("SFXPRG", "ZuweisungArtikel", "Bst nicht vorhanden",
               vonBstNr, FATAL);
}

void planeSofort (unsigned eTyp, int info1, int info2, int info3) {
  planesofort (eTyp, info1, info2, info3);
}

void planeEin (const SimTime& zeit, unsigned eTyp, int info1, int info2, 
               int info3) {
  planeein (zeit, eTyp, info1, info2, info3);
}

void planeDelta (const SimTime& zeit, unsigned eTyp, int info1, int info2, 
                 int info3) {
  planedelta (zeit, eTyp, info1, info2, info3);
}

double zufallszahl (unsigned prozNr, unsigned zeile) {
  typPRGProzess *zPr = (typPRGProzess*) MySFXModel->findProcess (prozNr);
  if (zPr)
    return (zeile == 1) ? zPr->ZufV1 () : zPr->ZufV2 ();
  return 0.0;
}
void PrgProzess (unsigned prozNr, int Art, float v1_min, float v1_mittel, float v1_max, int v1_start, float v2_min, float v2_mittel, float v2_max, int v2_start) {
   if (Art != 1) {
      sim_error("Sfxprg.cpp","PrgProzess","Art ist ungleich 1","",FATAL);
   }
   else if (MySFXModel->findProcess (prozNr, false)) {
      sim_error("Sfxprg.cpp","PrgProzess","Prozess bereits vorhanden. Nummer ",prozNr,FATAL);
   }
   else {
      typPRGProzess *proz = new typPRGProzess (prozNr, Art, v1_min, v1_mittel, v1_max, v1_start, v2_min, v2_mittel, v2_max, v2_start);
      MySFXModel->ObjProcesses.append (*proz);  
      //dprintf ("PrgProzess Nr %i erzeugt\n", prozNr);
   }
}


void syncBst (unsigned bstNr) {
  if (MySFXModel->PrgDebug ()) 
    dprintf ("PRG SYNCBST BST %d mit Bst %d\n", BstNr (), bstNr);
  if (!baustein[bstNr])
    sim_error ("FFSPRG", "syncBst", "Bst nicht vorhanden", bstNr, FATAL);    

  if (baustein[BstNr ()]->SyncPartner () > 0) 
    sim_error ("FFSPRG", "syncBst", "sync nicht richtig beendet",
               bstNr, FATAL);    
  
  if (baustein[bstNr]->SyncPartner () == This) {
    baustein[bstNr]->setZustand (PRGWARTEN);
    baustein[bstNr]->setSyncPartner (0);
    aktivieren (bstNr);
  }
  else {
    baustein[This]->setZustand (SYNCWARTEN);
    baustein[This]->setSyncPartner (bstNr);
    PrgModul->interruptUserProg ();
  }
}

void simAbbruch () {
  MySFXModel->stop ();
  modelOpen = false;
}

void DebugTraceEin () { MySFXModel->setPrgDebug (true); }

void DebugTraceAus () { MySFXModel->setPrgDebug (false); }

bool ausrichtenAufBst (unsigned bstNr, unsigned AufBstNr) {
  return ((baustein [bstNr] && baustein [AufBstNr])
          ? baustein [bstNr]->ausrichtenAufBaustein (baustein [AufBstNr])
          : false);
}
bool immerausrichtenAufBst (unsigned bstNr, unsigned AufBstNr, bool heben /*=true*/){
   return ((baustein [bstNr] && baustein [AufBstNr])
          ? baustein [bstNr]->immerausrichtenAufBaustein (baustein [AufBstNr], heben)
          : false);
}

void dreheBst (unsigned bstNr, const Angle& ang) {
  if (baustein [bstNr])
    baustein [bstNr]->drehen (ang);
  else sim_error ("SFXPRG", "dreheBst",
                  "Bst nicht vorhanden",
                  bstNr, FATAL);
}

void ausrichtenBst (unsigned bstNr, const Angle& ang) {
  if (baustein [bstNr])
    baustein [bstNr]->ausrichten (ang);
  else sim_error ("SFXPRG", "ausrichtenBst",
                  "Bst nicht vorhanden",
                   bstNr, FATAL);
}

void bewegeBst (unsigned bstNr, const Vec3D& v) {
  if (baustein [bstNr])
    baustein [bstNr]->bewegen (v);
  else sim_error ("SFXPRG", "bewegeBst",
                  "Bst nicht vorhanden",
                  bstNr, FATAL);
}

void positioniereBst (unsigned bstNr, const Vec3D& v) {
  if (baustein [bstNr])
    baustein [bstNr]->positionieren (v);
  else sim_error ("SFXPRG", "positioniereBst",
                  "Bst nicht vorhanden",
                  bstNr, FATAL);
}

//---------------------------------------------------------
//-------------------- Verwaltung -------------------------
//---------------------------------------------------------

void installEvent (unsigned eTyp, unsigned bstNr, char* fname) {
  PrgModul->installEvent (eTyp, bstNr, fname);
}

unsigned removeEvent (unsigned eTyp, unsigned bstNr) {
  return PrgModul->removeEvent (eTyp, bstNr);
}

void installProg (unsigned nr) {
  PrgModul->installProg (nr);
}

unsigned removeProg (unsigned nr) {
  return PrgModul->removeProg (nr);
}

void DateiMitModellPfad (Ustring &datName) {
  datName = MySFXModel->ModelPath () + datName;
}

Ustring GibModellPfad() {
  return MySFXModel->ModelPath ();
}
//---------------------------------------------------------
//-------------------- HLA-Kommunikation ------------------
//---------------------------------------------------------
/* Folgender Aufruf geht an die Realzeit.cpp
 * 
 */
void Hla_SendInteractionWithClassAndParameterName (double EreignisZeit, int ETyp, int BausteinNr, int ArbPlNr, int Menge, const char* className, const char* parName) {
  HLA_SendInteractionWithClassAndParName (EreignisZeit,ETyp,BausteinNr,ArbPlNr,Menge,className,parName);
}

void Hla_SendInteractionMessageWithClassAndParameterName (const char* iaMessage, const char* className, const char* parName) {
  HLA_SendInteractionMessageWithClassAndParName (iaMessage,className,parName);
}


const char* istHlaInteractionVorhanden () {
  // liefert die erste Nachricht in der Liste zurueck
  return HLA_GetReceivedInteraction ();
}

void Hla_PublishObject (const char* className, int bstNr, DynArray<char> &attribs) {
  HLA_PublishObject (className, bstNr, attribs);
}	

void Hla_SubscribeObject (const char* className, DynArray<char> &attribs) {
  HLA_SubscribeObject (className, attribs);                                    
}

//---------------------------------------------------------
bool VerzeichnisVorhanden (Ustring dirName) {
  const char *name = dirName.str();
  return (FileSystem::DirExists (name)) ? true : false;
}
			 
/**< Ergaenzt, um Ausgaben in verschiedenen Verzeichnisse umlenken zu koennen. Rudi: 02.08.2002.*/
Ustring GibAusgabePfad() {
  //return (MySFXModel->OutputPath () + Ustring("\\"));
  return MySFXModel->OutputPath ();
}

//Lars 
GeoObject* ErzeugeGeoObject(unsigned bstNr,Vec3D v){
	return baustein [bstNr]->ErzeugeGeoObject(v);
	
}


/**
 * BauteinAnpassen veraendert Groesse des Bausteins.
 * Palettenplatz wird verschonben.
 * @param BstNr Bausteinnummer
 * @param scale ???
 * @param Pal ???
 */
void BausteinAnpassen (unsigned bstNr, Vec3D scale,int pal) {
  GeoObject* geoObj = new GeoObject ();
  geoObj->copyContents (*(baustein[bstNr]->GibGeoObject()));
  geoObj->setParent (*(baustein[bstNr]->GibGeoObject()));
  geoObj->setPos(Vec3D(0,0,0));
  geoObj->setScale(scale,1);
	
  /**< PalPlatz verschieben.*/
  baustein[bstNr]->gibPlatz()->movePosition(Vec3D(0.07*scale.X() * pal,0,0));
}


/**

 * Ende der Modellzeit geschlosen wird.
 */
 void SimulatorBeenden() {
  Sfx3D_on = false;
}
//---------------------------------------------------------
//------------------- Std-Programm ------------------------
//---------------------------------------------------------

void prog_0 () {
  aufnehmen ();
  arbeiten ();
  abgeben (0);
}

 /* sfxprg.cpp */
