evalGodley.h

Go to the documentation of this file.

/*
  @copyright Steve Keen 2013
  @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 EVALGODLEY_H
#define EVALGODLEY_H

#include "schema/assetClass.h"
#include "classdesc_access.h"
#include "constMap.h"
#include "variableValues.h"
#include "str.h"
#include "flowCoef.h"

#include <arrays.h>

namespace minsky
{
  using namespace ecolab;

  class EvalGodley
  {
    ecolab::array<int> sidx, fidx;
    ecolab::array<double> m;

    ecolab::array<int> initIdx;

    CLASSDESC_ACCESS(EvalGodley);
  public:

    template <class GodleyIterator> 
    void initialiseGodleys
    (const GodleyIterator& begin, const GodleyIterator& end, 
     const VariableValues& values);

    void eval(double* sv, const double* fv) const;

    EvalGodley():  compatibility(false) {}
    bool compatibility;

  };

  template <class T>  class GodleyIteratorAdaptor
  {
    T it;
  public:
    GodleyIteratorAdaptor(const T& it): it(it) {}
    void operator++() {++it;}
    bool operator!=(const GodleyIteratorAdaptor& x) const
    {return x.it!=it;}

    int id() const {return it->id();}

    const std::vector<std::vector<std::string> >& data() const;
    GodleyAssetClass::AssetClass assetClass(std::size_t col) const;
    bool signConventionReversed(int col) const;
    bool initialConditionRow(int row) const;
    // TODO: this should be refactored to a more central location
    string valueId(const std::string& x) const {return it->valueId(x);}
  };

  template <class T> GodleyIteratorAdaptor<T> makeGodleyIt(const T& it)
  {return GodleyIteratorAdaptor<T>(it);}

  struct SharedColumnCheck: public GodleyAssetClass
  {
    typedef GodleyAssetClass::AssetClass AssetClass;
    
    std::map<string, AssetClass> colAssetType;
    std::set<string> sharedCol;

    void checkShared(const string& name, AssetClass ac);

    ConstMap<string, std::map<string, double> > colDef;

    bool updateColDefs(const string& col, const FlowCoef& fc);

    void checkSharedColDefs() const;
  };


  template <class GodleyIterator> void EvalGodley::initialiseGodleys
  (const GodleyIterator& begin, const GodleyIterator& end, 
     const VariableValues& values)
  {
    SharedColumnCheck scCheck;
    sidx.resize(0);
    fidx.resize(0);
    m.resize(0);

    std::set<int> iidx;

    for (GodleyIterator g=begin; g!=end; ++g)
      {
        if (g.data().empty()) continue;
        // check for shared columns
        if (!compatibility)
          for (std::size_t col=1; col<g.data()[0].size(); ++col)
            if (!trimWS(g.data()[0][col]).empty())
              scCheck.checkShared(g.valueId(trimWS(g.data()[0][col])), g.assetClass(col));

        for (std::size_t row=1; row<g.data().size(); ++row)
          if (!g.initialConditionRow(row))
            for (std::size_t col=1; col<g.data()[row].size(); ++col)
              {
                FlowCoef fvc(g.data()[row][col]);
                auto svName=col<g.data()[0].size()? trimWS(g.data()[0][col]): "";
                if (fvc.name.empty() || svName.empty()) continue;
                fvc.name=g.valueId(fvc.name);
                svName=g.valueId(svName);

                auto fv=values.find(fvc.name);
                auto sv=values.find(svName);
                if (fv!=values.end() && sv!=values.end() &&
                    fv->second->idx()>=0 && sv->second->idx()>=0)
                  {
                    // check for compatible column definitions
                    if (!compatibility && 
                        scCheck.updateColDefs(svName, fvc))
                      continue;
                
                    iidx.insert(sv->second->idx());
                    sidx<<=sv->second->idx();
                    fidx<<=fv->second->idx();
                    m<<=fvc.coef;
                  }
              }
      }

    initIdx.clear();
    for (auto i: iidx)
      initIdx<<=i;

    if (!compatibility)
      scCheck.checkSharedColDefs();
  }
                   
}

#include "evalGodley.cd"
#include "evalGodley.xcd"
#endif