OpenTemp.org

            // Write station locations
            sw.Write(", ");
            foreach (Station station in _stations.Values)
            {
                sw.Write(string.Format(", {0:F2}, {1:F2}, ", station.Latitude, station.Longitude));
            }
            sw.WriteLine();

            // Write cell location and cell-station weights
            foreach (Cell cell in _cells)
            {
                sw.Write(string.Format("{0:F2}, {1:F2}", cell.Latitude, cell.Longitude));
                foreach (Station station in _stations.Values)
                {
                    sw.Write(", , ");
                    float weight = -1.0f;
                    foreach (CellStation cs in cell.Stations)
                    {
                        if (cs.station.Equals(station))
                        {
                            weight = cs.weight;
                            break;
                        }
                    }
                    if (weight >= 0.0f)
                    {
                        sw.Write(string.Format(", {0:F3}", weight));
                    }
                    else
                    {
                        sw.Write(", ");
                    }
                }
                sw.WriteLine();
            }

            // Done
            sw.Close();

            // Done
            OpenTemp.WriteLine(string.Format("  Writing finished: {0} cells written", _cells.Count));
            return 0;
        }

            // Write one line for each cell
            foreach (Cell cell in _cells)
            {
                sw.WriteLine(string.Format("{0:F2}, {1:F2}, {2:F3}", cell.Latitude, cell.Longitude, cell.Area));
            }

            // Done
            sw.Close();

            // Done
            OpenTemp.WriteLine(string.Format("  Writing finished: {0} cells written", _cells.Count));
            return 0;
        }

            // Loop over all stations and series
            int nSeries = 0;
            foreach (Station station in _stations.Values)
            {
                foreach (Byte seriesNumber in station.SeriesNumbers)
                {
                    SortedList<DateTime, float?> readings = station.GetReadings(seriesNumber);
                    DateTime firstDate = readings.Keys[0];
                    DateTime lastDate = readings.Keys[readings.Keys.Count - 1];

                    sw.WriteLine(string.Format("{0}, {1}, {2}, {3:F2}, {4:F2}, {5:F2}, {6:F3}",
                        station.Country,
                        station.StationID,
                        seriesNumber,
                        station.Latitude,
                        firstDate.Year + (float)firstDate.Month / 12.0f,
                        lastDate.Year  + (float)lastDate.Month  / 12.0f,
                        station.GetSeriesOffset(seriesNumber)));

                    nSeries++;
                }
            }

            // Done
            sw.Close();

            // Done
            OpenTemp.WriteLine(string.Format("  Writing finished: {0} series written", nSeries));
            return 0;
        }

                // Store average readings for all stations
                foreach (Station station in _stations.Values)
                {
                    // Station average
                    int nSeries = 0;
                    float stationAverage = 0.0f;
                    foreach (Byte series in station.SeriesNumbers)
                    {
                        float seriesOffset = (useOffsets ? station.GetSeriesOffset(series) : 0.0f);
                        SortedList<DateTime, float?> readings = station.GetReadings(series);
                        if (readings.ContainsKey(date))
                        {
                            if (!readings[date].HasValue) continue;
                            stationAverage += readings[date].Value + seriesOffset;
                            nSeries++;
                        }
                    }
                    if (nSeries == 0) continue;
                    stationAverage /= (float)nSeries;

                    // Store the station average
                    stationAverages.Add(station.StationID, stationAverage);
                }

                // Iterate over all mesh cells
                float overallAverage = 0.0f;
                float cellAreaInAverage = 0.0f;
                foreach (Cell cell in _cells)
                {
                    float weight = 0.0f;
                    float weightSum = 0.0f;
                    float cellAverage = 0.0f;

                    foreach (CellStation cellStation in cell.Stations)
                    {
                        if (stationAverages.ContainsKey(cellStation.station.StationID))
                        {
                            weight = cellStation.weight;
                            weightSum += weight;
                            cellAverage += weight * stationAverages[cellStation.station.StationID];
                        }
                    }
                    if (weightSum > 0.0f)
                    {
                        cellAverage /= weightSum;
                        overallAverage += cellAverage * cell.Area;
                        cellAreaInAverage += cell.Area;
                    }
                }
                if (cellAreaInAverage > 0)
                {
                    overallAverage /= cellAreaInAverage;
                    _monthlyAverages.Add(date, overallAverage);      // TODO: Remove hard-code 0.1x scale
                }

                // Iterate and continue
                // TODO: Add error handling for months with no station data
                nMonths++;
                date = date.AddMonths(1);
                if (date.Month == 1)
                {
                    OpenTemp.Write(string.Format(" {0}", date.Year));
                }
            }

            // Done
            OpenTemp.WriteLine();
            OpenTemp.WriteLine(string.Format("  Monthly overall averages completed"));
            return nMonths;
        }

                    // Loop over every month
                    int nMonths = 0;
                    float difference = 0.0f;
                    foreach (DateTime date in readings.Keys)
                    {
                        if (!readings[date].HasValue) continue;
                        if (_monthlyAverages.ContainsKey(date))
                        {
                            difference += _monthlyAverages[date] - readings[date].Value;
                            nMonths++;
                        }
                    }

                    // Store series offset
                    if (nMonths > 0)
                    {
                        station.SetSeriesOffset(seriesNumber, difference / nMonths);
                        nSeries++;
                    }
                }
            }

            // Done
            OpenTemp.WriteLine(string.Format("  Series offsets completed for {0} series", nSeries));
            return nSeries;
        }

            // Open the file
            StreamWriter sw;
            try
            {
                sw = new StreamWriter(_outputMonthlyFile, false);      // Overwrite (do not append)
                OpenTemp.WriteLine(”  File opened for writing”);
            }
            catch (Exception ex)
            {
                OpenTemp.WriteLine(string.Format(”  Exception thrown when opening file:  {0}”, ex.ToString()));
                return -1;
            }
            if (sw == null)
            {
                OpenTemp.WriteLine(”  Failed to open file (check that it exists and the path is correct)”);
                return -2;
            }

            // Write header
            sw.Write(”YEAR,MONTH,AVG”);
            sw.WriteLine();

            // Write one line at a time
            int nMonths = 0;
            foreach (KeyValuePair<DateTime, float> average in _monthlyAverages)
            {
                sw.WriteLine(string.Format(”{0}, {1}, {2}”, average.Key.Year, average.Key.Month, average.Value.ToString(”F2″)));
                nMonths++;
            }

            // Done
            sw.Close();

            // Open the file
            StreamWriter sw;
            try
            {
                sw = new StreamWriter(_outputYearlyFile, false);      // Overwrite (do not append)
                OpenTemp.WriteLine(”  File opened for writing”);
            }
            catch (Exception ex)
            {
                OpenTemp.WriteLine(string.Format(”  Exception thrown when opening file:  {0}”, ex.ToString()));
                return -1;
            }
            if (sw == null)
            {
                OpenTemp.WriteLine(”  Failed to open file (check that it exists and the path is correct)”);
                return -2;
            }

            // Write header
            sw.Write(”YEAR,AVG”);
            sw.WriteLine();

            // Calculate yearly averages
            int nMonths = 0;
            SortedList<int, float> yearAverages = new SortedList<int, float>();
            foreach (KeyValuePair<DateTime, float> average in _monthlyAverages)
            {
                if (!yearAverages.ContainsKey(average.Key.Year))
                {
                    yearAverages.Add(average.Key.Year, 0.0f);
                }
                yearAverages[average.Key.Year] += average.Value / 12.0f;
                nMonths++;
            }

            // Write yearly data
            foreach (int year in yearAverages.Keys)
            {
                sw.WriteLine(string.Format(”{0}, {1}”, year, yearAverages[year].ToString(”F2″)));
            }
            // Done
            sw.Close();