def plotdraw(mode, case, writeoutput): graphdata = GraphData(mode, case) # Create output directory config_setup.ensure_existence(os.path.join(graphdata.saveloc, "graphs"), make=True) for graph in graphdata.graphs: graphdata.graphdetails(graph) for weight_method in graphdata.weight_methods: print(weight_method) for scenario in graphdata.scenarios: print(scenario) basedir = os.path.join( graphdata.saveloc, "weightdata", case, scenario, weight_method ) sigtypes = next(os.walk(basedir))[1] for sigtype in sigtypes: if sigtype in graphdata.significance_cases: print(sigtype) embedtypesdir = os.path.join(basedir, sigtype) embedtypes = next(os.walk(embedtypesdir))[1] for embedtype in embedtypes: print(embedtype) datadir = os.path.join(embedtypesdir, embedtype) # Actual plot drawing execution starts here drawplot(graphdata, scenario, datadir, graph, writeoutput) return None
def drawplot(graphdata, scenario, datadir, graph, writeoutput): dirparts = data_processing.getfolders(datadir) dirparts[dirparts.index("weightdata")] = "graphs" savedir = dirparts[0] for pathpart in dirparts[1:]: savedir = os.path.join(savedir, pathpart) config_setup.ensure_existence(os.path.join(savedir)) getattr(figtypes, graphdata.plot_type)(graphdata, graph, scenario, savedir) return None
def drawplot(graphdata, scenario, datadir, graph, writeoutput): dirparts = data_processing.getfolders(datadir) dirparts[dirparts.index('weightdata')] = 'graphs' savedir = dirparts[0] for pathpart in dirparts[1:]: savedir = os.path.join(savedir, pathpart) config_setup.ensure_existence(os.path.join(savedir)) getattr(figtypes, graphdata.plot_type)(graphdata, graph, scenario, savedir) return None
def filename(weightname, boxindex, causevar): boxstring = 'box{:03d}'.format(boxindex) filedir = config_setup.ensure_existence( os.path.join(weightstoredir, weightname, boxstring), make=True) filename = '{}.csv'.format(causevar) return os.path.join(filedir, filename)
def filename(weightname, boxindex, causevar): boxstring = "box{:03d}".format(boxindex) filedir = config_setup.ensure_existence( os.path.join(weightstoredir, weightname, boxstring), make=True ) filename = "{}.csv".format(causevar) return os.path.join(filedir, filename)
def calc_weights(weightcalcdata, method, scenario, writeoutput): """Determines the maximum weight between two variables by searching through a specified set of delays. Parameters ---------- method : str Can be one of the following: 'cross_correlation' 'partial_correlation' -- does not support time delays 'transfer_entropy_kernel' 'transfer_entropy_kraskov' TODO: Fix partial correlation method to make use of time delays """ if method == "cross_correlation": weightcalculator = CorrWeightcalc(weightcalcdata) elif method == "transfer_entropy_kernel": weightcalculator = TransentWeightcalc(weightcalcdata, "kernel") elif method == "transfer_entropy_kraskov": weightcalculator = TransentWeightcalc(weightcalcdata, "kraskov") elif method == "transfer_entropy_discrete": weightcalculator = TransentWeightcalc(weightcalcdata, "discrete") # elif method == 'partial_correlation': # weightcalculator = PartialCorrWeightcalc(weightcalcdata) else: raise ValueError("Method not recognized") if weightcalcdata.sigtest: sigstatus = "sigtested" elif not weightcalcdata.sigtest: sigstatus = "nosigtest" if method == "transfer_entropy_kraskov": if weightcalcdata.additional_parameters["auto_embed"]: embedstatus = "autoembedding" else: embedstatus = "naive" else: embedstatus = "naive" vardims = len(weightcalcdata.variables) startindex = weightcalcdata.startindex size = weightcalcdata.testsize cause_dellist = [] affected_dellist = [] for index in range(vardims): if index not in weightcalcdata.causevarindexes: cause_dellist.append(index) logging.info("Deleted column " + str(index)) if index not in weightcalcdata.affectedvarindexes: affected_dellist.append(index) logging.info("Deleted row " + str(index)) if weightcalcdata.connections_used: newconnectionmatrix = weightcalcdata.connectionmatrix else: newconnectionmatrix = np.ones((vardims, vardims)) # Substitute columns not used with zeros in connectionmatrix for cause_delindex in cause_dellist: newconnectionmatrix[:, cause_delindex] = np.zeros(vardims) # Substitute rows not used with zeros in connectionmatrix for affected_delindex in affected_dellist: newconnectionmatrix[affected_delindex, :] = np.zeros(vardims) # Initiate headerline for weightstore file # Create "Delay" as header for first row headerline = ["Delay"] for affectedvarindex in weightcalcdata.affectedvarindexes: affectedvarname = weightcalcdata.variables[affectedvarindex] headerline.append(affectedvarname) # Define filename structure for CSV file containing weights between # a specific causevar and all the subsequent affectedvars def filename(weightname, boxindex, causevar): boxstring = "box{:03d}".format(boxindex) filedir = config_setup.ensure_existence( os.path.join(weightstoredir, weightname, boxstring), make=True ) filename = "{}.csv".format(causevar) return os.path.join(filedir, filename) # Store the weight calculation results in similar format as original data # Define weightstoredir up to the method level weightstoredir = config_setup.ensure_existence( os.path.join( weightcalcdata.saveloc, "weightdata", weightcalcdata.casename, scenario, method, sigstatus, embedstatus, ), make=True, ) if weightcalcdata.single_entropies: # Initiate headerline for single signal entropies storage file signalent_headerline = weightcalcdata.variables # Define filename structure for CSV file def signalent_filename(name, boxindex): return signalent_filename_template.format( weightcalcdata.casename, scenario, name, boxindex ) signalentstoredir = config_setup.ensure_existence( os.path.join(weightcalcdata.saveloc, "signal_entropies"), make=True ) signalent_filename_template = os.path.join( signalentstoredir, "{}_{}_{}_box{:03d}.csv" ) for boxindex in weightcalcdata.boxindexes: box = weightcalcdata.boxes[boxindex] # Calculate single signal entropies - do not worry about # delays, but still do it according to different boxes if weightcalcdata.single_entropies: # Calculate single signal entropies of all variables # and save output in similar format to # standard weight calculation results signalentlist = [] for varindex, _ in enumerate(weightcalcdata.variables): vardata = box[:, varindex][startindex : startindex + size] entropy = data_processing.calc_signalent(vardata, weightcalcdata) signalentlist.append(entropy) # Write the signal entropies to file - one file for each box # Each file will only have one line as we are not # calculating for different delays as is done for the case of # variable pairs. # Need to add another axis to signalentlist in order to make # it a sequence so that it can work with writecsv_weightcalc signalentlist = np.asarray(signalentlist) signalentlist = signalentlist[np.newaxis, :] writecsv_weightcalc( signalent_filename("signal_entropy", boxindex + 1), signalentlist, signalent_headerline, ) # Start parallelising code here # Create one process for each causevarindex ########################################################### non_iter_args = [ weightcalcdata, weightcalculator, box, startindex, size, newconnectionmatrix, method, boxindex, filename, headerline, writeoutput, ] # Run the script that will handle multiprocessing gaincalc_oneset.run(non_iter_args, weightcalcdata.do_multiprocessing) ######################################################## return None
def dorankcalc(noderankdata, scenario, datadir, typename, rank_method, writeoutput, preprocessing): if noderankdata.datatype == 'file': noderankdata.get_boxes(scenario, datadir, typename) gainmatrices = get_gainmatrices(noderankdata, datadir, typename) delaymatrices = get_delaymatrices(noderankdata, datadir, typename) elif noderankdata.datatype == 'function': gainmatrices = [noderankdata.gainmatrix] delaymatrices = [np.zeros_like(noderankdata.gainmatrix)] noderankdata.boxes = [0] if len(noderankdata.boxes) > 1: generate_diffs = True else: generate_diffs = False rankinglist_name = 'rankinglist_{}.csv' modgainmatrix_name = 'modgainmatrix.csv' originalgainmatrix_name = 'originalgainmatrix.csv' graphfile_name = 'graph_{}.gml' transientdict_name = 'transientdict_{}.json' basevaldict_name = 'basevaldict_{}.json' boxrankdict_name = 'boxrankdict_{}.json' rel_boxrankdict_name = 'rel_boxrankdict_{}.json' if generate_diffs: dif_rankinglist_name = 'dif_rankinglist_{}.csv' dif_transientdict_name = 'dif_transientdict_{}.json' dif_basevaldict_name = 'dif_basevaldict_{}.json' dif_boxrankdict_name = 'dif_boxrankdict_{}.json' dif_rel_boxrankdict_name = 'dif_rel_boxrankdict_{}.json' dif_typename = 'dif_' + typename dif_gainmatrices = get_gainmatrices(noderankdata, datadir, dif_typename) # Create lists to store the backward ranking list # for each box and associated gainmatrix ranking result #backward_rankinglists = [] backward_rankingdicts = [] dif_backward_rankingdicts = [] for index, gainmatrix in enumerate(gainmatrices): if preprocessing: modgainmatrix, _ = \ gainmatrix_preprocessing(gainmatrix) else: modgainmatrix = gainmatrix if generate_diffs: dif_gainmatrix = dif_gainmatrices[index] # Take only positive values for now due to convergence issues # TODO: Investigate proper handling of negative edge changes mod_dif_gainmatrix = dif_gainmatrix_preprocessing(dif_gainmatrix) delays = delaymatrices[index] # _, dummyweight = gainmatrix_preprocessing(gainmatrix) # Set dummyweight to 10 dummyweight = 10 # This is where the actual ranking calculation happens rankingdict, rankinglist, connections, variables, gains = \ calc_gainrank(modgainmatrix, noderankdata, rank_method, dummyweight) if generate_diffs: # TODO: Review effect of positive differences only # Take only positive for now due to convergence issues, but investigate proper handling # of negative edge changes dif_rankingdict, dif_rankinglist, _, _, _ = \ calc_gainrank(mod_dif_gainmatrix, noderankdata, rank_method, dummyweight) # dif_backward_rankinglists.append(dif_rankinglist) dif_backward_rankingdicts.append(dif_rankingdict) # The rest of the function deals with storing the # results in the desired formats #backward_rankinglists.append(rankinglist) backward_rankingdicts.append(rankingdict) if writeoutput: # Make sure the correct directory exists # Take datadir and swop out 'weightdata' for 'noderank' savedir = data_processing.change_dirtype( datadir, 'weightdata', 'noderank') config_setup.ensure_existence(os.path.join(savedir, typename[:-7])) if preprocessing: # Save the modified gainmatrix writecsv_looprank( os.path.join(savedir, typename[:-7], modgainmatrix_name), modgainmatrix) # Save the original gainmatrix writecsv_looprank( os.path.join(savedir, typename[:-7], originalgainmatrix_name), gainmatrix) # Export graph files with dummy variables included # in backward rankings if available # directions = ['backward'] if noderankdata.dummies: dummystatus = 'withdummies' else: dummystatus = 'nodummies' # Save the ranking list for each box savepath = config_setup.ensure_existence( os.path.join(savedir, typename[:-7], 'box{:03d}'.format( noderankdata.boxes[index]+1), dummystatus)) writecsv_looprank( os.path.join(savepath, rankinglist_name.format(rank_method)), rankinglist) if generate_diffs: writecsv_looprank( os.path.join(savepath, dif_rankinglist_name.format(rank_method)), dif_rankinglist) # Save the graphs to file graph, _ = \ create_importance_graph(noderankdata, variables, connections, connections, gains, delays, rankingdict) graph_filename = \ os.path.join(savepath, graphfile_name.format(rank_method)) # Decided to keep connections natural, will rotate hierarchical layout # in post-processing nx.readwrite.write_gml(graph, graph_filename) # Get ranking dictionaries transientdict, basevaldict, boxrankdict, rel_boxrankdict = \ calc_transient_importancediffs( backward_rankingdicts, noderankdata.variablelist) if generate_diffs: # Get ranking dictionaries for difference gain arrays dif_transientdict, dif_basevaldict, dif_boxrankdict, dif_rel_boxrankdict = \ calc_transient_importancediffs( dif_backward_rankingdicts, noderankdata.variablelist) # Store dictonaries using JSON # Normal dictionaries data_processing.write_dictionary( os.path.join(savepath, boxrankdict_name.format(rank_method)), boxrankdict) data_processing.write_dictionary( os.path.join(savepath, rel_boxrankdict_name.format(rank_method)), rel_boxrankdict) data_processing.write_dictionary( os.path.join(savepath, transientdict_name.format(rank_method)), transientdict) data_processing.write_dictionary( os.path.join(savepath, basevaldict_name.format(rank_method)), basevaldict) if generate_diffs: # Difference dictionaries data_processing.write_dictionary( os.path.join(savepath, dif_boxrankdict_name.format(rank_method)), dif_boxrankdict) data_processing.write_dictionary( os.path.join(savepath, dif_rel_boxrankdict_name.format(rank_method)), dif_rel_boxrankdict) data_processing.write_dictionary( os.path.join(savepath, dif_transientdict_name.format(rank_method)), dif_transientdict) data_processing.write_dictionary( os.path.join(savepath, dif_basevaldict_name.format(rank_method)), dif_basevaldict) return None
"""Ranks the nodes in a network based on gain matrices already generated for different weight types. The results are stored in the noderank directory but retains the structure of the weightdata directory Notes ----- Preprocessing is experimental and should always be set to False """ noderankdata = NoderankData(mode, case) # Create output directory config_setup.ensure_existence( os.path.join(noderankdata.saveloc, 'noderank'), make=True) for scenario in noderankdata.scenarios: logging.info("Running scenario {}".format(scenario)) # Update scenario-specific fields of noderankdata object noderankdata.scenariodata(scenario) for rank_method in noderankdata.rank_methods: for weight_method in noderankdata.weight_methods: basedir = os.path.join(noderankdata.saveloc, 'weightdata', case, scenario, weight_method) if noderankdata.datatype == 'file':
def calc_weights(weightcalcdata, method, scenario, writeoutput): """Determines the maximum weight between two variables by searching through a specified set of delays. Parameters ---------- method : str Can be one of the following: 'cross_correlation' 'partial_correlation' -- does not support time delays 'transfer_entropy_kernel' 'transfer_entropy_kraskov' TODO: Fix partial correlation method to make use of time delays """ if method == 'cross_correlation': weightcalculator = CorrWeightcalc(weightcalcdata) elif method == 'transfer_entropy_kernel': weightcalculator = TransentWeightcalc(weightcalcdata, 'kernel') elif method == 'transfer_entropy_kraskov': weightcalculator = TransentWeightcalc(weightcalcdata, 'kraskov') elif method == 'transfer_entropy_discrete': weightcalculator = TransentWeightcalc(weightcalcdata, 'discrete') elif method == 'partial_correlation': weightcalculator = PartialCorrWeightcalc(weightcalcdata) if weightcalcdata.sigtest: sigstatus = 'sigtested' elif not weightcalcdata.sigtest: sigstatus = 'nosigtest' if method == 'transfer_entropy_kraskov': if weightcalcdata.additional_parameters['auto_embed']: embedstatus = 'autoembedding' else: embedstatus = 'naive' else: embedstatus = 'naive' vardims = len(weightcalcdata.variables) startindex = weightcalcdata.startindex size = weightcalcdata.testsize cause_dellist = [] affected_dellist = [] for index in range(vardims): if index not in weightcalcdata.causevarindexes: cause_dellist.append(index) logging.info("Deleted column " + str(index)) if index not in weightcalcdata.affectedvarindexes: affected_dellist.append(index) logging.info("Deleted row " + str(index)) if weightcalcdata.connections_used: newconnectionmatrix = weightcalcdata.connectionmatrix else: newconnectionmatrix = np.ones((vardims, vardims)) # Substitute columns not used with zeros in connectionmatrix for cause_delindex in cause_dellist: newconnectionmatrix[:, cause_delindex] = np.zeros(vardims) # Substitute rows not used with zeros in connectionmatrix for affected_delindex in affected_dellist: newconnectionmatrix[affected_delindex, :] = np.zeros(vardims) # Initiate headerline for weightstore file # Create "Delay" as header for first row headerline = ['Delay'] for affectedvarindex in weightcalcdata.affectedvarindexes: affectedvarname = weightcalcdata.variables[affectedvarindex] headerline.append(affectedvarname) # Define filename structure for CSV file containing weights between # a specific causevar and all the subsequent affectedvars def filename(weightname, boxindex, causevar): boxstring = 'box{:03d}'.format(boxindex) filedir = config_setup.ensure_existence(os.path.join( weightstoredir, weightname, boxstring), make=True) filename = '{}.csv'.format(causevar) return os.path.join(filedir, filename) # Store the weight calculation results in similar format as original data # Define weightstoredir up to the method level weightstoredir = config_setup.ensure_existence(os.path.join( weightcalcdata.saveloc, 'weightdata', weightcalcdata.casename, scenario, method, sigstatus, embedstatus), make=True) if weightcalcdata.single_entropies: # Initiate headerline for single signal entropies storage file signalent_headerline = weightcalcdata.variables # Define filename structure for CSV file def signalent_filename(name, boxindex): return signalent_filename_template.format(weightcalcdata.casename, scenario, name, boxindex) signalentstoredir = config_setup.ensure_existence(os.path.join( weightcalcdata.saveloc, 'signal_entropies'), make=True) signalent_filename_template = \ os.path.join(signalentstoredir, '{}_{}_{}_box{:03d}.csv') for boxindex in weightcalcdata.boxindexes: box = weightcalcdata.boxes[boxindex] # Calculate single signal entropies - do not worry about # delays, but still do it according to different boxes if weightcalcdata.single_entropies: # Calculate single signal entropies of all variables # and save output in similar format to # standard weight calculation results signalentlist = [] for varindex, _ in enumerate(weightcalcdata.variables): vardata = box[:, varindex][startindex:startindex + size] entropy = data_processing.calc_signalent( vardata, weightcalcdata) signalentlist.append(entropy) # Write the signal entropies to file - one file for each box # Each file will only have one line as we are not # calculating for different delays as is done for the case of # variable pairs. # Need to add another axis to signalentlist in order to make # it a sequence so that it can work with writecsv_weightcalc signalentlist = np.asarray(signalentlist) signalentlist = \ signalentlist[np.newaxis, :] writecsv_weightcalc( signalent_filename('signal_entropy', boxindex + 1), signalentlist, signalent_headerline) # Start parallelising code here # Create one process for each causevarindex ########################################################### non_iter_args = [ weightcalcdata, weightcalculator, box, startindex, size, newconnectionmatrix, method, boxindex, filename, headerline, writeoutput ] # Run the script that will handle multiprocessing gaincalc_oneset.run(non_iter_args, weightcalcdata.do_multiprocessing) ######################################################## return None
savedir = dirparts[0] for pathpart in dirparts[1:]: savedir = os.path.join(savedir, pathpart) config_setup.ensure_existence(os.path.join(savedir)) getattr(figtypes, graphdata.plot_type)(graphdata, graph, scenario, savedir) return None def plotdraw(mode, case, writeoutput): graphdata = GraphData(mode, case) # Create output directory config_setup.ensure_existence(os.path.join(graphdata.saveloc, 'graphs'), make=True) for graph in graphdata.graphs: graphdata.graphdetails(graph) for weight_method in graphdata.weight_methods: print(weight_method) for scenario in graphdata.scenarios: print(scenario) basedir = os.path.join(graphdata.saveloc, 'weightdata', case, scenario, weight_method) sigtypes = next(os.walk(basedir))[1] for sigtype in sigtypes: if sigtype in graphdata.significance_cases: print(sigtype)
def noderankcalc(mode, case, writeoutput, preprocessing=False): """Ranks the nodes in a network based on gain matrices already generated for different weight types. The results are stored in the noderank directory but retains the structure of the weightdata directory Notes ----- Preprocessing is experimental and should always be set to False """ noderankdata = NoderankData(mode, case) # Create output directory config_setup.ensure_existence( os.path.join(noderankdata.saveloc, "noderank"), make=True ) for scenario in noderankdata.scenarios: logging.info("Running scenario {}".format(scenario)) # Update scenario-specific fields of noderankdata object noderankdata.scenariodata(scenario) for rank_method in noderankdata.rank_methods: for weight_method in noderankdata.weight_methods: basedir = os.path.join( noderankdata.saveloc, "weightdata", case, scenario, weight_method ) if noderankdata.datatype == "file": sigtypes = next(os.walk(basedir))[1] elif noderankdata.datatype == "function": sigtypes = ["test_nosig"] for sigtype in sigtypes: print(sigtype) embedtypesdir = os.path.join(basedir, sigtype) if noderankdata.datatype == "file": embedtypes = next(os.walk(embedtypesdir))[1] elif noderankdata.datatype == "function": embedtypes = ["test_noembed"] for embedtype in embedtypes: print(embedtype) datadir = os.path.join(embedtypesdir, embedtype) if weight_method[:16] == "transfer_entropy": typenames = [ "weight_absolute_arrays", "weight_directional_arrays", ] # 'signtested_weight_directional_arrays'] if sigtype == "sigtest": typenames.append("sigweight_absolute_arrays") typenames.append("sigweight_directional_arrays") # typenames.append( # 'signtested_sigweight_directional_arrays') else: typenames = ["weight_arrays"] if sigtype == "sigtest": typenames.append("sigweight_arrays") for typename in typenames: # Start the methods here dorankcalc( noderankdata, scenario, datadir, typename, rank_method, writeoutput, preprocessing, ) return None
def dorankcalc( noderankdata, scenario, datadir, typename, rank_method, writeoutput, preprocessing ): if noderankdata.datatype == "file": noderankdata.get_boxes(scenario, datadir, typename) gainmatrices = get_gainmatrices(noderankdata, datadir, typename) delaymatrices = get_delaymatrices(noderankdata, datadir, typename) elif noderankdata.datatype == "function": gainmatrices = [noderankdata.gainmatrix] delaymatrices = [np.zeros_like(noderankdata.gainmatrix)] noderankdata.boxes = [0] if len(noderankdata.boxes) > 1: generate_diffs = True else: generate_diffs = False rankinglist_name = "rankinglist_{}.csv" modgainmatrix_name = "modgainmatrix.csv" originalgainmatrix_name = "originalgainmatrix.csv" graphfile_name = "graph_{}.gml" transientdict_name = "transientdict_{}.json" basevaldict_name = "basevaldict_{}.json" boxrankdict_name = "boxrankdict_{}.json" rel_boxrankdict_name = "rel_boxrankdict_{}.json" if generate_diffs: dif_rankinglist_name = "dif_rankinglist_{}.csv" dif_transientdict_name = "dif_transientdict_{}.json" dif_basevaldict_name = "dif_basevaldict_{}.json" dif_boxrankdict_name = "dif_boxrankdict_{}.json" dif_rel_boxrankdict_name = "dif_rel_boxrankdict_{}.json" dif_typename = "dif_" + typename dif_gainmatrices = get_gainmatrices(noderankdata, datadir, dif_typename) # Create lists to store the backward ranking list # for each box and associated gainmatrix ranking result # backward_rankinglists = [] backward_rankingdicts = [] dif_backward_rankingdicts = [] for index, gainmatrix in enumerate(gainmatrices): if preprocessing: # modgainmatrix, _ = \ # gainmatrix_preprocessing(gainmatrix) modgainmatrix = gainmatrix_tobinary(gainmatrix) else: modgainmatrix = gainmatrix if generate_diffs: dif_gainmatrix = dif_gainmatrices[index] # Take only positive values for now due to convergence issues # TODO: Investigate proper handling of negative edge changes mod_dif_gainmatrix = dif_gainmatrix_preprocessing( dif_gainmatrix, method="floor" ) delays = delaymatrices[index] # _, dummyweight = gainmatrix_preprocessing(gainmatrix) # Set dummyweight to 10 dummyweight = 10 # This is where the actual ranking calculation happens rankingdict, rankinglist, connections, variables, gains = calc_gainrank( modgainmatrix, noderankdata, rank_method, dummyweight ) if generate_diffs: # TODO: Review effect of positive differences only # Take only positive for now due to convergence issues, but investigate proper handling # of negative edge changes dif_rankingdict, dif_rankinglist, _, _, _ = calc_gainrank( mod_dif_gainmatrix, noderankdata, rank_method, dummyweight ) # dif_backward_rankinglists.append(dif_rankinglist) dif_backward_rankingdicts.append(dif_rankingdict) # The rest of the function deals with storing the # results in the desired formats # backward_rankinglists.append(rankinglist) backward_rankingdicts.append(rankingdict) if writeoutput: # Make sure the correct directory exists # Take datadir and swop out 'weightdata' for 'noderank' savedir = data_processing.change_dirtype(datadir, "weightdata", "noderank") config_setup.ensure_existence(os.path.join(savedir, typename[:-7])) if preprocessing: # Save the modified gainmatrix writecsv_looprank( os.path.join(savedir, typename[:-7], modgainmatrix_name), modgainmatrix, ) # Save the original gainmatrix writecsv_looprank( os.path.join(savedir, typename[:-7], originalgainmatrix_name), gainmatrix, ) # Export graph files with dummy variables included # in backward rankings if available # directions = ['backward'] if noderankdata.dummies: dummystatus = "withdummies" else: dummystatus = "nodummies" # Save the ranking list for each box savepath = config_setup.ensure_existence( os.path.join( savedir, typename[:-7], "box{:03d}".format(noderankdata.boxes[index] + 1), dummystatus, ) ) writecsv_looprank( os.path.join(savepath, rankinglist_name.format(rank_method)), rankinglist ) if generate_diffs: writecsv_looprank( os.path.join(savepath, dif_rankinglist_name.format(rank_method)), dif_rankinglist, ) # Save the graphs to file graph, _ = create_importance_graph( noderankdata, variables, connections, connections, gains, delays, rankingdict, ) graph_filename = os.path.join(savepath, graphfile_name.format(rank_method)) # Decided to keep connections natural, will rotate hierarchical layout # in post-processing nx.readwrite.write_gml(graph, graph_filename) # Get ranking dictionaries transientdict, basevaldict, boxrankdict, rel_boxrankdict = calc_transient_importancediffs( backward_rankingdicts, noderankdata.variablelist ) if generate_diffs: # Get ranking dictionaries for difference gain arrays dif_transientdict, dif_basevaldict, dif_boxrankdict, dif_rel_boxrankdict = calc_transient_importancediffs( dif_backward_rankingdicts, noderankdata.variablelist ) # Store dictonaries using JSON # Normal dictionaries data_processing.write_dictionary( os.path.join(savepath, boxrankdict_name.format(rank_method)), boxrankdict ) data_processing.write_dictionary( os.path.join(savepath, rel_boxrankdict_name.format(rank_method)), rel_boxrankdict, ) data_processing.write_dictionary( os.path.join(savepath, transientdict_name.format(rank_method)), transientdict, ) data_processing.write_dictionary( os.path.join(savepath, basevaldict_name.format(rank_method)), basevaldict ) if generate_diffs: # Difference dictionaries data_processing.write_dictionary( os.path.join(savepath, dif_boxrankdict_name.format(rank_method)), dif_boxrankdict, ) data_processing.write_dictionary( os.path.join(savepath, dif_rel_boxrankdict_name.format(rank_method)), dif_rel_boxrankdict, ) data_processing.write_dictionary( os.path.join(savepath, dif_transientdict_name.format(rank_method)), dif_transientdict, ) data_processing.write_dictionary( os.path.join(savepath, dif_basevaldict_name.format(rank_method)), dif_basevaldict, ) return None