How to create owl file using JENA?

Question

I am stuck in the middle of ontology creation. I want to create an OWL file using Java which is my objective. I have created the hierarchical clusters but now I have to use those clusters in ontology creation.

Thanks in advance.

I have tried this so far. I got Dickinson's point. Now this is my code and I am getting an Exception as Exception in thread "main" com.hp.hpl.jena.shared.BadURIException: Only well-formed absolute URIrefs can be included in RDF/XML output: Code: 57/REQUIRED_COMPONENT_MISSING in SCHEME: A component that is required by the scheme is missing.

JenaOwl.java

public class JenaOwl {

    static OntModel jenaModel = null;

    public static void main(String[] args) throws IOException {
        JenaOwl jo = new JenaOwl();
        FileWriter fw = null;
        try {
            jenaModel = createModel();
        } catch (Exception ex) {
            Logger.getLogger(JenaOwl.class.getName()).log(Level.SEVERE, null, ex);
        }
        OutputStream output = null;
        try {
            fw = new FileWriter("D:/mymodel.owl");
            jenaModel.write( fw, "RDF/XML-ABBREV" );
            fw.close();
  // OR Turtle format - compact and more readable
  // use this variant if you're not sure which to use!
            fw = new FileWriter("D:/mymodel.ttl");
            jenaModel.write( fw, "Turtle" );
//            output = new FileOutputStream(new File("D:/Sample.owl"));
//            jenaModel.write(output);
            //jo.write(output);
        } finally {
         if (fw != null) {
                try {
                    fw.close();
                }
          catch (IOException ignore) {
         }
         }


}
    }
        //jenaModel.write(output)}

    public static OntModel createModel() throws Exception {
        jenaModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM);
        jenaModel.setNsPrefix("ot", OT.NS);
        jenaModel.setNsPrefix("owl", OWL.NS);
        jenaModel.setNsPrefix("dc", DC.NS);
//        OT ot = new OT();
//        OT.OTClass otc;
        System.out.println("jenaModel.getOntClass(OT.OTClass.Dataset.getNS()) : "+jenaModel.getOntClass(OT.OTClass.Dataset.getNS()));
        Individual dataset = jenaModel.createIndividual("Dataset URI", jenaModel.getOntClass(OT.OTClass.Dataset.getNS()));

        OT.OTClass.Dataset.createOntClass(jenaModel);

        OT.OTClass.DataEntry.createOntClass(jenaModel);

        OT.OTClass.Feature.createOntClass(jenaModel);

        OT.OTClass.FeatureValue.createOntClass(jenaModel);

        OT.OTClass.Compound.createOntClass(jenaModel);

        Individual dataEntry = jenaModel.createIndividual(OT.OTClass.DataEntry.getOntClass(jenaModel));
        dataset.addProperty(OT.dataEntry, dataEntry);

        Individual compound = jenaModel.createIndividual("compoundURI", OT.OTClass.Compound.getOntClass(jenaModel));
        dataEntry.addProperty(OT.compound, compound);

        //  First
        Individual feature1 = jenaModel.createIndividual("featureURI1", OT.OTClass.Feature.getOntClass(jenaModel));
        Individual featureValue1 = jenaModel.createIndividual(OT.OTClass.FeatureValue.getOntClass(jenaModel));
        featureValue1.addProperty(OT.feature, feature1);
        featureValue1.addLiteral(OT.value, jenaModel.createTypedLiteral("formaldehyde", XSDDatatype.XSDstring));

//Second value
        Individual feature2 = jenaModel.createIndividual("featureURI2", OT.OTClass.Feature.getOntClass(jenaModel));
        Individual featureValue2 = jenaModel.createIndividual(OT.OTClass.FeatureValue.getOntClass(jenaModel));
        featureValue2.addProperty(OT.feature, feature2);
        featureValue2.addLiteral(OT.value, jenaModel.createTypedLiteral(3.14, XSDDatatype.XSDdouble));

//and finally add values to the data entry
        dataEntry.addProperty(OT.values, featureValue1);
        dataEntry.addProperty(OT.values, featureValue2);



        return jenaModel;
    }

    public void write(OutputStream output) {
        MediaType mediaType = new MediaType(null);
        if (mediaType.equals(MediaType.APPLICATION_RDF_XML)) //jenaModel.write(output,"RDF/XML");  //this is faster
        {
            jenaModel.write(output, "RDF/XML-ABBREV");   //this is more readable
        } else if (mediaType.equals(MediaType.APPLICATION_RDF_XML)) {
            jenaModel.write(output, "TURTLE");
        } else if (mediaType.equals(MediaType.TEXT_RDF_N3)) {
            jenaModel.write(output, "N3");
        } else if (mediaType.equals(MediaType.TEXT_RDF_N3)) {
            jenaModel.write(output, "N-TRIPLE");
        } else {
            jenaModel.write(output, "RDF/XML-ABBREV");
        }
    }

    ;
}

OT.java

public class OT {

    public enum OTClass {

        Compound,
        Conformer,
        Dataset,
        DataEntry,
        Feature,
        FeatureValue,
        Algorithm,
        Model,
        Validation,
        ValidationInfo;

        public String getNS() {
            System.out.println("String.format(_NS, toString()) : " + String.format(_NS, toString()));
            return String.format(_NS, toString());
        }

        public OntClass getOntClass(OntModel model) {
            return model.getOntClass(getNS());
        }

        public OntClass createOntClass(OntModel model) {
            return model.createClass(getNS());
        }

        public Property createProperty(OntModel model) {
            return model.createProperty(getNS());
        }
    };
    /** <p>The RDF model that holds the vocabulary terms</p> */
    private static Model m_model = ModelFactory.createDefaultModel();
    /** <p>The namespace of the vocabalary as a string ({@value})</p> */
    protected static final String _NS = "http://www.opentox.org/api/1.1#%s";
    public static final String NS = String.format(_NS, "");

    public static String getURI() {
        return NS;
    }
    /** <p>The namespace of the vocabalary as a resource</p> */
    public static final Resource NAMESPACE = m_model.createResource(NS);
    /**
     * Object properties
     */
    public static final Property dataEntry = m_model.createProperty(String.format(_NS, "dataEntry"));
    public static final Property compound = m_model.createProperty(String.format(_NS, "compound"));
    public static final Property feature = m_model.createProperty(String.format(_NS, "feature"));
    public static final Property values = m_model.createProperty(String.format(_NS, "values"));
    public static final Property hasSource = m_model.createProperty(String.format(_NS, "hasSource"));
    public static final Property conformer = m_model.createProperty(String.format(_NS, "conformer"));
    public static final Property isA = m_model.createProperty(String.format(_NS, "isA"));
    public static final Property model = m_model.createProperty(String.format(_NS, "model"));
    public static final Property report = m_model.createProperty(String.format(_NS, "report"));
    public static final Property algorithm = m_model.createProperty(String.format(_NS, "algorithm"));
    public static final Property dependentVariables = m_model.createProperty(String.format(_NS, "dependentVariables"));
    public static final Property independentVariables = m_model.createProperty(String.format(_NS, "independentVariables"));
    public static final Property predictedVariables = m_model.createProperty(String.format(_NS, "predictedVariables"));
    public static final Property trainingDataset = m_model.createProperty(String.format(_NS, "trainingDataset"));
    public static final Property validationReport = m_model.createProperty(String.format(_NS, "validationReport"));
    public static final Property validation = m_model.createProperty(String.format(_NS, "validation"));
    public static final Property hasValidationInfo = m_model.createProperty(String.format(_NS, "hasValidationInfo"));
    public static final Property validationModel = m_model.createProperty(String.format(_NS, "validationModel"));
    public static final Property validationPredictionDataset = m_model.createProperty(String.format(_NS, "validationPredictionDataset"));
    public static final Property validationTestDataset = m_model.createProperty(String.format(_NS, "validationTestDataset"));
    /**
     * Data properties
     */
    public static final Property value = m_model.createProperty(String.format(_NS, "value"));
    public static final Property units = m_model.createProperty(String.format(_NS, "units"));
    public static final Property has3Dstructure = m_model.createProperty(String.format(_NS, "has3Dstructure"));
    public static final Property hasStatus = m_model.createProperty(String.format(_NS, "hasStatus"));
    public static final Property paramScope = m_model.createProperty(String.format(_NS, "paramScope"));
    public static final Property paramValue = m_model.createProperty(String.format(_NS, "paramValue"));
    public static final Property statisticsSupported = m_model.createProperty(String.format(_NS, "statisticsSupported"));
}

can you help in this?

Answer 1

Your question isn't very clear. If you're asking about how to save the model that you have created, you need to write it out to a file:

OntModel m = .... your model .... ;
FileWriter out = null;
try {
  // XML format - long and verbose
  out = new FileWriter( "mymodel.xml" );
  m.write( out, "RDF/XML-ABBREV" );

  // OR Turtle format - compact and more readable
  // use this variant if you're not sure which to use!
  out = new FileWriter( "mymodel.ttl" );
  m.write( out, "Turtle" );
}
finally {
  if (out != null) {
    try {out.close()} catch (IOException ignore) {}
  }
}

See the Jena documentation for more details on writing RDF.

Alternatively, if your question is about how to add instances of your ontology, see the examples in the ontology API documentation . As a hint, roughly speaking you want to get an OntClass object that corresponds to the OWL class you want to create an instance of:

OntModel m = ... your model ... ;
String ns = "http://example.com/example#";
OntClass foo = m.getOntClass( ns + "Foo" );
Individual fubar = foo.createInstance( ns + "fubar" );

If that doesn't address your issue, please update your question with more details, and, ideally, a sample of the code that you have already tried.

Update

OK, I've seen your updated code. For Protégé, you only need to write the file in XML, so you can remove the lines to write the Turtle format. But your real problem is lines like this:

jenaModel.createIndividual("compoundURI" )

"compoundURI" is not a valid URI - which is what the error message is telling you. You need a full URI that conforms to one of the valid URI schemes like HTTP. So, something like:

jenaModel.createIndividual( OT.NS + compoundURI );