org.mindswap.pellet
Class PelletOptions

java.lang.Object
  extended by org.mindswap.pellet.PelletOptions

public class PelletOptions
extends java.lang.Object

This class contains options used throughout different modules of the reasoner. Setting one of the values should have effect in the behavior of the reasoner regardless of whether it is based on Jena or OWL-API (though some options are applicable only in one implementation). Some of these options are to control experimental extensions to the reasoner and may be removed in future releases as these features are completely tested and integrated.

Author:
Evren Sirin

Nested Class Summary
static class PelletOptions.InstanceRetrievalMethod
           
static class PelletOptions.MonitorType
           
static class PelletOptions.OrderedClassification
           
static class PelletOptions.UndefinedDatatypeHandling
           
 
Field Summary
static boolean ALWAYS_REBUILD_RETE
          Always rebuild rete (no incremental update)
static boolean BREADTH_FIRST
           
static boolean CACHE_RETRIEVAL
           
static boolean CHECK_NOMINAL_EDGES
          To decide if individual i has type class c check if the edges from cached model of c to nominal nodes also exists for the cached model of i.
static boolean COPY_ON_WRITE
          When doing a satisfiability check for a concept, do not copy the individuals even if there are nominals in the KB until you hit a nominal rule application.
static java.lang.Class<? extends CompletionStrategy> DEFAULT_COMPLETION_STRATEGY
          Deprecated. 
static java.lang.String DEFAULT_CONFIGURATION_FILE
           
static boolean DEPTH_FIRST
           
static boolean DISABLE_EL_CLASSIFIER
          Do not use EL Classifier, even if the ontology is EL
static boolean DL_SAFE_RULES
          This option tells the reasoner to enable support for DL-safe rules (encoded in SWRL).
static boolean FREEZE_BUILTIN_NAMESPACES
          With this option all triples that contains an unrecognized term from RDF, RDF-S, OWL, OWL 1.1, or XSD namespaces will be ignored.
static boolean FULL_SIZE_ESTIMATE
          This option controls if the size estimates for all the classes and properties in a KB will be computed fully when the PelletQueryExecution object is created.
static boolean HIDE_TOP_PROPERTY_VALUES
          Do not include owl:topObjectProperty and owl:topDataProperty values when retrieving the property values for an individual.
static boolean IGNORE_ANNOTATION_CLASSES
          In some ontologies, such as the ones from OBO, annotations may be nested and contain type assertions on annotation values.
static boolean IGNORE_DEPRECATED_TERMS
          This option causes all classes and properties defined as deprecated (using owl:DeprecetedClass or owl:DeprecetedProperty) to be ignored.
static boolean IGNORE_INVERSES
          This option is mainly used for debugging and causes the reasoner to ignore all inverse properties including inverseOf, InverseFunctionalProperty and SymmetricProperty definitions.
static boolean IGNORE_UNSUPPORTED_AXIOMS
          This option controls the behavior of Pellet while an ontology is being loaded.
static PelletOptions.InstanceRetrievalMethod INSTANCE_RETRIEVAL
           
static boolean INVALID_LITERAL_AS_INCONSISTENCY
          If true invalid literals cause inconsistencies.
static boolean KEEP_ABOX_ASSERTIONS
          Keep ABox assertions in the KB so they can be accessed later.
static java.util.logging.Logger log
           
static boolean MAINTAIN_COMPLETION_QUEUE
          Flag if the completion queue should be maintained through incremental deletions.
static int MAX_ANONYMOUS_CACHE
          The maximum number of cached pseudo models for anonymous classes.
static java.lang.String NO_SORTING
           
static java.lang.String OLDEST_FIRST
           
static boolean OPTIMIZE_DOWN_MONOTONIC
          When this option is set the query engine for distinguished variables uses taxonomies to prune downmonotonic variables in subClassOf and subPropertyOf atoms.
static PelletOptions.OrderedClassification ORDERED_CLASSIFICATION
          Classifier orders classes based on their usage to guarantee the correctness of the classification results.
static boolean PRINT_ABOX
          Print completion graph after each iteration (Should be used only for debugging purposes).
static boolean PROCESS_JENA_UPDATES_INCREMENTALLY
           
static boolean REALIZE_INDIVIDUAL_AT_A_TIME
          Control the realization strategy where we loop over individuals or concepts.
static boolean RETURN_DEDUCTIONS_GRAPH
          Deprecated. This option is introduced as a temporary solution for backward compatibility and is scheduled to be removed in future releases. One should avoid using InfGraph.getDeductionsGraph() (similarly InfModel.getDeductionsModel()) with Pellet. Model.listStatements() can be used to retrieve all the asserted and inferred statements.
static double SAMPLING_RATIO
          The ratio of individuals that will be inspected while generating the size estimate.
static boolean SATURATE_TABLEAU
          When this option is set completion will go on even if a clash is detected until the completion graph is saturated.
static boolean SEARCH_TYPE
           
static boolean SILENT_UNDEFINED_ENTITY_HANDLING
          Control the behavior if a function such as kb.getInstances(), kb.getTypes(), kb.getPropertyValues() is called with a parameter that is an undefined class, property or individual.
static boolean SIMPLIFY_QUERY
          Remove query atoms that are trivially entailed by other atoms.
static int STATIC_REORDERING_LIMIT
          The number of query atoms in a query that will trigger the switch from static query reordering to dynamic (incremental) query reordering.
static boolean TRACK_BRANCH_EFFECTS
          Track the association betweens nodes changed and branch.
static boolean TREAT_ALL_VARS_DISTINGUISHED
          According to SPARQL semantics all variables are distinguished by definition and bnodes in the query are non-distinguished variables.
static PelletOptions.UndefinedDatatypeHandling UNDEFINED_DATATYPE_HANDLING
          If EXCEPTION an exception is thrown when the reasoner encounters an undefined (and unsupported) datatype.
static boolean USE_ABSORPTION
          TBox absorption will be used to move some of the General Inclusion Axioms (GCI) from Tg to Tu.
static boolean USE_ADVANCED_CACHING
          Cache the pseudo models for anonymous classes.
static boolean USE_ANNOTATION_SUPPORT
          Activate annotation support in Pellet.
static boolean USE_ANYWHERE_BLOCKING
           
static boolean USE_BACKJUMPING
          Use dependency directed backjumping
static boolean USE_BINARY_ABSORPTION
           
static boolean USE_CACHING
          Cache the pseudo models for named classes and individuals.
static boolean USE_CD_CLASSIFICATION
          Use (if applicable) special optimization for completely defined (CD) concepts during classification.
static PelletOptions.MonitorType USE_CLASSIFICATION_MONITOR
           
static boolean USE_COMPLETION_QUEUE
          Flag set if the completion queue should be utilized.
static boolean USE_COMPLETION_STRATEGY
          Dynamically find the best completion strategy for the KB.
static boolean USE_CONTINUOUS_RULES
          Use continuous rete execution for applying rules.
static boolean USE_DISJUNCT_SORTING
          Sort the disjuncts based on the statistics
static java.lang.String USE_DISJUNCTION_SORTING
           
static boolean USE_FULL_DATATYPE_REASONING
          Check the cardinality restrictions on datatype properties and handle inverse functional datatype properties
static boolean USE_HASVALUE_ABSORPTION
           
static boolean USE_INCREMENTAL_CONSISTENCY
          Flag set if incremental consistency checking should be used.
static boolean USE_INCREMENTAL_DELETION
          Flag set if incremental support for deletions should be used.
static boolean USE_INVERSE_CACHING
          Cache the pseudo models for anonymous classes when inverses are present.
static boolean USE_LEGACY_TBOX
           
static boolean USE_NAIVE_QUERY_ENGINE
          Deprecated. 
static boolean USE_NOMINAL_ABSORPTION
          Absorb TBox axioms about nominals into ABox assertions
static boolean USE_OPTIMIZED_BASIC_COMPLETION_QUEUE
          Flag set if the optimized basic completion queue should be used.
static boolean USE_PSEUDO_NOMINALS
          Treat nominals (classes defined by enumeration) as named atomic concepts rather than individual names.
static boolean USE_ROLE_ABSORPTION
          Absorb TBox axioms into domain/range restrictions in RBox
static boolean USE_RULE_ABSORPTION
           
static boolean USE_SEMANTIC_BRANCHING
          Use semantic branching, i.e.
static boolean USE_SMART_RESTORE
          During backjumping use dependency set information to restore node labels rather than restoring the label exactly to the previous state.
static boolean USE_TRACING
           
static boolean USE_UNIQUE_NAME_ASSUMPTION
          This option tells Pellet to treat every individual with a distinct URI to be different from each other.
static boolean VALIDATE_ABOX
          Validate ABox structure during completion (Should be used only for debugging purposes).
 
Constructor Summary
PelletOptions()
           
 
Method Summary
static void load(java.net.URL configFile)
           
static java.util.Properties setOptions(java.util.Properties newOptions)
          Sets the Pellet configuration options and returns the old values for the options.
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

log

public static final java.util.logging.Logger log

SATURATE_TABLEAU

public static boolean SATURATE_TABLEAU
When this option is set completion will go on even if a clash is detected until the completion graph is saturated. Turning this option has very severe performance effect and right now is only used for experimental purposes to generate explanations.

*********** DO NOT CHANGE THE VALUE OF THIS OPTION **************


USE_UNIQUE_NAME_ASSUMPTION

public static boolean USE_UNIQUE_NAME_ASSUMPTION
This option tells Pellet to treat every individual with a distinct URI to be different from each other. This is against the semantics of OWL but is much more efficient than adding an definition with all the individuals. This option does not affect b-nodes, they can still be inferred to be same.


TRACK_BRANCH_EFFECTS

public static boolean TRACK_BRANCH_EFFECTS
Track the association betweens nodes changed and branch. Reduces the work done during restoration (and during some incremental reasoning changes), at the cost of memory overhead necessary for tracking.


TREAT_ALL_VARS_DISTINGUISHED

public static boolean TREAT_ALL_VARS_DISTINGUISHED
According to SPARQL semantics all variables are distinguished by definition and bnodes in the query are non-distinguished variables. This option overrides the default behavior and treats bnodes as distinguished variables, too. This means bnodes in the SPARQL query will only be matched to named individuals or existing bnodes in the dataset but not to inferred individuals (e.g. an individual whose existence is inferred due to an owl:someValuesFrom restriction)


USE_DISJUNCT_SORTING

public static boolean USE_DISJUNCT_SORTING
Sort the disjuncts based on the statistics


USE_CLASSIFICATION_MONITOR

public static PelletOptions.MonitorType USE_CLASSIFICATION_MONITOR

NO_SORTING

public static final java.lang.String NO_SORTING
See Also:
Constant Field Values

OLDEST_FIRST

public static final java.lang.String OLDEST_FIRST
See Also:
Constant Field Values

USE_DISJUNCTION_SORTING

public static java.lang.String USE_DISJUNCTION_SORTING

USE_ABSORPTION

public static boolean USE_ABSORPTION
TBox absorption will be used to move some of the General Inclusion Axioms (GCI) from Tg to Tu.


UNDEFINED_DATATYPE_HANDLING

public static PelletOptions.UndefinedDatatypeHandling UNDEFINED_DATATYPE_HANDLING
If EXCEPTION an exception is thrown when the reasoner encounters an undefined (and unsupported) datatype. If EMPTY it is treated as an empty datatype and has no valid lexical forms. If INFINITE it is treated as an infinite datatype and all lexical forms are valid and in which equality and identity is based on lexical form.


USE_ROLE_ABSORPTION

public static boolean USE_ROLE_ABSORPTION
Absorb TBox axioms into domain/range restrictions in RBox


USE_NOMINAL_ABSORPTION

public static boolean USE_NOMINAL_ABSORPTION
Absorb TBox axioms about nominals into ABox assertions


USE_HASVALUE_ABSORPTION

public static boolean USE_HASVALUE_ABSORPTION

USE_RULE_ABSORPTION

public static boolean USE_RULE_ABSORPTION

USE_BINARY_ABSORPTION

public static boolean USE_BINARY_ABSORPTION

USE_BACKJUMPING

public static boolean USE_BACKJUMPING
Use dependency directed backjumping


USE_FULL_DATATYPE_REASONING

public static boolean USE_FULL_DATATYPE_REASONING
Check the cardinality restrictions on datatype properties and handle inverse functional datatype properties


USE_CACHING

public static boolean USE_CACHING
Cache the pseudo models for named classes and individuals.


USE_ADVANCED_CACHING

public static boolean USE_ADVANCED_CACHING
Cache the pseudo models for anonymous classes. Used inside EmptySHNStrategy to prevent the expansion of completion graph nodes whose satisfiability status is already cached.


USE_INVERSE_CACHING

public static boolean USE_INVERSE_CACHING
Cache the pseudo models for anonymous classes when inverses are present. This can improve reasoning performance but will introduce memory overhead.


USE_ANYWHERE_BLOCKING

public static boolean USE_ANYWHERE_BLOCKING

MAX_ANONYMOUS_CACHE

public static int MAX_ANONYMOUS_CACHE
The maximum number of cached pseudo models for anonymous classes. The named concepts (and their negations) are always cached regardless of this limit. This setting is mostly relevant for SHN ontologies as USE_ADVANCED_CACHING option. If the cache reaches the maximum number of entries for anonymous classes the subsequent additions will be handled specially (default behavior is to remove the Least Recently Used (LRU) element from cache). Setting this value too high will increase the memory requirements and setting it too low will slow down the reasoning process.


CHECK_NOMINAL_EDGES

public static boolean CHECK_NOMINAL_EDGES
To decide if individual i has type class c check if the edges from cached model of c to nominal nodes also exists for the cached model of i.


USE_PSEUDO_NOMINALS

public static boolean USE_PSEUDO_NOMINALS
Treat nominals (classes defined by enumeration) as named atomic concepts rather than individual names. Turning this option improves the performance but soundness and completeness cannot be established.


IGNORE_INVERSES

public static boolean IGNORE_INVERSES
This option is mainly used for debugging and causes the reasoner to ignore all inverse properties including inverseOf, InverseFunctionalProperty and SymmetricProperty definitions.


USE_COMPLETION_STRATEGY

public static boolean USE_COMPLETION_STRATEGY
Dynamically find the best completion strategy for the KB. If disabled SROIQ strategy will be used for all the ontologies.


USE_CONTINUOUS_RULES

public static boolean USE_CONTINUOUS_RULES
Use continuous rete execution for applying rules.


ALWAYS_REBUILD_RETE

public static boolean ALWAYS_REBUILD_RETE
Always rebuild rete (no incremental update)


USE_SEMANTIC_BRANCHING

public static boolean USE_SEMANTIC_BRANCHING
Use semantic branching, i.e. add the negation of a disjunct when the next branch is being tried


DEFAULT_COMPLETION_STRATEGY

@Deprecated
public static java.lang.Class<? extends CompletionStrategy> DEFAULT_COMPLETION_STRATEGY
Deprecated. 
The default strategy used for ABox completion. If this values is set, this strategy will be used for all the KB's regardless of the expressivity.

*********** DO NOT CHANGE THE VALUE OF THIS OPTION **************


COPY_ON_WRITE

public static boolean COPY_ON_WRITE
When doing a satisfiability check for a concept, do not copy the individuals even if there are nominals in the KB until you hit a nominal rule application.


SILENT_UNDEFINED_ENTITY_HANDLING

public static boolean SILENT_UNDEFINED_ENTITY_HANDLING
Control the behavior if a function such as kb.getInstances(), kb.getTypes(), kb.getPropertyValues() is called with a parameter that is an undefined class, property or individual. If this option is set to false then an exception is thrown each time this occurs, if true set the corresponding function returns a false value (or an empty set where appropriate).


REALIZE_INDIVIDUAL_AT_A_TIME

public static boolean REALIZE_INDIVIDUAL_AT_A_TIME
Control the realization strategy where we loop over individuals or concepts. When this flag is set we loop over each individual and find the most specific type for that individual by traversing the class hierarchy. If this flag is not set we traverse the class hierarchy and for each concept find the instances. Then any individual that is also an instance of a subclass is removed. Both techniques have advantages and disadvantages. Best performance depends on the ontology characteristics.


VALIDATE_ABOX

public static boolean VALIDATE_ABOX
Validate ABox structure during completion (Should be used only for debugging purposes).


PRINT_ABOX

public static boolean PRINT_ABOX
Print completion graph after each iteration (Should be used only for debugging purposes).


DEPTH_FIRST

public static final boolean DEPTH_FIRST
See Also:
Constant Field Values

BREADTH_FIRST

public static final boolean BREADTH_FIRST
See Also:
Constant Field Values

KEEP_ABOX_ASSERTIONS

public static boolean KEEP_ABOX_ASSERTIONS
Keep ABox assertions in the KB so they can be accessed later. Currently not used by the reasoner but could be useful for outside applications.


SEARCH_TYPE

public static boolean SEARCH_TYPE

INSTANCE_RETRIEVAL

public static PelletOptions.InstanceRetrievalMethod INSTANCE_RETRIEVAL

INVALID_LITERAL_AS_INCONSISTENCY

public static boolean INVALID_LITERAL_AS_INCONSISTENCY
If true invalid literals cause inconsistencies. If false they cause exceptions to be generated.


OPTIMIZE_DOWN_MONOTONIC

public static boolean OPTIMIZE_DOWN_MONOTONIC
When this option is set the query engine for distinguished variables uses taxonomies to prune downmonotonic variables in subClassOf and subPropertyOf atoms.


SIMPLIFY_QUERY

public static boolean SIMPLIFY_QUERY
Remove query atoms that are trivially entailed by other atoms. For example, the query
query(x, y) :- Person(x), worksAt(x, y), Organization(y)
can be simplified to
query(x, y) :- worksAt(x, y)
if the domain of worksAt is Person and the range is Organization.


SAMPLING_RATIO

public static double SAMPLING_RATIO
The ratio of individuals that will be inspected while generating the size estimate. The query reordering optimization uses size estimates for classes and properties to estimate the cost of a certain query ordering. The size estimates are computed by random sampling. Increasing the sampling ratio yields more accurate results but is very costly for large ABoxes.


STATIC_REORDERING_LIMIT

public static int STATIC_REORDERING_LIMIT
The number of query atoms in a query that will trigger the switch from static query reordering to dynamic (incremental) query reordering.


FULL_SIZE_ESTIMATE

public static boolean FULL_SIZE_ESTIMATE
This option controls if the size estimates for all the classes and properties in a KB will be computed fully when the PelletQueryExecution object is created.


CACHE_RETRIEVAL

public static boolean CACHE_RETRIEVAL

USE_TRACING

public static boolean USE_TRACING

DEFAULT_CONFIGURATION_FILE

public static java.lang.String DEFAULT_CONFIGURATION_FILE

FREEZE_BUILTIN_NAMESPACES

public static boolean FREEZE_BUILTIN_NAMESPACES
With this option all triples that contains an unrecognized term from RDF, RDF-S, OWL, OWL 1.1, or XSD namespaces will be ignored.


IGNORE_DEPRECATED_TERMS

public static boolean IGNORE_DEPRECATED_TERMS
This option causes all classes and properties defined as deprecated (using owl:DeprecetedClass or owl:DeprecetedProperty) to be ignored. If turned off, these will be treated as ordinary classes and properties. Note that, even if this option is turned on deprecated entities used in ordinary axioms will be added to the KB.


IGNORE_UNSUPPORTED_AXIOMS

public static boolean IGNORE_UNSUPPORTED_AXIOMS
This option controls the behavior of Pellet while an ontology is being loaded. Some axioms, e.g. cardinality restrictions on transitive properties, is not supported by Pellet. If an axiom is used in the input ontology Pellet can just ignore that axiom (and print a warning) or simply throw an exception at the time that axiom is added to the KB. Default behavior is to ignore unsupported axioms.


DL_SAFE_RULES

public static boolean DL_SAFE_RULES
This option tells the reasoner to enable support for DL-safe rules (encoded in SWRL). If the value is set to ture then the rules will be taken into account during reasoning. Otherwise, rules will simply be ignored by the reasoner. Note that, some SWRL features such as DatavaluedPropertyAtom and BuiltinAtom is not supported. The behavior for what happens when rules containing such atoms is controlled by the IGNORE_UNSUPPORTED_AXIOMS option, e.g. such rules can be ignored or reasoner can throw an exception.


RETURN_DEDUCTIONS_GRAPH

public static boolean RETURN_DEDUCTIONS_GRAPH
Deprecated. This option is introduced as a temporary solution for backward compatibility and is scheduled to be removed in future releases. One should avoid using InfGraph.getDeductionsGraph() (similarly InfModel.getDeductionsModel()) with Pellet. Model.listStatements() can be used to retrieve all the asserted and inferred statements.
This option controls the behavior of PelletInfGraph.getDeductionsGraph() function affecting in turn how InfModel.getDeductionsGraph() behave. Jena documentation describes this function to apply only to forward-chaining rule engines which does not include pellet. The behavior of this function in Pellet prior to 1.5.1 release was to return an incomplete subset of all the inferences that the reasoner can compute from the base model. This is obviously not correct and Pellet should simply return null for this function according to the Jena documentation. But considering that the incorrect behavior of this function might already be being used by the users, Pellet 1.5.1 introduces this option for backward compatibility and forces PelletInfGraph return to the previous incorrect behavior.


USE_COMPLETION_QUEUE

public static boolean USE_COMPLETION_QUEUE
Flag set if the completion queue should be utilized. This optimization will introduce memory overhead but will (in some cases) dramatically reduce reasoning time. Rather than iterating over all individuals during the completion strategy, only those which need to have the rules fired are selected for rule applications.


USE_OPTIMIZED_BASIC_COMPLETION_QUEUE

public static boolean USE_OPTIMIZED_BASIC_COMPLETION_QUEUE
Flag set if the optimized basic completion queue should be used. The difference between the basic completion queue is that it maintains queues of individuals for each rule type. In contrast the basic completion queue simply one list of individuals which all rules iterate over


USE_SMART_RESTORE

public static boolean USE_SMART_RESTORE
During backjumping use dependency set information to restore node labels rather than restoring the label exactly to the previous state.


USE_INCREMENTAL_CONSISTENCY

public static boolean USE_INCREMENTAL_CONSISTENCY
Flag set if incremental consistency checking should be used. Currently it can only be used on KBs with SHIQ or SHOQ expressivity


USE_INCREMENTAL_DELETION

public static boolean USE_INCREMENTAL_DELETION
Flag set if incremental support for deletions should be used. Currently it can only be used on KBs with SHIQ or SHOQ expressivity. This flag is used as incremental deletions introduces memory overhead, which may not be suitable for some KBs


MAINTAIN_COMPLETION_QUEUE

public static boolean MAINTAIN_COMPLETION_QUEUE
Flag if the completion queue should be maintained through incremental deletions. It can be the case that a removal of a syntactic assertion will require a queue element to be removed, as it is no longer applicable. If this is set to false then a simple check before each rule is fired will be performed - if the ds for the label is null, then the rule will not be fired. If this is set to true and tracing is on, then the queue will be maintained through deletions. TODO: Note currently the queue maintenance is not implemented, so this should always be FALSE!

*********** DO NOT CHANGE THE VALUE OF THIS OPTION **************


USE_CD_CLASSIFICATION

public static boolean USE_CD_CLASSIFICATION
Use (if applicable) special optimization for completely defined (CD) concepts during classification.


USE_NAIVE_QUERY_ENGINE

@Deprecated
public static boolean USE_NAIVE_QUERY_ENGINE
Deprecated. 

USE_ANNOTATION_SUPPORT

public static boolean USE_ANNOTATION_SUPPORT
Activate annotation support in Pellet. If this variable is true, Ontology annotations are stored to the KB and they can be retrieved, either by querying the KB or using the query engines.


HIDE_TOP_PROPERTY_VALUES

public static boolean HIDE_TOP_PROPERTY_VALUES
Do not include owl:topObjectProperty and owl:topDataProperty values when retrieving the property values for an individual. Even tough such values are trivially inferred according to OWL 2 semantics, including these values in results increase result size drastically. This option will not affect boolean queries (asking whether a towl:topObjectProperty b is entailed will still return true) or property queries (sub and super property queries will include top properties).


USE_LEGACY_TBOX

public static boolean USE_LEGACY_TBOX

ORDERED_CLASSIFICATION

public static PelletOptions.OrderedClassification ORDERED_CLASSIFICATION
Classifier orders classes based on their usage to guarantee the correctness of the classification results. In certain cases, there might be no semantic reason to choose between two classes. In these cases, the reasoner can use a deterministic algorithm to choose which of the classes to process first. This option ensures that the reasoner will use same ordering at every run. Disabling this option means the classifier will break ties randomly which might result in different classification times.


DISABLE_EL_CLASSIFIER

public static boolean DISABLE_EL_CLASSIFIER
Do not use EL Classifier, even if the ontology is EL


PROCESS_JENA_UPDATES_INCREMENTALLY

public static boolean PROCESS_JENA_UPDATES_INCREMENTALLY

IGNORE_ANNOTATION_CLASSES

public static boolean IGNORE_ANNOTATION_CLASSES
In some ontologies, such as the ones from OBO, annotations may be nested and contain type assertions on annotation values. Such type assertions will be treated as regular assertions and processed by the reasoner. This causes many superfluous logical axioms to be considered by the reasoner which might have significant impact on performance. This options tells Pellet to ignore such annotations. The set of URIs that will be treated as annotation classes are defined in AnnotationClasses and has to be programmatically modified. Annotation classes from OBO are included by default.

Constructor Detail

PelletOptions

public PelletOptions()
Method Detail

setOptions

public static java.util.Properties setOptions(java.util.Properties newOptions)
Sets the Pellet configuration options and returns the old values for the options.

Parameters:
newOptions - the new values for configuration options

load

public static void load(java.net.URL configFile)
                 throws java.io.FileNotFoundException,
                        java.io.IOException
Throws:
java.io.FileNotFoundException
java.io.IOException


Copyright © 2004 Evren Sirin. All Rights Reserved.