schema3::Minsky Class Reference

#include <schema3.h>

Inheritance diagram for schema3::Minsky:

Collaboration diagram for schema3::Minsky:

Public Member Functions
	Minsky ()
	~Minsky ()
	Minsky (const minsky::Group &g, bool packTensorData=true)
	Minsky (const minsky::Minsky &m, bool packTensorData=true)
void	makeImpl ()
	Minsky (classdesc::xml_unpack_t &data)
	populate schema from XML data More...
	Minsky (const schema2::Minsky &m)
void	populateSchemaPublicationTabs (const std::vector< minsky::PubTab > &)
void	populatePublicationTabs (std::vector< minsky::PubTab > &) const
void	populateMinsky (minsky::Minsky &) const
	create a Minsky model from this More...
void	populateGroup (minsky::Group &g) const
	populate a group object from this. This mutates the ids in a consistent way into the free id space of the global minsky object More...

Public Attributes
int	schemaVersion =Minsky::version
std::string	minskyVersion ="unknown"
vector< Wire >	wires
vector< Item >	items
Optional< vector< int > >	inVariables
Optional< vector< int > >	outVariables
vector< Group >	groups
vector< LockGroup >	lockGroups
minsky::Simulation	rungeKutta
double	zoomFactor =1
vector< minsky::Bookmark >	bookmarks
minsky::Dimensions	dimensions
minsky::ConversionsMap	conversions
PhillipsDiagram	phillipsDiagram
std::vector< PublicationTab >	publicationTabs
std::vector< Item >	publicationItems

Static Public Attributes
static const int	version =3

Private Member Functions
	CLASSDESC_ACCESS (Minsky)

Detailed Description

Definition at line 242 of file schema3.h.

Constructor & Destructor Documentation

Minsky() [1/5]

schema3::Minsky::Minsky ( )

inline

Definition at line 263 of file schema3.h.

: schemaVersion(0) {makeImpl();} // schemaVersion defined on read in

~Minsky()

schema3::Minsky::~Minsky ( )

default

Minsky() [2/5]

schema3::Minsky::Minsky	(	const minsky::Group &	g,
		bool	packTensorData = true
	)

Definition at line 309 of file schema3.cc.

References minsky::GroupItems::groups, minsky::GroupItems::inVariables, minsky::GroupItems::items, minsky::GroupItems::outVariables, minsky::GroupItems::recursiveDo(), and minsky::GroupItems::wires.

  {
    makeImpl();
    auto& itemMap=impl->itemMap;

    g.recursiveDo(&minsky::GroupItems::items,[&](const minsky::Items&,minsky::Items::const_iterator i) {
        itemMap.emplaceIf<minsky::Ravel>(items, i->get()) ||
        itemMap.emplaceIf<minsky::OperationBase>(items, i->get()) ||
          itemMap.emplaceIf<minsky::VariableBase>(items, i->get()) ||
          itemMap.emplaceIf<minsky::GodleyIcon>(items, i->get()) ||
          itemMap.emplaceIf<minsky::PlotWidget>(items, i->get()) ||
          itemMap.emplaceIf<minsky::SwitchIcon>(items, i->get()) ||
          itemMap.emplaceIf<minsky::Sheet>(items, i->get()) ||
          itemMap.emplaceIf<minsky::Item>(items, i->get());
        if (packTensorData) //pack tensor data
          if (auto* v=(*i)->variableCast())
            if (!items.back().tensorData)
              items.back().packTensorInit(*v);

        return false;
      });

    // add any I/O variables
    vector<int> inVars, outVars;
    for (auto& i: g.inVariables)
      inVars.push_back(itemMap[i.get()]);
    for (auto& i: g.outVariables)
      outVars.push_back(itemMap[i.get()]);
    inVariables=inVars;
    outVariables=outVars;
    
    // search for and link up integrals to their variables, and Godley table ports
    g.recursiveDo(&minsky::GroupItems::items,[&](const minsky::Items&,minsky::Items::const_iterator i) {
        if (auto* integ=dynamic_cast<minsky::IntOp*>(i->get()))
          {
            const int id=itemMap[i->get()];
            for (auto& j: items)
              if (j.id==id)
                {
                  // nb conversion to Item* essential here, as
                  // conversion of derived class to void* may not be
                  // equivalent
                  assert(itemMap.count(static_cast<minsky::Item*>(integ->intVar.get())));
                  j.intVar.reset(new int(itemMap[static_cast<minsky::Item*>(integ->intVar.get())]));
                  break;
                }
          }
        return false;
      });
        
    g.recursiveDo(&minsky::GroupItems::wires,
                  [&](const minsky::Wires&,minsky::Wires::const_iterator i) {
                    wires.emplace_back(itemMap[i->get()], **i);
                    assert(itemMap.count((*i)->from().get()) && itemMap.count((*i)->to().get()));
                    wires.back().from=itemMap[(*i)->from().get()];
                    wires.back().to=itemMap[(*i)->to().get()];
                    return false;
      });
    
    g.recursiveDo(&minsky::GroupItems::groups,
                  [&](const minsky::Groups&,minsky::Groups::const_iterator i) {
                    groups.emplace_back(itemMap[i->get()], **i);
                    for (auto& j: (*i)->items)
                      {
                        // some invisible items are excluded from the schema 
                        assert(!j->visible() || itemMap.count(j.get()));
                        groups.back().items.push_back(itemMap[j.get()]);
                        if (j==(*i)->displayPlot)
                          groups.back().displayPlot=itemMap[j.get()];
                      }
                    for (auto& j: (*i)->groups)
                      groups.back().items.push_back(itemMap[j.get()]);
                   for (auto& v: (*i)->inVariables)
                      {
                        assert(itemMap.count(v.get()));
                        groups.back().inVariables->push_back(itemMap[v.get()]);
                      }
                    for (auto& v: (*i)->outVariables)
                      {
                        assert(itemMap.count(v.get()));
                        groups.back().outVariables->push_back(itemMap[v.get()]);
                      }
                    return false;
                  });

    
    
    // process lock groups
    for (auto lg: itemMap.lockGroups)
      {
        lockGroups.emplace_back();
        auto& slg=lockGroups.back();
        for (auto& wr: lg->ravels())
          if (auto r=wr.lock())
            slg.ravels.push_back(itemMap.at(static_cast<minsky::Item*>(r.get())));
          else
            slg.ravels.push_back(-1); // indicate invalidity
        for (auto& hli: lg->handleLockInfo)
          slg.handleLockInfo.emplace_back(hli);
      }
  }

Here is the call graph for this function:

Minsky() [3/5]

schema3::Minsky::Minsky ( const minsky::Minsky &  m, bool  packTensorData = true  )

inline

Definition at line 266 of file schema3.h.

References minsky::Minsky::conversions, minsky::Minsky::dimensions, minsky::Minsky::minskyVersion, minsky::Minsky::model, minsky::Minsky::phillipsDiagram, and minsky::Minsky::publicationTabs.

                                                           :
      Minsky(*m.model,packTensorData) {
      minskyVersion=m.minskyVersion;
      rungeKutta=m;
      zoomFactor=m.model->zoomFactor();
      bookmarks.insert(bookmarks.end(), m.model->bookmarks.begin(), m.model->bookmarks.end());
      dimensions=m.dimensions;
      conversions=m.conversions;
      phillipsDiagram=PhillipsDiagram(m.phillipsDiagram);
      populateSchemaPublicationTabs(m.publicationTabs);
    }

Minsky() [4/5]

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

inline

populate schema from XML data

Definition at line 281 of file schema3.h.

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

Minsky() [5/5]

schema3::Minsky::Minsky ( const schema2::Minsky &  m )

inline

Definition at line 284 of file schema3.h.

                                  :
      schemaVersion(m.schemaVersion),
      wires(m.wires.begin(), m.wires.end()),
      items(m.items.begin(), m.items.end()),
      groups(m.groups.begin(), m.groups.end()), rungeKutta(m.rungeKutta),
      zoomFactor(m.zoomFactor), bookmarks(m.bookmarks), dimensions(m.dimensions),
      conversions(m.conversions) {makeImpl();}

Member Function Documentation

CLASSDESC_ACCESS()

schema3::Minsky::CLASSDESC_ACCESS ( Minsky  )

private

makeImpl()

void schema3::Minsky::makeImpl

(

)

Definition at line 302 of file schema3.cc.

  {
    impl=make_shared<MinskyImpl>();
  }

populateGroup()

void schema3::Minsky::populateGroup

(

minsky::Group &

g

)

const

populate a group object from this. This mutates the ids in a consistent way into the free id space of the global minsky object

Definition at line 636 of file schema3.cc.

References minsky::GroupItems::addGroup(), minsky::Group::addItem(), minsky::GroupItems::addWire(), minsky::decode(), schema1::factory(), minsky::GroupItems::findItem(), minsky::VariableType::flow, minsky::VariableType::integral, minsky::GroupItems::inVariables, minsky::GroupItems::outVariables, schema3::populateItem(), schema3::populateNote(), schema3::populateWire(), minsky::GroupItems::removeItem(), minsky::VariableType::stock, and unpack().

Referenced by minsky::Minsky::insertGroupFromFile(), minsky::Minsky::paste(), and minsky::Minsky::undo().

                                                 {
    assert(impl.get());
    auto& itemMap=impl->reverseItemMap;
    map<int, weak_ptr<minsky::Port>> portMap;
    map<int, schema3::Item> schema3VarMap;
    const MinskyItemFactory factory;
    map<int,LockGroupFactory> lockGroups;
    
    for (const auto& i: items)
      if (auto newItem=itemMap[i.id]=g.addItem(factory.create(i.type)))
        {
          populateItem(*newItem,i);
          for (size_t j=0; j<min(newItem->portsSize(), i.ports.size()); ++j)
            portMap[i.ports[j]]=newItem->ports(j);
          if (newItem->variableCast())
            schema3VarMap[i.id]=i;
        }

    if (inVariables)
      for (auto i: *inVariables)
        g.inVariables.push_back(itemMap[i]);
    if (outVariables)
      for (auto i: *outVariables)
        g.outVariables.push_back(itemMap[i]);

    // second loop over items to wire up integrals, and populate Godley table variables
    for (const auto& i: items)
      {
        if ((i.type=="IntOp" || i.type=="Operation:integrate") && i.intVar)
          {
            assert(itemMap.count(i.id));
            assert(dynamic_pointer_cast<minsky::IntOp>(itemMap[i.id]));
            if (auto* integ=dynamic_cast<minsky::IntOp*>(itemMap[i.id].get()))
              {
                assert(integ->intVar);
                assert(integ->intVar->type()==minsky::VariableType::integral);
                if (itemMap.contains(*i.intVar))
                  {
                    if (integ->coupled()) integ->toggleCoupled();
                    g.removeItem(*integ->intVar);
                    integ->intVar=itemMap[*i.intVar];
                    if (!integ->intVar || integ->intVar->type()!=minsky::VariableType::integral)
                      // input mky file is corrupted at this point
                      integ->description(integ->description());
                  }
                auto iv=schema3VarMap.find(*i.intVar);
                if (iv!=schema3VarMap.end())
                  if ((!i.ports.empty() && !iv->second.ports.empty() && i.ports[0]==iv->second.ports[0]) != integ->coupled())
                    integ->toggleCoupled();
                // ensure that the correct port is inserted (may have been the deleted intVar)
                if (!i.ports.empty())
                  portMap[i.ports[0]]=integ->coupled()? integ->intVar->ports(0): integ->ports(0);
              }
          }
        if (i.type=="GodleyIcon")
          {
            assert(itemMap.count(i.id));
            if (auto* godley=dynamic_cast<minsky::GodleyIcon*>(itemMap[i.id].get()))
              {
                minsky::GodleyIcon::Variables flowVars, stockVars;
                for (auto p: i.ports)
                  {
                    auto newP=portMap.find(p);
                    if (newP!=portMap.end())
                      if (auto ip=g.findItem(newP->second.lock()->item()))
                        if (auto v=dynamic_pointer_cast<minsky::VariableBase>(ip))
                          switch (v->type())
                            {
                            case minsky::VariableType::stock:
                              stockVars.push_back(v);
                              break;
                            case minsky::VariableType::flow:
                              flowVars.push_back(v);
                              break;
                            default:
                              break;
                            }
                  }
                SchemaHelper::setStockAndFlow(*godley, flowVars, stockVars);
                try
                  {
                    godley->update();
                  }
                catch (...) {} //ignore exceptions: ticket #1045
              }
          }
        if (i.type=="Ravel" && i.lockGroup)
          if (auto r=dynamic_pointer_cast<minsky::Ravel>(itemMap[i.id]))
            {
              // note: legacy lock group format handling
              r->lockGroup=lockGroups[*i.lockGroup];
              r->lockGroup->addRavel(r);
              if (i.lockGroupHandles)
                r->lockGroup->setLockHandles({i.lockGroupHandles->begin(), i.lockGroupHandles->end()});
            }
      }
  
    // add in new lockGroup info
    for (auto& lgi: this->lockGroups)
      {
        auto lockGroup=make_shared<minsky::RavelLockGroup>();
        for (auto i: lgi.ravels)
          if (auto r=dynamic_pointer_cast<minsky::Ravel>(itemMap[i]))
            {
              lockGroup->addRavel(r);
              r->lockGroup=lockGroup;
            }
          else
            lockGroup->addRavel({});
        lockGroup->handleLockInfo=lgi.handleLockInfo;
      }
    
    for (const auto& w: wires)
      if (portMap.contains(w.to) && portMap.contains(w.from))
        {
          populateWire
            (*g.addWire(new minsky::Wire(portMap[w.from],portMap[w.to])),w);
        }
          
    for (const auto& i: groups)
      populateItem(*(itemMap[i.id]=g.addGroup(new minsky::Group)),i);

    // second loop over groups, because groups can contain other groups
    for (const auto& i: groups)
      {
        assert(itemMap.count(i.id));
        auto newG=dynamic_pointer_cast<minsky::Group>(itemMap[i.id]);
        if (newG)
          {
            for (auto j: i.items)
              {
                auto it=itemMap.find(j);
                if (it!=itemMap.end())
                  {
                    newG->addItem(it->second, true/*inSchema*/);
                  }
              }
            if (i.displayPlot>=0)
              {
                auto it=itemMap.find(i.displayPlot);
                if (it!=itemMap.end())
                  newG->displayPlot=dynamic_pointer_cast<minsky::PlotWidget>(it->second);
              }
            if (i.inVariables)
              for (auto j: *i.inVariables)
                {
                  auto it=itemMap.find(j);
                  if (it!=itemMap.end())
                    if (auto v=dynamic_pointer_cast<minsky::VariableBase>(it->second))
                      {
                        newG->addItem(it->second);
                        newG->inVariables.push_back(v);
                        v->controller=newG;
                      }
                }
            if (i.outVariables)
              for (auto j: *i.outVariables)
                {
                  auto it=itemMap.find(j);
                  if (it!=itemMap.end())
                    if (auto v=dynamic_pointer_cast<minsky::VariableBase>(it->second))
                      {
                        newG->addItem(it->second);
                        newG->outVariables.push_back(v);
                        v->controller=newG;
                      }
                }
          }
      }
    // now that variables have been homed in their groups, set the variableValue stuff
    for (auto& i: schema3VarMap)
      {
        auto it=itemMap.find(i.first);
        if (!it->second) continue;
        if (auto* v=it->second->variableCast())
          {
            if (i.second.init)
              v->init(*i.second.init);
            if (i.second.units)
              v->setUnits(*i.second.units);
            populateNote(*v,i.second);
            if (auto val=v->vValue())
              {
                if (i.second.csvDataSpec)
                  val->csvDialog.spec=*i.second.csvDataSpec;
                if (i.second.url)
                  val->csvDialog.url=*i.second.url;
                if (i.second.tensorData)
                  {
                    auto buf=minsky::decode(*i.second.tensorData);
                    try
                      {
                        civita::TensorVal tmp;
                        unpack(buf, tmp);
                        *val=tmp;
                        val->tensorInit=std::move(tmp);
                        assert(val->idxInRange());
                      }
                    catch (const std::exception& ex) {
                      val->tensorInit.hypercube({});
#if !defined(NDEBUG) || !defined(_WIN32)
                      cout<<ex.what()<<endl;
#endif
                    }
                    catch (...) {
                      val->tensorInit.hypercube({});
                      assert(val->idxInRange());
                    } // absorb for now - maybe log later
                  }
              }
          }
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

populateMinsky()

void schema3::Minsky::populateMinsky

(

minsky::Minsky &

m

)

const

create a Minsky model from this

Definition at line 448 of file schema3.cc.

References minsky::Minsky::canvas, minsky::Minsky::conversions, minsky::Minsky::dimensions, minsky::Minsky::fileVersion, minsky::Canvas::model, minsky::Minsky::model, minsky::Minsky::phillipsDiagram, and minsky::Minsky::publicationTabs.

Referenced by minsky::Minsky::load().

  {
    const minsky::LocalMinsky lm(m);
    m.model->clear();
    populateGroup(*m.model);
    m.canvas.model=m.model;

    m.model->setZoom(zoomFactor);
    m.model->bookmarks.insert(bookmarks.begin(), bookmarks.end());
    m.dimensions=dimensions;
    m.conversions=conversions;
    m.fileVersion=minskyVersion;
    
    static_cast<minsky::Simulation&>(m)=rungeKutta;

    phillipsDiagram.populatePhillipsDiagram(m.phillipsDiagram);
    populatePublicationTabs(m.publicationTabs);
  }

Here is the caller graph for this function:

populatePublicationTabs()

void schema3::Minsky::populatePublicationTabs

(

std::vector< minsky::PubTab > &

pubTabs

)

const

Definition at line 610 of file schema3.cc.

References schema1::factory(), and schema3::populateItem().

Referenced by minsky::Minsky::undo().

  {
    assert(impl.get());
    auto& itemMap=impl->reverseItemMap;

    // add in publication tab only items
    const MinskyItemFactory factory;
    for (auto& i: publicationItems)
      if (auto newItem=itemMap[i.id]=minsky::ItemPtr(factory.create(i.type)))
        populateItem(*newItem,i);
    
    pubTabs.clear();
    for (auto& pub: publicationTabs)
      {
        pubTabs.emplace_back(pub.name);
        pubTabs.back().offsx=pub.x;
        pubTabs.back().offsy=pub.y;
        pubTabs.back().m_zoomFactor=pub.zoomFactor;
           
        for (auto& item: pub.items)
          if (itemMap.contains(item.item))
            pubTabs.back().items.emplace_back(itemMap[item.item], item);
      }
    if (pubTabs.empty()) pubTabs.emplace_back("Publication");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

populateSchemaPublicationTabs()

void schema3::Minsky::populateSchemaPublicationTabs

(

const std::vector< minsky::PubTab > &

pubTabs

)

Definition at line 428 of file schema3.cc.

References schema3::IdMap::emplaceIf().

  {
    assert(impl.get());
    auto& itemMap=impl->itemMap;
    publicationTabs.clear();
    if (pubTabs.size()==1 && pubTabs.front().items.empty()) return; // don't bother adding a single empty pub tab
    for (auto& i: pubTabs)
      {
        publicationTabs.emplace_back();
        publicationTabs.back().name=i.name;
        for (auto& j: i.items)
          {
            // add locally added notes on publication tab to items list in schema
            if (!itemMap.count(j.itemRef.get()))
              itemMap.emplaceIf<minsky::Item>(publicationItems,j.itemRef.get());
            publicationTabs.back().items.emplace_back(itemMap[j.itemRef.get()], j);
          }
      }
  }

Here is the call graph for this function:

Member Data Documentation

bookmarks

vector<minsky::Bookmark> schema3::Minsky::bookmarks

Definition at line 256 of file schema3.h.

conversions

minsky::ConversionsMap schema3::Minsky::conversions

Definition at line 258 of file schema3.h.

dimensions

minsky::Dimensions schema3::Minsky::dimensions

Definition at line 257 of file schema3.h.

groups

vector<Group> schema3::Minsky::groups

Definition at line 252 of file schema3.h.

inVariables

Optional<vector<int> > schema3::Minsky::inVariables

Definition at line 251 of file schema3.h.

items

vector<Item> schema3::Minsky::items

Definition at line 250 of file schema3.h.

lockGroups

vector<LockGroup> schema3::Minsky::lockGroups

Definition at line 253 of file schema3.h.

minskyVersion

std::string schema3::Minsky::minskyVersion ="unknown"

Definition at line 248 of file schema3.h.

outVariables

Optional<vector<int> > schema3::Minsky::outVariables

Definition at line 251 of file schema3.h.

phillipsDiagram

PhillipsDiagram schema3::Minsky::phillipsDiagram

Definition at line 259 of file schema3.h.

Referenced by minsky::Minsky::undo().

publicationItems

std::vector<Item> schema3::Minsky::publicationItems

Definition at line 261 of file schema3.h.

publicationTabs

std::vector<PublicationTab> schema3::Minsky::publicationTabs

Definition at line 260 of file schema3.h.

rungeKutta

minsky::Simulation schema3::Minsky::rungeKutta

Definition at line 254 of file schema3.h.

schemaVersion

int schema3::Minsky::schemaVersion =Minsky::version

Definition at line 247 of file schema3.h.

Referenced by minsky::Minsky::load().

version

const int schema3::Minsky::version =3

static

Definition at line 246 of file schema3.h.

Referenced by minsky::Minsky::load().

wires

vector<Wire> schema3::Minsky::wires

Definition at line 249 of file schema3.h.

zoomFactor

double schema3::Minsky::zoomFactor =1

Definition at line 255 of file schema3.h.

Referenced by minsky::Minsky::undo().

---

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

• schema/schema3.h
• schema/schema3.cc