/Users/huttone/Devel/sedflux-new/sedflux/trunk/ew/plume/plume_approx.c

Go to the documentation of this file.
00001 #include <glib.h>
00002 
00003 #include "plume_approx.h"
00004 
00005 double plume_establishment_centerline_inv_at( double x , double l )
00006 {
00007    return exp( -l*x );
00008 }
00009 
00010 double plume_established_centerline_inv_at( double x , double l )
00011 {
00012    return   exp( -l*x )
00013           * pow( PLUME_XA/x , PLUME_P1 )
00014           * exp( -(2*l/(3*sqrt(PLUME_XA))*(pow(x,1.5)-pow(PLUME_XA,1.5))*PLUME_F2) );
00015 }
00016 
00017 double plume_establishment_inv_at( double x , double s , double l )
00018 {
00019    return   exp( -l*x );
00020 }
00021 
00022 double plume_plug_inventroy_at( double x , double s , double l )
00023 {
00024    return exp( -l*x );
00025 }
00026 
00027 double plume_established_inv_at( double x , double s , double l )
00028 {
00029    return   exp( -l*x )
00030           * exp( -pow(PLUME_M1*s,2) )
00031           * pow( PLUME_XA/x , PLUME_P1 )
00032           * exp( -(   2*l/(3*sqrt(PLUME_XA))
00033                     * ( pow(x,1.5)-pow(PLUME_XA,1.5) )
00034                     * exp(pow(PLUME_M2*s,2))
00035                     * PLUME_F2 ) );
00036 }
00037 
00038 double plume_inv_far( double x , gpointer data )
00039 {
00040    double l = *(double*)data;
00041    return plume_established_centerline_inv_at( x , l );
00042 }
00043 
00044 double plume_inv_near( double x , gpointer data )
00045 {
00046    double l = *(double*)data;
00047    return plume_establishment_centerline_inv_at( x , l );
00048 }
00049 
00050 double plume_centerline_inv_at( double x , double l )
00051 {
00052    double inv;
00053 
00054    eh_return_val_if_fail( x>=0 , 0. );
00055    eh_require( l>0 );
00056 
00057    if ( x<PLUME_XA )
00058       inv = plume_establishment_centerline_inv_at(x,l);
00059    else
00060       inv = plume_established_centerline_inv_at(x,l);
00061 
00062    return inv;
00063 }
00064 
00065 double* plume_centerline_inv_nd( double* inv , double* x , gssize len , double l )
00066 {
00067    eh_return_val_if_fail( x     , NULL );
00068    eh_return_val_if_fail( len>0 , NULL );
00069 
00070    {
00071       gssize i;
00072 
00073       if ( !inv )
00074          inv = eh_new( double , len );
00075       
00076       for ( i=0 ; i<len ; i++ )
00077          inv[i] = plume_centerline_inv_at( x[i] , l );
00078    }
00079 
00080    return inv;
00081 }
00082 
00083 double* plume_centerline_inv( double* inv , double* x   , gssize len ,
00084                               double  l   , double  i_0 , Sed_hydro r )
00085 {
00086    eh_return_val_if_fail( x     , NULL );
00087    eh_return_val_if_fail( len>0 , NULL );
00088    eh_return_val_if_fail( r     , NULL );
00089    eh_return_val_if_fail( i_0>0 , NULL );
00090 
00091    if ( !inv )
00092       inv = eh_new( double , len );
00093 
00094    {
00095       gssize i;
00096       double b0  = sed_hydro_width   ( r );
00097       double u0  = sed_hydro_velocity( r );
00098 
00099       l *= b0/(u0*S_SECONDS_PER_DAY);
00100 
00101       for ( i=0 ; i<len && x[i]/b0<PLUME_XA ; i++ )
00102          inv[i] = i_0 * plume_establishment_centerline_inv_at( x[i]/b0 , l );
00103 
00104       for ( ; i<len ; i++ )
00105          inv[i] = i_0 * plume_established_centerline_inv_at( x[i]/b0 , l );
00106    }
00107 
00108    return inv;
00109 }
00110 
00111 double plume_inv_nd_helper( double y , gpointer data )
00112 {
00113    double x = ((double*)data)[0];
00114    double l = ((double*)data)[1];
00115    return plume_established_inv_at( x , PLUME_SIGMA*y/x , l );
00116 }
00117 
00118 double plume_width_averaged_inv_at( double x , double dy , double l )
00119 {
00120    double data[3];
00121 
00122    data[0] = x;
00123    data[1] = l;
00124 
00125    return eh_integrate_with_data( plume_inv_nd_helper , 0.01 , dy , data );
00126 }
00127 
00128 double* plume_width_averaged_inv( double* inv , double* x , gssize len ,
00129                                   double  l   , double i_0 , double dy ,
00130                                   Sed_hydro r )
00131 {
00132    if ( !inv )
00133       inv = eh_new( double , len );
00134 
00135    {
00136       gssize i;
00137       double b0 = sed_hydro_width   (r);
00138       double u0 = sed_hydro_velocity(r);
00139 
00140       l *= b0/(u0*S_SECONDS_PER_YEAR);
00141       dy /= b0;
00142 /*
00143       for ( i=0 ; i<len && x[i]/b0<PLUME_XA ; i++ )
00144          inv[i] = i_0 * plume_establishment_width_averaged_inv_at( x[i]/b0 , dy , l );
00145 */
00146       for ( i=0 ; i<len ; i++ )
00147          inv[i] = i_0 * plume_width_averaged_inv_at( x[i]/b0 , dy , l );
00148    }
00149 
00150    return inv;
00151 }
00152 
00153 Sed_cell_grid plume_width_averaged_deposit( Sed_cell_grid g , Sed_hydro r , Sed_sediment s , double dy )
00154 {
00155    double* x;
00156 
00157    eh_return_val_if_fail( g , NULL );
00158    eh_return_val_if_fail( r , NULL );
00159 
00160    // Set up non-dimensional distances
00161    {
00162       gssize len = eh_grid_n_y(g);
00163 
00164       x = g_memdup( eh_grid_y( g ) , sizeof(double)*len );
00165 
00166       eh_dbl_array_mult( x , len , 1./sed_hydro_width(r) );
00167    }
00168 
00169    // Integrate the deposit thickness over the grid
00170    {
00171       gssize i, n;
00172       double i_0, rho, l;
00173       gssize n_grains = sed_sediment_n_types(s);
00174       gssize len      = eh_grid_n_y(g);
00175       double* t       = eh_new0( double , n_grains );
00176       double* dep     = eh_new ( double , len );
00177       double dt       = sed_hydro_duration(r);
00178 
00179       for ( n=1 ; n<n_grains ; n++ )
00180       {
00181          l   = plume_non_dim_lambda( sed_type_lambda ( sed_sediment_type( s , n ) ) , r );
00182          rho = sed_type_rho_sat( sed_sediment_type( s , n ) );
00183          i_0 = sed_hydro_nth_concentration(r,n)*sed_hydro_depth(r);
00184 
00185          plume_width_averaged_deposit_nd( dep , x , len , l );
00186          for ( i=0 ; i<len ; i++ )
00187          {
00188             t[n] = dep[i] * i_0 / rho * dt / dy;
00189             sed_cell_add_amount( sed_cell_grid_val(g,0,i) , t );
00190          }
00191 
00192          eh_dbl_array_mult( t , n_grains , 0. );
00193       }
00194 
00195       eh_free(t);
00196       eh_free(dep);
00197    }
00198 
00199    eh_free( x );
00200 
00201    return g;
00202 }
00203 
00204 double plume_width_averaged_inventory_at_helper( double x , gpointer data )
00205 {
00206    double dy = ((double*)data)[0];
00207    double l  = ((double*)data)[1];
00208    return plume_width_averaged_inv_at( x , dy , l );
00209 }
00210 
00211 double* plume_width_averaged_deposit_nd( double* dep , double* x , gssize len , double l )
00212 {
00213    eh_return_val_if_fail( x     , NULL );
00214    eh_return_val_if_fail( len>0 , NULL );
00215    eh_return_val_if_fail( l>0   , NULL );
00216 
00217    if ( !dep )
00218       dep = eh_new( double , len );
00219 
00220    {
00221       gssize i;
00222       double data[2];
00223 
00224       data[0] = 0.;
00225       data[1] = l;
00226 
00227       for ( i=0 ; i<len ; i++ )
00228          x[i] += PLUME_XA;
00229 
00230       for ( i=1 ; i<len ; i++ )
00231       {
00232          if ( x[i] < PLUME_XA )
00233             data[0] = .5 + (.25-.5/PLUME_XA)*x[i];
00234          else
00235             data[0] = .25*x[i];
00236 
00237          dep[i-1] = eh_integrate_with_data( plume_width_averaged_inventory_at_helper , x[i-1] , x[i] , data )
00238                   / ( x[i] - x[i-1] ) * 2;
00239       }
00240    }
00241 
00242    return dep;
00243 }
00244 
00245 double* plume_centerline_deposit_nd( double* dep , double* x , gssize len , double l )
00246 {
00247    eh_return_val_if_fail( x     , NULL );
00248    eh_return_val_if_fail( len>0 , NULL );
00249    eh_return_val_if_fail( l>0   , NULL );
00250 
00251    if ( !dep )
00252       dep = eh_new( double , len );
00253 
00254    {
00255       gssize i;
00256 
00257       for ( i=1 ; i<len && x[i]<PLUME_XA ; i++ )
00258          dep[i-1] = eh_integrate_with_data( plume_inv_near , x[i-1] , x[i] , &l )
00259                   / ( x[i] - x[i-1] );
00260 
00261       if ( i<len )
00262       {
00263          dep[i-1]  = (   eh_integrate_with_data( plume_inv_near , x[i-1]   , PLUME_XA , &l )
00264                        + eh_integrate_with_data( plume_inv_far  , PLUME_XA , x[i]     , &l ) )
00265                    / ( x[i] - x[i-1] );
00266 
00267          for ( i+=1 ; i<len ; i++ )
00268             dep[i-1] = eh_integrate_with_data( plume_inv_far , x[i-1] , x[i] , &l )
00269                      / ( x[i] - x[i-1] );
00270       }
00271    }
00272 
00273    return dep;
00274 }
00275 
00276 Sed_cell_grid plume_centerline_deposit( Sed_cell_grid g , Sed_hydro r , Sed_sediment s )
00277 {
00278    double* x;
00279 
00280    eh_return_val_if_fail( g , NULL );
00281    eh_return_val_if_fail( r , NULL );
00282 
00283    // Set up non-dimensional distances
00284    {
00285       gssize len = eh_grid_n_y(g);
00286 
00287       x = g_memdup( eh_grid_y( g ) , sizeof(double)*len );
00288 
00289       eh_dbl_array_mult( x , len , 1./sed_hydro_width(r) );
00290 
00291    }
00292 
00293    // Integrate the deposit thickness over the grid
00294    {
00295       gssize i, n;
00296       double i_0, rho, l;
00297       gssize n_grains = sed_sediment_n_types(s);
00298       gssize len      = eh_grid_n_y(g);
00299       double* t       = eh_new0( double , n_grains );
00300       double* dep     = eh_new ( double , len );
00301       double dt       = sed_hydro_duration(r);
00302 
00303       for ( n=1 ; n<n_grains ; n++ )
00304       {
00305          l   = plume_non_dim_lambda( sed_type_lambda ( sed_sediment_type( s , n ) ) , r );
00306          rho = sed_type_rho_sat( sed_sediment_type( s , n ) );
00307          i_0 = sed_hydro_nth_concentration(r,n)*sed_hydro_depth(r);
00308 
00309          plume_centerline_deposit_nd( dep , x , len , l );
00310          for ( i=0 ; i<len ; i++ )
00311          {
00312             t[n] = dep[i] * i_0 / rho * dt;
00313             sed_cell_add_amount( sed_cell_grid_val(g,0,i) , t );
00314          }
00315 
00316          eh_dbl_array_mult( t , n_grains , 0. );
00317       }
00318 
00319       eh_free(t);
00320       eh_free(dep);
00321    }
00322 
00323    eh_free( x );
00324 
00325    return g;
00326 }
00327 
00328 double* plume_inv_nd( double* dep , double* x , double* s ,  gssize len , double l )
00329 {
00330    eh_return_val_if_fail( x     , NULL );
00331    eh_return_val_if_fail( len>0 , NULL );
00332    eh_return_val_if_fail( l>0   , NULL );
00333 
00334    if ( !dep )
00335       dep = eh_new( double , len );
00336 
00337    {
00338       gssize i;
00339 
00340       for ( i=1 ; i<len && x[i]<PLUME_XA ; i++ )
00341          dep[i-1] = eh_integrate_with_data( plume_inv_near , x[i-1] , x[i] , &l )
00342                   / ( x[i] - x[i-1] );
00343 
00344       if ( i<len )
00345       {
00346          dep[i-1]  = (   eh_integrate_with_data( plume_inv_near , x[i-1]   , PLUME_XA , &l )
00347                        + eh_integrate_with_data( plume_inv_far  , PLUME_XA , x[i]     , &l ) )
00348                    / ( x[i] - x[i-1] );
00349 
00350          for ( i+=1 ; i<len ; i++ )
00351             dep[i-1] = eh_integrate_with_data( plume_inv_far , x[i-1] , x[i] , &l )
00352                      / ( x[i] - x[i-1] );
00353       }
00354    }
00355 
00356    return dep;
00357 }
00358 
00359 double* plume_inv( double* inv , double* x   , double* y , gssize len ,
00360                    double  l   , double  i_0 , Sed_hydro r )
00361 {
00362    eh_return_val_if_fail( x     , NULL );
00363    eh_return_val_if_fail( y     , NULL );
00364    eh_return_val_if_fail( len>0 , NULL );
00365    eh_return_val_if_fail( r     , NULL );
00366    eh_return_val_if_fail( i_0>0 , NULL );
00367 
00368    if ( !inv )
00369       inv = eh_new( double , len );
00370 
00371    {
00372       gssize i;
00373       double b0  = sed_hydro_width   ( r );
00374       double u0  = sed_hydro_velocity( r );
00375 
00376       l *= b0/(u0*S_SECONDS_PER_DAY);
00377 
00378       for ( i=0 ; i<len && x[i]/b0<PLUME_XA ; i++ )
00379       {
00380          if ( x[i]<PLUME_XA*b0 )
00381             inv[i] = i_0 * plume_establishment_inv_at( x[i]/b0 , PLUME_SIGMA*y[i]/x[i] , l );
00382          else
00383             inv[i] = i_0 * plume_established_inv_at  ( x[i]/b0 , PLUME_SIGMA*y[i]/x[i] , l );
00384       }
00385    }
00386 
00387    return inv;
00388 }
00389 
00390 double plume_non_dim_distance( double x , Sed_hydro r )
00391 {
00392    return x/sed_hydro_width(r);
00393 }
00394 
00395 double plume_non_dim_lambda( double l , Sed_hydro r )
00396 {
00397    return l/S_SECONDS_PER_DAY*sed_hydro_width(r)/sed_hydro_velocity(r);
00398 }
00399 
00400 double plume_v_bar_established( double x , double y )
00401 {
00402    double s = PLUME_SIGMA*y/x;
00403    return sqrt(PLUME_XA/x)/PLUME_SIGMA*( s*exp( -pow(s,2.) ) - .25*EH_SQRT_PI*erf( s ) );
00404 }
00405 
00406 double plume_v_bar_establishment( double x , double y )
00407 {
00408    double w = PLUME_SIGMA/x*( y - .5*(1.-x/PLUME_XA) );
00409 //   return plume_v_bar_established(x,y);
00410    return exp( -pow(w,2) ) * ( w/PLUME_SIGMA - .5/PLUME_XA ) + .5/PLUME_XA*(1-G_SQRT2*erf(w));
00411 }
00412 
00413 double plume_v_bar_plug( double x , double y )
00414 {
00415 //   return plume_v_bar_established(x,y);
00416    return 0.;
00417 }
00418 
00419 double plume_u_bar_plug( double x , double y )
00420 {
00421    return 1.;
00422 }
00423 
00424 double plume_u_bar_establishment( double x , double y )
00425 {
00426    if ( eh_compare_dbl( x , 0. , 1e-12 ) )
00427       return 0;
00428    else
00429    {
00430       double w = PLUME_SIGMA/x*( y - .5*(1.-x/PLUME_XA) );
00431       return exp( - pow( w , 2 ) );
00432    }
00433 }
00434 
00435 double plume_u_bar_established( double x , double y )
00436 {
00437    return sqrt( PLUME_XA/x ) * exp( -pow( PLUME_SIGMA*y/x , 2 ) );
00438 }
00439 
00440 double plume_k_bar_established( double x , double y )
00441 {
00442    double s = PLUME_SIGMA*y/x;
00443    double temp;
00444    if ( eh_compare_dbl( s , 0. , 1e-12 ) )
00445       temp = 2/EH_SQRT_PI;
00446    else
00447       temp = erf(s)/s;
00448    return ( .5/pow(PLUME_SIGMA,2)*sqrt(PLUME_XA/x)*x ) * ( .25 / EH_SQRT_PI ) * temp;
00449 }
00450 
00451 double plume_k_bar_plug( double x , double y )
00452 {
00453    return 0.;
00454 }
00455 
00456 double plume_k_bar_establishment( double x , double y )
00457 {
00458    return plume_k_bar_established( x,y );
00459 }
00460 
00461 double plume_k_bar_dy_plug( double x , double y )
00462 {
00463    return 0.;
00464 }
00465 
00466 double plume_k_bar_dy_established( double x , double y )
00467 {
00468    double s = PLUME_SIGMA*y/x;
00469    double temp;
00470    if ( eh_compare_dbl( s , 0. , 1e-12 ) )
00471       temp = 0.;
00472    else
00473       temp = ( 2.*s/EH_SQRT_PI*exp(-pow(s,2.)) - erf(s) ) / (s*s);
00474    return   ( .5/PLUME_SIGMA*sqrt(PLUME_XA/x) ) * ( .25 / EH_SQRT_PI )
00475           * temp;
00476 }
00477 
00478 double plume_k_bar_dy_establishment( double x , double y )
00479 {
00480    return plume_k_bar_dy_established( x,y );
00481 }
00482 
00483 double* plume_u_bar_at_x( double x , double dy , gssize* n_y )
00484 {
00485    double* u;
00486 
00487    eh_require( n_y );
00488 
00489    eh_return_val_if_fail( x>=0 , NULL );
00490    eh_return_val_if_fail( dy>0 , NULL );
00491 
00492    {
00493       gssize i;
00494       double y_max = plume_half_width( x );
00495       double* y = eh_uniform_array( 0 , y_max , dy , n_y );
00496       gssize len = *n_y;
00497 
00498       u = eh_new( double , len );
00499 
00500       if ( x<=PLUME_XA )
00501       {
00502          double y_plug          = plume_plug_width         ( x );
00503          double y_establishment = plume_establishment_width( x );
00504 
00505          eh_require( y_max>=y_plug );
00506          eh_require( y_max>=y_establishment );
00507 
00508          for ( i=0 ; i<len && y[i]<=y_plug ; i++ )
00509             u[i] = plume_u_bar_plug         ( x , y[i] );
00510 
00511          for (     ; i<len && y[i]<=y_establishment ; i++ )
00512             u[i] = plume_u_bar_establishment( x , y[i] );
00513       }
00514       else
00515       {
00516          double y_established = plume_established_width( x );
00517       
00518          eh_require( y_max>=y_established );
00519 
00520          for ( i=0 ; i<len && y[i]<=y_established   ; i++ )
00521             u[i] = plume_u_bar_established( x , y[i] );
00522       }
00523 
00524       eh_free( y );
00525    }
00526       
00527    return u;
00528 }
00529 
00530 double* plume_v_bar_at_x( double x , double dy , gssize* n_y )
00531 {
00532    double* v;
00533 
00534    eh_require( n_y );
00535 
00536    eh_return_val_if_fail( x>=0 , NULL );
00537    eh_return_val_if_fail( dy>0 , NULL );
00538 
00539    {
00540       gssize i;
00541       double y_max = plume_half_width( x );
00542       double* y = eh_uniform_array( 0 , y_max , dy , n_y );
00543       gssize len = *n_y;
00544 
00545       v = eh_new( double , len );
00546 
00547       if ( x<=PLUME_XA )
00548       {
00549          double y_plug          = plume_plug_width         ( x );
00550          double y_establishment = plume_establishment_width( x );
00551 
00552          eh_require( y_max>=y_plug );
00553          eh_require( y_max>=y_establishment );
00554 
00555          for ( i=0 ; i<len && y[i]<=y_plug ; i++ )
00556             v[i] = plume_v_bar_plug         ( x , y[i] );
00557 
00558          for (     ; i<len && y[i]<=y_establishment ; i++ )
00559             v[i] = plume_v_bar_establishment( x , y[i] );
00560       }
00561       else
00562       {
00563          double y_established = plume_established_width( x );
00564 
00565          eh_require( y_max>=y_established );
00566 
00567          for ( i=0 ; i<len && y[i]<=y_established   ; i++ )
00568             v[i] = plume_v_bar_established( x , y[i] );
00569       }
00570 
00571       eh_free( y );
00572    }
00573       
00574    return v;
00575 }
00576 
00577 double* plume_k_bar_at_x( double x , double dy , gssize* n_y )
00578 {
00579    double* k;
00580 
00581    eh_require( n_y );
00582 
00583    eh_return_val_if_fail( x>=0 , NULL );
00584    eh_return_val_if_fail( dy>0 , NULL );
00585 
00586    {
00587       gssize i;
00588       double y_max = plume_half_width         ( x );
00589       double* y = eh_uniform_array( 0 , y_max , dy , n_y );
00590       gssize len = *n_y;
00591 
00592       k = eh_new( double , len );
00593 
00594       if ( x<=PLUME_XA )
00595       {
00596          double y_plug          = plume_plug_width         ( x );
00597          double y_establishment = plume_establishment_width( x );
00598 
00599          eh_require( y_max>=y_plug );
00600          eh_require( y_max>=y_establishment );
00601 
00602          for ( i=0 ; i<len && y[i]<=y_plug ; i++ )
00603             k[i] = plume_k_bar_plug         ( x , y[i] );
00604 
00605          for (     ; i<len && y[i]<=y_establishment ; i++ )
00606             k[i] = plume_k_bar_establishment( x , y[i] );
00607       }
00608       else
00609       {
00610          double y_established = plume_established_width( x );
00611 
00612          eh_require( y_max>=y_established );
00613 
00614          for ( i=0 ; i<len && y[i]<=y_established   ; i++ )
00615             k[i] = plume_k_bar_established( x , y[i] );
00616       }
00617 
00618       eh_free( y );
00619    }
00620       
00621    return k;
00622 }
00623 
00624 double* plume_k_bar_dy_at_x( double x , double dy , gssize* n_y )
00625 {
00626    double* k;
00627 
00628    eh_require( n_y );
00629 
00630    eh_return_val_if_fail( x>=0 , NULL );
00631    eh_return_val_if_fail( dy>0 , NULL );
00632 
00633    {
00634       gssize i;
00635       double y_max = plume_half_width( x );
00636       double* y = eh_uniform_array( 0 , y_max , dy , n_y );
00637       gssize len = *n_y;
00638 
00639       k = eh_new( double , len );
00640 
00641       if ( x<=PLUME_XA )
00642       {
00643          double y_plug          = plume_plug_width         ( x );
00644          double y_establishment = plume_establishment_width( x );
00645 
00646          eh_require( y_max>=y_plug );
00647          eh_require( y_max>=y_establishment );
00648 
00649          for ( i=0 ; i<len && y[i]<=y_plug ; i++ )
00650             k[i] = plume_k_bar_dy_plug         ( x , y[i] );
00651 
00652          for (     ; i<len && y[i]<=y_establishment ; i++ )
00653             k[i] = plume_k_bar_dy_establishment( x , y[i] );
00654       }
00655       else
00656       {
00657          double y_established = plume_established_width( x );
00658 
00659          eh_require( y_max>=y_established );
00660 
00661          for ( i=0 ; i<len && y[i]<=y_established   ; i++ )
00662             k[i] = plume_k_bar_dy_established  ( x , y[i] );
00663       }
00664 
00665       eh_free( y );
00666    }
00667       
00668    return k;
00669 }
00670 
00671 double** plume_i_bar( double* x , gssize n_x , double l , gssize* n_y , double dy )
00672 {
00673    double** i_bar;
00674 
00675    eh_return_val_if_fail( x     , NULL );
00676    eh_return_val_if_fail( n_x>0 , NULL );
00677    eh_require( l>0 );
00678    eh_require( n_y );
00679 
00680    {
00681       double y_max = plume_half_width( x[n_x-1] );
00682       gssize len = y_max / dy + 1;
00683 
00684       i_bar = eh_new_2( double , n_x , len );
00685 
00686       *n_y = len;
00687    }
00688 
00689    {
00690       gssize j;
00691       double y_max = plume_half_width( x[0] );
00692       gssize len = y_max / dy;
00693 
00694       for ( j=0 ; j<len ; j++ )
00695          i_bar[0][j] = 1;
00696    }
00697 
00698    {
00699       gssize i;
00700       gssize len;
00701       double* i_bar_at_x;
00702 
00703       for ( i=1 ; i<n_x ; i++ )
00704       {
00705          i_bar_at_x = plume_i_bar_at_x( x[i] , x[i]-x[i-1] , dy , &len , l , i_bar[i-1] );
00706 
00707          eh_require( len<=(*n_y) );
00708 
00709          g_memmove( i_bar[i] , i_bar_at_x , sizeof(double)*len );
00710 
00711          eh_free( i_bar_at_x );
00712       }
00713 /*
00714       // Estimate how much is lost.
00715       x_end = x[len-1];
00716       do
00717       {
00718          i_bar_at_x = plume_i_bar_at_x( x_end , .5 , dy , &len , l , i_bar_last[i-1] );
00719 
00720          i_bar_sum = eh_dbl_array_sum( i_bar_at_x , len );
00721          i_bar_lost += i_bar_sum;
00722 
00723          eh_free( i_bar_at_x );
00724       }
00725       while ( i_bar_sum>.01 );
00726 */
00727    }
00728 
00729    return i_bar;
00730 }
00731 /*
00732 double plume_i_bar_total( double* i_bar_0 , gssize len , double x_0 , double x_1 , double y_0 , double y_1 , double l )
00733 {
00734    double** i_bar;
00735 
00736    {
00737       gssize i;
00738       double y_max = plume_half_width( x_1 );
00739       gssize len = y_max / dy + 1;
00740 
00741       i_bar = eh_new_2( double , n_x , len );
00742 
00743       *n_y = len;
00744    }
00745 
00746    {
00747       gssize j;
00748       double y_max = plume_half_width( x[0] );
00749       gssize len = y_max / dy;
00750 
00751       for ( j=0 ; j<len ; j++ )
00752          i_bar[0][j] = 1;
00753    }
00754 
00755    {
00756       gssize i;
00757       gssize len;
00758       double* i_bar_at_x;
00759 
00760       for ( i=1 ; i<n_x ; i++ )
00761       {
00762          i_bar_at_x = plume_i_bar_at_x( x[i] , x[i]-x[i-1] , dy , &len , l , i_bar[i-1] );
00763 
00764          eh_require( len<=(*n_y) );
00765 
00766          g_memmove( i_bar[i] , i_bar_at_x , sizeof(double)*len );
00767 
00768          eh_free( i_bar_at_x );
00769       }
00770 
00771       // Estimate how much is lost.
00772       x_end = x[len-1];
00773       do
00774       {
00775          i_bar_at_x = plume_i_bar_at_x( x_end , .5 , dy , &len , l , i_bar_last[i-1] );
00776 
00777          i_bar_sum = eh_dbl_array_sum( i_bar_at_x , len );
00778          i_bar_lost += i_bar_sum;
00779 
00780          eh_free( i_bar_at_x );
00781       }
00782       while ( i_bar_sum>.01 );
00783 
00784    }
00785 
00786    return i_bar;
00787 }
00788 */
00789 
00790 double* plume_i_bar_at_x( double x , double dx , double dy , gssize* n_y , double l , double* i_bar_last )
00791 {
00792    double* i_bar = NULL;
00793 
00794    {
00795       gssize j;
00796       double* u     = plume_u_bar_at_x( x , dy , n_y );
00797       double* v     = plume_v_bar_at_x( x , dy , n_y );
00798       double* k     = plume_k_bar_at_x( x , dy , n_y );
00799       double* dk_dy = plume_k_bar_dy_at_x( x , dy , n_y );
00800       double* sub   = eh_new( double , *n_y );
00801       double* d     = eh_new( double , *n_y );
00802       double* sup   = eh_new( double , *n_y );
00803       double* b     = eh_new( double , *n_y );
00804 
00805       i_bar = eh_new( double , *n_y );
00806 
00807       if ( x<PLUME_XA )
00808       {
00809          double y_plug = plume_plug_width(x);
00810          gssize len = y_plug / dy;
00811 
00812 //         if ( len>=(*n_y) )
00813 //            len = *n_y-1;
00814 
00815          for ( j=0 ; j<len ; j++ )
00816             i_bar[j] = exp( -l*x );
00817 
00818          if ( len<(*n_y-2) && *n_y>len )
00819          {
00820             for (    ; j<(*n_y)-1 ; j++ )
00821             {
00822                sub[j] = - ( v[j] - dk_dy[j] )/(2*dy) - k[j]/(dy*dy);
00823                sup[j] =   ( v[j] - dk_dy[j] )/(2*dy) - k[j]/(dy*dy);
00824                d[j]   =  u[j]/dx + l + 2*k[j]/(dy*dy);
00825                b[j]   = i_bar_last[j]*u[j]/dx;
00826             }
00827 
00828             // BC at plug boundary.
00829             b[len] = i_bar_last[len]*u[len]/dx
00830                    - i_bar[len-1]*( -(v[len-1] - dk_dy[len-1]) / (2*dy) - k[len-1]/(dy*dy) );
00831 
00832             // BC at plume edge.
00833             j = *n_y - 2;
00834             sup[j] = 0.;
00835 
00836             tridiag( sub+len , d+len , sup+len , b+len , i_bar+len , *n_y-1-len );
00837          }
00838       }
00839       else
00840       {
00841 
00842          for ( j=1 ; j<(*n_y)-1 ; j++ )
00843          {
00844             sub[j] = - ( v[j] - dk_dy[j] )/(2*dy) - k[j]/(dy*dy);
00845             sup[j] =   ( v[j] - dk_dy[j] )/(2*dy) - k[j]/(dy*dy);
00846             d[j]   =  u[j]/dx + l + 2*k[j]/(dy*dy);
00847             b[j]   = i_bar_last[j]*u[j]/dx;
00848          }
00849 
00850          // boundary condition at j=0.  Iy = 0 ( I_1 = I_-1 )
00851          // u_1     = u_-1
00852          // v_1     = - v_-1
00853          // k_1     = k_-1
00854          // dk_dy_1 = -dk_dy_-1
00855          d[0]   = u[0]/dx + l + 2*k[0]/(dy*dy);
00856          sup[0] = ( v[1] - dk_dy[1] )/dy - 2.*k[1]/(dy*dy);
00857          b[0]   = i_bar_last[0]*u[0]/dx;
00858 
00859          // boundary condition at j=N.  I(y=y_c) = 0
00860          j = *n_y - 1;
00861          sub[j] = 0.;
00862          d[j]   = 1.;
00863          b[j]   = i_bar_last[j]*u[j]/dx;
00864 
00865          j = *n_y - 2;
00866          sup[j] = 0.;
00867 
00868          tridiag( sub , d , sup , b , i_bar , *n_y-1 );
00869       }
00870 //      g_memmove( i_bar , dk_dy , sizeof(double)*(*n_y) );
00871 
00872       eh_free( b     );
00873       eh_free( sup   );
00874       eh_free( d     );
00875       eh_free( sub   );
00876       eh_free( dk_dy );
00877       eh_free( k     );
00878       eh_free( v     );
00879       eh_free( u     );
00880    }
00881 
00882    return i_bar;
00883 }
00884 
00885 double plume_half_width( double x )
00886 {
00887    double w;
00888 
00889    eh_require( x>=0 );
00890 
00891    if ( x < PLUME_XA )
00892       w = plume_establishment_width(x);
00893    else
00894       w = plume_established_width(x);
00895 
00896    return w;
00897 }
00898 
00899 double plume_established_width( double x )
00900 {
00901    double w=0;
00902 
00903    eh_return_val_if_fail( x>=PLUME_XA , 0 );
00904 
00905    w = .25*x;
00906 //   return plume_establishment_width(x);
00907 //   w = .25*x + .5;
00908    return w;
00909 }
00910 
00911 double plume_establishment_width( double x )
00912 {
00913    double w=0;
00914 
00915    eh_return_val_if_fail( x>=0        , 0 );
00916    eh_return_val_if_fail( x<=PLUME_XA , 0 );
00917 
00918    w = .5 + ( .25-.5/PLUME_XA)*x;
00919 
00920 //   w = .25*x + .5;
00921    return w;
00922 }
00923 
00924 double plume_plug_width( double x )
00925 {
00926    double w=0;
00927 
00928    eh_return_val_if_fail( x>=0        , 0 );
00929    eh_return_val_if_fail( x<=PLUME_XA , 0 );
00930 
00931    w = .5 - .5/PLUME_XA*x;
00932 
00933    return w;
00934 }
00935 
00936 Sed_cell_grid plume_width_averaged_deposit_num( Sed_cell_grid g , Sed_hydro r , Sed_sediment s , double dy )
00937 {
00938    double* x;
00939 
00940    eh_return_val_if_fail( g , NULL );
00941    eh_return_val_if_fail( r , NULL );
00942 
00943    // Set up non-dimensional distances
00944    {
00945       gssize len = eh_grid_n_y(g);
00946 
00947       x = g_memdup( eh_grid_y( g ) , sizeof(double)*len );
00948 
00949       eh_dbl_array_mult( x , len , 1./sed_hydro_width(r) );
00950    }
00951 
00952    // Integrate the deposit thickness over the grid
00953    {
00954       gssize i, n;
00955       double i_0, rho, l;
00956       gssize n_grains = sed_sediment_n_types(s);
00957       gssize len      = eh_grid_n_y(g);
00958       double* t       = eh_new0( double , n_grains );
00959       double* dep     = eh_new ( double , len );
00960       double dt       = sed_hydro_duration(r);
00961 
00962       for ( n=1 ; n<n_grains ; n++ )
00963       {
00964          l   = plume_non_dim_lambda( sed_type_lambda ( sed_sediment_type( s , n ) ) , r );
00965          rho = sed_type_rho_sat( sed_sediment_type( s , n ) );
00966          i_0 = sed_hydro_nth_concentration(r,n-1)*sed_hydro_depth(r);
00967 
00968          plume_width_averaged_deposit_nd_num( dep , x , len , l );
00969          for ( i=0 ; i<len-1 ; i++ )
00970          {
00971 //            t[n] = dep[i] * i_0 * pow(sed_hydro_width(r),2) / (dy*sed_hydro_width(r)*(x[i+1]-x[i])*rho)*sed_type_lambda( sed_sediment_type(s,n) );
00972             t[n] = dep[i] * i_0 / (rho*dy) * sed_type_lambda( sed_sediment_type(s,n) ) * sed_hydro_width(r)*dt;
00973 //            t[n] = dep[i] * i_0 / rho * dt / dy;
00974 //            t[n] = dep[i] / pow(sed_hydro_width(r),2) / rho * dt;
00975             sed_cell_add_amount( sed_cell_grid_val(g,0,i) , t );
00976          }
00977 
00978          t[n] = 0;
00979       }
00980 
00981       eh_free(t);
00982       eh_free(dep);
00983    }
00984 
00985    eh_free( x );
00986 
00987    return g;
00988 }
00989 
00990 double* plume_width_averaged_deposit_nd_num( double* dep , double* x , gssize len , double l )
00991 {
00992    eh_return_val_if_fail( x     , NULL );
00993    eh_return_val_if_fail( len>0 , NULL );
00994    eh_return_val_if_fail( l>0   , NULL );
00995 
00996    if ( !dep )
00997       dep = eh_new( double , len );
00998 
00999    {
01000       gssize i, j;
01001       gssize n_y;
01002       double** i_bar = plume_i_bar( x , len , l , &n_y , .01 );
01003 
01004       for ( i=0 ; i<len-1 ; i++ )
01005       {
01006          dep[i] = i_bar[i][0];
01007          for ( j=1 ; j<n_y ; j++ )
01008             dep[i] += 2.*i_bar[i][j];
01009 //         dep[i] *= .04*(x[i+1]-x[i])*2.;
01010          dep[i] *= .01;
01011       }
01012 
01013       eh_free( i_bar[0] );
01014       eh_free( i_bar );
01015    }
01016 
01017    return dep;
01018 }
01019 
01020 /*
01021 Eh_dbl_grid plume_u_bar_grid( gssize n_x , gssize n_y , double dx , double dy )
01022 {
01023    Eh_dbl_grid u = eh_grid_new_uniform( double , n_x , n_y , dx , dy );
01024 
01025    for ( i=0 ; i<n_x ; i++ )
01026       for ( j=0 ; j<n_y ; j++ )
01027          plume_u_bar( eh_grid_x(u)[i] , eh_grid_y(u)[j] );
01028 
01029    return u;
01030 }
01031 
01032 double plume_residual( double** inv , gssize n_x , gssize n_y , double l , double dx , double dy )
01033 {
01034     Eh_dbl_grid r = eh_dbl_grid_new( n_x , n_y );
01035 
01036    {
01037       gssize i, j;
01038       Eh_dbl_grid u   = plume_u_bar_grid   ( n_x , n_y , dx , dy );
01039       Eh_dbl_grid v   = plume_v_bar_grid   ( n_x , n_y , dx , dy );
01040       Eh_dbl_grid k   = plume_k_bar_grid   ( n_x , n_y , dx , dy );
01041       Eh_dbl_grid k_y = plume_k_bar_dy_grid( n_x , n_y , dx , dy );
01042       Eh_dbl_grid inv_x  = eh_dbl_grid_diff( inv , 1 , 2 );
01043       Eh_dbl_grid inv_y  = eh_dbl_grid_diff( inv , 1 , 1 );
01044       Eh_dbl_grid inv_yy = eh_dbl_grid_diff( inv , 2 , 1 );
01045       
01046 
01047       for ( i=0 ; i<n_x ; i++ )
01048          for ( j=0 ; j<n_x ; j++ )
01049             r[i][j] = u[i][j]*inv_x[i][j]
01050                     + v[i][j]*inv_y[i][j]
01051                     + k*inv[i][j]
01052                     - k[i][j]*inv_yy[i][j]
01053                     - k_y[i][j]*inv_y[i][j];
01054 
01055       eh_grid_destroy( inv_x  );
01056       eh_grid_destroy( inv_y  );
01057       eh_grid_destroy( inv_yy );
01058       eh_grid_destroy( u   );
01059       eh_grid_destroy( u   );
01060       eh_grid_destroy( v   );
01061       eh_grid_destroy( k   );
01062       eh_grid_destroy( k_y );
01063    }
01064 
01065 }
01066 */
01067 

Generated on Fri Jan 4 18:04:15 2008 for sedflux by  doxygen 1.5.2