001: /*
002:  *  control.c
003:  *  dynamo.cgi
004:  *
005:  *  Created by ashley on 19/05/2009.
006:  *  Copyright 2009 __MyCompanyName__. All rights reserved.
007:  *
008:  */
009: 
010: #include <stdio.h>
011: #include <stdlib.h>
012: #include <string.h>
013: #include <math.h>
014: #include "control.h"
015: 
016: // void output(int n, double *y, double t);
017: 
018: char *astrcpy(char *source)
019: {
020:         int n = strlen(source);
021:         char *dest = malloc(n + 1);
022:         strcpy(dest, source);
023:         
024:         return dest;
025: }
026: 
027: constant *makeconstant()
028: {
029:         constant *con = (constant *)malloc(sizeof(constant));
030:         con->name = NULL;
031:         con->value = 0.0;
032:         con->info = NULL;
033:         con->row = -1;
034:         con->column = -1;
035:         
036:         return con;
037: }
038: 
039: void freeconstant(constant *con)
040: {
041:         if (con->name!=NULL) free(con->name);
042:         if (con->info!=NULL) free(con->info);
043:         
044:         free(con);
045: }
046: 
047: variable *makevariable()
048: {
049:         variable *var = (variable *)malloc(sizeof(variable));
050:         var->name = NULL;
051:         var->linecolour = NULL;
052:         var->markercolour = NULL;
053:         
054:         return var;
055: }
056: 
057: void freevariable(variable *var)
058: {
059:         free(var->name);
060:         if (var->linecolour!=NULL) free(var->linecolour);
061:         if (var->markercolour!=NULL) free(var->markercolour);
062:         free(var);
063: }
064: 
065: plot* makeplot(plottype t, int nlines, int ordinate, int *lines)
066: {
067:         plot *p = (plot *)calloc(1, sizeof(plot));
068:         
069:         p->type = t;
070:         p->nlines = nlines;
071:         p->ordinate = ordinate;
072:         p->abscissae = (int *)calloc(nlines, sizeof(int));
073:         int i;
074:         for(i=0; i<nlines; i++) {
075:                 p->abscissae[i] = lines[i];
076:         }
077:         
078:         p->label = "";
079:         p->title = "";
080:         p->xlabel = "";
081:         p->ylabel = "";
082:         
083:         return p;
084: }
085: 
086: void freeplot(plot *p)
087: {
088:         free(p->abscissae);
089:         free(p);
090: }
091: 
092: control *makecontrol(int n, int p, int m)
093: {
094:         control *c = (control *)calloc(1, sizeof(control));
095: 
096:         c->title = "";
097:         c->description = "";
098: 
099:         c->output = output;
100:         c->outputcounter = 0;
101:         c->maxoutput = 0;
102:         c->results = NULL;
103: 
104:         c->nparameters = p;
105:         c->nvariables = n;
106:         
107: //      c->variablenames = (char **)malloc(n*sizeof(char *));
108: //      c->variablevalues = (double *)calloc(n, sizeof(double));
109:         c->variables = (variable **)malloc(n*sizeof(variable *));
110:         int i;
111:         for(i=0; i<n; i++) {
112:                 c->variables[i] = makevariable();
113:         }
114:         
115: /*      c->parameternames = (char **)malloc(p*sizeof(char *));
116:         c->parameterinfo = (char **)malloc(p*sizeof(char *));
117:         c->parametervalues = (double *)calloc(p, sizeof(double));
118:         for(i=0; i<p; i++) {
119:                 c->parameternames[i] = "";
120:                 c->parameterinfo[i] = "";
121:         } */
122:         c->parameters = (constant **)malloc(p*sizeof(constant *));
123:         for(i=0; i<p; i++) {
124:                 c->parameters[i] = makeconstant();
125:                 c->parameters[i]->column = 0;
126:                 c->parameters[i]->row = i;
127:         }
128:         
129:         c->nplots = m;
130:         c->plots = (plot **)malloc(p*sizeof(plot *));
131:         for(i=0; i<m; i++) {
132:                 c->plots[i] = NULL;
133:         }
134:         
135:         c->ncolumns = 1;
136:         c->nrows = c->nparameters;
137:         
138:         return c;
139: }
140: 
141: void freecontrol(control *c)
142: {
143:         if (c->results!=NULL) {
144:                 free(c->results);
145:         }
146: 
147: //      free(c->variablevalues);
148: //      free(c->parametervalues);
149:         int i;
150:         for(i=0; i<c->nvariables; i++) {
151: //              free(c->variablenames[i]);
152:                 freevariable(c->variables[i]);
153:         }
154:         free(c->variables);
155:         
156:         for(i=0; i<c->nparameters; i++) {
157: //              free(c->parameternames[i]);
158: //              free(c->parameterinfo[i]);
159:                 freeconstant(c->parameters[i]);
160:         }
161:         free(c->parameters);
162:         
163:         for(i=0; i<c->nplots; i++) {
164:                 if(c->plots[i] != NULL) freeplot(c->plots[i]);
165:         }
166:         free(c->plots);
167:         free(c);
168: }
169: 
170: void initvariables(control *c, double *y)
171: {
172:         int i;
173:         for(i=0; i<c->nvariables; i++) {
174:                 y[i] = c->variables[i]->value;
175:         }
176: }
177: 
178: void output(control *c, int n, double *y, double t)
179: {
180: //      printf("%g", t);
181:         
182:         int p = c->outputcounter*(c->nvariables + 1);
183:         c->results[p++] = t;
184:         int i;
185:         for(i=0; i<n; i++) {
186: //              printf("\t%g", y[i]);
187:                 c->results[p++] = y[i];
188:         }
189: //      printf("\n");
190:         
191:         
192:         (c->outputcounter)++;
193: 
194: }
195: 
196: void printresults(control *c)
197: {
198:         int i;
199:         int j;
200:         
201:         for(i=0; i<c->outputcounter; i++) {
202:                 for(j=0; j<=c->nvariables; j++) {
203:                         printf("%g ", c->results[i*(c->nvariables + 1) + j]);
204:                 }
205:                 printf("\n");
206:         }
207: }
208: