schema0.h

Go to the documentation of this file.

/*
  @copyright Steve Keen 2012
  @author Russell Standish
  This file is part of Minsky.

  Minsky 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 3 of the License, or
  (at your option) any later version.

  Minsky 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 Minsky.  If not, see <http://www.gnu.org/licenses/>.
*/


#ifndef SCHEMA_SCHEMA_0
#define SCHEMA_SCHEMA_0

#include "operationType.h"
#include "variableType.h"
#include "assetClass.h"
#include <arrays.h>
#include <plot.h>

namespace schema0
{
  struct Port
  {
    bool input; //true if input port
    double x,y;
    Port(float x=0, float y=0, bool input=false): input(input), x(x), y(y) {}
  };

  struct Wire
  {
    int from, to;
    bool visible; 
    ecolab::array<float> coords;
    Wire(int from=0, int to=0): from(from), to(to), visible(true) {}
  };


  struct Operation
  {
    double x{10}, y{10};
    double value{0}; 
    double rotation{0}; 

    bool visible{true}; 
    minsky::OperationType::Type m_type{minsky::OperationType::numOps};

    bool sliderVisible{false}, sliderBoundsSet{false}, sliderStepRel{false};
    double sliderMin, sliderMax, sliderStep;

    std::string m_description; 
    std::string description; 
    std::vector<int> m_ports;
    int intVar{-1}; 
  };

  struct VariablePtr
  {
    minsky::VariableType::Type m_type;

    double x{0}, y{0}; 
    std::string init{"0"}; 
    std::string name; 
    double rotation{0}; 

    bool visible{true};
    int m_outPort, m_inPort; 
    bool m_godley{false}; 

    bool operator<(const VariablePtr& x) const
    {return name<x.name;}
  };

  // used to support an older schema
  struct Variable: public VariablePtr {};

  struct VariableValue
  {
    minsky::VariableType::Type m_type;
    int m_idx{-1}; 

    std::string init;
    bool godleyOverridden{false};

    VariableValue(minsky::VariableType::Type type=minsky::VariableType::undefined, 
                  const std::string& init="0"): m_type(type), init(init) {}
  };


  struct VariableManager: public std::map<int,Variable>
  {
    typedef std::map<int,Variable> Variables;
    typedef std::map<std::string, VariableValue> VariableValues;
  
    std::set<std::string> wiredVariables; 
    std::map<int, int> portToVariable; 
    VariableValues values; 
  };

  struct GodleyTable
  {
    std::vector<std::vector<std::string> > data;
    std::vector<minsky::GodleyAssetClass::AssetClass> m_assetClass;
    bool doubleEntryCompliant;
    std::string title;
  
    GodleyTable(): doubleEntryCompliant(false)  {}
    std::size_t rows() const {return data.size();}
  };

  struct GodleyIcon
  {
    double adjustHoriz, adjustVert; // difference between where variables are displayed and screen coordinates
    double x, y; 
    double scale; 
    std::vector<VariablePtr> flowVars, stockVars;
    GodleyTable table;
  };

  class GroupIcon
  {
    std::vector<int> inVariables, outVariables;
    CLASSDESC_ACCESS(GroupIcon);
  public:
    std::vector<int> operations;
    std::vector<int> variables;
    std::vector<int> wires;
    ecolab::array<int> m_ports;

    std::string name;
    double x,y; //icon position
    double width, height; // size of icon
    double rotation; // orientation of icon

    GroupIcon(): width(100), height(100), rotation(0) {}
  };



  // a place to put helper classes to manage XML evolution
  namespace xml_conversions
  {
    struct GodleyIcon
    {
      std::set<Variable> flowVars, stockVars;
    };
  }

  struct PlotWidget 
  {
    int nxTicks, nyTicks; 
    double fontScale; 
    double offx, offy; 
    bool logx, logy; 
    bool grid; 
    bool leadingMarker; 
    bool autoscale; 
    ecolab::Plot::PlotType plotType;
    double minx, maxx, miny, maxy;
    ecolab::array<int> ports;
    std::vector<VariableValue> yvars;
    std::vector<VariableValue> xvars;
    VariableValue xminVar, xmaxVar, yminVar, ymaxVar;
  
    std::vector<std::string> images;
 
    double x,y;
  };


  struct Plots
  {
    typedef std::map<std::string, PlotWidget> Map;
    Map plots;
  };

  struct Minsky
  {
    typedef std::map<int, Port> Ports;
    typedef std::map<int, Wire> Wires;
    Ports ports;
    Wires wires;

    GodleyTable godley; // deprecated - needed for Minsky.1 capability
    typedef std::map<int, GodleyIcon> GodleyItems;
    GodleyItems godleyItems;

    typedef std::map<int, Operation> Operations;
    Operations operations;
    VariableManager variables;

    typedef std::map<int, GroupIcon> GroupIcons;
    GroupIcons groupItems;
    
    Plots plots;
    
    Minsky() {}

    double stepMin=0; 
    double stepMax=1; 
    int nSteps=1;     
    double epsAbs=1e-3;     
    double epsRel=1e-2;     

    Minsky(classdesc::xml_unpack_t& data)
    {
      ::xml_unpack(data,"root",*this);
      removeIntVarOrphans();
    }
    
    void removeIntVarOrphans();
  };

}

namespace classdesc
{
  template <class T>
  void xml_unpackp(xml_unpack_t& t, const string& d, ecolab::array<T>& a)
  {
    string x; xml_unpack(t,d,x);
    std::istringstream is(x);
    is>>a;
  }
}

#include "schema0.xcd"
#endif