/Users/huttone/Devel/sedflux-new/sedflux/trunk/ew/sedflux/run_river.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 #define SED_RIVER_PROC_NAME "river"
00022 #define EH_LOG_DOMAIN SED_RIVER_PROC_NAME
00023 
00024 #include <stdio.h>
00025 #include <fcntl.h>
00026 #include <limits.h>
00027 #include <string.h>
00028 #include <utils/utils.h>
00029 #include <sed/sed_sedflux.h>
00030 #include "my_processes.h"
00031 #include "sedflux.h"
00032 
00033 gboolean init_river_data( Sed_process proc , Sed_cube prof , GError** error );
00034 
00035 Sed_process_info
00036 run_river( Sed_process proc , Sed_cube prof )
00037 {
00038    River_t*         data = sed_process_user_data(proc);
00039    Sed_process_info info = SED_EMPTY_INFO;
00040    Sed_hydro        river_data;
00041 
00042    if ( sed_process_run_count(proc)==0 )
00043       init_river_data( proc , prof , NULL );
00044 
00045    river_data = sed_hydro_file_read_record( data->fp_river );
00046 
00047    if ( river_data )
00048    {
00049       gint i;
00050       double dt, volume, volume_to_remove, mass_removed;
00051       double susp_mass, bedload_mass, init_susp_mass, init_bedload_mass;
00052 
00053       //---
00054       // Set the cube time step to be that of the river.
00055       //---
00056 //      if ( data->type & (HYDRO_USE_BUFFER|HYDRO_INLINE) )
00057       if ( data->type==SED_HYDRO_INLINE || data->buffer_is_on )
00058          sed_cube_set_time_step( prof , 
00059                                  sed_hydro_duration_in_seconds(river_data)/S_SECONDS_PER_YEAR );
00060       dt = sed_cube_time_step_in_seconds( prof );
00061 
00062       //---
00063       // Keep a running total of the sediment mass added from the river.
00064       // This exludes erosion/deposition within the river.
00065       //---
00066       data->total_mass_from_river += sed_hydro_total_load( river_data );
00067 
00068       init_susp_mass         = sed_hydro_suspended_flux( river_data )*dt;
00069       init_bedload_mass      = sed_hydro_bedload       ( river_data )*dt;
00070 
00071       //---
00072       // Add any eroded sediment to the river.
00073       //---
00074       volume = sed_cube_x_res( prof )
00075              * sed_cube_y_res( prof )
00076              * sed_cell_size( sed_cube_to_add(prof) );
00077 
00078       sed_cell_resize   ( sed_cube_to_add(prof) , volume );
00079 
00080       sed_hydro_add_cell( river_data , sed_cube_to_add(prof) );
00081       sed_cell_clear    ( sed_cube_to_add(prof) );
00082 
00083       //---
00084       // Remove any sediment that was deposited within the river.
00085       //---
00086       volume_to_remove = sed_cube_x_res( prof )
00087                        * sed_cube_y_res( prof )
00088                        * sed_cell_size( sed_cube_to_remove(prof) );
00089 
00090       sed_cell_resize        ( sed_cube_to_remove(prof) , volume_to_remove );
00091       sed_hydro_subtract_cell( river_data , sed_cube_to_remove(prof) );
00092       sed_cell_clear         ( sed_cube_to_remove(prof) );
00093 
00094       susp_mass         = sed_hydro_suspended_flux( river_data )*dt;
00095       bedload_mass      = sed_hydro_bedload       ( river_data )*dt;
00096       data->total_mass += susp_mass + bedload_mass;
00097 
00098       mass_removed     = susp_mass+bedload_mass - (init_susp_mass+init_bedload_mass);
00099 
00100       sed_river_set_hydro( data->this_river , river_data );
00101 
00102       eh_message( "time         : %f" , sed_cube_age_in_years(prof) );
00103       eh_message( "duration     : %f" , sed_cube_time_step_in_years(prof) );
00104       eh_message( "velocity     : %f" , sed_hydro_velocity(river_data) );
00105       eh_message( "width        : %f" , sed_hydro_width   (river_data) );
00106       eh_message( "depth        : %f" , sed_hydro_depth   (river_data) );
00107       eh_message( "bedload      : %f" , sed_hydro_bedload (river_data) );
00108       for ( i=0 ; i<sed_hydro_size(river_data) ; i++ )
00109          eh_message( "conc[%d]      : %f" , i , sed_hydro_nth_concentration(river_data,i) );
00110       eh_message( "eroded sediment added (m^3): %g"        , volume );
00111       eh_message( "sediment removed (kg): %g"              , mass_removed );
00112       eh_message( "suspended mass (kg): %g"                , susp_mass );
00113       eh_message( "bedload mass (kg): %g"                  , bedload_mass );
00114       eh_message( "total sediment added to basin (kg): %g" , data->total_mass );
00115       eh_message( "total sediment added to river (kg): %g" , data->total_mass_from_river );
00116 
00117 // NOTE: this will be freed when the river file is closed.
00118 //      hydro_destroy_hydro_record( river_data );
00119 //      river_data = NULL;
00120 
00121    }
00122    else
00123       eh_require_not_reached();
00124 
00125    sed_hydro_destroy( river_data );
00126 
00127    return info;
00128 }
00129 
00130 #define RIVER_KEY_FILE_TYPE  "river values"
00131 #define RIVER_KEY_RIVER_FILE "river file"
00132 #define RIVER_KEY_RIVER_NAME "river name"
00133 
00134 static gchar* river_req_labels[] =
00135 {
00136    RIVER_KEY_FILE_TYPE  ,
00137    RIVER_KEY_RIVER_FILE ,
00138    RIVER_KEY_RIVER_NAME ,
00139    NULL
00140 };
00141 
00142 gboolean
00143 init_river( Sed_process p , Eh_symbol_table tab , GError** error )
00144 {
00145    River_t* data    = sed_process_new_user_data( p , River_t );
00146    GError*  tmp_err = NULL;
00147    gboolean is_ok   = TRUE;
00148    gchar*   str;
00149 
00150    eh_return_val_if_fail( error==NULL || *error==NULL , FALSE );
00151 
00152    data->total_mass            = 0;
00153    data->total_mass_from_river = 0;
00154    data->fp_river              = NULL;
00155    data->this_river            = NULL;
00156 
00157    if ( eh_symbol_table_require_labels( tab , river_req_labels , &tmp_err ) )
00158    {
00159       str              = eh_symbol_table_lookup( tab , RIVER_KEY_FILE_TYPE  );
00160       data->filename   = eh_symbol_table_value ( tab , RIVER_KEY_RIVER_FILE );
00161       data->river_name = eh_symbol_table_value ( tab , RIVER_KEY_RIVER_NAME );
00162 
00163       data->location     = 0;
00164       data->type         = 0;
00165       data->buffer_is_on = FALSE;
00166 
00167       data->type = sed_hydro_str_to_type( str );
00168 
00169       if (    g_ascii_strcasecmp( str , "EVENT"  )==0
00170            || g_ascii_strcasecmp( str , "BUFFER" )==0 
00171            && data->type == SED_HYDRO_HYDROTREND )
00172       {
00173          data->buffer_is_on = TRUE;
00174       }
00175 
00176       if ( data->type==SED_HYDRO_UNKNOWN )
00177          g_set_error( &tmp_err , SEDFLUX_ERROR , SEDFLUX_ERROR_BAD_PARAM ,
00178                       "Invalid river type key (season, hydrotrend, or event): %s" , str );
00179 
00180       if ( !tmp_err ) eh_touch_file( data->filename , O_RDONLY , &tmp_err );
00181 
00182       if ( !tmp_err )
00183       {
00184          Sed_hydro_file_type t = sed_hydro_file_guess_type( data->filename , &tmp_err );
00185 
00186          if ( !tmp_err )
00187          {
00188             if (    ( t==SED_HYDRO_HYDROTREND_BE && G_BYTE_ORDER!=G_BIG_ENDIAN    )
00189                  || ( t==SED_HYDRO_HYDROTREND_LE && G_BYTE_ORDER!=G_LITTLE_ENDIAN ) )
00190                g_set_error( &tmp_err , SEDFLUX_ERROR , SEDFLUX_ERROR_BAD_FILE_TYPE ,
00191                             "Byte-order of river file type doesn't match machine's: "
00192                             "Machine is %s but file is %s" ,
00193                                G_BYTE_ORDER==G_BIG_ENDIAN?"big-endian":"little-endian" ,
00194                                G_BYTE_ORDER==G_BIG_ENDIAN?"little-endian":"big-endian" );
00195          }
00196 
00197          if ( t==SED_HYDRO_HYDROTREND_BE || t==SED_HYDRO_HYDROTREND_LE ) t = SED_HYDRO_HYDROTREND;
00198 
00199          if ( !tmp_err && t!=data->type )
00200          {
00201             if ( t==SED_HYDRO_UNKNOWN )
00202                g_set_error( &tmp_err , SEDFLUX_ERROR , SEDFLUX_ERROR_UNKNOWN_FILE_TYPE ,
00203                             "Could not determine file type of river file: %s" , data->filename );
00204             else
00205                g_set_error( &tmp_err , SEDFLUX_ERROR , SEDFLUX_ERROR_BAD_FILE_TYPE ,
00206                             "River file type doesn't match the specified type: "
00207                             "Specified type is %s but file is type %s" , sed_hydro_type_to_s(data->type) , sed_hydro_type_to_s(t) );
00208          }
00209       }
00210    }
00211 
00212    if ( tmp_err )
00213    {
00214       g_propagate_error( error , tmp_err );
00215       is_ok = FALSE;
00216    }
00217 
00218    return is_ok;
00219 }
00220 
00221 gboolean
00222 init_river_data( Sed_process proc , Sed_cube prof , GError** error )
00223 {
00224    River_t* data = sed_process_user_data( proc );
00225 
00226    if ( data )
00227    {
00228       data->total_mass            = 0;
00229       data->total_mass_from_river = 0;
00230       data->fp_river              = sed_hydro_file_new( data->filename , data->type , data->buffer_is_on , TRUE , error );
00231       data->this_river            = sed_river_new     ( data->river_name );
00232 
00233       eh_require( data->fp_river );
00234 
00235       sed_cube_add_trunk( prof , data->this_river );
00236    }
00237 
00238    return TRUE;
00239 }
00240 
00241 gboolean
00242 destroy_river( Sed_process p )
00243 {
00244    if ( p )
00245    {
00246       River_t* data = sed_process_user_data( p );
00247       
00248       if ( data )
00249       {
00250          sed_hydro_file_destroy( data->fp_river );
00251 
00252          eh_free( data->filename   );
00253          eh_free( data->river_name );
00254          eh_free( data             );
00255       }
00256    }
00257 
00258    return TRUE;
00259 }
00260 
00261 gboolean
00262 dump_river_data( gpointer ptr , FILE *fp )
00263 {
00264    River_t *data = (River_t*)ptr;
00265    guint len;
00266 
00267    fwrite( data , sizeof(River_t) , 1 , fp );
00268 
00269    len = strlen(data->filename)+1;
00270    fwrite( &len , sizeof(guint) , 1 , fp );
00271    fwrite( data->filename , sizeof(char) , len , fp );
00272 
00273    return TRUE;
00274 }
00275 
00276 gboolean load_river_data( gpointer ptr , FILE *fp )
00277 {
00278    River_t *data = (River_t*)ptr;
00279    guint len;
00280 
00281    fread( data , sizeof(River_t) , 1 , fp );
00282 
00283    fread( &len , sizeof(guint)   , 1 , fp );
00284    fread( data->filename , sizeof(char) , len , fp );
00285    
00286    return TRUE;
00287 }
00288 
00289 
00290 /***********************************************************************
00291 *                                                                      *
00292 * Function :                                                           *
00293 *                                                                      *
00294 *  READRIVER                                                           *
00295 *                                                                      *
00296 ***********************************************************************/
00297 
00298 /***********************************************************************
00299 *                                                                      *
00300 * Description :                                                        *
00301 *                                                                      *
00302 *  Read the river data for the next time step.  The data file in this  *
00303 *  case is the binary output file from HYDROTREND.                     *
00304 *                                                                      *
00305 ***********************************************************************/
00306 
00307 /***********************************************************************
00308 *                                                                      *
00309 * Formal parameters :                                                  *
00310 *                                                                      *
00311 *  runPrefix - The file name prefix for the river data file.           *
00312 *                                                                      *
00313 ***********************************************************************/
00314 
00315 /***********************************************************************
00316 *                                                                      *
00317 * Global Variables :                                                   *
00318 *                                                                      *
00319 *  NONE                                                                *
00320 *                                                                      *
00321 ***********************************************************************/
00322 
00323 /***********************************************************************
00324 *                                                                      *
00325 * Local Variables :                                                    *
00326 *                                                                      *
00327 *  hydroData   - Structure containing the river data for this time     *
00328 *                step.                                                 *
00329 *  hydroHeader - Structure containing the header for the data file.    *
00330 *  first_time  - Flag indicating if this is the first time through the *
00331 *                function.                                             *
00332 *  prefix      - The file name prefix for the data file.               *
00333 *  extension   - The file name extension for the data file.            *
00334 *  fpRiver     - Pointer to the data file.                             *
00335 *                                                                      *
00336 ***********************************************************************/
00337 
00338 #if defined(IGNORE)
00339 
00340 #include <stdio.h>
00341 #include <string.h>
00342 //#include <values.h>
00343 #include "hydro.h"
00344 
00345 Hydro_record *read_river(FILE *fpRiver)
00346 {
00347    Hydro_record *hydro_data;
00348    static Hydro_header hydro_header;
00349    
00350    if ( ftell(fpRiver) == 0 )
00351       hydro_header = readHydroHeader(fpRiver);
00352 
00353    hydro_data = hydro_create_hydro_record(hydro_header.nGrain);
00354 
00355    if ( readHydroRecord(fpRiver,hydro_data,hydro_header.nGrain) )
00356       return hydro_data;
00357    else
00358    {
00359       hydro_destroy_hydro_record(hydro_data);
00360       return NULL;
00361    }
00362 }
00363 
00364 /***********************************************************************
00365 *                                                                      *
00366 * Function :                                                           *
00367 *                                                                      *
00368 *  READRIVERINLINE                                                     *
00369 *                                                                      *
00370 ***********************************************************************/
00371 
00372 /***********************************************************************
00373 *                                                                      *
00374 * Description :                                                        *
00375 *                                                                      *
00376 *  Read the river data for the next time step.  The data file in this  *
00377 *  case is an ascii file.  An example file follows.                    *
00378 *                                                                      *
00379 ***********************************************************************/
00380 
00381 /***********************************************************************
00382 *                                                                      *
00383 * Formal parameters :                                                  *
00384 *                                                                      *
00385 *  fpRiver - Pointer to the input file.                                *
00386 *                                                                      *
00387 ***********************************************************************/
00388 
00389 /***********************************************************************
00390 *                                                                      *
00391 * Global Variables :                                                   *
00392 *                                                                      *
00393 *  NONE                                                                *
00394 *                                                                      *
00395 ***********************************************************************/
00396 
00397 /***********************************************************************
00398 *                                                                      *
00399 * Local Variables :                                                    *
00400 *                                                                      *
00401 *  line      - The next line read from the input file.                 *
00402 *  riverData - Structure of the river data for the next time step.     *
00403 *  val       - The next number value read from the input file.         *
00404 *  nGrains   - The number of grain types provided by the river (both   *
00405 *              suspended load and bedload.                             *
00406 *                                                                      *
00407 ***********************************************************************/
00408 
00409 /***********************************************************************
00410 *                                                                      *
00411 * Example input file:                                                  *
00412 *                                                                      *
00413 *  Number of Grains: 5                                                 *
00414 *  -- Grain #1 (bedload) ---                                           *
00415 *  Bulk Density (kg/m^3):      1850                                    *
00416 *  Grain Size (microns):       200                                     *
00417 *  Removal Rate (1/day):       50                                      *
00418 *  Diffusion coefficient (-):  .25                                     *
00419 *  -- Grain #2 ---*                                                    *
00420 *  Bulk Density (kg/m^3):      1750                                    *
00421 *  Grain Size (microns):       75                                      *
00422 *  Removal Rate (1/day):       16.8                                    *
00423 *  Diffusion coefficient (-):  .25                                     *
00424 *                                                                      *
00425 ***********************************************************************/
00426 
00427 #include <stdio.h>
00428 #include <string.h>
00429 //#include <values.h>
00430 #include "hydro.h"
00431 
00432 Hydro_record *read_river_inline(FILE *fpRiver)
00433 {
00434    char line[S_LINEMAX];
00435    Hydro_record *river_data;
00436    double val;
00437    int nGrains;
00438    
00439    if ( read_int_vector(fpRiver,&nGrains,1)!=1 )
00440       return NULL;
00441    
00442    river_data = hydro_create_hydro_record(nGrains-1);
00443    
00444    read_double_vector(fpRiver,&river_data->bedload,1);
00445    read_double_vector(fpRiver,river_data->conc,(int)(nGrains-1));
00446    read_double_vector(fpRiver,&river_data->velocity,1);
00447    read_double_vector(fpRiver,&river_data->width,1);
00448    read_double_vector(fpRiver,&river_data->depth,1);
00449 
00450    return river_data;
00451    
00452 }
00453 
00454 #endif

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