def output_crn(enumerator, filename, output_condensed=False, output_rates=True, condense_options={}): output_file = open(filename, 'w') def write_reaction(output_file, reaction): reactants = map(str, reaction.reactants) products = map(str, reaction.products) reac_string_list = [ " + ".join(reactants), "->", " + ".join(products), "\n" ] reac_string = ' '.join(reac_string_list) output_file.write(reac_string) reactions = enumerator.reactions if (output_condensed): condensed = condense_resting_states(enumerator, **condense_options) reactions = condensed['reactions'] for reaction in sorted(reactions): # utils.natural_sort(reactions): write_reaction(output_file, reaction) output_file.close()
def output_k(enumerator, filename, output_condensed=False, output_rates=True, condense_options={}): output_file = open(filename, 'w') def write_reaction(output_file, reaction, reversible=True): reactants = sorted([ str(count) + '*' + str(x) if count > 1 else str(x) for (x, count) in collections.Counter(sorted(reaction.reactants)).iteritems() ]) products = sorted([ str(count) + '*' + str(x) if count > 1 else str(x) for (x, count) in collections.Counter(sorted(reaction.products)).iteritems() ]) if reversible: arrow = '<->' else: arrow = '->' rxn = [" + ".join(reactants), arrow, " + ".join(products), "\n"] output_file.write(' '.join(rxn)) reactions = enumerator.reactions if (output_condensed): condensed = condense_resting_states(enumerator, **condense_options) reactions = condensed['reactions'] for reaction in sorted(reactions): # utils.natural_sort(reactions): write_reaction(output_file, reaction, True) output_file.close()
def output_condensed_dotfile(enumerator, filename): fout = open(filename + ".dot", "w") fout.write("digraph G {\n") fout.write('size="7,10"\n') fout.write('page="8.5,11"\n') fout.write('node[width=0.25,height=0.375,fontsize=9]\n') condensed_graph = condense_resting_states(enumerator, **condense_options) # We loop through all resting states, drawing them on the graph for state in condensed_graph['resting_states']: fout.write('%s [label="%s"]\n' % (str(state), str(state))) # We now add reactions. We always create a reaction node. for (i, reaction) in enumerate(condensed_graph['reactions']): reaction_label = "R_%d" % i fout.write( '%s [label="",shape=circle,height=0.12,width=0.12,fontsize=1,style=filled,color=red];\n' % reaction_label) for reagent in reaction.reactants: fout.write("%s -> %s\n" % (str(reagent), reaction_label)) for product in reaction.products: fout.write("%s -> %s\n" % (reaction_label, str(product))) fout.write("}\n") fout.close()
def test_peppercorn_interface(self): """ Make sure peppercorn.utils did not change """ t0 = peputils.Domain('t0', 5, sequence='H'*5) t0_ = peputils.Domain('t0', 5, sequence='D'*5, is_complement=True) d1 = peputils.Domain('d1', 15, sequence='H'*15) d1_ = peputils.Domain('d1', 15, sequence='D'*15, is_complement=True) domains = [t0,t0_,d1,d1_] s0 = peputils.Strand('s0', [t0, d1]) s1 = peputils.Strand('s1', [d1]) s2 = peputils.Strand('s2', [d1_, t0_]) strands = [s0,s1,s2] c1s = peputils.parse_dot_paren('..') c1 = peputils.Complex('c1', [s0], c1s) c1.check_structure() c2s = peputils.parse_dot_paren('(+).') c2 = peputils.Complex('c2', [s1,s2], c2s) c2.check_structure() complexes = [c1,c2] enum = Enumerator(domains, strands, complexes) enum.enumerate() ########################### # Get full output CRN reactions = enum.reactions self.assertEqual(len(reactions), 3) r1_kernel = 't0 d1 + d1( + ) t0* -> t0( d1 + d1( + ) )' r2_kernel = 't0( d1 + d1( + ) ) -> t0( d1( + ) ) + d1' r3_kernel = 't0( d1 + d1( + ) ) -> t0 d1 + d1( + ) t0*' p_cntr = Counter() r_cntr = Counter() for r in sorted(reactions): #print r.kernel_string() for cx in r.reactants : p_cntr += Counter(map(str, cx.strands)) for cx in r.products: r_cntr += Counter(map(str, cx.strands)) self.assertEqual(p_cntr, r_cntr) self.assertTrue(r.kernel_string() in [r1_kernel, r2_kernel, r3_kernel]) ########################### # Get condensed output CRN condensed = condense_resting_states(enum, compute_rates=True, k_fast = 0.) reactions = condensed['reactions'] self.assertEqual(len(reactions), 1) result_kernel = 't0 d1 + d1( + ) t0* -> t0( d1( + ) ) + d1' self.assertEqual(reactions[0].kernel_string(), result_kernel)
def test_under_the_hood2(self): domstring = """ sequence tf : 5 sequence bm : 15 A : tf bm . . B : bm tf + tf* bm* tf* ( ( + ) ) . """ solution = self._TestTube_from_DOM(domstring) peppercorn = ne.TestTubePeppercornIO(testtube=solution, pargs=self.args) self.assertIsInstance(pep.enumerator, Enumerator) pep.enumerate() ########################### # Get full output CRN reactions = pep.enumerator.reactions r1 = 'tf bm + tf( bm( + tf* ) ) -> tf( bm( + tf( bm + ) ) )' r2 = 'tf bm + bm( tf( + ) ) tf* -> tf( bm + bm( tf( + ) ) )' r3 = 'tf( bm( + tf* ) ) + bm tf -> tf( bm( + bm tf( + ) ) )' r4 = 'bm tf + bm( tf( + ) ) tf* -> bm tf( + bm( tf( + ) ) )' r5 = 'tf( bm + bm( tf( + ) ) ) -> tf( bm( + bm tf( + ) ) )' r6 = 'tf( bm( + bm tf( + ) ) ) -> tf( bm + bm( tf( + ) ) )' r7 = 'tf( bm( + tf( bm + ) ) ) -> tf bm + tf( bm( + tf* ) )' r8 = 'tf( bm + bm( tf( + ) ) ) -> tf bm + bm( tf( + ) ) tf*' r9 = 'tf( bm( + bm tf( + ) ) ) -> tf( bm( + tf* ) ) + bm tf' r10 = 'bm tf( + bm( tf( + ) ) ) -> bm tf + bm( tf( + ) ) tf*' self.assertEqual(len(reactions), 10) for r in sorted(reactions): self.assertTrue(r.kernel_string() in [ r1, r2, r3, r4, r5, r6, r7, r8, r9, r10]) ########################### # Get condensed output CRN condensed = condense_resting_states(pep.enumerator) reactions = condensed['reactions'] rc1 = 'tf bm + bm( tf( + ) ) tf* -> tf( bm( + tf* ) ) + bm tf' rc2 = 'tf( bm( + tf* ) ) + bm tf -> tf bm + bm( tf( + ) ) tf*' self.assertEqual(len(reactions), 2) for r in sorted(reactions): self.assertTrue(r.kernel_string() in [rc1, rc2])
def test_under_the_hood1(self): # A test function that checks enumerated reaction networks by directly # calling the Enumerator object, not the output of the TestTubePeppercornIO # wrapper. domstring = """ sequence tf : 5 sequence bm : 15 sequence tb : 5 A : tf bm . . B : bm tb + tb* bm* tf* ( ( + ) ) . """ solution = self._TestTube_from_DOM(domstring) peppercorn = ne.TestTubePeppercornIO(testtube=solution, pargs=self.args) self.assertIsInstance(pep.enumerator, Enumerator) pep.enumerate() ########################### # Get full output CRN reactions = pep.enumerator.reactions r1 = 'tf bm + bm( tb( + ) ) tf* -> tf( bm + bm( tb( + ) ) )' r2 = 'tf( bm( + tb* ) ) + bm tb -> tf( bm( + bm tb( + ) ) )' r3 = 'tf( bm + bm( tb( + ) ) ) -> tf( bm( + bm tb( + ) ) )' r4 = 'tf( bm( + bm tb( + ) ) ) -> tf( bm + bm( tb( + ) ) )' r5 = 'tf( bm + bm( tb( + ) ) ) -> tf bm + bm( tb( + ) ) tf*' r6 = 'tf( bm( + bm tb( + ) ) ) -> tf( bm( + tb* ) ) + bm tb' for r in sorted(reactions): print r.kernel_string() self.assertTrue(r.kernel_string() in [r1, r2, r3, r4, r5, r6]) ########################### # Get condensed output CRN condensed = condense_resting_states(pep.enumerator) reactions = condensed['reactions'] rc1 = 'tf bm + bm( tb( + ) ) tf* -> tf( bm( + tb* ) ) + bm tb' rc2 = 'tf( bm( + tb* ) ) + bm tb -> tf bm + bm( tb( + ) ) tf*' for r in sorted(reactions): self.assertTrue(r.kernel_string() in [rc1, rc2])
def enumerator_to_testtube(self, enumerator): """Merge Enumerator() complexes into the TestTube() object. Note that the enumerator cannot generate new domains or new strands, it only finds new complexes. This function adds all complexes that are present in resting states in the system. Transient states are ignored. """ condensed = TestTubePeppercornIO.condensed ttcomplexes = dict() domains = enumerator.domains # The enumerator cannot find new domains, so if there is a testtube object # already, then we might as well save some effort and use the testtube # domains directly if self._testtube: dNames = map(lambda x: x.name, domains) tDomains = self._testtube.domains assert all(map(lambda d: d in tDomains, dNames)) domains = tDomains else: # translate domains to nuskell.Domain format, easy... raise NotImplementedError if condensed: enum_complexes = enumerator.resting_complexes else: # resting_complexes + transient_complexes enum_complexes = enumerator.complexes for cx in enum_complexes: if cx.name in self._enumN_to_ttubeO: ttcplx = self._enumN_to_ttubeO[cx.name] ttcomplexes[cx.name] = (ttcplx, None, None) continue domseq = [] for sd in cx.strands: domseq.append('+') for do in sd.domains: assert (do.name in domains) dom = domains[do.name] domseq.append(dom) # remove the first '+' again if len(domseq) > 0: domseq = domseq[1:] domstr = list(cx.dot_paren_string()) cplxname = self._ecplx_rename(cx.name) if cplxname in ttcomplexes: raise ValueError("Complex found in muliple resting states?") ttcplx = Complex(sequence=domseq, structure=domstr, name=cplxname) ttcomplexes[ttcplx.name] = (ttcplx, None, None) self._enumN_to_ttubeO[cx.name] = ttcplx self._ttubeN_to_enumO[ttcplx.name] = cx crn = dict() if condensed: condensed = condense_resting_states(enumerator, compute_rates=True, k_fast=enumerator.k_fast) reactions = condensed['reactions'] for r in reactions: # NOTE: takes only the *first complex* of resting states as representative react = [] for rs in r.reactants: react.append(self._enumN_to_ttubeO[rs.complexes[0].name]) prod = [] for rs in r.products: prod.append(self._enumN_to_ttubeO[rs.complexes[0].name]) rxn = Reaction(react, prod, rate=r.rate(), rtype=r.name) crn[rxn.name] = rxn else: for r in enumerator.reactions: react = [] for re in r.reactants: react.append(self._enumN_to_ttubeO[re.name]) prod = [] for pr in r.products: prod.append(self._enumN_to_ttubeO[pr.name]) rxn = Reaction(react, prod, rate=r.rate(), rtype=r.name) crn[rxn.name] = rxn return TestTube(complexes=ttcomplexes, reactions=crn)
def output_case(enumerator, filename, output_condensed=False, condense_options={}): def tab(x): return "\t" * x of = open(filename, 'w') of.write("def test_%s(enumerator):\n" % filename) # Domains of.write(tab(1) + "# Domains \n") of.write(tab(1) + "domains = { \n") lines = [] for domain in utils.natural_sort(enumerator.domains): # name, length, is_complement=False, sequence=None lines.append( tab(2) + "'%s' : Domain('%s', %d, is_complement=%s, sequence='%s')" % (domain.name, domain.identity, domain.length, domain.is_complement, domain.sequence)) of.write(",\n".join(lines) + "\n") of.write(tab(1) + "}\n") of.write( tab(1) + "assert set(domains.values()) == set(enumerator.domains)\n\n") # Strands of.write(tab(1) + "# Strands \n") of.write(tab(1) + "strands = { \n") lines = [] for strand in utils.natural_sort(enumerator.strands): doms = ", ".join("domains['%s']" % dom.name for dom in strand.domains) lines.append( tab(2) + "'%s' : Strand('%s', [%s])" % (strand.name, strand.name, doms)) of.write(",\n".join(lines) + "\n") of.write(tab(1) + "}\n") of.write( tab(1) + "assert set(strands.values()) == set(enumerator.strands)\n\n") # Complexes of.write(tab(1) + "# Complexes \n") of.write(tab(1) + "complexes = { \n") lines = [] for complex in utils.natural_sort(enumerator.complexes): strands = ", ".join("strands['%s']" % strand.name for strand in complex.strands) lines.append( tab(2) + "'%s' : Complex('%s', [%s], %r)" % (complex.name, complex.name, strands, complex.structure)) of.write(",\n".join(lines) + "\n") of.write(tab(1) + "}\n") of.write( tab(1) + "assert set(complexes.values()) == set(enumerator.complexes)\n\n") # Reactions of.write(tab(1) + "# Reactions \n") of.write(tab(1) + "reactions = { \n") lines = [] for reaction in utils.natural_sort(enumerator.reactions): reactants = ", ".join("complexes['%s']" % complex.name for complex in reaction.reactants) products = ", ".join("complexes['%s']" % complex.name for complex in reaction.products) lines.append( tab(2) + "ReactionPathway('%s', [%s], [%s])" % (reaction.name, reactants, products)) of.write(",\n".join(lines) + "\n") of.write(tab(1) + "}\n") of.write(tab(1) + "assert set(reactions) == set(enumerator.reactions)\n\n") if (output_condensed): condensed = condense_resting_states(enumerator, **condense_options) # Resting states of.write(tab(1) + "# Resting states \n") of.write(tab(1) + "resting_states = { \n") lines = [] for rs in utils.natural_sort(condensed['resting_states']): complexes = ", ".join("complexes['%s']" % complex.name for complex in rs.complexes) lines.append( tab(2) + "'%s' : RestingState('%s', [%s])" % (rs.name, rs.name, complexes)) of.write(",\n".join(lines) + "\n") of.write(tab(1) + "}\n") of.write( tab(1) + "assert set(resting_states.values()) == set(condensed['resting_states'])\n\n" ) # Condensed reactions of.write(tab(1) + "# Condensed Reactions \n") of.write(tab(1) + "condensed_reactions = { \n") lines = [] for reaction in utils.natural_sort(condensed['reactions']): reactants = ", ".join("resting_states['%s']" % species.name for species in reaction.reactants) products = ", ".join("resting_states['%s']" % species.name for species in reaction.products) lines.append( tab(2) + "ReactionPathway('%s', [%s], [%s])" % (reaction.name, reactants, products)) of.write(",\n".join(lines) + "\n") of.write(tab(1) + "}\n") of.write( tab(1) + "assert set(condensed_reactions) == set(condensed['reactions'])\n\n" ) of.close()
def output_sbml(enumerator, filename, output_condensed=False, output_rates=True, condense_options={}): # # default initial concentration of all species is 100 nM # initial_concentration = 10e-7 import xml.dom.minidom header = '<?xml version="1.0" encoding="UTF-8"?>' out = [ header, '<sbml level="2" version="3" xmlns="http://www.sbml.org/sbml/level2/version3">', '<model name="%s">' % filename, '<listOfUnitDefinitions>', '<unitDefinition id="per_second">', '<listOfUnits>', '<unit kind="second" exponent="-1"/>', ' </listOfUnits>', '</unitDefinition>', '<unitDefinition id="litre_per_mole_per_second">', '<listOfUnits>', '<unit kind="mole" exponent="-1"/>', '<unit kind="litre" exponent="1"/>', '<unit kind="second" exponent="-1"/>', '</listOfUnits>', '</unitDefinition>', '</listOfUnitDefinitions>', '<listOfCompartments>', '<compartment id="reaction" size="1e-3" />', '</listOfCompartments>', '<listOfSpecies>' ] if (output_condensed): condensed = condense_resting_states(enumerator, **condense_options) complexes = condensed['resting_states'] reactions = condensed['reactions'] else: complexes = enumerator.complexes reactions = enumerator.reactions def id(species): return "s_" + species.name # build elements for each species if (output_condensed): for resting_state in complexes: # is_initial = any(c in enumerator.initial_complexes for c in resting_state.complexes) initial_concentration = sum( (c.concentration if c.concentration is not None else 0.0) for c in resting_state.complexes) out.append( '<species compartment="reaction" id="%(id)s" name="%(name)s" initialConcentration="%(initial)g"/>' % { "name": resting_state.name, "id": id(resting_state), "initial": initial_concentration }) else: for complex in complexes: # is_initial = (complex in enumerator.initial_complexes) initial_concentration = complex.concentration if complex.concentration is not None else 0.0 out.append( '<species compartment="reaction" id="%(id)s" name="%(name)s" initialConcentration="%(initial)g"/>' % { "name": complex.name, "id": id(complex), "initial": initial_concentration }) out += ['</listOfSpecies>', '<listOfReactions>'] # list reactions for (i, reaction) in enumerate(reactions): out += ['<reaction id="r_%d" reversible="false">' % i, '<listOfReactants>'] + \ ['<speciesReference species="%s"/>' % id(species) for species in reaction.reactants] + \ ['</listOfReactants>', '<listOfProducts>'] + \ ['<speciesReference species="%s"/>' % id(species) for species in reaction.products] + \ ['</listOfProducts>'] # unimolecular rate constants have units 1/s, bimolecular rate # constants have units 1/M/s units = 'per_second' if reaction.arity[ 0] == 1 else 'litre_per_mole_per_second' out += ['<kineticLaw>', '<math xmlns="http://www.w3.org/1998/Math/MathML">', '<apply>', '<times />', '<ci>k</ci>'] + \ ['<ci>' + id(s) + '</ci>' for s in reaction.reactants] + \ ['</apply>', '</math>', '<listOfParameters>', '<parameter id="k" value="%.10f" units="%s"/>' % ( reaction.rate(), units), '</listOfParameters>', '</kineticLaw>', '</reaction>'] out.extend(['</listOfReactions>', '</model>', '</sbml>']) doc = xml.dom.minidom.parseString("".join(out)) fout = open(filename, "w") fout.write(header + '\n' + doc.documentElement.toprettyxml(indent="\t")) fout.close()
def output_json(enumerator, filename, output_condensed=False, output_rates=True, condense_options={}): """ JSON-based output schema intended to be easily machine parsable. Uses python's JSON serialization libraries. """ def serializeComplex(complex): temp_strands = [] for strand in complex.strands: temp_strands.append(strand.name) return { 'name': complex.name, 'strands': temp_strands, 'structure': complex.structure, 'dot-paren': complex.dot_paren_string(), 'dot-paren-full': complex.dot_paren_string_full(), } def serializeReaction(reaction): # temp_reactants = [] # for reactant in reaction.reactants: # temp_reactants.append(reactant.name) # temp_products = [] # for product in reaction.products: # temp_products.append(product.name) reactants = map(str, reaction.reactants) products = map(str, reaction.products) return { "name": reaction.name, "reactants": reactants, # temp_reactants, "products": products # temp_products } def serializeDomain(domain): temp_domain = { "name": domain.name, "length": domain.length, "is_complement": domain.is_complement } # temp_domain = {} # temp_domain['name'] = domain.name # temp_domain['length'] = domain.length # temp_domain['is_complement'] = domain.is_complement if domain.sequence is not None: temp_domain['sequence'] = domain.sequence return temp_domain def serializeStrand(strand): return { "name": strand.name, "domains": [domain.name for domain in strand.domains] } # temp_strand = {} # temp_strand['name'] = strand.name # temp_domains = [] # for domain in strand.domains: # temp_domains.append(domain.name) # temp_strand['domains'] = temp_domains # return temp_strand def serializeRestingState(resting_state): return { "name": str(resting_state), "complexes": [complex.name for complex in resting_state.complexes] } # temp_resting_state = {} # temp_complexes = [] # for complex in resting_state.complexes: # temp_complexes.append(complex.name) # temp_resting_state['name'] = resting_state.name # temp_resting_state['complexes'] = temp_complexes # return temp_resting_state object_out = {} object_out['domains'] = map(serializeDomain, enumerator.domains) object_out['strands'] = map(serializeStrand, enumerator.strands) object_out['resting_complexes'] = map(serializeComplex, enumerator.resting_complexes) object_out['transient_complexes'] = map(serializeComplex, enumerator.transient_complexes) object_out['resting_states'] = map(serializeRestingState, enumerator.resting_states) object_out['initial_complexes'] = map(serializeComplex, enumerator.initial_complexes) object_out['reactions'] = map(serializeReaction, enumerator.reactions) if output_condensed: condensed = condense_resting_states(enumerator, **condense_options) object_out['condensed_reactions'] = map(serializeReaction, condensed['reactions']) fout = open(filename, 'w') json.dump(object_out, fout, indent=4) fout.close()
def output_kernel(enumerator, filename, output_condensed=False, output_rates=True, condense_options={}): """ Text-based output using the Pepper Intermediate Language (PIL) """ def write_complex(output_file, complex): params = "" if complex.concentration is not None: params = "[@ %g %sM] " % utils.format_si(complex.concentration) output_file.write( str(complex) + params + " = " + complex.kernel_string() + "\n") def write_reaction(output_file, reaction): if output_rates: rate_units = "/M" * (reaction.arity[0] - 1) + "/s" rate_const = "[%f %s]" % (reaction.rate(), rate_units) else: rate_const = "" reac_string_list = [rate_const, reaction.kernel_string()] reac_string = ' '.join(reac_string_list) reactants = map(str, reaction.reactants) products = map(str, reaction.products) prefix = " ".join([ "# ", str(reaction), " + ".join(reactants), "->", " + ".join(products) ]) output_file.write(prefix + "\n" + reac_string + "\n") complexes = enumerator.complexes transient_complexes = enumerator.transient_complexes resting_complexes = enumerator.resting_complexes reactions = enumerator.reactions resting_states = enumerator.resting_states output_file = open(filename, 'w') output_file.write("###### Enumerated Output ######\n") output_file.write("\n# Domains \n") def seq(dom): if (dom.sequence is not None): return dom.sequence else: return "N" * len(dom) for domain in utils.natural_sort(enumerator.domains): if (not domain.is_complement): output_file.write("sequence " + domain.name + " = " + seq(domain) + " : " + str(domain.length) + "\n") output_file.write("\n# Strands \n") for strand in utils.natural_sort(enumerator.strands): output_file.write("strand " + strand.name + " = " + " ".join(map(lambda dom: dom.name, strand.domains)) + "\n") output_file.write("\n# Resting-state Complexes \n") for complex in utils.natural_sort(resting_complexes): write_complex(output_file, complex) if (output_condensed): condensed = condense_resting_states(enumerator, **condense_options) output_file.write("\n# Resting-state sets \n") resting_states = condensed['resting_states'] for resting_state in utils.natural_sort(resting_states): output_file.write("# state " + str(resting_state) + " = { " + " ".join(map(str, resting_state.complexes)) + " }\n") output_file.write("\n# Condensed Reactions \n") new_reactions = condensed['reactions'] for reaction in sorted(new_reactions): write_reaction(output_file, reaction) else: output_file.write("\n# Transient Complexes \n") for complex in utils.natural_sort(transient_complexes): write_complex(output_file, complex) output_file.write("\n# Detailed Reactions \n") for reaction in sorted(reactions): # utils.natural_sort(reactions): write_reaction(output_file, reaction) output_file.close()
def output_legacy(enumerator, filename, output_condensed=False, output_rates=False, condense_options={}): """ Legacy text-based output scheme similar to that used in the original enumerator. Designed to be simultaneously parsable and human-readable. Supports output of condensed graph in addition to the full graph. Does not support strands. """ def write_complex(output_file, complex): output_file.write(str(complex) + "\n") names = [] for strand in complex.strands: names.append(" ".join(map(str, strand.domains))) strands_string = " + ".join(names) output_file.write(strands_string + "\n") output_file.write(str(complex.dot_paren_string()) + "\n") output_file.write("\n") def write_reaction(output_file, reaction): reactants = map(str, reaction.reactants) products = map(str, reaction.products) reac_string_list = [ " + ".join(reactants), "->", " + ".join(products), "\n" ] reac_string = ' '.join(reac_string_list) output_file.write(reac_string) # def write_reaction(output_file,reaction): # reactants = reaction.reactants # products = reaction.products # reac_string_list = [reactants[0].name] # for reactant in reactants[1:]: # reac_string_list.append(" + " + reactant.name) # reac_string_list.append(" -> ") # reac_string_list.append(products[0].name) # for product in products[1:]: # reac_string_list.append(" + " + product.name) # reac_string_list.append("\n") # reac_string = ''.join(reac_string_list) # output_file.write(reac_string) complexes = enumerator.complexes transient_complexes = enumerator.transient_complexes resting_complexes = enumerator.resting_complexes reactions = enumerator.reactions resting_states = enumerator.resting_states output_file = open(filename, 'w') output_file.write("###### Enumerated Output ######\n") output_file.write("\n\n# Domains \n") for domain in sorted(enumerator.domains): if (not domain.is_complement): output_file.write("sequence " + domain.name + " = : " + str(domain.length) + "\n") output_file.write("\n\n# End-state Complexes \n") for complex in sorted(resting_complexes): write_complex(output_file, complex) # Not part of the original output; omitting # output_file.write("###############################\n") # output_file.write("\n\n# Resting-state sets \n") # for resting_state in sorted(resting_states): # output_file.write("state " + resting_state.name + " = : ") # output_file.write(str(resting_state.complexes[0])) # for complex in resting_state.complexes[1:]: # output_file.write(" %s" % complex) # output_file.write("\n") output_file.write("###############################\n") output_file.write("\n\n# Fast (Transition) Complexes \n") for complex in sorted(transient_complexes): write_complex(output_file, complex) output_file.write("###############################\n") output_file.write("\n\n# Reactions \n") for reaction in sorted(reactions): write_reaction(output_file, reaction) if (output_condensed): output_file.write("###############################\n") output_file.write("\n\n# Condensed Reactions \n") condensed = condense_resting_states(enumerator, **condense_options) new_reactions = condensed['reactions'] for reaction in sorted(new_reactions): write_reaction(output_file, reaction) output_file.close()
def test_under_the_hood3(self): # Here we have a test example that illustrates the condese function of the # enumerator. The example uses complexes from the Soloveichik scheme, # reaction B+B->B. Note that some of these complexes are commented out! # It turns out that the enumerator does the correct thing, and the test is # kind of pointless. But it is nice to understand what is going on under the # hood of the condese function, and what problems you might find when # looking at the return statements. domstring = """ sequence a : 6 sequence x : 15 sequence b : 6 sequence y : 15 B : y a x b . . . . #C_1_ : #x b a #. . . #C_2_ : #y a x b + a* y* b* #( ( . . + ) ) . C_3_ : x b a + x b y a + b* x* a* b* x* a* ( ( ( + ( ( . . + ) ) ) ) ) . """ solution = self._TestTube_from_DOM(domstring) #self.args.reject_remote = False self.args.MAX_COMPLEX_SIZE = 4 self.args.MAX_COMPLEX_COUNT = 9 self.args.MAX_REACTION_COUNT = 10 self.args.REJECT_REMOTE = False self.args.ignore_branch_4way = True peppercorn = ne.TestTubePeppercornIO(testtube=solution, pargs=self.args) self.assertIsInstance(pep.enumerator, Enumerator) pep.enumerate() ########################### # Get full output CRN reactions = pep.enumerator.reactions count = 0 ks_t_cp = dict() for r in sorted(reactions): print map(str, r.reactants), '->', map(str, r.products) print r.kernel_string() print '--' ########################### # Get condensed output CRN condensed = condense_resting_states(pep.enumerator) reactions = condensed['reactions'] for r in sorted(reactions): print map(str, map(lambda x: x.complexes, r.reactants)), '->', print map(str, map(lambda x: x.complexes, r.products)) print r.kernel_string() for rs in r.reactants : if len(rs.complexes) == 1 : print rs.complexes[0], else : print 'rs' + str(rs), print '->', for rs in r.products: if len(rs.complexes) == 1 : print rs.complexes[0], else : print 'rs' + str(rs), print ## INCORRECT (misses resting state) for r in condensed['resting_states']: print 'r', r ## CORRECT (frozensets) for m in condensed['resting_state_map']: print 'm', m ## CORRECT (all species) for t in condensed['resting_state_targets']: print 't', t ## CORRECT (all resting states) for s in condensed['complexes_to_resting_states']: print 's', s