/Users/huttone/Devel/sedflux-new/sedflux/trunk/ew/plume/plumemass.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 /*
00022  * PlumeMass    Calculate mass balance checks for PLUME
00023  *
00024  *      Author:         M.D. Morehead
00025  *      Original:       May 1998
00026  *
00027  */
00028 
00029 #include <glib.h>
00030 #include <utils/utils.h>
00031 #include "plumeinput.h"
00032 #include "plumevars.h"
00033 
00044 int plumemass( Plume_enviro *env , Plume_grid *grid , Plume_mass_bal *mb )
00045 {
00046 #ifdef DBG
00047    int xi[4];
00048    Plume_ocean ocean = *(env->ocean);
00049 #endif
00050    int ii, jj, nn, err;
00051    double *mass_in, *mass_out;
00052    Plume_river river = *(env->river);
00053    Plume_sediment *sedload = env->sed;
00054 
00055    mass_in  = eh_new0( double , env->n_grains );
00056    mass_out = eh_new0( double , env->n_grains );
00057 
00058    err = 0;
00059    mb->Qsr = 0.0;
00060    mb->Tsr = 0.0; 
00061    mb->Qsw[0] = 0.0; mb->Qsw[1] = 0.0; mb->Qsw[2] = 0.0; mb->Qsw[3] = 0.0;
00062    mb->Tsd[0] = 0.0; mb->Tsd[1] = 0.0;
00063 
00064 /*
00065    // Flux of sediment out of the river
00066    // Qs(kg/m^3 m^3/s = kg/s)
00067    // Ts = Qs*dt (kg/s s/day = kg/day)
00068    for( nn=0 ; nn<ngrains ; nn++ )
00069       Qsr = Qsr + river.Cs[nn]*river.Q;
00070    Tsr = Qsr*dTOs;
00071 */
00072 
00073    // calculate the mass of each grain size that enters the plume on a 
00074    // daily time step.
00075    for ( nn=0 ; nn<env->n_grains ; nn++ )
00076       mass_in[nn] = (river.Cs[nn]<.001)?0:(river.Cs[nn]*river.Q*dTOs);
00077 
00078 #ifdef DBG
00079    // 1) Flux across any cross section perpendicular to the jet axis
00080    // must be constant and equal to flux out of river for
00081    //    a) the conservative plume
00082    //    b) in fjords or ocean.vo = 0
00083    // test 4 cross-sections close to 5, 10, 20, and 40 km
00084    if( opt->fjrd || opt->strt )
00085    {
00086       xi[0] = (int)rnd( 5000/grid->dx);
00087       xi[1] = (int)rnd(10000/grid->dx);
00088       xi[2] = (int)rnd(20000/grid->dx);
00089       xi[3] = (int)rnd(40000/grid->dx);
00090 
00091       for( ii=0 ; ii<4 ; ii++ )
00092       {
00093          if ( grid->lx > xi[ii] )
00094          {
00095             for ( jj=0 ; jj<grid->ly ; jj++ )
00096             {
00097                for ( nn=0 ; nn<env->n_grains ; nn++ )
00098                {
00099                   mb->Qsw[ii] = mb->Qsw[ii] 
00100                               +   grid->ccnc[xi[ii]][jj][nn]
00101                                 * grid->ualb[xi[ii]][jj]
00102                                 * grid->dy
00103                                 * river.d0;
00104                }
00105             }
00106          }
00107       }
00108    }
00109 #endif
00110 
00111 /*
00112    // 2) Total deposit should equal total sediment out of the river
00113    //    (m/day kg/m^3 m^2 = kg/day)
00114    for( ii=0; ii<lx; ii++ ) {
00115       for( jj=0; jj<ly; jj++ ) {
00116          for( nn=0; nn<ngrains; nn++ ) {
00117             Tsd[0] = Tsd[0] + deps[ii][jj][nn]*sedload[nn].rho*dx*dy;
00118          }
00119       }
00120    }
00121 */
00122 
00123    // calculate the mass of each grain size that is deposited by the
00124    // the plume.
00125    for ( ii=0 ; ii<grid->lx ; ii++ )
00126       for ( jj=0 ; jj<grid->ly ; jj++ )
00127          for ( nn=0 ; nn<env->n_grains ; nn++ )
00128             mass_out[nn] += grid->deps[ii][jj][nn]
00129                           * sedload[nn].rho
00130                           * grid->dx
00131                           * grid->dy;
00132 
00133 #ifdef MASS_CHECK
00134    // Indicate if deposit != discharged sediment
00135    merr = (mb->Tsd[0] - mb->Tsr)/mb->Tsr;
00136    if( fabs(mb->merr) > mberr ) {
00137       fprintf(stderr,"----------------------------\n");
00138       fprintf(stderr,"Mass Balance ERROR in PLUME \n");
00139       fprintf(stderr,"----------------------------\n");
00140       fprintf(stderr,"   Mass of deposit != Mass discharged by river \n");
00141       fprintf(stderr,"   abs( ( Tsd[0] - Tsr )/ Tsr ) > mberr \n");
00142       fprintf(stderr,"   Mass of deposit (Tsd[0])       = %g (kg) \n", mb->Tsd[0]);
00143       fprintf(stderr,"   Mass from River (Tsr)  = %g (kg) \n", mb->Tsr);
00144       fprintf(stderr,"   ( Tsd[0] - Tsr )/Tsr)  = %g \n", mb->merr);
00145       fprintf(stderr,"   Max allowed error (mberr)      = %g \n", mberr);
00146       fprintf(stderr,"   mberr defined in PlumeVars.h \n\n");
00147       fprintf(stderr,"   Plume continuing, output will be questionable. \n\n");
00148       fprintf(stderr,"----------------------------\n\n");
00149 
00150       if ( opt->o1 )
00151       {
00152          fprintf(fidlog,"----------------------------\n");
00153          fprintf(fidlog,"Mass Balance ERROR in PLUME \n");
00154          fprintf(fidlog,"----------------------------\n");
00155          fprintf(fidlog,"   Mass of deposit != Mass discharged by river \n");
00156          fprintf(fidlog,"   abs( ( Tsd[0] - Tsr )/ Tsr ) < mberr \n");
00157          fprintf(fidlog,"   Mass of deposit (Tsd[0])    = %g (kg) \n", mb->Tsd[0]);
00158          fprintf(fidlog,"   Mass from River (Tsr)       = %g (kg) \n", mb->Tsr);
00159          fprintf(fidlog,"   ( Tsd[0] - Tsr )/Tsr)       = %g \n", mb->merr);
00160          fprintf(fidlog,"   Max allowed error (mberr)   = %g \n", mberr);
00161          fprintf(fidlog,"   mberr defined in PlumeVars.h \n\n");
00162          fprintf(fidlog,"   Plume continuing, output will be questionable. \n\n");
00163          fprintf(fidlog,"----------------------------\n\n");
00164       }
00165       err = 1;
00166    } 
00167 
00168 #endif // end mass_check
00169 
00170 #ifdef DBG
00171 
00172    printf("   Mass of deposit (Tsd[0])  = %g (kg) \n", mb->Tsd[0]);
00173    printf("   Mass from River (Tsr)     = %g (kg) \n", mb->Tsr);
00174    printf("   river.Q   = %g (m^3/s) \n", river.Q );
00175    printf("   river.u0  = %g (m/s) \n", river.u0 );
00176    printf("   river.b0  = %g (m) \n", river.b0 );
00177    printf("   river.d0  = %g (m) \n", river.d0 );
00178    printf("   river.Cs[0]       = %g (kg/m^3) \n", river.Cs[0] );
00179    printf("   river.Cs[1]       = %g (kg/m^3) \n", river.Cs[1] );
00180    printf("   river.Cs[2]       = %g (kg/m^3) \n", river.Cs[2] );
00181    printf("   river.Cs[3]       = %g (kg/m^3) \n", river.Cs[3] );
00182    printf("   sedload.lambda[0] = %g (1/s) \n", sedload[0].lambda );
00183    printf("   sedload.lambda[1] = %g (1/s) \n", sedload[1].lambda );
00184    printf("   sedload.lambda[2] = %g (1/s) \n", sedload[2].lambda );
00185    printf("   sedload.lambda[3] = %g (1/s) \n", sedload[3].lambda );
00186    printf("   ngrains   = %d  \n", env->n_grains );
00187    printf("   ocean.Cw  = %g (kg/m^3) \n", ocean.Cw );
00188    printf("   ocean.vo  = %g (m/s) \n", ocean.vo );
00189    printf("   ocean.vdirection  = %g (degN) \n", ocean.vdirection );
00190    printf("   river.rdirection  = %g (degN) \n", river.rdirection );
00191    printf("   ocean.cc  = %g (%%) \n", ocean.cc );
00192    printf("   river.rma = %g (degN) \n", river.rma );
00193    printf("   kwf       = %d  \n", opt->kwf );
00194    printf("   lat       = %g (degN) \n", env->lat );
00195 
00196 #endif
00197 
00198 /*
00199    // Corrected deposit and total mass Tsd[1]
00200    for( ii=0; ii<lx; ii++ ) {
00201       for( jj=0; jj<ly; jj++ ) {
00202          for( nn=0; nn<ngrains; nn++ ) {
00203             deps[ii][jj][nn] = deps[ii][jj][nn]*(Tsr/Tsd[0]);
00204             Tsd[1] = Tsd[1] + deps[ii][jj][nn]*sedload[nn].rho*dx*dy;
00205           }
00206       }
00207    }
00208 */
00209 
00210    // scale the final deposit to balance the mass.
00211    for( ii=0 ; ii<grid->lx ; ii++ )
00212       for( jj=0 ; jj<grid->ly ; jj++ )
00213          for( nn=0 ; nn<env->n_grains ; nn++ )
00214             if ( mass_in[nn]>0 )
00215                grid->deps[ii][jj][nn] *= mass_in[nn]/mass_out[nn];
00216 
00217    for ( nn=0 ; nn<env->n_grains ; nn++ )
00218       mass_out[nn] = 0;
00219 
00220    eh_free( mass_in  );
00221    eh_free( mass_out );
00222 
00223    return(err);
00224 
00225 } // end of PlumeMass
00226 

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