streamdrivensystem.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          streamdrivensystem.cpp  -  description
                             -------------------
    begin                : Mon Nov 17 2003
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef STEAM_DRIVEN_SYSTEM_HEADER
#define STEAM_DRIVEN_SYSTEM_HEADER



#include <queue>
#include <map>
#include <iosfwd>
#include <iostream>
#include <string>

#include <simthetic/freeconnectionsystem.h>
#include <simthetic/phbib.h>
#include <simthetic/exceptions.h>
#include <simthetic/basicsimulationsystem.h>
#include <simthetic/devicesystemintf.h>
#include <simthetic/connection.h>
#include <simthetic/basicdevicefactory.h>
#include <simthetic/devicemanager.h>
#include <simthetic/parameterdescription.h>

namespace simth
{

class StreamDrivenSystem : public FreeConnectionSystem
{
  private:
    //std::string loopControlFileName;
    //std::string connectionFileName;
    //std::string deviceFileName;
    std::string parameterOutputFileName;

    // std::queue<Device*> refreshQueue;
    std::queue<Device*> processQueue;

    typedef simth::checkedVector<std::string> StringList;
    StringList libPaths;
    StringList preLoadLibs;
    int startDeviceNumber;
    bool verbose;

    simth::checkedVector<LoopControl*> controls;
    typedef std::map<int, Device*> DeviceMap;
    DeviceMap devices;
    simth::checkedVector<Connection> connections;

    static const std::string const_blockQualifier;

    /* If set to true, the current iteration is stopped */
    bool _isIterationStopped;
    /* If set to true, the complete simulation will be stopped and
    not just the current iteration.
    */
    bool _isStoppedPremature;
    /* Is set to true if the simulation finally
       reached its end.
    */
    bool _reachedEnd;

    virtual LoopControl* loopControl(const std::string& varName);
    virtual Device* device(int deviceNr);




    void nextIteration();

    bool reachedEnd();


    DeviceFactory *createDeviceFactory(const std::string& libName) const;

    DeviceFactory *getDeviceFactory(const std::string &filename) const;

    virtual void connectDevices();
    
    DeviceFactory::FactoryMap getAllFactoryMaps() const;



    // Total wrapper for the version-1 process of loading a device.
    Device *createDeviceByFactoryV1(const std::string& datasetFileName,
                    int deviceNr);

    virtual void initLoopControls(const std::string&);

    virtual void readConnectionTable(const std::string&);
    void readConnectionTablev1(std::ifstream*is);



    // Total wrapper for the version-2 process of loading a device
    // from a FactoryFunc.
    Device *createDeviceByFactoryFunc(const std::string& deviceFileName, 
                      int deviceNr, 
                      const DeviceDescription& dd, 
                      const DeviceFactory::FactoryFunc& factoryfunc, 
                      const std::string& cppname);

    // Retrieves the C++ type name of this device number from the
    // parameter file at filename.
    static std::string getTypeName(const std::string& filename, int deviceNr);

    virtual void initDevices(const std::string& deviceFileName,
                 const DeviceManager::DDMap& ddmap);

    void readConnectionTablev2(std::ifstream* is);



    // Total wrapper for the version-3 process of loading a device
    // from a FactoryFunc with ParameterDescription.
    Device *createDeviceByFactoryFunc(const ParameterDescription& pdescr,
                      int deviceNr, 
                      const DeviceDescription& dd, 
                      const DeviceFactory::FactoryFunc& factoryfunc, 
                      const std::string& cppname);

    void initDevicesV3(const ParameterDescription& pardescr,
               const DeviceManager::DDMap& ddmap);

    void readConnectionTablev3(
    const std::vector<ParameterDescription::Connection>& clist);

    void initLoopControls(const ParameterDescription& pardescr);

    // Retrieves the C++ type name of this device number from the
    // ParameterDescription
    static std::string getTypeName(const ParameterDescription& pdescr, 
                   int deviceNr);

    static const ParameterDescription::Devicevalues& 
    getDevice(const ParameterDescription& pdescr, unsigned deviceNr);

    static const ParameterDescription::Loopvariable& 
    getLoopvar(const ParameterDescription& pdescr, unsigned nr);




  public:

    StreamDrivenSystem(const std::string& fileName);

    virtual ~StreamDrivenSystem();

    virtual void connectInterface(ControlInterface* interface, const std::string& varName);

    virtual const Device* device(int deviceNr) const;

    virtual double mainSimulationLoop(int mode = 0);

    virtual void queueForProcess(Device *dev);

    virtual void stopIteration();

    virtual void stopSimulationPremature();

    virtual void print(std::ostream &os) const;
};


}


#endif

---