00001 #include "iotools.h"
00002 #include "mathem.h"
00003 #include "globalt.h"
00004 #include "entitybocon.h"
00005 #include <math.h>
00006 #include <string.h>
00007 #include <ctype.h>
00008
00009
00010
00011
00012
00013
00014
00015
00016 entitybocon::entitybocon()
00017 {
00018 it = interpoltype(0);
00019 dc = 0;
00020 dt = 0;
00021 }
00022
00023
00024
00025
00026
00027
00028
00029
00030 entitybocon::~entitybocon()
00031 {
00032 }
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046 long entitybocon::read(XFILE *in)
00047 {
00048 long res;
00049
00050 gf.read(in);
00051 switch (gf.tfunc)
00052 {
00053 case stat:
00054 case tab:
00055 return 0;
00056 case pars:
00057 res = checkvar2coord();
00058 if(res < 1)
00059 return 1;
00060
00061
00062
00063
00064
00065
00066
00067 return 0;
00068 case pars_set:
00069 res = checkvar2coord();
00070 if(res < 1)
00071 return 1;
00072 if (dt == 0)
00073 {
00074
00075 xfscanf(in, "%k%m", "approx_type", &interpoltype_kwdset, (int*)&it);
00076 }
00077 return 0;
00078 default:
00079 print_err("unsupported type of gfunct - 'stat', 'tab', 'pars' or 'pars_set' can be specified", __FILE__, __LINE__, __func__);
00080 abort();
00081 }
00082 return 0;
00083
00084 }
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098 long entitybocon::checkvar2coord()
00099 {
00100 long i, j;
00101 long ret = 0;
00102 long n = 0;
00103
00104 var_x = var_y = var_z = -1;
00105 dt = 0;
00106 dc = 0;
00107
00108 switch(gf.tfunc)
00109 {
00110 case pars:
00111 case pars_set:
00112 for(i=0; i<gf.neqs; i++)
00113 {
00114 for(j=0; j<gf.eq[i]->Variables.count(); j++)
00115 {
00116 if (tolower(gf.var[i][j]->Name[0]) == 'x')
00117 {
00118 var_x = j;
00119 dc = 1;
00120 n++;
00121 }
00122 if (tolower(gf.var[i][j]->Name[0]) == 'y')
00123 {
00124 var_y = j;
00125 dc = 1;
00126 n++;
00127 }
00128 if (tolower(gf.var[i][j]->Name[0]) == 'z')
00129 {
00130 var_z = j;
00131 dc = 1;
00132 n++;
00133 }
00134 if (tolower(gf.var[i][j]->Name[0]) == 't')
00135 {
00136 dt = 1;
00137 n++;
00138 }
00139 }
00140 if (n != gf.eq[0]->Variables.count())
00141 {
00142 print_err("unknown parameters of function detected,\n"
00143 " parameters must be denoted by x,y,z and t only.", __FILE__, __LINE__, __func__);
00144 abort();
00145 }
00146 if (n > ret)
00147 ret = n;
00148 n = 0;
00149 }
00150 break;
00151 default:
00152 print_err("unknown type of gfunct is required"
00153 " only 'pars' and 'pars_set' can be used", __FILE__, __LINE__, __func__);
00154 abort();
00155 }
00156 return ret;
00157 }
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172 long entitybocon::var2coord(long i)
00173 {
00174 long j;
00175 long ret = 0;
00176
00177 var_x = var_y = var_z = -1;
00178
00179 if ((i < 0) && (i>=gf.neqs))
00180 {
00181 print_err("index of parsed function is out of range", __FILE__, __LINE__, __func__);
00182 abort();
00183 }
00184
00185 switch(gf.tfunc)
00186 {
00187 case pars:
00188 case pars_set:
00189 for(j=0; j<gf.eq[i]->Variables.count(); j++)
00190 {
00191 if (tolower(gf.var[i][j]->Name[0]) == 'x')
00192 {
00193 var_x = j;
00194 ret++;
00195 }
00196 if (tolower(gf.var[i][j]->Name[0]) == 'y')
00197 {
00198 var_y = j;
00199 ret++;
00200 }
00201 if (tolower(gf.var[i][j]->Name[0]) == 'z')
00202 {
00203 var_z = j;
00204 ret++;
00205 }
00206 if (tolower(gf.var[i][j]->Name[0]) == 't')
00207 {
00208 ret++;
00209 }
00210 }
00211 if (ret != gf.eq[i]->Variables.count())
00212 {
00213 print_err("unknown parameters of function detected,\n"
00214 " parameters must be denoted by x,y,z and t only.", __FILE__, __LINE__, __func__);
00215 abort();
00216 }
00217 return ret;
00218 default:
00219 print_err("unknown type of gfunct is required"
00220 " only 'pars' and 'pars_set' can be used", __FILE__, __LINE__, __func__);
00221 abort();
00222 }
00223 return ret;
00224 }
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242 long entitybocon::getval(snode &tn, gfunct &tgf)
00243 {
00244 long i, j;
00245 Parser par;
00246
00247 switch (gf.tfunc)
00248 {
00249 case stat:
00250 case tab:
00251 tgf.copy(gf);
00252 break;
00253 case pars:
00254 if (dc)
00255 {
00256 if (dt)
00257 {
00258
00259
00260 tgf.tfunc = pars;
00261 tgf.neqs = 1;
00262 tgf.eq = new Equation* [1];
00263 tgf.var = new variable**[1];
00264 tgf.func = new char* [1];
00265 tgf.func[0] = substbcstr(gf.func[0], tn);
00266 tgf.eq[0] = par.TextToTree(tgf.func[0]);
00267 if (tgf.eq[0] == NULL)
00268 {
00269 print_err("parsing expression", __FILE__, __LINE__, __func__);
00270 return (2);
00271 }
00272 tgf.var[0] = new variable* [tgf.eq[0]->Variables.count()];
00273 for(j=0; j < tgf.eq[0]->Variables.count(); j++)
00274 gf.var[0][j] = tgf.eq[0]->Variables.at(j);
00275 }
00276 else
00277 {
00278
00279 tgf.tfunc = stat;
00280 var2coord(0);
00281 setvars(tn, 0);
00282 tgf.f = gf.eq[0]->Evaluate();
00283 }
00284 }
00285 else
00286 {
00287
00288 tgf.copy(gf);
00289 }
00290 break;
00291 case pars_set:
00292 if (dc)
00293 {
00294 if (dt)
00295 {
00296
00297
00298 tgf.tfunc = pars_set;
00299 tgf.neqs = gf.neqs;
00300 tgf.eq = new Equation* [gf.neqs];
00301 tgf.var = new variable**[gf.neqs];
00302 tgf.func = new char* [gf.neqs];
00303 tgf.limval = new double [gf.neqs];
00304 for(i=0; i<gf.neqs; i++)
00305 {
00306 tgf.limval[i] = gf.limval[i];
00307 tgf.func[i] = substbcstr(gf.func[i], tn);
00308 tgf.eq[i] = par.TextToTree(tgf.func[i]);
00309 if (tgf.eq[i] == NULL)
00310 {
00311 print_err("parsing expression", __FILE__, __LINE__, __func__);
00312 return (2);
00313 }
00314 tgf.var[i] = new variable* [tgf.eq[i]->Variables.count()];
00315 for(j=0; j < gf.eq[i]->Variables.count(); j++)
00316 tgf.var[i][j] = tgf.eq[i]->Variables.at(j);
00317 }
00318 }
00319 else
00320 {
00321
00322 tgf.tfunc = tab;
00323
00324 tgf.tabf = new tablefunct(gf.neqs+1);
00325
00326 tgf.tabf->itype = it;
00327 for(i=0; i<gf.neqs; i++)
00328 {
00329 tgf.tabf->x[i+1] = gf.limval[i];
00330 var2coord(i);
00331 setvars(tn, i);
00332 tgf.tabf->y[i+1] = gf.eq[i]->Evaluate();
00333 }
00334
00335
00336
00337 tgf.tabf->x[0] = tgf.tabf->x[1]-1.0;
00338 tgf.tabf->y[0] = tgf.tabf->y[1];
00339 }
00340 }
00341 else
00342 {
00343
00344 tgf.copy(gf);
00345 }
00346 break;
00347 default:
00348 print_err("unknown type of function is required", __FILE__, __LINE__, __func__);
00349 return 1;
00350 }
00351 return(0);
00352 }
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368 void entitybocon::setvars(snode &tn, long i)
00369 {
00370 if (var_x > -1)
00371 gf.var[i][var_x]->Value = tn.x;
00372
00373 if (var_y > -1)
00374 gf.var[i][var_y]->Value = tn.y;
00375
00376 if (var_z > -1)
00377 gf.var[i][var_z]->Value = tn.z;
00378 }
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396 char *entitybocon::substbcstr(const char *expr, snode &tn)
00397 {
00398 char *src, *ret;
00399 char *loc, *ploc, *aptr;
00400 long l = strlen(expr);
00401 long ln;
00402 long i, nx, ny, nz;
00403 int n;
00404 long lalpha, ralpha;
00405
00406
00407 src = new char[l];
00408 memcpy(src, expr, l);
00409 for(i=0; i<l; i++)
00410 src[i] = tolower(src[i]);
00411 loc = src;
00412 nx = ny = nz = 0L;
00413 do
00414 {
00415 loc = strpbrk(loc, "xyz");
00416 if (loc)
00417 {
00418 if (loc > src)
00419 lalpha = isalpha(*(loc-1));
00420 else
00421 lalpha = 0;
00422
00423 ralpha = isalpha(*(loc+1));
00424
00425 if (lalpha+ralpha == 0)
00426 {
00427
00428
00429 if (*loc == 'x')
00430 nx++;
00431 if (*loc == 'y')
00432 ny++;
00433 if (*loc == 'z')
00434 nz++;
00435 }
00436 }
00437 }while(loc);
00438
00439
00440 ln = l + (nx+ny+nz)*(1+1+1+1+15+1+1+3+1)+1;
00441
00442 ret = new char[ln];
00443 aptr = ret;
00444 loc = ploc = src;
00445 ploc--;
00446
00447 do
00448 {
00449 loc = strpbrk(loc, "xyz");
00450 if (loc)
00451 {
00452 if (loc > src)
00453 lalpha = isalpha(*(loc-1));
00454 else
00455 lalpha = 0;
00456
00457 ralpha = isalpha(*(loc+1));
00458
00459 if (lalpha+ralpha == 0)
00460 {
00461
00462
00463
00464
00465 memcpy(ret, ploc+1, loc-ploc-1);
00466 aptr += loc-ploc-1;
00467
00468
00469 if (*loc == 'x')
00470 {
00471 sprintf(aptr, "(%.15le)%n", tn.x, &n);
00472 aptr += n;
00473 }
00474 if (*loc == 'y')
00475 {
00476 sprintf(aptr, "(%.15le)%n", tn.y, &n);
00477 aptr += n;
00478 }
00479 if (*loc == 'z')
00480 {
00481 sprintf(aptr, "(%.15le)%n", tn.z, &n);
00482 aptr += n;
00483 }
00484 ploc = loc;
00485 }
00486 }
00487 }while(loc);
00488
00489
00490 memcpy(aptr, ploc+1, (src+l+1)-(ploc+1));
00491
00492 aptr += src+l+1-ploc-1;
00493
00494 delete [] src;
00495
00496 return ret;
00497 }