File Coverage

blib/lib/Geo/WeatherNWS.pm

Criterion	Covered	Total	%
statement	280	404	69.3
branch	118	182	64.8
condition	70	122	57.3
subroutine	17	25	68.0
pod	20	20	100.0
total	505	753	67.0

package Geo::WeatherNWS;

#------------------------------------------------------------------------------
#
# Package Name:  Get Observations from NWS (Geo::WeatherNWS)
#
# Last Modified:  18 December 2001 - Prepared for CPAN - Marc Slagle
#                 24 February 2002 - Adding server/error code - Marc
#                 10 August 2011   - changed FTP server name, added tests,
#                                    docs, some restructuring. - Bob Ernst
#                 14 November 2012 - removed unneeded /d after tr,
#                                    make network tests optional,
#                                    check status of opens - Bob
#                 26 November 2012 - Address bug 14632 (METAR Decoding) from dstroma
#                                    Address bug 27513 (Geo-WeatherNWS returns wrong station code)
#                                    from Guenter Knauf
#                                    Fix issues with undefined values,
#                                    Change some conversion constants,
#                                    Round instead of truncate results,
#                                    Only calculate windchill for proper range,
#                                    "ptemerature" is now spelled "ptemperature"
#                                    Fixed handling of condition text
#                                    Relax ICAO naming rules
#                                    Change ICAO website
#                                    Change http web site from weather.noaa.gov
#                                    to www.aviationweather.gov, and change parsing to match.
#                                    Add report_date and report_time items.
#                                    - Bob
#                 27 November 2012 - Add POD documentation for new functions.
#                 20 December 2012 - Handle undefined dewpoint
#                                    Minor performance improvement
#                                    Add test for getreporthttp
#                 22 December 2012 - Clean up and avoid division by zero
#
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# We need these
#------------------------------------------------------------------------------

require 5.005_62;
use strict;
use warnings;
use Net::FTP ();
use POSIX ();
use Carp ();

#------------------------------------------------------------------------------
# Version
#------------------------------------------------------------------------------

our $VERSION = '1.053';

#------------------------------------------------------------------------------
# Round function
# Using Math::Round would add another dependency
#------------------------------------------------------------------------------

sub round {
    my $float = shift;
    my $rounded;

    if ( defined $float && $float ne "" ) {
        $rounded = sprintf "%.0f", $float;
    }
    return $rounded;
}

#------------------------------------------------------------------------------
# Temperature conversion
# If the temperature we are converting from is undefined,
# then the temperature we are converting to is also undefined.
#------------------------------------------------------------------------------

sub convert_f_to_c {
    my $fahrenheit = shift;
    my $celsius;

    if ( defined $fahrenheit && $fahrenheit ne "" ) {
        $celsius = (5.0/9.0) * ($fahrenheit - 32.0);
    }
    return $celsius;
}

sub convert_c_to_f {
    my $celsius = shift;
    my $fahrenheit;

    if ( defined $celsius && $celsius ne "" )  {
        $fahrenheit = ((9.0/5.0) * $celsius) + 32.0;
    }
    return $fahrenheit;
}

#------------------------------------------------------------------------------
# Windchill
#------------------------------------------------------------------------------

sub windchill {
    my $F = shift;
    my $wind_speed_mph = shift;
    my $windchill;

    # This is the North American wind chill index.
    # Windchill temperature is only defined for:
    # *  temperatures at or below 50 F
    # *  wind speed above 3 mph
    # Bright sunshine may increase the wind chill temperature by
    # 10 to 18 degress F.

    if ( defined $F && $F ne "" && defined $wind_speed_mph && $wind_speed_mph ne "" ) {
        # Old Formula
        # my $Windc=int(
        #    0.0817*
        #    (3.71*$Self->{windspeedmph}**0.5 + 5.81 - 0.25*$Self->{windspeedmph})*
        #    ($F - 91.4) + 91.4);

        # New Formula
        if ($F <= 50 && $wind_speed_mph > 3) {
            $windchill =
                35.74 +
                ( 0.6215 * $F ) -
                ( 35.75 * ( $wind_speed_mph**0.16 ) ) +
                ( ( 0.4275 * $F ) * ( $wind_speed_mph**0.16 ) );
        }
    }
    return $windchill;
}

#------------------------------------------------------------------------------
# Heat Index
#------------------------------------------------------------------------------

sub heat_index {
    my $F = shift;
    my $rh = shift;
    my $heat_index;

    if ( defined $F && $F ne "" && defined $rh && $rh ne "" ) {
        $heat_index =
            -42.379 +
            2.04901523 * $F +
            10.14333127 * $rh -
            0.22475541 * $F * $rh -
            6.83783e-03 * $F**2 -
            5.481717e-02 * $rh**2 +
            1.22874e-03 * $F**2 * $rh +
            8.5282e-04 * $F * $rh**2 -
            1.99e-06 * $F**2 * $rh**2;
    }
    return $heat_index;
}

#------------------------------------------------------------------------------
# Convert wind speed from nautical miles per hour to miles per hour
#------------------------------------------------------------------------------

sub convert_kts_to_mph {
    my $knots = shift;
    my $mph;

    if ( defined $knots && $knots ne "" ) {
        $mph = $knots * 1.150779;
    }
    return $mph;
}

#------------------------------------------------------------------------------
# Convert wind speed from nautical miles per hour to kilometers per hour
#------------------------------------------------------------------------------

sub convert_kts_to_kmh {
    my $knots = shift;
    my $kmh;

    if ( defined $knots && $knots ne "" ) {
        $kmh = $knots * 1.852;
    }
    return $kmh;
}

#------------------------------------------------------------------------------
# Convert miles to kilometers
#------------------------------------------------------------------------------

sub convert_miles_to_km {
    my $miles = shift;
    my $km;

    if ( defined $miles && $miles ne "" ) {
        $km = $miles * 1.609344;
    }
    return $km;
}

#------------------------------------------------------------------------------
# Translate Weather into readable Conditions Text
#
# Reference is WMO Code Table 4678
#------------------------------------------------------------------------------

sub translate_weather {
    my $coded = shift;
    my $old_conditionstext = shift;
    my $old_conditions1 = shift;
    my $old_conditions2 = shift;
    my ($conditionstext, $conditions1, $conditions2, $intensity);

    # We use %Converter to translate 2-letter codes into text

    my %Converter = (
        BR => 'Mist',
        TS => 'Thunderstorm',
        MI => 'Shallow',
        PR => 'Partial',
        BC => 'Patches',
        DR => 'Low Drifting',
        BL => 'Blowing',
        SH => 'Shower',
        FZ => 'Freezing',
        DZ => 'Drizzle',
        RA => 'Rain',
        SN => 'Snow',
        SG => 'Snow Grains',
        IC => 'Ice Crystals',
        PE => 'Ice Pellets',
        PL => 'Ice Pellets',
        GR => 'Hail',
        GS => 'Small Hail/Snow',
        UP => 'Unknown Precipitation',
        FG => 'Fog',
        FU => 'Smoke',
        VA => 'Volcanic Ash',
        DU => 'Widespread Dust',
        SA => 'Sand',
        HZ => 'Haze',
        PY => 'Spray',
        PO => 'Dust Devils',
        SQ => 'Squalls',
        FC => 'Tornado',
        SS => 'Sandstorm'
    );

    if ( $coded =~ /^[-+]/ ) {
        # Heavy(+) or Light(-) condition

        if ( !$old_conditions1 ) {
            my ( $Block1, $Block2 );
            my $Modifier = substr( $coded, 0, 1 ); # +/-
            my $Block1t  = substr( $coded, 1, 2 ); # e.g. TS
            my $Block2t  = substr( $coded, 3, 4 ); # e.g. RA

            $Block1 = $Converter{$Block1t};        # e.g. Thunderstorm
            $conditions1 = $Block1;                # e.g. Thunderstorm

            if ($Block2t) {
                $Block2 = $Converter{$Block2t};    # e.g. Rain
                $conditions2 = $Block2;            # e.g. Rain
            }

            if ( $Modifier =~ /^\-/ ) {
                $Block1 = "Light $Block1";         # e.g. Light Thunderstorm
                $intensity = "Light";
            }
            elsif ( $Modifier =~ /^\+/ ) {
                $Block1 = "Heavy $Block1";         # e.g. Heavy Thunderstorm
                $intensity = "Heavy";
            }

            if ($Block2) {
                $Block1 = "$Block1 $Block2";       # e.g. Light Thunderstorm Rain
            }

            if ($old_conditionstext) {
                if ( $Block1 eq "SH" ) {
                    $conditionstext = "$Block2 of $Block1";
                    $conditions1    = "Showers of";
                }
                else {
                    $conditionstext = "$old_conditionstext and $Block1";
                }
            }
            else {
                $conditionstext = $Block1;
            }
        }
    }
    else {
        # Moderate condition

        if ( !$old_conditions1 ) {
            my ( $Block1, $Block2 );
            my $Block1t = substr( $coded, 0, 2 ); # e.g. TS
            my $Block2t = substr( $coded, 2, 4 ); # e.g. RA

            $Block1 = $Converter{$Block1t};       # e.g. Thunderstorm
            $conditions1 = $Block1;               # e.g. Thunderstorm

            if ($Block2t) {
                $Block2      = $Converter{$Block2t};
                $conditions2 = $Block2;
                $Block1      = "$Block1 $Block2";
            }

            if ($old_conditionstext) {
                if ( $Block1 eq "SH" ) {
                    $conditionstext = "$Block2 of $Block1";
                    $conditions1    = "Showers of";
                 }
                 else {
                    $conditionstext = "$old_conditionstext and $Block1";
                 }
            }
            else {
                $conditionstext = $Block1;
            }
        }
    }
    return ($conditionstext, $conditions1, $conditions2, $intensity);
}

#------------------------------------------------------------------------------
# Lets create a new self
#------------------------------------------------------------------------------

sub new {
    my $Proto = shift;
    my $Class = ref($Proto) || $Proto || __PACKAGE__;
    my $Self  = {};

    $Self->{servername} = "tgftp.nws.noaa.gov";
    $Self->{username}   = "anonymous";
    $Self->{password}   = '[e-mail]';
    $Self->{directory}  = "/data/observations/metar/stations";
    $Self->{timeout}    = 120;

    bless $Self, $Class;
    return $Self;
}

#------------------------------------------------------------------------------
# Adding ability to edit server/user/directory at runtime...
#------------------------------------------------------------------------------

sub setservername {
    my $Self       = shift;
    my $Servername = shift;
    $Self->{servername} = $Servername;
    return $Self;
}

sub setusername {
    my $Self = shift;
    my $User = shift;
    $Self->{username} = $User;
    return $Self;
}

sub setpassword {
    my $Self = shift;
    my $Pass = shift;
    $Self->{password} = $Pass;
    return $Self;
}

sub setdirectory {
    my $Self = shift;
    my $Dir  = shift;
    $Self->{directory} = $Dir;
    return $Self;
}

sub settemplatefile {
    my $Self  = shift;
    my $Tfile = shift;
    $Self->{tfile} = $Tfile;
    return $Self;
}

sub settimeout {
    my $Self    = shift;
    my $Seconds = shift;
    $Self->{timeout} = $Seconds;
    return $Self;
}

#------------------------------------------------------------------------------
# Here we get to FTP to the NWS and get the data
#------------------------------------------------------------------------------

sub getreporthttp {
    my $Self = shift;
    my $Code = shift;
    # The old site was: http://weather.noaa.gov/cgi-bin/mgetmetar.pl?cccc=$Code
    $Self->{http} =
        'http://www.aviationweather.gov/adds/metars/?station_ids=' . $Code . '&chk_metars=on&hoursStr=most+recent+only';
    my $Ret = &getreport( $Self, $Code );
    return $Ret;
}

sub getreport {
    my $Self    = shift;
    my $Station = shift;

    $Self->{error} = "0";
    my $Tmpfile = POSIX::tmpnam();
    my $Code    = uc($Station);

    if ( !$Code ) {
        $Self->{error}     = "1";
        $Self->{errortext} = "No Station Code Entered\n";
        return $Self;
    }

    if ( $Self->{http} ) {
        require LWP::UserAgent;
        my $Ua = LWP::UserAgent->new();
        $Ua->agent("Geo::WeatherNWS $VERSION");

        my $Req = HTTP::Request->new( GET => $Self->{http} );
        $Req->content_type('application/x-www-form-urlencoded');
        my $Res = $Ua->request($Req);

        if ( $Res->is_success ) {
            my @Lines = split( /\n/, $Res->content );
            foreach my $Line (@Lines) {
                if ( $Line =~ /<(TITLE|H1|H2)>/ ) {
                    # ignore
                }
                else {
                    # Remove HTML elements.
                    # (This isn't very robust, but it gets the job done for now.)
                    $Line =~ s/<[^>]*>//g;

                    # If the line starts with an ICAO, then the line is an observation (we hope)
                    if ( $Line =~ /^[A-Z][A-Z0-9]{3}\s/ ) {
                        $Self->{obs} = $Line;
                        last;
                    }
                }
            }
        }
    }
    else {

        # Some users needed this for firewalls...
        my $Ftp = Net::FTP->new(
            $Self->{servername},
            Debug   => 0,
            Passive => 1,
            Timeout => $Self->{timeout}
        );

        # my $Ftp=Net::FTP->new($Self->{servername}, Debug => 0);
        if ( !defined $Ftp ) {
            $Self->{error}     = 1;
            $Self->{errortext} = "Cannot connect to $Self->{servername}: $@";
            return $Self;
        }
        $Ftp->login( $Self->{username}, $Self->{password} );
        my $Rcode   = $Ftp->code();
        my $Message = $Ftp->message();

        if ( $Rcode =~ /^[45]/ ) {
            $Self->{error}     = $Rcode;
            $Self->{errortext} = $Message;
            return $Self;
        }

        $Ftp->cwd( $Self->{directory} );
        $Rcode   = $Ftp->code();
        $Message = $Ftp->message();

        if ( $Rcode =~ /^[45]/ ) {
            $Self->{error}     = $Rcode;
            $Self->{errortext} = $Message;
            return $Self;
        }

        $Rcode   = $Ftp->get( "$Code.TXT", $Tmpfile );
        $Rcode   = $Ftp->code();
        $Message = $Ftp->message();
        $Ftp->quit;

        if ( $Rcode =~ /^[45]/ ) {
            $Self->{error}     = $Rcode;
            $Self->{errortext} = $Message;
            return $Self;
        }

        local $/;    # enable slurp mode
        open my $F, '<', $Tmpfile or
                Carp::croak "error opening temp input $Tmpfile: $!";
        my $Data = <$F>;
        close($F);
        unlink($Tmpfile);

        $Data =~ tr/\n/ /;
        $Self->{obs} = $Data;
    }

    $Self->decode();
    return $Self;
}

#------------------------------------------------------------------------------
# Decodeobs takes the obs in a string format and decodes them
#------------------------------------------------------------------------------

sub decodeobs {
    my $Self = shift;
    my $Obs  = shift;
    $Self->{obs} = $Obs;
    $Self->decode();
    return $Self;
}

#------------------------------------------------------------------------------
# Decode does the work, and is only called internally
#------------------------------------------------------------------------------

sub decode {
    my $Self = shift;
    my @Cloudlevels;

    my @Splitter = split( /\s+/, $Self->{obs} );

 #------------------------------------------------------------------------------
 # Break the METAR observations down and decode
 #------------------------------------------------------------------------------

    my $have_icao_code = 0;
    my $column = 0;

    foreach my $Line (@Splitter) {
        $column++;


 #------------------------------------------------------------------------------
 # Report date and time
 # These aren't always present (for example, from the http interface)
 #------------------------------------------------------------------------------

        if ( $column == 1 && $Line =~ /^\d{4}\/\d{2}\/\d{2}$/) {
            $Self->{report_date} = $Line;
        }

        if ( $column == 2 && $Line =~ /^\d{2}:\d{2}$/) {
            $Self->{report_time} = $Line;
        }

 #------------------------------------------------------------------------------
 # ICAO station code
 #------------------------------------------------------------------------------

        if ( ( $Line =~ /^([A-Z][A-Z0-9]{3})/ ) &&
             ( !$have_icao_code ) ) {
            # Use the first value that looks like the ICAO code.
            # This should either be the first item, or
            # the third item if there is a leading date and time.
            # (Before we checked have_icao_code, we'd get values
            # like TSRA or FZFG later in the observation being treated
            # as the ICAO code.)
            # We also allow the last three characters to be digits.

            # There was a check for "AUTO" above before, for now
            # we'll add an extra check for that value. (AUTO should
            # show up in the fifth column.)
            Carp::croak "Unexpected value AUTO for ICAO code" if $Line eq "AUTO";

            $Self->{code} = $Line;
            $have_icao_code = 1;
        }

 #------------------------------------------------------------------------------
 # Report Time
 #------------------------------------------------------------------------------

        elsif ( $Line =~ /([0-9]Z)$/ ) {
            my $Timez = substr( $Line, 2, 4 );
            $Self->{time} = $Timez;
            $Self->{day} = substr( $Line, 0, 2 );
        }

 #------------------------------------------------------------------------------
 # Wind speed and direction
 #------------------------------------------------------------------------------

        elsif ( $Line =~ /([0-9]KT)$/ ) {
            my $Newline;
            my $Variable;

            if ( $Line =~ /VRB/ ) {
                $Newline = substr( $Line, 3 );
                $Variable = "1";
            }
            else {
                $Newline = $Line;
            }

            my $Winddir = substr( $Newline, 0, 3 );
            $Winddir =~ tr/[A-Z]/ /d;
            $Winddir = $Winddir - 0;
            my $Winddirtxt;

            if ($Variable) {
                $Winddirtxt = "Variable";
            }
            elsif ( ( $Winddir <= 22.5 ) || ( $Winddir >= 337.5 ) ) {
                $Winddirtxt = "North";
            }
            elsif ( ( $Winddir <= 67.5 ) && ( $Winddir >= 22.5 ) ) {
                $Winddirtxt = "Northeast";
            }
            elsif ( ( $Winddir <= 112.5 ) && ( $Winddir >= 67.5 ) ) {
                $Winddirtxt = "East";
            }
            elsif ( ( $Winddir <= 157.5 ) && ( $Winddir >= 112.5 ) ) {
                $Winddirtxt = "Southeast";
            }
            elsif ( ( $Winddir <= 202.5 ) && ( $Winddir >= 157.5 ) ) {
                $Winddirtxt = "South";
            }
            elsif ( ( $Winddir <= 247.5 ) && ( $Winddir >= 202.5 ) ) {
                $Winddirtxt = "Southwest";
            }
            elsif ( ( $Winddir <= 292.5 ) && ( $Winddir >= 247.5 ) ) {
                $Winddirtxt = "West";
            }
            elsif ( ( $Winddir <= 337.5 ) && ( $Winddir >= 292.5 ) ) {
                $Winddirtxt = "Northwest";
            }

            my $Windspeedkts = substr( $Line, 3 );
            my $Windgustkts = 0;

            if ( $Windspeedkts =~ /G/ ) {
                ($Windspeedkts, $Windgustkts) = split( /G/, $Windspeedkts );
                if ( ! defined $Windgustkts || $Windgustkts eq "" ) {
                    $Windgustkts = 0;
                }
            }

            $Windspeedkts =~ tr/[A-Z]//d;
            $Windgustkts  =~ tr/[A-Z]//d;

            if ( $Windspeedkts == 0 ) {
                $Winddirtxt = "Calm";
            }

            my $MPH  = round( convert_kts_to_mph($Windspeedkts) );
            my $GMPH = round( convert_kts_to_mph($Windgustkts) );
            my $KMH  = round( convert_kts_to_kmh($Windspeedkts) );
            my $GKMH = round( convert_kts_to_kmh($Windgustkts) );

            $Self->{windspeedkts} = $Windspeedkts;
            $Self->{windgustkts}  = $Windgustkts;
            $Self->{windspeedkts} = $Self->{windspeedkts} - 0;
            $Self->{windspeedmph} = $MPH;
            $Self->{windspeedkmh} = $KMH;
            $Self->{windgustmph}  = $GMPH;
            $Self->{windgustkmh}  = $GKMH;
            $Self->{winddirtext}  = $Winddirtxt;
            $Self->{winddir}      = $Winddir;
            $Self->{winddir}      = $Self->{winddir} - 0;
        }

 #------------------------------------------------------------------------------
 # Current Visibility
 #------------------------------------------------------------------------------

        elsif ( $Line =~ /([0-9]SM)$/ ) {
            $DB::single = 1;
            $Line =~ tr/[A-Z]//d;

 #------------------------------------------------------------------------------
 # Some stations were reporting fractions for this value
 #------------------------------------------------------------------------------

            if ( $Line =~ /\// ) {
                my ($Numerator,$Denominator) = split( /\//, $Line );
                if ( defined $Denominator && $Denominator ne "" ) {
                    if ( $Denominator != 0 ) {
                        $Line = $Numerator / $Denominator;
                    }
                    else {
                        $Line = undef;
                    }
                }
                else {
                    $Line = $Numerator;
                }
            }

            my $Viskm = convert_miles_to_km( $Line );
            $Self->{visibility_mi} = round($Line);
            $Self->{visibility_km} = round($Viskm);
        }

 #------------------------------------------------------------------------------
 # Current Conditions
 #------------------------------------------------------------------------------

        elsif (
            ( $Line =~ /
                (BR|TS|MI|PR|BC|DR|BL|SH|FZ|DZ|RA|SN|SG|IC|PE|PL|GR|GS|UP|FG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS)
                ([A-Z])*
                /x)
            || ( $Line =~ /^VC([A-Z])*/ )
            || ( $Line =~ /[\+\-]VC([A-Z])*/ ) )
        {
            my ($conditionstext, $conditions1, $conditions2, $intensity) =
                translate_weather($Line, $Self->{conditionstext}, $Self->{conditions1},$Self->{conditions2});
            $Self->{conditionstext} = $conditionstext if defined $conditionstext;
            $Self->{conditions1} = $conditions1 if defined $conditions1;
            $Self->{conditions2} = $conditions2 if defined $conditions2;
            $Self->{intensity} = $intensity if defined $intensity;
        }

 #------------------------------------------------------------------------------
 # Cloud Cover
 #------------------------------------------------------------------------------

        elsif (( $Line =~ /^(VV[0-9])/ )
            || ( $Line =~ /^(SKC[0-9])/ )
            || ( $Line =~ /^(CLR)/ )
            || ( $Line =~ /^(FEW)/ )
            || ( $Line =~ /^(SCT[0-9])/ )
            || ( $Line =~ /^(BKN[0-9])/ )
            || ( $Line =~ /^(OVC[0-9])/ ) )
        {

            push( @Cloudlevels, $Line );

            if ( $Line =~ /^(CLR)/ ) {
                $Self->{cloudcover} = "Clear";
            }
            elsif ( $Line =~ /^(FEW)/ ) {
                $Self->{cloudcover} = "Fair";
            }
            elsif ( $Line =~ /^(SCT[0-9])/ ) {
                $Self->{cloudcover} = "Partly Cloudy";
            }
            elsif ( $Line =~ /^(BKN[0-9])/ ) {
                $Self->{cloudcover} = "Mostly Cloudy";
            }
            elsif ( $Line =~ /^(OVC[0-9])/ ) {
                $Self->{cloudcover} = "Cloudy";
            }

            if ( !$Self->{conditionstext} ) {
                $Self->{conditionstext} = $Self->{cloudcover};
            }
        }

 #------------------------------------------------------------------------------
 # Get the temperature/dewpoint and calculate windchill/heat index
 #------------------------------------------------------------------------------

        elsif (( $Line =~ /^([0-9][0-9]\/[0-9][0-9])/ )
            || ( $Line =~ /^(M[0-9][0-9]\/)/ )
            || ( $Line =~ /^(M[0-9][0-9]\/M[0-9][0-9])/ )
            || ( $Line =~ /^([0-9][0-9]\/M[0-9][0-9])/ ) )
        {
            my ($Temperature, $Dewpoint) = split( /\//, $Line );
            if ( $Dewpoint eq "" ) {
                $Dewpoint = undef;
            }

            if ( $Temperature =~ /M/ ) {
                $Temperature =~ tr/[A-Z]//d;
                $Temperature = ( $Temperature - ( $Temperature * 2 ) );
            }

            if ( defined $Dewpoint && $Dewpoint =~ /M/ ) {
                $Dewpoint =~ tr/[A-Z]//d;
                $Dewpoint = ( $Dewpoint - ( $Dewpoint * 2 ) );
            }

            my $Tempf = convert_c_to_f( $Temperature );
            my $Dewf  = convert_c_to_f( $Dewpoint );

            my $Es =
              6.11 * 10.0**( 7.5 * $Temperature / ( 237.7 + $Temperature ) );
            my $E;
            my $rh;
            if ( defined $Dewpoint ) {
                $E = 6.11 * 10.0**( 7.5 * $Dewpoint / ( 237.7 + $Dewpoint ) );
                if ($Es != 0) {
                    $rh = round( ( $E / $Es ) * 100 );
                }
            }

            my $F = $Tempf;

            my $Heati = heat_index( $F, $rh );
            my $Heatic = convert_f_to_c( $Heati );

            $Tempf = round($Tempf);
            $Dewf = round($Dewf);
            $Heati = round($Heati);
            $Heatic = round($Heatic);

            my $Windc = windchill( $F, $Self->{windspeedmph} );
            my $Windcc = convert_f_to_c( $Windc );
            $Windc = round($Windc);
            $Windcc = round($Windcc);

            $Self->{temperature_c}     = $Temperature;
            $Self->{temperature_f}     = $Tempf;
            $Self->{dewpoint_c}        = $Dewpoint;
            $Self->{dewpoint_f}        = $Dewf;
            $Self->{relative_humidity} = $rh;
            $Self->{heat_index_c}      = $Heatic;
            $Self->{heat_index_f}      = $Heati;
            $Self->{windchill_c}       = $Windcc;
            $Self->{windchill_f}       = $Windc;
        }

 #------------------------------------------------------------------------------
 # Calculate the atmospheric pressure in different formats.
 # Based on report (inches of mercury)
 #------------------------------------------------------------------------------

        elsif ( $Line =~ /^(A[0-9]{4})/ ) {
            $Line =~ tr/[A-Z]//d;
            my $Part1 = substr( $Line, 0, 2 );
            my $Part2 = substr( $Line, 2, 4 );
            $Self->{pressure_inhg} = "$Part1.$Part2";

            my $mb   = $Self->{pressure_inhg} * 33.8639;
            my $mmHg = $Self->{pressure_inhg} * 25.4;
            my $lbin = ( $Self->{pressure_inhg} * 0.491154 );
            my $kgcm = ( $Self->{pressure_inhg} * 0.0345316 );
            $mb = round($mb);
            $mmHg = round($mmHg);

            $Self->{pressure_mb}   = $mb;
            $Self->{pressure_mmhg} = $mmHg;
            $Self->{pressure_lbin} = $lbin;
            $Self->{pressure_kgcm} = $kgcm;
        }

 #------------------------------------------------------------------------------
 # Calculate the atmospheric pressure in different formats.
 # Based on report (millibars)
 #------------------------------------------------------------------------------

        elsif ( $Line =~ /^(Q[0-9]{4})/ ) {
            $Line =~ tr/[A-Z]//d;
            $Self->{pressure_mb} = $Line;

            my $inhg = ( $Self->{pressure_mb} * 0.02953 );
            $Self->{pressure_inhg} = sprintf( "%.2f", $inhg );
            my $mmHg = $Self->{pressure_inhg} * 25.4;
            my $lbin = ( $Self->{pressure_inhg} * 0.491154 );
            my $kgcm = ( $Self->{pressure_inhg} * 0.0345316 );
            $mmHg = round($mmHg);

            $Self->{pressure_mmhg} = $mmHg;
            $Self->{pressure_lbin} = $lbin;
            $Self->{pressure_kgcm} = $kgcm;
        }

 #------------------------------------------------------------------------------
 # If the remarks section is starting, we are done
 #------------------------------------------------------------------------------

        elsif ( $Line =~ /^(RMK)/ ) {
            last;
        }
    }

 #------------------------------------------------------------------------------
 # Read the remarks into an array for later processing
 #------------------------------------------------------------------------------

    my $Remarks = 0;
    my @Remarkarray;

    foreach my $Line (@Splitter) {
        if ( $Line =~ /^(RMK)/ ) {
            $Remarks = 1;
        }

        if ($Remarks) {
            push( @Remarkarray, $Line );
        }
    }

 #------------------------------------------------------------------------------
 # Delete the temp file
 #------------------------------------------------------------------------------

    $Self->{cloudlevel_arrayref} = \@Cloudlevels;
    $Self->{station_type}        = "Manual";

 #------------------------------------------------------------------------------
 # Now we process remarks.  These aren't all going to be in the report,
 # and usually aren't.  This has made it hard to develop.  This section
 # is basically incomplete, but you can get some of the data out
 #------------------------------------------------------------------------------

    foreach my $Remark (@Remarkarray) {
        if ($Remark) {
            my $Line = $Remark;

            if ( $Remark =~ /^AO[1-2]/ ) {
                $Self->{station_type} = "Automated";
            }
            elsif ( $Remark =~ /^SLP/ ) {
                $Remark =~ tr/[A-Z]//d;

                if ( !defined $Remark || $Remark eq "") {
                    $Remark = 0;
                }

                if ( ($Remark) && ( $Remark >= 800 ) ) {
                    $Remark = $Remark * .1;
                    $Remark = $Remark + 900;
                }
                else {
                    $Remark = $Remark * .1;
                    $Remark = $Remark + 1000;
                }

                $Self->{slp_inhg} = ( $Remark * 0.0295300 );
                $Self->{slp_inhg} = substr( $Self->{slp_inhg}, 0, 5 );
                $Self->{slp_mmhg} = round( $Remark * 0.750062 );
                $Self->{slp_lbin} = ( $Remark * 0.0145038 );
                $Self->{slp_kgcm} = ( $Remark * 0.00101972 );
                $Self->{slp_mb}   = round($Remark);
            }

 #------------------------------------------------------------------------------
 # Thunderstorm info
 #------------------------------------------------------------------------------

            elsif ( $Remark =~ /^TS/ ) {
                $Self->{storm} = $Remark;
            }

 #------------------------------------------------------------------------------
 # Three hour pressure tendency
 #------------------------------------------------------------------------------

            elsif ( $Remark =~ /^5[0-9]/ ) {
                $Self->{thpressure} = $Remark;
            }

 #------------------------------------------------------------------------------
 # Automated station needs maintenance
 #------------------------------------------------------------------------------

            elsif ( $Remark =~ /\$/ ) {
                $Self->{maintenance} = $Remark;
            }

 #------------------------------------------------------------------------------
 # Precipitation since last report (100ths of an inch)
 #------------------------------------------------------------------------------

            elsif ( $Remark =~ /^P[0-9]/ ) {
                $Self->{precipslr} = $Remark;
            }

 #------------------------------------------------------------------------------
 # Event beginning or ending
 #------------------------------------------------------------------------------

            elsif ( $Line =~ /^(BRB|TSB|MIB|PRB|BCB|DRB|BLB|SHB|FZB|DZB|RAB|SNB|SGB|ICB|PEB|GRB|GSB|UPB|FGB|FUB|VAB|DUB|SAB|HZB|PYB|POB|SQB|FCB|SSB)/ )
            {
                $Self->{eventbe} = $Remark;
            }

 #------------------------------------------------------------------------------
 # Precise temperature reading
 #------------------------------------------------------------------------------

            elsif ( $Remark =~ /^T[0-9]/ ) {
                $Self->{ptemperature} = $Remark;
            }
        }
    }

    my $Templatefile = $Self->{tfile};

    if ($Templatefile) {
        local $/;    # enable slurp mode
        open my $F, '<', $Templatefile or
            Carp::croak "error opening template file $Templatefile: $!";
        my $tout = <$F>;
        close($F);

        $tout =~ s{ %% ( .*? ) %% }
                        { exists( $Self->{$1} )
                                ? $Self->{$1}
                                : ""
                        }gsex;

        $Self->{templateout} = $tout;
    }

    $Self->{remark_arrayref} = \@Remarkarray;
    return $Self;
}

1;
__END__