datastruct.c

Go to the documentation of this file.

/***************************************************
Apache License Version 2.0

Copyright 2007-2011 EcoEquity and Stockholm Environment Institute

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
file except in compliance with the License. You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under
the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the specific language governing
permissions and limitations under the License.
****************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include "datastruct.h"
#ifdef DMALLOC
#include <dmalloc.h>
#endif


int getdata(char *fname, struct datablock *dblock, struct appdata ad) {
    FILE *fp;
    char iso3[4];
    int numrecs, row, col, ncol, retval;
    float x;

    if((fp = fopen(fname, "r")) == NULL) {
        return DBLOCK_FREADERROR;
    }

    /* This is where it reads it in */
    fscanf(fp, "%d%d%d", &dblock->y_start, &dblock->y_end, &numrecs);
    if (numrecs != ad.numrecs) {
        fclose(fp);
        return DBLOCK_NRECMISMATCH;
    }

    if ((retval = allocdata(dblock, ad))) {
        fclose(fp);
        return retval;
    }
    ncol = dblock->y_end - dblock->y_start + 1;

    for (row = 0; row < numrecs; row++) {
        fscanf(fp, "%s", iso3); // Don't use this
        for (col = 0; col < ncol; col++) {
            fscanf(fp, "%f", &x);
            dblock->data[row * ncol + col] = x;
        }
    }

    if (fclose(fp)) {
        return DBLOCK_FCLOSEERROR;
    }

    return DBLOCK_OK;
}

int getff(char *fname, struct fixedfactor *ff, char **name, int datacol, struct appdata ad) {
    FILE *fp;
    char iso3[4], linebuff[8192], *namebuff;
    int row, col, retval, ncols, numrecs;
    float x;

    if((fp = fopen(fname, "r")) == NULL) {
        return DBLOCK_FREADERROR;
    }

    // This is where it reads it in
    fscanf(fp, "%d%d", &ncols, &numrecs);
    if (numrecs != ad.numrecs) {
        fclose(fp);
        return DBLOCK_NRECMISMATCH;
    }

    if ((retval = allocff(ff, ad))) {
        fclose(fp);
        return retval;
    }

    // Get the name (assume tabs as separator character, to allow spaces in names)
    fgetc(fp); // First skip the newline at the end of the current line
    fgets(linebuff, 8192, fp);
    namebuff = strtok(linebuff, "\t"); // Ignore the first entry (iso3 code)
    for (col = 0; col < ncols; col++) {
        namebuff = strtok(NULL, "\t");
        if (col == datacol) {
            *name = strdup(namebuff);
            break;
        }
    }

    for (row = 0; row < numrecs; row++) {
        fscanf(fp, "%s", iso3); // Don't use this
        for (col = 0; col < ncols; col++) {
            fscanf(fp, "%f", &x);
            if (col == datacol) {
                ff->data[row] = x;
            }
        }
    }

    if (fclose(fp)) {
        return DBLOCK_FCLOSEERROR;
    }

    return DBLOCK_OK;
}

int getts(char *fname, struct timeseries *ts, struct appdata ad) {
    FILE *fp;
    int line, nlines, retval;
    float x;

    if((fp = fopen(fname, "r")) == NULL) {
        return DBLOCK_FREADERROR;
    }

    /* This is where it reads it in */
    fscanf(fp, "%d%d", &ts->y_start, &ts->y_end);

    if ((retval = allocts(ts, ad))) {
        fclose(fp);
        return retval;
    }
    nlines = ts->y_end - ts->y_start + 1;

    for (line = 0; line < nlines; line++) {
        fscanf(fp, "%f", &x);
        ts->data[line] = x;
    }

    if (fclose(fp)) {
        return DBLOCK_FCLOSEERROR;
    }

    return DBLOCK_OK;

}

void data2ff(struct datablock dblock, struct fixedfactor ff, int year, struct appdata ad) {
    int i;

    for (i = 0; i < ad.numrecs; i++) {
        ff.data[i] = getval(dblock, i, year, ad);
    }
}

void ff2data(struct fixedfactor ff, struct datablock dblock, int year, struct appdata ad) {
    int i;

    for (i = 0; i < ad.numrecs; i++) {
        setval(dblock, ff.data[i], i, year, ad);
    }
}

int allocdata(struct datablock *dblock, struct appdata ad) {
    int ncol, dblock_size, i;

    ncol = dblock->y_end - dblock->y_start + 1;

    if (ncol <= 0) {
        return DBLOCK_BADYEARS;
    }

    // A numrecs x year sized block
    dblock_size = ad.numrecs * ncol;
    dblock->data = malloc(dblock_size * sizeof(double));
    if (!dblock->data) {
        return DBLOCK_NOMEM;
    }
    // Initialize to NaN
    for (i = 0; i < dblock_size; i++) {
        dblock->data[i] = NAN;
    }

    return DBLOCK_OK;
}

int allocff(struct fixedfactor *ff, struct appdata ad) {
    int i;

    // A numrecs-sized block
    ff->data = malloc(ad.numrecs * sizeof(double));
    if (!ff->data) {
        return DBLOCK_NOMEM;
    }
    // Initialize to NaN
    for (i = 0; i < ad.numrecs; i++) {
        ff->data[i] = NAN;
    }
    
    return DBLOCK_OK;
}

int allocts(struct timeseries *ts, struct appdata ad) {
    int ncol, i;

    // A years-sized block
    ncol = ts->y_end - ts->y_start + 1;

    if (ncol <= 0) {
        return DBLOCK_BADYEARS;
    }

    ts->data = malloc(ncol * sizeof(double));
    if (!ts->data) {
        return DBLOCK_NOMEM;
    }
    // Initialize to NaN
    for (i = 0; i < ncol; i++) {
        ts->data[i] = NAN;
    }
    return DBLOCK_OK;

}

void cleardata(struct datablock dblock) {
    free(dblock.data);
}

void clearff(struct fixedfactor ff) {
    free(ff.data);
}

void clearts(struct timeseries ts) {
    free(ts.data);
}

int writedb2delim(struct datablock dblock, char *fname, char delim, struct appdata ad) {
    FILE *fp;
    int i, year;

    if((fp = fopen(fname, "w")) == NULL) {
        return DBLOCK_FREADERROR;
    }

    for (year = dblock.y_start; year < dblock.y_end; year++) {
        fprintf(fp, "%d%c", year, delim);
    }
    fprintf(fp, "%d\n", year);

    for (i = 0; i < ad.numrecs; i++) {
        for (year = dblock.y_start; year < dblock.y_end; year++) {
            fprintf(fp, "%f%c", getval(dblock, i, year, ad), delim);
        }
        fprintf(fp, "%f\n", getval(dblock, i, year, ad));
    }

    if (fclose(fp)) {
        return DBLOCK_FCLOSEERROR;
    }

    return DBLOCK_OK;
}

int writets2delim(struct timeseries ts, char * fname, char delim, struct appdata ad) {
    FILE *fp;
    int year;

    if((fp = fopen(fname, "w")) == NULL) {
        return DBLOCK_FREADERROR;
    }

    for (year = ts.y_start; year < ts.y_end; year++) {
        fprintf(fp, "%d%c%f\n", year, delim, gettsval(ts, year, ad));
    }

    if (fclose(fp)) {
        return DBLOCK_FCLOSEERROR;
    }

    return DBLOCK_OK;
}

int writeff2delim(struct fixedfactor ff, char * fname, char delim, struct appdata ad) {
    FILE *fp;
    int i;

    if((fp = fopen(fname, "w")) == NULL) {
        return DBLOCK_FREADERROR;
    }

    for (i = 0; i < ad.numrecs; i++) {
        fprintf(fp, "%f\n", ff.data[i]);
    }

    if (fclose(fp)) {
        return DBLOCK_FCLOSEERROR;
    }

    return DBLOCK_OK;
}


double getval(struct datablock db, int row, int year, struct appdata ad) {
    if (row > ad.numrecs - 1) {
        return NAN;
    }

    if (year < db.y_start || year > db.y_end) {
        return NAN;
    }

    return db.data[(db.y_end - db.y_start + 1) * row + year - db.y_start];
}

void setval(struct datablock db, double val, int row, int year, struct appdata ad) {
    if (row > ad.numrecs - 1) {
        return;
    }

    if (year < db.y_start || year > db.y_end) {
        return;
    }

    db.data[(db.y_end - db.y_start + 1) * row + year - db.y_start] = val;
}

double gettsval(struct timeseries ts, int year, struct appdata ad) {
    if (year < ts.y_start || year > ts.y_end) {
        return NAN;
    }

    return ts.data[year - ts.y_start];
}

void settsval(struct timeseries ts, double val, int year, struct appdata ad) {
    if (year < ts.y_start || year > ts.y_end) {
        return;
    }

    ts.data[year - ts.y_start] = val;
}

double getffval(struct fixedfactor ff, int row, struct appdata ad) {
    if ((row > ad.numrecs - 1) || (row < 0)) {
        return NAN;
    }

    return ff.data[row];
}

void setffval(struct fixedfactor ff, double val, int row, struct appdata ad) {
    if ((row > ad.numrecs - 1) || (row < 0)) {
        return;
    }

    ff.data[row] = val;
}