Main Page   Compound List   File List   Compound Members   File Members  

RothFuelModel.c

Go to the documentation of this file.
00001 
00024 #include "RothFuelModel.h"
00025 
00026 RothFuelModel * InitRothFuelModelEmpty()    {
00027     RothFuelModel * rfm = NULL;
00028     int i;
00029     
00030     if ( (rfm = (RothFuelModel *) malloc(sizeof(RothFuelModel))) == NULL )  {
00031         ERR_ERROR_CONTINUE("Unable to allocate memory for RothFuelModel. \n", ERR_ENOMEM);
00032         return rfm;
00033         }
00034         
00035     rfm->brntype    = EnumRothUnBurnable;
00036     rfm->units      = EnumUnknownUnits;
00037     rfm->fdepth = rfm->mex = rfm->ros_adj = 0.0;
00038     rfm->num_fp = 0;
00039     rfm->fdens = rfm->fsav = rfm->pkrat = 0.0;
00040     for(i = 0; i < EnumNumSizeClasses; i++)     {
00041         rfm->load[i] = rfm->sav[i] = rfm->dens[i] = rfm->hc[i] = rfm->stot[i] = rfm->seff[i] = 0.0;
00042         rfm->sarea[i] = rfm->effhn[i] = 0.0;
00043         rfm->awtg[i] = 0.0;
00044         rfm->larea = rfm->darea = 0.0;
00045         rfm->fm[i] = 0.0;
00046         }
00047     if ( (rfm->rp = InitRothPipelineEmpty()) == NULL )  {
00048         free(rfm);
00049         return rfm;
00050         }
00051         
00052     return rfm;
00053     }
00054 
00055 RothFuelModel * InitRothFuelModelFMDFile(FILE * fstream, int model_num) {
00056     RothFuelModel * rfm = NULL;
00057     int c, i = 0;
00058     char * line = NULL, * token = NULL;
00059     float fmd_vals[ROTH_FM_FMD_NUM_VALUES];
00060     
00061     if ( fstream == NULL )  {
00062         ERR_ERROR_CONTINUE("Stream to FMD file not open, RothFuelModel not retrieved. \n", ERR_EIOFAIL);
00063         return rfm;
00064         }
00065         
00066     if ( (rfm = InitRothFuelModelEmpty()) == NULL ) {
00067         ERR_ERROR_CONTINUE("Unable to allocate memory for RothFuelModel. \n", ERR_ENOMEM);
00068         return rfm;
00069         }
00070 
00071     rfm->brntype = EnumRothBurnable;
00072     rfm->units = EnumEnglishUnits;
00073     
00074     /* retrieve fmd contents */
00075     while ( (c = fgetc(fstream)) != EOF )   {
00076         ungetc(c, fstream);
00077         /* test line is not empty */
00078         if ( (line = GetLineFStreamIO(fstream)) != NULL )       {
00079             /* test line is not comment and parse into tokens */
00080             if ( line[0] != *ROTH_FM_FMD_COMMENT_CHAR 
00081                  && (token = strtok(line, ROTH_FM_FMD_SEPARATOR_CHARS)) != NULL )       {
00082                 /* ENGLISH UNITS */             
00083                 if ( strcmp(token, ROTH_FM_FMD_KEYWORD_ENGLISH) == 0)   {
00084                     rfm->units = EnumEnglishUnits;
00085                     }
00086                 /* METRIC UNITS */              
00087                 else if ( strcmp(token, ROTH_FM_FMD_KEYWORD_METRIC) == 0)   {
00088                     rfm->units = EnumMetricUnits;
00089                     }
00090                 /* FUEL VALUES */
00091                 else if ( model_num == atoi(token) )    {
00092                     /* model num matches, populate the attributes of the fuel model */                      
00093                     while ( (token = strtok(NULL, ROTH_FM_FMD_SEPARATOR_CHARS)) != NULL )   {
00094                         fmd_vals[i] = atof(token);
00095                         i++;
00096                         }
00097                     }               
00098                 }
00099             free(line);
00100             }
00101         /* get another line in file */
00102         }
00103 
00104     /* test if attribute values retrieved */
00105     if ( i == 0 && rfm != NULL )    {
00106         ERR_ERROR_CONTINUE("Attribute values for model num not retrieved from .FMD file. \n", ERR_ERANGE);
00107         FreeRothFuelModel(rfm);
00108         rfm = NULL;
00109         return rfm;
00110         }
00111 
00112     /* populate static fuel bed properties */
00113     rfm->fdepth                     = (rfm->units == EnumEnglishUnits) ?
00114             fmd_vals[ROTH_FM_FMD_FBED_DEPTH] : UNITS_CM_TO_M(fmd_vals[ROTH_FM_FMD_FBED_DEPTH]);
00115     rfm->mex                        = fmd_vals[ROTH_FM_FMD_EXT_MOIST] / 100;
00116     rfm->ros_adj                    = ROTH_FM_ZERO_ROS_ADJ_FACTOR;
00117 
00118     /* fuel particle load */
00119     rfm->load[EnumD1HSizeClass]     = (rfm->units == EnumEnglishUnits) ?
00120             fmd_vals[ROTH_FM_FMD_D1H_LOAD]      : UNITS_MGPHA_TO_KGPMSQ(fmd_vals[ROTH_FM_FMD_D1H_LOAD]);
00121     rfm->load[EnumD10HSizeClass]    = (rfm->units == EnumEnglishUnits) ?
00122             fmd_vals[ROTH_FM_FMD_D10H_LOAD]     : UNITS_MGPHA_TO_KGPMSQ(fmd_vals[ROTH_FM_FMD_D10H_LOAD]);   
00123     rfm->load[EnumD100HSizeClass]   = (rfm->units == EnumEnglishUnits) ?
00124             fmd_vals[ROTH_FM_FMD_D100H_LOAD]    : UNITS_MGPHA_TO_KGPMSQ(fmd_vals[ROTH_FM_FMD_D100H_LOAD]);  
00125     rfm->load[EnumLHSizeClass]      = (rfm->units == EnumEnglishUnits) ?
00126             fmd_vals[ROTH_FM_FMD_LH_LOAD]       : UNITS_MGPHA_TO_KGPMSQ(fmd_vals[ROTH_FM_FMD_LH_LOAD]); 
00127     rfm->load[EnumLWSizeClass]      = (rfm->units == EnumEnglishUnits) ?
00128             fmd_vals[ROTH_FM_FMD_LW_LOAD]       : UNITS_MGPHA_TO_KGPMSQ(fmd_vals[ROTH_FM_FMD_LW_LOAD]);
00129     /* fuel particle sav */         
00130     rfm->sav[EnumD1HSizeClass]      = (rfm->units == EnumEnglishUnits) ?
00131             fmd_vals[ROTH_FM_FMD_1H_SAV]        : UNITS_CMSAV_TO_MSAV(fmd_vals[ROTH_FM_FMD_1H_SAV]);
00132     rfm->sav[EnumD10HSizeClass]     = (rfm->units == EnumEnglishUnits) ? 
00133             ROTH_FM_D10H_STD_SAV_ENGLISH        : UNITS_FTSAV_TO_MSAV(ROTH_FM_D10H_STD_SAV_ENGLISH);
00134     rfm->sav[EnumD100HSizeClass]    = (rfm->units == EnumEnglishUnits) ? 
00135             ROTH_FM_D100H_STD_SAV_ENGLISH       : UNITS_FTSAV_TO_MSAV(ROTH_FM_D100H_STD_SAV_ENGLISH);
00136     rfm->sav[EnumLHSizeClass]       = (rfm->units == EnumEnglishUnits) ? 
00137             fmd_vals[ROTH_FM_FMD_LH_SAV]        : UNITS_CMSAV_TO_MSAV(fmd_vals[ROTH_FM_FMD_LH_SAV]);
00138     rfm->sav[EnumLWSizeClass]       = (rfm->units == EnumEnglishUnits) ? 
00139             fmd_vals[ROTH_FM_FMD_LW_SAV]        : UNITS_CMSAV_TO_MSAV(fmd_vals[ROTH_FM_FMD_LW_SAV]);
00140     /* fuel particle dens */
00141     rfm->dens[EnumD1HSizeClass]     = (rfm->units == EnumEnglishUnits) ? 
00142             ROTH_FM_STD_FP_DENSITY_ENGLISH      : UNITS_LBPFT3_TO_KGPM3(ROTH_FM_STD_FP_DENSITY_ENGLISH);
00143     rfm->dens[EnumD10HSizeClass]    = (rfm->units == EnumEnglishUnits) ? 
00144             ROTH_FM_STD_FP_DENSITY_ENGLISH      : UNITS_LBPFT3_TO_KGPM3(ROTH_FM_STD_FP_DENSITY_ENGLISH);
00145     rfm->dens[EnumD100HSizeClass]   = (rfm->units == EnumEnglishUnits) ? 
00146             ROTH_FM_STD_FP_DENSITY_ENGLISH      : UNITS_LBPFT3_TO_KGPM3(ROTH_FM_STD_FP_DENSITY_ENGLISH);
00147     rfm->dens[EnumLHSizeClass]      = (rfm->units == EnumEnglishUnits) ? 
00148             ROTH_FM_STD_FP_DENSITY_ENGLISH      : UNITS_LBPFT3_TO_KGPM3(ROTH_FM_STD_FP_DENSITY_ENGLISH);
00149     rfm->dens[EnumLWSizeClass]      = (rfm->units == EnumEnglishUnits) ? 
00150             ROTH_FM_STD_FP_DENSITY_ENGLISH      : UNITS_LBPFT3_TO_KGPM3(ROTH_FM_STD_FP_DENSITY_ENGLISH);
00151     /* fuel particle heat content */
00152     rfm->hc[EnumD1HSizeClass]       = (rfm->units == EnumEnglishUnits) ? 
00153             fmd_vals[ROTH_FM_FMD_DHC]           : UNITS_KJPKG_TO_JPKG(fmd_vals[ROTH_FM_FMD_DHC]);
00154     rfm->hc[EnumD10HSizeClass]      = (rfm->units == EnumEnglishUnits) ? 
00155             fmd_vals[ROTH_FM_FMD_DHC]           : UNITS_KJPKG_TO_JPKG(fmd_vals[ROTH_FM_FMD_DHC]);
00156     rfm->hc[EnumD100HSizeClass]     = (rfm->units == EnumEnglishUnits) ? 
00157             fmd_vals[ROTH_FM_FMD_DHC]           : UNITS_KJPKG_TO_JPKG(fmd_vals[ROTH_FM_FMD_DHC]);
00158     rfm->hc[EnumLHSizeClass]        = (rfm->units == EnumEnglishUnits) ? 
00159             fmd_vals[ROTH_FM_FMD_LHC]           : UNITS_KJPKG_TO_JPKG(fmd_vals[ROTH_FM_FMD_LHC]);
00160     rfm->hc[EnumLWSizeClass]        = (rfm->units == EnumEnglishUnits) ? 
00161             fmd_vals[ROTH_FM_FMD_LHC]           : UNITS_KJPKG_TO_JPKG(fmd_vals[ROTH_FM_FMD_LHC]);
00162     /* fuel particle total silica content */
00163     rfm->stot[EnumD1HSizeClass]     = ROTH_FM_STD_TOTAL_SILICA_UNITLESS; 
00164     rfm->stot[EnumD10HSizeClass]    = ROTH_FM_STD_TOTAL_SILICA_UNITLESS; 
00165     rfm->stot[EnumD100HSizeClass]   = ROTH_FM_STD_TOTAL_SILICA_UNITLESS; 
00166     rfm->stot[EnumLHSizeClass]      = ROTH_FM_STD_TOTAL_SILICA_UNITLESS; 
00167     rfm->stot[EnumLWSizeClass]      = ROTH_FM_STD_TOTAL_SILICA_UNITLESS; 
00168     /* fuel particle effective silica content */
00169     rfm->seff[EnumD1HSizeClass]     = ROTH_FM_STD_EFF_SILICA_UNITLESS;
00170     rfm->seff[EnumD10HSizeClass]    = ROTH_FM_STD_EFF_SILICA_UNITLESS;
00171     rfm->seff[EnumD100HSizeClass]   = ROTH_FM_STD_EFF_SILICA_UNITLESS;
00172     rfm->seff[EnumLHSizeClass]      = ROTH_FM_STD_EFF_SILICA_UNITLESS;
00173     rfm->seff[EnumLWSizeClass]      = ROTH_FM_STD_EFF_SILICA_UNITLESS;
00174     
00175     /* count num fuel particles */
00176     for(i = 0; i < EnumNumSizeClasses; i++)     {
00177         if ( UNITS_FP_GT_ZERO(rfm->load[i]) )   {
00178             rfm->num_fp = rfm->num_fp + 1;
00179             }
00180         }
00181     
00182     /* populate derived fuel particle properties */
00183     if ( RothFuelModelSetDerivedProperties(rfm) )   {
00184         ERR_ERROR_CONTINUE("Unable to initialize RothFuelModel from .FMD file. \n", ERR_EBADFUNC);
00185         FreeRothFuelModel(rfm);
00186         rfm = NULL;
00187         return rfm;
00188         }
00189                 
00190     return rfm;
00191     }
00192 
00193 RothFuelModel * InitRothFuelModelUnBurnable()   {
00194     RothFuelModel * rfm = NULL;
00195         
00196     if ( (rfm = InitRothFuelModelEmpty()) == NULL ) {
00197         ERR_ERROR_CONTINUE("Unable to allocate memory for RothFuelModel. \n", ERR_ENOMEM);
00198         return rfm;
00199         }
00200 
00201     rfm->brntype = EnumRothUnBurnable;
00202     
00203     return rfm;
00204     }
00205 
00206 /*
00207  * Description:
00208  * Takes a RothFuelModel structure consisting of multi-sized fuel particles
00209  * and calculates the derived fuel particle properties.
00210  *
00211  * Arguments:
00212  * rfm- RothFuelModel containing fuel particle attributes
00213  *
00214  * Returns:
00215  * ERR_SUCCESS (0) if operation successful, an error code otherwise.
00216  * Best use of this facility is as follows...
00217  * int error_status = CallFunctionXXX();
00218  * if ( error_status)  something bad happened
00219  */
00220 int RothFuelModelSetDerivedProperties(RothFuelModel * rfm)  {
00221     int i;
00222     float tarea, lsav, dsav;
00223 
00224     tarea = lsav = dsav = 0.0;
00225     
00226     /* check args */
00227     if ( rfm == NULL )  {
00228         ERR_ERROR("Unable to calculate derived properties in RothFuelModel. \n", ERR_EINVAL);
00229         }
00230         
00231     /* check if burnable fuel */
00232     if ( rfm->brntype == EnumRothUnBurnable )   {
00233         return ERR_SUCCESS;
00234         }
00235          
00236     /* update fuel particle derived properties */           
00237     for(i = 0; i < EnumNumSizeClasses; i++)     {
00238         /* surface area */
00239         if ( UNITS_FP_GT_ZERO(rfm->dens[i]) )   {
00240             rfm->sarea[i] = (rfm->load[i] * rfm->sav[i]) / rfm->dens[i];
00241             }
00242         else    {
00243             rfm->sarea[i] = 0.0;
00244             }
00245         /* effective heating number */
00246         if ( rfm->units == EnumEnglishUnits )   {
00247             if ( UNITS_FP_GT_ZERO(rfm->sav[i]) )    {
00248                 rfm->effhn[i] = exp(-138.0 / rfm->sav[i]);
00249                 }
00250             else    {
00251                 rfm->effhn[i] = 0.0;
00252                 }
00253             }
00254         if ( rfm->units == EnumMetricUnits )    {
00255             if ( UNITS_FP_GT_ZERO(rfm->sav[i]) )    {
00256                 rfm->effhn[i] = exp(-1.0 / (0.0022 * rfm->sav[i]));
00257                 }
00258             else    {
00259                 rfm->effhn[i] = 0.0;
00260                 }
00261             }       
00262         /* zero wtg */
00263         rfm->awtg[i] = 0.0;
00264         }
00265     
00266     /* accumulate surface areas by life category for the entire fuel bed */
00267     rfm->larea = rfm->darea = 0.0;
00268     rfm->larea = rfm->sarea[EnumLHSizeClass] + rfm->sarea[EnumLWSizeClass];
00269     rfm->darea = rfm->sarea[EnumD1HSizeClass] + rfm->sarea[EnumD10HSizeClass] + rfm->sarea[EnumD100HSizeClass];
00270 
00271     /* surface area weighting factor for each particle */
00272     if ( UNITS_FP_GT_ZERO(rfm->larea) ) {
00273         rfm->awtg[EnumLHSizeClass] = rfm->sarea[EnumLHSizeClass] / rfm->larea;
00274         rfm->awtg[EnumLWSizeClass] = rfm->sarea[EnumLWSizeClass] / rfm->larea;
00275         }
00276     if ( UNITS_FP_GT_ZERO(rfm->darea) ) {
00277         rfm->awtg[EnumD1HSizeClass] = rfm->sarea[EnumD1HSizeClass] / rfm->darea;
00278         rfm->awtg[EnumD10HSizeClass] = rfm->sarea[EnumD10HSizeClass] / rfm->darea;
00279         rfm->awtg[EnumD100HSizeClass] = rfm->sarea[EnumD100HSizeClass] / rfm->darea;        
00280         }       
00281         
00282     /* surface area weighting contributed by live and dead fuels */
00283     tarea = rfm->larea + rfm->darea;
00284     rfm->larea = rfm->larea / tarea;
00285     rfm->darea = rfm->darea / tarea;
00286     
00287     /* fuel bed bulk density */     
00288     if ( UNITS_FP_GT_ZERO(rfm->fdepth) )    {
00289         rfm->fdens = (rfm->load[EnumLHSizeClass] + rfm->load[EnumLWSizeClass] + rfm->load[EnumD1HSizeClass] +
00290                     rfm->load[EnumD10HSizeClass] + rfm->load[EnumD100HSizeClass]) / rfm->fdepth;
00291         }
00292         
00293     /* fuel bed characteristic sav */
00294     lsav =  (rfm->awtg[EnumLHSizeClass] * rfm->sav[EnumLHSizeClass]) +
00295             (rfm->awtg[EnumLWSizeClass] * rfm->sav[EnumLWSizeClass]);   
00296     dsav =  (rfm->awtg[EnumD1HSizeClass] * rfm->sav[EnumD1HSizeClass]) +
00297             (rfm->awtg[EnumD10HSizeClass] * rfm->sav[EnumD10HSizeClass]) +
00298             (rfm->awtg[EnumD100HSizeClass] * rfm->sav[EnumD100HSizeClass]);
00299     rfm->fsav = (rfm->larea * lsav) + (rfm->darea * dsav);
00300 
00301     /* fuel bed packing ratio */
00302     rfm->pkrat = 0.0;
00303     for(i = 0; i < EnumNumSizeClasses; i++)     {
00304         if ( UNITS_FP_GT_ZERO(rfm->dens[i]) )   {
00305             rfm->pkrat += rfm->load[i] / rfm->dens[i];
00306             }
00307         }
00308     if ( UNITS_FP_GT_ZERO(rfm->fdepth) )    {
00309         rfm->pkrat /= rfm->fdepth;
00310         }
00311     
00312     return ERR_SUCCESS;
00313     }
00314 
00315 int RothFuelModelMetricToEnglish(RothFuelModel * rfm)   {
00316     int i;
00317      
00318     if ( rfm == NULL ) {
00319         ERR_ERROR("RothFuelModel values not initialized, conversion failed. \n", ERR_EINVAL);
00320         }
00321     else if ( rfm->brntype == EnumRothUnBurnable )  {
00322         ERR_ERROR("RothFuelModel  designated unburnable, conversion failed. \n", ERR_EINVAL);
00323         }
00324     else if ( rfm->units == EnumUnknownUnits )  {
00325         ERR_ERROR("RothFuelModel units are unknown, unable to convert to ENGLISH. \n", ERR_EINVAL);
00326         }
00327     else if ( rfm->units == EnumEnglishUnits )  {
00328         ERR_ERROR("RothFuelModel values already ENGLISH, no conversion necessary. \n", ERR_WARNING);
00329         }
00330 
00331     rfm->units = EnumEnglishUnits;
00332     
00333     /* convert each static fuel particle property */
00334     for(i = 0; i < EnumNumSizeClasses; i++)     {
00335         if ( UNITS_FP_GT_ZERO(rfm->load[i]) )   {
00336             rfm->load[i] = UNITS_KGPMSQ_TO_LBPFTSQ(rfm->load[i]);
00337             }
00338         if ( UNITS_FP_GT_ZERO(rfm->sav[i]) )    {
00339             rfm->sav[i] = UNITS_MSAV_TO_FTSAV(rfm->sav[i]);
00340             }
00341         if ( UNITS_FP_GT_ZERO(rfm->dens[i]) )   {
00342             rfm->dens[i] = UNITS_KGPM3_TO_LBPFT3(rfm->dens[i]);
00343             }
00344         if ( UNITS_FP_GT_ZERO(rfm->hc[i]) ) {
00345             rfm->hc[i] = UNITS_JPKG_TO_BTUPLB(rfm->hc[i]);
00346             }
00347         }
00348 
00349     /* convert the static fuel bed properties */
00350     if ( UNITS_FP_GT_ZERO(rfm->fdepth) )    {
00351         rfm->fdepth = UNITS_M_TO_FT(rfm->fdepth);
00352         }
00353     if ( UNITS_FP_GT_ZERO(rfm->fdens) )     {
00354         rfm->fdens = UNITS_KGPM3_TO_LBPFT3(rfm->fdens);
00355         }
00356     if ( UNITS_FP_GT_ZERO(rfm->fsav) )      {
00357         rfm->fsav = UNITS_MSAV_TO_FTSAV(rfm->fsav);
00358         }   
00359         
00360     /* recalculate derived fuel particle properties */
00361     if ( RothFuelModelSetDerivedProperties(rfm) )   {
00362         ERR_ERROR("Calculation of derived properties failed during unit conversion. \n", ERR_EBADFUNC);
00363         }
00364         
00365     return ERR_SUCCESS; 
00366     }
00367 
00368 int RothFuelModelEnglishToMetric(RothFuelModel * rfm)   {
00369     int i;
00370      
00371     if ( rfm == NULL ) {
00372         ERR_ERROR("RothFuelModel values not initialized, conversion failed. \n", ERR_EINVAL);
00373         }
00374     else if ( rfm->brntype == EnumRothUnBurnable )  {
00375         ERR_ERROR("RothFuelModel  designated unburnable, conversion failed. \n", ERR_EINVAL);
00376         }
00377     else if ( rfm->units == EnumUnknownUnits )  {
00378         ERR_ERROR("RothFuelModel units are unknown, unable to convert to METRIC. \n", ERR_EINVAL);
00379         }
00380     else if ( rfm->units == EnumMetricUnits )   {
00381         ERR_ERROR("RothFuelModel values already METRIC, no conversion necessary. \n", ERR_WARNING);
00382         }
00383 
00384     rfm->units = EnumMetricUnits;
00385     
00386     /* convert each static fuel particle property */
00387     for(i = 0; i < EnumNumSizeClasses; i++)     {
00388         if ( UNITS_FP_GT_ZERO(rfm->load[i]) )   {
00389             rfm->load[i] = UNITS_LBPFTSQ_TO_KGPMSQ(rfm->load[i]);
00390             }
00391         if ( UNITS_FP_GT_ZERO(rfm->sav[i]) )    {
00392             rfm->sav[i] = UNITS_FTSAV_TO_MSAV(rfm->sav[i]);
00393             }
00394         if ( UNITS_FP_GT_ZERO(rfm->dens[i]) )   {
00395             rfm->dens[i] = UNITS_LBPFT3_TO_KGPM3(rfm->dens[i]);
00396             }
00397         if ( UNITS_FP_GT_ZERO(rfm->hc[i]) ) {
00398             rfm->hc[i] = UNITS_BTUPLB_TO_JPKG(rfm->hc[i]);
00399             }
00400         }
00401 
00402     /* convert the static fuel bed properties */
00403     if ( UNITS_FP_GT_ZERO(rfm->fdepth) )    {
00404         rfm->fdepth = UNITS_FT_TO_M(rfm->fdepth);
00405         }
00406     if ( UNITS_FP_GT_ZERO(rfm->fdens) )     {
00407         rfm->fdens = UNITS_LBPFT3_TO_KGPM3(rfm->fdens);
00408         }
00409     if ( UNITS_FP_GT_ZERO(rfm->fsav) )      {
00410         rfm->fsav = UNITS_FTSAV_TO_MSAV(rfm->fsav);
00411         }   
00412         
00413     /* recalculate derived fuel particle properties */
00414     if ( RothFuelModelSetDerivedProperties(rfm) )   {
00415         ERR_ERROR("Calculation of derived properties failed during unit conversion. \n", ERR_EBADFUNC);
00416         }
00417         
00418     return ERR_SUCCESS; 
00419     }
00420 
00421 void RothFuelModelDumpToStream(RothFuelModel * rfm, FILE * fstream) {
00422     if ( rfm == NULL || fstream == NULL )   {
00423         ERR_ERROR_CONTINUE("Unable to dump RothFuelModel attributes. \n", ERR_EINVAL);
00424         return;
00425         }
00426 
00427     switch(rfm->units)  {
00428         case EnumUnknownUnits:
00429             fprintf(fstream, "UNITS: UNKNOWN \n");
00430             break;
00431         case EnumEnglishUnits:
00432             fprintf(fstream, "UNITS: ENGLISH \n");
00433             break;
00434         case EnumMetricUnits:
00435             fprintf(fstream, "UNITS: METRIC \n");
00436             break;
00437         default:
00438             fprintf(fstream, "UNITS: <WARNING! NOT RECOGNIZED> \n");
00439             break;
00440         }
00441     fprintf(fstream, "FUEL BED PROPERTIES \n");
00442     fprintf(fstream, "DEPTH: \t\t %f \n", rfm->fdepth);
00443     fprintf(fstream, "MEXT: \t\t %f \n", rfm->mex);
00444     fprintf(fstream, "ROS ADJ: \t %f \n", rfm->ros_adj);
00445     fprintf(fstream, "NUM FP: \t %d \n", rfm->num_fp);
00446     fprintf(fstream, "FUEL BED CHARACTERISTIC PROPERTIES \n");
00447     fprintf(fstream, "FDENS: \t\t %f \n", rfm->fdens);
00448     fprintf(fstream, "FSAV: \t\t %f \n", rfm->fsav);
00449     fprintf(fstream, "PACKR: \t\t %f \n", rfm->pkrat);
00450     fprintf(fstream, "FUEL PARTICLE PROPERTIES \n");    
00451     fprintf(fstream, "SIZE: \t D1H \t\t D10H \t\t D100H \t\t LH \t\t LW \n");
00452     fprintf(fstream, "LOAD: \t %.4f \t %.4f \t %.4f \t %.4f \t %.4f \n", 
00453         rfm->load[EnumD1HSizeClass], rfm->load[EnumD10HSizeClass], rfm->load[EnumD100HSizeClass], 
00454         rfm->load[EnumLHSizeClass], rfm->load[EnumLWSizeClass] );           
00455     fprintf(fstream, "SAV: \t %.4f \t %.4f \t %.4f \t %.4f \t %.4f \n", 
00456         rfm->sav[EnumD1HSizeClass], rfm->sav[EnumD10HSizeClass], rfm->sav[EnumD100HSizeClass], 
00457         rfm->sav[EnumLHSizeClass], rfm->sav[EnumLWSizeClass] );
00458     fprintf(fstream, "DENS: \t %.4f \t %.4f \t %.4f \t %.4f \t %.4f \n", 
00459         rfm->dens[EnumD1HSizeClass], rfm->dens[EnumD10HSizeClass], rfm->dens[EnumD100HSizeClass], 
00460         rfm->dens[EnumLHSizeClass], rfm->dens[EnumLWSizeClass] );
00461     fprintf(fstream, "HC: \t %.2f \t %.2f \t %.2f \t %.2f \t %.2f \n", 
00462         rfm->hc[EnumD1HSizeClass], rfm->hc[EnumD10HSizeClass], rfm->hc[EnumD100HSizeClass], 
00463         rfm->hc[EnumLHSizeClass], rfm->hc[EnumLWSizeClass] );
00464     fprintf(fstream, "STOT: \t %f \t %f \t %f \t %f \t %f \n", 
00465         rfm->stot[EnumD1HSizeClass], rfm->stot[EnumD10HSizeClass], rfm->stot[EnumD100HSizeClass], 
00466         rfm->stot[EnumLHSizeClass], rfm->stot[EnumLWSizeClass] );
00467     fprintf(fstream, "SEFF: \t %f \t %f \t %f \t %f \t %f \n", 
00468         rfm->seff[EnumD1HSizeClass], rfm->seff[EnumD10HSizeClass], rfm->seff[EnumD100HSizeClass], 
00469         rfm->seff[EnumLHSizeClass], rfm->seff[EnumLWSizeClass] );
00470     fprintf(fstream, "FUEL PARTICLE DERIVED PROPERTIES \n");
00471     fprintf(fstream, "SAREA: \t %f \t %f \t %f \t %f \t %f \n", 
00472         rfm->sarea[EnumD1HSizeClass], rfm->sarea[EnumD10HSizeClass], rfm->sarea[EnumD100HSizeClass], 
00473         rfm->sarea[EnumLHSizeClass], rfm->sarea[EnumLWSizeClass] );
00474     fprintf(fstream, "EFFHN: \t %f \t %f \t %f \t %f \t %f \n", 
00475         rfm->effhn[EnumD1HSizeClass], rfm->effhn[EnumD10HSizeClass], rfm->effhn[EnumD100HSizeClass], 
00476         rfm->effhn[EnumLHSizeClass], rfm->effhn[EnumLWSizeClass] );         
00477     fprintf(fstream, "FUEL BED WEIGHTING PROPERTIES \n");       
00478     fprintf(fstream, "AWTG: \t %f \t %f \t %f \t %f \t %f \n", 
00479         rfm->awtg[EnumD1HSizeClass], rfm->awtg[EnumD10HSizeClass], rfm->awtg[EnumD100HSizeClass], 
00480         rfm->awtg[EnumLHSizeClass], rfm->awtg[EnumLWSizeClass] );
00481     fprintf(fstream, "LDWTG: \t %f \t %f \t %f \t %f \t %f \n", 
00482         rfm->darea, rfm->darea, rfm->darea, rfm->larea, rfm->larea );   
00483     fprintf(fstream, "FUEL PARTICLE ENVIRONMENTAL PROPERTIES \n");      
00484     fprintf(fstream, "FM: \t %f \t %f \t %f \t %f \t %f \n", 
00485         rfm->fm[EnumD1HSizeClass], rfm->fm[EnumD10HSizeClass], rfm->fm[EnumD100HSizeClass], 
00486         rfm->fm[EnumLHSizeClass], rfm->fm[EnumLWSizeClass] );
00487     fprintf(fstream, "NOTE: some attributes not user-configurable, assigned default values \n");    
00488     
00489     return;
00490     }
00491 
00492 void FreeRothFuelModel(void * vptr) {
00493     RothFuelModel * rfm = NULL;
00494     if ( vptr != NULL ) {
00495         rfm = (RothFuelModel *) vptr;
00496         if ( rfm != NULL )  {
00497             if ( rfm->rp != NULL )  {
00498                 FreeRothPipeline(rfm->rp);
00499                 }
00500             free(rfm);
00501             }
00502         }   
00503     rfm = NULL;
00504     return; 
00505     }
00506     
00507 /* end of RothFuelModel.c */
Generated at Fri Jun 22 00:46:51 2001 for HFire by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000