schema1::Minsky Struct Reference

#include <schema1.h>

Collaboration diagram for schema1::Minsky:

Public Member Functions
	Minsky ()
	Minsky (const schema0::Minsky &m)
	Minsky (classdesc::xml_unpack_t &data)
	populate schema from XML data More...
void	removeIntVarOrphans ()

Public Attributes
int	schemaVersion =Minsky::version
MinskyModel	model
vector< shared_ptr< Layout > >	layout
double	zoomFactor =1

Static Public Attributes
static const int	version =1

Detailed Description

Definition at line 337 of file schema1.h.

Constructor & Destructor Documentation

Minsky() [1/3]

schema1::Minsky::Minsky ( )

inline

Definition at line 344 of file schema1.h.

: schemaVersion(-1) {} // schemaVersion defined on read in

Minsky() [2/3]

schema1::Minsky::Minsky

(

const schema0::Minsky &

m

)

Definition at line 69 of file schema1.cc.

References schema0::Minsky::epsAbs, schema0::Minsky::epsRel, schema0::Minsky::godleyItems, schema0::Minsky::groupItems, schema0::Minsky::nSteps, schema0::Minsky::operations, schema0::Plots::plots, schema0::Minsky::plots, schema0::Minsky::ports, schema0::Minsky::stepMax, schema0::Minsky::stepMin, schema0::VariableManager::values, schema0::Minsky::variables, and schema0::Minsky::wires.

  {
    // uniquify all IDs
    int nextId=0;
    map<int,int> newPortIds;
    map<int,int> newOpIds;
    map<int,int> newVarIds;

    for (auto& i: m.ports)
      newPortIds[i.first]=nextId++;
    for (auto& i: m.wires)
      {
        model.wires.emplace_back(nextId, newPortIds[i.second.from], newPortIds[i.second.to]);
        layout.emplace_back(new WireLayout(nextId++, i.second));
      }
    for (auto v: m.variables) //NOLINT - index var mutated in loop body
      {
        newVarIds[v.first]=nextId;
        v.second.m_outPort=newPortIds[v.second.m_outPort];
        if (v.second.m_inPort>=0)
          v.second.m_inPort=newPortIds[v.second.m_inPort];
        // values init field overrides that of the variable's
        auto value=m.variables.values.find(v.second.name);
        if (value!=m.variables.values.end())
          v.second.init=value->second.init;
        model.variables.emplace_back(nextId, v.second);
        layout.emplace_back(new ItemLayout(nextId++, v.second));
      }
    for (auto i: m.operations)
      {
        newOpIds[i.first]=nextId;
        for (auto& j: i.second.m_ports)
          j=newPortIds[j];
        if (i.second.intVar>-1) i.second.intVar=newVarIds[i.second.intVar];
        model.operations.emplace_back(nextId, i.second);
        layout.emplace_back(new ItemLayout(nextId++, i.second));
      }

    for (auto i: m.plots.plots)
      {
        for (auto& j: i.second.ports)
          j=newPortIds[j];
        // insert another 6 ports for axis ranges that weren't there in schema 0
        // move first 4 ports (x ports) to end, and add anothe 4 x ports
        i.second.ports=(pcoord(6)+nextId)<<
          i.second.ports[pcoord(8)+4]<<
          i.second.ports[pcoord(4)]<<
          (pcoord(4)+nextId+6);
        nextId+=10;
        model.plots.emplace_back(nextId, i.second);
        layout.emplace_back(new PlotLayout(nextId++, i.second));
      }

    for (auto g: m.groupItems)
      {
        for (auto& i: g.second.operations)
          i=newOpIds[i];
        for (auto& i: g.second.variables)
          i=newVarIds[i];
        for (auto& j: g.second.m_ports)
          j=newPortIds[j];
        // wires not used in new schema, no need to renumber
        model.groups.emplace_back(nextId, g.second);
        layout.emplace_back(new GroupLayout(nextId++, g.second));
      }

    for (auto g: m.godleyItems)
      {
        // need to renumber ports in variables
        for (auto& v: g.second.flowVars)
          v.m_inPort=newPortIds[v.m_inPort];
        for (auto& v: g.second.stockVars)
          v.m_outPort=newPortIds[v.m_outPort];
        model.godleys.emplace_back(nextId, g.second);
        layout.emplace_back(new PositionLayout(nextId++, g.second.x, g.second.y));
      }
    
    model.rungeKutta.stepMin=m.stepMin;
    model.rungeKutta.stepMax=m.stepMax;
    model.rungeKutta.nSteps=m.nSteps;
    model.rungeKutta.epsAbs=m.epsAbs;
    model.rungeKutta.epsRel=m.epsRel;
    removeIntVarOrphans();
  }

Minsky() [3/3]

schema1::Minsky::Minsky ( classdesc::xml_unpack_t &  data )

inline

populate schema from XML data

Definition at line 348 of file schema1.h.

                                       : schemaVersion(0)
    {
      minsky::loadSchema<schema0::Minsky>(*this,data,"Minsky");
      removeIntVarOrphans();
    }

Member Function Documentation

removeIntVarOrphans()

void schema1::Minsky::removeIntVarOrphans

(

)

See ticket #329 and references within. At some stage, IntOp had no destructor, which leads to an orphaned, invisible integral variable, with invalid output port. This bit of code deals with corrupt schema files that have been caused by this problem

Definition at line 47 of file schema1.cc.

References minsky::VariableType::integral, and minsky::OperationType::integrate.

  {
    set<string> intNames;
    for (vector<Operation>::const_iterator o=model.operations.begin(); 
         o!=model.operations.end(); ++o)
      if (o->type==minsky::OperationType::integrate)
        intNames.insert(o->name);

    IsOrphan isOrphan;
    for (vector<Variable>::const_iterator v=model.variables.begin();
         v!=model.variables.end(); ++v)
      // an orphaned variable is an integral variable not attached to an integral and without
      if (v->type==minsky::VariableType::integral && intNames.contains(v->name)==0)
        isOrphan.insert(v->id);

    model.variables.erase
      (remove_if(model.variables.begin(), model.variables.end(), isOrphan), 
       model.variables.end());
    layout.erase
      (remove_if(layout.begin(), layout.end(), isOrphan), layout.end());
  }

Member Data Documentation

layout

vector<shared_ptr<Layout> > schema1::Minsky::layout

Definition at line 342 of file schema1.h.

Referenced by schema2::Minsky::Minsky().

model

MinskyModel schema1::Minsky::model

Definition at line 341 of file schema1.h.

Referenced by schema2::Minsky::Minsky().

schemaVersion

int schema1::Minsky::schemaVersion =Minsky::version

Definition at line 340 of file schema1.h.

version

const int schema1::Minsky::version =1

static

Definition at line 339 of file schema1.h.

zoomFactor

double schema1::Minsky::zoomFactor =1

Definition at line 343 of file schema1.h.

Referenced by schema2::Minsky::Minsky().

---

The documentation for this struct was generated from the following files:

• schema/schema1.h
• schema/schema1.cc