Java 类org.semanticweb.owlapi.model.OWLClassAssertionAxiom 实例源码

/**
 * Asserts that the given individual is an instance of the complement of the given type.
 * @param type the given type
 * @param indObj the given individual about which the assertion will be made
 * @return <code>true</code> if the assertion is successful
 */
@Override
public boolean addNegatedAttributeToObject(OWLClass type,IndividualObject indObj) {
    OWLClassAssertionAxiom axiom = getFactory().getOWLClassAssertionAxiom(
            ELIndividualObject.getComplement(getOntology(), type),
            indObj.getIdentifier());
    AddAxiom  addAxiom = new AddAxiom(getOntology(),axiom); 
    try {
        getManager().applyChange(addAxiom);
        reClassifyOntology();
        updateObjects(Constants.AFTER_MODIFICATION);
        updateObjectDescriptions(Constants.AFTER_MODIFICATION);
    }
    catch (OWLOntologyChangeException e) {
        e.printStackTrace();
        System.exit(-1);
    }
    getHistory().push(new ClassAssertionChange(this,addAxiom,indObj.getIdentifier(),type,true));
    return true;
}

/**
 * Adds a given individual to the ontology as an instance of <code>Thing</code>
 * @param object the given object to be added
 * @return <code>true</code> if the object is successfully added
 */
// @Override
public boolean addIndividualToOntology(OWLNamedIndividual object) {
    OWLClassAssertionAxiom axiom = getFactory().getOWLClassAssertionAxiom(getFactory().getOWLThing(), object);
    AddAxiom  addAxiom = new AddAxiom(getOntology(),axiom); 
    Set<OWLClass> attrs = new HashSet<OWLClass>();
    try {
        getManager().applyChange(addAxiom);
        reClassifyOntology();
        IndividualObject indObj = createIndividualObject(object);
        indObj.updateDescription(Constants.AFTER_MODIFICATION);
        addObject(indObj);
    }
    catch (OWLOntologyChangeException e) {
        e.printStackTrace();
        System.exit(-1);
    }
    attrs.add(getFactory().getOWLThing());
    getHistory().push(new NewIndividualChange(this,addAxiom,object,attrs));
    return true;
}

/**
 * Adds a given individual to the ontology as an instance of the conjunction of the 
 * given set of classes
 * @param object the individual to be added
 * @param attributes the set of classes
 * @return <code>true</code> if the individual is successfully added
 */
public boolean addIndividualToOntology(OWLNamedIndividual object, Set<OWLClass> attributes) {
    // OWLObjectIntersectionOf description = toOWLDescription(attributes);
    OWLClassExpression description = toOWLDescription(attributes);
    OWLClassAssertionAxiom axiom = getFactory().getOWLClassAssertionAxiom(description, object);
    AddAxiom  addAxiom = new AddAxiom(getOntology(),axiom); 
    try {
        getManager().applyChange(addAxiom);
        reClassifyOntology();
        IndividualObject indObj = createIndividualObject(object);
        // for (OWLClass attribute : attributes) {
        //  indObj.getDescription().addAttribute(attribute);
        // }
        indObj.getDescription().addAttributes(attributes);
        indObj.updateDescription(Constants.AFTER_MODIFICATION);
        addObject(indObj);
    }
    catch (OWLOntologyChangeException e) {
        e.printStackTrace();
        System.exit(-1);
    }
    getHistory().push(new NewIndividualChange(this,addAxiom,object,attributes));
    return true;
}

/**
 * Asserts that the given individual is an instance of the given type.
 * @param type the given type
 * @param indObj the given individual about which the assertion will be made
 * @return <code>true</code> if the assertion is successful
 */
public boolean addAttributeToObject(OWLClass type,IndividualObject indObj) {
    OWLClassAssertionAxiom axiom = getFactory().getOWLClassAssertionAxiom(type, indObj.getIdentifier());
    AddAxiom  addAxiom = new AddAxiom(getOntology(),axiom); 
    try {
        getManager().applyChange(addAxiom);
        reClassifyOntology();
        updateObjects(Constants.AFTER_MODIFICATION);
        updateObjectDescriptions(Constants.AFTER_MODIFICATION);
    }
    catch (OWLOntologyChangeException e) {
        e.printStackTrace();
        System.exit(-1);
    }
    getHistory().push(new ClassAssertionChange(this,addAxiom,indObj.getIdentifier(),type,false));
    return true;
}

/**
 * Asserts that the given individual is an instance of the complement of the given type.
 * @param type the given type
 * @param indObj the given individual about which the assertion will be made
 * @return <code>true</code> if the assertion is successful
 */
public boolean addNegatedAttributeToObject(OWLClass type,IndividualObject indObj) {
    OWLClassAssertionAxiom axiom = getFactory().getOWLClassAssertionAxiom(getFactory().getOWLObjectComplementOf(type), indObj.getIdentifier());
    AddAxiom  addAxiom = new AddAxiom(getOntology(),axiom); 
    try {
        getManager().applyChange(addAxiom);
        reClassifyOntology();
        updateObjects(Constants.AFTER_MODIFICATION);
        updateObjectDescriptions(Constants.AFTER_MODIFICATION);
    }
    catch (OWLOntologyChangeException e) {
        e.printStackTrace();
        System.exit(-1);
    }
    getHistory().push(new ClassAssertionChange(this,addAxiom,indObj.getIdentifier(),type,true));
    return true;
}

public void undo() {
    OWLClassAssertionAxiom axiom = null;
    if (isTypePlus) {
        axiom = theContext.getFactory().getOWLClassAssertionAxiom(changedType, candidate);
    }
    else {
        axiom = theContext.getFactory().getOWLClassAssertionAxiom( 
                theContext.getFactory().getOWLObjectComplementOf(changedType), candidate);
    }
    RemoveAxiom  removeAxiom = new RemoveAxiom(theContext.getOntology(),axiom); 
    try {
        theContext.getManager().applyChange(removeAxiom);
    }
    catch (OWLOntologyChangeException e) {
        e.printStackTrace();
        System.exit(-1);
    }
}

private static Pair<OWLNamedIndividual, Set<OWLAxiom>> createIndividualInternal(IRI iri, OWLOntology abox, OWLClassExpression ce, Set<OWLAnnotation> annotations) {
    LOG.info("Generating individual for IRI: "+iri);
    OWLDataFactory f = abox.getOWLOntologyManager().getOWLDataFactory();
    OWLNamedIndividual i = f.getOWLNamedIndividual(iri);

    // create axioms
    Set<OWLAxiom> axioms = new HashSet<OWLAxiom>();
    // declaration
    axioms.add(f.getOWLDeclarationAxiom(i));
    // annotation assertions
    if(annotations != null) {
        for(OWLAnnotation annotation : annotations) {
            axioms.add(f.getOWLAnnotationAssertionAxiom(iri, annotation));
        }
    }

    if (ce != null) {
        OWLClassAssertionAxiom typeAxiom = createType(f, i, ce);
        if (typeAxiom != null) {
            axioms.add(typeAxiom);
        }
    }

    return Pair.of(i, axioms);
}

public NodeSet<OWLClass> getTypes(OWLNamedIndividual ind, boolean direct) throws InconsistentOntologyException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    ensurePrepared();
    DefaultNodeSet<OWLClass> result = new OWLClassNodeSet();
    for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
        for (OWLClassAssertionAxiom axiom : ontology.getClassAssertionAxioms(ind)) {
            OWLClassExpression ce = axiom.getClassExpression();
            if (!ce.isAnonymous()) {
                result.addNode(classHierarchyInfo.getEquivalents(ce.asOWLClass()));
                if (!direct) {
                    result.addAllNodes(getSuperClasses(ce, false).getNodes());
                }
            }
        }
    }
    return result;
}

public boolean isSatisfiable(OWLClassExpression classExpression) {
    checkPreConditions(classExpression);
    if (!isConsistent())
        return false;
    if (classExpression instanceof OWLClass
            && m_atomicConceptHierarchy != null) {
        AtomicConcept concept = H((OWLClass) classExpression);
        HierarchyNode<AtomicConcept> node = m_atomicConceptHierarchy
                .getNodeForElement(concept);
        return node != m_atomicConceptHierarchy.getBottomNode();
    } else {
        OWLDataFactory factory = getDataFactory();
        OWLIndividual freshIndividual = factory
                .getOWLAnonymousIndividual("fresh-individual");
        OWLClassAssertionAxiom assertClassExpression = factory
                .getOWLClassAssertionAxiom(classExpression, freshIndividual);
        Tableau tableau = getTableau(assertClassExpression);
        return tableau.isSatisfiable(true, null, null, null, null, null,
                ReasoningTaskDescription
                        .isConceptSatisfiable(classExpression));
    }
}

public Boolean visit(OWLDatatypeDefinitionAxiom axiom) {
    reasoner.throwInconsistentOntologyExceptionIfNecessary();
    if (!reasoner.isConsistent())
        return true;
    if (reasoner.m_dlOntology.hasDatatypes()) {
        OWLDataFactory factory=reasoner.getDataFactory();
        OWLIndividual freshIndividual=factory.getOWLAnonymousIndividual("fresh-individual");
        OWLDataProperty freshDataProperty=factory.getOWLDataProperty(IRI.create("fresh-data-property"));
        OWLDataRange dataRange=axiom.getDataRange();
        OWLDatatype dt=axiom.getDatatype();
        OWLDataIntersectionOf dr1=factory.getOWLDataIntersectionOf(factory.getOWLDataComplementOf(dataRange),dt);
        OWLDataIntersectionOf dr2=factory.getOWLDataIntersectionOf(factory.getOWLDataComplementOf(dt),dataRange);
        OWLDataUnionOf union=factory.getOWLDataUnionOf(dr1,dr2);
        OWLClassExpression c=factory.getOWLDataSomeValuesFrom(freshDataProperty,union);
        OWLClassAssertionAxiom ax=factory.getOWLClassAssertionAxiom(c,freshIndividual);
        Tableau tableau=reasoner.getTableau(ax);
        return !tableau.isSatisfiable(true,true,null,null,null,null,null,ReasoningTaskDescription.isAxiomEntailed(axiom));
    }
    else
        return false;
}

public void visit(OWLClassAssertionAxiom axiom) {
    if (axiom.getClassExpression().isOWLThing())
        return;
    OWLIndividual node=axiom.getIndividual();
    if (!node.isAnonymous()) {
        namedNodes.add(node.asOWLNamedIndividual());
    }
    else {
        nodes.add(node.asOWLAnonymousIndividual());
        if (nodelLabels.containsKey(node)) {
            nodelLabels.get(node).add(axiom.getClassExpression());
        }
        else {
            Set<OWLClassExpression> label=new HashSet<OWLClassExpression>();
            label.add(axiom.getClassExpression());
            nodelLabels.put(node.asOWLAnonymousIndividual(),label);
        }
    }
}

public boolean isSatisfiable(OWLClassExpression classExpression) {
    checkPreConditions(classExpression);
    if (!isConsistent())
        return false;
    if (classExpression instanceof OWLClass
            && m_atomicConceptHierarchy != null) {
        AtomicConcept concept = H((OWLClass) classExpression);
        HierarchyNode<AtomicConcept> node = m_atomicConceptHierarchy
                .getNodeForElement(concept);
        return node != m_atomicConceptHierarchy.getBottomNode();
    } else {
        OWLDataFactory factory = getDataFactory();
        OWLIndividual freshIndividual = factory
                .getOWLAnonymousIndividual("fresh-individual");
        OWLClassAssertionAxiom assertClassExpression = factory
                .getOWLClassAssertionAxiom(classExpression, freshIndividual);
        Tableau tableau = getTableau(assertClassExpression);
        return tableau.isSatisfiable(true, null, null, null, null, null,
                ReasoningTaskDescription
                        .isConceptSatisfiable(classExpression));
    }
}

public Boolean visit(OWLDatatypeDefinitionAxiom axiom) {
    reasoner.throwInconsistentOntologyExceptionIfNecessary();
    if (!reasoner.isConsistent())
        return true;
    if (reasoner.m_dlOntology.hasDatatypes()) {
        OWLDataFactory factory=reasoner.getDataFactory();
        OWLIndividual freshIndividual=factory.getOWLAnonymousIndividual("fresh-individual");
        OWLDataProperty freshDataProperty=factory.getOWLDataProperty(IRI.create("fresh-data-property"));
        OWLDataRange dataRange=axiom.getDataRange();
        OWLDatatype dt=axiom.getDatatype();
        OWLDataIntersectionOf dr1=factory.getOWLDataIntersectionOf(factory.getOWLDataComplementOf(dataRange),dt);
        OWLDataIntersectionOf dr2=factory.getOWLDataIntersectionOf(factory.getOWLDataComplementOf(dt),dataRange);
        OWLDataUnionOf union=factory.getOWLDataUnionOf(dr1,dr2);
        OWLClassExpression c=factory.getOWLDataSomeValuesFrom(freshDataProperty,union);
        OWLClassAssertionAxiom ax=factory.getOWLClassAssertionAxiom(c,freshIndividual);
        Tableau tableau=reasoner.getTableau(ax);
        return !tableau.isSatisfiable(true,true,null,null,null,null,null,ReasoningTaskDescription.isAxiomEntailed(axiom));
    }
    else
        return false;
}

public void visit(OWLClassAssertionAxiom axiom) {
    if (axiom.getClassExpression().isOWLThing())
        return;
    OWLIndividual node=axiom.getIndividual();
    if (!node.isAnonymous()) {
        namedNodes.add(node.asOWLNamedIndividual());
    }
    else {
        nodes.add(node.asOWLAnonymousIndividual());
        if (nodelLabels.containsKey(node)) {
            nodelLabels.get(node).add(axiom.getClassExpression());
        }
        else {
            Set<OWLClassExpression> label=new HashSet<OWLClassExpression>();
            label.add(axiom.getClassExpression());
            nodelLabels.put(node.asOWLAnonymousIndividual(),label);
        }
    }
}

@CLIMethod("--remove-dangling-annotations")
public void removeDangningAnnotations(Opts opts) throws Exception {
    OWLOntology ont = g.getSourceOntology();
    int n = 0;
    Set<OWLAxiom> rmAxioms = new HashSet<OWLAxiom>();
    for (OWLNamedIndividual i : ont.getIndividualsInSignature()) {
        for (OWLClassAssertionAxiom ca : ont.getClassAssertionAxioms(i)) {
            OWLClassExpression cx = ca.getClassExpression();
            if (cx instanceof OWLClass) {
                OWLClass c = (OWLClass) cx;
                String label = g.getLabel(c);
                if (label == null)
                    rmAxioms.add(ca);
                else
                    n++;
            }
        }
    }
    LOG.info("Removing " + rmAxioms.size() + " axioms");
    ont.getOWLOntologyManager().removeAxioms(ont, rmAxioms);
    LOG.info("Remaining: " + n + " axioms");
}

public Set<OWLClass> materializeClassExpressionsReferencedBy(OWLObjectProperty p) {
    Set<OWLClassExpression> xs = new HashSet<OWLClassExpression>();
    for (OWLAxiom ax : outputOntology.getReferencingAxioms(p, Imports.INCLUDED)) {
        if (ax instanceof OWLSubClassOfAxiom) {
            xs.addAll(getClassExpressionReferencedBy(p, ((OWLSubClassOfAxiom)ax).getSuperClass()));
        }
        else if (ax instanceof OWLClassAssertionAxiom) {
            xs.addAll(getClassExpressionReferencedBy(p, ((OWLClassAssertionAxiom)ax).getClassExpression()));
        }
        else if (ax instanceof OWLEquivalentClassesAxiom) {
            for (OWLClassExpression x : ((OWLEquivalentClassesAxiom)ax).getClassExpressions()) {
                xs.addAll(getClassExpressionReferencedBy(p,x));
            }
        }
    }
    return materializeClassExpressions(xs);
}

public static void randomizeClassAssertions(OWLOntology ont, int num) {
    Set<OWLClassAssertionAxiom> caas = new HashSet<OWLClassAssertionAxiom>();
    Set<OWLClassAssertionAxiom> caasNew = new HashSet<OWLClassAssertionAxiom>();
        Set<OWLNamedIndividual> inds = ont.getIndividualsInSignature(Imports.INCLUDED);
    OWLNamedIndividual[] indArr = (OWLNamedIndividual[]) inds.toArray();
    for (OWLNamedIndividual ind : inds) {
        caas.addAll( ont.getClassAssertionAxioms(ind) );
    }
    for (OWLClassAssertionAxiom caa : caas) {
        OWLIndividual randomIndividual = null;
        caasNew.add(ont.getOWLOntologyManager().getOWLDataFactory().getOWLClassAssertionAxiom(caa.getClassExpression(), 
                randomIndividual));
    }
    ont.getOWLOntologyManager().removeAxioms(ont, caas);
    ont.getOWLOntologyManager().addAxioms(ont, caasNew);
}

protected void makeHasPhenotypeInstancesDirect() {
    // x Type has_phenotype some C ==> x Type C
    LOG.info("x Type has_phenotype some C ==> x Type C");
    OWLObjectProperty hasPhenotype = getOWLObjectPropertyViaOBOSuffix(HAS_PHENOTYPE);
    Set<OWLAxiom> rmAxioms = new HashSet<OWLAxiom>();
    Set<OWLAxiom> newAxioms = new HashSet<OWLAxiom>();
    for (OWLClassAssertionAxiom caa : outputOntology.getAxioms(AxiomType.CLASS_ASSERTION)) {
        OWLClassExpression ex = caa.getClassExpression();
        OWLIndividual i = caa.getIndividual();
        if (ex instanceof OWLObjectSomeValuesFrom) {
            OWLObjectSomeValuesFrom svf = (OWLObjectSomeValuesFrom)ex;
            if (svf.getProperty().equals(hasPhenotype)) {
                rmAxioms.add(caa);
                newAxioms.add(getOWLDataFactory().getOWLClassAssertionAxiom(svf.getFiller(), i));
            }

        }
    }
    LOG.info("making instances direct: +"+newAxioms.size()+ " -"+rmAxioms.size());
    addAxiomsToOutput(newAxioms, false);
    removeAxiomsFromOutput(rmAxioms, false);
}

public void visit(OWLClassAssertionAxiom classAssertion) {
    OWLIndividual individual = classAssertion.getIndividual();
    OWLClassExpression classExpression = classAssertion.getClassExpression();

    if (!classExpression.isAnonymous()) {
        OWLClass namedClass = classExpression.asOWLClass();

        writer.print(namedClass.getIRI().getFragment());
        writer.print("(");
        writer.print(IRI.create(individual.toStringID()).getFragment());
        writer.print(").\n");
    }
    else {

    }
}

/**
 * Create an individual of a given type
 * 
 * @param individual
 *            the individual signature
 * @param type
 *            individual type
 */

public void createIndividual(final String individual, final String type) {
    OWLDataFactory factory = ontology.getOWLOntologyManager()
            .getOWLDataFactory();

    OWLClass clazz = factory.getOWLClass(IRI.create(type));

    OWLNamedIndividual ind = factory.getOWLNamedIndividual(IRI
            .create(individual));
    OWLClassAssertionAxiom assertion = factory.getOWLClassAssertionAxiom(
            clazz, ind);
    final List<OWLOntologyChange> owlOntologyChanges = ontology
            .getOWLOntologyManager().addAxiom(ontology, assertion);
    manager.applyChanges(owlOntologyChanges);
    reasoner.flush();
}

/**
 * Add a new class membership to an individual
 * 
 * @param individual
 *            the individual signature
 * @param type
 *            individual type
 */

public void addIndividualMembership(final String individual,
        final String type) {
    OWLDataFactory factory = ontology.getOWLOntologyManager()
            .getOWLDataFactory();

    OWLClass clazz = factory.getOWLClass(IRI.create(type));

    OWLNamedIndividual ind = factory.getOWLNamedIndividual(IRI
            .create(individual));
    OWLClassAssertionAxiom assertion = factory.getOWLClassAssertionAxiom(
            clazz, ind);
    final List<OWLOntologyChange> owlOntologyChanges = ontology
            .getOWLOntologyManager().addAxiom(ontology, assertion);
    manager.applyChanges(owlOntologyChanges);
    reasoner.flush();
}

/**
 * Remove class membership from an individual
 * 
 * @param individual
 *            the individual signature
 * @param type
 *            individual type
 */
//
public void removeIndividualMembership(final String individual,
        final String type) {
    OWLDataFactory factory = ontology.getOWLOntologyManager()
            .getOWLDataFactory();

    OWLClass clazz = factory.getOWLClass(IRI.create(type));

    OWLNamedIndividual ind = factory.getOWLNamedIndividual(IRI
            .create(individual));
    OWLClassAssertionAxiom assertion = factory.getOWLClassAssertionAxiom(
            clazz, ind);
    final List<OWLOntologyChange> owlOntologyChanges = ontology
            .getOWLOntologyManager().removeAxiom(ontology, assertion);
    manager.applyChanges(owlOntologyChanges);
    reasoner.flush();
}

/**
 * Genera los axiomas correspondientes a un PPI
 * 
 * @param element Objeto del modelo del PPI
 * @param bpmn20ModelHandler Manejador del modelo BPMN correspondiente al mismo proceso del PPI
 * @return Objeto OWL de la medida
 * @throws Exception
 */
void converterPpiOWL(PPI element, Bpmn20ModelHandlerInterface bpmn20ModelHandler) throws Exception {

    String ppiId = element.getId();

    MeasureDefinition measuredBy = element.getMeasuredBy();
    String measureId = measuredBy.getId();

    // adiciona el axioma que indica la clase del PPI
    OWLNamedIndividual ppiIndividual = factory.getOWLNamedIndividual( IRI.create(ppinotGeneratedOntologyURI+"#"+ppiId) );
    OWLClass ppiClass = factory.getOWLClass( IRI.create(Vocabulary.PPI_URI));
    OWLClassAssertionAxiom ppiClassAxiom = factory.getOWLClassAssertionAxiom(ppiClass, ppiIndividual);
    manager.addAxiom(ontology, ppiClassAxiom);

    // adiciona el axioma con la relacion entre el PPI y la medida
    OWLObjectPropertyExpression definition = factory.getOWLObjectProperty(IRI.create(Vocabulary.DEFINITION_URI));
    OWLNamedIndividual measureIndividual = factory.getOWLNamedIndividual( IRI.create(ppinotGeneratedOntologyURI+"#"+measureId) );
    OWLObjectPropertyAssertionAxiom definitionAxiom = factory.getOWLObjectPropertyAssertionAxiom(definition, ppiIndividual, measureIndividual);
    manager.addAxiom(ontology, definitionAxiom);
}

public boolean hasType(OWLClassExpression type, OWLNamedIndividual individual) {
    boolean ret = false;
    Set<OWLClassAssertionAxiom> set = getContext().getReasoner().getRootOntology().getClassAssertionAxioms(individual);
    for (OWLClassAssertionAxiom axiom : set) {
        ret = ret || getContext().isSubClassOf(axiom.getClassExpression(), type);
    }
    return ret;
}

private Set<OWLObjectSomeValuesFrom> getSvfTypes(OWLNamedIndividual i, OWLOntology model) {
    Set<OWLClassAssertionAxiom> axioms = model.getClassAssertionAxioms(i);
    final Set<OWLObjectSomeValuesFrom> svfs = new HashSet<OWLObjectSomeValuesFrom>();
    for (OWLClassAssertionAxiom axiom : axioms) {
        axiom.getClassExpression().accept(new OWLClassExpressionVisitorAdapter(){

            @Override
            public void visit(OWLObjectSomeValuesFrom svf) {
                svfs.add(svf);
            }
        });
    }
    return svfs;
}

private Set<OWLClass> getTypes(OWLNamedIndividual i, OWLOntology model) {
    Set<OWLClassAssertionAxiom> axioms = model.getClassAssertionAxioms(i);
    Set<OWLClass> types = new HashSet<OWLClass>();
    for (OWLClassAssertionAxiom axiom : axioms) {
        OWLClassExpression ce = axiom.getClassExpression();
        if (ce instanceof OWLClass) {
            OWLClass cls = ce.asOWLClass();
            if (cls.isBuiltIn() == false) {
                types.add(cls);
            }
        }
    }
    return types;
}

/**
 * Adds a ClassAssertion, where the class expression instantiated is an
 * ObjectSomeValuesFrom expression
 * 
 * Example: Individual: i Type: enabledBy some PRO_123
 *  
 * @param model
 * @param i
 * @param p
 * @param filler
 * @param metadata
 */
void addType(ModelContainer model,
        OWLIndividual i, 
        OWLObjectPropertyExpression p,
        OWLClassExpression filler,
        METADATA metadata) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("Adding "+i+ " type "+p+" some "+filler); 
    }
    OWLDataFactory f = model.getOWLDataFactory();
    OWLObjectSomeValuesFrom c = f.getOWLObjectSomeValuesFrom(p, filler);
    OWLClassAssertionAxiom axiom = f.getOWLClassAssertionAxiom(c, i);
    addAxiom(model, axiom, metadata);
}

/**
 * remove ClassAssertion(c,i) from the model
 * 
 * @param model
 * @param i
 * @param ce
 * @param metadata
 */
public void removeType(ModelContainer model, OWLIndividual i, 
        OWLClassExpression ce, METADATA metadata) {
    Set<OWLClassAssertionAxiom> allAxioms = model.getAboxOntology().getClassAssertionAxioms(i);
    // use search to remove also axioms with annotations
    for (OWLClassAssertionAxiom ax : allAxioms) {
        if (ce.equals(ax.getClassExpression())) {
            removeAxiom(model, ax, metadata);
        }
    }

}

void removeType(ModelContainer model,
        OWLIndividual i, 
        OWLObjectPropertyExpression p,
        OWLClassExpression filler,
        METADATA metadata) {
    OWLDataFactory f = model.getOWLDataFactory();
    OWLClassAssertionAxiom axiom = f.getOWLClassAssertionAxiom(f.getOWLObjectSomeValuesFrom(p, filler), i);
    removeAxiom(model, axiom, metadata);
}

private void addClassAssertionAxiom(OWLClass classname, OWLIndividual individ) {
    // pipe1 (individual) belongs to the class Pipe
    OWLClassAssertionAxiom assertion = dataFactory.getOWLClassAssertionAxiom(classname, individ);
    AddAxiom addAxiom = new AddAxiom(ontology, assertion);
    manager.applyChange(addAxiom);
    countClassAssertionAxioms++;
    log.log(Level.FINER, "The class assertion axiom was added: " + assertion.toString());
}

public NodeSet<OWLNamedIndividual> getInstances(OWLClassExpression ce, boolean direct) throws InconsistentOntologyException, ClassExpressionNotInProfileException, FreshEntitiesException, ReasonerInterruptedException, TimeOutException {
    ensurePrepared();
    DefaultNodeSet<OWLNamedIndividual> result = new OWLNamedIndividualNodeSet();
    if (!ce.isAnonymous()) {
        OWLClass cls = ce.asOWLClass();
        Set<OWLClass> clses = new HashSet<OWLClass>();
        clses.add(cls);
        if (!direct) {
            clses.addAll(getSubClasses(cls, false).getFlattened());
        }
        for (OWLOntology ontology : getRootOntology().getImportsClosure()) {
            for (OWLClass curCls : clses) {
                for (OWLClassAssertionAxiom axiom : ontology.getClassAssertionAxioms(curCls)) {
                    OWLIndividual individual = axiom.getIndividual();
                    if (!individual.isAnonymous()) {
                        if (getIndividualNodeSetPolicy().equals(IndividualNodeSetPolicy.BY_SAME_AS)) {
                            result.addNode(getSameIndividuals(individual.asOWLNamedIndividual()));
                        }
                        else {
                            result.addNode(new OWLNamedIndividualNode(individual.asOWLNamedIndividual()));
                        }
                    }
                }
            }
        }
    }
    return result;
}

public Set<OWLNamedIndividual> getConceptSchemes () {

        Set<OWLNamedIndividual> inds = new HashSet<OWLNamedIndividual>(10);

        for (OWLOntology onto  : getOWLEditorKit().getModelManager().getOntologies()) {
            Set<OWLClassAssertionAxiom> axioms = onto.getClassAssertionAxioms(getOWLEditorKit().getModelManager().getOWLDataFactory().getOWLClass(SKOSVocabulary.CONCEPTSCHEME.getIRI()));
            for (OWLClassAssertionAxiom axiom : axioms) {
                inds.add(axiom.getIndividual().asOWLNamedIndividual());
            }

        }
        return inds;
    }

public static Set<OWLIndividual> getConceptSchemes (OWLEditorKit owlEditorKit) {

        Set<OWLIndividual> inds = new HashSet<OWLIndividual>();

        for (OWLOntology onto  : owlEditorKit.getModelManager().getOntologies()) {
            Set<OWLClassAssertionAxiom> axioms = onto.getClassAssertionAxioms(owlEditorKit.getModelManager().getOWLDataFactory().getOWLClass(SKOSVocabulary.CONCEPTSCHEME.getIRI()));
            for (OWLClassAssertionAxiom clssAx : axioms) {
                inds.add(clssAx.getIndividual());
            }
        }
        return inds;
    }

public void visit(OWLClassAssertionAxiom axiom) {
    OWLClassExpression classExpression=axiom.getClassExpression();
    if (classExpression instanceof OWLDataHasValue) {
        OWLDataHasValue hasValue=(OWLDataHasValue)classExpression;
        addFact(m_factory.getOWLDataPropertyAssertionAxiom(hasValue.getProperty(), axiom.getIndividual(), hasValue.getValue()));
        return;
    }
    if (classExpression instanceof OWLDataSomeValuesFrom) {
        OWLDataSomeValuesFrom someValuesFrom=(OWLDataSomeValuesFrom)classExpression;
        OWLDataRange dataRange=someValuesFrom.getFiller();
        if (dataRange instanceof OWLDataOneOf) {
            OWLDataOneOf oneOf=(OWLDataOneOf)dataRange;
            if (oneOf.getValues().size()==1) {
                addFact(m_factory.getOWLDataPropertyAssertionAxiom(someValuesFrom.getProperty(),axiom.getIndividual(),oneOf.getValues().iterator().next()));
                return;
            }
        }
    }
    classExpression=positive(classExpression);
    if (!isSimple(classExpression)) {
        OWLClassExpression definition=getDefinitionFor(classExpression,m_alreadyExists);
        if (!m_alreadyExists[0])
            m_classExpressionInclusionsAsDisjunctions.add(new OWLClassExpression[] { negative(definition),classExpression });
        classExpression=definition;
    }
    addFact(m_factory.getOWLClassAssertionAxiom(classExpression,axiom.getIndividual()));
}

public Boolean visit(OWLClassAssertionAxiom axiom) {
    OWLIndividual ind=axiom.getIndividual();
    if (ind.isAnonymous()) {
        anonymousIndividualAxioms.add(axiom);
        return true; // will be checked afterwards by rolling-up
    }
    OWLClassExpression c=axiom.getClassExpression();
    return reasoner.hasType(ind.asOWLNamedIndividual(),c,false);
}

@Override
public T visit(OWLClassAssertionAxiom axiom) {
    throw new IllegalArgumentException(
            OWLClassAssertionAxiom.class.getSimpleName()
                    + " cannot be converted to "
                    + getTargetClass().getSimpleName());
}

public void visit(OWLClassAssertionAxiom axiom) {
    OWLClassExpression classExpression=axiom.getClassExpression();
    if (classExpression instanceof OWLDataHasValue) {
        OWLDataHasValue hasValue=(OWLDataHasValue)classExpression;
        addFact(m_factory.getOWLDataPropertyAssertionAxiom(hasValue.getProperty(), axiom.getIndividual(), hasValue.getValue()));
        return;
    }
    if (classExpression instanceof OWLDataSomeValuesFrom) {
        OWLDataSomeValuesFrom someValuesFrom=(OWLDataSomeValuesFrom)classExpression;
        OWLDataRange dataRange=someValuesFrom.getFiller();
        if (dataRange instanceof OWLDataOneOf) {
            OWLDataOneOf oneOf=(OWLDataOneOf)dataRange;
            if (oneOf.getValues().size()==1) {
                addFact(m_factory.getOWLDataPropertyAssertionAxiom(someValuesFrom.getProperty(),axiom.getIndividual(),oneOf.getValues().iterator().next()));
                return;
            }
        }
    }
    classExpression=positive(classExpression);
    if (!isSimple(classExpression)) {
        OWLClassExpression definition=getDefinitionFor(classExpression,m_alreadyExists);
        if (!m_alreadyExists[0])
            m_classExpressionInclusionsAsDisjunctions.add(new OWLClassExpression[] { negative(definition),classExpression });
        classExpression=definition;
    }
    addFact(m_factory.getOWLClassAssertionAxiom(classExpression,axiom.getIndividual()));
}

public Boolean visit(OWLClassAssertionAxiom axiom) {
    OWLIndividual ind=axiom.getIndividual();
    if (ind.isAnonymous()) {
        anonymousIndividualAxioms.add(axiom);
        return true; // will be checked afterwards by rolling-up
    }
    OWLClassExpression c=axiom.getClassExpression();
    return reasoner.hasType(ind.asOWLNamedIndividual(),c,false);
}

private OWLClass findFirstType(OWLNamedIndividual relevant) {
    Set<OWLClassAssertionAxiom> axioms = model.getClassAssertionAxioms(relevant);
    for (OWLClassAssertionAxiom axiom : axioms) {
        OWLClassExpression ce = axiom.getClassExpression();
        if (ce.isAnonymous() == false) {
            return ce.asOWLClass();
        }
    }
    return null;
}

public static void createRandomClassAssertions(OWLOntology ont, int num, int maxAssertionsPerInstance) {
    Set<OWLClassAssertionAxiom> caasNew = new HashSet<OWLClassAssertionAxiom>();
    Vector<OWLClass> clist = new Vector<OWLClass>(ont.getClassesInSignature(Imports.INCLUDED));
    for (int i=0; i<num; i++) {
        OWLNamedIndividual ind = ont.getOWLOntologyManager().getOWLDataFactory().
        getOWLNamedIndividual(IRI.create("http://x.org/"+i));
        for (int j=0; j< Math.random() * maxAssertionsPerInstance; j++) {
            OWLClass c = clist.get((int)(Math.random() * clist.size()));
            caasNew.add(ont.getOWLOntologyManager().getOWLDataFactory().
                    getOWLClassAssertionAxiom(c, ind));
        }

    }
    ont.getOWLOntologyManager().addAxioms(ont, caasNew);
}