コード例 #1
0
void removeMatrixRow(int row, MatDoub &out) {

    int dummy = -1000;

    Rh.resize(Ri.nrows(),Ri.nrows());
    Rh = Ri;

    for(int i=0; i<Rh.nrows(); i++) {
        Rh[row][i] = dummy;
        Rh[i][row] = dummy;
    }

    datain = Rh.getMatrixArray();
    data   [Rh.nrows()*Rh.nrows()];
    int k=0;

    for(int i=0; i < Rh.nrows()*Rh.nrows(); i++) {

        double ele = datain[i];
        if(ele != dummy)
            data[k++] = ele;

    }

    out = MatDoub( out.nrows(), out.nrows(), data );


}
コード例 #2
0
/*
 Utility method used by RandomWalk algorithm to
 resize the Graph Laplacian for each community, com,
 within the network.
 */
void getSubMatrix(int com, vector<node> &Nodes) {

    int dummy = -1000;
    int rows  = 0;

    Rh.resize(R.nrows(), R.nrows());
    Rh = R;

    //--- NR style
    for( int i=0; i< C.size(); i++) {

        if( C[i] == com )
            Nodes.push_back(node(rows++,0.0,0.0));
        else {
            for( int k=0; k<Rh.nrows(); k++) {
                Rh[i][k] = dummy;
                Rh[k][i] = dummy;
            }
        }

    }

    datain = Rh.getMatrixArray();
    data   [Rh.nrows()*Rh.nrows()];
    int ind = 0;

    for(int i=0; i < Rh.nrows()*Rh.ncols(); i++) {

        double ele = datain[i];
        if(ele != dummy)
            data[ind++] = ele;

    }

    Ri.resize(rows,rows);
    Ri = MatDoub( rows, rows, data );

}
コード例 #3
0
/*
 Calculate the eigenvalues, betai, and eigenvectors, u, for
 the current Modularity matrix Bgi.
 */
void calculateEigenVectors() {

    int Ng = Bgi.ncols();

    if(u.ncols() != Ng) {
        u.resize(Ng,Ng);
        betai.resize(Ng);
    }

    u.resize(Ng,Ng);
    betai.resize(Ng);

    Symmeig h(Bgi, true);

    for(int i=0; i<Ng; i++) {
        betai[i] = h.d[i];
        for(int j=0; j<Ng; j++) {
            u[j][i] = h.z[j][i];
        }
    }


}
コード例 #4
0
/*
 Calculte the Modularity matrix when split
 into more than two communities, see [2]
 in method declarations above.
 */
void calculateB(MatDoub B, MatDoub &Bg) {

    int Ng = B.ncols();

    if( Bg.ncols() != Ng )
        Bg.resize(Ng,Ng);

    for(int i=0; i<Ng; i++) {
        for(int j=0; j<Ng; j++) {
            double sum = 0.0;
            for(int k=0; k<Ng; k++)
                sum += B[i][k];

            Bg[i][j] = B[i][j] -1.0 * delta(i,j) * sum;
        }
    }

}
コード例 #5
0
/*
 Update the index vectors, si and SI, for each node in the
 current split such that:

 si(i) =  1 if eigenvector_max(i) > 0
       = -1 if eigenvector_max(i) < 0

 SI(i,0) = 1
 SI(i,1) = 0 if eigenvector_max(i) > 0
         = 0
         = 1 if eigenvector_max(i) < 0
 */
void maximiseIndexVectors( int ind ) {

    int Ng = u.ncols();

    si.resize(Ng);

    SI.resize(Ng,2);

    for(int i=0; i<Ng; i++) {

        if(u[i][ind] < 0) {
            si[i]    = -1;
            SI[i][0] =  0;
            SI[i][1] =  1;
        } else {
            si[i]    =  1;
            SI[i][0] =  1;
            SI[i][1] =  0;
        }

    }

}
コード例 #6
0
/*
 Calculate the split of nodes belonging to the last group of nodes
 with negative eigenvector values.
 */
void splitN(MatDoub Bg, VecInt keys, int dummy, double tol) {

    cout << "> In splitN method... " << endl;

    int N = Bg.nrows();
    MatDoub Bgii(N,N);
    MatDoub Bgiii(N,N);
    VecInt  keysi_n (N);

    //--- Starting from the group Modularity matrix Bg,
    //--- resize matrices: Bgi, keysi_p, keysi_n, u and betai.
    Bgiii  = Bg;
    int Ng = 0;

    for(int i=0; i<keys.size(); i++) {
        if(keys[i] != dummy) {
            Ng++;
        } else {
            for(int k=0; k<Bgiii.nrows(); k++) {
                Bgiii[i][k] = dummy;
                Bgiii[k][i] = dummy;
            }
        }
    }

    keysi_n.resize(Ng);
    VecInt keysi_p(Ng);

    int k=0;
    for(int i=0; i<keys.size(); i++) {
        if(keys[i] != dummy)
            keysi_n[k++] = keys[i];
    }

    Bgii.resize(Ng,Ng);
    removeMatrixRow(Bgiii,Bgii);

    Bgi.resize(Bgii.nrows(),Bgii.nrows());

    //--- Calculate the Modularity matrix Bgi for the new node group
    calculateB(Bgii, Bgi);

    u.resize(Ng,Ng);
    betai.resize(Ng);

    //--- Calculate eigenvectors, and values, from Bgi...
    calculateEigenVectors();

    int ind = 0;
    findLeadingEigenVectors(ind);

    //--- Check that maximum eigenvalue is greater than the tolerance.
    cout << "> max EigenValue is " << betai[ind] << " with ind " << ind << endl;
    if(betai[ind] > tol ) {

        //--- set up the index vectors, si and SI, for the initial split
        maximiseIndexVectors(ind);

        double deltaQ_old = 0.0;
        double deltaQ_new = 0.0;

        int cp = 0;
        int cn = 0;

        //--- Calculate the Spectral Modularity
        deltaModularity(deltaQ_old);
        cout << "> Spectral Q: " << deltaQ_old << endl;

        double diff = fabs(deltaQ_old);
        int count   = 0;

        //--- Fine tuning stage to maximum deltaModularity for the initial split
        while( diff > tol ) {

            modifySplit( tol, Ng );

            deltaModularity(deltaQ_new);
            cout << "> Modified Q: " << deltaQ_new << endl;

            diff = fabs( deltaQ_new - deltaQ_old );

            deltaQ_old = deltaQ_new;

        }

        //--- Keep recorded of maximum fine-tuned Modularity value.
        specQ += deltaQ_old;
        for(int i=0; i<Ng; i++) {
            si[i] = si[i];
            if(si[i] > 0) cp++;
            else          cn++;
        }

        if(cp < 1 || cn < 1) {
            cout << "> Stop splitting. " << endl;
            return;
        }

        int Ncomn = maxCommunity() + 1;
        int Ncomp = Ncomn + 1;

        cout << "> node list " << endl;
        for(int i=0; i<keysi_n.size(); i++) {
            if( si[i] < 0) {
                keysi_n[i] = keysi_n[i];
                keysi_p[i] = dummy;
                n[(int)keysi_n[i]].c = Ncomn;
                cout << "> Node: " << keysi_n[i] << " c = " << n[(int)keysi_n[i]].c << endl;
            } else {
                keysi_p[i] = keysi_n[i];
                keysi_n[i] = dummy;
                cout << "> Node: " << keysi_p[i] << " c = " << n[(int)keysi_p[i]].c << endl;
            }
        }

        //--- Recursively split the group of positive eigenvector nodes
        splitP(Bgii, keysi_p, dummy, tol);

        //--- Recursively split the group of negative eigenvector nodes
        splitN(Bgii, keysi_n, dummy, tol);

    } else {
        cout << "> Stop splitting. " << endl;
        return ;
    }


}
コード例 #7
0
//--- MAIN PROGRAM
//-------------------------------------------------------------------------------------
int main(int argc, char * argv[]) {

    int seed;
    int a_type;
    int w_type;
    string title;
    string if_weighted;
    string if_help;
    const char *file_network;
    const char *file_names;

    if ( argc != 5 ) {
        printHelpMessage( argv[0] );
    }

    if_help = argv[1];
    if( if_help.compare("-h") == 0 || if_help.compare("-help") == 0 ) {
        printHelpMessage( argv[0] );
    }

    seed = atoi(argv[1]);
    cout << "> seed is " << seed << endl;

    //--- Initialize random seed:
    _rand.setSeed(seed);

    a_type = atoi(argv[2]);

    if( a_type < 1 || a_type > 3 ) {
        cout << "argument 2: the type of algorithm to run needs to be either (1,2,3): " << endl;
        cout << "          : 1 = Geodesic edge Betweenness" << endl;
        cout << "          : 2 = Random edge Betweenness"   << endl;
        cout << "          : 3 = Spectral Betweenness"      << endl;
        exit(1);
    }

    switch(a_type) {

    case 1:
        cout << "> Using Geodesic edge Betweenness." << endl;
        title = "Geodesic edge Betweenness.";
        break;

    case 2:
        cout << "> Using Random edge Betweenness." << endl;
        title = "RandomWalk edge Betweenness.";
        break;

    case 3:
        cout << "> Using Spectral Betweenness." << endl;
        title = "Spectral Betweenness.";
        break;

    default:
        break;

    }

    if_weighted = argv[3];

    if( if_weighted.compare("w") == 0 ) {
        w_type = 3;
        cout << "> Using a weighted network " << endl;
    } else {
        if( if_weighted.compare("nw") == 0 ) {
            w_type = 2;
            cout << "> Using a non-weighted network " << endl;
        } else {
            cout << "argument 3: specify if network file is weighted or not: " << endl;
            cout << "          : w  = Using a weighted network file " << endl;
            cout << "          : nw = Using a non-weighted network file " << endl;
            exit(1);
        }
    }

    file_network = argv[4];

    //--- Default values for parameters which may be modified from the commandline
    ihelper = Helper();
    reader.readFile(file_network, w_type);
    Gn      = reader.getNodeSet();
    Gelist  = reader.getEdgeSet();

    vector<int> key_listi;
    vector<int> key_listj;
    vector<int> key_listk;

    cout << "> The Global node list..." << endl;
    for(int i=1; i<Gn.size(); i++) {
        key_listi.push_back(Gn[i].ID);
        key_listj.push_back(Gn[i].ID);
        key_listk.push_back(-1);
        Gn[i].print();
        Gn[i].printEdges();
    }

    //--- To use getSubSample, comment following two lines, and
    //--- uncomment getSubSample(key_listj).
    n     = Gn;
    elist = Gelist;
    //getSubSample(key_listj);

    //cout << "The sub-node list ... " << endl;
    //for(int i=1; i<n.size(); i++){
    //n[i].print();
    //n[i].printEdges();
    //}

    cout << "> The Global edge list..." << endl;
    for(int i=0; i<elist.size(); i++) {
        elist[i].print();
    }

    forcytoscape = new fstream("OUT/communities_newman.txt",ios_base::out);
    (*forcytoscape) << "communities" << endl;

    removededges = new fstream("OUT/removededges.txt",ios_base::out);
    (*removededges) << "Removed Edges" << endl;
    (*removededges) << "so \t IDso \t si \t IDsi \t we \t Globalweight \t key" << endl;

    totallist = ihelper.cloneEdgeList(elist);

    com_max      = 0;
    specQ        = 0.0;
    double Q     = 0.0;
    double Q_SD     = 0.0;
    double Q_old = 0.0;
    double Q_SD_old = 0.0;

    int loop       = elist.size();
    int E          = loop;
    double Q_max   = 0.0;
    double Q_limit = 1.0;
    bool stopping  = false;

    int N = n.size()-1;

    R.resize(N,N);
    Ri.resize(N,N);
    A.resize(N,N);
    Ai.resize(N,N);
    Bi.resize(N,N);
    C.resize(N);

    S.resize(N,1);
    V.resize(N,1);
    T.resize(N,N);
    Ti.resize(N,N);
    Rc.resize((N-1),(N-1));
    Vi.resize(C.size(),1);

    B.resize(N,N);
    Bm.resize(N,N);
    Bgi.resize(N,N);

    keys_p.resize(N);
    keys_n.resize(N);

    u.resize(N,N);  //eigenvectors
    betai.resize(N);//eigenvalues

    SI.resize(N,2);
    si.resize(N);
    visited.resize(N);

    setupMatrices();

    cout << "> Running " << title.c_str() << endl;

    cstart = clock();

    if( a_type == 3 ) {
        //--- Calculate betweenness using the Spectral algorithm
        calculateSpectralModularity();
    } else {

        while( loop !=0 && !stopping ) {

            int old_max_com = com_max;

            //--- Calculate betweenness using Geodesic or RandomWalk algorithms
            if( a_type == 1 )
                calculateEdgeBetweennessGeodesic();
            else
                calculateEdgeBetweennessRandom();

            //--- Calculate the Modularity
            Q_old = Q;
            Q_SD_old = Q_SD;
            Q     = 0.0;
            Q_SD   = 0.0;

            Modularity(Q, Q_SD);

            //--- Store networks state if Modularity has increased during this iteraction
            if(com_max > old_max_com) {
                vec_mod.push_back(Q);
                vec_mod_err.push_back(Q_SD);
                vec_com_max.push_back(com_max);
                vec_nodes.push_back(storeNodes());
            }


            //--- Record the maximum Modularity value
            if( Q > Q_max ) {
                Q_max = Q;
            } else {
                if( Q_max > 0.0 && (Q_max - Q)/Q_max > Q_limit ) stopping = true;
            }


            //--- Find edge with maximum edge betweenness score and remove
            edge _max;
            _max = totallist[1].Clone();
            for(int i=1; i<totallist.size(); i++) {

                if( totallist[i].removed == false ) {

                    if(totallist[i].we >= _max.we) {

                        if(totallist[i].we > _max.we)
                            _max = totallist[i];
                        else {
                            int rdm = rand()%2;
                            if(rdm == 1) _max = totallist[i];
                        }
                    }
                }
                totallist[i].we = 0;
            }

            //--- Record the removed edges.
            _max.print( removededges );

            n[elist[_max.key-1].so].removeEdge(_max.key);
            n[elist[_max.key-1].si].removeEdge(_max.key);
            n[elist[_max.key-1].so].setDegree( (n[elist[_max.key-1].so].getDegree() - 1) );
            n[elist[_max.key-1].si].setDegree( (n[elist[_max.key-1].si].getDegree() - 1) );
            totallist[_max.key].removed = true;
            elist[_max.key-1].removed   = true;
            --loop;

            //--- Calculate the remaining processor time
            DrawProgressBar( 20, ((double)E - (double)loop)/(double)E );

        }
    }

    //--- Recored the CPU-time taken
    cend = clock();
    double cpu_time_used = ((double) (cend - cstart)) / CLOCKS_PER_SEC;
    cout << "" << endl;
    cout << "> cputime: " << cpu_time_used << " seconds " << endl;
    cout << "> Network (nodes): " << N << " (edges): " << E << endl;

    if( a_type != 3 ) {

        //--- Print all stored Modularity values
        modularityscore = new fstream("OUT/modularityscore.txt",ios_base::out);
        (*modularityscore) << title.c_str() << endl;
        for(int i=0; i<vec_mod.size(); i++) {
            (*modularityscore) << vec_mod[i] << " " << vec_mod_err[i] << " " << vec_com_max[i] << endl;
        }
        modularityscore->close();

        int ind   = findMax(vec_mod);
        int com   = 1;
        int _size = 0;
        int c_max = com_max;

        //--- Print node communities for maximum Modularity value, for Geodesic or RandomWalk runs
        communityout = new fstream("OUT/communityout.txt",ios_base::out);
        (*communityout) << "Max Q: " << vec_mod[ind] << " +- " << vec_mod_err[ind] << endl;
        (*communityout) << "cputime: " << cpu_time_used << " seconds " << endl;
        (*communityout) << "Network (nodes): " << N << " (edges): " << E << endl;

        while(com<(c_max+1)) {
            _size = 0;
            for(int i=0; i<vec_nodes[ind].size(); i++) {
                if(vec_nodes[ind][i].c == com ) {
                    (*communityout) << vec_nodes[ind][i].ID << "\t" << vec_nodes[ind][i].c << endl;
                    //vec_nodes[ind][i].print( communityout );
                    _size++;
                }
            }
            if(_size != 0)
                (*communityout) << "community: " << com << " size: " << _size << endl;
            com++;
        }

        for(int i=0; i<vec_nodes[ind].size(); i++) {
            for(int j=0; j<key_listi.size(); j++) {
                if(vec_nodes[ind][i].ID == key_listi[j]) {
                    key_listk[j] = vec_nodes[ind][i].c;
                    break;
                }
            }
        }

        //--- Print node communities for maximum Modularity for the consensus matrix
        consensusout = new fstream("OUT/consensusout.txt",ios_base::out);
        (*consensusout) << "key list" << endl;
        for(int i=0; i<key_listi.size(); i++) {
            if(key_listk[i] == -1 && key_listj[i] != -1)
                key_listj[i] = -1;
            (*consensusout) << key_listi[i] << " " << key_listj[i] << " " << key_listk[i] << endl;
            //(*consensusout) << key_listi[i] << " = " << key_listk[i] << endl;
            (*forcytoscape) << key_listi[i] << " = " << key_listk[i] << endl;
            cout << key_listi[i] << " " << key_listj[i] << " " << key_listk[i] << endl;
        }
    } else {

        int com   = 1;
        int _size = 0;
        int c_max = maxCommunity();

        //--- Store node communities for maximum Modularity for the Spectral Modularity run
        communityout = new fstream("OUT/communityout.txt",ios_base::out);
        (*communityout) << "communityout" << endl;
        (*communityout) << "Max Q: " << specQ << endl;
        (*communityout) << "cputime: " << cpu_time_used << " seconds " << endl;
        (*communityout) << "Network (nodes): " << N << " (edges): " << E << endl;
        while(com<(c_max+1)) {
            _size = 0;
            for(int i=0; i<n.size(); i++) {
                if(n[i].c == com ) {
                    n[i].print( communityout );
                    _size++;
                }
            }
            if(_size != 0)
                (*communityout) << "community: " << com << " size: " << _size << endl;
            com++;
        }

        for(int i=1; i<n.size(); i++) {
            for(int j=0; j<key_listi.size(); j++) {
                if(n[i].ID == key_listi[j]) {
                    key_listk[j] = n[i].c;
                    break;
                }
            }
        }

        //--- Print node communities for maximum Modularity the consensus matrix
        consensusout = new fstream("OUT/consensusout.txt",ios_base::out);
        (*consensusout) << "key list" << endl;
        for(int i=0; i<key_listi.size(); i++) {
            if(key_listk[i] == -1 && key_listj[i] != -1)
                key_listj[i] = -1;
            (*consensusout) << key_listi[i] << " " << key_listj[i] << " " << key_listk[i] << endl;
            //(*consensusout) << key_listi[i] << " = " << key_listk[i] << endl;
            (*forcytoscape) << key_listi[i] << " = " << key_listk[i] << endl;
            cout << key_listi[i] << " " << key_listj[i] << " " << key_listk[i] << endl;
        }


    }


    //--- Remove data structures
    communityout->close();
    forcytoscape->close();
    vec_mod.clear();
    vec_mod_err.clear();
    vec_nodes.clear();

    exit(1);

}
コード例 #8
0
/*
 Utility method used by the RandomWalk algorithm to
 invert the Graph Laplacian and accummulate the random-path
 contributions from each source-sink node pair, in
 accordance with [2] (see method declarations above).
 */
void calculateRandomWalk(int c, vector<node> Nodes) {

    queue<node> termNodes;
    for(int i=0; i<Nodes.size(); i++)
        termNodes.push(Nodes[i]);

    int N = Nodes.size();
    S.resize(N,1);
    V.resize(N,1);
    T.resize(N,N);
    Rc.resize((N-1),(N-1));
    Vi.resize(C.size(),1);

    //--- Remove arbitrary termination ('sink') state '0'.
    removeMatrixRow(0,Rc);

    //--- Invert Matrix.
    LUdcmp lu( Rc );

    Ti.resize(Rc.nrows(),Rc.nrows());

    lu.inverse( Ti );

    for(int i=0; i< T.nrows(); i++) {
        for(int j=0; j< T.nrows(); j++) {
            T[i][j] = 0;
        }
    }

    //--- Add back arbitrary termination ('sink') state '0'.
    addMatrixRow(Ti,0,T);

    while ( !termNodes.empty() ) {

        node termNode  = termNodes.front();
        termNodes.pop();

        for(int t=0; t< Nodes.size(); t++) {

            //--- Take the next start ('source') state.
            node startNode = Nodes[t];

            if( startNode.k != termNode.k ) {

                for(int i=0; i<S.nrows(); i++) {
                    S[i][0]  = 0;
                    V[i][0]  = 0;
                    Vi[i][0] = 0;
                }

                S[startNode.k][0] =  1;
                S[termNode.k][0]  = -1;

                //--- V = T * S
                for(int i=0; i<T.nrows(); i++) {
                    double sum = 0.0;
                    for(int j=0; j<T.nrows(); j++) {
                        sum += T[i][j] * S[j][0];
                    }
                    V[i][0] = sum;
                }

                addMatrixRows(V, c, Vi);

                //--- Edge Betweenness, i.e.
                //--- the currents (potential differences) alone each edge!
                for(int i=0; i<elist.size(); i++) {

                    if( !elist[i].removed ) {
                        int Ni = elist[i].so-1;
                        int Nj = elist[i].si-1;

                        totallist[i+1].we += fabs(Vi[Ni][0] - Vi[Nj][0]);

                    }
                }//elist
            }//Nodes
        }//startNodes

    }

}
コード例 #9
0
void C_csp_gen_collector_receiver::init(const C_csp_collector_receiver::S_csp_cr_init_inputs init_inputs, 
			C_csp_collector_receiver::S_csp_cr_solved_params & solved_params)
{
	// Check that ms_params are set
	check_double_params_are_set();

	// Could sanity-check other parameters here...
	if(ms_params.m_interp_arr < 1 || ms_params.m_interp_arr > 2)
	{
		std::string msg = util::format("The interpolation code must be 1 (interpolate) or 2 (nearest neighbor)"
			"The input value was %d, so it was reset to 1", ms_params.m_interp_arr);
		mc_csp_messages.add_notice(msg);
		ms_params.m_interp_arr = 1;
	}
	if(ms_params.m_rad_type < 1 || ms_params.m_rad_type > 3)
	{	// Fairly important to know the intent of this input, so throw an exception if it's not one of the three options
		std::string msg = util::format("The solar resource radiation type must be 1 (DNI), 2 (Beam horizontal), or "
			"3 (Total horizontal). The input value was %d.");
		throw(C_csp_exception("C_csp_gen_collector_receiver::init",msg));
	}

	if(ms_params.mv_sfhlQ_coefs.size() < 1)
	{
		throw(C_csp_exception("C_csp_gen_collector_receiver::init","The model requires at least one irradiation-based "
			"thermal loss adjustment coefficient (mv_sfhlQ_coefs)"));
	}
	if(ms_params.mv_sfhlT_coefs.size() < 1)
	{
		throw(C_csp_exception("C_csp_gen_collector_receiver::init", "The model requires at least one temperature-based "
			"thermal loss adjustment coefficient (mv_sfhlT_coefs)"));
	}
	if( ms_params.mv_sfhlV_coefs.size() < 1 )
	{
		throw(C_csp_exception("C_csp_gen_collector_receiver::init", "The model requires at least one wind-based "
			"thermal loss adjustment coefficient (mv_sfhlV_coefs)"));
	}

	// Unit conversions
	ms_params.m_latitude *= CSP::pi/180.0;		//[rad], convert from deg
	ms_params.m_longitude *= CSP::pi / 180.0;	//[rad], convert from deg
	ms_params.m_theta_stow *= CSP::pi / 180.0;	//[rad], convert from deg
	ms_params.m_theta_dep *= CSP::pi / 180.0;	//[rad], convert from deg
	ms_params.m_T_sfdes += 273.15;	//[K], convert from C

	if( !ms_params.m_is_table_unsorted )
	{
		/*
		Standard azimuth-elevation table
		*/

		//does the table look right?
		if( (ms_params.m_optical_table.nrows() < 5 && ms_params.m_optical_table.ncols() > 3) || 
			(ms_params.m_optical_table.ncols() == 3 && ms_params.m_optical_table.nrows() > 4) )
		{
			mc_csp_messages.add_message(C_csp_messages::WARNING, "The optical efficiency table option flag may not match the specified table format. If running SSC, ensure \"IsTableUnsorted\""
			" =0 if regularly-spaced azimuth-zenith matrix is used and =1 if azimuth,zenith,efficiency points are specified.");
		}



		if( ms_params.m_optical_table.nrows() <= 0 || ms_params.m_optical_table.ncols() <= 0 ) // If these were not set correctly, it will create memory allocation crash not caught by error handling.
		{
			throw(C_csp_exception("C_csp_gen_collector_receiver::init","The optical table must have a positive number of rows and columns"));
		}

		double *xax = new double[ms_params.m_optical_table.ncols() - 1];
		double *yax = new double[ms_params.m_optical_table.nrows() - 1];
		double *data = new double[(ms_params.m_optical_table.ncols() - 1) * (ms_params.m_optical_table.nrows() - 1)];

		//get the xaxis data values
		for( size_t i = 1; i<ms_params.m_optical_table.ncols(); i++ ){
			xax[i - 1] = ms_params.m_optical_table(0,i)*CSP::pi/180.0;
		}
		//get the yaxis data values
		for( size_t j = 1; j<ms_params.m_optical_table.nrows(); j++ ){
			yax[j - 1] = ms_params.m_optical_table(j,0)*CSP::pi / 180.0;
		}
		//Get the data values
		for( size_t j = 1; j<ms_params.m_optical_table.nrows(); j++ ){
			for( size_t i = 1; i<ms_params.m_optical_table.ncols(); i++ ){
				data[i - 1 + (ms_params.m_optical_table.ncols() - 1)*(j - 1)] = ms_params.m_optical_table(j, i);
			}
		}

		mc_optical_table.AddXAxis(xax, (int)ms_params.m_optical_table.ncols() - 1);
		mc_optical_table.AddYAxis(yax, (int)ms_params.m_optical_table.nrows() - 1);
		mc_optical_table.AddData(data);
		delete[] xax, yax, data;	
	}
	else
	{
		/*
		Use the unstructured data table
		*/

		/*
		------------------------------------------------------------------------------
		Create the regression fit on the efficiency map
		------------------------------------------------------------------------------
		*/

		if( ms_params.m_optical_table.ncols() != 3 )
		{
			std::string msg = util::format("The heliostat field efficiency file is not formatted correctly. Type expects 3 columns"
				" (zenith angle, azimuth angle, efficiency value) and instead has %d cols.", ms_params.m_optical_table.ncols());
			throw(C_csp_exception("C_csp_gen_collector_receiver::init", msg));
		}

		MatDoub sunpos;
		vector<double> effs;

		int nrows = (int)ms_params.m_optical_table.nrows();

		//read the data from the array into the local storage arrays
		sunpos.resize(nrows, VectDoub(2));
		effs.resize(nrows);
		double eff_maxval = -9.e9;
		for( int i = 0; i<nrows; i++ )
		{
			sunpos.at(i).at(0) = ms_params.m_optical_table(i,0) / az_scale * CSP::pi / 180.;
			sunpos.at(i).at(1) = ms_params.m_optical_table(i,1) / zen_scale * CSP::pi / 180.;
			double eff = ms_params.m_optical_table(i,2);

			effs.at(i) = eff;
			if( eff > eff_maxval ) eff_maxval = eff;
		}

		//scale values based on maximum. This helps the GM interpolation routine
		m_eff_scale = eff_maxval;
		for( int i = 0; i<nrows; i++ )
			effs.at(i) /= m_eff_scale;

		//Create the field efficiency table
		Powvargram vgram(sunpos, effs, 1.99, 0.);
		mpc_optical_table_uns = new GaussMarkov(sunpos, effs, vgram);

		//test how well the fit matches the data
		double err_fit = 0.;
		int npoints = (int)sunpos.size();
		for( int i = 0; i<npoints; i++ ){
			double zref = effs.at(i);
			double zfit = mpc_optical_table_uns->interp(sunpos.at(i));
			double dz = zref - zfit;
			err_fit += dz * dz;
		}
		err_fit = sqrt(err_fit);
		if( err_fit > 0.01 )
		{
			std::string msg = util::format("The heliostat field interpolation function fit is poor! (err_fit=%f RMS)", err_fit);
			mc_csp_messages.add_message(C_csp_messages::WARNING, msg);
		}

	}	// end unstructured data table

	init_sf();

	m_mode = C_csp_collector_receiver::OFF;					//[-] 0 = requires startup, 1 = starting up, 2 = running
	m_mode_prev = m_mode;
	
	return;
}