00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include <stdio.h>
00022 #include <glib.h>
00023
00024 #include "utils/utils.h"
00025
00026 #include "sed_sediment.h"
00027
00028 CLASS ( Sed_type )
00029 {
00030 double rho_sat;
00031 double rho_grain;
00032 double gz;
00033 double pi;
00034 double void_min;
00035 double diff_coef;
00036 double lambda;
00037 double c_v;
00038 double c;
00039
00040 double w_s;
00041 double rho_max;
00042 double gz_in_m;
00043 double gz_in_phi;
00044 Sed_size_class class;
00045 double viscosity;
00046 double dynamic_viscosity;
00047 double relative_density;
00048 double void_ratio;
00049 double void_ratio_max;
00050 double porosity;
00051 double porosity_min;
00052 double permeability;
00053 };
00054
00055 CLASS ( Sed_sediment )
00056 {
00057 Sed_type* l;
00058 gssize len;
00059 };
00060
00061 static Sed_sediment sed_env = NULL;
00062 static gboolean sed_env_is_set = FALSE;
00063
00064 Sed_sediment
00065 sed_sediment_new( )
00066 {
00067 Sed_sediment p;
00068
00069 NEW_OBJECT( Sed_sediment , p );
00070
00071 p->len = 0;
00072 p->l = NULL;
00073
00074 return p;
00075 }
00076
00077 Sed_sediment sed_sediment_new_sized( gssize n )
00078 {
00079 Sed_sediment p = NULL;
00080
00081 if ( n>=0 )
00082 {
00083 p = sed_sediment_new();
00084 if ( n>0 )
00085 p = sed_sediment_resize( p , n );
00086 }
00087
00088 return p;
00089 }
00090
00091 Sed_sediment sed_sediment_set_env( Sed_sediment s )
00092 {
00093 if ( !sed_env_is_set )
00094 {
00095 sed_env = sed_sediment_dup( s );
00096 sed_env_is_set = TRUE;
00097 }
00098
00099 return sed_env;
00100 }
00101
00102 Sed_sediment sed_sediment_unset_env( )
00103 {
00104 sed_env = sed_sediment_destroy( sed_env );
00105 sed_env_is_set = FALSE;
00106
00107 return NULL;
00108 }
00109
00110 Sed_sediment sed_sediment_env( )
00111 {
00112 return sed_env;
00113 }
00114
00115 gboolean sed_sediment_env_is_set( )
00116 {
00117 return sed_env_is_set;
00118 }
00119
00120 Sed_sediment sed_sediment_copy( Sed_sediment dest , const Sed_sediment src )
00121 {
00122 eh_require( src );
00123
00124 if ( src )
00125 {
00126 gssize i;
00127 gssize n_grains = sed_sediment_n_types( src );
00128
00129 if ( !dest )
00130 dest = sed_sediment_new( );
00131
00132 dest->l = eh_new( Sed_type , n_grains );
00133 dest->len = n_grains;
00134
00135 for ( i=0 ; i<n_grains ; i++ )
00136 dest->l[i] = sed_type_dup( src->l[i] );
00137 }
00138 else
00139 dest = NULL;
00140
00141 return dest;
00142 }
00143
00144 Sed_sediment sed_sediment_dup( const Sed_sediment src )
00145 {
00146 return sed_sediment_copy( NULL , src );
00147 }
00148
00149 gssize sed_sediment_n_types( const Sed_sediment sed )
00150 {
00151 if ( sed )
00152 return sed->len;
00153 else
00154 return sed_sediment_env_n_types();
00155 }
00156
00157 gssize sed_sediment_env_size( )
00158 {
00159 gssize n = 0;
00160
00161 if ( sed_sediment_env_is_set() )
00162 n = sed_sediment_env()->len;
00163
00164
00165
00166 return n;
00167 }
00168
00169 gint
00170 sed_sediment_env_n_types()
00171 {
00172 gint n = 0;
00173 if ( sed_sediment_env_is_set() )
00174 n = sed_sediment_env()->len;
00175
00176 return n;
00177 }
00178
00179 Sed_sediment sed_sediment_resize( Sed_sediment s , gssize new_len )
00180 {
00181 if ( new_len>0 )
00182 {
00183
00184 if ( !s )
00185 s = sed_sediment_new();
00186
00187 s->l = eh_renew( Sed_type , s->l , new_len );
00188 s->len = new_len;
00189 }
00190 else
00191 s = sed_sediment_destroy( s );
00192
00193 return s;
00194 }
00195
00196 Sed_sediment sed_sediment_add_type( Sed_sediment sed , const Sed_type new_type )
00197 {
00198 eh_require( sed );
00199 eh_require( new_type );
00200
00201 if ( sed && new_type )
00202 {
00203 if ( !sed_sediment_has_type(sed,new_type) )
00204 {
00205 sed = sed_sediment_resize( sed , sed->len+1 );
00206 sed = sed_sediment_append( sed , new_type );
00207
00208 }
00209 }
00210
00211 return sed;
00212 }
00213
00214 gboolean sed_sediment_has_type( Sed_sediment s , Sed_type t )
00215 {
00216 gboolean found = FALSE;
00217
00218 if ( t )
00219 {
00220 gssize i;
00221
00222 for ( i=0 ; !found && i<s->len ; i++ )
00223 found = sed_type_is_same( s->l[i] , t );
00224 }
00225
00226 return found;
00227 }
00228
00229 Sed_sediment sed_sediment_insert_sorted( Sed_sediment s , Sed_type t )
00230 {
00231 eh_require( s );
00232 eh_require( t );
00233
00234 if ( s && t )
00235 {
00236 gssize i;
00237 double gz = t->gz;
00238 gboolean is_inserted = FALSE;
00239
00240 eh_require( s->l[s->len-1] == NULL );
00241
00242 if ( s->len == 1 )
00243 {
00244 s->l[0] = sed_type_dup(t);
00245 is_inserted = TRUE;
00246 }
00247
00248 for ( i=s->len-2 ; !is_inserted && i>=0 ; i-- )
00249 {
00250 if ( gz > s->l[i]->gz )
00251 {
00252 s->l[i+1] = s->l[i];
00253 if ( i==0 )
00254 {
00255 s->l[0] = sed_type_dup(t);
00256 is_inserted = TRUE;
00257 }
00258 }
00259 else
00260 {
00261 s->l[i+1] = sed_type_dup(t);
00262 is_inserted = TRUE;
00263 }
00264 }
00265 }
00266 else
00267 s = NULL;
00268
00269 return s;
00270 }
00271
00272 gssize sed_sediment_fprint( FILE* fp , Sed_sediment s )
00273 {
00274 gssize n = 0;
00275
00276 if ( s )
00277 {
00278 gint i;
00279 for ( i=0 ; i<s->len ; i++ )
00280 {
00281 fprintf( fp , "Sediment type id: %d\n" , i );
00282 n += sed_type_fprint( fp , s->l[i] );
00283 }
00284 }
00285 else
00286 fprintf( fp , "( null )\n" );
00287
00288 return n;
00289 }
00290
00291 Sed_sediment sed_sediment_append( Sed_sediment s , Sed_type t )
00292 {
00293 eh_require( s );
00294 eh_require( t );
00295
00296 if ( s && t )
00297 s->l[s->len-1] = sed_type_dup( t );
00298 else
00299 s = NULL;
00300
00301 return s;
00302 }
00303
00304 void sed_sediment_foreach( Sed_sediment s , GFunc f , gpointer user_data )
00305 {
00306 eh_require( s );
00307
00308 if ( s )
00309 {
00310 gssize i;
00311 for ( i=0 ; i<s->len ; i++ )
00312 (*f)( s->l[i] , user_data );
00313 }
00314 }
00315
00316 double* sed_sediment_property( Sed_sediment s , Sed_type_property_func_0 f )
00317 {
00318 double* x;
00319
00320 if ( !s )
00321 s = sed_sediment_env();
00322
00323 {
00324 gssize i;
00325 gssize len = sed_sediment_n_types(s);
00326
00327 x = eh_new( double , len );
00328
00329 for ( i=0 ; i<len ; i++ )
00330 x[i] = (*f)( s->l[i] );
00331 }
00332
00333 return x;
00334 }
00335
00336 double sed_sediment_property_avg( Sed_sediment s , double* f , Sed_type_property_func_0 p_func )
00337 {
00338 double val = 0;
00339
00340 {
00341 gssize i;
00342
00343 if ( !s )
00344 s = sed_sediment_env();
00345
00346 for ( i=0 ; i<s->len ; i++ )
00347 val += f[i] * (*p_func)( s->l[i] );
00348 }
00349
00350 return val;
00351 }
00352
00353 double sed_sediment_property_avg_1( Sed_sediment s , double* f , double arg_1 , Sed_type_property_func_1 p_func )
00354 {
00355 double val = 0;
00356
00357 {
00358 gssize i;
00359
00360 if ( !s )
00361 s = sed_sediment_env();
00362
00363 for ( i=0 ; i<s->len ; i++ )
00364 val += f[i] * (*p_func)( s->l[i] , arg_1 );
00365 }
00366
00367 return val;
00368 }
00369
00370 double sed_sediment_property_avg_2( Sed_sediment s , double* f , double arg_1 , double arg_2 , Sed_type_property_func_2 p_func )
00371 {
00372 double val = 0;
00373
00374 {
00375 gssize i;
00376
00377 if ( !s )
00378 s = sed_sediment_env();
00379
00380 for ( i=0 ; i<s->len ; i++ )
00381 val += f[i] * (*p_func)( s->l[i] , arg_1 , arg_2 );
00382 }
00383
00384 return val;
00385 }
00386
00387 double sed_sediment_property_avg_with_data( Sed_sediment s , double* f , Sed_type_property_func_with_data p_func , gpointer data )
00388 {
00389 double val = 0;
00390
00391 {
00392 gssize i;
00393
00394 if ( !s )
00395 s = sed_sediment_env();
00396
00397 for ( i=0 ; i<s->len ; i++ )
00398 {
00399 if ( f[i]>1e-12 )
00400 val += f[i] * (*p_func)( s->l[i] , data );
00401 }
00402 }
00403
00404 return val;
00405 }
00406
00407 Sed_type sed_sediment_type( const Sed_sediment s , gssize id )
00408 {
00409 Sed_type t = NULL;
00410
00411 {
00412 const Sed_sediment real_s = (s)?(s):(sed_sediment_env());
00413
00414 eh_require( id>=0 );
00415 eh_require( id<real_s->len );
00416
00417 if ( real_s->len>0 )
00418 t = real_s->l[id];
00419 }
00420
00421 return t;
00422 }
00423
00424 Sed_type sed_sediment_bedload( const Sed_sediment s )
00425 {
00426 return s->l[0];
00427 }
00428
00429 Sed_sediment sed_sediment_destroy( Sed_sediment s )
00430 {
00431 if ( s )
00432 {
00433 gssize i;
00434 for ( i=0 ; i<s->len ; i++ )
00435 sed_type_destroy( s->l[i] );
00436 eh_free( s->l );
00437 eh_free( s );
00438 }
00439
00440 return NULL;
00441 }
00442
00443 Sed_type sed_type_new( )
00444 {
00445 Sed_type t;
00446 NEW_OBJECT( Sed_type , t );
00447
00448 memset( t , 0 , sizeof(*t) );
00449
00450 return t;
00451 }
00452
00453 Sed_type sed_type_destroy( Sed_type t )
00454 {
00455 if ( t )
00456 {
00457 eh_free( t );
00458 }
00459
00460 return t;
00461 }
00462
00463 #include <string.h>
00464
00465 Sed_type sed_type_copy( Sed_type dest , Sed_type src )
00466 {
00467 eh_require( src );
00468
00469 if ( !dest )
00470 dest = sed_type_new();
00471
00472 memcpy( dest , src , sizeof( *dest ) );
00473
00474 return dest;
00475 }
00476
00477 Sed_type sed_type_dup( Sed_type src )
00478 {
00479 return sed_type_copy( NULL , src );
00480 }
00481
00482 gssize sed_type_fprint( FILE* fp , Sed_type t )
00483 {
00484 gssize n = 0;
00485
00486 if ( t )
00487 {
00488 n += fprintf( fp , "Saturated density (kg/m^3) : %f\n" , t->rho_sat );
00489 n += fprintf( fp , "Grain density (kg/m^3) : %f\n" , t->rho_grain );
00490 n += fprintf( fp , "Grain size (um) : %f\n" , t->gz );
00491 n += fprintf( fp , "Plastic incex (-) : %f\n" , t->pi );
00492 n += fprintf( fp , "Minimum void ratio (-) : %f\n" , t->void_min );
00493 n += fprintf( fp , "Diffusion coefficient (-) : %f\n" , t->diff_coef );
00494 n += fprintf( fp , "Removal rate (1/day) : %f\n" , t->lambda );
00495 n += fprintf( fp , "Consolidation (?) : %f\n" , t->c_v );
00496 n += fprintf( fp , "Compressibility (?) : %f\n" , t->c );
00497 n += fprintf( fp , "Settling velocity (m/day) : %f\n" , t->w_s );
00498 }
00499 else
00500 n += fprintf( fp , "( null )\n" );
00501
00502 return n;
00503 }
00504
00505 gssize sed_type_write( FILE* fp , Sed_type t )
00506 {
00507 gssize n = 0;
00508
00509 eh_require( fp );
00510 eh_require( t );
00511
00512 if ( fp && t )
00513 {
00514 n += fwrite( t , sizeof(Sed_type) , 1 , fp );
00515 }
00516
00517 return n;
00518 }
00519
00520 Sed_type sed_type_read( FILE* fp )
00521 {
00522 Sed_type t = NULL;
00523
00524 if ( fp )
00525 {
00526 t = sed_type_new();
00527
00528 fread( t , sizeof(Sed_type) , 1 , fp );
00529 }
00530
00531 return t;
00532 }
00533
00534 double sed_sediment_bedload_rho(const Sed_sediment s)
00535 {
00536 return sed_type_rho_sat( s->l[0] );
00537 }
00538
00539 gssize sed_sediment_write( FILE *fp , const Sed_sediment s )
00540 {
00541 gssize n = 0;
00542
00543 if ( s )
00544 {
00545 gssize i;
00546 gssize n_grains = sed_sediment_n_types(s);
00547
00548 n += fwrite( &n_grains , sizeof(gssize) , 1 , fp );
00549 for ( i=0 ; i<n_grains ; i++ )
00550 n += sed_type_write( fp , s->l[i] );
00551 }
00552
00553 return n;
00554 }
00555
00556 Sed_sediment sed_sediment_read( FILE* fp )
00557 {
00558 Sed_sediment s;
00559
00560 if ( fp )
00561 {
00562 gssize n;
00563 gssize n_grains;
00564 Sed_type new_type;
00565
00566 fread( &n_grains , sizeof(gint16) , 1 , fp );
00567
00568 s = sed_sediment_new( );
00569 for ( n=0 ; n<n_grains ; n++ )
00570 {
00571 fread( &new_type , sizeof(Sed_type) , 1 , fp );
00572 sed_sediment_add_type( s , new_type );
00573 }
00574 }
00575
00576 return s;
00577 }
00578
00579 void sed_sediment_fprint_default( FILE *fp )
00580 {
00581 eh_require( fp );
00582
00583 if ( fp )
00584 {
00585 char *text[] = DEFAULT_SEDIMENT_FILE;
00586 char **p;
00587 for ( p = text ; *p ; p++ )
00588 fprintf( fp , "%s\n" , *p );
00589 }
00590 }
00591
00613 Sed_sediment
00614 sed_sediment_scan( const char *file , GError** error )
00615 {
00616 Sed_sediment sed = NULL;
00617
00618 eh_return_val_if_fail( error==NULL || *error==NULL , NULL );
00619
00620 if ( !file )
00621 file = SED_SEDIMENT_TEST_FILE;
00622
00623 {
00624 char* name_used = g_strdup( file );
00625 GError* tmp_err = NULL;
00626 Eh_key_file key_file = NULL;
00627
00628 key_file = eh_key_file_scan( name_used , &tmp_err );
00629
00630 if ( key_file )
00631 {
00632 Eh_symbol_table group;
00633 Sed_type new_type;
00634
00635 sed = sed_sediment_new();
00636
00637 for ( group = eh_key_file_pop_group( key_file ) ;
00638 group ;
00639 group = eh_key_file_pop_group( key_file ) )
00640 {
00641 new_type = sed_type_init( group );
00642
00643 sed = sed_sediment_add_type( sed , new_type );
00644
00645 group = eh_symbol_table_destroy( group );
00646 new_type = sed_type_destroy ( new_type );
00647 }
00648 }
00649 else
00650 g_propagate_error( error , tmp_err );
00651
00652 eh_key_file_destroy( key_file );
00653 eh_free ( name_used );
00654 }
00655
00656 return sed;
00657 }
00658
00659 #define S_KEY_GRAIN_SIZE "grain size"
00660 #define S_KEY_RHO_GRAIN "grain density"
00661 #define S_KEY_RHO_SAT "saturated density"
00662 #define S_KEY_VOID_MIN "minimum void ratio"
00663 #define S_KEY_PI "plastic index"
00664 #define S_KEY_DIFF_COEF "diffusion coefficient"
00665 #define S_KEY_LAMBDA "removal rate"
00666 #define S_KEY_C_V "consolidation coefficient"
00667 #define S_KEY_C "compaction coefficient"
00668
00669 Sed_type sed_type_init( Eh_symbol_table t )
00670 {
00671 Sed_type s;
00672
00673 s = sed_type_new();
00674
00675 s->gz = eh_symbol_table_dbl_value( t , S_KEY_GRAIN_SIZE );
00676 s->rho_grain = eh_symbol_table_dbl_value( t , S_KEY_RHO_GRAIN );
00677 s->rho_sat = eh_symbol_table_dbl_value( t , S_KEY_RHO_SAT );
00678 s->void_min = eh_symbol_table_dbl_value( t , S_KEY_VOID_MIN );
00679 s->diff_coef = eh_symbol_table_dbl_value( t , S_KEY_DIFF_COEF );
00680 s->lambda = eh_symbol_table_dbl_value( t , S_KEY_LAMBDA );
00681 s->c_v = eh_symbol_table_dbl_value( t , S_KEY_C_V );
00682 s->c = eh_symbol_table_dbl_value( t , S_KEY_C );
00683
00684 s->w_s = sed_removal_rate_to_settling_velocity( s->lambda );
00685
00686 eh_require( s->rho_grain >= sed_rho_sea_water() );
00687 eh_require( s->rho_grain <= sed_rho_quartz() );
00688 eh_require( s->rho_sat >= sed_rho_sea_water() );
00689 eh_require( s->rho_sat <= sed_rho_quartz() );
00690 eh_require( s->rho_sat <= s->rho_grain );
00691 eh_require( s->void_min >= 0. );
00692 eh_require( s->diff_coef >= 0. );
00693 eh_require( s->diff_coef <= 1. );
00694
00695 return s;
00696 }
00697
00698 gboolean sed_type_is_same( Sed_type t_1 , Sed_type t_2 )
00699 {
00700 gboolean same = TRUE;
00701
00702 eh_require( t_1 );
00703 eh_require( t_2 );
00704
00705 if ( t_1!=t_2 )
00706 {
00707 same = fabs( t_1->rho_grain - t_2->rho_grain ) < 1e-12
00708 && fabs( t_1->rho_sat - t_2->rho_sat ) < 1e-12
00709 && fabs( t_1->gz - t_2->gz ) < 1e-12
00710 && fabs( t_1->pi - t_2->pi ) < 1e-12
00711 && fabs( t_1->void_min - t_2->void_min ) < 1e-12
00712 && fabs( t_1->diff_coef - t_2->diff_coef ) < 1e-12
00713 && fabs( t_1->lambda - t_2->lambda ) < 1e-12
00714 && fabs( t_1->c_v - t_2->c_v ) < 1e-12
00715 && fabs( t_1->c - t_2->c ) < 1e-12
00716 && fabs( t_1->w_s - t_2->w_s ) < 1e-12;
00717 }
00718
00719 return same;
00720 }
00721
00722 gboolean
00723 sed_type_is_same_size( Sed_type t_1 , Sed_type t_2 )
00724 {
00725 gboolean same = TRUE;
00726
00727 eh_require( t_1 );
00728 eh_require( t_2 );
00729
00730 if ( t_1!=t_2 )
00731 {
00732 same = fabs( t_1->gz - t_2->gz ) < 1e-12;
00733 }
00734
00735 return same;
00736 }
00737
00738 double __gravity = S_GRAVITY;
00739 double __rho_sea_water = S_RHO_SEA_WATER;
00740 double __rho_fresh_water = S_RHO_FRESH_WATER;
00741 double __mu_water = S_MU_WATER;
00742 double __salinity_sea = S_SALINITY_SEA;
00743 double __rho_grain = S_RHO_GRAIN;
00744 double __rho_mantle = S_RHO_MANTLE;
00745
00746 double sed_gravity( )
00747 {
00748 extern double __gravity;
00749 return __gravity;
00750 }
00751 double sed_gravity_units( Sed_units units )
00752 {
00753 switch ( units )
00754 {
00755 case UNITS_MKS:
00756 return __gravity;
00757 case UNITS_CGS:
00758 return __gravity*100.;
00759 case UNITS_IMPERIAL:
00760 return __gravity*3.2808399;
00761 default:
00762 eh_require_not_reached();
00763 return __gravity;
00764 }
00765 }
00766 double sed_set_gravity( double new_val )
00767 {
00768 extern double __gravity;
00769 return __gravity = new_val;
00770 }
00771 double sed_rho_sea_water()
00772 {
00773 extern double __rho_sea_water;
00774 return __rho_sea_water;
00775 }
00776
00777 double
00778 sed_rho_sea_water_units( Sed_units units )
00779 {
00780 switch ( units )
00781 {
00782 case UNITS_MKS:
00783 return sed_rho_sea_water();
00784 case UNITS_CGS:
00785 return sed_rho_sea_water()*.001;
00786 case UNITS_IMPERIAL:
00787 return sed_rho_sea_water()*0.062428;
00788 default:
00789 eh_require_not_reached();
00790 return sed_rho_sea_water();
00791 }
00792 }
00793
00794 double
00795 sed_set_rho_sea_water( double new_val )
00796 {
00797 extern double __rho_sea_water;
00798 return __rho_sea_water = new_val;
00799 }
00800
00801 double
00802 sed_rho_fresh_water()
00803 {
00804 extern double __rho_fresh_water;
00805 return __rho_fresh_water;
00806 }
00807
00808 double
00809 sed_rho_fresh_water_units( Sed_units units )
00810 {
00811 switch ( units )
00812 {
00813 case UNITS_MKS:
00814 return sed_rho_fresh_water();
00815 case UNITS_CGS:
00816 return sed_rho_fresh_water()*.001;
00817 case UNITS_IMPERIAL:
00818 return sed_rho_fresh_water()*0.062428;
00819 default:
00820 eh_require_not_reached();
00821 return sed_rho_fresh_water();
00822 }
00823 }
00824
00825 double
00826 sed_set_rho_fresh_water( double new_val )
00827 {
00828 extern double __rho_fresh_water;
00829 return __rho_fresh_water = new_val;
00830 }
00831
00832 double
00833 sed_mu_water()
00834 {
00835 extern double __mu_water;
00836 return __mu_water;
00837 }
00838
00839 double
00840 sed_mu_water_units( Sed_units units )
00841 {
00842 switch ( units )
00843 {
00844 case UNITS_MKS: return sed_mu_water();
00845 case UNITS_CGS: return sed_mu_water()*10.;
00846 case UNITS_IMPERIAL:
00847 default:
00848 eh_require_not_reached();
00849 return sed_mu_water();
00850 }
00851 }
00852
00853 double
00854 sed_set_mu_water( double new_val )
00855 {
00856 extern double __mu_water;
00857 return __mu_water = new_val;
00858 }
00859
00860 double sed_sea_salinity()
00861 {
00862 extern double __salinity_sea;
00863 return __salinity_sea;
00864 }
00865 double sed_sea_salinity_units( Sed_units units )
00866 {
00867 switch ( units )
00868 {
00869 case UNITS_MKS:
00870 return sed_sea_salinity()*.001;
00871 case UNITS_CGS:
00872 return sed_sea_salinity()*.001;
00873 case UNITS_IMPERIAL:
00874 return sed_sea_salinity()*.001;
00875 default:
00876 eh_require_not_reached();
00877 return sed_sea_salinity()*.001;
00878 }
00879 }
00880 double sed_set_sea_salinity( double new_val )
00881 {
00882 extern double __salinity_sea;
00883 return __salinity_sea = new_val;
00884 }
00885
00886 double sed_rho_quartz()
00887 {
00888 extern double __rho_grain;
00889 return __rho_grain;
00890 }
00891
00892 double sed_rho_quartz_units( Sed_units units )
00893 {
00894 switch ( units )
00895 {
00896 case UNITS_MKS:
00897 return sed_rho_quartz();
00898 case UNITS_CGS:
00899 return sed_rho_quartz()*.001;
00900 case UNITS_IMPERIAL:
00901 return sed_rho_quartz()*0.062428;
00902 default:
00903 eh_require_not_reached();
00904 return sed_rho_quartz();
00905 }
00906 }
00907
00908 double sed_set_rho_quartz( double new_val )
00909 {
00910 extern double __rho_grain;
00911 return __rho_grain = new_val;
00912 }
00913
00914 double sed_rho_mantle()
00915 {
00916 extern double __rho_mantle;
00917 return __rho_mantle;
00918 }
00919
00920 double sed_rho_mantle_units( Sed_units units )
00921 {
00922 switch ( units )
00923 {
00924 case UNITS_MKS:
00925 return sed_rho_mantle();
00926 case UNITS_CGS:
00927 return sed_rho_mantle()*.001;
00928 case UNITS_IMPERIAL:
00929 return sed_rho_mantle()*0.062428;
00930 default:
00931 eh_require_not_reached();
00932 return sed_rho_mantle();
00933 }
00934 }
00935
00936 double sed_set_rho_mantle( double new_val )
00937 {
00938 extern double __rho_mantle;
00939 return __rho_mantle = new_val;
00940 }
00941
00942 Sed_type sed_type_set_rho_sat( Sed_type t , double rho_sat )
00943 {
00944 t->rho_sat = rho_sat;
00945 return t;
00946 }
00947
00948 Sed_type sed_type_set_rho_grain( Sed_type t , double rho_grain )
00949 {
00950 t->rho_grain = rho_grain;
00951 return t;
00952 }
00953
00954 Sed_type sed_type_set_grain_size( Sed_type t , double gz )
00955 {
00956 t->gz = gz;
00957 return t;
00958 }
00959
00960 Sed_type sed_type_set_plastic_index( Sed_type t , double pi )
00961 {
00962 t->pi = pi;
00963 return t;
00964 }
00965
00966 Sed_type sed_type_set_void_ratio_min( Sed_type t , double void_min )
00967 {
00968 t->void_min = void_min;
00969 return t;
00970 }
00971
00972 Sed_type sed_type_set_diff_coef( Sed_type t , double k )
00973 {
00974 t->diff_coef = k;
00975 return t;
00976 }
00977
00978 Sed_type sed_type_set_lambda( Sed_type t , double l )
00979 {
00980 t->lambda = l;
00981 t->w_s = sed_removal_rate_to_settling_velocity( t->lambda );
00982 return t;
00983 }
00984
00985 Sed_type sed_type_set_settling_velocity( Sed_type t , double w )
00986 {
00987 t->w_s = w;
00988 t->lambda = sed_settling_velocity_to_removal_rate( t->w_s );
00989 return t;
00990 }
00991
00992 Sed_type sed_type_set_c_consolidation( Sed_type t , double c_v )
00993 {
00994 t->c_v = c_v;
00995 return t;
00996 }
00997
00998 Sed_type sed_type_set_compressibility( Sed_type t , double c )
00999 {
01000 t->c = c;
01001 return t;
01002 }
01003
01004 double sed_type_rho_sat( const Sed_type t )
01005 {
01006 return t->rho_sat;
01007 }
01008
01009 double sed_type_rho_grain( const Sed_type t )
01010 {
01011 return t->rho_grain;
01012 }
01013
01014 double sed_type_grain_size( const Sed_type t )
01015 {
01016 return t->gz;
01017 }
01018
01019 double sed_type_plastic_index( const Sed_type t )
01020 {
01021 return t->pi;
01022 }
01023
01024 double sed_type_void_ratio_min(const Sed_type t )
01025 {
01026 return t->void_min;
01027 }
01028
01029 double sed_type_diff_coef(const Sed_type t )
01030 {
01031 return t->diff_coef;
01032 }
01033
01034 double sed_type_lambda( const Sed_type t )
01035 {
01036 return t->lambda;
01037 }
01038
01039 double sed_type_lambda_in_per_seconds( const Sed_type t )
01040 {
01041 return t->lambda*S_DAYS_PER_SECOND;
01042 }
01043
01057 #define SED_BURSIK_CONST_A_3 (1.74)
01058 #define SED_BURSIK_CONST_H (7.5)
01059 double
01060 sed_type_settling_velocity( const Sed_type t )
01061 {
01062 return t->w_s;
01063 }
01064
01065 double
01066 sed_removal_rate_to_settling_velocity( double l )
01067 {
01068 return l * SED_BURSIK_CONST_A_3 * SED_BURSIK_CONST_H;
01069 }
01070
01071 double sed_settling_velocity_to_removal_rate( double w_s )
01072 {
01073 return w_s / ( SED_BURSIK_CONST_A_3 * SED_BURSIK_CONST_H );
01074 }
01075
01076 double sed_type_c_consolidation( const Sed_type t )
01077 {
01078 return t->c_v;
01079 }
01080
01081 double sed_type_compressibility( const Sed_type t )
01082 {
01083 return t->c;
01084 }
01085
01086 double sed_type_density_0( const Sed_type t )
01087 {
01088
01089
01090
01091
01092 return sed_type_rho_sat(t);
01093 }
01094
01095 double sed_type_rho_max( const Sed_type t )
01096 {
01097 double e = sed_type_void_ratio_min(t);
01098 return (sed_type_rho_grain(t) + e*sed_rho_sea_water())/(e+1.);
01099 }
01100
01101 double sed_type_grain_size_in_meters( const Sed_type t )
01102 {
01103 return sed_type_grain_size(t)*1e-6;
01104 }
01105
01106 double sed_type_inv_grain_size_in_meters( const Sed_type t )
01107 {
01108 return 1./( sed_type_grain_size(t)*1e-6 );
01109 }
01110
01111 double sed_type_grain_size_in_phi( const Sed_type t )
01112 {
01113 return -log2(t->gz*1e-3);
01114 }
01115
01116 double sed_type_is_sand( const Sed_type t )
01117 {
01118 if ( (Sed_size_class)
01119 (S_SED_TYPE_SAND & sed_type_size_class( t ) ) )
01120 return TRUE;
01121 else
01122 return FALSE;
01123 }
01124
01125 double sed_type_is_silt( const Sed_type t )
01126 {
01127 if ( (Sed_size_class)
01128 (S_SED_TYPE_SILT & sed_type_size_class( t ) ) )
01129 return TRUE;
01130 else
01131 return FALSE;
01132 }
01133
01134 double sed_type_is_clay( const Sed_type t )
01135 {
01136 if ( (Sed_size_class)
01137 (S_SED_TYPE_CLAY & sed_type_size_class( t ) ) )
01138 return TRUE;
01139 else
01140 return FALSE;
01141 }
01142
01143 double sed_type_is_mud( const Sed_type t )
01144 {
01145 if ( (Sed_size_class)
01146 (S_SED_TYPE_MUD & sed_type_size_class( t )) )
01147 return TRUE;
01148 else
01149 return FALSE;
01150 }
01151
01152 Sed_size_class sed_type_grain_size_in_wentworth( const Sed_type t )
01153 {
01154 return sed_size_class( sed_type_grain_size_in_phi( t ) );
01155 }
01156
01157 Sed_size_class
01158 sed_type_size_class( const Sed_type t )
01159 {
01160 return sed_size_class( sed_type_grain_size_in_phi( t ) );
01161 }
01162
01163 double sed_type_velocity( const Sed_type t )
01164 {
01165 double e = sed_type_void_ratio( t );
01166 return ( e*S_VELOCITY_IN_WATER + S_VELOCITY_IN_ROCK)/(e+1);
01167 }
01168
01169 double sed_type_viscosity( const Sed_type t )
01170 {
01171 double mu = 0;
01172 double r = sed_type_void_ratio( t ) / sed_type_void_ratio_min( t );
01173
01174 if ( r > .8 )
01175 mu = S_ETA_WATER * 25;
01176 else
01177 mu = S_ETA_WATER * pow( 1-r , -2 );
01178
01179 return mu;
01180 }
01181
01182 double sed_type_dynamic_viscosity( const Sed_type t )
01183 {
01184 double c = 1. - sed_type_porosity( t );
01185 Sed_size_class size = sed_type_size_class( t );
01186 double a;
01187
01188 switch ( size )
01189 {
01190 case S_SED_TYPE_SAND:
01191 a = 10.;
01192 break;
01193 default:
01194 a = 23;
01195 }
01196
01197 return S_MU_WATER*( 1. + 2.5*c + exp( a*(c-.05) ) );
01198 }
01199
01200 double sed_type_relative_density( const Sed_type t )
01201 {
01202 double e = sed_type_void_ratio ( t );
01203 double e_min = sed_type_void_ratio_min( t );
01204 double e_max = sed_type_void_ratio_max( t );
01205
01206 return ( e_max-e ) / ( e_max-e_min );
01207 }
01208
01209 double sed_type_void_ratio( Sed_type t )
01210 {
01211 double rho_sat = sed_type_rho_sat ( t );
01212 double rho_grain = sed_type_rho_grain( t );
01213
01214 return (rho_grain - rho_sat)/(rho_sat - sed_rho_sea_water());
01215 }
01216
01217 double sed_type_void_ratio_max( Sed_type t )
01218 {
01219 double p_max = sed_type_porosity_max( t );
01220 return p_max / ( 1. - p_max );
01221 }
01222
01223 double sed_type_porosity( const Sed_type t )
01224 {
01225 double e = sed_type_void_ratio( t );
01226 return e / (1+e);
01227 }
01228
01229 double sed_type_porosity_min( const Sed_type t )
01230 {
01231 double e_min = sed_type_void_ratio_min(t);
01232 return e_min / ( 1 + e_min );
01233 }
01234
01235 double sed_type_porosity_max(const Sed_type t )
01236 {
01237 return sed_type_porosity(t);
01238 }
01239
01240 #define S_F (1.25)
01241
01242 double sed_type_permeability( const Sed_type t )
01243 {
01244 double e = sed_type_void_ratio ( t );
01245 double d = sed_type_grain_size_in_meters( t );
01246 double s = 6./d;
01247
01248 return ( 1./(5.*S_F*s*s) )*(pow(e,3)/(1+e));
01249 }
01250
01251 double sed_type_hydraulic_conductivity( const Sed_type t )
01252 {
01253 return sed_type_permeability( t ) * S_GAMMA_WATER / S_MU_WATER;
01254 }
01255
01256 double sed_type_water_content( const Sed_type t )
01257 {
01258 double e = sed_type_void_ratio( t );
01259 double rho_grain = sed_type_rho_grain ( t );
01260 return e*(sed_rho_sea_water()/rho_grain);
01261 }
01262
01263 double sed_specific_gravity( const Sed_type t )
01264 {
01265 return sed_type_rho_grain(t)/sed_rho_sea_water();
01266 }
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285 double sed_type_friction_angle( const Sed_type t )
01286 {
01287 double phi = 36.;
01288 double grain_size = sed_type_grain_size_in_meters( t );
01289 double rho_rel = sed_type_relative_density ( t );
01290
01291 if ( grain_size >= 2e-3 )
01292 phi -= 11;
01293 else if ( grain_size >= .6e-3 )
01294 phi -= 9;
01295 else if ( grain_size >= .2e-3 )
01296 phi -= 4;
01297
01298 if ( rho_rel <= .5 )
01299 phi -= 1;
01300 else if ( rho_rel > .75 )
01301 phi += 4;
01302
01303 return phi;
01304 }
01305
01306 double sed_type_yield_strength( const Sed_type t )
01307 {
01308 double a;
01309 Sed_size_class size = sed_type_size_class( t );
01310 double c = 1. - sed_type_porosity( t );
01311
01312 switch ( size )
01313 {
01314 case S_SED_TYPE_SAND:
01315 a = 3.;
01316 break;
01317 case S_SED_TYPE_SILT:
01318 a = 13.;
01319 break;
01320 case S_SED_TYPE_CLAY:
01321 a = 23.;
01322 break;
01323 default:
01324 eh_require_not_reached();
01325 }
01326
01327 return .1*exp( a *( c - .05 ) );
01328 }
01329
01330 double sed_type_mv( const Sed_type t )
01331 {
01332 return sed_type_compressibility( t );
01333 }
01334
01335 double sed_type_cv( const Sed_type t )
01336 {
01337 double mv = sed_type_compressibility( t );
01338 return sed_type_hydraulic_conductivity(t) / ( S_GAMMA_WATER * mv );
01339 }
01340
01341 double sed_type_shear_strength( const Sed_type t , double load )
01342 {
01343 return load*( .11 + .0037 * sed_type_plastic_index(t) );
01344 }
01345
01346 double sed_type_shear_strength_with_data( const Sed_type t , gpointer data )
01347 {
01348 return sed_type_shear_strength( t , *((double*)data) );
01349 }
01350
01351 double sed_type_cohesion( const Sed_type t , double load )
01352 {
01353 double a = .69;
01354 double m = .6;
01355
01356 return ( a*(1-m)*pow(load*1e-6,m) )*1e6;
01357
01358 }
01359
01360 double sed_type_cohesion_with_data( const Sed_type t , gpointer data )
01361 {
01362 return sed_type_cohesion( t , *((double*)data) );
01363 }
01364
01365 double sed_type_consolidation( const Sed_type t , double d , double dt )
01366 {
01367 double c_v = sed_type_c_consolidation( t );
01368
01369 return sed_calculate_avg_consolidation( c_v , d , dt );
01370 }
01371
01372 double sed_type_consolidation_with_data( const Sed_type t , gpointer data )
01373 {
01374 return sed_type_consolidation_rate( t , ((double*)data)[0] , ((double*)data)[1] );
01375 }
01376
01377 double sed_type_consolidation_rate( const Sed_type t , double d , double dt )
01378 {
01379 double u;
01380 double c_v = sed_type_c_consolidation( t );
01381 double t_v = c_v*dt/(d*d);
01382
01383 if ( t_v < .2827 )
01384 u = .5/sqrt(4/G_PI*dt);
01385 else
01386 u = 2*exp( -G_PI*G_PI*.25*t_v );
01387
01388 return u;
01389 }
01390
01391 double sed_type_consolidation_rate_with_data( const Sed_type t , gpointer data )
01392 {
01393 return sed_type_consolidation_rate( t , ((double*)data)[0] , ((double*)data)[1] );
01394 }
01395
01396 double sed_calculate_avg_consolidation( double c_v , double d , double t )
01397 {
01398 double t_v = c_v*t/(d*d);
01399 if ( d <= 0 )
01400 return 1.;
01401 if ( t_v < .2827 )
01402 return ( sqrt(4./G_PI*t_v) );
01403 else
01404 return ( 1.-8./(G_PI*G_PI)*exp(-G_PI*G_PI/4.*t_v) );
01405 }
01406
01407 double sed_calculate_consolidation( double c_v , double d , double z , double t )
01408 {
01409 double t_v = c_v*t/(d*d);
01410 double n, eps = G_MAXDOUBLE;
01411 double u, u_0;
01412
01413 if ( d <= 0 )
01414 return 1.;
01415 if ( t <= 0 )
01416 return 0;
01417
01418 for ( n=1,u=0 ; eps>1e-3 ; n+=2 )
01419 {
01420 u_0 = u;
01421 u += 1./n*sin( n*G_PI*z/d )*exp( -pow(n*G_PI*.5,2)*t_v );
01422 eps = fabs( ( u_0 - u ) / u );
01423 }
01424 u *= 4/G_PI;
01425
01426 return 1-u;
01427 }
01428
01429 double
01430 sed_type_is_size_class( Sed_type t , Sed_size_class size )
01431 {
01432 return size & sed_type_size_class( t );
01433 }
01434
01435 double sed_type_is_size_class_with_data( Sed_type t , gpointer size )
01436 {
01437 return sed_type_is_size_class( t , *((Sed_size_class*)size) );
01438 }
01439
01440 double sed_type_sum_size_classes_with_data( Sed_type t , gpointer size )
01441 {
01442 Sed_size_class* c = (Sed_size_class*)size;
01443
01444 *c |= sed_type_size_class( t );
01445
01446 return 1.0;
01447 }
01448
01449 double sed_type_void_ratio_compacted( Sed_type t , gpointer d )
01450 {
01451 return (*(double*)d)*(1+sed_type_void_ratio(t)) - 1;
01452 }
01453
01454 double sed_type_density_compacted( Sed_type t , gpointer d )
01455 {
01456 double e = sed_type_void_ratio_compacted(t,d);
01457 return ( sed_type_rho_grain(t) + e*sed_rho_sea_water() ) / (1.+e);
01458 }
01459
01470 Sed_size_class
01471 sed_size_class( const double phi )
01472 {
01473 if ( phi <= S_SED_TYPE_VERY_FINE_SAND_PHI )
01474 return S_SED_TYPE_SAND;
01475 else if ( phi <= S_SED_TYPE_VERY_FINE_SILT_PHI )
01476 return S_SED_TYPE_SILT;
01477 else
01478 return S_SED_TYPE_CLAY;
01479 }
01480