00001 #include "entityload.h"
00002 #include "iotools.h"
00003 #include "mathem.h"
00004 #include <math.h>
00005 #include <string.h>
00006 #include <ctype.h>
00007
00008
00009
00010
00011
00012
00013 entityload::entityload()
00014 {
00015 ncomp = 0L;
00016 nlc = 0L;
00017 ft = stat;
00018 lgcs = 0L;
00019 val = NULL;
00020 func = NULL;
00021 tfunc = NULL;
00022 }
00023
00024
00025
00026
00027
00028
00029 entityload::~entityload()
00030 {
00031 long i;
00032 if (func)
00033 {
00034 for (i=0; i <ncomp; i++)
00035 {
00036 delete func[i];
00037 delete [] tfunc[i];
00038 }
00039 delete [] func;
00040 delete [] tfunc;
00041 }
00042 delete [] val;
00043 }
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060 long entityload::read(XFILE *in, long lc, long *slc=NULL)
00061 {
00062 Parser par;
00063 long var_x, var_y, var_z;
00064
00065 xfscanf(in, "%k%ld", "lc_id", &nlc);
00066 if ((nlc < 1) || (nlc > lc))
00067 return(1);
00068 if (slc)
00069 {
00070 xfscanf(in, "%k%ld", "slc_id", &nslc);
00071 if ((nslc < 1) || (nslc > slc[nlc-1]))
00072 return(1);
00073 }
00074 long i;
00075 xfscanf(in, "%k%ld%k%m", "ncomp", &ncomp, "func_type", &generalfunct_kwdset, &ft);
00076 xfscanf(in, "%k%ld", "coord_sys", &lgcs);
00077 if ((lgcs < 1) || (lgcs > 2))
00078 return 2;
00079 switch (ft)
00080 {
00081 case stat:
00082 val = new double [ncomp];
00083 memset (val, 0, sizeof(*val)*ncomp);
00084 xfscanf(in, "%k", "load_comp");
00085 for (i=0; i<ncomp; i++)
00086 xfscanf(in, "%le", val+i);
00087 break;
00088 case pars:
00089 func = new Equation*[ncomp];
00090 tfunc = new char*[ncomp];
00091 memset (func, 0, sizeof(*func)*ncomp);
00092 memset (tfunc, 0, sizeof(*tfunc)*ncomp);
00093 for (i=0; i<ncomp; i++)
00094 {
00095 tfunc[i] = new char[1001];
00096 xfscanf(in, "%1000s", tfunc[i]);
00097 func[i] = par.TextToTree(tfunc[i]);
00098
00099 if (func[i]->Variables.count() != 3)
00100 return 3;
00101 var2coord(func[i], var_x, var_y, var_z);
00102 if ((var_x < 0) || (var_y < 0) || (var_z < 0))
00103 return 4;
00104 }
00105 break;
00106 default:
00107 return 5;
00108 }
00109 return(0);
00110 }
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126 void entityload::var2coord(Equation *eq, long &var_x, long &var_y, long &var_z)
00127 {
00128 variable *var;
00129
00130 var_x = var_y = var_z = -1;
00131
00132 var = eq->Variables.at(0);
00133 if (tolower(var->Name[0]) == 'x')
00134 var_x = 0;
00135 else
00136 {
00137 if (tolower(var->Name[0]) == 'y')
00138 var_y = 0;
00139 else
00140 {
00141 if (tolower(var->Name[0]) == 'z')
00142 var_z = 0;
00143 }
00144 }
00145
00146 var = eq->Variables.at(1);
00147 if (tolower(var->Name[0]) == 'x')
00148 var_x = 1;
00149 else
00150 {
00151 if (tolower(var->Name[0]) == 'y')
00152 var_y = 1;
00153 else
00154 {
00155 if (tolower(var->Name[0]) == 'z')
00156 var_z = 1;
00157 }
00158 }
00159
00160 var = eq->Variables.at(2);
00161 if (tolower(var->Name[0]) == 'x')
00162 var_x = 2;
00163 else
00164 {
00165 if (tolower(var->Name[0]) == 'y')
00166 var_y = 2;
00167 else
00168 {
00169 if (tolower(var->Name[0]) == 'z')
00170 var_z = 2;
00171 }
00172 }
00173 }
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187 long entityload::getval(snode &tn, double *nv)
00188 {
00189 long i, var_x, var_y, var_z;
00190 variable *var;
00191
00192 switch (ft)
00193 {
00194 case stat:
00195 for (i=0; i<ncomp; i++)
00196 nv[i] = val[i];
00197 break;
00198 case pars:
00199 for (i=0; i<ncomp; i++)
00200 {
00201 var2coord(func[i], var_x, var_y, var_z);
00202
00203 var = func[i]->Variables.at(var_x);
00204 var->Value = tn.x;
00205
00206 var = func[i]->Variables.at(var_y);
00207 var->Value = tn.y;
00208
00209 var = func[i]->Variables.at(var_z);
00210 var->Value = tn.z;
00211 nv[i] = func[i]->Evaluate();
00212 }
00213 break;
00214 default:
00215 return 1;
00216 }
00217 return(0);
00218 }
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238 loadel *entityload::edge2loadel(selement &el, long prop, snode *nodes, long *edgid, long nedgid)
00239 {
00240 long i, j, k, l, id, tnne;
00241 loadel *ret=new loadel;
00242 double *nv;
00243
00244 for (i=0, tnne=0; i<el.ned; i++)
00245 tnne += el.nned[i];
00246 ret->tel = edge;
00247 ret->ned = el.ned;
00248 ret->nnve = tnne*ncomp;
00249 ret->nlc = nlc;
00250 ret->le = new long[ret->ned];
00251 memset(ret->le, 0, sizeof(*ret->le)*ret->ned);
00252 ret->nodvale = new double[ret->nnve];
00253 memset(ret->nodvale, 0, sizeof(*ret->nodvale)*ret->nnve);
00254 nv = new double[ncomp];
00255
00256 if (el.propedg)
00257 {
00258 id = 0;
00259 for(i=0; i<el.ned; i++)
00260 {
00261 if (el.propedg[i] == prop)
00262 {
00263 ret->le[i] = lgcs;
00264 for(j=0; j<el.nned[i]; j++)
00265 {
00266 if (getval(nodes[el.nodes[el.edgenod[i][j]]], nv))
00267 {
00268 delete ret;
00269 delete nv;
00270 return NULL;
00271 }
00272
00273 for(k=0; k<ncomp; k++)
00274 {
00275 ret->nodvale[id] += nv[k];
00276 id++;
00277 }
00278 }
00279 }
00280 else
00281 id += el.nned[i]*ncomp;
00282 }
00283 }
00284
00285 if (edgid && nedgid)
00286 {
00287
00288 id = 0;
00289 l = 0;
00290 for(i=0; i<el.ned; i++)
00291 {
00292 if (i == edgid[l])
00293 {
00294 ret->le[i] = lgcs;
00295 for(j=0; j<el.nned[i]; j++)
00296 {
00297 if (getval(nodes[el.nodes[el.edgenod[i][j]]], nv))
00298 {
00299 delete ret;
00300 delete nv;
00301 return NULL;
00302 }
00303
00304 for(k=0; k<ncomp; k++)
00305 {
00306 ret->nodvale[id] += nv[k];
00307 id++;
00308 }
00309 }
00310 if (l < nedgid-1)
00311 l++;
00312 else
00313 break;
00314 }
00315 else
00316 id += el.nned[i]*ncomp;
00317 }
00318 }
00319
00320 delete [] nv;
00321 return ret;
00322 }
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342 loadel *entityload::surface2loadel(selement &el, long prop, snode *nodes, long *surfid, long nsurfid)
00343 {
00344 long i, j, k, l, id, tnns;
00345 loadel *ret=new loadel;
00346 double *nv;
00347
00348 for (i=0, tnns=0; i<el.nsurf; i++)
00349 tnns += el.nnsurf[i];
00350 ret->tel = surface;
00351 ret->nsurf = el.nsurf;
00352 ret->nnvs = tnns*ncomp;
00353 ret->nlc = nlc;
00354 ret->ls = new long[ret->nsurf];
00355 memset(ret->ls, 0, sizeof(*ret->ls)*ret->nsurf);
00356 ret->nodvals = new double[ret->nnvs];
00357 memset(ret->nodvals, 0, sizeof(*ret->nodvals)*ret->nnvs);
00358 nv = new double[ncomp];
00359
00360 if (el.propsurf)
00361 {
00362 id = 0;
00363 for(i=0; i<el.nsurf; i++)
00364 {
00365 if (el.propsurf[i] == prop)
00366 {
00367 ret->ls[i] = lgcs;
00368 for(j=0; j<el.nnsurf[i]; j++)
00369 {
00370 if (getval(nodes[el.nodes[el.surfnod[i][j]]], nv))
00371 {
00372 delete ret;
00373 delete nv;
00374 return NULL;
00375 }
00376
00377 for(k=0; k<ncomp; k++)
00378 {
00379 ret->nodvals[id] += nv[k];
00380 id++;
00381 }
00382 }
00383 }
00384 else
00385 id += el.nnsurf[i]*ncomp;
00386 }
00387 }
00388
00389 if (surfid && nsurfid)
00390 {
00391
00392 id = 0;
00393 l = 0;
00394 for(i=0; i<el.nsurf; i++)
00395 {
00396 if (i == surfid[l])
00397 {
00398 l++;
00399 ret->ls[i] = lgcs;
00400 for(j=0; j<el.nnsurf[i]; j++)
00401 {
00402 if (getval(nodes[el.nodes[el.surfnod[i][j]]], nv))
00403 {
00404 delete ret;
00405 delete nv;
00406 return NULL;
00407 }
00408
00409 for(k=0; k<ncomp; k++)
00410 {
00411 ret->nodvals[id] += nv[k];
00412 id++;
00413 }
00414 }
00415 if (l < nsurfid-1)
00416 l++;
00417 else
00418 break;
00419 }
00420 else
00421 id += el.nnsurf[i]*ncomp;
00422 }
00423 }
00424
00425 delete [] nv;
00426 return ret;
00427 }
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444 loadel *entityload::vol2loadel(selement &el, long prop, snode *nodes)
00445 {
00446 long i, k, id;
00447 loadel *ret=new loadel;
00448 double *nv;
00449
00450 nv = new double[ncomp];
00451 if (el.prop == prop)
00452 {
00453 ret->nnvv = el.nne*ncomp;
00454 ret->tel = volume;
00455 ret->nlc = nlc;
00456 ret->nodvalv = new double[ret->nnvv];
00457 memset(ret->nodvalv, 0, sizeof(*ret->nodvalv)*ret->nnvv);
00458
00459 id = 0;
00460 for (i=0; i<el.nne; i++)
00461 {
00462 if (getval(nodes[el.nodes[i]], nv))
00463 {
00464 delete ret;
00465 delete nv;
00466 return NULL;
00467 }
00468 for(k=0; k<ncomp; k++)
00469 {
00470 ret->nodvalv[id] += nv[k];
00471 id++;
00472 }
00473 }
00474 }
00475 delete [] nv;
00476 return ret;
00477 }