def testTwoStations(self):
     """According to jan.ucc.nau.edu/~cvm/latlongdist, the distance
     between Ithaca and Brewton is 1576.7066 km
     """
     dist1 = compute_arc_dist(self.STATION_A, self.STATION_B)
     dist2 = compute_arc_dist(self.STATION_B, self.STATION_A)
     self.assertAlmostEquals(dist1, 1576.7066, delta=self.DELTA)
     self.assertAlmostEquals(dist2, 1576.7066, delta=self.DELTA)
def find_neighborhood(station, stations_list, numsrt=40, mindist=200.0, **kwargs):
    """
    Determines the neighborhood comprised of the closes numsrt neighbors located
    around a given station. 
    
    :Param stations:
        The candidate *Station* object.
    :Param stations_list:
        A list of *Station* objects to use to determine the neighborhood.
    :Param numsrt:
        The number of *Station* objects which should comprise the resulting 
        neighberhood.
    :Param mindist: 
        The minimum distance to use while searching through the *Station* objects
        iteratively. Most likely will not be used.
    
    :Return:
        The neighborhood as a list of two-element tuples. The tuples will each
        be of the form (Station.coop_id, computed distance from candidate), and
        the list will be sorted in descending order based on the computed
        distance.
    """

    neighbors = dict()
    for other in stations_list:

        if not station.coop_id == other.coop_id:
            dist = compute_arc_dist(station, other)
            neighbors[other.coop_id] = dist

    # Sort the dictionary of neighbors into a list, sorting from least
    # distance to greatest distances. Only take numsrt neighbors maximum.
    sorted_neighbors = sorted(neighbors.iteritems(), key=itemgetter(1))[: numsrt - 1]
    """
    # This code is actually superfluous, but it loops through the list of
    # sorted neighbors, and finds only the neighbors which are within a maximum
    # distance from the candidate station. When its done, it sees if there are
    # enough neighbors, and if not, ups the threshold for distance and tries 
    # again.
    close_neighbors = []
    iter = 1
    hidist = mindist
    print "...searching for neighbors within %4.1fkm" % mindist
    while (len(close_neighbors) < numsrt-1):
        print "......iteration %d, %d neighbors found" % (iter, 
                                                          len(close_neighbors))
        for (coop_id, dist) in sorted_neighbors:
            if dist < hidist:
                sorted_neighbors.remove((coop_id, dist))
                close_neighbors.append((coop_id, dist))
        hidist = hidist+distinc
        print ".........distance now %4.1fkm" % mindist    
        iter = iter+1
    print "......ultimately found %d neighbors" % len(close_neighbors)
    all_neighbors[coop_id1] = close_neighbors
    """

    return sorted_neighbors
 def testQuarterArc(self):
     dist1 = compute_arc_dist(self.STATION_C, self.STATION_D)
     dist2 = compute_arc_dist(self.STATION_D, self.STATION_C)
     quarter_arc = (2.*pi*RADIUS_EARTH)/4.0
     self.assertAlmostEquals(dist1, quarter_arc, delta=self.DELTA)
     self.assertAlmostEquals(dist2, quarter_arc, delta=self.DELTA)
 def testSameStation(self):
     """Distance between the same station should round off to 0."""
     dist = compute_arc_dist(self.STATION_A, self.STATION_A)
     self.assertAlmostEquals(dist, 0., delta=self.DELTA)