def test_pretty_print(self): """Test printing cuds objects in a human readable way.""" c, p1, p2, p3, n1, n2, s1 = get_test_city() px = city.Person() c.add(px, rel=city.encloses) f = io.StringIO() pretty_print(c, file=f) self.maxDiff = 5000 self.assertEqual( f.getvalue(), "\n".join([ "- Cuds object named <Freiburg>:", " uuid: %s" % c.uid, " type: city.City", " superclasses: city.City, city.GeographicalPlace, " + "city.PopulatedPlace, cuba.Entity", " values: coordinates: [1 2]", " description: ", " To Be Determined", "", " |_Relationship city.encloses:", " | - city.Person cuds object named <John Smith>:", " | uuid: %s" % px.uid, " | age: 25", " |_Relationship city.hasInhabitant:", " | - city.Citizen cuds object named <Carlos>:", " | . uuid: %s" % p2.uid, " | . age: 25", " | . |_Relationship city.hasChild:", " | . - city.Citizen cuds object named <Maria>:", " | . uuid: %s" % p3.uid, " | . age: 25", " | - city.Citizen cuds object named <Maria>:", " | . uuid: %s" % p3.uid, " | . (already printed)", " | - city.Citizen cuds object named <Rainer>:", " | uuid: %s" % p1.uid, " | age: 25", " | |_Relationship city.hasChild:", " | - city.Citizen cuds object named <Maria>:", " | uuid: %s" % p3.uid, " | (already printed)", " |_Relationship city.hasPart:", " - city.Neighborhood cuds object named <St. Georgen>:", " . uuid: %s" % n2.uid, " . coordinates: [3 4]", " . |_Relationship city.hasPart:", " . - city.Street cuds object named <Lange Straße>:", " . uuid: %s" % s1.uid, " . coordinates: [4 5]", " . |_Relationship city.hasInhabitant:", " . - city.Citizen cuds object named <Carlos>:", " . . uuid: %s" % p2.uid, " . . (already printed)", " . - city.Citizen cuds object named <Maria>:", " . uuid: %s" % p3.uid, " . (already printed)", " - city.Neighborhood cuds object named <Zähringen>:", " uuid: %s" % n1.uid, " coordinates: [2 3]", " |_Relationship city.hasPart:", " - city.Street cuds object named <Lange Straße>:", " uuid: %s" % s1.uid, " (already printed)", "" ]))
def parseResults(self, jsonResults, root_cuds_object, synEntityToCUDSmap): """Given the results of a remote simulation in JSON form, this function parses them in to CUDS objects. Arguments: jsonResults -- Remote simulation results root_cuds_object -- Root CUDS object representing input data synEntityToCUDSmap -- Dictionary which stores a mapping between syntacitc (key) output representation that engine understands and the concrete CUDS instance that the it is associated with """ # TODO - Should we expect the originally input CUDS objects to contain # placeholders for the output data, or do we need to generate and append # new CUDS objects for them? if jsonResults is None: print("No valid simulation results detected, session has failed.") self.successful = False else: # Use the CUDSAdaptor to fill CUDS objects with results CUDSAdaptor.toCUDS(jsonResults, synEntityToCUDSmap) print( "CUDS objects have now been populated with simulation results." ) self.successful = True results = [ res_dict[CUDS_BIND] for res_dict in list(synEntityToCUDSmap.values()) ] if results is not None: if len(results) == 0: print("Could not find OUTPUT_RESULTS instance in CUDS") else: outputs_file = open("output_results.txt", "w") for result_item in results: pretty_print(result_item, outputs_file) outputs_file.close() print( "CUDS representation of results written to: ./output_results.txt" ) else: print("Could not find CUDS results instances") # Mark as complete self.executed = True
def _run(self, root_cuds_object): """Runs the AgentBridge class to execute a remote Kinetics simulation. Note that once CUDS data is passed into this method, it should be considered READ-ONLY by any calling code outside this wrapper. Arguments: root_cuds_object -- Root CUDS object representing input data """ print("") print("===== Start: KineticsSession =====") # Save a copy of the CUDS inputs inputs_file = open("input_results.txt", "w") pretty_print(root_cuds_object, inputs_file) inputs_file.close() print("CUDS representation of inputs written to: ./input_results.txt") # Determine template from root CUDS object simulation_template = self._engine.determineTemplate( root_cuds_object, self.modelFlag) # Use the engine to generate JSON inputs jsonInputs, synEntityToCUDSmap = self._engine.generateJSON( root_cuds_object, simulation_template) # Run remote simulation (via AgentBridge) agentBridge = AgentBridge() jsonResult = agentBridge.runJob(json.dumps(jsonInputs)) # Pass results (in JSON form) back to the engine for parsing self._engine.parseResults(jsonResult, root_cuds_object, synEntityToCUDSmap) print("===== End: KineticsSession =====") print("")
fd.add(QE.Volume(value = 33, unit = "au^3")) sim2.add(QE.TotalEnergy(value = -432, unit = "Ry")) with qeSession(root) as session: # Adds session to wrapper quantum_espresso_wrapper = QE.QEWrapper(session = session) # Adds simulation to wrapper sim = quantum_espresso_wrapper.add(sim) # pretty_print(sim) # Creates a qeUtil object and creates an input file based off of the simulation print("Running calculation...") # Runs the simulation # pretty_print(quantum_espresso_wrapper) # pretty_print(quantum_espresso_wrapper) quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "pw.x", calculation_type = "scf", root = root) # quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "pw.x", calculation_type = "bands") # quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "bands.x", calculation_type = "") # quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "pw.x", calculation_type = "relax", IONS = {'ion_dynamics': "'bfgs'"}) # quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "pw.x", calculation_type = "scf", SYSTEM = {'occupations': "'tetrahedra'"}) # quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "dos.x", calculation_type = "") quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "pp.x", calculation_type = 9, PLOT = {"output_format": 6}) # quantum_espresso_wrapper.session._run(simulation = [sim, sim2], prefix = 'si', command_type = "ev.x", calculation_type = '1') # quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "ph.x", calculation_type = "") # quantum_espresso_wrapper.session._run(simulation = sim, prefix = "si", command_type = "plotband.x", calculation_type = "", params = {'Input file': 'si.bands.dat', 'Emin, Emax': "-6 17", "gnuplot": "gnuplot", "ps": "si.bands.ps", "Efermi": "0", "deltaE": "5 0"}) pretty_print(sim) # pretty_print(sim2) # print("Results: ") # Pretty prints the simulation
# THIS ALLOWS US TO SHOW THAT OSP-CORE CAN IMPORT ANY RDF DATA, # AND NOT ONLY DATA THAT WAS PREVIOUSLY EXPORTED BY OSP CORE! # THIS IS NOTHING THAT YOU AS A USER WOULD EVER HAVE TO DO. print("Replace UUID in turtle file") with open("test.rdf") as f1: with open("test2.rdf", "w", encoding="utf-8") as f2: for line in f1: match = uuid_re.match(line) if match: uid = uuid.UUID(match[2]) line = line.replace( match[1], "http://city.com/" + session._registry.get(uid).name, ) print("\t", line, end="") print(line, end="", file=f2) # Create new session and import file with SqliteSession(path="test2.db") as session: w = city.CityWrapper(session=session) # wrapper will be skipped for export import_cuds("test2.rdf", format="ttl", session=session) w.add(session.load_from_iri(URIRef("http://city.com/Freiburg")).one()) print("Imported data:") pretty_print(w) os.remove("test.db") os.remove("test2.db") os.remove("test.rdf") os.remove("test2.rdf")
print("Connect to DB via transport session") with TransportSessionClient( SqliteSession, "ws://localhost:8688", path="test.db" ) as session: wrapper = city.CityWrapper(session=session) wrapper.add(c) wrapper.session.commit() print("Reconnect and check if data is still there") with TransportSessionClient( SqliteSession, "ws://localhost:8688", path="test.db" ) as session: wrapper = city.CityWrapper(session=session) c = wrapper.get(oclass=city.City)[0] pretty_print(c) print("Reconnect and make some changes") with TransportSessionClient( SqliteSession, "ws://localhost:8688", path="test.db" ) as session: wrapper = city.CityWrapper(session=session) c = wrapper.get(oclass=city.City)[0] c.name = "Paris" wrapper.session.commit() print("Reconnect and check if changes were successful") with TransportSessionClient( SqliteSession, "ws://localhost:8688", path="test.db" ) as session: wrapper = city.CityWrapper(session=session)
"""This code runs on the wrapper under `../osp/wrappers/simple_simulation`""" import numpy as np from osp.core.namespaces import simple_ontology from osp.core.utils import pretty_print from osp.wrappers.simple_simulation import SimpleSimulationSession m = simple_ontology.Material() for i in range(3): a = m.add(simple_ontology.Atom()) a.add(simple_ontology.Position(value=[i, i, i], unit="m"), simple_ontology.Velocity(value=np.random.random(3), unit="m/s")) # Run a simulation with SimpleSimulationSession() as session: w = simple_ontology.Wrapper(session=session) m = w.add(m) w.session.run() pretty_print(m) for atom in m.get(rel=simple_ontology.hasPart): atom.get(oclass=simple_ontology.Velocity)[0].value = [0, 0, 0] w.session.run() pretty_print(m)
# create rectangle rec = Rectangle(temp_dir, values={ 'x': 20, 'y': 10, 'z': 150, 'filling_fraction': 0.5, 'resolution': 1 }, units={ 'lengths': "mm", 'resolution': "mm" }, session=session) wrapper.add(rec.get_model(), rel=emmo.hasPart) print("Run the GMSH computation:") session.run() # get the entity with the computed output computation = wrapper.get(oclass=emmo.MeshGeneration) # pretty print the output print("Generated meta data:") pretty_print(computation[0]) # print information of generated .stl-file print(f"You can now review the files under {temp_dir}")
# We can go through inverse relationships print(onto.get(rel=city.isPartOf)[0].name + ' is my city!') # Working with a DB-wrapper: Store in the DB. with SqlAlchemyWrapperSession(postgres_url) as session: wrapper = city.CityWrapper(session=session) wrapper.add(emmo_town) session.commit() # Load from the DB. with SqlAlchemyWrapperSession(postgres_url) as db_session: db_wrapper = city.CityWrapper(session=db_session) db_emmo_town = db_wrapper.get(emmo_town.uid) print("The database contains the following information about the city:") pretty_print(db_emmo_town) # Working with a Simulation wrapper with SimDummySession() as sim_session: sim_wrapper = city.CitySimWrapper(numSteps=1, session=sim_session) new_inhabitant = city.Person(age=31, name="Peter") sim_emmo_town, _ = sim_wrapper.add(db_emmo_town, new_inhabitant) sim_session.run() print("The city has a new inhabitant:") pretty_print(sim_emmo_town.get(new_inhabitant.uid)) # update database db_wrapper.update(sim_emmo_town) db_session.commit()
"""An example explaining the use of the pretty_print function.""" # Please install the city ontology: $pico install city from osp.core.namespaces import city from osp.core.utils import pretty_print # Let's build an EMMO compatible city! emmo_town = city.City(name="EMMO town", coordinates=[42, 42]) emmo_town.add(city.Citizen(name="Emanuele Ghedini"), rel=city.hasInhabitant) emmo_town.add(city.Citizen(name="Adham Hashibon"), rel=city.hasInhabitant) emmo_town.add( city.Citizen(name="Jesper Friis"), city.Citizen(name="Gerhard Goldbeck"), city.Citizen(name="Georg Schmitz"), city.Citizen(name="Anne de Baas"), rel=city.hasInhabitant, ) emmo_town.add(city.Neighborhood(name="Ontology")) emmo_town.add(city.Neighborhood(name="User cases")) ontology_uid = None for neighborhood in emmo_town.get(oclass=city.Neighborhood): if neighborhood.name == "Ontology": ontology_uid = neighborhood.uid neighborhood.add(city.Street(name="Relationships"), rel=city.hasPart) neighborhood.add(city.Street(name="Entities"), rel=city.hasPart) pretty_print(emmo_town)
["H", [1.14720, -0.93530, 0.00160]]] # define the material by specifying atom symbols and cartesian coordinates, atom-by-atom for atom_symbol, atom_coords in atoms_to_add: atom = material.add(cobramm.atom()) atom.add(cobramm.position(vector_value=atom_coords, unit="Ang")) atom.add(cobramm.element_id(atom_symbol=atom_symbol)) # add other physical properties: temperature, pressure, solvent (with commercial name) material.add(cobramm.temperature(scalar_value=300., unit="K")) material.add(cobramm.pressure(scalar_value=1., unit="bar")) material.add(cobramm.solvent(commercial_name="water")) # pretty-print the material so far print("\n") pretty_print(material) print("\n") # now open a new CobrammSession to execute the simulation with CobrammSession() as session: wrapper = cobramm.wrapper(session=session) material_wrapper = wrapper.add(material, rel=cobramm.has_part) # run the simulation material_wrapper.session.run() # extract the spectrum spectrum = material_wrapper.get(oclass=cobramm.spectrum)[0] # pretty-print the final spectrum print("\n")
name='Temporal temperature gradient') temp_start = onto.Temperature(value=2000, unit='K', name='Start temperature') # Declaring and adding plasma composition comp = onto.Composition() arf = onto.MolarFraction(value=1, name='Ar', unit='~') h2f = onto.MolarFraction(value=0, name='H2', unit='~') n2f = onto.MolarFraction(value=0, name='N2', unit='~') comp.add(arf, h2f, n2f, rel=onto.hasPart) # Define the results CUDS Particles_Properties = onto.SizeDistribution(name='Particles') Primaries_Properties = onto.SizeDistribution(name='Primaries') # Define the user case in the wrapper (the high level wrapper) wrapper.add(pressure, accuracy_level, prec, comp, flow_rate, Particles_Properties, Primaries_Properties, temp_grad, temp_start) # Run the session for the defined case ########################################################## session.run() # Get the results Particles_Properties = wrapper.get(Particles_Properties.uid) pretty_print(Particles_Properties) Primaries_Properties = wrapper.get(Primaries_Properties.uid) pretty_print(Primaries_Properties)