Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package it.unibz.krdb.obda.owlrefplatform.core.tboxprocessing;
  
  /*
   * #%L
   * ontop-reformulation-core
   * %%
   * Copyright (C) 2009 - 2014 Free University of Bozen-Bolzano
   * %%
   * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * #L%
  */
 
 
 import java.util.List;
 import java.util.Set;
 
Prune Ontology for redundant assertions based on dependencies
 
 public class SigmaTBoxOptimizer {
 
 	private static final Logger		log					= LoggerFactory.getLogger(SigmaTBoxOptimizer.class);
 	private final DAGImpl				isa;
 	private final DAGImpl				sigma;
 	private final DAGImpl				isaChain;
 	private final DAGImpl				sigmaChain;
 	private final TBoxReasonerImpl reasonerIsa;
 
 	private static final OBDADataFactory	predicateFactory = OBDADataFactoryImpl.getInstance();
 	private static final OntologyFactory	descFactory = OntologyFactoryImpl.getInstance();
 
 	private Ontology				originalOntologynull;
 
 	private Ontology				originalSigmanull;
 
 	public SigmaTBoxOptimizer(Ontology isatOntology sigmat) {
 		this. = isat;
 
 		this. = sigmat;
 		new TBoxReasonerImpl(isat,false);
 		this. = .getDAG();
 		TBoxReasonerImpl reasonerSigmanew TBoxReasonerImpl(sigmat,false);
 		this. = reasonerSigma.getDAG();
 		new TBoxReasonerImpl(isat,false);
 		
 		new TBoxReasonerImpl(sigmat,false);
 
 	}
 
 		Ontology reformulationOntology = .createOntology("http://it.unibz.krdb/obda/auxontology");
 		reformulationOntology.addEntities(.getVocabulary());
 
 		reformulationOntology.addAssertions(reduce());
 		return reformulationOntology;
 	}
 
 	public List<Axiomreduce() {
 		.debug("Starting semantic-reduction");
 		List<Axiomrv = new LinkedList<Axiom>();
 
 		for(Description node:.vertexSet()){
			for (Set<Descriptiondescendants.getDescendants(nodefalse)){
					Description firstDescendant=descendants.iterator().next();
					Description descendant.getReplacements().get(firstDescendant);
					if(descendant==null)
						descendant=firstDescendant;
					Axiom axiom = null;
					if(!descendant.equals(node)){
					/*
					 * Creating subClassOf or subPropertyOf axioms
					 */
					if (descendant instanceof ClassDescription) {
				if (!check_redundant(nodedescendant)) {
				}
else {
				if (!check_redundant_role(node,descendant)) {
				}
			}
					}
			}
			Set<Descriptionequivalents = .getEquivalences(nodefalse);
			for(Description equivalent:equivalents){
				if(!equivalent.equals(node)){
					if (node instanceof ClassDescription) {
						if (!check_redundant(equivalentnode)) {
						}
else {
						if (!check_redundant_role(equivalent,node)) {
						}
					}
					if (equivalent instanceof ClassDescription) {
						if (!check_redundant(nodeequivalent)) {
						}
else {
						if (!check_redundant_role(node,equivalent)) {
						}
					}
					}
				}
		}
//		log.debug("Finished semantic-reduction.");
		return rv;
	}
	private boolean check_redundant_role(Description parentDescription child) {
		if (check_directly_redundant_role(parentchild))
			return true;
		else {
//			log.debug("Not directly redundant role {} {}", parent, child);
			for (Set<Descriptionchildren_prime : .getDirectChildren(parentfalse)) {
				Description child_prime=children_prime.iterator().next();
				if (!child_prime.equals(child) && check_directly_redundant_role(child_primechild)
						&& !check_redundant(child_primeparent)) {
					return true;
				}
//				}
			}
		}
//		log.debug("Not redundant role {} {}", parent, child);
		return false;
	}
	private boolean check_directly_redundant_role(Description parentDescription child) {
		Property parentDesc = (Propertyparent;
		Property childDesc = (Propertychild;
		PropertySomeRestriction existParentDesc = .getPropertySomeRestriction(parentDesc.getPredicate(), parentDesc.isInverse());
		Description exists_parent = .getNode(existParentDesc);
		Description exists_child = .getNode(existChildDesc);
		return check_directly_redundant(parentchild) && check_directly_redundant(exists_parentexists_child);
	}
	private boolean check_redundant(Description parentDescription child) {
		if (check_directly_redundant(parentchild))
			return true;
		else {
			for (Set<Descriptionchildren_prime : .getDirectChildren(parentfalse)) {
			Description child_prime=children_prime.iterator().next();
				if (!child_prime.equals(child) && check_directly_redundant(child_primechild) && !check_redundant(child_primeparent)) {
					return true;
				}
				}
		}
		return false;
	}
	private boolean check_directly_redundant(Description parentDescription child) {
		if (sp == null || sc == null || tc == null) {
			return false;
		}
		if (.getReplacements().get(parent) != null){
			spChildren.getDirectChildren(spfalse);
		}
		if (.getReplacements().get(child) != null){
			scEquivalent=.getEquivalences(scfalse);
			scChildren=.getDescendants(scfalse); 
		}
		if (.getReplacements().get(child) != null){
		}
		boolean redundant =spChildren.contains(scEquivalent) && scChildren.containsAll(tcChildren);
		return (redundant);
	}
New to GrepCode? Check out our FAQ X