dsim_model.h

Go to the documentation of this file.

/*
 *  dsim_model.h
 *  DSimEngine2
 *
 *  Created by David Wilson on 3/16/09.
 *  Copyright 2009 Princeton Satellite Systems. All rights reserved.
 *
 */

#ifndef __DSIM_MODEL__
#define __DSIM_MODEL__

#include "dsim_variable.h"
#include "dsim_value.h"
#include "dsim_network.h"
#include <vector>
#include <map>
#include <string>

class dsim_integrator;
class dsim_simulation;
class dsim_model_setup;

class dsim_outlet
{
    public:
        dsim_outlet() :
            name(),
            units(),
            description(),
            type(sd_type_invalid),
            dependent(false),
            variable(NULL)
        {
        }
        dsim_outlet(const char *oname,int otype,const char *ounits,const char *odescription,dsim_variable *ovariable,bool odependent) :
            name(oname),
            units(ounits),
            description(odescription),
            type(otype),
            dependent(odependent),
            variable(ovariable)
        {
        }
        dsim_outlet(const dsim_outlet &base) :
            name(base.name),
            units(base.units),
            description(base.description),
            type(base.type),
            dependent(base.dependent),
            variable(base.variable)
        {
        }
        dsim_outlet &operator=(const dsim_outlet &base)
        {
            name = base.name;
            units = base.units;
            description = base.description;
            type = base.type;
            variable = base.variable;
            dependent = base.dependent;
            return *this;
        }
        
        std::string name;
        std::string units;
        std::string description;
        int type;
        bool dependent;
        dsim_variable *variable;
};

class dsim_target
{
    public:
        dsim_target() :
            multiple(false)
        {
        }
        dsim_target(const char *tname,const char *tdescription,bool tmultiple)
        {
            name = tname;
            description = tdescription;
            multiple = tmultiple;
        }
        dsim_target(const dsim_target &base)
        {
            name = base.name;
            description = base.description;
            target_path = base.target_path;
            multiple = base.multiple;
            target_set = base.target_set;
        }
        dsim_target &operator=(const dsim_target &base)
        {
            name = base.name;
            description = base.description;
            target_path = base.target_path;
            multiple = base.multiple;
            target_set = base.target_set;
            return *this;
        }
        
        std::string name;
        std::string description;
        std::string target_path;
        std::vector<std::string> target_set;
        bool multiple;
};

class dsim_model
{
    public:
        dsim_model(dsim_model_setup *setup);
        virtual ~dsim_model();
        
        // Inspection

        const char *name() const;
        const char *path() const;
        dsim_model *parent() const;
        unsigned int child_count() const;
        dsim_model *child_at_index(unsigned int index) const;
        dsim_model *child_with_name(const char *name) const;
    
        // Initialization

        virtual void *describe_setup(void *ds);
        void describe_setup_command(void *ds,const char *command,const char *description);
        virtual bool parse_setup(const char *command,const char *data);
        virtual void initialize_data();
        virtual void initialization_complete();
        
        // Timestep and Integration

        virtual void initialize_timestep();
        virtual void pre_calculate();
        virtual void post_calculate();
        virtual void complete_timestep();
        virtual void rhs(double t,double jd);
        
        // Data lookup and setup

        dsim_variable request_local_variable(const char *name,bool quiet = false);
        dsim_value current_value_for_variable(const char *name);
        bool connect_outlet(const char *name,const dsim_variable &source,const char *source_object = NULL);
        // \}
        
        // Attributes

        void set_attribute(const std::string &ame,const std::string &value);
        bool has_attribute(const std::string &name);
        std::string get_attribute(const std::string &name);
        std::map<std::string,std::string>::iterator attribute_iterator();
        std::map<std::string,std::string>::iterator end_attribute_iterator();
        
        // Object interaction

        virtual dsim_value handle_message(const std::string &sender_path,const std::string &message_name,const dsim_value &argument);
        virtual std::vector<dsim_value> handle_messages(const std::string &sender_path,const std::string &message_name,const std::vector<dsim_value> &arguments);
        
        inline bool should_pre_calculate() { return _call_pre_calculate; }
        inline bool should_integrate() { return _call_rhs; }
        inline bool should_post_calculate() { return _call_post_calculate; }
    protected:
        // Configuration
        void configure_timestep(bool call_pre,bool call_rhs,bool call_post);
        
        // Data Management

        dsim_variable create_parameter(const char *name,int data_type,void *init_value,int rows,int cols,const char *units,const char *description);
        dsim_variable create_input(const char *name,int data_type,void *init_value,int rows,int cols,const char *units,const char *description);
        dsim_variable create_output(const char *name,int data_type,void *init_value,int rows,int cols,const char *units,const char *description);
        dsim_variable create_state(const char *name,int data_type,void *init_value,int rows,int cols,const char *units,const char *description);
        dsim_variable create_integrated_state(const char *name,int data_type,void *init_value,int rows,int cols,const char *units,const char *description);
        
        void create_outlet(dsim_variable &outlet,const char *name,int data_type,const char *units,const char *description,bool dependent = false);
        dsim_variable request_variable(const char *path,bool quiet = false,bool store = true);
        dsim_variable request_hierarchy_variable(const char *path,bool quiet = false);
        
        // Object messaging

        void create_target(const char *toarget_name,const char *target_description,bool multiple = false);
        const char *lookup_target(const char *target_name);
        bool set_target(const char *target_name,const char *target_path);
        const std::vector<std::string> &target_destinations(const std::string &target_name);
        dsim_value send_message(const char *destination,const char *message_name,const dsim_value &argument);
        
        // Object networks

        dsim_network *create_managed_network(const char *name,const char *description);
        dsim_network *managed_network_with_name(const char *name);
        // \}
        
        // Simulation parameters
        double sim_jd() const;
        double sim_time() const;
        double sim_dt() const;
        
        // Error handling and logging
        void error(const char *msg,...) const;
        void warning(const char *msg,...) const;
        void log(const char *msg,...) const;
    
    private:
        // Hierarchy Setup
        void set_parent(dsim_model *parent);
        // Internal Utility
        dsim_variable create_variable(const char *name,dsim_variable::dsim_variable_usage usage,int data_type,void *init_value,int rows,int cols,const char *units,const char *description);
        
        // Integration
        void do_integration_step(int step,double t,double dt);
        
        // Model loading
        static dsim_model *load_model(const char *type,const char *library,dsim_model_setup *setup);
        
        // Setup handling
        bool setup_set_value(int line,const char *variable,const char *value);
        bool setup_set_connection(int line,const char *variable,const char *source);
        
        void annotate_description(ds_dictionary *desc);
        
        dsim_simulation *_simulation;
        
        std::string _name;
        std::string _path;
        
        bool _call_pre_calculate,_call_post_calculate,_call_rhs;
    
        dsim_model *_parent;
        std::vector<dsim_model *> _children;
        
        std::map<std::string,dsim_variable> _variables;
        std::vector<dsim_variable> _integrated_variables;
        std::map<std::string,dsim_outlet> _outlets;
        std::map<std::string,dsim_target> _targets;
        std::map<std::string,dsim_network *> _managed_networks;
        std::map<std::string,std::string> _attributes;
        std::map<std::string,dsim_variable> _stored_variables;
        
        
        dsim_integrator *_integrator;
    
    friend class dsim_simulation;
};

typedef dsim_model *(*dsim_model_factory_t)(dsim_model_setup *);

#endif