def add_simulation_run(project, cache_directory, scenario_name, run_name,
start_year, end_year, run_id):
'''
Creates a simulation run node and adds it to the project
@param project (OpusProject): currently loaded project
@param cache_directory (String): absolute path to the cache directory
@param scenario_name (String): name of the scenario that was run
@param run_name (String): name of the run
@param start_year (int): start year of run
@param end_year (int): end year of run
@param run_id (int): ID number for the run
'''
## XML-ify the name
# run_name = run_name.replace(' ', '_')
# Assemble the new run node
str_atr = {'type': 'string'}
int_atr = {'type': 'integer'}
run_node = Element('run', {'type': 'source_data',
'name': run_name,
'hidden': 'Children',
'run_id': str(run_id)})
# SubElement(run_node, 'run_id', int_atr).text = str(run_id)
SubElement(run_node, 'scenario_name', str_atr).text = scenario_name
SubElement(run_node, 'cache_directory', str_atr).text = cache_directory
SubElement(run_node, 'start_year', int_atr).text = str(start_year)
SubElement(run_node, 'end_year', int_atr).text = str(end_year)
# Grab the results manager instance for the GUI and insert the new node
get_manager_instance('results_manager').add_run(run_node)
project.dirty = True
update_mainwindow_savestate()
def _apply_variable_changes(self):
''' apply the changes the user made to the expression library '''
# Case XML (before) Editor (after) Change Action
# ----------------------------------------------------------
# A <none> local created create
# B local inherited reverted delete
# C local <none> deleted delete
# TODO: also check into the possibility that an inherited variable can have it's name
# changed (in this case don't overwrite the orginal variable's name. Instead create a new
# variable with the new name.
dirty_variables = [var for var in self.model.variables if var['dirty']]
# case A
create_set = [var for var in dirty_variables if var['originalnode'] is None]
delete_set = []
for xml_node in self.original_nodes:
if xml_node.get('inherited') is not None: # only care about local or shadowing nodes
continue
for variable in self.model.variables:
if variable['originalnode'] is xml_node: # original is represented in variable list
if variable['inherited']:
delete_set.append(xml_node) # Case B
break # stop looking
else: # did not find node
delete_set.append(xml_node) # case C
# the rest of the variables should just be updated
update_set = [var for var in dirty_variables if
not var['originalnode'] in delete_set and var not in create_set]
# Apply the changes to each set of nodes
expression_lib = self.project.find('general/expression_library')
for variable in create_set:
# print 'CREATE SET ', variable
node = node_from_variable(variable)
# print ' node', node
self.project.insert_node(node, expression_lib)
for variable in update_set:
node = node_from_variable(variable)
original_node = variable['originalnode'] # reference to the actual XML node
# print 'UPDATE SET %s (original %s)' %(variable['name'], original_node)
self.project.make_local(original_node)
for key in node.attrib:
if not key == 'inherited':
original_node.set(key, node.get(key))
if 'dataset' in original_node.attrib:
del original_node.attrib['dataset']
original_node.text = node.text
for node in delete_set:
# print 'DELETE SET %s' % (node)
self.project.delete_node(node)
self.initialize()
something_changed = bool(update_set or create_set or delete_set)
update_mainwindow_savestate(something_changed)
get_mainwindow_instance().emit(SIGNAL('variables_updated'))
return True
def insertRow(self, row, parent_index, node, reinserting=False):
'''
Insert a row into the data model
@param row (int): row to insert into.
@param parent_index (QModelIndex): index of parent item
@param node (Element): node to insert
@param reinserting (bool): if True; assume that the project has already reinserted the node
and just insert it into the internal model. Also skip making it local after inserting.
@return: True if the sibling was inserted, False otherwise
'''
if row < 0 or row > self.rowCount(parent_index):
return False
self.emit(SIGNAL("layoutAboutToBeChanged()"))
self.beginInsertRows(parent_index, row, row)
# Get a valid parent_item
if parent_index == QModelIndex():
parent_item = self._root_item
else:
parent_item = parent_index.internalPointer()
parent_node = parent_item.node
if self.project is None: # no inheritance simple insert into tree
parent_node.insert(row, node)
else:
# when dealing with a project and inheritance we have two cases --
# either insertRow is inserting a node that already exists in the project
# (reinserting is True) or we are inserting a new node.
if not reinserting:
inserted_node = self.project.insert_node(
node, parent_node, row)
if inserted_node is None:
# raise RuntimeError('Could not insert node into model')
print 'WARNING: Could not insert %s:%s' % (
node.tag, node.get('name'))
return False
self.project.make_local(inserted_node)
else:
inserted_node = node
new_item = XmlItem(inserted_node, parent_item)
new_item.rebuild()
parent_item.child_items.insert(row, new_item)
self.endInsertRows()
self.emit(SIGNAL("layoutChanged()"))
# If the item was created we store it so that XmlViews can access it
self.last_inserted_index = self.index(
row, 0, parent_index) if new_item else None
update_mainwindow_savestate()
return True
def insertRow(self, row, parent_index, node, reinserting = False):
'''
Insert a row into the data model
@param row (int): row to insert into.
@param parent_index (QModelIndex): index of parent item
@param node (Element): node to insert
@param reinserting (bool): if True; assume that the project has already reinserted the node
and just insert it into the internal model. Also skip making it local after inserting.
@return: True if the sibling was inserted, False otherwise
'''
if row < 0 or row > self.rowCount(parent_index):
return False
self.emit(SIGNAL("layoutAboutToBeChanged()"))
self.beginInsertRows(parent_index, row, row)
# Get a valid parent_item
if parent_index == QModelIndex():
parent_item = self._root_item
else:
parent_item = parent_index.internalPointer()
parent_node = parent_item.node
if self.project is None: # no inheritance simple insert into tree
parent_node.insert(row, node)
else:
# when dealing with a project and inheritance we have two cases --
# either insertRow is inserting a node that already exists in the project
# (reinserting is True) or we are inserting a new node.
if not reinserting:
inserted_node = self.project.insert_node(node, parent_node, row)
if inserted_node is None:
# raise RuntimeError('Could not insert node into model')
print 'WARNING: Could not insert %s:%s' % (node.tag, node.get('name'))
return False
self.project.make_local(inserted_node)
else:
inserted_node = node
new_item = XmlItem(inserted_node, parent_item)
new_item.rebuild()
parent_item.child_items.insert(row, new_item)
self.endInsertRows()
self.emit(SIGNAL("layoutChanged()"))
# If the item was created we store it so that XmlViews can access it
self.last_inserted_index = self.index(row, 0, parent_index) if new_item else None
update_mainwindow_savestate()
return True
def _apply_variable_changes(self):
''' apply the changes the user made to the expression library '''
# TODO: also check into the possibility that an inherited variable can have its name
# changed (in this case don't overwrite the original variable's name. Instead create a new
# variable with the new name.)
dirty_variables = [var for var in self.model.all_variables if var['dirty']]
# partition dirty variables into create, delete and update sets
create_set = [var for var in dirty_variables if var['originalnode'] is None]
delete_set = [var for var in dirty_variables if var['delete'] and var['originalnode'] is not None]
# the rest of the variables should just be updated
update_set = [var for var in dirty_variables if
not var['originalnode'] in delete_set and var not in create_set]
# verify if we have a partition
assert(set([str(var) for var in create_set]) | set([str(var) for var in delete_set]) | set([str(var) for var in update_set])
== set([str(var) for var in dirty_variables]))
assert(set([str(var) for var in create_set]) & set([str(var) for var in delete_set]) & set([str(var) for var in update_set])
== set())
# Apply the changes to each set of nodes
expression_lib = self.project.find('general/expression_library')
for variable in create_set:
# print 'CREATE SET ', variable
node = node_from_variable(variable)
# print ' node', node
self.project.insert_node(node, expression_lib)
for variable in update_set:
node = node_from_variable(variable)
original_node = variable['originalnode'] # reference to the actual XML node
# print 'UPDATE SET %s (original %s)' %(variable['name'], original_node)
self.project.make_local(original_node)
for key in node.attrib:
if not key == 'inherited':
original_node.set(key, node.get(key))
if 'dataset' in original_node.attrib:
del original_node.attrib['dataset']
original_node.text = node.text
for variable in delete_set:
# print 'DELETE SET %s' % (node)
self.project.delete_node(variable['originalnode'])
self.initialize()
something_changed = bool(update_set or create_set or delete_set)
update_mainwindow_savestate(something_changed)
get_mainwindow_instance().emit(SIGNAL('variables_updated'))
return True
def _apply_variable_changes(self):
''' apply the changes the user made to the expression library '''
# TODO: also check into the possibility that an inherited variable can have its name
# changed (in this case don't overwrite the original variable's name. Instead create a new
# variable with the new name.)
dirty_variables = [
var for var in self.model.all_variables if var['dirty']
]
# partition dirty variables into create, delete and update sets
create_set = [
var for var in dirty_variables if var['originalnode'] is None
]
delete_set = [
var for var in dirty_variables
if var['delete'] and var['originalnode'] is not None
]
# the rest of the variables should just be updated
update_set = [
var for var in dirty_variables
if not var['originalnode'] in delete_set and var not in create_set
]
# verify if we have a partition
assert (set([str(var) for var in create_set])
| set([str(var) for var in delete_set])
| set([str(var) for var in update_set]) == set(
[str(var) for var in dirty_variables]))
assert (set([str(var) for var in create_set])
& set([str(var) for var in delete_set])
& set([str(var) for var in update_set]) == set())
# Apply the changes to each set of nodes
expression_lib = self.project.find('general/expression_library')
for variable in create_set:
# print 'CREATE SET ', variable
node = node_from_variable(variable)
# print ' node', node
self.project.insert_node(node, expression_lib)
for variable in update_set:
node = node_from_variable(variable)
original_node = variable[
'originalnode'] # reference to the actual XML node
# print 'UPDATE SET %s (original %s)' %(variable['name'], original_node)
self.project.make_local(original_node)
for key in node.attrib:
if not key == 'inherited':
original_node.set(key, node.get(key))
if 'dataset' in original_node.attrib:
del original_node.attrib['dataset']
original_node.text = node.text
for variable in delete_set:
# print 'DELETE SET %s' % (node)
self.project.delete_node(variable['originalnode'])
self.initialize()
something_changed = bool(update_set or create_set or delete_set)
update_mainwindow_savestate(something_changed)
get_mainwindow_instance().emit(SIGNAL('variables_updated'))
return True
def __set_dirty(self, dirty):
self._dirty = dirty
update_mainwindow_savestate()
def __set_dirty(self, dirty):
self._dirty = dirty
update_mainwindow_savestate()
