END_TEST
START_TEST ( test_approx_deposit_nd )
{
gssize i;
double* dep;
gssize len = 1000;
double* x = eh_new( double , len );
for ( i=0 ; i<len ; i++ )
x[i] = i/10.;
dep = plume_centerline_deposit_nd( NULL , x , len , 1. );
fail_if( dep==NULL , "Deposit array should be created" );
for ( i=0 ; i<len ; i++ )
{
fail_unless( ~eh_isnan(dep[i]) , "Deposit thickness is non-NaN" );
fail_unless( dep[i]>=0 , "Deposit thickness is positive" );
}
eh_free( dep );
eh_free( x );
}
void free_dmatrix( double **m )
{
if ( m )
{
eh_free( m[0] );
eh_free( m );
}
}
void free_d3tensor( double ***t )
{
if ( t )
{
if ( t[0] )
{
eh_free( t[0][0] );
eh_free( t[0] );
}
eh_free( t );
}
}
/** Destroy an Eh_input_val
\param val An Eh_input_val that was created with eh_create_input_val.
\see eh_create_input_val.
*/
Eh_input_val
eh_input_val_destroy( Eh_input_val val )
{
if (val)
{
eh_free (val->x);
eh_free (val->y);
eh_free (val->file);
g_rand_free (val->rand);
eh_free (val);
}
return NULL;
}
/** Destroy a CSDMSComp
\param[in,out] c A CSDMSComp
\return NULL
*/
CSDMSComp*
csdms_comp_destroy( CSDMSComp* c )
{
if ( c ) eh_free( c );
return NULL;
}
void destroy_plume_data( Plume_data *grid )
{
if ( grid )
{
eh_free( grid->xval );
eh_free( grid->yval );
free_d3tensor( grid->ccnc );
free_d3tensor( grid->ncnc );
free_d3tensor( grid->deps );
free_d3tensor( grid->dist );
free_dmatrix ( grid->ualb );
free_dmatrix ( grid->pcent );
eh_free( grid );
}
}
END_TEST
START_TEST ( test_approx_from_file )
{
gssize len = 1000;
double* x = eh_new( double , len );
double* dep = eh_new( double , len );
{
Sed_type this_type;
gssize n, i;
gssize n_grains = sed_sediment_env_n_types();
Sed_hydro_file f = sed_hydro_file_new( SED_HYDRO_TEST_FILE , SED_HYDRO_HYDROTREND , FALSE , TRUE , NULL );
Sed_hydro river;
double dt;
double l;
double* total = eh_new0( double , len );
for ( n=1 ; n<n_grains ; n++ )
{
this_type = sed_sediment_type( NULL , n );
for ( dt=0 ; dt<365 ; )
{
river = sed_hydro_file_read_record( f );
l = plume_non_dim_lambda( sed_type_lambda(this_type) , river );
for ( i=0 ; i<len ; i++ )
x[i] = plume_non_dim_distance( i*100 , river );
dt += sed_hydro_duration( river );
if ( dt <= 365 )
dep = plume_centerline_deposit_nd( dep , x , len , l );
eh_dbl_array_add_each( total , len , dep );
sed_hydro_destroy( river );
}
}
sed_hydro_file_destroy( f );
eh_free( total );
}
eh_free( x );
eh_free( dep );
}
gboolean
parse_data_list( const gchar* name , const gchar* value , gpointer data , GError** error )
{
gboolean success = FALSE;
Sakura_var* data_id = NULL;
eh_return_val_if_fail( error==NULL || *error==NULL , FALSE );
if ( name && value )
{
GError* tmp_err = NULL;
gchar** data_list = g_strsplit( value , "," , 0 );
if ( !data_list )
{
g_set_error( &tmp_err ,
G_OPTION_ERROR ,
G_OPTION_ERROR_FAILED ,
"Failed to parse comma-separated list of data values to monitor" );
}
else
{
gchar** key;
Sakura_var id;
gint i;
data_id = eh_new( Sakura_var , g_strv_length( data_list )+1 );
for ( key=data_list,i=0 ; *key && !tmp_err ; key++,i++ )
{
id = eh_strv_find( _DATA_VAL_KEYS , *key );
data_id[i] = id;
if ( id<0 )
g_set_error( &tmp_err ,
G_OPTION_ERROR ,
G_OPTION_ERROR_FAILED ,
"Invalid data key (%s)" , *key );
}
data_id[i] = -1;
}
if ( tmp_err )
{
g_propagate_error( error , tmp_err );
eh_free( data_id );
data_id = NULL;
success = FALSE;
}
else
success = TRUE;
}
_data_id = data_id;
return success;
}
END_TEST
START_TEST ( test_set_input_val )
{
Eh_input_val v;
{
GError* err = NULL;
v = eh_input_val_set( "-.5" , &err );
if ( err!=NULL )
fprintf( stderr , "%s" , err->message );
fail_unless( eh_input_val_eval(v)==-.5 , "Scalar value set incorrectly" );
v = eh_input_val_destroy( v );
g_clear_error( &err );
}
{
gssize n_evals = 100000;
gssize i;
double* vals = eh_new( double , n_evals );
double mean, var;
GError* err = NULL;
v = eh_input_val_set( "normal=-.5,.1" , &err );
if ( err!=NULL )
fprintf( stderr , "%s" , err->message );
for ( i=0 ; i<n_evals ; i++ )
vals[i] = eh_input_val_eval( v );
mean = eh_dbl_array_mean( vals , n_evals );
var = eh_dbl_array_var ( vals , n_evals );
fail_unless( eh_compare_dbl(mean,-.5,.01) , "Normal distribution mean set incorrectly" );
fail_unless( eh_compare_dbl(sqrt(var),.1,.01) , "Normal distribution variance set incorrectly" );
eh_free( vals );
v = eh_input_val_destroy( v );
g_clear_error( &err );
}
/*
{
v = eh_input_val_set( "user=user_test.txt" );
fail_if( v==NULL , "Could not read user file" );
v = eh_input_val_destroy( v );
}
*/
}
gboolean
destroy_erosion( Sed_process p )
{
if ( p )
{
Erosion_t* data = (Erosion_t*)sed_process_user_data( p );
if ( data ) eh_free( data );
}
return TRUE;
}
Sed_cell
erode_river_profile( Sed_cube p , Sed_riv r , double slope , gint method )
{
Sed_cell eroded_sed = NULL;
if ( p && r )
{
gint* river_path = sed_cube_river_path_id( p , r , TRUE );
eh_require( river_path );
if ( river_path )
{
Sed_cube river_profile = sed_cube_cols( p , river_path );
Sed_hydro river_data = sed_river_hydro( r );
eh_require( river_data );
eh_require( river_profile );
if ( sed_mode_is_3d() )
{
sed_cube_set_x_res( river_profile , 1. );
sed_cube_set_y_res( river_profile , .5*(sed_cube_x_res(p)+sed_cube_y_res(p)) );
}
else
{
sed_cube_set_x_res( river_profile , sed_cube_x_res(p) );
sed_cube_set_y_res( river_profile , sed_cube_y_res(p) );
}
switch ( method )
{
case EROSION_ALGORITHM_DIFFUSION:
eroded_sed = diffuse_profile( river_profile , river_data ); break;
case EROSION_ALGORITHM_SLOPE:
eroded_sed = erode_profile ( river_profile , slope ); break;
default:
eh_require_not_reached();
}
sed_hydro_add_cell( river_data , eroded_sed );
sed_river_set_hydro( r , river_data );
sed_hydro_destroy( river_data );
eh_free ( river_path );
sed_cube_free ( river_profile , FALSE );
}
}
return eroded_sed;
}
void
eh_set_error_strv( GError** error , GQuark domain , gint code , gchar** err_s )
{
if ( err_s && *err_s )
{
gchar* str = g_strjoinv( "\n" , err_s );
g_set_error( error , domain , code , "%s" , str );
eh_free( str );
}
return;
}
gboolean
destroy_bioturbation( Sed_process p )
{
if ( p )
{
Bioturbation_t* data = sed_process_user_data( p );
if ( data )
{
eh_input_val_destroy( data->k );
eh_input_val_destroy( data->depth );
eh_free ( data );
}
}
return TRUE;
}
gboolean
destroy_xshore( Sed_process p )
{
if ( p )
{
Xshore_t* data = (Xshore_t*)sed_process_user_data( p );
if ( data )
{
eh_input_val_destroy( data->xshore_current );
eh_free ( data );
}
}
return TRUE;
}
void
eh_print_on_error( GError* error , const gchar* format , ... )
{
if ( error )
{
gchar* err_s;
va_list ap;
va_start( ap , format );
err_s = g_strdup_vprintf( format , ap );
eh_error( eh_render_error_str( error , err_s ) );
va_end(ap);
eh_free( err_s );
}
}
void supla_client_clean(void *_suplaclient) {
TSuplaClientData *suplaclient = (TSuplaClientData *)_suplaclient;
if ( suplaclient ) {
if ( suplaclient->eh ) {
eh_free(suplaclient->eh);
suplaclient->eh = NULL;
}
if ( suplaclient->srpc ) {
srpc_free(suplaclient->srpc);
suplaclient->srpc = NULL;
}
}
}
END_TEST
START_TEST ( test_compact_mixed )
{
Sed_column c = sed_column_new( 5 );
Sed_cell cell;
{
double* f = eh_new0( double , sed_sediment_env_n_types() );
gssize n;
for ( n=0 ; n<sed_sediment_env_n_types() ; n++ )
f[n] = 1./(double)sed_sediment_env_n_types();
cell = sed_cell_new_sized( sed_sediment_env_n_types() , 30000 , f );
eh_free( f );
}
sed_column_set_sea_level ( c , 10 );
sed_column_set_base_height( c , -40000 );
sed_column_add_cell( c , cell );
{
double mass_out;
double mass_in = sed_column_sediment_mass(c);
compact( c );
mass_out = sed_column_sediment_mass(c);
fail_unless( eh_compare_dbl( mass_in , mass_out , 1e-12 ) , "Mass balance error in compaction" );
}
{
Sed_cell cell_0 = sed_column_nth_cell( c , 0 );
double e_min = sed_cell_void_ratio_min( cell_0 );
double e = sed_cell_void_ratio ( cell_0 );
fail_unless( eh_compare_dbl( e_min , e , 1e-5 ) , "Cell did not reach maximum compaction" );
}
sed_cell_destroy ( cell );
sed_column_destroy( c );
}
void
my_hook( Sed_process_queue q )
{
if ( q )
{
gssize i;
Failure_proc_t** data;
Sed_process d = sed_process_queue_find_nth_obj( q , "debris flow" , 0 );
Sed_process t = sed_process_queue_find_nth_obj( q , "turbidity current" , 0 );
Sed_process s = sed_process_queue_find_nth_obj( q , "slump" , 0 );
data = (Failure_proc_t**)sed_process_queue_obj_data( q , "failure" );
for ( i=0 ; data && data[i] ; i++ )
{
data[i]->debris_flow = d;
data[i]->turbidity_current = t;
data[i]->slump = s;
}
eh_free( data );
}
return;
}
Sed_cell
diffuse_profile( Sed_cube river_profile , Sed_hydro river_data )
{
Sed_cell eroded_sed = NULL;
eh_require( river_profile );
if ( river_profile )
{
double time_fraction = 1e-0;
double dt = sed_cube_time_step_in_days( river_profile );
double width = sed_cube_x_res( river_profile );
Sed_cell* lost_cell = NULL;
double k_land;
k_land = get_paola_diffusion( river_data , width , time_fraction , PAOLA_BRAIDED )
* S_SECONDS_PER_DAY
* sed_cube_storm( river_profile );
// k_land = 200;
// dt = 15;
/*
eh_message( "diffusion coefficient : %.3e m^2/day" , k_land );
eh_message( "time step : %.3e days" , dt );
*/
lost_cell = diffuse_sediment( river_profile , k_land ,
0 , dt ,
DIFFUSION_OPT_LAND|DIFFUSION_OPT_FILL );
// convert time step to seconds.
// dt = sed_get_profile_time_step_in_seconds(p);
if ( lost_cell )
{
double dx = sed_cube_y_res ( river_profile );
double river_width = sed_hydro_width( river_data );
/* The volume of sediment diffused through the right boundary. This
is the sediment that has made it to the ocean. */
// volume_eroded = sed_cell_size(lost_cell[1])*dx*river_width;
/* Bedload may have been added along the profile ([3]). Remove this from the sediment
that is diffused through the right boundary ([1]). */
sed_cell_separate_cell( lost_cell[1] , lost_cell[3] );
// dt *= S_SECONDS_PER_DAY;
eroded_sed = sed_cell_new_env();
sed_cell_add ( eroded_sed , lost_cell[1] );
sed_cell_add ( eroded_sed , lost_cell[2] );
sed_cell_resize( eroded_sed , sed_cell_size(eroded_sed)*dx*river_width );
/*
// Add suspended sediment to the river
sed_hydro_add_cell( river_data , lost_cell[2] , volume_eroded );
// Add sediment diffused out of the right boundary to the river
sed_hydro_add_cell( river_data , lost_cell[1] , volume_eroded );
*/
sed_cell_destroy( lost_cell[0] );
sed_cell_destroy( lost_cell[1] );
sed_cell_destroy( lost_cell[2] );
sed_cell_destroy( lost_cell[3] );
eh_free( lost_cell );
}
// eh_message( "eroded sediment (m^3): %.3g" , volume_eroded );
}
return eroded_sed;
}
svr_ipcctrl::~svr_ipcctrl() {
if ( sfd != -1 )
close(sfd);
eh_free(eh);
}
Sed_process_info
run_erosion( Sed_process proc , Sed_cube p )
{
Erosion_t* data = (Erosion_t*)sed_process_user_data(proc);
Sed_process_info info = SED_EMPTY_INFO;
Sed_riv* all;
// for ( this_river=sed_cube_river_list(p) ; this_river ; this_river=this_river->next )
/*
for ( n=0,this_river = sed_cube_nth_river(p,n) ;
n<n_rivers ;
n++,this_river = sed_cube_nth_river(p,n) )
*/
all = sed_cube_all_leaves( p );
if ( all )
{
Sed_riv* r;
Sed_cell eroded_sed = NULL;
for ( r=all ; *r ; r++ )
{
eh_message( "Eroding along river %s" , sed_river_name_loc( *r ) );
eroded_sed = erode_river_profile( p , *r , data->slope , data->method );
sed_cell_destroy( eroded_sed );
/*
river_path = sed_cube_river_path_id( p , *r , TRUE );
river_profile = sed_cube_cols( p , river_path );
if ( sed_mode_is_3d() )
{
sed_cube_set_x_res( river_profile , 1. );
sed_cube_set_y_res( river_profile , .5*(sed_cube_x_res(p)+sed_cube_y_res(p)) );
}
else
{
sed_cube_set_x_res( river_profile , sed_cube_x_res(p) );
sed_cube_set_y_res( river_profile , sed_cube_y_res(p) );
}
eh_free( river_path );
// river_data = ((Sed_river*)(this_river->data))->data;
river_data = sed_river_hydro( *r );
if ( data->method == EROSION_ALGORITHM_DIFFUSION )
eroded_sed = diffuse_profile( river_profile , river_data );
else
eroded_sed = erode_profile( river_profile , river_data );
sed_hydro_add_cell( river_data , eroded_sed );
sed_river_set_hydro( *r , river_data );
sed_hydro_destroy ( river_data );
sed_cube_free( river_profile , FALSE );
*/
/*
if ( data->method == EROSION_ALGORITHM_DIFFUSION )
{
dt = sed_cube_time_step_in_days( river_profile );
// time_fraction = 1e-1;
time_fraction = 1e-0;
if ( sed_mode_is_3d() )
basin_width = sed_cube_x_res( river_profile );
else
basin_width = sed_cube_x_res( p );
k_land = get_paola_diffusion( river_data , basin_width ,
time_fraction , PAOLA_BRAIDED )
* S_SECONDS_PER_DAY;
k_land *= sed_cube_storm( river_profile );
// k_land = 200;
// dt = 15;
eh_message( "diffusion coefficient : %.3e m^2/day" , k_land );
eh_message( "time step : %.3e days" , dt );
lost_cell = diffuse_sediment( river_profile , k_land ,
0 , dt ,
DIFFUSION_OPT_LAND|DIFFUSION_OPT_FILL );
// convert time step to seconds.
// dt = sed_get_profile_time_step_in_seconds(p);
if ( lost_cell )
{
dx = sed_cube_y_res( river_profile );
width = sed_hydro_width( river_data );
// add the eroded sediment to the river discharge.
volume_eroded = sed_cell_size(lost_cell[1])*dx*width;
sed_cell_separate_cell( lost_cell[1] , lost_cell[3] );
dt *= S_SECONDS_PER_DAY;
sed_hydro_add_cell( river_data , lost_cell[2] , volume_eroded );
sed_hydro_add_cell( river_data , lost_cell[1] , volume_eroded );
sed_cell_destroy( lost_cell[0] );
sed_cell_destroy( lost_cell[1] );
sed_cell_destroy( lost_cell[2] );
sed_cell_destroy( lost_cell[3] );
eh_free( lost_cell );
}
eh_message( "eroded sediment (m^3): %.3g" , volume_eroded );
}
else
{
eroded_fraction = eh_new( double , n_grains );
for (i=0;i<n_grains;i++)
eroded_fraction[i] = 1.;
total = sed_cell_new( n_grains );
eroded = sed_cell_new( n_grains );
if ( sed_cube_river_mouth_1d( river_profile )<0 )
return info;
dx = sed_cube_y_res( river_profile );
width = sed_cube_x_res( river_profile );
i_river = sed_cube_river_mouth_1d( river_profile ) - 1;
if ( i_river < 0 )
return info;
river_height = sed_cube_top_height(river_profile,0,i_river);
// log_const = getLogConstants( OMEGA_DELTA ,
// data->stream_relief ,
// data->stream_reach);
linear_const = get_linear_constants( data->stream_relief
/ data->stream_reach );
for (i=i_river-1;i>=0;i--)
{
x = (i-i_river)*dx;
// height = getLogHeight(x,log_const) + river_height;
height = get_linear_height( x , linear_const ) + river_height;
eroded_height = sed_cube_top_height(river_profile,0,i)-height;
if ( eroded_height > 1e-12 )
{
sed_column_extract_top( sed_cube_col(river_profile,i) ,
eroded_height ,
eroded);
sed_cell_add( total , eroded );
}
}
if ( sed_cube_river_mouth_1d( river_profile )<0 )
return info;
// convert time step to seconds.
dt = sed_cube_time_step_in_seconds( river_profile );
// add the eroded sediment to the river discharge.
// river_data = sed_cube_river_data( river_profile );
volume_eroded = sed_cell_size(total)*dx*width;
sed_hydro_add_cell( river_data , total , volume_eroded );
eh_message( "eroded sediment (m^3): %.3g" , volume_eroded );
sed_cell_destroy( eroded );
sed_cell_destroy( total );
eh_free( eroded_fraction );
}
sed_river_set_hydro( *r , river_data );
sed_hydro_destroy ( river_data );
sed_cube_free( river_profile , FALSE );
*/
}
eh_free( all );
}
return info;
}
gint
plumeout2( Plume_enviro* env ,
Plume_grid* grid ,
double dx ,
double** deposit ,
int deposit_len ,
int n_grains ,
double basin_width )
{
double *deposit_thickness, *deposit_int;
double *deposit_x;
double mass_in, mass_out;
int ii, jj, nn;
Plume_river river = *(env->river);
Plume_sediment *sedload = env->sed;
deposit_thickness = eh_new( double , grid->lx );
deposit_int = eh_new( double , deposit_len );
deposit_x = eh_new( double , deposit_len );
//---
// initialize the x-coordinate for each deposit location. this is where
// where we want to calculate the sedimentation rates. we will interpolate
// plume's grid to this one.
//---
for ( ii=0 ; ii<deposit_len ; ii++ )
deposit_x[ii] = ii*dx;
//---
// here we average the 2d plume grid row by row so that we obtain an
// average sedimentation rate that we use as the centerline average.
// we then interpolate this 1d array to the points that are specified
// as input (a constant spacing of dx).
//
// we also calculate the sediment mass that was input (for each grain
// size) and the mass the is output. if there is a difference, we scale
// the output mass to assure that mass is balanced. we assume that any
// discrepancy is a result of small numerical errors.
//---
for ( nn=0 ; nn<env->n_grains ; nn++ )
{
mass_in = river.Cs[nn]*river.Q*dTOs;
// Determine the centerline average for each grain size
for( ii=0 ; ii<grid->lx ; ii++ )
{
deposit_thickness[ii] = 0.0;
for( jj=0 ; jj<grid->ly ; jj++ )
deposit_thickness[ii] += grid->deps[ii][jj][nn];
deposit_thickness[ii] /= grid->ly;
}
// Interpolate to the requested grid.
interpolate( grid->xval ,
deposit_thickness ,
grid->lx ,
deposit_x ,
deposit_int ,
deposit_len );
for( ii=0, mass_out=0 ; ii<deposit_len ; ii++ )
if ( !isnan(deposit_int[ii]) )
mass_out += deposit_int[ii]*sedload[nn].rho;
else
deposit_int[ii] = 0.;
mass_out *= basin_width*dx;
// Need to swap these arrays for sedflux. While we are it, scale the
// interpolated deposit for mass balance.
if ( mass_out > 0 )
for (ii=0;ii<deposit_len;ii++)
deposit[ii][nn] = deposit_int[ii];
//deposit[ii][nn] = deposit_int[ii]*(mass_in/mass_out);
else
eh_require_not_reached();
eh_watch_dbl( mass_in );
mass_out = 0;
for (ii=0;ii<deposit_len;ii++)
mass_out += deposit_int[ii]*dx*basin_width*sedload[nn].rho;
eh_watch_dbl( mass_out );
}
eh_free( deposit_x );
eh_free( deposit_thickness );
eh_free( deposit_int );
return 0;
} // end of PlumeOut2
END_TEST
/*
START_TEST ( test_plume_from_file )
{
Plume_inputs plume_const;
Plume_data plume_data;
Eh_dbl_grid* deposit;
plume_const.current_velocity = 0.;
plume_const.ocean_concentration = 0.;
plume_const.plume_width = 3000.;
plume_const.ndx = 1;
plume_const.ndy = 3;
plume_data_init( &plume_data );
{
gssize n;
deposit = eh_new( Eh_dbl_grid , 4 );
for ( n=0 ; n<4 ; n++ )
{
deposit[n] = eh_grid_new( double , 2 , 800 );
eh_grid_set_x_lin( deposit[n] , -30000 , 30000 );
eh_grid_set_y_lin( deposit[n] , 0 , 100 );
}
}
{
Sed_hydro_file f = sed_hydro_file_new( SED_HYDRO_TEST_FILE , HYDRO_HYDROTREND , TRUE );
Sed_hydro river;
double dt;
for ( dt=0 ; dt<365 ; )
{
river = sed_hydro_file_read_record( f );
dt += sed_hydro_duration( river );
if ( dt <= 365 )
plume_3d( &plume_const , river , sed_sediment_env() , deposit , &plume_data );
sed_hydro_destroy( river );
}
sed_hydro_file_destroy( f );
}
}
END_TEST
*/
START_TEST ( test_i_bar )
{
gssize n_x = 1000;
double x_max = 40;
double dy = x_max/n_x;
// double dy = .1;
double l = .087;
double** i_bar;
double* x = eh_linspace( 0 , x_max , n_x );
gssize n_y;
i_bar = plume_i_bar( x , n_x , l , &n_y , dy);
{
gssize i, j;
for ( i=0 ; i<n_x ; i++ )
{
for ( j=0 ; j<n_y ; j++ )
fprintf( stderr , "%g, " , i_bar[i][j] );
fprintf( stderr , "\n" );
}
}
eh_free( x );
eh_free( i_bar[0] );
eh_free( i_bar );
}
Sed_process_info
run_xshore( Sed_process proc , Sed_cube prof )
{
Xshore_t* data = (Xshore_t*)sed_process_user_data(proc);
Sed_process_info info = SED_EMPTY_INFO;
double dt;
double start_time, end_time, current_time;
double xshore_current;
double this_sea_level;
double mass_before, mass_after, mass_added, mass_lost;
Sed_cell *lost = NULL;
Sed_cell along_shore_sediment;
Sed_ocean_storm this_storm;
GSList *this_link;
Xshore_info x_info;
if ( sed_process_run_count(proc)==0 )
init_xshore_data( proc , prof , NULL );
if ( sed_mode_is_3d() )
return info;
start_time = data->last_time;
end_time = sed_cube_age_in_years( prof );
dt = end_time - start_time;
data->last_time = sed_cube_age_in_years( prof );
{
double *along_shore_fraction = eh_new0( double , sed_sediment_env_n_types() );
along_shore_fraction[data->sediment_type] = 1.;
along_shore_sediment = sed_cell_new_env( );
sed_cell_set_fraction( along_shore_sediment ,
along_shore_fraction );
eh_free( along_shore_fraction );
}
// dt = sed_cube_time_step( prof );
current_time = start_time;
sed_cube_set_age( prof , start_time );
for ( this_link=sed_cube_storm_list( prof ) ;
this_link ;
this_link=this_link->next )
{
double storm_wave;
double max_current = eh_input_val_eval( data->xshore_current ,
current_time );
mass_before = sed_cube_mass( prof );
this_storm = (Sed_ocean_storm)this_link->data;
storm_wave = sed_ocean_storm_wave_height( this_storm );
xshore_current = max_current*0.5*storm_wave;
eh_clamp( xshore_current , 0 , max_current );
this_sea_level = sed_cube_sea_level( prof );
sed_cube_adjust_sea_level( prof , storm_wave*.5 );
// if ( sed_cube_time_step_in_days( prof ) > 3. )
// sed_cube_set_time_step( prof , 3./S_DAYS_PER_YEAR );
// if ( sed_cube_wave_height( prof ) > .1 )
if ( is_worth_running( this_storm ) )
{
x_info = xshore( prof ,
along_shore_sediment ,
xshore_current ,
this_storm );
}
else
{
x_info.added = NULL;
x_info.lost = NULL;
x_info.dt = NULL;
}
sed_cube_set_sea_level( prof , this_sea_level );
eh_message( "time : %f" , current_time );
if ( TRUE )
{
if ( x_info.added )
{
mass_added = sed_cell_mass( x_info.added )
* sed_cube_x_res( prof )
* sed_cube_y_res( prof );
mass_lost = sed_cell_mass( x_info.lost )
* sed_cube_x_res( prof )
* sed_cube_y_res( prof );
// sed_cell_resize( info.added , sed_cell_thickness(info.added)*2 );
// sed_cell_add( sed_cube_to_remove(prof) , info.added );
}
else
{
mass_added = 0;
mass_lost = 0;
x_info.bruun_a = 0;
x_info.bruun_m = 0;
x_info.bruun_h_b = 0;
x_info.bruun_y_0 = 0;
x_info.bruun_y_b = 0;
x_info.z_0 = 0;
}
info.mass_added = mass_added;
info.mass_lost = mass_lost;
mass_after = sed_cube_mass( prof );
eh_message( "time step (days) : %f" , sed_ocean_storm_duration(this_storm) );
eh_message( "cross shore current (m/s) : %f" , xshore_current );
eh_message( "incoming wave height (m) : %f" , sed_ocean_storm_wave_height( this_storm ) );
eh_message( "closure depth (m) : %f" , x_info.z_0 );
eh_message( "Bruun a (-) : %f" , x_info.bruun_a );
eh_message( "Bruun m (-) : %f" , x_info.bruun_m );
eh_message( "Bruun closure depth (m) : %f" , x_info.bruun_h_b );
eh_message( "Bruun start (m) : %f" , x_info.bruun_y_0 );
eh_message( "Bruun end (m) : %f" , x_info.bruun_y_b );
// eh_message( "along shore sediment added (kg) : %f" , sed_cell_mass( info.added ) );
// eh_message( "sediment lost (kg) : %f" , sed_cell_mass( info.lost ) );
eh_message( "mass before (kg) : %f" , mass_before );
eh_message( "mass after (kg) : %f" , mass_after );
eh_message( "mass added (kg) : %f" , mass_added );
eh_message( "mass balance (kg) : %f" , (mass_after-mass_added)-mass_before );
sed_cell_destroy( x_info.added );
sed_cell_destroy( x_info.lost );
eh_free( x_info.dt );
lost = NULL;
}
else
{
eh_message( "time step (days) : %f" , sed_ocean_storm_duration(this_storm) );
eh_message( "cross shore current (m/s) : %f" , xshore_current );
eh_message( "incoming wave height (m) : %f" , sed_ocean_storm_wave_height( this_storm ) );
eh_message( "along shore sediment added (kg) : %f" , 0. );
eh_message( "total sediment moved (kg) : %f" , 0. );
}
current_time += sed_ocean_storm_duration(this_storm)*S_YEARS_PER_DAY;
sed_cube_set_age( prof , current_time );
}
// sed_cube_set_time_step( prof , dt );
sed_cube_set_age( prof , end_time );
sed_cell_destroy( along_shore_sediment );
return info;
}
Sed_wave sed_wave_destroy( Sed_wave w )
{
if ( w )
eh_free( w );
return NULL;
}
