PelletOptions (Pellet :: Common library 2.3.4-ansell API)

java.lang.Object
- org.mindswap.pellet.PelletOptions

```
public class PelletOptions
extends 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

Nested Classes
Modifier and Type	Class and Description
`static class`	`PelletOptions.InstanceRetrievalMethod`
`static class`	`PelletOptions.MonitorType`
`static class`	`PelletOptions.OrderedClassification`
`static class`	`PelletOptions.UndefinedDatatypeHandling`

Field Summary

Fields
Modifier and Type	Field and Description
`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 Class<? extends CompletionStrategy>`	`DEFAULT_COMPLETION_STRATEGY` Deprecated.
`static 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 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 String`	`NO_SORTING`
`static 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 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

Constructors
Constructor and Description

PelletOptions()

Constructors
Constructor and Description
`PelletOptions()`

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`load(URL configFile)`
`static Properties`	`setOptions(Properties newOptions)` Sets the Pellet configuration options and returns the old values for the options.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - log
```
public static final 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 String NO_SORTING
```
    See Also:
    Constant Field Values
  - OLDEST_FIRST
```
public static final String OLDEST_FIRST
```
    See Also:
    Constant Field Values
  - USE_DISJUNCTION_SORTING
```
public static 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 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 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 Properties setOptions(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(URL configFile)
                 throws FileNotFoundException,
                        IOException
```
    Throws:
    
    FileNotFoundException
    
    IOException

Class PelletOptions

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

log

SATURATE_TABLEAU

USE_UNIQUE_NAME_ASSUMPTION

TRACK_BRANCH_EFFECTS

TREAT_ALL_VARS_DISTINGUISHED

USE_DISJUNCT_SORTING

USE_CLASSIFICATION_MONITOR

NO_SORTING

OLDEST_FIRST

USE_DISJUNCTION_SORTING

USE_ABSORPTION

UNDEFINED_DATATYPE_HANDLING

USE_ROLE_ABSORPTION

USE_NOMINAL_ABSORPTION

USE_HASVALUE_ABSORPTION

USE_RULE_ABSORPTION

USE_BINARY_ABSORPTION

USE_BACKJUMPING

USE_FULL_DATATYPE_REASONING

USE_CACHING

USE_ADVANCED_CACHING

USE_INVERSE_CACHING

USE_ANYWHERE_BLOCKING

MAX_ANONYMOUS_CACHE

CHECK_NOMINAL_EDGES

USE_PSEUDO_NOMINALS

IGNORE_INVERSES

USE_COMPLETION_STRATEGY

USE_CONTINUOUS_RULES

ALWAYS_REBUILD_RETE

USE_SEMANTIC_BRANCHING

DEFAULT_COMPLETION_STRATEGY

COPY_ON_WRITE

SILENT_UNDEFINED_ENTITY_HANDLING

REALIZE_INDIVIDUAL_AT_A_TIME

VALIDATE_ABOX

PRINT_ABOX

DEPTH_FIRST

BREADTH_FIRST

KEEP_ABOX_ASSERTIONS

SEARCH_TYPE

INSTANCE_RETRIEVAL

INVALID_LITERAL_AS_INCONSISTENCY

OPTIMIZE_DOWN_MONOTONIC

SIMPLIFY_QUERY

SAMPLING_RATIO

STATIC_REORDERING_LIMIT

FULL_SIZE_ESTIMATE

CACHE_RETRIEVAL

USE_TRACING

DEFAULT_CONFIGURATION_FILE

FREEZE_BUILTIN_NAMESPACES

IGNORE_DEPRECATED_TERMS

IGNORE_UNSUPPORTED_AXIOMS

DL_SAFE_RULES

RETURN_DEDUCTIONS_GRAPH

USE_COMPLETION_QUEUE

USE_OPTIMIZED_BASIC_COMPLETION_QUEUE

USE_SMART_RESTORE

USE_INCREMENTAL_CONSISTENCY

USE_INCREMENTAL_DELETION

MAINTAIN_COMPLETION_QUEUE

USE_CD_CLASSIFICATION

USE_NAIVE_QUERY_ENGINE

USE_ANNOTATION_SUPPORT

HIDE_TOP_PROPERTY_VALUES

USE_LEGACY_TBOX

ORDERED_CLASSIFICATION

DISABLE_EL_CLASSIFIER

PROCESS_JENA_UPDATES_INCREMENTALLY

IGNORE_ANNOTATION_CLASSES

Constructor Detail

PelletOptions