/Users/huttone/Devel/sedflux-new/sedflux/trunk/ew/sed/sed_sediment.c

Go to the documentation of this file.
00001 //---
00002 //
00003 // This file is part of sedflux.
00004 //
00005 // sedflux is free software; you can redistribute it and/or modify
00006 // it under the terms of the GNU General Public License as published by
00007 // the Free Software Foundation; either version 2 of the License, or
00008 // (at your option) any later version.
00009 //
00010 // sedflux is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU General Public License
00016 // along with sedflux; if not, write to the Free Software
00017 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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 //   else
00164 //      eh_warning( "A sediment environment has not been set" );
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 //         sed = sed_sediment_insert_sorted( sed , new_type   );
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    double e = sed_type_void_ratio( t );
01090    return ( sed_type_rho_grain(t) + e*sed_rho_sea_water() ) / (1+e);
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; // An assumed shape factor
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 double sed_type_friction_angle( const Sed_sediment t )
01270 {
01271    double phi        = 36.;
01272    double grain_size = sed_type_grain_size( t );
01273 
01274    if ( grain_size >= 2e-3 )
01275       phi -= 11;
01276    else if ( grain_size >= .6e-3 )
01277       phi -= 9;
01278    else if ( grain_size >= .2e-3 )
01279       phi -= 4;
01280 
01281    return phi;
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 // return load * tan(sed_cell_friction_angle(c,sed,n)*M_PI/180.) - sed_cell_shear_strength(c,load,sed,n);
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 

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