Tools for batch production

Running stuff

Batch run stuff.

class mpop.saturn.runner.SequentialRunner(satellite, instrument, tasklist, precompute=False)

Runs scenes in a sequential order, as opposed to parallelized running.

run_from_cmd(hook=None)

Batch run mpop.

run_from_data(tasklist=None, radius=None, hook=None)

Run on given data.

run_from_local_data(tasklist=None, extra_tags=None, hook=None)

Run on given local data (already projected).

stop()

Stops the runner.

mpop.saturn.runner.parse_options()

Parse command line options.

mpop.saturn.runner.usage(scriptname)

Print usefull information for running the script.

Handling tasks

Tasklist class and helper function.

class mpop.saturn.tasklist.TaskList(product_file=None)

Defines a tasklist.

get_prerequisites(klass, area_id=None)

Get the channels we need to load to fulfill the tasklist according to methods defined in klass. If area is provided, account only for tasks on this area.

shape(klass, mode=set([]), original_areas=set([]), specific_composites=set([]))

Shape the given the tasklist according to the options.

split(*keys)

Split the tasklist along the keys parameter: keys in the first part, non keys in the second.

mpop.saturn.tasklist.get_product_list(satscene)

Returns the tasklist corresponding to the satellite described in satscene, which can be a scene object, a list or a tuple. If the corresponding file could not be found, the function returns more generic tasklists (variant and name based, then only variant based), or None if no file can be found.

NB: the product files are looked for in the CONFIG_PATH directory.

Monitoring and processing incoming files

Watch files coming in a given directory.

class mpop.saturn.filewatcher.FileProcessor(file_queue, fun, refresh=None)

Execute fun on filenames provided by from file_queue. If refresh is a positive number, run fun every given number of seconds with None as argument.

run()

Execute the given function on files from the file queue.

stop()

Stops a running process.

terminate()

Terminate thread.

class mpop.saturn.filewatcher.FileWatcher(filename_template, file_queue, frequency)

Looks for new files, and queues them.

run()

Run the file watcher.

terminate()

Terminate thread.

wait(secs)

Earth geometry

Spherical geometry module.

class mpop.saturn.assemble_segments.Arc(start, end)

An arc of the great circle between two points.

angle(other_arc)

Oriented angle between two arcs.

center_angle()

Angle of an arc at the center of the sphere.

end = None

intersection(other_arc)

Says where, if two arcs defined by the current arc and the other_arc intersect. An arc is defined as the shortest tracks between two points.

intersections(other_arc)

Gives the two intersections of the greats circles defined by the current arc and other_arc.

intersects(other_arc)

Says if two arcs defined by the current arc and the other_arc intersect. An arc is defined as the shortest tracks between two points.

start = None

class mpop.saturn.assemble_segments.Coordinate(lat=None, lon=None, x__=None, y__=None, z__=None, R=1)

Point on earth in terms of lat and lon.

cross(point)

cross product with another vector.

cross2cart(point)

Compute the cross product, and convert to cartesian coordinates (assuming radius 1).

distance(point)

Vincenty formula.

dot(point)

dot product with another vector.

lat = None

lon = None

norm()

Return the norm of the vector.

normalize()

normalize the vector.

x__ = None

y__ = None

z__ = None

class mpop.saturn.assemble_segments.TestSphereGeometry(methodName='runTest')

Testing sphere geometry from this module.

test_angle()

Testing the angle value between two arcs.

test_inside()

Testing if a point is inside for other points.

test_intersects()

Test if two arcs intersect.

test_overlap_rate()

Test how much two areas overlap.

test_overlaps()

Test if two areas overlap.

mpop.saturn.assemble_segments.get_area(corners)

Get the area of the convex area defined by corners.

mpop.saturn.assemble_segments.get_first_intersection(b__, boundaries)

Get the first intersection on b__ with boundaries.

mpop.saturn.assemble_segments.get_intersections(b__, boundaries)

Get the intersections of b__ with boundaries. Returns both the intersection coordinates and the concerned boundaries.

mpop.saturn.assemble_segments.get_next_intersection(p__, b__, boundaries)

Get the next intersection from the intersection of arcs p__ and b__ along segment b__ with boundaries.

mpop.saturn.assemble_segments.min_distances(area_corners, segment_corners)

Min distances between each corner of area_corners and segment_corners.

mpop.saturn.assemble_segments.modpi(val)

Puts val between -pi and pi.

mpop.saturn.assemble_segments.modpi2(val)

Puts val between 0 and 2pi.

mpop.saturn.assemble_segments.overlap_rate(swath_corners, area_corners)

Get how much a swath overlaps an area.

mpop.saturn.assemble_segments.overlaps(area_corners, segment_corners)

Are two areas overlapping ? This uses great circle arcs as area boundaries.

mpop.saturn.assemble_segments.point_inside(point, corners)

Is a point inside the 4 corners ? This uses great circle arcs as area boundaries.

mpop.saturn.assemble_segments.polygon(area_corners, segment_corners)

Get the intersection polygon between two areas.

mpop.saturn.assemble_segments.should_wait(area_corners, segment_corners, previous_segment_corners)

Are the newest cornest still inside the area ? is the last segment boundary overlapping any boundary of the area ? In this case we should wait for the next segment to arrive.