stats_obj.c

CA仿真模型中SLEUTH模型

  run = proc_GetCurrentRun ();

  if (scen_GetWriteAvgFileFlag ())
  {
    sprintf (avg_filename, "%savg_pe_%u.log", output_dir, glb_mype);
    if (!avg_log_created)
    {
      stats_CreateStatsValFile (avg_filename);
      avg_log_created = 1;
    }
  }

  if (scen_GetWriteStdDevFileFlag ())
  {
    sprintf (std_filename, "%sstd_dev_pe_%u.log", output_dir, glb_mype);
    if (!std_dev_log_created)
    {
      stats_CreateStatsValFile (std_filename);
      std_dev_log_created = 1;
    }
  }

  if (proc_GetProcessingType () != PREDICTING)
  {
    sprintf (cntrl_filename, "%scontrol_stats_pe_%u.log", output_dir, glb_mype);
    if (!control_stats_log_created)
    {
      stats_CreateControlFile (cntrl_filename);
      control_stats_log_created = 1;
    }
  }

  if (proc_GetProcessingType () != PREDICTING)
  {
    /*
     *
     * start at i = 1, i = 0 is the initial seed
     *
     */
    for (i = 1; i < igrid_GetUrbanCount (); i++)
    {
      yr = igrid_GetUrbanYear (i);
      stats_CalAverages (i);
      stats_ProcessGrowLog (run, yr);

      if (scen_GetWriteAvgFileFlag ())
      {
        stats_WriteStatsValLine (avg_filename, run, yr, average, i);
      }
      if (scen_GetWriteStdDevFileFlag ())
      {
        stats_WriteStatsValLine (std_filename, run, yr, std_dev, i);
      }
    }
    stats_DoRegressions ();
    stats_DoAggregate (fmatch);
    stats_WriteControlStats (cntrl_filename);
  }
  if (proc_GetProcessingType () == PREDICTING)
  {
    for (yr = scen_GetPredictionStartDate () + 1;
         yr <= proc_GetStopYear (); yr++)
    {
#if 1
      stats_ClearStatsValArrays ();
#endif
      stats_ProcessGrowLog (run, yr);
      if (scen_GetWriteAvgFileFlag ())
      {
        stats_WriteStatsValLine (avg_filename, run, yr, average, 0);
      }
      if (scen_GetWriteStdDevFileFlag ())
      {
        stats_WriteStatsValLine (std_filename, run, yr, std_dev, 0);
      }
#if 1
      stats_ClearStatsValArrays ();
#endif
    }
  }
  stats_ClearStatsValArrays ();
}
/******************************************************************************
*******************************************************************************
** FUNCTION NAME: 
** PURPOSE:       
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  stats_Dump (char *file, int line)
{
  int i;
  int yr;

  fprintf (stdout, "%s %u stats_Dump\n", file, line);
  stats_LogStatValHdr (stdout);
  fprintf (stdout, "this_year:\n");
  stats_LogStatVal (proc_GetCurrentRun (), proc_GetCurrentYear (),
                    0, &record.this_year, stdout);
  fprintf (stdout, "running_total:\n");
  for (i = 0; i < MAX_URBAN_YEARS; i++)
  {
    yr = igrid_GetUrbanYear (i);
    if (i == 0)
    {
      yr = 0;
    }
    stats_LogStatVal (proc_GetCurrentRun (), yr, i,
                      &running_total[i], stdout);
  }
  fprintf (stdout, "average:\n");
  for (i = 0; i < MAX_URBAN_YEARS; i++)
  {
    yr = igrid_GetUrbanYear (i);
    if (i == 0)
    {
      yr = 0;
    }
    stats_LogStatVal (proc_GetCurrentRun (), yr, i, &average[i], stdout);
  }
  fprintf (stdout, "std_dev:\n");
  for (i = 0; i < MAX_URBAN_YEARS; i++)
  {
    yr = igrid_GetUrbanYear (i);
    if (i == 0)
    {
      yr = 0;
    }
    stats_LogStatVal (proc_GetCurrentRun (), yr, i, &std_dev[i], stdout);
  }
  stats_LogStatInfoHdr (stdout);
  fprintf (stdout, "stats_actual:\n");
  for (i = 0; i < MAX_URBAN_YEARS; i++)
  {
    yr = igrid_GetUrbanYear (i);
    if (i == 0)
    {
      yr = 0;
    }
    stats_LogStatInfo (proc_GetCurrentRun (), yr, i,
                       &stats_actual[i], stdout);
  }
  fprintf (stdout, "regression:\n");
  stats_LogStatInfo (proc_GetCurrentRun (), 0, 0, &regression, stdout);
}
/******************************************************************************
*******************************************************************************
** FUNCTION NAME: 
** PURPOSE:       
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  stats_LogControlStatsHdr (FILE * fp)
{
  fprintf (fp, "                                               Cluster\n");
  fprintf (fp, "  Run  Product Compare     Pop   Edges Clusters   ");
  fprintf (fp, "Size Leesalee  Slope ");
  fprintf (fp, " %%Urban   Xmean   Ymean     Rad  Fmatch ");
  fprintf (fp, "Diff  Brd Sprd  Slp   RG\n");
}
/******************************************************************************
*******************************************************************************
** FUNCTION NAME: 
** PURPOSE:       
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  stats_LogControlStats (FILE * fp)
{
  fprintf (fp, "%5u %8.5f %7.5f %7.5f %7.5f %7.5f %7.5f %7.5f %7.5f %7.5f ",
           proc_GetCurrentRun (),
           aggregate.product,
           aggregate.compare,
           regression.pop,
           regression.edges,
           regression.clusters,
           regression.mean_cluster_size,
           aggregate.leesalee,
           regression.average_slope,
           regression.percent_urban);
  fprintf (fp, "%7.5f %7.5f %7.5f %7.5f %4.0f %4.0f %4.0f %4.0f %4.0f\n",
           regression.xmean,
           regression.ymean,
           regression.rad,
           aggregate.fmatch,
           coeff_GetSavedDiffusion (),
           coeff_GetSavedBreed (),
           coeff_GetSavedSpread (),
           coeff_GetSavedSlopeResist (),
           coeff_GetSavedRoadGravity ());
}
/******************************************************************************
*******************************************************************************
** FUNCTION NAME: 
** PURPOSE:       
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  stats_DoAggregate (double fmatch)
{
  char func[] = "stats_DoAggregate";
  int last_index;
  int i;
  double fmatch_tmp = 1.0;
  double numerator;
  double denominator;

  last_index = igrid_GetUrbanCount () - 1;
  aggregate.fmatch = fmatch;
  aggregate.actual = stats_actual[last_index].pop;
  aggregate.simulated = average[last_index].pop;
  aggregate.leesalee = 0.0;
  for (i = 1; i < igrid_GetUrbanCount (); i++)
  {
    aggregate.leesalee += average[i].leesalee;
  }
  aggregate.leesalee /= (igrid_GetUrbanCount () - 1);
  if (aggregate.actual > aggregate.simulated)
  {
    if (aggregate.actual != 0.0)
    {
      denominator = aggregate.actual;
      numerator = aggregate.simulated;
      aggregate.compare = numerator / denominator;
    }
    else
    {
      sprintf (msg_buf, "aggregate.actual = 0.0");
      LOG_ERROR (msg_buf);
      EXIT (1);
    }
  }
  else
  {
    if (aggregate.simulated != 0.0)
    {
      denominator = aggregate.simulated;
      numerator = aggregate.actual;
      aggregate.compare = numerator / denominator;
    }
    else
    {
      sprintf (msg_buf, "aggregate.simulated = 0.0");
      LOG_ERROR (msg_buf);
      EXIT (1);
    }
  }
  if (scen_GetDoingLanduseFlag ())
  {
    fmatch_tmp = fmatch;
  }
  aggregate.product =
    aggregate.compare *
    aggregate.leesalee *
    regression.edges *
    regression.clusters *
    regression.pop *
    regression.xmean *
    regression.ymean *
    regression.rad *
    regression.average_slope *
    regression.mean_cluster_size *
    regression.percent_urban *
    fmatch_tmp;

}
/******************************************************************************
*******************************************************************************
** FUNCTION NAME: 
** PURPOSE:       
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  stats_DoRegressions ()
{
  double dependent[MAX_URBAN_YEARS];
  double independent[MAX_URBAN_YEARS];
  int nobs;
  int i;

  nobs = igrid_GetUrbanCount () - 1;
  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].area;
    independent[i - 1] = average[i].area;
  }
  regression.area = stats_linefit (dependent, independent, nobs);

  nobs = igrid_GetUrbanCount () - 1;
  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].edges;
    independent[i - 1] = average[i].edges;
  }
  regression.edges = stats_linefit (dependent, independent, nobs);

  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].clusters;
    independent[i - 1] = average[i].clusters;
  }
  regression.clusters = stats_linefit (dependent, independent, nobs);

  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].pop;
    independent[i - 1] = average[i].pop;
  }
  regression.pop = stats_linefit (dependent, independent, nobs);

  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].xmean;
    independent[i - 1] = average[i].xmean;
  }
  regression.xmean = stats_linefit (dependent, independent, nobs);

  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].ymean;
    independent[i - 1] = average[i].ymean;
  }
  regression.ymean = stats_linefit (dependent, independent, nobs);

  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].rad;
    independent[i - 1] = average[i].rad;
  }
  regression.rad = stats_linefit (dependent, independent, nobs);

  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].average_slope;
    independent[i - 1] = average[i].slope;
  }
  regression.average_slope = stats_linefit (dependent, independent, nobs);

  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].mean_cluster_size;
    independent[i - 1] = average[i].mean_cluster_size;
  }
  regression.mean_cluster_size = stats_linefit (dependent, independent, nobs);

  for (i = 1; i <= nobs; i++)
  {
    dependent[i - 1] = stats_actual[i].percent_urban;
    independent[i - 1] = average[i].percent_urban;
  }
  regression.percent_urban = stats_linefit (dependent, independent, nobs);
}
/******************************************************************************
*******************************************************************************
** FUNCTION NAME: 
** PURPOSE:       
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  stats_Save (char *filename)
{
  char func[] = "stats_Save";
  int num_written;
  int fseek_loc;
  int index;
  int i;
  FILE *fp;
  record.run = proc_GetCurrentRun ();
  record.monte_carlo = proc_GetCurrentMonteCarlo ();
  record.year = proc_GetCurrentYear ();
  index = 0;
  if (proc_GetProcessingType () != PREDICTING)
  {
    index = igrid_UrbanYear2Index (record.year);
  }

  stats_UpdateRunningTotal (index);

  if (record.monte_carlo == 0)
  {
    FILE_OPEN (fp, filename, "wb");
    for (i = 0; i < scen_GetMonteCarloIterations (); i++)
    {
      num_written = fwrite (&record, sizeof (record), 1, fp);
      if (num_written != 1)
      {
        printf ("%s %u ERROR\n", __FILE__, __LINE__);
      }
    }

  }
  else
  {
    FILE_OPEN (fp, filename, "r+b");
    rewind (fp);
    fseek_loc = fseek (fp, sizeof (record) * record.monte_carlo, SEEK_SET);
    num_written = fwrite (&record, sizeof (record), 1, fp);
    if (num_written != 1)
    {
      printf ("%s %u ERROR\n", __FILE__, __LINE__);
    }

  }
  fclose (fp);

}
/******************************************************************************
*******************************************************************************
** FUNCTION NAME: 
** P