00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070 #include "plumeinput.h"
00071 #include "plumevars.h"
00072 #include <stdlib.h>
00073 #include <utils/utils.h>
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095 int plumearray( Plume_grid *grid , Plume_enviro *env , Plume_options *opt )
00096 {
00097 static int reuse_count = 0;
00098 static int new_count = 0;
00099 int ii, jj, kk, l1, endi;
00100 int x_size, y_size;
00101 double aa, AA, avo, mxcs, mnlm, Li, nv, tst, xend, yend, zend;
00102 double *dcl, *xcl, *ycl;
00103 int n_grains = env->n_grains;
00104 Plume_river *river = env->river;
00105 Plume_ocean *ocean = env->ocean;
00106 Plume_sediment *sedload = env->sed;
00107
00108 grid->xmin = 0;
00109
00110
00111 mxcs = river->Cs[0];
00112 mnlm = sedload[0].lambda;
00113 for( ii=0; ii<n_grains; ii++ )
00114 {
00115 mxcs = mx( mxcs, river->Cs[ii]);
00116 mnlm = mn( mnlm, sedload[ii].lambda);
00117 }
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128 zend = 1.2*pow((-(river->u0/mnlm)*sqrt(river->b0/(sqpi*C1))*log(pcrit) ),(2.0/3.0));
00129
00130
00131
00132
00133
00134 if ( zend > grid->max_len && grid->max_len != 0 )
00135 zend = grid->max_len;
00136
00137 if ( !(opt->fjrd || opt->strt) )
00138 Li = river->u0/(2*omega*sin(env->lat*degTOr));
00139
00140
00141
00142
00143 if ( opt->fjrd || opt->strt )
00144 grid->xmax = rnd(1.1*zend);
00145
00146
00147
00148
00149 else if( opt->kwf == 1 )
00150 {
00151 grid->xmax = rnd(Li);
00152 if( ocean->vo > 0 )
00153 {
00154 grid->ymin = floor(-2*river->b0);
00155 grid->ymax = ceil(zend);
00156 }
00157 else
00158 {
00159 grid->ymin = floor(-zend);
00160 grid->ymax = ceil(2*river->b0);
00161 }
00162 }
00163
00164
00165
00166
00167 else
00168 {
00169
00170
00171 avo = fabs(ocean->vo);
00172 aa = river->u0/avo;
00173 nv = 0.37;
00174 AA = 1.53 + 0.90*aa;
00175
00176
00177 l1 = (int)rnd(1.1*zend/grid->dy);
00178 if( (xcl = (double *) calloc(l1,sizeof(double))) == NULL ||
00179 (ycl = (double *) calloc(l1,sizeof(double))) == NULL ||
00180 (dcl = (double *) calloc(l1,sizeof(double))) == NULL )
00181 {
00182 fprintf(stderr," PlumeArray ERROR: memory allocation failed \n");
00183 fprintf(stderr," failed on xcl, ycl, dcl \n");
00184 return 1;
00185 }
00186
00187
00188 xcl[0] = ycl[0] = dcl[0] = 0.0;
00189 for ( jj = 1; jj<l1; jj++ )
00190 {
00191 ycl[jj] = grid->dy*(jj-1);
00192 xcl[jj] = river->b0*AA*pow((ycl[jj]/river->b0),nv);
00193 dcl[jj] = dcl[jj-1]
00194 + sqrt(pow((ycl[jj]-ycl[jj-1]),2)+pow((xcl[jj]-xcl[jj-1]),2));
00195 }
00196
00197
00198
00199 endi = 0;
00200 tst = fabs(dcl[0]-zend);
00201 for( jj=1; jj<l1; jj++ )
00202 {
00203 if( fabs(dcl[jj]-zend) < tst )
00204 {
00205 endi = jj;
00206 tst = fabs(dcl[jj]-zend);
00207 }
00208 }
00209 xend = xcl[endi]; yend = ycl[endi];
00210
00211
00212 free(xcl);
00213 free(ycl);
00214 free(dcl);
00215
00216
00217
00218
00219
00220 if( yend > 1.5*xend )
00221 {
00222 grid->xmax = rnd(xend+Li);
00223 if( ocean->vo > 0 )
00224 {
00225 grid->ymin = rnd(-4*river->b0);
00226 grid->ymax = rnd(yend);
00227 }
00228 else
00229 {
00230 grid->ymin = rnd(-yend);
00231 grid->ymax = rnd(4*river->b0);
00232 }
00233 }
00234
00235
00236
00237
00238
00239 else if( xend > 1.5*yend )
00240 {
00241 grid->xmax = rnd(xend);
00242 if ( ocean->vo > 0 )
00243 {
00244 grid->ymin = rnd(-Li);
00245 grid->ymax = rnd(yend);
00246 }
00247 else
00248 {
00249 grid->ymin = rnd(-yend);
00250 grid->ymax = rnd(Li);
00251 }
00252 }
00253
00254
00255
00256
00257
00258 else
00259 {
00260 grid->xmax = xend;
00261 if ( ocean->vo > 0 )
00262 {
00263 grid->ymin = rnd(-Li);
00264 grid->ymax = rnd(yend);
00265 }
00266 else
00267 {
00268 grid->ymin = rnd(-yend);
00269 grid->ymax = rnd(Li);
00270 }
00271 }
00272 }
00273
00274
00275
00276
00277
00278 grid->ymin = rnd(floor(grid->ymin/(int)(grid->dy))*(int)(grid->dy));
00279 grid->lx = (int)(((grid->xmax-grid->xmin)/(int)(grid->dx))+2);
00280 grid->ly = (int)(((grid->ymax-grid->ymin)/(int)(grid->dy))+2);
00281 grid->lz = n_grains;
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298 grid->xmax = grid->xmin + (grid->lx-1)*grid->dx;
00299
00300 grid->ymax = grid->ymin + (grid->ly-1)*grid->dy;
00301 grid->zx = 0;
00302 grid->zy = (int)((grid->ly - grid->ymax/(int)(grid->dy))-1);
00303 grid->lpc = (int)(2.4*(grid->lx+grid->ly));
00304
00305
00306 grid->lpc *= 10;
00307
00308 if ( grid->lx>grid->x_len || grid->ly>grid->y_len || TRUE )
00309 {
00310
00311 new_count++;
00312
00313 if ( grid->x_len!=0 || grid->y_len!=0 )
00314 {
00315 eh_free( grid->xval );
00316 eh_free( grid->yval );
00317
00318 free_d3tensor( grid->ccnc );
00319 free_d3tensor( grid->ncnc );
00320 free_d3tensor( grid->deps );
00321 free_d3tensor( grid->dist );
00322 free_dmatrix ( grid->ualb );
00323 free_dmatrix ( grid->pcent );
00324 }
00325
00326 if ( grid->lx>grid->x_len )
00327 grid->x_len = grid->lx;
00328 if ( grid->ly>grid->y_len )
00329 grid->y_len = grid->ly;
00330
00331 grid->xval = eh_new( double , grid->lx );
00332 grid->yval = eh_new( double , grid->ly );
00333
00334 for ( ii = 0 ; ii<grid->lx ; ii++ )
00335 grid->xval[ii] = grid->xmin+ii*grid->dx;
00336 for ( ii = 0 ; ii<grid->ly ; ii++ )
00337 grid->yval[ii] = grid->ymin+ii*grid->dy;
00338
00339 y_size = grid->ly;
00340 if ( y_size<grid->y_len )
00341 y_size = grid->y_len;
00342 x_size = grid->lx;
00343 if ( x_size<grid->x_len )
00344 x_size = grid->x_len;
00345
00346
00347
00348
00349
00350
00351
00352
00353 grid->ccnc = new_d3tensor(x_size,y_size,n_grains);
00354 grid->ncnc = new_d3tensor(x_size,y_size,n_grains);
00355 grid->deps = new_d3tensor(x_size,y_size,n_grains);
00356 grid->dist = new_d3tensor(x_size,y_size,5);
00357 grid->ualb = new_dmatrix(x_size,y_size);
00358 grid->pcent = new_dmatrix(grid->lpc,4);
00359
00360 if( opt->o1 )
00361 {
00362
00363 grid->sln = new_dmatrix(x_size,y_size);
00364 }
00365 }
00366 else
00367 {
00368 reuse_count++;
00369 }
00370
00371 for ( ii=0 ; ii<grid->x_len ; ii++ )
00372 for ( jj=0 ; jj<grid->y_len ; jj++ )
00373 {
00374 for ( kk=0 ; kk<n_grains ; kk++ )
00375 {
00376 grid->ccnc[ii][jj][kk] = 0.;
00377 grid->ncnc[ii][jj][kk] = 0.;
00378 grid->deps[ii][jj][kk] = 0.;
00379 }
00380 for ( kk=0 ; kk<5 ; kk++ )
00381 grid->dist[ii][jj][kk] = 0.;
00382 grid->ualb[ii][jj] = 0.;
00383 }
00384 for ( ii=0 ; ii<grid->lpc ; ii++ )
00385 for ( jj=0 ; jj<4 ; jj++ )
00386 grid->pcent[ii][jj] = 0.;
00387
00388 return 0;
00389
00390 }
00391