pygtk/interface/incidencematrix.cpp

#include "incidencematrix.h"

#include <stdexcept>
#include <iostream>
using namespace std;

IncidencePoint::IncidencePoint(const int&row, const int &col, const IncidencePointType &type) : row(row), col(col), type(type){
    // constructor, IncidencePoint
}

IncidencePoint::IncidencePoint(const IncidencePoint &old) : row(old.row), col(old.col), type(old.type){
    // copy ctor
}

IncidencePoint::IncidencePoint() : row(-1), col(-1), type(IM_NULL){
    // default ctor... don't use. need this to keep swig happy for some strange reason.
}

IncidenceMatrix::IncidenceMatrix(Simulation &sim) : sim(sim){
    // constructor
    is_built = FALSE;
}

IncidenceMatrix::~IncidenceMatrix(){
    if(is_built){
        free_incidence_data(&i);
    }
}

void
IncidenceMatrix::buildPlotData(){
    int c=-1;

    cerr << "BUILDPLOTDATA" << endl;

    slv_system_t sys = sim.getSystem();

    cerr << "GOT SYSTEM DATA" << endl;

    if(build_incidence_data(sys,&i)) {
        cerr << "FAILED TO BUILD INCIDENCE DATA" << endl;
        free_incidence_data(&i);
        throw runtime_error("IncidenceMatrix::buildPlotData error calculating grid");
        return;
    }

    for (int r=0; r < i.nprow; r++) {
        struct rel_relation *rel = i.rlist[i.pr2e[r]];
        const struct var_variable **vp = rel_incidence_list(rel);

        if(rel_active(rel)){
            int nvars = rel_n_incidences(rel);  
            if(rel_included(rel)){
                for(int v=0; v < nvars; v++ ) {
                    if(var_flags(vp[v]) & VAR_SVAR) {
                        int vndx = var_sindex(vp[v]);
                        c = i.v2pc[vndx];
                        if (i.vfixed[vndx]) {
                            data.push_back(IncidencePoint(r,c,IM_ACTIVE_FIXED));
                        }else{
                            data.push_back(IncidencePoint(r,c,IM_ACTIVE_FREE));
                        }
                    }
                }
            }else{ /* hollow squares */
                for(int v=0; v < nvars; v++ ) {
                    if (var_flags(vp[v]) & VAR_SVAR) {
                        int vndx = var_sindex(vp[v]);
                        c = i.v2pc[vndx];
                        if (i.vfixed[vndx]) {
                            data.push_back(IncidencePoint(r,c,IM_DORMANT_FIXED));
                        } else {
                            data.push_back(IncidencePoint(r,c,IM_DORMANT_FREE));
                        }
                    }
                }
            }
        }
    }
    
    is_built = TRUE;
}

const int &
IncidenceMatrix::getNumRows() const{
    return i.nprow;
}

const int &
IncidenceMatrix::getNumCols() const{
    return i.npcol;
}

const vector<IncidencePoint> &
IncidenceMatrix::getIncidenceData(){
    cerr << "GET INCIDENCE DATA" << endl;
    if(!is_built){
        buildPlotData();
    }
    return data;
}
1	#include "incidencematrix.h"
2
3	#include <stdexcept>
4	#include <iostream>
5	using namespace std;
6
7	IncidencePoint::IncidencePoint(const int&row, const int &col, const IncidencePointType &type) : row(row), col(col), type(type){
8	// constructor, IncidencePoint
9	}
10
11	IncidencePoint::IncidencePoint(const IncidencePoint &old) : row(old.row), col(old.col), type(old.type){
12	// copy ctor
13	}
14
15	IncidencePoint::IncidencePoint() : row(-1), col(-1), type(IM_NULL){
16	// default ctor... don't use. need this to keep swig happy for some strange reason.
17	}
18
19	IncidenceMatrix::IncidenceMatrix(Simulation &sim) : sim(sim){
20	// constructor
21	is_built = FALSE;
22	}
23
24	IncidenceMatrix::~IncidenceMatrix(){
25	if(is_built){
26	free_incidence_data(&i);
27	}
28	}
29
30	void
31	IncidenceMatrix::buildPlotData(){
32	int c=-1;
33
34	cerr << "BUILDPLOTDATA" << endl;
35
36	slv_system_t sys = sim.getSystem();
37
38	cerr << "GOT SYSTEM DATA" << endl;
39
40	if(build_incidence_data(sys,&i)) {
41	cerr << "FAILED TO BUILD INCIDENCE DATA" << endl;
42	free_incidence_data(&i);
43	throw runtime_error("IncidenceMatrix::buildPlotData error calculating grid");
44	return;
45	}
46
47	for (int r=0; r < i.nprow; r++) {
48	struct rel_relation *rel = i.rlist[i.pr2e[r]];
49	const struct var_variable **vp = rel_incidence_list(rel);
50
51	if(rel_active(rel)){
52	int nvars = rel_n_incidences(rel);
53	if(rel_included(rel)){
54	for(int v=0; v < nvars; v++ ) {
55	if(var_flags(vp[v]) & VAR_SVAR) {
56	int vndx = var_sindex(vp[v]);
57	c = i.v2pc[vndx];
58	if (i.vfixed[vndx]) {
59	data.push_back(IncidencePoint(r,c,IM_ACTIVE_FIXED));
60	}else{
61	data.push_back(IncidencePoint(r,c,IM_ACTIVE_FREE));
62	}
63	}
64	}
65	}else{ /* hollow squares */
66	for(int v=0; v < nvars; v++ ) {
67	if (var_flags(vp[v]) & VAR_SVAR) {
68	int vndx = var_sindex(vp[v]);
69	c = i.v2pc[vndx];
70	if (i.vfixed[vndx]) {
71	data.push_back(IncidencePoint(r,c,IM_DORMANT_FIXED));
72	} else {
73	data.push_back(IncidencePoint(r,c,IM_DORMANT_FREE));
74	}
75	}
76	}
77	}
78	}
79	}
80
81	is_built = TRUE;
82	}
83
84	const int &
85	IncidenceMatrix::getNumRows() const{
86	return i.nprow;
87	}
88
89	const int &
90	IncidenceMatrix::getNumCols() const{
91	return i.npcol;
92	}
93
94	const vector<IncidencePoint> &
95	IncidenceMatrix::getIncidenceData(){
96	cerr << "GET INCIDENCE DATA" << endl;
97	if(!is_built){
98	buildPlotData();
99	}
100	return data;
101	}