def __init__(self, simulation_directory, iterate_number):
     self.number = iterate_number
     self.min_max_concns = {}
     agent_path = os.path.join(simulation_directory.agent_State,
                                 'agent_State(%d).xml'%(iterate_number))
     agent_path = toolbox_basic.check_path(agent_path)
     self.agent_output = toolbox_results.AgentOutput(path=agent_path)
     self.time = self.agent_output.time
     env_path = os.path.join(simulation_directory.env_State,
                                     'env_State(%d).xml'%(iterate_number))
     env_path = toolbox_basic.check_path(env_path)
     self.env_output = toolbox_results.EnvOutput(path=env_path)
 def __init__(self, simulation_directory, iterate_number):
     self.number = iterate_number
     self.min_max_concns = {}
     agent_path = os.path.join(simulation_directory.agent_State,
                               'agent_State(%d).xml' % (iterate_number))
     agent_path = toolbox_basic.check_path(agent_path)
     self.agent_output = toolbox_results.AgentOutput(path=agent_path)
     self.time = self.agent_output.time
     env_path = os.path.join(simulation_directory.env_State,
                             'env_State(%d).xml' % (iterate_number))
     env_path = toolbox_basic.check_path(env_path)
     self.env_output = toolbox_results.EnvOutput(path=env_path)
Пример #3
0
def setup_heterogeneous_progenitors(sim_dir_path):
    sim_dir_path = basic.check_path(sim_dir_path)
    last_path = os.path.join(sim_dir_path, 'lastIter', 'agent_State(last).xml')
    output, species = results.get_single_species(last_path)
    timestep = float(output.time) / float(output.iterate)
    agent_State_dir = basic.unzip_files(
        os.path.join(sim_dir_path, 'agent_State.zip'))
    save_cells = []
    for cell in species.members:
        genealogy = int(cell.vars['genealogy'])
        if genealogy == 1:
            iter = int(float(cell.vars['birthday']) / timestep)
            iter_path = os.path.join(agent_State_dir,
                                     'agent_State(' + str(iter) + ').xml')
            iter_output, iter_species = results.get_single_species(iter_path)
            requirements = {'family': cell.vars['family'], 'genealogy': 0}
            oldie = species.find_cells(requirements)[0]
            oldie.vars['generation'] = 0
            save_cells.append(oldie)
            requirements['genealogy'] = 1
            newbie = species.find_cells(requirements)[0]
            newbie.vars['family'] = int(newbie.vars['family']) + 15
            newbie.vars['generation'] = 0
            newbie.vars['genealogy'] = 0
            newbie.vars['birthday'] = 0.0
            save_cells.append(newbie)
    species.members = save_cells
    species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'agentS.xml')
    output.write(output_path=save_path)
Пример #4
0
 def __init__(self, root_dir, find_protocol=True):
     self.root_dir = toolbox_basic.check_path(root_dir)
     if not find_protocol: return
     # Set up the space from the protocol file.
     protocol_path = toolbox_basic.find_protocol_file_path(self.root_dir)
     self.protocol_tree = toolbox_basic.get_xml_tree(protocol_path)
     space_params = self.protocol_tree.findall('./space/param')
     for param in space_params:
         name, text = param.attrib['name'], param.text
         if name == 'wrapping': self.wrapping = (text == 'true')
         elif name == 'length': self.side_length = int(float(text))
         elif name == 'nDims':  self.is_3d = (int(float(text)) == 3)
     marks = self.protocol_tree.findall('./mark')
     for mark in marks:
         for param in mark:
             if param.attrib['name'] == 'value':
                 value = int(param.text)
             if param.attrib['name'] == 'number':
                 number = int(param.text)
         if value == 2:
             self.consumers = number
         else:
             self.producers = number
     rs = self.protocol_tree.find("./process/param[@name='randomSeed']")
     self.random_seed = int(rs.text)
def build_life_history(sim_dir_path, attribute, cell_id=(1,0),
                        biomass_names=['activeBiomass', 'inactiveBiomass']):
    sim_dir_path = basic.check_path(sim_dir_path)
    attributes = {'name':attribute, 'header':'time,value'}
    results_file_path = os.path.join(sim_dir_path, 'results.xml')
    results_output = results.ResultsOutput(path=results_file_path)
    result_set = results.ResultSet(results_output, attributes)
    if len(result_set.members) > 0:
        return result_set.members
    requirements = {'family':str(cell_id[0]), 'genealogy':str(cell_id[1])}
    file_dir = os.path.join(sim_dir_path, 'agent_State')
    basic.unzip_files(file_dir+'.zip')
    file_list = basic.file_list(file_dir)
    for filename in file_list:
        output = results.AgentOutput(path=filename)
        species = results.SpeciesOutput(output)
        cells = species.find_cells(requirements)
        cell = cells[0]
        single_result = results.SingleResult()
        single_result.vars['time'] = output.time
        if attribute == 'specific growth rate':
            single_result.vars['value'] = \
                        cell.get_specific_growth_rate(biomass_names)
        else:
            single_result.vars['value'] = cell.vars[attribute]
        result_set.members.append(single_result)
    result_set.update_results_output()
    results_output.write(results_file_path)
    basic.rm_dir(file_dir)
    return result_set
def get_all_cells_location(sim_dir_path, iternum=480):
    sim_dir_path = basic.check_path(sim_dir_path)
    attributes = {'name':'locations', 'header':'X,Y'}
    results_file_path = os.path.join(sim_dir_path, 'cell_locations.xml')
    results_output = results.ResultsOutput(path=results_file_path)
    result_set = results.ResultSet(results_output, attributes)
    #requirements = {'family':'', 'genealogy':''}
    file_dir = os.path.join(sim_dir_path, 'agent_State')
    basic.unzip_files(file_dir+'.zip')
    file_list = basic.file_list(file_dir)
    for filename in file_list:
        output = results.AgentOutput(path=filename)
        if output.iterate == iternum:
            output = results.AgentOutput(path=filename)
            cells = output.get_all_cells()
            #species = results.SpeciesOutput(output)
            #cells = species.find_cells(requirements)
            for cell in cells:
                single_result = results.SingleResult()
                single_result.vars['X'] = cell.vars['locationX']
                single_result.vars['Y'] = cell.vars['locationY']
                result_set.members.append(single_result)
    result_set.update_results_output()
    results_output.write(results_file_path)
    basic.rm_dir(file_dir)
    return result_set


#sim_dir_path = sys.argv[1]
#get_grid_size(sim_dir_path)
#get_all_cells_location(sim_dir_path)
Пример #7
0
 def __init__(self, agent_output, save_path):
     self.agent_output = agent_output
     self.save_path = os.path.join( \
                     toolbox_basic.check_path(os.path.dirname(save_path)),
                     os.path.basename(save_path))
     nI, nJ = agent_output.grid_nI, agent_output.grid_nJ
     nK, res = agent_output.grid_nK, agent_output.grid_res
     max_dimension = max(nI, nJ, nK)
     x_scale = nI / max_dimension
     y_scale = nJ / max_dimension
     self.scaling = res * max_dimension
     ### Set the header
     self.script = '#declare white = color rgb < 1.0, 1.0, 1.0 >;\n\n'
     self.script += 'background { white }\n'
     # The camera
     self.script += 'camera {\n'
     self.script += '\t location < 0.5 %f 1 >\n'%(y_scale/2)
     self.script += '\t look_at < 0.5, %f -1 >\n'%(y_scale/2)
     self.script += '\t up < 0.0, %f, 0.0 >\n'%(1.2*y_scale)
     self.script += '\t right < %f, 0.0, 0.0 >\n}\n\n'%(1.2*x_scale)
     # The lights
     for i in [0, 1]:
         self.script += 'light_source {\n\t < %d, 1, 1 >\n'%(i)
         self.script += '\t white\n\t shadowless}\n\n'
     # The substratum
     self.script += 'box {\n\t < 0.0, 0.0, 0.0 >\n'
     self.script += '\t< 1.0, -0.01, -0.001 >\n'
     self.script += '\t pigment { color rgb < 0.25, 0.25, 0.25 > }\n}\n\n'
Пример #8
0
 def use_image(self, axis, image_path):
     image_path = toolbox_basic.check_path(image_path)
     datafile = cbook.get_sample_data(image_path)
     image = Image.open(datafile)
     axis.set_ylim(0,image.size[0])
     axis.set_ylim(image.size[1],0)
     return imshow(image)
Пример #9
0
 def use_image(self, axis, image_path):
     image_path = toolbox_basic.check_path(image_path)
     datafile = cbook.get_sample_data(image_path)
     image = Image.open(datafile)
     axis.set_ylim(0, image.size[0])
     axis.set_ylim(image.size[1], 0)
     return imshow(image)
Пример #10
0
 def __init__(self, agent_output, save_path):
     self.agent_output = agent_output
     self.save_path = os.path.join( \
                     toolbox_basic.check_path(os.path.dirname(save_path)),
                     os.path.basename(save_path))
     nI, nJ = agent_output.grid_nI, agent_output.grid_nJ
     nK, res = agent_output.grid_nK, agent_output.grid_res
     max_dimension = max(nI, nJ, nK)
     x_scale = nI / max_dimension
     y_scale = nJ / max_dimension
     self.scaling = res * max_dimension
     ### Set the header
     self.script = '#declare white = color rgb < 1.0, 1.0, 1.0 >;\n\n'
     self.script += 'background { white }\n'
     # The camera
     self.script += 'camera {\n'
     self.script += '\t location < 0.5 %f 1 >\n' % (y_scale / 2)
     self.script += '\t look_at < 0.5, %f -1 >\n' % (y_scale / 2)
     self.script += '\t up < 0.0, %f, 0.0 >\n' % (1.2 * y_scale)
     self.script += '\t right < %f, 0.0, 0.0 >\n}\n\n' % (1.2 * x_scale)
     # The lights
     for i in [0, 1]:
         self.script += 'light_source {\n\t < %d, 1, 1 >\n' % (i)
         self.script += '\t white\n\t shadowless}\n\n'
     # The substratum
     self.script += 'box {\n\t < 0.0, 0.0, 0.0 >\n'
     self.script += '\t< 1.0, -0.01, -0.001 >\n'
     self.script += '\t pigment { color rgb < 0.25, 0.25, 0.25 > }\n}\n\n'
Пример #11
0
def setup_heterogeneous_progenitors(sim_dir_path):
    sim_dir_path = basic.check_path(sim_dir_path)
    last_path = os.path.join(sim_dir_path, 'lastIter', 'agent_State(last).xml')
    output, species = results.get_single_species(last_path)
    timestep = float(output.time) / float(output.iterate)
    agent_State_dir = basic.unzip_files(os.path.join(sim_dir_path,
                                                            'agent_State.zip'))
    save_cells = []
    for cell in species.members:
        genealogy = int(cell.vars['genealogy'])
        if genealogy == 1:
            iter = int( float(cell.vars['birthday']) / timestep )
            iter_path = os.path.join(agent_State_dir, 
                                              'agent_State('+str(iter)+').xml')
            iter_output, iter_species = results.get_single_species(iter_path)
            requirements = {'family': cell.vars['family'], 'genealogy':0}
            oldie = species.find_cells(requirements)[0]
            oldie.vars['generation'] = 0
            save_cells.append(oldie)
            requirements['genealogy'] = 1
            newbie = species.find_cells(requirements)[0]
            newbie.vars['family'] = int(newbie.vars['family']) + 15
            newbie.vars['generation'] = 0
            newbie.vars['genealogy'] = 0
            newbie.vars['birthday'] = 0.0
            save_cells.append(newbie)
    species.members = save_cells
    species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'agentS.xml')
    output.write(output_path=save_path)
def build_population_structure(sim_dir_path, attribute, 
                        bins=numpy.linspace(0, 0.6, 121), starting_time=2400,
                        biomass_names=['activeBiomassGrowth', 'activeBiomassRepair', 'inactiveBiomassGrowth', 'activeBiomassRepair']):
    attributes = {'name':attribute+' population structure',
                    'starting_time':str(starting_time),
                    'header':'bin,frequency'}
    sim_dir_path = basic.check_path(sim_dir_path)
    results_file_path = os.path.join(sim_dir_path, 'results.xml')
    results_output = results.ResultsOutput(path=results_file_path)
    result_set = results.ResultSet(results_output, attributes)
    if len(result_set.members) > 0:
        return result_set.members
    attr_values = []
    total_pop = 0.0
    file_dir = os.path.join(sim_dir_path, 'agent_State')
    basic.unzip_files(file_dir+'.zip')
    file_list = basic.file_list(file_dir)
    for filename in file_list:
        output = results.AgentOutput(path=filename)
        if output.time >= starting_time:
            species = results.SpeciesOutput(output)
            species.set_biomass_names(biomass_names)
            attr_values.extend(species.get_attribute_values(attribute))
            total_pop += species.population()
    hist, bin_edges = numpy.histogram(attr_values, bins)
    for i in range(len(hist)):
        single_result = results.SingleResult()
        single_result.vars['bin'] = str(bins[i+1])+'-'+str(bins[i])
        single_result.vars['frequency'] = str(float(hist[i])/total_pop)
        result_set.members.append(single_result)
    result_set.update_results_output()
    results_output.write(results_file_path)
    basic.rm_dir(file_dir)
    return result_set
Пример #13
0
def calc_mean_attribute(sim_dir_path, attribute, output_type, file_process,
                                                        starting_time=2400):
    attributes = {'name':attribute, 
                    'starting_time':str(starting_time),
                    'header':'mean,std'}
    sim_dir_path = basic.check_path(sim_dir_path)
    results_file_path = os.path.join(sim_dir_path, 'results.xml')
    results_output = results.ResultsOutput(path=results_file_path)
    result_set = results.ResultSet(results_output, attributes)
    if len(result_set.members) > 0:
        result = result_set.members[0]
        return float(result.vars['mean']), float(result.vars['std'])
    values = []
    file_dir = os.path.join(sim_dir_path, output_type)
    basic.unzip_files(file_dir+'.zip')
    file_list = basic.file_list(file_dir)
    for filename in file_list:
        args = [attribute, filename]
        val = file_process(*args)
        # If output.time < starting_time, None will be returned
        if not val == None:
            values.append(val)
    single_result = results.SingleResult()
    mean_value = numpy.mean(values)
    std_value = numpy.std(values)
    single_result.vars['mean'] = mean_value
    single_result.vars['std'] = std_value
    result_set.members.append(single_result)
    result_set.update_results_output()
    results_output.write(results_file_path)
    basic.rm_dir(file_dir)
    return mean_value, std_value
def read_color_dict(file_path):
    out = {}
    file_path = toolbox_basic.check_path(file_path)
    with open(file_path, 'Ur') as f:
        for line in f.readlines()[1:]:
            line = line.replace('\n', '')
            vals = line.split('\t\t')
            out[vals[1]] = vals[0]
    return out
 def __init__(self, path):
     self.path = toolbox_basic.check_path(path)
     self.iterate_numbers = []
     self.iterate_information = []
     self.min_max_concns = {}
     # agent_Sum
     try:
         self.agent_Sum = os.path.join(self.path, 'agent_Sum')
         if not os.path.isdir( self.agent_Sum ):
             toolbox_basic.unzip_files(self.agent_Sum + '.zip')
         self.agent_Sum = toolbox_basic.check_path(self.agent_Sum)
     except TypeError:
         print('Could not find agent_Sum info! '+self.path)
     # agent_State
     try:
         self.agent_State = os.path.join(self.path, 'agent_State')
         if not os.path.isdir( self.agent_State ):
             toolbox_basic.unzip_files(self.agent_State + '.zip')
         self.agent_State = toolbox_basic.check_path(self.agent_State)
     except TypeError:
         print('Could not find agent_State info! '+self.path)
     # env_Sum
     try:
         self.env_Sum = os.path.join(self.path, 'env_Sum')
         if not os.path.isdir( self.env_Sum ):
             toolbox_basic.unzip_files(self.env_Sum + '.zip')
         self.env_Sum = toolbox_basic.check_path(self.env_Sum)
     except TypeError:
         print('Could not find env_Sum info! '+self.path)
     # env_State
     try:
         self.env_State = os.path.join(self.path, 'env_State')
         if not os.path.isdir( self.env_State ):
             toolbox_basic.unzip_files(self.env_State + '.zip')
         self.env_State = toolbox_basic.check_path(self.env_State)
     except TypeError:
         print('Could not find env_State info! '+self.path)
     # Figures directory
     self.figures_dir = os.path.join(self.path, 'figures')
     if not os.path.isdir(self.figures_dir):
         toolbox_basic.make_dir(self.figures_dir)
     self.movies_dir = os.path.join(self.path, 'movies')
     if not os.path.isdir(self.movies_dir):
         toolbox_basic.make_dir(self.movies_dir)
Пример #16
0
def plot_lineages(axis, results_path, max_generation,
                                            line_width=1.0, error_bars=True):
    results_path = basic.check_path(results_path)
    results_output = results.AgentOutput(path=results_path)
    results_species = results.SpeciesOutput(results_output)
    if error_bars and results_species.attributes.count('std_growth_rate') == 0:
        print('Could not find data for error bars')
        error_bars = False
    for cell in results_species.members:
        generation = int(cell.vars['generation'])
        if generation <= max_generation-1:
            family = int(cell.vars['family'])
            genealogy = int(cell.vars['genealogy'])
            growth_rate = float(cell.vars['growth_rate'])
            if error_bars:
                eb_x = [generation+1]
                eb_y = [growth_rate]
                eb_e = [float(cell.vars['std_growth_rate'])]
            requirements = {'family':family, 'genealogy':genealogy,
                                            'generation':generation+1}
            temp = results_species.find_cells(requirements)
            if not temp == []:
                oldie = temp[0]
                oldie_grow = float(oldie.vars['growth_rate'])
                axis.plot([generation+1, generation+2],
                          [growth_rate, oldie_grow], 
                          'r', linewidth=line_width, 
                          solid_capstyle='round', 
                          zorder=5+numpy.random.randint(5))
                if error_bars:
                    eb_x.append(generation+2)
                    eb_y.append(oldie_grow)
                    eb_e.append(float(oldie.vars['std_growth_rate']))
            requirements['genealogy'] = genealogy + 2**generation
            temp = results_species.find_cells(requirements)
            if not temp == []:
                newbie = temp[0]
                newbie_grow = float(newbie.vars['growth_rate'])
                axis.plot([generation+1, generation+2],
                          [growth_rate, newbie_grow],
                          'b', linewidth=line_width,
                          solid_capstyle='round',
                          zorder=5+numpy.random.randint(5))
                if error_bars:
                    eb_x.append(generation+2)
                    eb_y.append(newbie_grow)
                    eb_e.append(float(newbie.vars['std_growth_rate']))
            if error_bars:
                axis.errorbar(eb_x, eb_y, yerr=eb_e, ecolor='grey', fmt=None, 
                                  elinewidth=line_width/2, capsize=1, zorder=1)
    axis.set_xlabel('Generations')
    axis.set_ylabel('Normalised growth rate')
    axis.set_xlim([1, max_generation+1])
Пример #17
0
def get_first_fifteen(sim_dir_path):
    sim_dir_path = basic.check_path(sim_dir_path)
    last_path = os.path.join(sim_dir_path, 'lastIter', 'agent_State(last).xml')
    output, species = results.get_single_species(last_path)
    species.members = species.members[:15]
    for i in range(15):
        cell = species.members[i]
        cell.vars['family'] = i + 1
        cell.vars['genealogy'] = 0
        cell.vars['generation'] = 0
        cell.vars['birthday'] = 0.0
    species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'agentS.xml')
    output.write(output_path=save_path)
Пример #18
0
def get_first_fifteen(sim_dir_path):
    sim_dir_path = basic.check_path(sim_dir_path)
    last_path = os.path.join(sim_dir_path, 'lastIter', 'agent_State(last).xml')
    output, species = results.get_single_species(last_path)
    species.members = species.members[:15]
    for i in range(15):
        cell = species.members[i]
        cell.vars['family'] = i + 1
        cell.vars['genealogy'] = 0
        cell.vars['generation'] = 0
        cell.vars['birthday'] = 0.0
    species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'agentS.xml')
    output.write(output_path=save_path)
Пример #19
0
def normalise_by_generation(sim_dir_path, max_generation):
    results_path = basic.check_path(os.path.join(sim_dir_path, 'lineage_results.xml'))
    results_output = results.AgentOutput(path=results_path)
    results_species = results.SpeciesOutput(results_output)
    for generation in range(max_generation+1):
        cohort = [c for c in 
                    results_species.members if int(c.vars['generation']) == generation]
        growth_rates = [float(c.vars['growth_rate']) for c in cohort]
        mean = numpy.mean(growth_rates)
        for cell in cohort:
            cell.vars['growth_rate'] = str(float(cell.vars['growth_rate']) / mean)
    results_species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'norm_gen_lineage_results.xml')
    results_output.write(output_path=save_path)
Пример #20
0
 def __init__(self, path):
     self.path = toolbox_basic.check_path(path)
     self.iterate_numbers = []
     self.iterate_information = []
     self.min_max_concns = {}
     # agent_Sum
     """
     try:
         self.agent_Sum = os.path.join(self.path, 'agent_Sum')
         if not os.path.isdir( self.agent_Sum ):
             toolbox_basic.unzip_files(self.agent_Sum + '.zip')
         self.agent_Sum = toolbox_basic.check_path(self.agent_Sum)
     except TypeError:
         print('Could not find agent_Sum info! '+self.path)
     """
     # agent_State
     try:
         self.agent_State = os.path.join(self.path, 'agent_State')
         if not os.path.isdir( self.agent_State ):
             toolbox_basic.unzip_files(self.agent_State + '.zip')
         self.agent_State = toolbox_basic.check_path(self.agent_State)
     except TypeError:
         print('Could not find agent_State info! '+self.path)
     """
Пример #21
0
 def __init__(self, path=None, root_name='idynomics'):
     if path == None or not os.path.isfile(path):
         self.path = path
         self.root = xmlTree.Element(root_name)
         self.tree = xmlTree.ElementTree(self.root)
         simulation = xmlTree.SubElement(self.root, 'simulation')
         simulation.set('iterate', '0')
         simulation.set('time', '0.0')
         simulation.set('unit', 'h')
     else:
         self.path = toolbox_basic.check_path(path)
         self.tree = toolbox_basic.get_xml_tree(self.path)
         self.root = self.tree.getroot()
     self.simulation = self.find('./simulation')
     self.iterate = int(self.simulation.attrib['iterate'])
     self.time = float(self.simulation.attrib['time'])
     self.time_unit = self.simulation.attrib['unit']
Пример #22
0
 def get_concn_array(self, detail_level, sif_name):
     self.get_run_dir(detail_level, sif_name)
     grid_length = detail_level * self.side_length
     array_path = os.path.join(self.run_dir, 'concn_array')
     if os.path.isfile(array_path):
         concn_array = toolbox_basic.load_array(array_path)
     else:
         result_file_path = os.path.join(self.run_dir, 'case.result')
         result_file_path = toolbox_basic.check_path(result_file_path)
         # This isn't quite correct! Without wrapping, Elmer skips some nodes
         num_nodes = (grid_length + 1)**2
         array_shape = (grid_length + 1,)*2
         with open(result_file_path, 'Ur') as f:
             last_lines = f.readlines()[-num_nodes:]
         concn_array = numpy.array([float(line) for line in last_lines])
         concn_array = numpy.reshape(concn_array, array_shape)
         toolbox_basic.save_array(concn_array, array_path)
     return concn_array
Пример #23
0
def normalise_by_generation(sim_dir_path, max_generation):
    results_path = basic.check_path(
        os.path.join(sim_dir_path, 'lineage_results.xml'))
    results_output = results.AgentOutput(path=results_path)
    results_species = results.SpeciesOutput(results_output)
    for generation in range(max_generation + 1):
        cohort = [
            c for c in results_species.members
            if int(c.vars['generation']) == generation
        ]
        growth_rates = [float(c.vars['growth_rate']) for c in cohort]
        mean = numpy.mean(growth_rates)
        for cell in cohort:
            cell.vars['growth_rate'] = str(
                float(cell.vars['growth_rate']) / mean)
    results_species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'norm_gen_lineage_results.xml')
    results_output.write(output_path=save_path)
Пример #24
0
def normalise_by_progenitor(sim_dir_path):
    results_path = basic.check_path(os.path.join(sim_dir_path, 'lineage_results.xml'))
    results_output = results.AgentOutput(path=results_path)
    results_species = results.SpeciesOutput(results_output)
    prog_growth_rates = {}
    for cell in results_species.members:
        generation = cell.vars['generation']
        if generation == '0':
            family = cell.vars['family']
            growth_rate = float(cell.vars['growth_rate'])
            prog_growth_rates[family] = growth_rate
    for cell in results_species.members:
        family = cell.vars['family']
        top = float(cell.vars['growth_rate'])
        bottom = prog_growth_rates[family]
        cell.vars['growth_rate'] = str( top / bottom )
    results_species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'norm_prog_lineage_results.xml')
    results_output.write(output_path=save_path)
def build_life_history(
    sim_dir_path,
    attribute1,
    attribute2,
    cell_id=(1, 0),
    biomass_names=["activeBiomassGrowth", "activeBiomassRepair", "inactiveBiomassGrowth", "inactiveBiomassRepair"],
):
    sim_dir_path = basic.check_path(sim_dir_path)
    # this must be value and not value1 for the first value so that the plotting
    # script can also plot older results at the same time
    attributes = {"name": attribute1, "name2": attribute2, "name3": "generation", "header": "time,value,value2,value3"}
    results_file_path = os.path.join(sim_dir_path, "life_history_results.xml")
    results_output = results.ResultsOutput(path=results_file_path)
    result_set = results.ResultSet(results_output, attributes)
    if len(result_set.members) > 0:
        return result_set.members
    requirements = {"family": str(cell_id[0]), "genealogy": str(cell_id[1])}
    file_dir = os.path.join(sim_dir_path, "agent_State")
    basic.unzip_files(file_dir + ".zip")
    file_list = basic.file_list(file_dir)
    for filename in file_list:
        output = results.AgentOutput(path=filename)
        species = results.SpeciesOutput(output)
        cells = species.find_cells(requirements)
        single_result = results.SingleResult()
        single_result.vars["time"] = output.time
        if len(cells) == 0:
            continue
        cell = cells[0]
        single_result.vars["value3"] = cell.vars["generation"]
        if attribute1 == "specific growth rate":
            single_result.vars["value"] = cell.get_specific_growth_rate(biomass_names)
        else:
            single_result.vars["value"] = cell.vars[attribute1]
        if attribute2 == "specific growth rate":
            single_result.vars["value2"] = cell.get_specific_growth_rate(biomass_names)
        else:
            single_result.vars["value2"] = cell.vars[attribute2]
        result_set.members.append(single_result)
    result_set.update_results_output()
    results_output.write(results_file_path)
    basic.rm_dir(file_dir)
    return result_set
Пример #26
0
def normalise_by_progenitor(sim_dir_path):
    results_path = basic.check_path(
        os.path.join(sim_dir_path, 'lineage_results.xml'))
    results_output = results.AgentOutput(path=results_path)
    results_species = results.SpeciesOutput(results_output)
    prog_growth_rates = {}
    for cell in results_species.members:
        generation = cell.vars['generation']
        if generation == '0':
            family = cell.vars['family']
            growth_rate = float(cell.vars['growth_rate'])
            prog_growth_rates[family] = growth_rate
    for cell in results_species.members:
        family = cell.vars['family']
        top = float(cell.vars['growth_rate'])
        bottom = prog_growth_rates[family]
        cell.vars['growth_rate'] = str(top / bottom)
    results_species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'norm_prog_lineage_results.xml')
    results_output.write(output_path=save_path)
Пример #27
0
def settle_competition(set_dir_path):
    set_dir_path = basic.check_path(set_dir_path)
    attributes = {'name' : 'competition', 
                  'header' : 'speciesAwashout,speciesBwashout,numSims,pValue'}
    results_file_path = os.path.join(set_dir_path, 'results.xml')
    results_output = results.ResultsOutput(path=results_file_path)
    result_set = results.ResultSet(results_output, attributes)
    if len(result_set.members) > 0:
        return result_set
    dir_list = basic.subdir_list(set_dir_path)
    dir_result = results.SingleResult()
    washoutA = 0
    washoutB = 0
    for dir_name in dir_list:
        last_path = os.path.join(dir_name, 'lastIter', 'agent_Sum(last).xml')
        last_output = results.AgentOutput(path=last_path)
        species_names = last_output.get_species_names()
        if not len(species_names) == 2:
            basic.error_message('There should be 2 species for a competition',
                                                                     last_path)
        last_speciesA = results.SpeciesOutput(last_output,
                                                 name=species_names[0])
        populationA = float(last_speciesA.members[0].vars['population'])
        last_speciesB = results.SpeciesOutput(last_output,
                                                 name=species_names[1])
        populationB = float(last_speciesB.members[0].vars['population'])
        if populationA < 1 and populationB > 0:
            washoutA += 1
        if populationB < 1 and populationA > 0:
            washoutB += 1
        if populationA < 1 and populationB < 1:
            basic.error_message('Both species washed out in', last_path)
    dir_result.vars['speciesAwashout'] = washoutA
    dir_result.vars['speciesBwashout'] = washoutB
    dir_result.vars['numSims'] = len(dir_list)
    dir_result.vars['pValue'] = \
               stats.binom.cdf(min(washoutA,washoutB),(washoutA+washoutB),0.5)
    result_set.members.append(dir_result)
    result_set.update_results_output()
    results_output.write(results_file_path)
    return result_set
def build_population_structure(
    sim_dir_path,
    attribute,
    bins=numpy.linspace(0, 0.6, 90),
    starting_time=2400,
    biomass_names=["activeBiomassGrowth", "activeBiomassRepair", "inactiveBiomassGrowth", "inactiveBiomassRepair"],
):
    attributes = {
        "name": attribute + " population structure",
        "starting_time": str(starting_time),
        "header": "bin,frequency",
    }
    print sim_dir_path
    sim_dir_path = basic.check_path(sim_dir_path)
    results_file_path = os.path.join(sim_dir_path, "results.xml")
    results_output = results.ResultsOutput(path=results_file_path)
    result_set = results.ResultSet(results_output, attributes)
    if len(result_set.members) > 0:
        return result_set.members
    attr_values = []
    total_pop = 0.0
    file_dir = os.path.join(sim_dir_path, "agent_State")
    basic.unzip_files(file_dir + ".zip")
    file_list = basic.file_list(file_dir)
    for filename in file_list:
        output = results.AgentOutput(path=filename)
        if output.time >= starting_time:
            species = results.SpeciesOutput(output)
            species.set_biomass_names(biomass_names)
            attr_values.extend(species.get_attribute_values(attribute))
            total_pop += species.population()
    hist, bin_edges = numpy.histogram(attr_values, bins)
    for i in range(len(hist)):
        single_result = results.SingleResult()
        single_result.vars["bin"] = str(bins[i + 1]) + "-" + str(bins[i])
        single_result.vars["frequency"] = str(float(hist[i]) / total_pop)
        result_set.members.append(single_result)
    result_set.update_results_output()
    results_output.write(results_file_path)
    basic.rm_dir(file_dir)
    return result_set
Пример #29
0
def calc_averages(results_path, max_generation):
    results_path = basic.check_path(results_path)
    results_output = results.AgentOutput(path=results_path)
    results_species = results.SpeciesOutput(results_output)
    results_species.change_header(
        'family,genealogy,generation,growth_rate,std_growth_rate')
    save_cells = []
    min_num_cells = 10000000000
    max_num_cells = 0
    for generation in range(max_generation + 1):
        cohort = [
            c for c in results_species.members
            if int(c.vars['generation']) == generation
        ]
        genealogies = list(set([int(c.vars['genealogy']) for c in cohort]))
        for genealogy in genealogies:
            growth_rates = [
                float(c.vars['growth_rate']) for c in cohort
                if int(c.vars['genealogy']) == genealogy
            ]
            num_cells = len(growth_rates)
            min_num_cells = min(min_num_cells, num_cells)
            max_num_cells = max(max_num_cells, num_cells)
            if num_cells < 5:
                print('Only ' + str(num_cells) + ' in point ' +
                      str(genealogy) + ', ' + str(generation))
            cell = LineageCell(results_species)
            cell.vars['genealogy'] = genealogy
            cell.vars['generation'] = generation
            cell.vars['growth_rate'] = numpy.mean(growth_rates)
            cell.vars['std_growth_rate'] = numpy.std(growth_rates)
            save_cells.append(cell)
    print('All lineages had between ' + str(min_num_cells) + ' and ' +
          str(max_num_cells) + ' cells')
    results_species.members = save_cells
    results_species.update_agent_output()
    dir_name = os.path.dirname(results_path)
    base_name = 'mean_' + os.path.basename(results_path)
    save_path = os.path.join(dir_name, base_name)
    results_output.write(output_path=save_path)
Пример #30
0
def collate_mean_attributes(set_dir_path, attribute, output_type, file_process,
                                                        starting_time=2400):
    set_dir_path = basic.check_path(set_dir_path)
    attributes = {'name':attribute, 
                    'starting_time':str(starting_time),
                    'header':'directory,mean,std'}
    results_file_path = os.path.join(set_dir_path, 'results.xml')
    results_output = results.ResultsOutput(path=results_file_path)
    result_set = results.ResultSet(results_output, attributes)
    if len(result_set.members) > 0:
        return result_set
    dir_list = basic.subdir_list(set_dir_path)
    for dir_name in dir_list:
        dir_result = results.SingleResult()
        dir_result.vars['directory'] = os.path.basename(dir_name)
        mean, std = calc_mean_attribute(dir_name, attribute, output_type,
                                   file_process, starting_time=starting_time)
        dir_result.vars['mean'] = mean
        dir_result.vars['std'] = std
        result_set.members.append(dir_result)
    result_set.update_results_output()
    results_output.write(results_file_path)
    return result_set
Пример #31
0
def calc_averages(results_path, max_generation):
    results_path = basic.check_path(results_path)
    results_output = results.AgentOutput(path=results_path)
    results_species = results.SpeciesOutput(results_output)
    results_species.change_header(
                    'family,genealogy,generation,growth_rate,std_growth_rate')
    save_cells = []
    min_num_cells = 10000000000
    max_num_cells = 0
    for generation in range(max_generation+1):
        cohort = [c for c in results_species.members if
                        int(c.vars['generation']) == generation]
        genealogies = list(set([int(c.vars['genealogy']) for c in cohort]))
        for genealogy in genealogies:
            growth_rates = [float(c.vars['growth_rate']) for c in cohort if 
                                        int(c.vars['genealogy']) == genealogy]
            num_cells = len(growth_rates)
            min_num_cells = min(min_num_cells, num_cells)
            max_num_cells = max(max_num_cells, num_cells)
            if num_cells < 5:
                print('Only '+str(num_cells)+' in point '+str(genealogy)+', '+
                                                               str(generation))
            cell = LineageCell(results_species)
            cell.vars['genealogy'] = genealogy
            cell.vars['generation'] = generation
            cell.vars['growth_rate'] = numpy.mean(growth_rates)
            cell.vars['std_growth_rate'] = numpy.std(growth_rates)
            save_cells.append(cell)
    print('All lineages had between '+str(min_num_cells)+
                                ' and '+str(max_num_cells)+' cells')
    results_species.members = save_cells
    results_species.update_agent_output()
    dir_name = os.path.dirname(results_path)
    base_name = 'mean_'+os.path.basename(results_path)
    save_path = os.path.join(dir_name, base_name)
    results_output.write(output_path=save_path)
Пример #32
0
def plot_lineages(axis,
                  results_path,
                  max_generation,
                  line_width=1.0,
                  error_bars=True):
    results_path = basic.check_path(results_path)
    results_output = results.AgentOutput(path=results_path)
    results_species = results.SpeciesOutput(results_output)
    if error_bars and results_species.attributes.count('std_growth_rate') == 0:
        print('Could not find data for error bars')
        error_bars = False
    for cell in results_species.members:
        generation = int(cell.vars['generation'])
        if generation <= max_generation - 1:
            family = int(cell.vars['family'])
            genealogy = int(cell.vars['genealogy'])
            growth_rate = float(cell.vars['growth_rate'])
            if error_bars:
                eb_x = [generation + 1]
                eb_y = [growth_rate]
                eb_e = [float(cell.vars['std_growth_rate'])]
            requirements = {
                'family': family,
                'genealogy': genealogy,
                'generation': generation + 1
            }
            temp = results_species.find_cells(requirements)
            if not temp == []:
                oldie = temp[0]
                oldie_grow = float(oldie.vars['growth_rate'])
                axis.plot([generation + 1, generation + 2],
                          [growth_rate, oldie_grow],
                          'r',
                          linewidth=line_width,
                          solid_capstyle='round',
                          zorder=5 + numpy.random.randint(5))
                if error_bars:
                    eb_x.append(generation + 2)
                    eb_y.append(oldie_grow)
                    eb_e.append(float(oldie.vars['std_growth_rate']))
            requirements['genealogy'] = genealogy + 2**generation
            temp = results_species.find_cells(requirements)
            if not temp == []:
                newbie = temp[0]
                newbie_grow = float(newbie.vars['growth_rate'])
                axis.plot([generation + 1, generation + 2],
                          [growth_rate, newbie_grow],
                          'b',
                          linewidth=line_width,
                          solid_capstyle='round',
                          zorder=5 + numpy.random.randint(5))
                if error_bars:
                    eb_x.append(generation + 2)
                    eb_y.append(newbie_grow)
                    eb_e.append(float(newbie.vars['std_growth_rate']))
            if error_bars:
                axis.errorbar(eb_x,
                              eb_y,
                              yerr=eb_e,
                              ecolor='grey',
                              fmt=None,
                              elinewidth=line_width / 2,
                              capsize=1,
                              zorder=1)
    axis.set_xlabel('Generations')
    axis.set_ylabel('Normalised growth rate')
    axis.set_xlim([1, max_generation + 1])
Пример #33
0
#!/usr/bin/python
from __future__ import division
from __future__ import with_statement
import os
import toolbox_basic

input_file = \
        os.path.join("~", "Dropbox", "KreftGroup", "NRM", "bac_000_070000.ml")

input_file = toolbox_basic.check_path(input_file)

with open(input_file, 'Ur') as f:
    input_script = f.readlines()

species_names = {1: 'Eco', 2: 'Ego'}

species_lists = [[], []]

input_column_heads = [
    'species', 'locationX', 'locationY', 'locationZ', 'radius', 'unknown1',
    'genealogy', 'growthRate', 'unknown2'
]

for line in input_script:
    if line is '':
        continue
    columns = line.replace('\n', '').split('\t')
    '''
    for i in range(len(columns)):
        if '.' in columns[i]:
            columns[i] = float(columns[i])
Пример #34
0
#!/usr/bin/python
from __future__ import division
from __future__ import with_statement
import os
import toolbox_basic

input_file = os.path.join("~", "Dropbox", "KreftGroup", "NRM", "bac_000_070000.ml")

input_file = toolbox_basic.check_path(input_file)

with open(input_file, "Ur") as f:
    input_script = f.readlines()

species_names = {1: "Eco", 2: "Ego"}

species_lists = [[], []]

input_column_heads = [
    "species",
    "locationX",
    "locationY",
    "locationZ",
    "radius",
    "unknown1",
    "genealogy",
    "growthRate",
    "unknown2",
]

for line in input_script:
    if line is "":
Пример #35
0
def process_last_iter(sim_dir_path, max_generation, use_masses=True):
    sim_dir_path = basic.check_path(sim_dir_path)
    last_path = os.path.join(sim_dir_path, 'lastIter', 'agent_State(last).xml')
    last_path = basic.check_path(last_path)
    last_output, last_species = results.get_single_species(last_path)
    if use_masses:
        agent_State_dir = basic.unzip_files(
            os.path.join(sim_dir_path, 'agent_State.zip'))
        biomass_names = ['activeBiomass', 'inactiveBiomass']
        timestep = float(last_output.time) / float(last_output.iterate)
    # do a first run-through
    temp_cells = []
    families = []
    for cell in last_species.members:
        family = int(cell.vars['family'])
        if families.count(family) == 0:
            families.append(family)
        genealogy = int(cell.vars['genealogy'])
        birthday = float(cell.vars['birthday'])
        birth_generation = calc_birth_generation(genealogy)
        for generation in range(birth_generation, max_generation + 2):
            temp = LineageCell(last_species)
            temp.vars['family'] = family
            temp.vars['genealogy'] = genealogy
            temp.vars['generation'] = generation
            temp.vars['initial_time'] = birthday
            if use_masses:
                iter = str(int(birthday / timestep))
                iter_path = os.path.join(agent_State_dir,
                                         'agent_State(' + iter + ').xml')
                iter_output, iter_species = results.get_single_species(
                    iter_path)
                requirements = {'family': family, 'genealogy': genealogy}
                iter_cell = iter_species.find_cells(requirements)[0]
                temp.vars['initial_mass'] = iter_cell.get_total_biomass(
                    biomass_names)
                requirements['genealogy'] = genealogy - 2**(generation - 1)
                sibling = iter_species.find_cells(requirements)
                if len(sibling) == 1:
                    temp.sibling_mass = sibling[0].get_total_biomass(
                        biomass_names)
            temp_cells.append(temp)
    print(
        str(len(temp_cells)) + ' cells in ' + str(len(families)) + ' families')
    # then filter
    last_species.members = []
    for family in families:
        members = [c for c in temp_cells if c.vars['family'] == family]
        next_gen = [c for c in members if c.vars['generation'] == 0]
        for generation in range(max_generation + 1):
            current_gen = next_gen
            next_gen = [
                c for c in members if c.vars['generation'] == generation + 1
            ]
            for cell in current_gen:
                genealogy = cell.vars['genealogy']
                # find my baby
                baby_genealogy = genealogy + 2**generation
                possibles = [
                    c for c in next_gen
                    if c.vars['genealogy'] == baby_genealogy
                ]
                if len(possibles) == 1:
                    baby = possibles[0]
                    baby_bday = baby.vars['initial_time']
                    cell.vars['division_time'] = baby_bday
                    if use_masses:
                        total_mass = baby.vars[
                            'initial_mass'] + baby.sibling_mass
                        cell.vars['division_mass'] = total_mass
                    possibles = [
                        c for c in next_gen if c.vars['genealogy'] == genealogy
                    ]
                    if len(possibles) == 1:
                        me_next = possibles[0]
                        me_next.vars['initial_time'] = baby_bday
                        if use_masses:
                            me_next.vars['initial_mass'] = baby.sibling_mass
                    cell.set_growth_rate()
                    last_species.members.append(cell)
    print(str(len(last_species.members)) + ' cells remain')
    #for cell in temp_cells.members:
    header = 'family,genealogy,generation,initial_time,division_time,'
    header += 'initial_mass,division_mass,growth_rate'
    last_species.change_header(header)
    last_species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'lineage_results.xml')
    last_output.write(output_path=save_path)
Пример #36
0
def process_last_iter(sim_dir_path, max_generation, use_masses=True):
    sim_dir_path = basic.check_path(sim_dir_path)
    last_path = os.path.join(sim_dir_path, 'lastIter', 'agent_State(last).xml')
    last_path = basic.check_path(last_path)
    last_output, last_species = results.get_single_species(last_path)
    if use_masses:
        agent_State_dir = basic.unzip_files(os.path.join(sim_dir_path, 'agent_State.zip'))
        biomass_names = ['activeBiomass','inactiveBiomass']
        timestep = float(last_output.time) / float(last_output.iterate)
    # do a first run-through
    temp_cells = []
    families = []
    for cell in last_species.members:
        family = int(cell.vars['family'])
        if families.count(family) == 0:
            families.append(family)
        genealogy = int(cell.vars['genealogy'])
        birthday = float(cell.vars['birthday'])
        birth_generation = calc_birth_generation(genealogy)
        for generation in range(birth_generation, max_generation+2):
            temp = LineageCell(last_species)
            temp.vars['family'] = family
            temp.vars['genealogy'] = genealogy
            temp.vars['generation'] = generation
            temp.vars['initial_time'] = birthday
            if use_masses:
                iter = str(int( birthday / timestep ))
                iter_path = os.path.join(agent_State_dir, 
                                            'agent_State('+iter+').xml')
                iter_output, iter_species = results.get_single_species(iter_path)
                requirements = {'family':family, 'genealogy':genealogy}
                iter_cell = iter_species.find_cells(requirements)[0]
                temp.vars['initial_mass'] = iter_cell.get_total_biomass(biomass_names)
                requirements['genealogy'] = genealogy - 2**(generation-1)
                sibling = iter_species.find_cells(requirements)
                if len(sibling) == 1:
                    temp.sibling_mass = sibling[0].get_total_biomass(biomass_names)
            temp_cells.append(temp)
    print(str(len(temp_cells))+' cells in '+str(len(families))+' families')
    # then filter
    last_species.members = []
    for family in families:
        members = [c for c in temp_cells if c.vars['family'] == family]
        next_gen = [c for c in members if c.vars['generation'] == 0]
        for generation in range(max_generation + 1):
            current_gen = next_gen
            next_gen = [c for c in members if 
                                    c.vars['generation'] == generation+1]
            for cell in current_gen:
                genealogy = cell.vars['genealogy']
                # find my baby
                baby_genealogy = genealogy + 2**generation
                possibles = [c for c in next_gen if 
                                        c.vars['genealogy'] == baby_genealogy]
                if len(possibles) == 1:
                    baby = possibles[0]
                    baby_bday = baby.vars['initial_time']
                    cell.vars['division_time'] = baby_bday
                    if use_masses:
                        total_mass = baby.vars['initial_mass'] + baby.sibling_mass
                        cell.vars['division_mass'] = total_mass
                    possibles = [c for c in next_gen if 
                                            c.vars['genealogy'] == genealogy]
                    if len(possibles) == 1:
                        me_next = possibles[0]
                        me_next.vars['initial_time'] = baby_bday
                        if use_masses:
                            me_next.vars['initial_mass'] = baby.sibling_mass
                    cell.set_growth_rate()
                    last_species.members.append(cell)
    print(str(len(last_species.members))+' cells remain')
    #for cell in temp_cells.members:
    header = 'family,genealogy,generation,initial_time,division_time,'
    header += 'initial_mass,division_mass,growth_rate'
    last_species.change_header(header)
    last_species.update_agent_output()
    save_path = os.path.join(sim_dir_path, 'lineage_results.xml')
    last_output.write(output_path=save_path)
Пример #37
0
#!/usr/bin/python
from __future__ import division
from __future__ import with_statement
import os
import toolbox_basic

input_dir = os.path.join("~", "Dropbox", "KreftGroup", "NRM")
input_dir = toolbox_basic.check_path(input_dir)

input_file = os.path.join(input_dir, "bac_000_070000.ml")
output_file = os.path.join(input_dir, "bac_000_070000.pov")

with open(input_file, "Ur") as f:
    input_script = f.readlines()

species_names = {"1": "Eco", "2": "Ego"}

# TODO .incl files?
output_script = ""

for line in input_script:
    if line is "":
        continue
    columns = line.replace("\n", "").split("\t")
    output_script += "sphere { <%s, %s, %s> %s texture { %s } }\n" % (
        columns[2],
        columns[1],
        columns[3],
        columns[4],
        species_names[columns[0]],
    )
#!/usr/bin/python
from __future__ import division
import aging_extras
import os
import math
from pylab import *
import toolbox_basic
import toolbox_plotting
import toolbox_results
from mpl_toolkits.axes_grid1 import make_axes_locatable

# base_path = os.path.join('~', 'Dropbox', 'EclipseWorkspace', 'iDynoAge')
# base_path = os.path.join('C:\\', 'Users', 'RJW598', 'git', 'iDynoMiCS')
base_path = os.path.join("~", "git", "iDynoMiCS")
print base_path
base_path = toolbox_basic.check_path(base_path)
print base_path
input_path = os.path.join(base_path, "results", "Older", "Figure_4")
output_path = os.path.join(input_path, "figure_4_life_history_ABC.pdf")

fig = toolbox_plotting.BmcFigure(double_column=True, height="double")

axisA = fig.add_subplot("A", 221)
paths = [
    "T010S12OBConstEnvCleggComp_life_history_results.xml",
    "T010S12NRConstEnvCleggComp_life_history_results.xml",
    "T010S12007ConstEnvCleggComp_life_history_results.xml",
    "T010AS12NRConstEnvCleggComp_life_history_results.xml",
    "T010AS12007ConstEnvCleggComp_life_history_results.xml",
    "T010AS12OBConstEnv1_0D_Ind_life_history_results.xml",
]
Пример #39
0
#!/usr/bin/python
from __future__ import division
from __future__ import with_statement
import os
import toolbox_basic

input_dir = os.path.join("~", "Dropbox", "KreftGroup", "NRM")
input_dir = toolbox_basic.check_path(input_dir)

input_file = os.path.join(input_dir, "bac_000_070000.ml")
output_file = os.path.join(input_dir, "bac_000_070000.pov")

with open(input_file, 'Ur') as f:
    input_script = f.readlines()

species_names = {'1': 'Eco', '2': 'Ego'}

# TODO .incl files?
output_script = ""

for line in input_script:
    if line is '':
        continue
    columns = line.replace('\n', '').split('\t')
    output_script += 'sphere { <%s, %s, %s> %s texture { %s } }\n' \
        %(columns[2], columns[1], columns[3], columns[4], species_names[columns[0]])

with open(output_file, 'w') as f:
    f.write(output_script)
def get_all(folder, f):
    sim_dir_path = basic.check_path(folder + f + '/')
    file_dir = os.path.join(sim_dir_path, 'agent_Sum')
    basic.unzip_files(file_dir + '.zip')
    file_list = basic.file_list(file_dir)
    t_a, population_a, biomass_a, growthrate_a = [], [], [], []
    t_b, population_b, biomass_b, growthrate_b = [], [], [], []
    last_pop_a, last_biomass_a, last_growthrate_a = [], [], []
    last_pop_b, last_biomass_b, last_growthrate_b = [], [], []
    for filename in file_list:
        output = results.AgentOutput(path=filename)
        species = results.SpeciesOutput(output, 'OldieA')
        requirements = {}
        cells = species.find_cells(requirements)
        #single_result = results.SingleResult()
        t_a.append(float(output.time))
        if len(cells) == 0:
            continue
        cell = cells[0]
        population_a.append(float(cell.vars['population']))
        biomass_a.append(float(cell.vars['mass']))
        growthrate_a.append(float(cell.vars['growthRate']))
        species = results.SpeciesOutput(output, 'OldieB')
        requirements = {}
        cells = species.find_cells(requirements)
        #single_result = results.SingleResult()
        t_b.append(float(output.time))
        if len(cells) == 0:
            continue
        cell = cells[0]
        population_b.append(float(cell.vars['population']))
        biomass_b.append(float(cell.vars['mass']))
        growthrate_b.append(float(cell.vars['growthRate']))
    basic.rm_dir(file_dir)
    lists_a, lists_b = [population_a, biomass_a,
                        growthrate_a], [population_b, biomass_b, growthrate_b]
    t_a1, t_b1 = t_a, t_b
    for i in range(3):
        list1, list2, list3, list4 = t_a1, lists_a[i], t_b1, lists_b[i]
        t_a, lists_a[i] = (list(x) for x in zip(
            *sorted(zip(list1, list2), key=itemgetter(0))))
        t_b, lists_b[i] = (list(x) for x in zip(
            *sorted(zip(list3, list4), key=itemgetter(0))))
    biomass_ratio, population_ratio, growthrate_ratio = [], [], []
    for j in range(len(lists_a[1])):
        biomass_ratio.append(numpy.log(lists_a[1][j] / lists_b[1][j]))
        population_ratio.append(numpy.log(lists_a[0][j] / lists_b[0][j]))
        if lists_a[2][j] == 0 and lists_b[2][j] == 0:
            growthrate_ratio.append(0)
        elif lists_a[2][j] == 0:
            lists_b[2][j] = abs(1 / (lists_b[2][j]))
            growthrate_ratio.append(numpy.log(lists_b[2][j]))
        elif lists_b[2][j] == 0:
            lists_a[2][j] = abs((lists_a[2][j]) / 1)
            growthrate_ratio.append(numpy.log(lists_a[2][j]))
        else:
            growthrate_ratio.append(
                abs(numpy.log(lists_a[2][j] / lists_b[2][j])))
        if j == len(lists_a[1]) - 1:
            last_pop_a.append(lists_a[0][j])
            last_pop_b.append(lists_b[0][j])
            last_biomass_a.append(lists_a[1][j])
            last_biomass_b.append(lists_b[1][j])
            last_growthrate_a.append(lists_a[2][j])
            last_growthrate_b.append(lists_b[2][j])
    return t_a, [biomass_ratio, population_ratio, growthrate_ratio]
Пример #41
0
#!/usr/bin/python
#import numpy
import os
import sys
import toolbox_basic as basic
#import toolbox_results as results
#import toolbox_fitness as fitness
#import toolbox_idynomics
import random
import math

#this is for one species only

dir_path = basic.check_path(
    '/Users/u1560915/git/iDynoMiCS/results_analysis_python')
file_path = os.path.join(dir_path, 'even_spacing_to_start.xml')
gridres = 4
density = 201
genealogy = 0.0
generation = 0.0
birthday = 0.0
activeBiomassGrowth = 300
activeBiomassRepair = 0.0
inactiveBiomassGrowth = 0.0
inactiveBiomassRepair = 0.0
growthRate = 0.0
volumeRate = 0.0
locationX = 0.0  #- or the same as the radius?
locationY = 0.000000  #+i = +4 = +4*(i-1)
locationZ = 0.000000
radius = 0.0
Пример #42
0
def get_replicate_results(replicates_dir):
    replicates_dir = toolbox_basic.check_path(replicates_dir)
    results_path = os.path.join(replicates_dir, 'results.xml')
    results_file = ReplicatesFile(path=results_path)
    return results_file