def create_sim_map(burnin_id) : am = AnalyzeManager(burnin_id, analyzers=SimulationDirectoryMapAnalyzer()) am.analyze() sim_map_dict = am.analyzers[0].results df = pd.concat([pd.DataFrame(exp) for exp_id, exp in sim_map_dict.items()]) return df
def run_single_analyzer(exp_id, analyzer, savefile_prefix=""): SetupParser.default_block = 'HPC' SetupParser.init() am = AnalyzeManager() am.add_analyzer(analyzer()) exp = retrieve_experiment(exp_id) am.add_experiment(exp) am.analyze() df_return = am.analyzers[0].results df_return.to_csv("{}_{}.csv".format(savefile_prefix, exp_id), index=False) return df_return
def plot_inset_diagnostics(experiment_list, channels=default_channels, working_dir=".", filename="output/InsetChart.json", **kwargs): from simtools.Analysis.AnalyzeManager import AnalyzeManager am = AnalyzeManager() am.add_analyzer( inset_channel_plotter(channels, working_dir=working_dir, filename=filename, **kwargs)) for expt in experiment_list: am.add_experiment(expt) am.analyze()
def run_analyzers(exp_id, analyzers, savefile_prefix=""): def _remove_duplicate_columns(df): columns_to_keep = [] for c in df.columns: if "_duplicated" not in c: columns_to_keep.append(c) return df[columns_to_keep] SetupParser.default_block = 'HPC' SetupParser.init() am = AnalyzeManager() for a in analyzers: am.add_analyzer(a()) exp = retrieve_experiment(exp_id) am.add_experiment(exp) am.analyze() if len(analyzers) == 1: df_return = am.analyzers[0].results elif len(analyzers) > 1: df_list = [x.results for x in am.analyzers] df_return = pd.merge(df_list[0], df_list[1], on="sim_id", suffixes=["", "_duplicated"]) # Drop duplicated columns # for c in df_result.columns: # if "_duplicated" in c: # df_result.drop(c, inplace=True) df_return = _remove_duplicate_columns(df_return) else: raise ValueError df_return.to_csv("{}_{}.csv".format(savefile_prefix, exp_id), index=False) return df_return
def run_experiment(configbuilder, experiment_name, experiment_builder, analyzers): run_sim_args = { 'config_builder': configbuilder, 'exp_name': experiment_name, 'exp_builder': experiment_builder } if not SetupParser.initialized: SetupParser.init('HPC') exp_manager = ExperimentManagerFactory.init() exp_manager.run_simulations(**run_sim_args) exp_manager.wait_for_finished(verbose=True) assert (exp_manager.succeeded()) am = AnalyzeManager(exp_manager.experiment) for a in analyzers: am.add_analyzer(a) am.analyze()
# Write special serialized_files_sim_map for runs that need it for c in range(56): catch = catch_list[c] c_folder = "C:/Users/jsuresh/Dropbox (IDM)/Malaria Team Folder/projects/zambia_gridded_sims/kariba_gridded_sims/calibs/{}".format( catch) sim_map_filename = os.path.join(c_folder, "serialized_files_sim_map.csv") # See if you can find an experiment named CATCH_project_climatefix try: name_try = "{}_project_climatefix".format(catch) proj_exp = DataStore.get_most_recent_experiment( id_or_name=name_try) # If you can find the experiment, find the corresponding parent simulation and output its sim map if proj_exp: name_try = "{}_serialize".format(catch) orig_exp = DataStore.get_most_recent_experiment( id_or_name=name_try) am = AnalyzeManager() am.add_experiment(orig_exp) am.add_analyzer( SimulationDirectoryMapAnalyzer(save_file=sim_map_filename)) am.analyze() print("Wrote serialized_files_sim_map for {}".format(catch)) except: pass
from simtools.Analysis.AnalyzeManager import AnalyzeManager from simtools.Analysis.BaseAnalyzers import DownloadAnalyzer if __name__ == "__main__": analyzer = DownloadAnalyzer(filenames=[ 'campaign_Swaziland_v05Sep2018_FINAL_reftracktopup_2011_v2.json', 'config.json', 'Swaziland_Demographics_With_Properties.json', 'Risk_Assortivity_Overlay.json', 'PFA_Overlay.json', 'Accessibility_and_Risk_IP_Overlay.json' ]) am = AnalyzeManager(["6f6ff06d-fed6-e811-a2bd-c4346bcb1555"], analyzers=analyzer) am.analyze()
# This block will be used unless overridden on the command-line SetupParser.default_block = 'HPC' cb = DTKConfigBuilder.from_defaults('VECTOR_SIM') configure_site(cb, 'Namawala') cb.set_param('Simulation_Duration',365) analyzers = (TimeseriesAnalyzer(), VectorSpeciesAnalyzer()) builder = GenericSweepBuilder.from_dict({'Run_Number': range(5)}) run_sim_args = { 'exp_name': 'testrunandanalyze', 'exp_builder': builder, 'config_builder':cb } if __name__ == "__main__": SetupParser.init(selected_block=SetupParser.default_block) exp_manager = ExperimentManagerFactory.from_cb(config_builder=cb) exp_manager.run_simulations(**run_sim_args) exp_manager.wait_for_finished(verbose=True) am = AnalyzeManager(exp_manager.experiment) for a in analyzers: am.add_analyzer(a) am.analyze()
if len(selected) == 0: print("No data have been returned... Exiting...") return d = pd.concat(selected).reset_index(drop=True) d['year'] = d['time'].apply(lambda x : int(x/365)) d = d[d['time'] >= 100] summed = d.groupby(self.sweep_variables + ['Run_Number'])[self.channel].agg(np.sum).reset_index() df = summed.groupby(self.sweep_variables)[self.channel].agg(np.mean).reset_index() print(df) sns.set_style('white', {'axes.linewidth' : 0.5}) fig = plt.figure() ax = fig.gca() sns.heatmap(df.pivot(index=self.sweep_variables[0], columns=self.sweep_variables[1], values=self.channel), ax=ax) ax.set_ylabel(self.sweep_variables[0]) ax.set_xlabel(self.sweep_variables[1]) plt.show() plt.close('all') if __name__ == '__main__' : expid = '63903283-1f7b-e811-a2c0-c4346bcb7275' am = AnalyzeManager(expid, analyzers=Sweep2DAnalyzer(['coverage', 'initial_killing'])) am.analyze()
cb = CMSConfigBuilder.from_files(model_file='inputs/models/simplemodel.emodl', config_file='inputs/models/simplemodel.cfg') # If the base collection containing CMS exists, use it # If not, use the local if SetupParser.default_block == "HPC": try: cb.set_collection_id('CMS 0.82 Pre-release') except SimulationAssets.InvalidCollection: cb.set_experiment_executable('inputs/compartments/compartments.exe') cb.set_dll_root('inputs/compartments') else: cb.set_experiment_executable('inputs/compartments/compartments.exe') cb.set_dll_root('inputs/compartments') run_sim_args = {"config_builder": cb, "exp_name": "First CMS run"} if __name__ == "__main__": SetupParser.init() em = ExperimentManagerFactory.from_cb(run_sim_args["config_builder"]) em.run_simulations(exp_name=run_sim_args["exp_name"]) # Wait for the simulation to complete em.wait_for_finished(verbose=True) # Analyze am = AnalyzeManager(exp_list='latest') am.add_analyzer(SimpleCMSAnalyzer()) am.analyze()
from COMPS.Data import QueryCriteria sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from PythonHelperFunctions.utils import load_output_path from SCOutputAnalyzer import SCOutputAnalyzer SetupParser.default_block = "HPC" if __name__ == "__main__": SetupParser.init() exp_list = pd.read_csv(os.path.join(load_output_path(), 'Experiment_tracking.csv'), index_col="Index") for index, row in exp_list.iterrows(): exp = row['Experiment ID'] print('Checking experiment ' + exp) tmp = get_experiment_by_id( exp, query_criteria=QueryCriteria().select_children(["tags"])) foldername = row['Description'] outDir = os.path.join(load_output_path(), foldername, 'simOutputs') if not os.path.exists(outDir): os.mkdir(outDir) am = AnalyzeManager(exp, analyzers=SCOutputAnalyzer(filenames=[ 'output/InsetChart.json', 'output/PropertyReport.json' ], output_path=outDir)) am.analyze()
] for smc_coverage in coverages for seed in range(num_seeds) ] builder = ModBuilder.from_list(SMC) run_sim_args = {'config_builder': cb, 'exp_name': expname, 'exp_builder': builder} if __name__ == "__main__": SetupParser.default_block = 'HPC' SetupParser.init() exp_manager = ExperimentManagerFactory.init() exp_manager.run_simulations(**run_sim_args) # Wait for the simulations to be done exp_manager.wait_for_finished(verbose=True) assert (exp_manager.succeeded()) analyzer = PrevalenceAnalyzer(expt_name=expname, sweep_variables=["Run_Number", "Coverage" ]) am = AnalyzeManager(exp_manager.experiment, analyzers=analyzer) am.analyze()
adf = pd.concat(selected).reset_index(drop=True) adf.sort_values(by=self.sweep_variables + ['year'], inplace=True) adf.to_csv(os.path.join(self.working_dir, '%s.csv' % self.expt_name), index=False) if __name__ == '__main__': out_dir = os.path.join(wdir, 'data') experiments = {"End60": "229a4440-8d1f-e911-a2be-c4346bcb1554"} for expt_name, exp_id in experiments.items(): am = AnalyzeManager(exp_list=exp_id, analyzers=[ IvermectinAnalyzer( working_dir=out_dir, expt_name=expt_name, sweep_variables=[ "Run_Number", "x_Temporary_Larval_Habitat", 'dirus_Anthropophily', 'target', 'coverage', "intervention" ]) ], force_analyze=True) print(am.experiments) am.analyze()
plt.ylabel("Fraction of sims eliminating") plt.title(vc_packs[i]) plt.legend() plt.show() if __name__=="__main__": if True: # analyzer_list = [ExtractInfectionResult()] analyzer_list = [ExtractInfectionResult(), SimulationDirectoryMapAnalyzer(save_file="sim_map.csv")] exp_list = ["520818ca-ae3b-e911-a2c5-c4346bcb7273"] am = AnalyzeManager(force_analyze=True) for exp_name in exp_list: am.add_experiment(retrieve_experiment(exp_name)) for a in analyzer_list: am.add_analyzer(a) am.analyze() if True: convert_infection_csv_to_elim() if False: plot_elim_curves(y=2)
df.to_csv(os.path.join(self.working_dir, '%s.csv' % self.dir_name), index=False) if __name__ == "__main__": SetupParser.init("HPC") out_dir = os.path.join('E:/', 'Dropbox (IDM)', 'Malaria Team Folder', 'projects', 'map_intervention_impact', 'lookup_tables') sites = pd.read_csv("site_details.csv") experiments = { "corr_itn_irs" :"e7fd04a2-a8d8-e811-a2bd-c4346bcb1555" } for dirname, exp_id in experiments.items(): am = AnalyzeManager(exp_list=exp_id, analyzers=[BurdenAnalyzer(working_dir=out_dir, dir_name=dirname, report_names = sites["name"].tolist(), sweep_variables=["Run_Number", "x_Temporary_Larval_Habitat", "IRS_Coverage", "ITN_Coverage", "ITN_IRS_Coverage", ])], force_analyze=True) print(am.experiments) am.analyze()
if sdf[self.channel][j] == sdf[self.channel][j+365]: eliminated[str(c) + ' / ' + str(r)] += 1 # infections[str(c) + ' / ' + str(r)] = sdf[self.channel] for num in range (1460): infect[num] += sdf[self.channel][j-1000+num] j += 4*365 for num in range(1460): infect[num] ax.plot(range(1460), infect, linewidth = 1, label='cov %.2f' % (c)) ax.legend() ax.set_xlabel('Time') ax.set_ylabel('Infected') #plt.savefig(os.path.join(plotdir, '123myplot123.pdf'), format='PDF') plt.title('ATSB Infection Reduction (CDC)') plt.show() plt.close('all') if __name__ == '__main__' : expid = '905a91f4-2e9b-e811-a2c0-c4346bcb7275' am = AnalyzeManager(expid, analyzers=VectorCountAnalyzer()) am.analyze()
value1 = tags[param1] value2 = tags[param2] sweep_set = '%s-%s--%s-%s' % (param1, value1, param2, value2) return sweep_name, sweep_set def get_sim_folder(self, simulation): sweep_name, sweep_set = self.determine_sweep_set(simulation.tags) return os.path.join(self.output_path, sweep_name, sweep_set, simulation.id) def select_simulation_data(self, data, simulation): # Create a folder for the current simulation sim_folder = self.get_sim_folder(simulation) os.makedirs(sim_folder, exist_ok=True) # Create the requested files for filename in self.filenames: file_path = os.path.join(sim_folder, os.path.basename(filename)) with open(file_path, 'wb') as outfile: outfile.write(data[filename]) if __name__ == "__main__": analyzer = DownloadAnalyzerWithTags( filenames=['output\\ReportHIVByAgeAndGender.csv']) experiments = retrieve_item( itemid='5a088005-19f8-e911-a2c3-c4346bcb1551') # suite_id passed here experiments = [e.id for e in experiments] am = AnalyzeManager(exp_list=experiments, analyzers=analyzer) am.analyze()
if __name__=="__main__": # Run endpoint analyzer on original run, and output as endpoint_original.csv for c in catch_nums: catch = catch_list[c] catch_folder = os.path.join(cf_folder, catch) if run_endpoint_original: sim_map_filename = os.path.join(catch_folder, "sim_map_original.csv") endpoint_filename = os.path.join(catch_folder, "endpoint_original.csv") analyzer_list = [] analyzer_list += [SaveEndpoint(save_file=endpoint_filename, year_to_use=6), SimulationDirectoryMapAnalyzer(save_file=sim_map_filename)] am = AnalyzeManager() exp = retrieve_experiment(orig_exp["exp_id"]) am.add_experiment(exp) for a in analyzer_list: am.add_analyzer(a) am.analyze() if run_endpoint_cf: sim_map_filename = os.path.join(catch_folder, "sim_map_cf.csv") endpoint_filename = os.path.join(catch_folder, "endpoint_cf.csv") analyzer_list = [] analyzer_list += [SaveEndpoint(save_file=endpoint_filename, year_to_use=6), SimulationDirectoryMapAnalyzer(save_file=sim_map_filename)]
from simtools.Analysis.AnalyzeManager import AnalyzeManager from simtools.Analysis.BaseAnalyzers import BaseAnalyzer class PopulationAnalyzer(BaseAnalyzer): def __init__(self): super().__init__(filenames=['output\\InsetChart.json']) def select_simulation_data(self, data, simulation): # Apply is called for every simulations included into the experiment # We are simply storing the population data in the pop_data dictionary return data[self.filenames[0]]["Channels"]["Statistical Population"]["Data"] def finalize(self, all_data): import matplotlib.pyplot as plt for pop in list(all_data.values()): plt.plot(pop) plt.legend([s.id for s in all_data.keys()]) plt.show() # This code will analyze the latest experiment ran with the PopulationAnalyzer if __name__ == "__main__": am = AnalyzeManager('latest', analyzers=PopulationAnalyzer()) am.analyze()
x = np.linspace(0, 0.25, 100) y = np.linspace( min(sdf2['pre-prevalence']), max(sdf2['pre-prevalence']), 100 ) #np.arange(min(sdf['Log_x_Temp']), max(sdf['Log_x_Temp'])+(sdf['Log_x_Temp'][3]-sdf['Log_x_Temp'][2]), (sdf['Log_x_Temp'][3]-sdf['Log_x_Temp'][2])) xx, yy = np.meshgrid(x, y) inter = interpolate.Rbf(sdf['killing'], sdf2['pre-prevalence'], sdf[self.channel]) zz = inter(xx, yy) cmap = 'rainbow_r' #plt.imshow(zz, cmap = plt.get_cmap(cmap, 10)) c = plt.contour(xx, yy, zz, cmap=plt.get_cmap((cmap)), vmin=0, vmax=1) plt.clabel(c, inline=1, fontsize=8, fmt='%.2f') palette = sns.color_palette(cmap, 100) ax.scatter( sdf['killing'], sdf2['pre-prevalence'], 20, color=[palette[int(x * 100)] for x in sdf[self.channel].values], alpha=0.5) #plt.savefig(os.path.join(plotdir, '123myplot123.pdf'), format='PDF') plt.title('ATSB Infection Reduction Heatmap') plt.show() plt.close('all') if __name__ == '__main__': expid = '4ee73ebf-d59c-e811-a2c0-c4346bcb7275' am = AnalyzeManager(expid, analyzers=HeatmapAnalyzer()) am.analyze()
class SCOutputAnalyzer(BaseAnalyzer): def __init__(self, filenames=None, output_path=None): super().__init__(filenames=filenames) self.output_path = output_path or "output" def select_simulation_data(self, data, simulation): # Apply is called for every simulations included into the experiment # We are simply storing the population data in the pop_data dictionary selected_data = {} selected_data['insetChart'] = data[self.filenames[0]] selected_data['sim_id'] = simulation.id if simulation.tags.get('__sample_index__') is not None: selected_data['sample'] = simulation.tags.get('__sample_index__') else: selected_data['sample'] = simulation.id selected_data['tags'] = simulation.tags selected_data['propertyReport'] = data[self.filenames[1]] return selected_data def finalize(self, all_data): with open(os.path.join(self.output_path, 'results.pkl'), 'wb') as pklfile: pickle.dump(all_data, pklfile) # This code will analyze the latest experiment ran with the PopulationAnalyzer if __name__ == "__main__": am = AnalyzeManager('latest', analyzers=SCOutputAnalyzer()) am.analyze()
# "IVM_final": "dd4ce507-c72f-e911-a2c5-c4346bcb7273", # "No_interventions": "e9e19499-c52f-e911-a2c5-c4346bcb7273" # "eSMC_IVM_everyone": "9609582b-7b3f-e911-a2c5-c4346bcb7273", # "eSMC10_IVM": "a47b2382-7b3f-e911-a2c5-c4346bcb7273", # "Ivermectin_excludingchildbearing": "1afccb61-8846-e911-a2c0-c4346bcb1554", 'SMC_10': '154263e1-c031-e911-a2c5-c4346bcb7273' } for expt_name, exp_id in experiments.items(): if 'Reference' in expt_name: am = AnalyzeManager( exp_list=exp_id, analyzers=[ SummaryAnalyzer(expt_name=expt_name, report_names=['Daily_Report'], sweep_variables=["Run_Number"]), InsetAnalyzer(expt_name=expt_name, report_names=['InsetChart'], sweep_variables=["Run_Number"]) ], force_analyze=False) else: am = AnalyzeManager(exp_list=exp_id, analyzers=[ SummaryAnalyzer( expt_name=expt_name, report_names=['Daily_Report'], sweep_variables=[ "Run_Number", "Coverage", "Intervention_type"
'Malaria Team Folder', 'projects', 'map_intervention_impact', 'lookup_tables') run_type = "exp" if run_type == "exp": experiments = ["6e91248b-dbbd-e811-a2bd-c4346bcb1555"] for exp_id in experiments: am = AnalyzeManager(exp_list=exp_id, analyzers=[ PfPRAnalyzer( working_dir=out_dir, sweep_variables=[ "Site_Name", "Run_Number", "x_Temporary_Larval_Habitat", "ACT_Coverage", "IRS_Coverage", "ITN_Coverage" ]) ], force_analyze=True) print(am.experiments) am.analyze() elif run_type == "suite": exps = exps_for_suite_id("537b9041-0fa3-e811-a2c0-c4346bcb7275") print(exps) am = AnalyzeManager(exp_list=exps, analyzers=[
add_SerializationTimesteps(config_builder=cb_serializing, timesteps=[timestep_to_reload], end_at_final=True) s_pop_filename = "state-{0:05d}.dtk".format(timestep_to_reload) # Run the simulation exp_manager.run_simulations(config_builder=cb_serializing, exp_name="Sample serialization test") exp_manager.wait_for_finished(verbose=True) # Download the state file simulation = exp_manager.experiment.simulations[0] da = DownloadAnalyzer(filenames=["output\\{}".format(s_pop_filename)], output_path="temp") am = AnalyzeManager(sim_list=[simulation], analyzers=[da]) am.analyze() # Add the state file cb_reload = DTKConfigBuilder.from_defaults('VECTOR_SIM') configure_site(cb_reload, 'Namawala') cb_reload.set_param("Simulation_Duration", 365) cb_reload.experiment_files.add_file( os.path.join("temp", simulation.id, s_pop_filename)) load_Serialized_Population(cb_reload, 'Assets', [s_pop_filename]) # Run ! exp_manager.run_simulations(config_builder=cb_reload) # Cleanup temp directory
color=palette[c], label=coverage) if i == num_interventions - 1: ax.set_xlabel('%s no intervention' % self.data_channel) if s == 0: ax.set_ylabel('%s with intervention' % self.data_channel) ax.set_title('%s %s' % (site, intervention)) axes[-1].legend(title='coverage') plt.show() if __name__ == "__main__": from simtools.Analysis.AnalyzeManager import AnalyzeManager from simtools.SetupParser import SetupParser SetupParser.default_block = 'HPC' SetupParser.init() sites = pd.read_csv("site_details.csv") analyzer = PfPRAnalyzer(expt_name='global_int_ex_test', report_names=sites["name"].tolist(), sweep_variables=[ "Run_Number", "x_Temporary_Larval_Habitat", "intervention" ]) am = AnalyzeManager('d9bf3918-d8fc-e811-a2bd-c4346bcb1555', analyzers=analyzer) am.analyze()
index=False) if __name__ == "__main__": SetupParser.default_block = 'LOCAL' SetupParser.init() out_dir = os.path.join(projectdir, 'sim_data') experiments = { "SMC_ivermection_scenarios_uncorrelated": "01768676-af24-e911-a2be-c4346bcb1554" } for expt_name, exp_id in experiments.items(): am = AnalyzeManager(exp_list=exp_id, analyzers=[ InsetAnalyzer(working_dir=out_dir, expt_name=expt_name, report_names=['InsetChart'], sweep_variables=[ "Run_Number", "Coverage", "Intervention_type" ]) ], force_analyze=False) print(am.experiments) am.analyze()
df.to_csv('%s.csv' % self.output_fname) fig = plt.figure() ax = fig.gca() max_EIR = np.max(df['aEIR']) ax.scatter(np.log10(df['aEIR']), df['PfPR_2to10']) ax.set_xlabel('aEIR') ax.set_ylabel('PfPR [2 to 10]') ax.set_ylim(0, 1) plt.title('PfPR [2 to 10] v. aEIR') plt.savefig('%s.png' % self.output_fname) plt.savefig('%s.pdf' % self.output_fname, format='PDF') plt.close('all') if __name__ == '__main__': expids = ['4f157763-d898-ea11-a2c5-c4346bcb1550'] expnames = ['EIR_sweep'] for expname, expid in zip(expnames, expids): os.makedirs(os.path.join(wdir, expid), exist_ok=True) output_fname = os.path.join(wdir, expid, expname) am = AnalyzeManager(expid, analyzers=EIR_PfPR_Analyzer(output_fname)) am.analyze()
experiments_ids.append(experiment_manager.experiment.exp_id) # Dump the experiment ids for resume with open('ids.json', 'w') as out: json.dump(experiments_ids, out) # While the experiments are running, we are analyzing every 30 seconds while True: print("Analyzing !") # Determine if we are done at the beginning of the loop # We will still analyze everything even if we are done finished = all([em.finished() for em in experiments]) # Create a new AnalyzeManager and add experiment and analyzer am = AnalyzeManager(verbose=False) for em in experiments: am.add_experiment(em.experiment) analyzer = DownloadAnalyzerTPI( filenames=['output\\ReportHIVByAgeAndGender.csv'], TPI_tag="TPI", ignore_TPI=False, REP_tag="TPI", ignore_REP=True, output_path=output_directory) am.add_analyzer(analyzer) # Make sure we refresh our set of experiments
if "c" in locals(): plt.plot(data, label=label, c=c) else: plt.plot(data, label=label) plt.xlabel("Simulation Time") plt.ylabel(self.channel) plt.legend() plt.show() if __name__ == "__main__": from simtools.Analysis.AnalyzeManager import AnalyzeManager am = AnalyzeManager() # am.add_analyzer(basic_inset_channel_plotter("True Prevalence")) am.add_analyzer( inset_channel_plotter("True Prevalence", color_by_expt=True, label_by_expt=True, label_dict={ "7e3073b4-d9f1-e811-a2bd-c4346bcb1555": "full campaign", "a2e981fe-d9f1-e811-a2bd-c4346bcb1555": "no 2011 bednets" }, ref_date="2001-01-01")) am.add_experiment("7e3073b4-d9f1-e811-a2bd-c4346bcb1555") am.add_experiment("a2e981fe-d9f1-e811-a2bd-c4346bcb1555")
from simtools.Analysis.AnalyzeManager import AnalyzeManager from simtools.Analysis.BaseAnalyzers import DownloadAnalyzer if __name__ == "__main__": analyzer = DownloadAnalyzer( filenames=['output\\InsetChart.json', 'config.json']) am = AnalyzeManager('latest', analyzers=analyzer) am.analyze()