00001 #include <stdlib.h>
00002 #include <stdio.h>
00003 #include <string.h>
00004 #include <math.h>
00005 #include "selection.h"
00006 #include "iotools.h"
00007
00008
00009
00010
00011
00012
00013 sel::sel()
00014 {
00015 st = sel_no;
00016 n = 0;
00017 ncomp = id1 = NULL;
00018 rid1 = rid2 = NULL;
00019 err = 0.0;
00020 initime = fintime = r = 0.0;
00021 ent = NULL;
00022 }
00023
00024
00025
00026
00027
00028 sel::~sel()
00029 {
00030 delete [] ncomp;
00031 delete [] id1;
00032 delete [] rid1;
00033 delete [] rid2;
00034 delete [] ent;
00035 }
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052 long sel::read(XFILE *in)
00053 {
00054 long i;
00055 char *kwdstr;
00056
00057 if (xfscanf(in, "%m", &seltype_kwdset, (int *)&st) != 1)
00058 {
00059 print_err("cannot read type of selection", __FILE__, __LINE__, __func__);
00060 return 1;
00061 }
00062 switch (st)
00063 {
00064 case sel_no:
00065 n = 0;
00066 return 0;
00067 case sel_all:
00068 case sel_impvalues:
00069 n = 1;
00070 id1 = new long [1];
00071 ncomp = new long [1];
00072 id1[0] = 0;
00073 ncomp[0] = 0;
00074 return 0;
00075 case sel_period:
00076 n = 1;
00077 id1 = new long [1];
00078 ncomp = new long [1];
00079 ncomp[0] = 1;
00080 if (xfscanf(in, "%ld", id1) != 1)
00081 {
00082 print_err("cannot read reading period", __FILE__, __LINE__, __func__);
00083 return 2;
00084 }
00085 return 0;
00086 case sel_realperiod:
00087 if (xfscanf(in, "%k%le%k%le%k%le%k%le", "ini_time", &initime,
00088 "fin_time", &fintime, "period", &r, "err", &err) != 8)
00089 {
00090 print_err("Cannot read real period selection", __FILE__, __LINE__, __func__);
00091 return 2;
00092 }
00093 if ((fintime - initime) < 0.0)
00094 {
00095 print_err("Final time is less than initial time", __FILE__, __LINE__, __func__);
00096 return 2;
00097 }
00098 n = long((fintime - initime)/r) + 1;
00099 if (n < 2)
00100 n = 2;
00101 rid1 = new double[n];
00102 memset(rid1, 0, sizeof(*rid1)*n);
00103 rid1[0] = initime;
00104 for (i=1; i<n-1; i++)
00105 rid1[i] += rid1[i-1] + r;
00106 rid1[n-1] = fintime;
00107 return 0;
00108 case sel_mtx:
00109 n = 1;
00110 id1 = new long [1];
00111 ncomp = new long [1];
00112 id1[0] = 0;
00113 ncomp[0] = 0;
00114 return 0;
00115 case sel_vec:
00116 case sel_range_vec:
00117 case sel_range_mtx:
00118 n = 1;
00119 break;
00120 case sel_range:
00121 case sel_realrange:
00122 kwdstr = "numranges";
00123 break;
00124 case sel_list:
00125 case sel_reallist:
00126 case sel_impvallst:
00127 kwdstr = "numlist_items";
00128 break;
00129 case sel_prop:
00130 if (xfscanf(in, "%k%ld", "numprop", &n) != 5)
00131 {
00132 print_err("cannot read number of selected property id", __FILE__, __LINE__, __func__);
00133 return 2;
00134 }
00135 id1 = new long [n];
00136 ncomp = new long [n];
00137 ent = new gentity [n];
00138 for (i=0; i<n; i++)
00139 {
00140 ncomp[i] = 1;
00141 if (xfscanf(in, "%k%ld", "prop", id1+i) != 1)
00142 {
00143 print_err("cannot read property number", __FILE__, __LINE__, __func__);
00144 return 2;
00145 }
00146 if (xfscanf(in, "%k%m", "ent", &gentity_kwdset, ent+i) != 1)
00147 {
00148 print_err("cannot read entity type", __FILE__, __LINE__, __func__);
00149 return 2;
00150 }
00151 }
00152 return 0;
00153 default:
00154 break;
00155 }
00156 if ((st != sel_range_vec) && (st != sel_range_mtx) && (st != sel_vec))
00157 {
00158 if (xfscanf(in, "%k%ld", kwdstr, &n) != 2)
00159 {
00160 print_err("cannot read number of ranges or items", __FILE__, __LINE__, __func__);
00161 return 2;
00162 }
00163 }
00164 if ((st == sel_range) || (st == sel_range_mtx) || (st == sel_range_vec) || (st == sel_list) ||
00165 (st == sel_vec) || (st == sel_impvallst))
00166 {
00167 id1 = new long[n];
00168 memset(id1, 0, sizeof(*id1)*n);
00169 if ((st == sel_range)|| (st == sel_range_mtx) || (st == sel_range_vec))
00170 {
00171 ncomp = new long[n];
00172 memset(ncomp, 0, sizeof(*ncomp)*n);
00173 }
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187 for (i=0; i<n; i++)
00188 {
00189
00190 if (xfscanf(in, "%ld", id1+i) != 1)
00191 {
00192 print_err("cannot read range or list of selection", __FILE__, __LINE__, __func__);
00193 return 3;
00194 }
00195 id1[i]--;
00196 if ((st == sel_list) || (st == sel_vec))
00197 continue;
00198
00199 if (xfscanf(in, "%ld", ncomp+i) != 1)
00200 {
00201 print_err("cannot read range of selection", __FILE__, __LINE__, __func__);
00202 return 3;
00203 }
00204 }
00205 }
00206 if ((st == sel_realrange) || (st == sel_reallist))
00207 {
00208 rid1 = new double[n];
00209 memset(rid1, 0, sizeof(*rid1)*n);
00210 if (st == sel_realrange)
00211 {
00212 rid2 = new double[n];
00213 memset(rid2, 0, sizeof(*rid2)*n);
00214 }
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226 for (i=0; i<n; i++)
00227 {
00228
00229
00230 if (xfscanf(in, "%lf", rid1+i) != 1)
00231 {
00232 print_err("cannot read real range or list", __FILE__, __LINE__, __func__);
00233 return 4;
00234 }
00235 if (st == sel_reallist)
00236 continue;
00237
00238 if (xfscanf(in, "%lf", rid2+i) != 1)
00239 {
00240 print_err("cannot read real range in function", __FILE__, __LINE__, __func__);
00241 return 4;
00242 }
00243 }
00244 if (st == sel_reallist)
00245 {
00246
00247 if (xfscanf(in, "%lf", &err) != 1)
00248 {
00249 print_err("cannot read real range or list", __FILE__, __LINE__, __func__);
00250 return 4;
00251 }
00252 }
00253 }
00254 return 0;
00255 }
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268 void sel::print(FILE *out)
00269 {
00270 long i;
00271 fprintf(out, "%d", (int)st);
00272 switch (st)
00273 {
00274 case sel_no:
00275 case sel_all:
00276 case sel_impvalues:
00277 case sel_mtx:
00278 fprintf(out, "\n");
00279 break;
00280 case sel_vec:
00281 fprintf(out, " %ld\n", id1[0]+1);
00282 break;
00283 case sel_range:
00284 fprintf(out, " %ld\n", n);
00285 for (i=0; i<n; i++)
00286 fprintf(out, "%ld %ld\n", id1[i]+1, ncomp[i]);
00287 break;
00288 case sel_range_vec:
00289 for (i=0; i<n; i++)
00290 fprintf(out, " %ld %ld\n", id1[i]+1, ncomp[i]);
00291 break;
00292 case sel_range_mtx:
00293 for (i=0; i<n; i++)
00294 fprintf(out, " %ld %ld\n", id1[i]+1, ncomp[i]);
00295 break;
00296 case sel_list:
00297 fprintf(out, " %ld\n", n);
00298 for (i=0; i<n; i++)
00299 fprintf(out, "%ld\n", id1[i]+1);
00300 break;
00301 case sel_period:
00302 fprintf(out, " %ld\n", id1[0]);
00303 break;
00304 case sel_realperiod:
00305 fprintf(out, " %le %le %le %le\n", initime, fintime, r, err);
00306 case sel_realrange:
00307 fprintf(out, " %ld\n", n);
00308 for (i=0; i<n; i++)
00309 fprintf(out, "%e %e\n", rid1[i], rid2[i]);
00310 break;
00311 case sel_reallist:
00312 fprintf(out, " %ld\n", n);
00313 for (i=0; i<n; i++)
00314 fprintf(out, "%e\n", rid1[i]);
00315 fprintf(out, "%e\n", err);
00316 break;
00317 case sel_prop:
00318 fprintf(out, " %ld\n", n);
00319 for (i=0; i<n; i++)
00320 fprintf(out, "%ld %d\n", id1[i], int(ent[i]));
00321 break;
00322 case sel_impvallst:
00323 fprintf(out, " %ld\n", n);
00324 for (i=0; i<n; i++)
00325 fprintf(out, "%ld\n", id1[i]+1);
00326 break;
00327 default:
00328 print_err("unknown type of selection is required", __FILE__, __LINE__, __func__);
00329 }
00330 }
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342 long sel::presence_id(double id)
00343 {
00344 long i;
00345 switch (st)
00346 {
00347 case sel_realrange:
00348 for (i=0; i<n; i++)
00349 if ((id >= rid1[i]) && (id <= rid2[i]))
00350 return 1;
00351 break;
00352 case sel_reallist:
00353 case sel_realperiod:
00354 for (i=0; i<n; i++)
00355 if (fabs(id - rid1[i]) <= err)
00356 return 1;
00357 break;
00358 default:
00359 print_err("unknown type of selection is required", __FILE__, __LINE__, __func__);
00360 }
00361 return 0;
00362 }
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375 long sel::presence_id(long id)
00376 {
00377 long i;
00378 switch (st)
00379 {
00380 case sel_no:
00381 return 0;
00382 case sel_all:
00383 return 1;
00384 case sel_mtx:
00385 if (id < 6)
00386 return 1;
00387 break;
00388 case sel_vec:
00389 if (id == id1[0])
00390 return 1;
00391 break;
00392 case sel_range:
00393 case sel_range_vec:
00394 case sel_range_mtx:
00395 for (i=0; i<n; i++)
00396 if ((id >= id1[i]) && (id < id1[i]+ncomp[i]))
00397 return 1;
00398 break;
00399 case sel_list:
00400 for (i=0; i<n; i++)
00401 if (id == id1[i])
00402 return 1;
00403 break;
00404 case sel_period:
00405 if (id%id1[0] == 0)
00406 return 1;
00407 break;
00408 default:
00409 print_err("unknown type of selection is required", __FILE__, __LINE__, __func__);
00410 }
00411 return 0;
00412 }
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427 long sel::presence_id(long id, double rid)
00428 {
00429 if ((st == sel_realrange) || (st == sel_reallist) || (st == sel_realperiod))
00430 return presence_id(rid);
00431 else
00432 return presence_id(id);
00433 }
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451 long sel::presence_id(long id, double rid, timecontr &tc)
00452 {
00453 if (st == sel_impvalues)
00454 return tc.iiit;
00455 if (st == sel_impvallst)
00456 {
00457 for (long i=0; i<n; i++)
00458 {
00459 if (tc.apit == id1[i])
00460 return tc.iiit;
00461 }
00462 return 0;
00463 }
00464 if ((st == sel_realrange) || (st == sel_reallist) || (st == sel_realperiod))
00465 return presence_id(rid);
00466 else
00467 return presence_id(id);
00468 }
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483 long sel::presence_id(double id, long &ir)
00484 {
00485 long i;
00486 ir = -1;
00487 switch (st)
00488 {
00489 case sel_realrange:
00490 for (i=0; i<n; i++)
00491 {
00492 if ((id >= rid1[i]) && (id <= rid2[i]))
00493 {
00494 ir = i;
00495 return 1;
00496 }
00497 }
00498 break;
00499 case sel_reallist:
00500 case sel_realperiod:
00501 for (i=0; i<n; i++)
00502 {
00503 if (fabs(id - rid1[i]) <= err)
00504 {
00505 ir = i;
00506 return 1;
00507 }
00508 }
00509 break;
00510 default:
00511 print_err("unknown type of selection is required", __FILE__, __LINE__, __func__);
00512 }
00513 return 0;
00514 }
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529 long sel::presence_id(long id, long &ir)
00530 {
00531 long i;
00532 ir = -1;
00533 switch (st)
00534 {
00535 case sel_no:
00536 return 0;
00537 case sel_all:
00538 ir = 0;
00539 return 1;
00540 case sel_mtx:
00541 if (id < 6)
00542 {
00543 ir = 0;
00544 return 1;
00545 }
00546 break;
00547 case sel_vec:
00548 if (id == id1[0])
00549 {
00550 ir = 0;
00551 return 1;
00552 }
00553 break;
00554 case sel_range:
00555 case sel_range_vec:
00556 case sel_range_mtx:
00557 for (i=0; i<n; i++)
00558 {
00559 if ((id >= id1[i]) && (id < id1[i]+ncomp[i]))
00560 {
00561 ir = i;
00562 return 1;
00563 }
00564 }
00565 break;
00566 case sel_list:
00567 for (i=0; i<n; i++)
00568 {
00569 if (id == id1[i])
00570 {
00571 ir = i;
00572 return 1;
00573 }
00574 }
00575 break;
00576 case sel_period:
00577 if (id%id1[0] == 0)
00578 {
00579 ir = 0;
00580 return 1;
00581 }
00582 break;
00583 default:
00584 print_err("unknown type of selection is required", __FILE__, __LINE__, __func__);
00585 }
00586 return 0;
00587 }
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608 long sel::presence_idgt(long id, long &ir)
00609 {
00610 long i;
00611 switch (st)
00612 {
00613 case sel_no:
00614 return 0;
00615 case sel_all:
00616 if (ir < 0)
00617 {
00618 ir = 0;
00619 return 1;
00620 }
00621 break;
00622 case sel_mtx:
00623 if ((id < 6) && (ir < 0))
00624 {
00625 ir = 0;
00626 return 1;
00627 }
00628 break;
00629 case sel_vec:
00630 if ((id == id1[0]) && (ir < 0))
00631 {
00632 ir = 0;
00633 return 1;
00634 }
00635 break;
00636 case sel_range:
00637 case sel_range_vec:
00638 case sel_range_mtx:
00639 for (i=0; i<n; i++)
00640 {
00641 if ((id >= id1[i]) && (id < id1[i]+ncomp[i]) && (ir < i))
00642 {
00643 ir = i;
00644 return 1;
00645 }
00646 }
00647 break;
00648 case sel_list:
00649 for (i=0; i<n; i++)
00650 {
00651 if ((id == id1[i]) && (ir < i))
00652 {
00653 ir = i;
00654 return 1;
00655 }
00656 }
00657 break;
00658 case sel_period:
00659 if ((id%id1[0] == 0) && (ir < 0))
00660 {
00661 ir = 0;
00662 return 1;
00663 }
00664 break;
00665 default:
00666 print_err("unknown type of selection is required", __FILE__, __LINE__, __func__);
00667 }
00668 return 0;
00669 }
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685 long sel::presence_id(long id, long sid, long &ir)
00686 {
00687 ir = -1;
00688 switch (st)
00689 {
00690 case sel_no:
00691 return 0;
00692 case sel_all:
00693 if (sid == 0)
00694 {
00695 ir = 0;
00696 return 1;
00697 }
00698 case sel_mtx:
00699 if ((id < 6) && (sid == 0))
00700 {
00701 ir = 0;
00702 return 1;
00703 }
00704 break;
00705 case sel_vec:
00706 if ((id == id1[0]) && (sid == 0))
00707 {
00708 ir = 0;
00709 return 1;
00710 }
00711 break;
00712 case sel_range:
00713 case sel_range_vec:
00714 case sel_range_mtx:
00715 if ((sid < 0) && (sid >= n))
00716 break;
00717 if ((id >= id1[sid]) && (id < id1[sid]+ncomp[sid]))
00718 {
00719 ir = sid;
00720 return 1;
00721 }
00722 break;
00723 case sel_list:
00724 if ((sid < 0) && (sid >= n))
00725 break;
00726 if (id == id1[sid])
00727 {
00728 ir = sid;
00729 return 1;
00730 }
00731 break;
00732 case sel_period:
00733 if ((id%id1[0] == 0) && (sid == 0))
00734 {
00735 ir = 0;
00736 return 1;
00737 }
00738 break;
00739 default:
00740 print_err("unknown type of selection is required", __FILE__, __LINE__, __func__);
00741 }
00742 return 0;
00743 }
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759 long sel::presence_id(long id, double rid, long &ir)
00760 {
00761 if ((st == sel_realrange) || (st == sel_reallist) || (st == sel_realperiod))
00762 return presence_id(rid, ir);
00763 else
00764 return presence_id(id, ir);
00765 }
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783 long sel::presence_id(sel *consel, long id, long idc)
00784 {
00785 long ir=-1;
00786 long i;
00787
00788 for (i=0; i < n; i++)
00789 {
00790 if (presence_idgt(id, ir))
00791 {
00792 if (consel[ir].presence_id(idc))
00793 return 1;
00794 }
00795 else
00796 return 0;
00797 }
00798
00799 return 0;
00800 }
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819 long sel::presence_id(sel *consel, long id, long idc, long &ir)
00820 {
00821 ir=-1;
00822 long i;
00823
00824 for (i=0; i < n; i++)
00825 {
00826 if (presence_idgt(id, ir))
00827 {
00828 if (consel[ir].presence_id(idc))
00829 return 1;
00830 }
00831 else
00832 return 0;
00833 }
00834
00835 return 0;
00836 }
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848 long sel::give_nselcomp(long tncomp)
00849 {
00850 long ret=0;
00851 long i, di;
00852
00853 switch(st)
00854 {
00855 case sel_no:
00856 ret=0;
00857 break;
00858 case sel_all:
00859 ret=tncomp;
00860 break;
00861 case sel_range:
00862 for(i=0; i<n; i++)
00863 {
00864 if (id1[i] >= tncomp)
00865 continue;
00866 di = id1[i]+ncomp[i]-1;
00867 if (di < tncomp)
00868 {
00869 ret += ncomp[i];
00870 continue;
00871 }
00872 else
00873 ret += di+1-tncomp;
00874 }
00875 break;
00876 case sel_list:
00877 for(i=0; i<n; i++)
00878 {
00879 if (id1[i] < tncomp) ret++;
00880 }
00881 break;
00882 default:
00883 print_err("unknown type of selection is required", __FILE__, __LINE__, __func__);
00884 }
00885 return ret;
00886 }
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905 long sel::conv_selprop(siftop *top, objtype ot)
00906 {
00907 long i,j;
00908 long nlit, nrit;
00909 long ret;
00910 long *selobj;
00911 long nobj;
00912 long *entid;
00913 long nentid;
00914
00915 switch (ot)
00916 {
00917 case gelem:
00918 nobj = top->ne;
00919 selobj = new long[nobj];
00920 memset(selobj, 0, sizeof(*selobj)*nobj);
00921 for (i=0; i<n; i++)
00922 {
00923 for (j=0; j<top->ne; j++)
00924 {
00925 entid = NULL;
00926 nentid = 0;
00927 ret = top->elements[j].searchprop(id1[i], ent[i], NULL, j, top->edges, top->surfaces, entid, nentid);
00928 if (ret < 0)
00929 {
00930 print_err("no edge or surface properties are given on elements", __FILE__, __LINE__, __func__);
00931 return 2;
00932 }
00933 selobj[j] += ret;
00934 }
00935 }
00936 break;
00937 case gnod:
00938 nobj = top->nn;
00939 selobj = new long[nobj];
00940 memset(selobj, 0, sizeof(*selobj)*nobj);
00941 for (i=0; i<n; i++)
00942 {
00943 for (j=0; j<top->nn; j++)
00944 {
00945 entid = NULL;
00946 nentid = 0;
00947 top->get_propent_nodes(id1[i], ent[i], selobj);
00948 }
00949 }
00950 break;
00951 default:
00952 print_err("unknown type of object(%d) is required", __FILE__, __LINE__, __func__, ot);
00953 return 1;
00954 }
00955
00956 nlit = give_num_lst_items(nobj, selobj);
00957 nrit = give_num_range_items(nobj, selobj);
00958 delete [] id1;
00959 delete [] ncomp;
00960 delete [] ent;
00961 ent = NULL;
00962 if (2*nrit < nlit)
00963 conv2range(nrit, nobj, selobj);
00964 else
00965 conv2lst(nlit, nobj, selobj);
00966
00967 return 0;
00968 }
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983 long sel::give_num_lst_items(long nobj, long *selobj)
00984 {
00985 long i, j;
00986
00987 j = 0;
00988 for (i=0; i<nobj; i++)
00989 {
00990 if (selobj[i]) j++;
00991 }
00992
00993 return j;
00994 }
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010 long sel::give_num_range_items(long nobj, long *selobj)
01011 {
01012 long i, j, start_r;
01013
01014 j = 0;
01015 start_r = 0;
01016 for(i=0; i<nobj; i++)
01017 {
01018 if (selobj[i])
01019 {
01020 if (start_r == 0)
01021 start_r = 1;
01022
01023 continue;
01024 }
01025 else
01026 {
01027 if (start_r)
01028 {
01029 j++;
01030 start_r = 0;
01031 }
01032 }
01033 }
01034 if (start_r)
01035 {
01036 j++;
01037 start_r = 0;
01038 }
01039
01040 return j;
01041 }
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061 void sel::conv2range(long nit, long nobj, long *selobj)
01062 {
01063 long i, j, start_r;
01064
01065 st = sel_range;
01066 n = nit;
01067 id1 = new long[n];
01068 ncomp = new long[n];
01069 memset(id1, 0, sizeof(*id1)*n);
01070 memset(ncomp, 0, sizeof(*ncomp)*n);
01071
01072
01073 j = 0;
01074 start_r = 0;
01075 for(i=0; i<nobj; i++)
01076 {
01077 if (selobj[i])
01078 {
01079 if (start_r == 0)
01080 {
01081 id1[j] = i;
01082 start_r = 1;
01083 }
01084 continue;
01085 }
01086 else
01087 {
01088 if (start_r)
01089 {
01090 ncomp[j] = i-id1[j];
01091 j++;
01092 start_r = 0;
01093 }
01094 }
01095 }
01096 if (start_r)
01097 {
01098 ncomp[j] = i-id1[j];
01099 start_r = 0;
01100 }
01101 }
01102
01103
01104
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121 void sel::conv2lst(long nit, long nobj, long *selobj)
01122 {
01123 long i, j;
01124
01125 st = sel_list;
01126 n = nit;
01127 id1 = new long[n];
01128 ncomp = NULL;
01129 memset(id1, 0, sizeof(*id1)*n);
01130
01131 j = 0;
01132 for (i=0; i<nobj; i++)
01133 {
01134 if (selobj[i])
01135 {
01136 id1[j]=i;
01137 j++;
01138 }
01139 }
01140 }