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;
}
