Ontology MessageConversions::ontologyFromMessage(const semantic_map_msgs:: Ontology& message) const { Ontology ontology(message.ns); for (size_t index = 0; index < message.imports.size(); ++index) ontology.addImport(message.imports[index]); for (size_t index = 0; index < message.ns_prefixes.size(); ++index) ontology.addPrefix(prefixFromMessage(message.ns_prefixes[index])); return ontology; }
void run(Factory *f) { ontology::Ontology ontology(f, verbose); // Starting code Generation std::set<std::string> cppNameSpaces; for ( auto const& klassMapItem: ontology.classUri2Ptr()) { // created directory if needed createDirectory(Klass(*klassMapItem.second).genCppNameSpaceInclusionPath()); cppNameSpaces.insert(Klass(*klassMapItem.second).genCppNameSpace()); Klass(*klassMapItem.second).generateInterfaceDeclaration(); Klass(*klassMapItem.second).generateInterfaceDefinition(); Klass(*klassMapItem.second).generateDeclaration(); Klass(*klassMapItem.second).generateDefinition(); } // Generate all TypesInfo generateRdfTypeInfo(ontology); // Generate all inclusions files for ( const std::string& cppNameSpace : cppNameSpaces ) { std::ofstream ofs; createFile(Klass::outdir + "/" + cppNameSpace + "/" + cppNameSpace + ".h", &ofs); generateCodeProtectorBegin(ofs, cppNameSpace, cppNameSpace); for ( auto const& klassMapItem: ontology.classUri2Ptr()) { if ( Klass(*klassMapItem.second).genCppNameSpace() == cppNameSpace ) { const Klass& cls = *klassMapItem.second; ofs << "#include <" << cls.genCppNameSpaceInclusionPath() << "/" << klassMapItem.second->prettyIRIName() << ".h" << ">" << std::endl; } } ofs << std::endl; generateCodeProtectorEnd(ofs, cppNameSpace, cppNameSpace); } // Generate all in one cpp file if ( generateAllInOne ) { std::ofstream ofs; createFile(RdfsEntity::outdir + "/AllInOne.cpp", &ofs); addBoilerPlate(ofs); ofs << std::endl; ofs << "#include \"RdfTypeInfo.cpp\"" << std::endl; for ( auto const& klassMapItem: ontology.classUri2Ptr()) { const Klass& cls = *klassMapItem.second; ofs << "#include \"" << cls.genCppNameSpaceInclusionPath() << "/I" << klassMapItem.second->prettyIRIName() << ".cpp" << "\"" << std::endl; ofs << "#include \"" << cls.genCppNameSpaceInclusionPath() << "/" << klassMapItem.second->prettyIRIName() << ".cpp" << "\"" << std::endl; } ofs << std::endl; } }
ModelGenerationResult test(std::string p_ontPath, std::vector<std::string>* p_requiredModelElements, bool warmUp, bool global, bool verbose, int maxHopCount = 3, int maxStepCount = 10, std::function<void(supplementary::ClingWrapper *asp)> lambda = nullptr) { ModelGenerationResult result; std::vector<std::string> entities; std::vector<std::shared_ptr<supplementary::External>> externals; std::chrono::time_point<std::chrono::system_clock> start, end, startOntologyRead, endOntologyRead, startOntologyReasoner, endOntologyReasoner, startOntologyToASP, endOntologyToASP, startAsp, endAsp; // Initializing ASP supplementary::ClingWrapper asp; if (this->testRepresentations) { asp.addKnowledgeFile(path + "/asp/transformation/computing.lp"); } else { asp.addKnowledgeFile(path + "/asp/informationProcessing/processing.lp"); asp.addKnowledgeFile(path + "/asp/informationProcessing/searchBottomUp.lp"); if (global) asp.addKnowledgeFile(path + "/asp/informationProcessing/globalOptimization.lp"); else asp.addKnowledgeFile(path + "/asp/informationProcessing/localOptimization.lp"); } asp.setNoWarnings(true); asp.init(); // Initializing OwlAPI ice::OntologyInterface ontology(path + "/java/lib/"); ontology.setLogLevel(ice::LogLevel::Error); ontology.addIRIMapper(path + "/ontology/"); ontology.loadOntology(p_ontPath); start = std::chrono::system_clock::now(); // Load ontology startOntologyRead = std::chrono::system_clock::now(); ontology.loadOntologies(); endOntologyRead = std::chrono::system_clock::now(); // Reasoning ontology startOntologyReasoner = std::chrono::system_clock::now(); ontology.initReasoner(true); endOntologyReasoner = std::chrono::system_clock::now(); // Ontology 2 ASP // if (false == warmUp) // std::cout << "Ontology 2 ASP" << std::endl; startOntologyToASP = std::chrono::system_clock::now(); const char* infoStructure = ontology.readInformationStructureAsASP(); //this->entityTypeMap.clear(); std::string programPart = "ontology" + 1; std::stringstream ss; std::string item; ss << infoStructure; // delete infoStructure; while (std::getline(ss, item, '\n')) { if (item.find("entity(") == 0) { int index1 = item.find(","); int index2 = item.find(")"); auto entity = item.substr(7, index1 - 7); auto entityType = item.substr(index1 + 1, index2 - index1 - 1); // this->entityTypeMap[entity] = entityType; } if (std::find(entities.begin(), entities.end(), item) == entities.end()) { entities.push_back(item); asp.add(programPart, {}, item); } } if (false == this->testRepresentations) { auto ontSystems = ontology.getSystems(); for (auto ontSystem : *ontSystems) { std::string aspStr = ontology.toShortIri(ontSystem); auto external = asp.getExternal("system", {Gringo::Value(aspStr), "default"}, "system", {Gringo::Value(aspStr)}, true); auto nodes = ontology.readNodesAndIROsAsASP(ontSystem); std::vector<const char*>* types = nodes->at(0); std::vector<const char*>* names = nodes->at(1); std::vector<const char*>* strings = nodes->at(2); std::vector<const char*>* aspStrings = nodes->at(3); std::vector<const char*>* cppStrings = nodes->at(4); for (int i = 0; i < names->size(); ++i) { const char* name = names->at(i); const char* elementStr = strings->at(i); const char* aspStr = aspStrings->at(i); const char* cppStr = cppStrings->at(i); const char* typeStr = types->at(i); ice::ASPElementType type; if (typeStr == nullptr) { delete name; delete elementStr; delete aspStr; delete cppStr; delete typeStr; continue; } else if (std::strcmp(typeStr, "COMPUTATION_NODE") == 0) { type = ice::ASPElementType::ASP_COMPUTATION_NODE; } else if (std::strcmp(typeStr, "SOURCE_NODE") == 0) { type = ice::ASPElementType::ASP_SOURCE_NODE; } else if (std::strcmp(typeStr, "REQUIRED_STREAM") == 0) { type = ice::ASPElementType::ASP_REQUIRED_STREAM; } else if (std::strcmp(typeStr, "MAP_NODE") == 0) { type = ice::ASPElementType::ASP_MAP_NODE; } else if (std::strcmp(typeStr, "IRO_NODE") == 0) { type = ice::ASPElementType::ASP_IRO_NODE; } else if (std::strcmp(typeStr, "REQUIRED_MAP") == 0) { type = ice::ASPElementType::ASP_REQUIRED_MAP; } else { delete name; delete elementStr; delete aspStr; delete cppStr; delete typeStr; continue; } auto external = asp.getExternal(elementStr); externals.push_back(external); switch (type) { case ice::ASPElementType::ASP_COMPUTATION_NODE: case ice::ASPElementType::ASP_SOURCE_NODE: case ice::ASPElementType::ASP_MAP_NODE: case ice::ASPElementType::ASP_IRO_NODE: external->assign(true); break; default: external->assign(true); break; } asp.add(name, {}, aspStr); asp.ground(name, {}); delete name; delete elementStr; delete aspStr; delete cppStr; delete typeStr; } delete types; delete names; delete strings; delete aspStrings; delete cppStrings; // delete ontSystem; } } endOntologyToASP = std::chrono::system_clock::now(); if (warmUp) { externals.clear(); return result; } if (lambda != nullptr) lambda(&asp); // Grounding // std::cout << "ASP ground call" << std::endl; startAsp = std::chrono::system_clock::now(); asp.ground(programPart, {}); auto lastQuery = asp.getExternal("query", {1}, "query", {1, maxHopCount, maxStepCount}, true); asp.ground("query", {1}); // Solving // std::cout << "ASP solving" << std::endl; auto solveResult = asp.solve(); // std::cout << "ASP done" << std::endl; endAsp = std::chrono::system_clock::now(); end = std::chrono::system_clock::now(); result.successful = true; result.totalTime = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count(); result.ontologyReadTime = std::chrono::duration_cast<std::chrono::milliseconds>(endOntologyRead - startOntologyRead).count(); result.ontologyReasonerTime = std::chrono::duration_cast<std::chrono::milliseconds>( endOntologyReasoner - startOntologyReasoner).count(); result.ontologyToASPTime = std::chrono::duration_cast<std::chrono::milliseconds>( endOntologyToASP - startOntologyToASP).count(); result.aspSolvingTime = asp.getSolvingTime(); result.aspGroundingTime = std::chrono::duration_cast<std::chrono::milliseconds>(endAsp - startAsp).count() - result.aspSolvingTime; result.aspSatTime = asp.getSatTime(); result.aspUnsatTime = asp.getUnsatTime(); result.aspModelCount = asp.getModelCount(); result.aspAtomCount = asp.getAtomCount(); result.aspBodiesCount = asp.getBodiesCount(); result.aspAuxAtomCount = asp.getAuxAtomsCount(); if (solveResult == Gringo::SolveResult::SAT) { if (verbose) { asp.printLastModel(false); ofstream file; file.open("/tmp/tut.txt"); file << asp.toStringLastModel(true); file.close(); } bool first = true; for (auto toCheck : *p_requiredModelElements) { auto value = supplementary::ClingWrapper::stringToValue(toCheck.c_str()); std::string name = *value.name(); if (false == asp.query(name, value.args())) { if (first) { if (false == verbose) std::cout << std::endl << asp.toStringLastModel(false) << std::endl; first = false; } value.print(std::cout); std::cout << std::endl; result.successful = false; } } } else { std::cout << "UNSAT" << std::endl; result.successful = false; } externals.clear(); if (verbose) result.print(); return result; }