@@ -49,37 +49,35 @@ object Main extends ZCaseApp[Config] {
4949 nonredundantRDFWriter <- createStreamRDF(nonredundantOutputStream)
5050 redundantRDFWriter <- createStreamRDF(redundantOutputStream)
5151 } yield (nonredundantRDFWriter, redundantRDFWriter)
52- val program = streamsManaged.use {
53- case (nonredundantRDFWriter, redundantRDFWriter) =>
54- for {
55- fileProperties <- config.propertiesFile.map(readPropertiesFile).getOrElse(ZIO .succeed(Set .empty[OWLObjectProperty ]))
56- specifiedProperties = fileProperties ++ config.property.map(prop => df.getOWLObjectProperty(IRI .create(prop))).to(Set )
57- manager <- ZIO .effect(OWLManager .createOWLOntologyManager())
58- ontology <- ZIO .effect(manager.loadOntologyFromOntologyDocument(ontologyFile))
59- whelkOntology = Bridge .ontologyToAxioms(ontology)
60- _ <- ZIO .effectTotal(scribe.info(" Running reasoner" ))
61- whelk = Reasoner .assert(whelkOntology)
62- _ <- ZIO .effectTotal(scribe.info(" Done running reasoner" ))
63- _ <- (effectBlockingIO(
64- nonredundantRDFWriter.triple(Triple .create(NodeFactory .createBlankNode(" nonredundant" ), RDFType , OWLOntology ))) *>
65- effectBlockingIO(redundantRDFWriter.triple(Triple .create(NodeFactory .createBlankNode(" redundant" ), RDFType , OWLOntology ))))
66- .when(config.mode == OWLMode )
67- start <- ZIO .effectTotal(System .currentTimeMillis())
68- classes = allClasses(ontology)
69- classesTasks = classes.map(c => Task (processSuperclasses(c, whelk, config)))
70- restrictions = extractAllRestrictions(ontology, specifiedProperties)
71- restrictionsTasks = restrictions.map(r => Task (processRestriction(r, whelk, config.mode)))
72- allTasks = classesTasks ++ restrictionsTasks
73- processed = allTasks.mapParallelUnordered(JRuntime .getRuntime.availableProcessors)(identity)
74- monixTask = processed.foreachL {
75- case TriplesGroup (nonredundant, redundant) =>
76- nonredundant.foreach(nonredundantRDFWriter.triple)
77- redundant.foreach(redundantRDFWriter.triple)
78- }
79- _ <- IO .fromTask(monixTask)
80- stop <- ZIO .effectTotal(System .currentTimeMillis())
81- _ <- ZIO .effectTotal(scribe.info(s " Computed relations in ${(stop - start) / 1000.0 }s " ))
82- } yield ()
52+ val program = streamsManaged.use { case (nonredundantRDFWriter, redundantRDFWriter) =>
53+ for {
54+ fileProperties <- config.propertiesFile.map(readPropertiesFile).getOrElse(ZIO .succeed(Set .empty[OWLObjectProperty ]))
55+ specifiedProperties = fileProperties ++ config.property.map(prop => df.getOWLObjectProperty(IRI .create(prop))).to(Set )
56+ manager <- ZIO .effect(OWLManager .createOWLOntologyManager())
57+ ontology <- ZIO .effect(manager.loadOntologyFromOntologyDocument(ontologyFile))
58+ whelkOntology = Bridge .ontologyToAxioms(ontology)
59+ _ <- ZIO .effectTotal(scribe.info(" Running reasoner" ))
60+ whelk = Reasoner .assert(whelkOntology)
61+ _ <- ZIO .effectTotal(scribe.info(" Done running reasoner" ))
62+ _ <- (effectBlockingIO(
63+ nonredundantRDFWriter.triple(Triple .create(NodeFactory .createBlankNode(" nonredundant" ), RDFType , OWLOntology ))) *>
64+ effectBlockingIO(redundantRDFWriter.triple(Triple .create(NodeFactory .createBlankNode(" redundant" ), RDFType , OWLOntology ))))
65+ .when(config.mode == OWLMode )
66+ start <- ZIO .effectTotal(System .currentTimeMillis())
67+ classes = allClasses(ontology)
68+ classesTasks = classes.map(c => Task (processSuperclasses(c, whelk, config)))
69+ restrictions = extractAllRestrictions(ontology, specifiedProperties)
70+ restrictionsTasks = restrictions.map(r => Task (processRestriction(r, whelk, config.mode)))
71+ allTasks = classesTasks ++ restrictionsTasks
72+ processed = allTasks.mapParallelUnordered(JRuntime .getRuntime.availableProcessors)(identity)
73+ monixTask = processed.foreachL { case TriplesGroup (nonredundant, redundant) =>
74+ nonredundant.foreach(nonredundantRDFWriter.triple)
75+ redundant.foreach(redundantRDFWriter.triple)
76+ }
77+ _ <- IO .fromTask(monixTask)
78+ stop <- ZIO .effectTotal(System .currentTimeMillis())
79+ _ <- ZIO .effectTotal(scribe.info(s " Computed relations in ${(stop - start) / 1000.0 }s " ))
80+ } yield ()
8381 }
8482 program.exitCode
8583 }
@@ -98,7 +96,8 @@ object Main extends ZCaseApp[Config] {
9896 }
9997 }(stream => ZIO .effectTotal(stream.finish()))
10098
101- def allClasses (ont : OWLOntology ): Observable [OWLClass ] = Observable .fromIterable(ont.getClassesInSignature(Imports .INCLUDED ).asScala.to(Set ) - OWLThing - OWLNothing )
99+ def allClasses (ont : OWLOntology ): Observable [OWLClass ] =
100+ Observable .fromIterable(ont.getClassesInSignature(Imports .INCLUDED ).asScala.to(Set ) - OWLThing - OWLNothing )
102101
103102 def processSuperclasses (cls : OWLClass , whelk : ReasonerState , config : Config ): TriplesGroup = {
104103 val subject = NodeFactory .createURI(cls.getIRI.toString)
@@ -110,19 +109,21 @@ object Main extends ZCaseApp[Config] {
110109 val (equivs, directSuperclasses) = whelk.directlySubsumedBy(concept)
111110 val adjustedEquivs = if (config.reflexiveSubclasses.bool) equivs + concept else equivs - concept
112111 val directSuperclassTriples = directSuperclasses.map(c => Triple .create(subject, RDFSSubClassOf , NodeFactory .createURI(c.id)))
113- val equivalentClassTriples = if (config.equivalenceAsSubclass.bool)
114- adjustedEquivs.map(c => Triple .create(subject, RDFSSubClassOf , NodeFactory .createURI(c.id)))
115- else
116- adjustedEquivs.map(c => Triple .create(subject, OWLEquivalentClass , NodeFactory .createURI(c.id)))
112+ val equivalentClassTriples =
113+ if (config.equivalenceAsSubclass.bool)
114+ adjustedEquivs.map(c => Triple .create(subject, RDFSSubClassOf , NodeFactory .createURI(c.id)))
115+ else
116+ adjustedEquivs.map(c => Triple .create(subject, OWLEquivalentClass , NodeFactory .createURI(c.id)))
117117 val nonredundantTriples = directSuperclassTriples ++ equivalentClassTriples
118118 val adjustedSuperclasses = if (config.reflexiveSubclasses.bool) allSuperclasses + concept else allSuperclasses - concept
119- val redundantTriples = if (config.equivalenceAsSubclass.bool)
120- adjustedSuperclasses.map(c => Triple .create(subject, RDFSSubClassOf , NodeFactory .createURI(c.id)))
121- else {
122- val superclassesMinusEquiv = adjustedSuperclasses -- adjustedEquivs
123- superclassesMinusEquiv.map(c => Triple .create(subject, RDFSSubClassOf , NodeFactory .createURI(c.id))) ++
124- equivalentClassTriples
125- }
119+ val redundantTriples =
120+ if (config.equivalenceAsSubclass.bool)
121+ adjustedSuperclasses.map(c => Triple .create(subject, RDFSSubClassOf , NodeFactory .createURI(c.id)))
122+ else {
123+ val superclassesMinusEquiv = adjustedSuperclasses -- adjustedEquivs
124+ superclassesMinusEquiv.map(c => Triple .create(subject, RDFSSubClassOf , NodeFactory .createURI(c.id))) ++
125+ equivalentClassTriples
126+ }
126127 TriplesGroup (nonredundantTriples, redundantTriples)
127128 }
128129 }
0 commit comments