source: observatorio/simulacion/SimEscenariosEconomicos/productionNetwork.H

/*
  Copyright (C) 2012
  Alejandro Mujica (amujica@cenditel.gob.ve)
  Erwin Paredes (eparedes@cenditel.gob.ve)
  José Ruiz (jruiz@cenditel.gob.ve)
  Rodolfo Rangel (rrangel@cenditel.gob.ve)
  Julie Vera (jvera@cenditel.gob.ve)
 
  CENDITEL Fundación Centro Nacional de Desarrollo e Investigación en
  Tecnologías Libres
 
  Este programa es software libre; Usted puede usarlo bajo los términos de la
  licencia de software GPL versión 2.0 de la Free Software Foundation.
 
  Este programa se distribuye con la esperanza de que sea útil, pero SIN
  NINGUNA GARANTÍA; tampoco las implícitas garantías de MERCANTILIDAD o
  ADECUACIÓN A UN PROPÓSITO PARTICULAR.
  Consulte la licencia GPL para más detalles. Usted debe recibir una copia
  de la GPL junto con este programa; si no, escriba a la Free Software
  Foundation Inc. 51 Franklin Street,5 Piso, Boston, MA 02110-1301, USA.
*/

/*
  Autor:             Alejandro J. Mujica
  Fecha de creación: 10/09/2013
  Este archivo contiene la implementación de la clase ProductionNetwork.
*/

# ifndef PRODUCTION_NETWORK_H
# define PRODUCTION_NETWORK_H

# include <types.H>

# include <tpl_graph_indexes.H>

# include <product.H>
# include <input.H>

enum NodeType {

    ROOT,

    UPSTREAM,

    DOWNSTREAM,

    SUGGESTED,

    IMPORT,

    NUM_NODE_TYPES
};

typedef Graph_Node <std::shared_ptr<Good>> BaseNode;

struct ProductionNode : public BaseNode {

    long id;

    ::NodeType type;

    Tree <long> levels;

    bool isInQueue;

    real newValue1;

    real newValue2;

    real newValue3;

    ProductionNode()
        : BaseNode(), id(-1),  type(ROOT), levels(), isInQueue(false),
          newValue1(0.0), newValue2(0.0) {

        // Empty
    }

    ProductionNode(const std::shared_ptr<Good> & good)
        : BaseNode(good), id(-1), type(ROOT), levels(), isInQueue(false),
          newValue1(0.0), newValue2(0.0) {

        // Empty
    }

    ProductionNode(ProductionNode * node)
        : BaseNode(node), id(node->id), type(node->type), levels(node->levels),
          isInQueue(false), newValue1(0.0), newValue2(0.0) {

      // Empty
    }
};

struct ArcInfo {

    long inputId;

    std::string measurementUnit;

    real quantity;

    real totalQuantity;

    real usedQuantity;

    real reqQuantity; // Coeficiente técnico

    real price; // Precio unitario

    bool isMin;

    real newValue1;

    real newValue2;

    real newValue3;

    ArcInfo()
        : inputId(-1), measurementUnit(), quantity(0.0), totalQuantity(0.0),
          usedQuantity(0.0), reqQuantity(0.0), price(0.0), isMin(false),
          newValue1(0.0), newValue2(0.0), newValue3(0.0) {

        // Empty
    }
};

typedef Graph_Arc <ArcInfo> ProductionArc;

typedef List_Graph <ProductionNode, ProductionArc> BaseGraph;

struct CmpCompany {

    bool operator () (const Company & c1, const Company & c2) {

        const std::string & str1 = c1.getNationality() == "E"
                                   ? c1.getName() : c1.getRif();

        const std::string & str2 = c2.getNationality() == "E"
                                   ? c2.getName() : c2.getRif();

        return str1 < str2;
    }
};

struct CmpPlant {

    bool operator () (const Plant & p1, const Plant & p2) {
        return p1.getId() < p2.getId();
    }
};

class ProductionNetwork : public BaseGraph {

    Tree <Company, CmpCompany> companies;

    Tree <Plant, CmpPlant> plants;

public:
    std::string year;

    size_t maxLevelUpstream;

    size_t maxLevelDownstream;

    ProductionNetwork()
        : BaseGraph(), companies(), plants() {

        // Empty
    }

    ProductionNetwork(const ProductionNetwork & network)
        : BaseGraph(network), companies(network.companies),
          plants(network.plants) {

        // Empty
    }

    Company * searchOrInsert(const Company & company) {

        Company * ptr_company = companies.search(company);

        if (ptr_company == NULL)
            ptr_company = companies.insert(company);

        return ptr_company;
    }

    Plant * searchOrInsert(const Plant & plant) {

        Plant * ptr_plant = plants.search(plant);

        if (ptr_plant == NULL)
            ptr_plant = plants.insert(plant);

        return ptr_plant;
    }

    Node * insertNode(std::shared_ptr <Good> & good) {

        Node * p = BaseGraph::insert_node(good);

        return p;
    }
};


# endif // PRODUCTION_NETWORK_H