def prep_nodes(short_profile, module_names, include_flight_attributes):
''' go through modules to get derived nodes and check if we need to write a new hdf5 file'''
if short_profile=='base':
required_nodes = get_derived_nodes(settings.NODE_MODULES + module_names)
derived_nodes = required_nodes
write_hdf = True
required_params = required_nodes.keys()
exclusions = ['Transmit',
'EngGasTempDuringMaximumContinuousPowerForXMinMax', #still calcs
'Eng Gas Temp During Maximum Continuous Power For X Min Max',
'EngGasTempDuringEngStartForXSecMax',
'Eng Gas Temp During Eng Start For X Sec Max',
]
required_params = sorted( set(required_params ) - set(exclusions)) #exclude select params from FDS set
if include_flight_attributes:
required_params = list(set( required_params + get_derived_nodes(['analysis_engine.flight_attribute']).keys()))
else:
required_nodes = get_derived_nodes(module_names)
derived_nodes = get_derived_nodes(settings.NODE_MODULES + module_names)
required_params = required_nodes.keys()
# determine whether we'll need to copy the hdf5 to store new timeseries
write_hdf = False
for (name, nd) in required_nodes.items():
if str(nd.__bases__).find('DerivedParameterNode')>=0: write_hdf=True
return required_params, derived_nodes, write_hdf
def test_sample_parameter_module(self):
"""Tests many options:
can_operate on SmoothedTrack works with
"""
requested = ['Smoothed Track', 'Moment Of Takeoff', 'Vertical Speed',
'Slip On Runway']
lfl_params = ['Indicated Airspeed',
'Groundspeed',
'Pressure Altitude',
'Heading', 'TAT',
'Latitude', 'Longitude',
'Longitudinal g', 'Lateral g', 'Normal g',
'Pitch', 'Roll',
]
try:
# for test cmd line runners
derived = get_derived_nodes(['tests.sample_derived_parameters'])
except ImportError:
# for IDE test runners
derived = get_derived_nodes(['sample_derived_parameters'])
nodes = NodeManager(datetime.now(), 10, lfl_params, requested, [],
derived, {}, {})
order, _ = dependency_order(nodes, draw=False)
pos = order.index
self.assertTrue(len(order))
self.assertNotIn('Moment Of Takeoff', order) # not available
self.assertTrue(pos('Vertical Speed') > pos('Pressure Altitude'))
self.assertTrue(pos('Slip On Runway') > pos('Groundspeed'))
self.assertTrue(pos('Slip On Runway') > pos('Horizontal g Across Track'))
self.assertTrue(pos('Horizontal g Across Track') > pos('Roll'))
self.assertFalse('Mach' in order) # Mach wasn't requested!
self.assertFalse('Radio Altimeter' in order)
self.assertEqual(len(nodes.hdf_keys), 12)
self.assertEqual(len(nodes.requested), 4)
self.assertEqual(len(nodes.derived_nodes), 13)
def prep_nodes(short_profile, module_names):
''' go through modules to get derived nodes '''
if short_profile == 'base':
requested_nodes = get_derived_nodes(settings.NODE_MODULES +
module_names)
available_nodes = requested_nodes
requested_params = available_nodes.keys()
exclusions = [
'Transmit',
'EngGasTempDuringMaximumContinuousPowerForXMinMax', #still calcs
'Eng Gas Temp During Maximum Continuous Power For X Min Max',
'EngGasTempDuringEngStartForXSecMax',
'Eng Gas Temp During Eng Start For X Sec Max',
'Eng Oil Temp For X Min Max',
# 'Configuration',
]
requested_params = sorted(
set(requested_params) -
set(exclusions)) #exclude select params from FDS set
requested_params = list(
set(requested_params +
get_derived_nodes(['analysis_engine.flight_attribute']).keys())
)
else:
requested_nodes = get_derived_nodes(module_names)
available_nodes = get_derived_nodes(settings.NODE_MODULES +
module_names)
requested_params = requested_nodes.keys()
return requested_params, available_nodes
def test_invalid_requirement_raises(self):
lfl_params = []
requested = ['Smoothed Track', 'Moment of Takeoff'] #it's called Moment Of Takeoff
try:
# for test cmd line runners
derived = get_derived_nodes(['tests.sample_derived_parameters'])
except ImportError:
# for IDE test runners
derived = get_derived_nodes(['sample_derived_parameters'])
mgr = NodeManager(datetime.now(), 10, lfl_params, requested, [],
derived, {}, {})
self.assertRaises(nx.NetworkXError, dependency_order, mgr, draw=False)
def derived_trimmer(hdf_path, node_names, dest):
'''
Trims an HDF file of parameters which are not dependencies of nodes in
node_names.
:param hdf_path: file path of hdf file.
:type hdf_path: str
:param node_names: A list of Node names which are required.
:type node_names: list of str
:param dest: destination path for trimmed output file
:type dest: str
:return: parameters in stripped hdf file
:rtype: [str]
'''
params = []
with hdf_file(hdf_path) as hdf:
derived_nodes = get_derived_nodes(NODE_MODULES)
node_mgr = NodeManager(
datetime.now(), hdf.duration, hdf.valid_param_names(), [],
derived_nodes, {}, {})
_graph = graph_nodes(node_mgr)
for node_name in node_names:
deps = dependencies3(_graph, node_name, node_mgr)
params.extend(filter(lambda d: d in node_mgr.hdf_keys, deps))
return strip_hdf(hdf_path, params, dest)
def test_avoiding_possible_circular_dependency(self):
# Possible circular dependency which can be avoided:
# Gear Selected Down depends on Gear Down which depends on Gear Selected Down...!
lfl_params = ['Airspeed', 'Gear (L) Down', 'Gear (L) Red Warning']
requested = ['Airspeed At Gear Down Selected']
try:
# for test cmd line runners
derived = get_derived_nodes(['tests.sample_circular_dependency_nodes'])
except ImportError:
# for IDE test runners
derived = get_derived_nodes(['sample_circular_dependency_nodes'])
mgr = NodeManager(datetime.now(), 10, lfl_params, requested, [],
derived, {}, {})
order, _ = dependency_order(mgr, draw=True)
# As Gear Selected Down depends upon Gear Down
self.assertEqual(order,
['Gear (L) Down', 'Gear Down', 'Gear (L) Red Warning',
'Gear Down Selected', 'Airspeed', 'Airspeed At Gear Down Selected'])
def _generate_json(self, lfl_params):
'''
Returns list of parameters used in the spanning tree.
Note: LFL parameters not used will not be returned!
'''
print "Establishing Node dependencies from Analysis Engine"
# Ensure file is a valid HDF file before continuing:
derived_nodes = get_derived_nodes(settings.NODE_MODULES)
required_params = derived_nodes.keys()
# TODO: Update ac_info with keys from provided fields:
ac_info = {
'Family': u'B737 NG',
'Frame': u'737-3C',
'Identifier': u'15',
'Main Gear To Lowest Point Of Tail': None,
'Main Gear To Radio Altimeter Antenna': None,
'Manufacturer Serial Number': u'39009',
'Manufacturer': u'Boeing',
'Model': u'B737-8JP',
'Precise Positioning': True,
'Series': u'B737-800',
'Tail Number': 'G-ABCD',
}
# TODO: Option to populate an AFR:
achieved_flight_record = {}
# Generate the dependency tree:
node_mgr = NodeManager(
{},
1000,
lfl_params,
required_params,
[],
derived_nodes,
ac_info,
achieved_flight_record,
)
_graph = graph_nodes(node_mgr)
gr_all, gr_st, order = process_order(_graph, node_mgr)
# Save the dependency tree to tree.json:
tree = os.path.join(AJAX_DIR, 'tree.json')
with open(tree, 'w') as fh:
json.dump(graph_adjacencies(gr_st), fh, indent=4)
# Save the list of nodes to node_list.json:
node_list = os.path.join(AJAX_DIR, 'node_list.json')
spanning_tree_params = sorted(gr_st.nodes())
with open(node_list, 'w') as fh:
json.dump(spanning_tree_params, fh, indent=4)
return
def _generate_json(self, lfl_params):
'''
Returns list of parameters used in the spanning tree.
Note: LFL parameters not used will not be returned!
'''
print "Establishing Node dependencies from Analysis Engine"
# Ensure file is a valid HDF file before continuing:
derived_nodes = get_derived_nodes(settings.NODE_MODULES)
required_params = derived_nodes.keys()
# TODO: Update ac_info with keys from provided fields:
ac_info = {
'Family': u'B737 NG',
'Frame': u'737-3C',
'Identifier': u'15',
'Main Gear To Lowest Point Of Tail': None,
'Main Gear To Radio Altimeter Antenna': None,
'Manufacturer Serial Number': u'39009',
'Manufacturer': u'Boeing',
'Model': u'B737-8JP',
'Precise Positioning': True,
'Series': u'B737-800',
'Tail Number': 'G-ABCD',
}
# TODO: Option to populate an AFR:
achieved_flight_record = {}
# Generate the dependency tree:
node_mgr = NodeManager(
{},
1000,
lfl_params,
required_params,
[],
derived_nodes,
ac_info,
achieved_flight_record,
)
_graph = graph_nodes(node_mgr)
gr_all, gr_st, order = process_order(_graph, node_mgr)
# Save the dependency tree to tree.json:
tree = os.path.join(AJAX_DIR, 'tree.json')
with open(tree, 'w') as fh:
json.dump(graph_adjacencies(gr_st), fh, indent=4)
# Save the list of nodes to node_list.json:
node_list = os.path.join(AJAX_DIR, 'node_list.json')
spanning_tree_params = sorted(gr_st.nodes())
with open(node_list, 'w') as fh:
json.dump(spanning_tree_params, fh, indent=4)
return
def prep_nodes(short_profile, module_names):
''' go through modules to get derived nodes '''
if short_profile=='base':
requested_nodes = get_derived_nodes(settings.NODE_MODULES + module_names)
available_nodes = requested_nodes
requested_params = available_nodes.keys()
exclusions = ['Transmit',
'EngGasTempDuringMaximumContinuousPowerForXMinMax', #still calcs
'Eng Gas Temp During Maximum Continuous Power For X Min Max',
'EngGasTempDuringEngStartForXSecMax',
'Eng Gas Temp During Eng Start For X Sec Max',
'Eng Oil Temp For X Min Max',
# 'Configuration',
]
requested_params = sorted( set(requested_params) - set(exclusions)) #exclude select params from FDS set
requested_params = list(set( requested_params + get_derived_nodes(['analysis_engine.flight_attribute']).keys()))
else:
requested_nodes = get_derived_nodes(module_names)
available_nodes = get_derived_nodes(settings.NODE_MODULES + module_names)
requested_params = requested_nodes.keys()
return requested_params, available_nodes
def _get_names(module_locations, fetch_names=True, fetch_dependencies=False):
'''
Get the names of Nodes and dependencies.
:param module_locations: list of locations to fetch modules from
:type module_locations: list of strings
:param fetch_names: Return name of parameters etc. created by class
:type fetch_names: Bool
:param fetch_dependencies: Return names of the arguments in derive methods
:type fetch_dependencies: Bool
'''
nodes = get_derived_nodes(module_locations)
names = []
for node in nodes.values():
if fetch_names:
if hasattr(node, 'names'):
# FormattedNameNode (KPV/KTI) can have many names
names.extend(node.names())
else:
names.append(node.get_name())
if fetch_dependencies:
names.extend(node.get_dependency_names())
return sorted(names)
