def execute_calculateExchangeFluxStatistics(self,simulation_id_I,simulation_dateAndTimes_I=[],flux_units_I=[],rxn_ids_I=[]): '''Calculate: 1. # of unresolved fluxes per total # of reactions 2. average flux precision per resolved flux''' mfamethods = MFA_methods(); data_O = []; print('calculating fit statistics...') # simulation_dateAndTime if simulation_dateAndTimes_I: simulation_dateAndTimes = [self.convert_string2datetime(x) for x in simulation_dateAndTimes_I]; else: simulation_dateAndTimes = []; simulation_dateAndTimes = self.get_simulationDateAndTimes_simulationID_dataStage02IsotopomerfittedFluxes(simulation_id_I); for simulation_dateAndTime in simulation_dateAndTimes: print('calculating flux ratios for simulation_dataAndTime ' + str(simulation_dateAndTime)) # get all flux_units if flux_units_I: flux_units = flux_units_I; else: flux_units = []; flux_units = self.get_fluxUnits_simulationIDAndSimulationDateAndTime_dataStage02IsotopomerfittedExchangeFluxes(simulation_id_I,simulation_dateAndTime) for flux_unit_cnt,flux_unit in enumerate(flux_units): print('calculating fit statistics for flux_units ' + str(flux_unit)) # get the net fluxes flux_O,flux_stdev_O,flux_lb_O,flux_ub_O,flux_units_O=[],[],[],[],[]; if rxn_ids_I: for rxn_id in rxn_ids_I: flux_average_2,flux_stdev_2,flux_lb_2,flux_ub_2,flux_units_2 = self.get_flux_simulationIDAndSimulationDateAndTimeAndFluxUnitsAndRxnID_dataStage02IsotopomerfittedExchangeFluxes(simulation_id_I,simulation_dateAndTime,flux_unit,rxn_id); flux_O.append(flux_average_2); flux_stdev_O.append(flux_stdev_2); flux_lb_O.append(flux_lb_2); flux_ub_O.append(flux_ub_2); flux_units_O.append(flux_units_2); else: flux_O,flux_stdev_O,flux_lb_O,flux_ub_O,flux_units_O=self.get_fluxes_simulationIDAndSimulationDateAndTimeAndFluxUnits_dataStage02IsotopomerfittedExchangeFluxes(simulation_id_I,simulation_dateAndTime,flux_unit); total_fluxes,observable_fluxes,relative_nObservableFluxes = mfamethods.calculate_relativeNObservableFluxes(flux_O,flux_lb_O,flux_ub_O); average_fluxPrecision,average_observable_fluxPrecision = mfamethods.calculate_averageFluxPrecision(flux_O,flux_stdev_O,flux_lb_O,flux_ub_O); total_fluxPrecision,total_observable_fluxPrecision = mfamethods.calculate_totalFluxPrecision(flux_O,flux_stdev_O,flux_lb_O,flux_ub_O); tmp = {}; tmp['simulation_id'] = simulation_id_I; tmp['simulation_dateAndTime'] = simulation_dateAndTime; tmp['n_fluxes'] = total_fluxes tmp['n_observableFluxes'] = observable_fluxes tmp['total_precision'] = total_fluxPrecision tmp['total_observablePrecision'] = total_observable_fluxPrecision tmp['relative_nObservableFluxes']= relative_nObservableFluxes; tmp['average_observableFluxPrecision'] = average_observable_fluxPrecision; tmp['average_fluxPrecision'] = average_fluxPrecision tmp['flux_units'] = flux_unit; tmp['used_'] = True; tmp['comment_'] = None; data_O.append(tmp); self.add_data_stage02_isotopomer_fittedExchangeFluxStatistics(data_O);
def execute_makeExchangeFluxes(self, simulation_id_I,simulation_dateAndTimes_I=[],normalize_rxn_id_I=None,convert_netRxn2IndividualRxns_I=False, calculate_fluxStdevFromLBAndUB_I=True,calculate_fluxAverageFromLBAndUB_I=True,substitute_zeroFluxForNone_I=True, lower_bound_I=None,upper_bound_I=None): '''Determine the exchange flux of reversible reactions INPUT: normalize_rxn_id_I = rxn_id to normalize all fluxes to conver_netRxn2IndividualRxns_I = break apart lumped reactions into individual reactions calculate_fluxStdevFromLBAndUB_I = substitute the calculated standard deviation with the lb/ub as follows: (flux_ub_I - flux_lb_I)/4 calculate_fluxAverageFromLBAndUB_I = calculate the flux average from the mean of the lb/ub substitute_zeroFluxForNone_I = substitute 0.0 for None lower_bound_I = lower bound for the reaction flux upper_bound_I = upper bound for the reaction flux''' mfamethods = MFA_methods(); isotopomernetRxns = isotopomer_netRxns(); data_O = []; # simulation_dateAndTime if simulation_dateAndTimes_I: simulation_dateAndTimes = [self.convert_string2datetime(x) for x in simulation_dateAndTimes_I]; else: simulation_dateAndTimes = []; simulation_dateAndTimes = self.get_simulationDateAndTimes_simulationID_dataStage02IsotopomerfittedFluxes(simulation_id_I); for simulation_dateAndTime in simulation_dateAndTimes: # get all reactions included in the simulation (in alphabetical order) rxns = []; rxns = self.get_rxnIDs_simulationIDAndSimulationDateAndTime_dataStage02IsotopomerfittedFluxes(simulation_id_I,simulation_dateAndTime) # group into forward and reverse reactions rxns_pairs = {}; rxn_pair = []; for rxn_cnt,rxn in enumerate(rxns): #if rxn == 'ValSYN': # print('check'); if not rxn_pair: rxn_pair.append(rxn); else: if '_reverse' in rxn and rxn_pair[0] in rxn: rxn_pair.append(rxn); rxns_pairs[rxn_pair[0]]=rxn_pair; rxn_pair = []; elif '_reverse' in rxn_pair[0]: rxn_pair.insert(0,None); rxn_name = rxn_pair[1].replace('_reverse',''); rxns_pairs[rxn_name]=rxn_pair; rxn_pair = []; rxn_pair.append(rxn); if rxn_cnt == len(rxns)-1: #final rxn rxn_pair.insert(0,None); rxn_name = rxn_pair[1].replace('_reverse',''); rxns_pairs[rxn_name]=rxn_pair; rxn_pair = []; else: rxn_pair.append(None); rxns_pairs[rxn_pair[0]]=rxn_pair; rxn_pair = []; rxn_pair.append(rxn); if rxn_cnt == len(rxns)-1: #final rxn rxn_pair.append(None); rxns_pairs[rxn_pair[0]]=rxn_pair; rxn_pair = []; # query the maximum and minimum flux: if not lower_bound_I is None or not upper_bound_I is None: min_flux,max_flux=lower_bound_I,upper_bound_I; else: min_flux,max_flux=None,None min_flux,max_flux = self.get_fluxMinAndMax_simulationIDAndSimulationDateAndTime_dataStage02IsotopomerfittedFluxes(simulation_id_I,simulation_dateAndTime); # query the normalized rxn flux if normalize_rxn_id_I: flux_average_norm,flux_stdev_norm,flux_lb_norm,flux_ub_norm,flux_units_norm = None,None,None,None,None; flux_average_norm,flux_stdev_norm,flux_lb_norm,flux_ub_norm,flux_units_norm = self.get_flux_simulationIDAndSimulationDateAndTimeAndRxnID_dataStage02IsotopomerfittedFluxes(simulation_id_I,simulation_dateAndTime,normalize_rxn_id_I); min_flux = min_flux/flux_average_norm max_flux = max_flux/flux_average_norm # check if the sign switched if max_flux < min_flux: min_flux_tmp = min_flux; max_flux_tmp = min_flux; max_flux = min_flux_tmp min_flux = max_flux_tmp # calculate the net reaction flux average, stdev, lb and ub unique_rxn_ids = []; #add only unique rxn_ids for k,v in rxns_pairs.items(): flux_average_1 = 0.0 flux_average_2 = 0.0 flux_average_net = 0.0 flux_stdev_1 = 0.0 flux_stdev_2 = 0.0 flux_stdev_net = 0.0 flux_lb_1 = 0.0 flux_lb_2 = 0.0 flux_lb_net = 0.0 flux_ub_1 = 0.0 flux_ub_2 = 0.0 flux_ub_net = 0.0 flux_units_1 = '' flux_units_2 = '' flux_units_net = '' # get the flux data if v[0]: flux_average_1,flux_stdev_1,flux_lb_1,flux_ub_1,flux_units_1 = self.get_flux_simulationIDAndSimulationDateAndTimeAndRxnID_dataStage02IsotopomerfittedFluxes(simulation_id_I,simulation_dateAndTime,v[0]); if v[1]: flux_average_2,flux_stdev_2,flux_lb_2,flux_ub_2,flux_units_2 = self.get_flux_simulationIDAndSimulationDateAndTimeAndRxnID_dataStage02IsotopomerfittedFluxes(simulation_id_I,simulation_dateAndTime,v[1]); # determine if the fluxes are observable observable_1 = mfamethods.check_observableFlux(flux_average_1,flux_lb_1,flux_ub_1) observable_2 = mfamethods.check_observableFlux(flux_average_2,flux_lb_2,flux_ub_2) # normalize the flux to normalize_rxn_id_I if there was a flux if normalize_rxn_id_I: if flux_units_1!='': flux_average_1,flux_stdev_1,flux_lb_1,flux_ub_1,flux_units_1=mfamethods.normalize_flux(normalize_rxn_id_I,flux_average_norm,flux_stdev_norm,flux_lb_norm,flux_ub_norm,flux_average_1,flux_stdev_1,flux_lb_1,flux_ub_1); if flux_units_2!='': flux_average_2,flux_stdev_2,flux_lb_2,flux_ub_2,flux_units_2=mfamethods.normalize_flux(normalize_rxn_id_I,flux_average_norm,flux_stdev_norm,flux_lb_norm,flux_ub_norm,flux_average_2,flux_stdev_2,flux_lb_2,flux_ub_2); # get the net flux if flux_units_1!='': flux_average_net,flux_stdev_net,flux_lb_net,flux_ub_net,flux_units_net = self.get_flux_simulationIDAndSimulationDateAndTimeAndFluxUnitsAndRxnID_dataStage02IsotopomerfittedNetFluxes( simulation_id_I,simulation_dateAndTime,flux_units_1,k); elif flux_units_2!='': flux_average_net,flux_stdev_net,flux_lb_net,flux_ub_net,flux_units_net = self.get_flux_simulationIDAndSimulationDateAndTimeAndFluxUnitsAndRxnID_dataStage02IsotopomerfittedNetFluxes( simulation_id_I,simulation_dateAndTime,flux_units_2,k); ## calculate the net flux #if k=='PGM': # print('check'); flux_average,flux_stdev,flux_lb,flux_ub,flux_units,\ flux_normalized_average,flux_normalized_stdev,flux_normalized_lb,flux_normalized_ub,flux_normalized_units = mfamethods.calculate_exchangeFlux( flux_average_1,flux_stdev_1,flux_lb_1,flux_ub_1,flux_units_1, flux_average_2,flux_stdev_2,flux_lb_2,flux_ub_2,flux_units_2, flux_average_net,flux_stdev_net,flux_lb_net,flux_ub_net,flux_units_net, min_flux,max_flux) # correct the flux stdev if calculate_fluxStdevFromLBAndUB_I: flux_stdev = mfamethods.calculate_fluxStdevFromLBAndUB(flux_lb,flux_ub); #default = true for flux_normalized if calculate_fluxAverageFromLBAndUB_I: flux_average = mfamethods.calculate_fluxAverageFromLBAndUB(flux_average,flux_lb,flux_ub); #default = true for flux_normalized if substitute_zeroFluxForNone_I: flux_average = mfamethods.substitute_zeroFluxForNone(flux_average); flux_normalized_average = mfamethods.substitute_zeroFluxForNone(flux_normalized_average); # record net reaction flux if convert_netRxn2IndividualRxns_I: rxns_O,fluxes_O,fluxes_stdev_O,fluxes_lb_O,fluxes_ub_O,fluxes_units_O = isotopomernetRxns.convert_netRxn2IndividualRxns(k,flux_average,flux_stdev,flux_lb,flux_ub,flux_units); rxns_normalized_O,fluxes_normalized_O,fluxes_normalized_stdev_O,fluxes_normalized_lb_O,fluxes_normalized_ub_O,fluxes_normalized_units_O = isotopomernetRxns.convert_netRxn2IndividualRxns(k,flux_normalized_average,flux_normalized_stdev,flux_normalized_lb,flux_normalized_ub,flux_normalized_units); if fluxes_O: for i,flux in enumerate(fluxes_O): if not rxns_O[i] in unique_rxn_ids: unique_rxn_ids.append(rxns_O[i]); data_O.append({'simulation_id':simulation_id_I, 'simulation_dateAndTime':simulation_dateAndTime, 'rxn_id':rxns_O[i], 'flux_exchange':fluxes_O[i], 'flux_exchange_stdev':fluxes_stdev_O[i], 'flux_exchange_lb':fluxes_lb_O[i], 'flux_exchange_ub':fluxes_ub_O[i], 'flux_exchange_units':fluxes_units_O[i], 'flux_exchange_normalized':fluxes_normalized_O[i], 'flux_exchange_normalized_stdev':fluxes_normalized_stdev_O[i], 'flux_exchange_normalized_lb':fluxes_normalized_lb_O[i], 'flux_exchange_normalized_ub':fluxes_normalized_ub_O[i], 'flux_exchange_normalized_units':fluxes_normalized_units_O[i], 'used_':True, 'comment_':None}) else: if not k in unique_rxn_ids: unique_rxn_ids.append(k); data_O.append({'simulation_id':simulation_id_I, 'simulation_dateAndTime':simulation_dateAndTime, 'rxn_id':k, 'flux_exchange':flux_average, 'flux_exchange_stdev':flux_stdev, 'flux_exchange_lb':flux_lb, 'flux_exchange_ub':flux_ub, 'flux_exchange_units':flux_units, 'flux_exchange_normalized':flux_normalized_average, 'flux_exchange_normalized_stdev':flux_normalized_stdev, 'flux_exchange_normalized_lb':flux_normalized_lb, 'flux_exchange_normalized_ub':flux_normalized_ub, 'flux_exchange_normalized_units':flux_normalized_units, 'used_':True, 'comment_':None}) else: data_O.append({'simulation_id':simulation_id_I, 'simulation_dateAndTime':simulation_dateAndTime, 'rxn_id':k, 'flux_exchange':flux_average, 'flux_exchange_stdev':flux_stdev, 'flux_exchange_lb':flux_lb, 'flux_exchange_ub':flux_ub, 'flux_exchange_units':flux_units, 'flux_exchange_normalized':flux_normalized_average, 'flux_exchange_normalized_stdev':flux_normalized_stdev, 'flux_exchange_normalized_lb':flux_normalized_lb, 'flux_exchange_normalized_ub':flux_normalized_ub, 'flux_exchange_normalized_units':flux_normalized_units, 'used_':True, 'comment_':None}) # add data to the database: self.add_data_stage02_isotopomer_fittedExchangeFluxes(data_O);
def execute_calculateFluxSplits(self,simulation_id_I,simulation_dateAndTimes_I=[],flux_splits_I=None, calculate_fluxStdevFromLBAndUB_I=True, calculate_fluxAverageFromLBAndUB_I=False, criteria_I = 'flux_lb/flux_ub'): '''calculate the flux splits INPUT: calculate_fluxStdevFromLBAndUB_I = substitute the calculated standard deviation with the lb/ub as follows: (flux_ub_I - flux_lb_I)/4 calculate_fluxAverageFromLBAndUB_I = calculate the flux average from the mean of the lb/ub criteria_I = string, flux_lb/flux_ub: use flux_lb and flux_ub to determine the confidence intervals (default) flux_mean/flux_stdev: use the flux_mean and flux_stdev to determine the confidence intervals ''' #Input: # simulation_id_I = string, simulation id # flux_splits_I = dict, {split_id:[rxn_id_1,rxn_id_2]} mfamethods = MFA_methods(); if not flux_splits_I: flux_splits = isotopomer_fluxSplits(); flux_splits_I=flux_splits.isotopomer_splits; data_O = []; print('calculating flux splits...') # simulation_dateAndTime if simulation_dateAndTimes_I: simulation_dateAndTimes = [self.convert_string2datetime(x) for x in simulation_dateAndTimes_I]; else: simulation_dateAndTimes = []; simulation_dateAndTimes = self.get_simulationDateAndTimes_simulationID_dataStage02IsotopomerfittedNetFluxes(simulation_id_I); for simulation_dateAndTime in simulation_dateAndTimes: print('calculating flux splits for simulation_dateAndTime ' + str(simulation_dateAndTime)) # get all flux_units flux_units = []; flux_units = self.get_fluxUnits_simulationIDAndSimulationDateAndTime_dataStage02IsotopomerfittedNetFluxes(simulation_id_I,simulation_dateAndTime) for flux_unit_cnt,flux_unit in enumerate(flux_units): # check for more than 1 flux_unit if flux_unit_cnt>0: break; #splits do not depend on the flux_unit print('calculating flux splits for flux_unit ' + str(flux_unit)) for k,v in flux_splits_I.items(): print('flux_split ' + str(k)) # get the fluxes flux_average_1,flux_stdev_1,flux_lb_1,flux_ub_1,flux_units_1=[],[],[],[],[] for rxn_id in v: flux_average_2,flux_stdev_2,flux_lb_2,flux_ub_2,flux_units_2 = self.get_flux_simulationIDAndSimulationDateAndTimeAndFluxUnitsAndRxnID_dataStage02IsotopomerfittedNetFluxes(simulation_id_I,simulation_dateAndTime,flux_unit,rxn_id); flux_average_1.append(flux_average_2); flux_stdev_1.append(flux_stdev_2); flux_lb_1.append(flux_lb_2); flux_ub_1.append(flux_ub_2); flux_units_1.append(flux_units_2); # calculate the split split,split_stdev,split_lb,split_ub,split_units=mfamethods.calculate_fluxSplit(flux_average_1,flux_stdev_1,flux_lb_1,flux_ub_1,flux_units_1,criteria_I) # correct the flux stdev if calculate_fluxStdevFromLBAndUB_I: split_stdev = mfamethods.calculate_fluxStdevFromLBAndUB(split_lb,split_ub); if calculate_fluxAverageFromLBAndUB_I: split = mfamethods.calculate_fluxAverageFromLBAndUB(split,split_lb,split_ub); # record the data for rxn_id_cnt,rxn_id in enumerate(v): data_O.append({'simulation_id':simulation_id_I, 'simulation_dateAndTime':simulation_dateAndTime, 'split_id':k, 'split_rxn_ids':rxn_id, 'split':split[rxn_id_cnt], 'split_stdev':split_stdev[rxn_id_cnt], 'split_lb':split_lb[rxn_id_cnt], 'split_ub':split_ub[rxn_id_cnt], 'split_units':split_units[rxn_id_cnt], 'used_':True, 'comment_':None}) # add the data to the database: for d in data_O: row=None; row=data_stage02_isotopomer_fittedFluxSplits(d['simulation_id'], d['simulation_dateAndTime'], d['split_id'], d['split_rxn_ids'], d['split'], d['split_stdev'], d['split_lb'], d['split_ub'], d['split_units'], d['used_'], d['comment_']); self.session.add(row); self.session.commit();
def export_dataStage02IsotopomerFluxMap_js(self,analysis_id_I,simulation_id_I = None,data_dir_I="tmp"): '''Export flux map for viewing''' MFAmethods = MFA_methods(); # Get the simulation information if simulation_id_I: simulation_id = simulation_id_I; else: simulation_ids = []; simulation_ids = self.get_simulationID_analysisID_dataStage02IsotopomerAnalysis(analysis_id_I); if not simulation_ids: print('No simulation found for the analysis_id ' + analysis_id_I); elif len(simulation_ids)>1: print('More than 1 simulation found for the analysis_id ' + analysis_id_I); simulation_id_I = simulation_ids[0]; else: simulation_id_I = simulation_ids[0]; # Get the flux information flux = []; flux_tmp = []; #flux = self.get_rowsEscherFluxList_simulationID_dataStage02IsotopomerfittedExchangeFluxes(simulation_id_I); flux_tmp = self.get_rows_simulationID_dataStage02IsotopomerfittedExchangeFluxes(simulation_id_I); for i,row in enumerate(flux_tmp): observable = MFAmethods.check_observableExchangeFlux(row['flux'],row['flux_lb'],row['flux_ub']); if not row['flux'] is None and row['flux']!=0.0 and numpy.abs(row['flux']) < 10.0: flux_tmp[i]['simulation_dateAndTime'] = self.convert_datetime2string(row['simulation_dateAndTime']); flux_tmp[i]['flux_units'] = self.remove_jsRegularExpressions(row['flux_units']); if observable: flux_tmp[i]['observable'] = 'Yes'; else: flux_tmp[i]['observable'] = 'No'; flux.append(flux_tmp[i]); elif row['flux']==0.0 and numpy.abs(numpy.mean([row['flux_lb'],row['flux_ub']]))<10.0: flux_tmp[i]['simulation_dateAndTime'] = self.convert_datetime2string(row['simulation_dateAndTime']); flux_tmp[i]['flux_units'] = self.remove_jsRegularExpressions(row['flux_units']); #flux_tmp[i]['flux'] = numpy.mean([row['flux_lb'],row['flux_ub']]); if observable: flux_tmp[i]['observable'] = 'Yes'; else: flux_tmp[i]['observable'] = 'No'; flux.append(flux_tmp[i]); # Get the map information map = []; map = self.get_rows_modelID_modelsEschermaps('iJO1366'); # dump chart parameters to a js files data1_keys = ['simulation_id','rxn_id','simulation_dateAndTime','flux_units','observable' ]; data1_nestkeys = ['simulation_id']; data1_keymap = {'values':'flux','key':'rxn_id'}; data2_keys = ['model_id','eschermap_id' ]; data2_nestkeys = ['model_id']; data2_keymap = {'data':'eschermap_json'}; # make the data object dataobject_O = [{"data":flux,"datakeys":data1_keys,"datanestkeys":data1_nestkeys}, {"data":map,"datakeys":data2_keys,"datanestkeys":data2_nestkeys}]; # make the tile parameter objects formtileparameters1_O = {'tileheader':'Filter menu','tiletype':'html','tileid':"filtermenu1",'rowid':"row1",'colid':"col1", 'tileclass':"panel panel-default",'rowclass':"row",'colclass':"col-sm-6"}; formparameters1_O = {'htmlid':'filtermenuform1',"htmltype":'form_01',"formsubmitbuttonidtext":{'id':'submit1','text':'submit'},"formresetbuttonidtext":{'id':'reset1','text':'reset'},"formupdatebuttonidtext":{'id':'update1','text':'update'}}; formtileparameters1_O.update(formparameters1_O); formtileparameters2_O = {'tileheader':'Filter menu','tiletype':'html','tileid':"filtermenu2",'rowid':"row1",'colid':"col2", 'tileclass':"panel panel-default",'rowclass':"row",'colclass':"col-sm-6"}; formparameters2_O = {'htmlid':'filtermenuform2',"htmltype":'form_01',"formsubmitbuttonidtext":{'id':'submit2','text':'submit'},"formresetbuttonidtext":{'id':'reset2','text':'reset'},"formupdatebuttonidtext":{'id':'update2','text':'update'}}; formtileparameters2_O.update(formparameters2_O); htmlparameters_O = {"htmlkeymap":[data1_keymap,data2_keymap], 'htmltype':'escher_01','htmlid':'html1', 'escherdataindex':{"reactiondata":0,"mapdata":1}, 'escherembeddedcss':None, 'escheroptions':None}; htmltileparameters_O = {'tileheader':'Escher map','tiletype':'html','tileid':"tile1",'rowid':"row2",'colid':"col1", 'tileclass':"panel panel-default",'rowclass':"row",'colclass':"col-sm-12"}; htmltileparameters_O.update(htmlparameters_O); tableparameters_O = {"tabletype":'responsivetable_01', 'tableid':'table1', "tablefilters":None, "tableclass":"table table-condensed table-hover", 'tableformtileid':'filtermenu1','tableresetbuttonid':'reset1','tablesubmitbuttonid':'submit1'}; tabletileparameters_O = {'tileheader':'Flux precision','tiletype':'table','tileid':"tile2",'rowid':"row3",'colid':"col1", 'tileclass':"panel panel-default",'rowclass':"row",'colclass':"col-sm-12"}; tabletileparameters_O.update(tableparameters_O); parametersobject_O = [formtileparameters1_O,formtileparameters2_O,htmltileparameters_O,tabletileparameters_O]; tile2datamap_O = {"filtermenu1":[0],"filtermenu2":[1],"tile1":[0,1],"tile2":[0]}; filtermenuobject_O = [{"filtermenuid":"filtermenu1","filtermenuhtmlid":"filtermenuform1", "filtermenusubmitbuttonid":"submit1","filtermenuresetbuttonid":"reset1", "filtermenuupdatebuttonid":"update1"},{"filtermenuid":"filtermenu2","filtermenuhtmlid":"filtermenuform2", "filtermenusubmitbuttonid":"submit2","filtermenuresetbuttonid":"reset2", "filtermenuupdatebuttonid":"update2"}]; # dump the data to a json file ddtutilities = ddt_container(parameters_I = parametersobject_O,data_I = dataobject_O,tile2datamap_I = tile2datamap_O,filtermenu_I = filtermenuobject_O); if data_dir_I=='tmp': filename_str = self.settings['visualization_data'] + '/tmp/ddt_data.js' elif data_dir_I=='data_json': data_json_O = ddtutilities.get_allObjects_js(); return data_json_O; with open(filename_str,'w') as file: file.write(ddtutilities.get_allObjects());
def export_dataStage02IsotopomerFittedExchangeFluxes_js(self,analysis_id_I = None, simulation_ids_I = [], bullet_chart_I = True, data_dir_I="tmp"): '''Plot the flux precision for a given set of simulations and a given set of reactions Input: analysis_id_I = string, analysis id Optional Input: simulation_ids_I = [] of strings, simulation_ids in a specific order bullet_chart_I = True: show the flux estimation +/- StDev False: show the 95% confidence invervals and flux estimation +/- StDev ''' MFAmethods = MFA_methods(); #Input: # analysis_id_I or # simulation_ids_I if simulation_ids_I: simulation_ids = simulation_ids_I; else: simulation_ids = []; simulation_ids = self.get_simulationID_analysisID_dataStage02IsotopomerAnalysis(analysis_id_I); data_O =[]; for simulation_id in simulation_ids: # get the flux information for each simulation flux_data = []; flux_data = self.get_rows_simulationID_dataStage02IsotopomerfittedExchangeFluxes(simulation_id); #min_flux,max_flux = None,None; #min_flux,max_flux = self.get_fluxMinAndMax_simulationID_dataStage02IsotopomerfittedExchangeFluxes(simulation_id) for i,row in enumerate(flux_data): observable = MFAmethods.check_observableExchangeFlux(row['flux'],row['flux_lb'],row['flux_ub']); if not row['flux'] is None: row['simulation_dateAndTime'] = self.convert_datetime2string(row['simulation_dateAndTime']); #row['flux_units'] = row['flux_units'].replace('*','x'); row['flux_lb_stdev'] = row['flux'] - row['flux_stdev']; row['flux_ub_stdev'] = row['flux'] + row['flux_stdev']; row['flux_mean'] = numpy.mean([row['flux_lb'],row['flux_ub']]); if observable: row['observable'] = 'Yes'; else: row['observable'] = 'No'; data_O.append(row); #if not row['flux'] is None and observable: # row['simulation_dateAndTime'] = self.convert_datetime2string(row['simulation_dateAndTime']); # row['flux_units'] = row['flux_units'].replace('*','x'); # row['flux_lb_stdev'] = row['flux'] - row['flux_stdev']; # row['flux_ub_stdev'] = row['flux'] + row['flux_stdev']; # row['flux_mean'] = numpy.mean([row['flux_lb'],row['flux_ub']]); # data_O.append(row); #elif not row['flux'] is None and not observable: # row['simulation_dateAndTime'] = self.convert_datetime2string(row['simulation_dateAndTime']); # row['flux_units'] = row['flux_units'].replace('*','x'); # row['flux_lb'] = None; # row['flux_ub'] = None; # row['flux_mean'] = None; # data_O.append(row); #elif row['flux']==0.0 and observable: # row['simulation_dateAndTime'] = self.convert_datetime2string(row['simulation_dateAndTime']); # row['flux_units'] = row['flux_units'].replace('*','x'); # row['flux_lb_stdev'] = 0.0; # row['flux_ub_stdev'] = 0.0; # row['flux_mean'] = numpy.mean([row['flux_lb'],row['flux_ub']]); # data_O.append(row); #elif row['flux']==0.0 and not observable: # row['simulation_dateAndTime'] = self.convert_datetime2string(row['simulation_dateAndTime']); # row['flux_units'] = row['flux_units'].replace('*','x'); # row['flux_lb'] = None; # row['flux_ub'] = None; # #row['flux_mean'] = None; # row['flux_lb_stdev'] = None; # row['flux_ub_stdev'] = None; # row['flux']=None; # data_O.append(row); elif row['flux']==0.0: row['simulation_dateAndTime'] = self.convert_datetime2string(row['simulation_dateAndTime']); row['flux_units'] = row['flux_units'].replace('*','x'); row['flux_lb_stdev'] = 0.0; row['flux_ub_stdev'] = 0.0; row['flux_mean'] = numpy.mean([row['flux_lb'],row['flux_ub']]); if observable: row['observable'] = 'Yes'; else: row['observable'] = 'No'; data_O.append(row); # dump chart parameters to a js files data1_keys = ['simulation_id','rxn_id','simulation_dateAndTime','flux_units','observable' ]; data1_nestkeys = ['rxn_id']; if bullet_chart_I: data1_keymap = {'xdata':'rxn_id', 'ydatamean':'flux', 'ydatalb':'flux_lb_stdev', 'ydataub':'flux_ub_stdev', 'serieslabel':'simulation_id', 'featureslabel':'rxn_id'}; else: data1_keymap = {'xdata':'rxn_id', #'ydata':'flux', 'ydatamean':'flux_mean', 'ydatalb':'flux_lb', 'ydataub':'flux_ub', #'ydatamin':'min', #'ydatamax':'max', 'ydataiq1':'flux_lb_stdev', 'ydataiq3':'flux_ub_stdev', 'ydatamedian':'flux', 'serieslabel':'simulation_id', 'featureslabel':'rxn_id'}; # make the data object dataobject_O = [{"data":data_O,"datakeys":data1_keys,"datanestkeys":data1_nestkeys}]; # make the tile parameter objects formtileparameters_O = {'tileheader':'Filter menu','tiletype':'html','tileid':"filtermenu1",'rowid':"row1",'colid':"col1", 'tileclass':"panel panel-default",'rowclass':"row",'colclass':"col-sm-12"}; formparameters_O = {'htmlid':'filtermenuform1',"htmltype":'form_01',"formsubmitbuttonidtext":{'id':'submit1','text':'submit'},"formresetbuttonidtext":{'id':'reset1','text':'reset'},"formupdatebuttonidtext":{'id':'update1','text':'update'}}; formtileparameters_O.update(formparameters_O); svgparameters_O = {"svgtype":'boxandwhiskersplot2d_02',"svgkeymap":[data1_keymap,data1_keymap], 'svgid':'svg1', "svgmargin":{ 'top': 50, 'right': 350, 'bottom': 50, 'left': 50 }, "svgwidth":750,"svgheight":350, "svgx1axislabel":"rxn_id","svgy1axislabel":"flux", 'svgformtileid':'filtermenu1','svgresetbuttonid':'reset1','svgsubmitbuttonid':'submit1'}; svgtileparameters_O = {'tileheader':'Flux precision','tiletype':'svg','tileid':"tile2",'rowid':"row1",'colid':"col1", 'tileclass':"panel panel-default",'rowclass':"row",'colclass':"col-sm-12"}; svgtileparameters_O.update(svgparameters_O); tableparameters_O = {"tabletype":'responsivetable_01', 'tableid':'table1', "tablefilters":None, "tableclass":"table table-condensed table-hover", 'tableformtileid':'filtermenu1','tableresetbuttonid':'reset1','tablesubmitbuttonid':'submit1'}; tabletileparameters_O = {'tileheader':'Flux precision','tiletype':'table','tileid':"tile3",'rowid':"row1",'colid':"col1", 'tileclass':"panel panel-default",'rowclass':"row",'colclass':"col-sm-12"}; tabletileparameters_O.update(tableparameters_O); parametersobject_O = [formtileparameters_O,svgtileparameters_O,tabletileparameters_O]; tile2datamap_O = {"filtermenu1":[0],"tile2":[0],"tile3":[0]}; # dump the data to a json file ddtutilities = ddt_container(parameters_I = parametersobject_O,data_I = dataobject_O,tile2datamap_I = tile2datamap_O,filtermenu_I = None); if data_dir_I=='tmp': filename_str = self.settings['visualization_data'] + '/tmp/ddt_data.js' elif data_dir_I=='data_json': data_json_O = ddtutilities.get_allObjects_js(); return data_json_O; with open(filename_str,'w') as file: file.write(ddtutilities.get_allObjects());
def execute_findNetFluxSignificantDifferences(self,analysis_id_I, criteria_I = 'flux_lb/flux_ub', simulation_ids_I=[],simulation_dateAndTimes_I = [], rxn_ids_I = [],flux_units_I = [], control_simulation_id_I=None, control_simulation_dateAndTime_I=None, redundancy_I=False, observable_only_I=False): """Find fluxes that are significantly different Input: analysis_id_I = string, criteria_I = string, flux_lb/flux_ub: use flux_lb and flux_ub to determine significance (default) flux_mean/flux_stdev: use the flux_mean and flux_stdev to determine significance control_simulation_id_I = string, simulation_id to compare all other simulation_ids to simulation_dateAndTime_I = string, simulation_dateAndTime to compare all other simulation_ids to redundancy_I = boolean, if true, all values with be compared, if false (default), only unique comparisons will be made observable_only_I = boolean, if true, only observable fluxes will be compared, if false (default), observable and unobservable fluxes will be compared """ mfamethods = MFA_methods(); data_O = []; print('executing findNetFluxSignificantDifferences...') # get the simulation_id and simulation_id dateAndTimes if simulation_ids_I and simulation_dateAndTimes_I: simulation_ids = simulation_ids_I; simulation_dateAndTimes = simulation_dateAndTimes_I; else: simulation_ids = []; simulation_ids_unique = []; simulation_dateAndTimes = []; # get the simulation unique ids simulation_ids_unique = self.get_simulationID_analysisID_dataStage02IsotopomerAnalysis(analysis_id_I); for simulation_id in simulation_ids_unique: # get the simulation dateAndTimes simulation_dateAndTimes_tmp = [] simulation_dateAndTimes_tmp = self.get_simulationDateAndTimes_simulationID_dataStage02IsotopomerfittedNetFluxes(simulation_id); simulation_ids_tmp = [simulation_id for x in simulation_dateAndTimes_tmp]; simulation_dateAndTimes.extend(simulation_dateAndTimes_tmp) simulation_ids.extend(simulation_ids_tmp) if control_simulation_id_I and control_simulation_dateAndTime_I: index = simulation_ids.index(control_simulation_id_I); value = simulation_ids.pop(index); simulation_ids.insert(0, value); control_simulation_dateAndTime_I = self.convert_string2datetime(control_simulation_dateAndTime_I); index = simulation_dateAndTimes.index(control_simulation_dateAndTime_I); value = simulation_dateAndTimes.pop(index) simulation_dateAndTimes.insert(0, value); for simulation_cnt_1, simulation_id_1 in enumerate(simulation_ids): print("calculating netFluxDifferences for simulation_id " + simulation_id_1); # check for control if control_simulation_id_I and control_simulation_dateAndTime_I and simulation_cnt_1>0: break; #prevents redundancy and if simulation_cnt_1+1 >= len(simulation_ids): break; # get the units if flux_units_I: flux_units = flux_units_I; else: flux_units = self.get_fluxUnits_simulationIDAndSimulationDateAndTime_dataStage02IsotopomerfittedNetFluxes(simulation_id_1,simulation_dateAndTimes[simulation_cnt_1]) for flux_unit in flux_units: print("calculating netFluxDifferences for flux_units " + flux_unit); # get the rxn_ids if rxn_ids_I: rxn_ids = rxn_ids_I; else: rxn_ids = []; rxn_ids = self.get_rxnIDs_simulationIDAndSimulationDateAndTimeAndFluxUnits_dataStage02IsotopomerfittedNetFluxes(simulation_id_1,simulation_dateAndTimes[simulation_cnt_1],flux_unit); for rxn_id in rxn_ids: print("calculating netFluxDifferes for rxn_id " + rxn_id); # get simulation_id_1 flux data flux_1,flux_stdev_1,flux_lb_1,flux_ub_1,flux_units_1=None,None,None,None,None; flux_1,flux_stdev_1,flux_lb_1,flux_ub_1,flux_units_1=self.get_flux_simulationIDAndSimulationDateAndTimeAndFluxUnitsAndRxnID_dataStage02IsotopomerfittedNetFluxes(simulation_id_1,simulation_dateAndTimes[simulation_cnt_1],flux_unit,rxn_id); if not mfamethods.check_criteria(flux_1,flux_stdev_1,flux_lb_1,flux_ub_1, criteria_I): continue; if redundancy_I: list_2 = simulation_ids; else: list_2 = simulation_ids[simulation_cnt_1+1:]; if observable_only_I: observable_1 = mfamethods.check_observableNetFlux(flux_1,flux_lb_1,flux_ub_1) if not observable_1: continue; for cnt,simulation_id_2 in enumerate(list_2): #prevents redundancy if redundancy_I: simulation_cnt_2 = cnt; else: simulation_cnt_2 = simulation_cnt_1+cnt+1; if simulation_cnt_2 == simulation_cnt_1: continue; # simulation_id_2 flux_data flux_2,flux_stdev_2,flux_lb_2,flux_ub_2,flux_units_2=None,None,None,None,None; flux_2,flux_stdev_2,flux_lb_2,flux_ub_2,flux_units_2=self.get_flux_simulationIDAndSimulationDateAndTimeAndFluxUnitsAndRxnID_dataStage02IsotopomerfittedNetFluxes(simulation_id_2,simulation_dateAndTimes[simulation_cnt_2],flux_unit,rxn_id); if not mfamethods.check_criteria(flux_2,flux_stdev_2,flux_lb_2,flux_ub_2, criteria_I): continue; if observable_only_I: observable_2 = mfamethods.check_observableNetFlux(flux_2,flux_lb_2,flux_ub_2); if not observable_2: continue; flux_diff,flux_distance,fold_change,significant = None,None,None,False; flux_diff,flux_distance,fold_change,significant = mfamethods.calculate_fluxDifference(flux_1,flux_stdev_1,flux_lb_1,flux_ub_1,flux_units_1, flux_2,flux_stdev_2,flux_lb_2,flux_ub_2,flux_units_2, criteria_I = criteria_I); # record the data data_O.append({ 'analysis_id':analysis_id_I, 'simulation_id_1':simulation_id_1, 'simulation_dateAndTime_1':simulation_dateAndTimes[simulation_cnt_1], 'simulation_id_2':simulation_id_2, 'simulation_dateAndTime_2':simulation_dateAndTimes[simulation_cnt_2], 'rxn_id':rxn_id, 'flux_difference':flux_diff, 'significant':significant, 'significant_criteria':criteria_I, 'flux_units':flux_unit, 'fold_change_geo':fold_change, 'flux_distance':flux_distance, 'used_':True, 'comment_':None}); # add data to the database self.add_data_stage02_isotopomer_fittedNetFluxDifferences(data_O);