Сложные и рефлексивные рассуждения

Простые одношаговые рассуждения

Мотивация

Развитая система мотивации, включающая убеждения, желания, намерения

Простейшие побуждения, связанные с выживанием

Память

Есть

Нет

Реакция

Медленная

Быстрая

Адаптивность

Малая

Высокая

Модульная архитектура

Есть

Нет

Состав MAC

Небольшое число автономных агентов

Большое число зависимых друг от друга агентов

Из сопоставления характеристик когнитивных и реактивных агентов видно, что синергетические автономные агенты должны обладать гибридной архитектурой, сочетающей достоинства реактивных и когнитивных агентов. В этом плане налицо тенденция построения интегрированных архитектур агентов, аналогичная современным вариантам интеграции логических и нейросетевых моделей в ИИ.

В сообществе специалистов по MAC как одна из перспективных моделей рассматривается модель самообучающегося агента. Однако при этом делаются ссылки на результаты в области извлечения знаний и машинного обучения, полученные ранее в ИИ применительно к экспертным системам. Очевидно, что применительно к MAC задача обучения имеет свои особенности, которые пока не учитываются. Весьма специфична и задача обучения агентов коллективному поведению, поскольку кооперативное решение проблем подразумевает совместное использование знаний нескольких агентов.

2.4 Архитектура агента

Архитектуры агентов классифицируются в зависимости от вида структуры, наложенной на функциональные компоненты агента и принятых методов организации взаимодействия его компонент в процессе работы.

Базовая классификация архитектур агентов основывается на парадигме, лежащей в основе принятой архитектуры. По этому признаку различают два основных класса архитектур:

- архитектура, которая базируется на принципах и методах классического ИИ, т.е. систем, основанных на знаниях (“архитектура разумного агента”),

- архитектура, основанная на поведении или “реактивная архитектура”, которая исходит из реакций системы на события внешнего мира.

Только самые простые приложения агентов могут быть реализованы по одноуровневой схеме. Как правило, архитектура агента организуется в виде нескольких уровней. Как правило, уровни представляют различные функциональные характеристики агентов, такие, как восприятие внешних событий и простые реакции на них; поведение, управляемое целями; координация действий с поведением других агентов; обновление внутреннего состояния агента, т.е. убеждений о внешнем мире; прогнозирование состояний внешнего мира; определение своих действий на очередном шаге и др.

Наиболее часто в архитектуре агента присутствуют уровни, ответственные за:

а) восприятие и исполнение действий;

б) реактивное поведение;

в) локальное планирование;

г) кооперативное поведение;

д) моделирование внешней среды;

е) формирование намерений;

ж) обучение агента.

2.5 Кооперация агентов

Идея многоагентности предполагает кооперацию агентов при коллективном решении задач. В MAC агент, который не способен решить некоторую задачу самостоятельно, может обратиться к другим агентам. Другой вариант, когда необходима кооперация -- это использование коллектива агентов для решения общей трудной задачи. При этом агенты могут строить планы действий, основываясь уже не только на своих возможностях, но и “думая” о планах и намерениях других агентов. Известно, что коллективы даже простейших автоматов, в которых каждый автомат преследует только свои примитивные цели, в целом способны решать очень сложные задачи. В качестве иллюстрации можно взять, например, пчелиный улей или муравейник. Можно надеяться, что система, в которой агенты могут учитывать планы и интересы других агентов, будет являться во многих случаях еще более гибкой.

В настоящее время предложено множество различных моделей коллективного поведения агентов. Как правило, каждая из моделей концентрирует внимание на нескольких аспектах такого поведения и рассматривает проблемы в соответствии с выбранной архитектурой (моделью) самого агента. Для знаний, отвечающих за коллективное поведение, в архитектуре агента обычно выделяют специальный уровень -- уровень кооперации.

Существуют две основные модели взаимодействия агентов:

- Одноуровневая архитектура - агенты не образуют иерархии и решают общую задачу в распределенной организационной структуре.

- Иерархическая архитектура - координация распределенного функционирования агентов в той или иной мере поддерживается специально выделенным агентом, который при этом понимается как находящийся на метауровне по отношению к остальным агентам.

Рассмотрим простейший вариант иерархической организации взаимодействия агентов, который предполагает использование хотя бы одного агента “метауровня”, осуществляющего координацию распределенного решения задач агентами.

Агент-Координатор может быть привязан к конкретному серверу, и тогда он называется “местом встречи агентов”. Таким образом, место встречи агентов (АМР --Agent Meeting Place) -- это по сути дела агент, играющий роль брокера между агентами, запрашивающими некоторые требующиеся им ресурсы, и агентами, которые эти ресурсы могут предоставить. Поэтому архитектура АМР есть архитектура обычного агента, дополненная некоторыми вспомогательными компонентами, характеризующими функции координатора взаимодействия других агентов. Вспомогательные компоненты должны, с одной стороны, содержать единое описание множества доступных через АМР агентов и их возможностей (ресурсов, функций и пр.) а, с другой стороны, организовать унифицированный доступ к ним. Это обеспечивается следующими компонентами АМР:

1) Объекты базовых сервисов (в частности, это могут быть удаленный вызов объектов, упорядочение объектов, дублирование объектов и другие базовые возможности), которые обычно поддерживаются той или иной платформой открытой распределенной обработки.

2) Связные порты, ответственные за прием и отправку агентов в АМР с помощью соответствующих протоколов.

3) Компонента установления подлинности агента по имени (опознание агента, “авторизация”).

4) Администратор, выполняющий функции проверки полномочий поступающего агента, контроля наличия на АМР запрашиваемой услуги, оказания помощи агенту в выборе дальнейшего маршрута перемещения и др.

5) Поверхностный маршрутизатор, который выполняет функции интерфейса между агентами и компонентами АМР, которые сами по себе регистрируются в этом маршрутизаторе; он поддерживает ограниченный словарь для удовлетворения агентских запросов.

6) Глубинный маршрутизатор, который используется при более специальных или сложных запросах.

7) Лингвистический журнал, который представляет собой базу данных, помогающую агентам и АМР понимать друг друга в процессе коммуникаций. В нем регистрируются словари и языки, но не описания языков или смысл терминов, а лишь ссылки на них, т.е. журнал предоставляет информацию о том, что может быть понято в АМР.

8) Менеджер ресурсов; он регистрирует агентов на АМР и связанные с ними ресурсы, а также управляет ресурсами АМР.

9) Среда реализации агента, которая регистрируется в АМР и управляет доступом к компонентам агента; она интерпретирует сценарии, обеспечивает доступ к базовым возможностям и др.

10) Система доставки событий (источниками событий могут быть локальные средства, резидентные агенты АМР и др.); система регистрирует события и выполняет поиск агентов для соответствующего типа событий, сообщений. [1]

2.6 Платформа для разработки мультиагентных систем JADE

JADE - это платформа разработки мультиагентных систем. Она удовлетворяет спецификациям FIPA. Jade включает в себя:

- Динамическую среду, где JADE агенты могут "жить"; она должна быть активна на принимающем хосте до того, как на нём будут запущены один или более агентов.

- Библиотеку классов, которую программисты могут использовать (прямо или опосредованно) для разработки своих агентов.

- Набор графических инструментов, позволяющий управлять и следить за активностью запущенных агентов.

Каждая запущенная динамическая среда JADE называется контейнером и может содержать несколько агентов. Набор активных контейнеров называется платформой. Единственный специальный контейнер - главный (Main) должен всегда быть активным на платформе: все остальные контейнеры регистрируются и связываются с ним в момент запуска. Отсюда следует, что первым контейнером при старте платформы должен быть главный, а все остальные контейнеры должны быть "нормальными" (т.е. не главными) контейнерами и должны заранее "знать", как найти (то есть иметь данные о хосте и порте) главный контейнер (на котором они будут регистрироваться).

Помимо возможности приёма регистраций от других контейнеров, главный контейнер отличается от обычного контейнера тем, что содержит два специальных агента (AMS и DF).

AMS (система управления агентами) обеспечивает службу именования (то есть гарантирует, что каждый клиент на платформе обладает уникальным именем) и осуществляет управление на платформе (например, можно создавать и ликвидировать агентов на удалённом контейнере по запросу AMS).

DF (Координатор каталога) предоставляет сервис "Жёлтые страницы", с помощью которого агент может искать других агентов, предоставляющих услуги, которые нужны данному агенту для достижения целей. Сервис «Жёлтых страниц» позволяет агентам опубликовать данные об одном или более сервисах, которые они предоставляют, так, что другие агенты могут находить и успешно использовать эти сервисы.

Рисунок 2.6.1 - Сервис «жёлтых страниц» в JADE

C точки зрения платформы, агент JADE - обычный экземпляр определяемого пользователем Java-класса, который расширяет класс Agent, реализованный в платформе. Из этого следует, что базовый набор действий агента, необходимый для функционирования внутри платформы определен изначально.

Для отработки реакции на события агент имеет поведения. Агент может отрабатывать несколько поведений одновременно. Обработка поведений происходит не по приоритетам (как java потоки), а совместно. Очередность исполнения отдельных простых поведений не гарантируется, для этого нужно использовать поведения специальных типов или синхронизацию. В Jade реализованы следующие типы поведений агента:

- простое поведение:

- единожды исполняемое поведение;

- циклически исполняемое поведение;

- сложное поведение:

- поведение-триггер;

- последовательное поведение;

- параллельное поведение.

Поведения, как и сам агент, являются Java-классами, следовательно, в процессе разработки программист имеет возможность комбинировать существующие типы поведений и наполнять их необходимым функционалом.

Рисунок 2.6.2 - Модули агента Jade

Одной из наиболее важных особенностей, которую JADE агенты представляют - это возможность коммуникации. Коммуникационной парадигмой принято называть сообщение асинхронного прохождения. Каждый агент имеет почтовый ящик (очередь сообщений агента), куда среда выполнения JADE передает сообщения, отправленные другими агентами. Всякий раз, когда сообщение поступает в очереди сообщений, получающий его агент уведомляется. Однако процесс, когда агент на самом деле вынимает сообщения из очереди сообщений, полностью лежит на плечах программиста.

Обмен сообщениями JADE агентами имеет формат специфицированного языка ACL и определяется FIPA (The Foundation for Intelligent Agent) как международный стандарт для взаимодействий агентов. Этот формат включает в себя целый ряд пунктов, в частности:

- Отправитель сообщения

- Список получателей

- Коммуникативные намерения, указывающие на то, что отправитель намерен достичь отправкой сообщения.

- Содержание, т.е. фактически информация, содержащаяся в сообщении

- Язык, т.е. синтаксис используемый для передачи содержания (и отправитель, и получатель должны быть в состоянии кодировать/разбирать выражения с этим синтаксисом, чтобы общение было эффективным).

- Онтология, т.е. словарь символов, используемых в содержании и их значение (и отправитель, и получатель должны приписывать символам одинаковый смысл, чтобы общение было эффективным).

- Некоторые поля, используемые для контроля над несколькими одновременными разговорами и указанный перерыв для получения ответа. Например, conversation-id, reply-with, in-reply-to, reply-by.

Для обеспечения контроля за разработко многоагентной системы могут быть использованы специальные системные агенты:

- Sniffer Agent - отслеживание потока сообщений между агентами;

- Dummy Agent - отправка сообщения агенту;

- Introspector Agent - мониторинг жизненного цикла агента;

- Remote Monitoring Agent - мониторинг платформы. [3]

2.7 Создание прототипа интеллектуального агента

Используя платформу Jade создадим прототип интеллектуального агента. Для этого используем следующий подход: наделим простого Jade-агента возможностью работать с семантической базой знаний в формате OWL. Для этой интеграции используем следующие два фреймворка:

- OWL API;

- Jena Semantic Web Framework.

Для адекватной интеграции агента и базы знаний, агент должен быть способен выполнять следующие простые операции:

- получение сведений из базы знаний;

- запись новых знаний в базу знаний;

- выполнение запросов к базе знаний.

Рисунок 2.6.3 - Консоль управления агентами Jade

Диаграмма классов прототипа интеллектуального агента приведена в Приложении Б, а исходные коды когнитивного агента находятся в Приложении В.



3. ТЕХНИКО-ЭКОНОМИЧЕСКОЕ ОБОСНОВАНИЕ РАЗРАБОТКИ БАЗЫ ЗНАНИЙ

3.1 Характеристика программного продукта

Прототип многоагентной системы взаимодействующей с базой знаний демонстрирует новую концепцию, известную как семантическая паутина.

Разработка и внедрение онтологий позволит:

- программам-клиентам непосредственно извлекать из всемирной сети факты и делать из них логические заключения, что обеспечит качественно новый уровень обработки информации;

- значительно повысит эффективность автоматической обработки информации интеллектуальными агентами.

Экономическая целесообразность инвестиций в разработку и использование программного продукта осуществляется на основе расчета и оценки следующих показателей:

? чистая дисконтированная стоимость (ЧДД);

? срок окупаемости инвестиций (Т_ОК);

? рентабельность инвестиций (Р_И).

В результате разработки данного программного продукта информация будет обрабатываться автоматически, что и будет являться результатом от внедрения программного продукта.

3.2 Расчет затрат и отпускной цены программного средства

1. Основная заработная плата исполнителей проекта определяется по формуле

где n - количество исполнителей, занятых разработкой ПС;

T_Чi - часовая тарифная ставка i-го исполнителя (руб.);

Ф_Эi - эффективный фонд рабочего времени i-го исполнителя (дней)

Т_Ч - количество часов работы в день (ч);

К - коэффициент премирования (1,5).

В настоящий момент тарифная ставка 1-го разряда на предприятии составляет 700 000 руб.

Расчет основной заработной платы представлен в табл. 4.1.

Таблица 3.1 - Расчет основной заработной платы

Исполнитель	Раз-ряд	Тарифный коэф.	Месячная тарифная ставка, руб.	Часовая тарифная ставка, руб.	Плано-вый фонд рабочего времени, дн.	Заработная плата, руб.
Программист 2-й категории	10	2,84	1988000	11 694	180	25 259 294
Программист 1-ой категории	12	3,25	2275000	13 382	200	32 117 647
Ведущий программист	15	3,48	2436000	14 329	220	37 829 647
Начальник лаборатории	16	3,72	2604000	15 318	150	27 571 765
Основная заработная плата						122 778 353

2. Дополнительная заработная плата исполнителей проекта определяется по формуле

где Н_Д - норматив дополнительной заработной платы (20%)

Дополнительная заработная плата составит:

З_Д = 122 778 353*20/100=24 555 671 руб.

3. Отчисления в фонд социальной защиты населения и на обязательное страхование (З_С) определяются в соответствии с действующими законодательными актами по формуле

где Н_СЗ - норматив отчислений в фонд социальной защиты населения и на обязательное страхование (34% +0,6%).

З_СЗ = (122 778 353+24 555 671) ·34,6/100=50 977 572 руб.

4. Расходы по статье «Машинное время» (Р_М) включают оплату машинного времени, необходимого для разработки и отладки ПС, и определяются по формуле:

Р_М = Ц_М*Т_Ч*С_Р

где Ц_М - цена одного машино-часа;

Т_Ч - количество часов работы в день;

С_Р - длительность проекта.

Стоимость машино-часа на предприятии составляет 6 000 руб. Разработка проекта займет 220 дней Определим затраты по статье “Машинное время”:

Р_М = 6000·8·220=10 560 000 руб.

5. Затраты по статье «Накладные расходы» (Р_Н), связанные с необходимостью содержания аппарата управления, вспомогательных хозяйств и опытных (экспериментальных) производств, а также с расходами на общехозяйственные нужды (Р_Н), определяются по формуле

где Н_РН - норматив накладных расходов (50%).

Накладные расходы составят:

Рн = 122 778 353·0,5 = 61 389 176 руб.

Общая сумма расходов по всем статьям сметы (С_Р) на ПО рассчитывается по формуле:

С_Р = 122 778 353 + 24 555 671 + 50 977 572 + 10 560 000 + 61 389 176 = 270 260 772 руб.

Кроме того, организация-разработчик осуществляет затраты на сопровождение и адаптацию ПС (Р_СА), которые определяются по нормативу (Н_РСА)

где Н_РАС - норматив расходов на сопровождение и адаптацию (20%).

С_Р - смета расходов в целом по организации без расходов на сопровождение и адаптацию (руб.).

Р_СА = 270 260 772 * 20/100= 54 052 154 руб.

Общая сумма расходов на разработку (с затратами на сопровождение и адаптацию) как полная себестоимость ПС (С_П) определяется по формуле

С_П = 270 260 772 + 54 052 154 = 324 312 926 руб.

Прибыль ПС рассчитывается по формуле

где П_ПС - прибыль от реализации ПС заказчику (руб.);

У_Р - уровень рентабельности ПС (25%);

С_П - себестоимость ПС (руб.).

П_ПС = 324 312 926*25/100 = 81 078 231 руб.

Прогнозируемая отпускная цена ПС

.

Ц_П = 324 312 926 + 81 078 231 = 405 391 157 руб.

3.3 Расчет стоимостной оценки результата

Результатом (Р) в сфере использования программного продукта является прирост чистой прибыли и амортизационных отчислений.

3.3.1 Расчет прироста чистой прибыли

Прирост прибыли за счет экономии расходов на заработную плату в результате автоматического выполнения работ машинами, ранее выполняемых автоматизированно с участием оператора.

1. Экономия затрат на заработную плату при использовании ПС в расчете на объем выполняемых работ определяется по формуле:

Э_З = К_ПР *(tс * Т_С - tн * Тн) * N_П * (1 + Н_Д/100)*(1+Н_НО/100),

где N_П - плановый объем работ;

tc, t_H - трудоемкость выполнения работы до и после внедрения программного продукта, нормо-час;

Т_С, Т_Н - часовая тарифная ставка, соответствующая разряду выполняемых работ до и после внедрения программного продукта, руб./ч (8000 руб.);

К_ПР - коэффициент премий, (1,5);

Н_Д - норматив дополнительной заработной платы, (20%);

Н_НО - ставка отчислений от заработной платы, включаемых в себестоимость, (34,6%).

До внедрения программного продукта трудоемкость работы операторов составляла 1,3 человека-часа, после внедрения системы - 0 человека-часа. Пусть в год система проводит около 10 000 запросов-транзакций.

Экономия на заработной плате и начисления на заработную плату составит

Э_З=1,5*(1,3*8000-0*8000)*10 000*(1,2)*1,346 = 251 971 200 руб.

Прирост чистой прибыли (ДП_Ч) определяется по формуле:

,

где Н_П - ставка налога на прибыль, (18%);

C_O - общая готовая экономия текущих затрат.

Таким образом, прирост чистой прибыли составит

П_Ч = 251 971 200 - 251 971 200*18/100 = 206 616 384 руб.

3.3.2 Расчет прироста амортизационных отчислений

Расчет амортизационных отчислений осуществляется по формуле:

А = Н_А* З/100

где З - затраты на разработку программы, руб.;

Н_А - норма амортизации программного продукта, (20%);

А = 324 312 926 *0,2 = 64 862 585 руб.

3.4 Расчет показателей эффективности использования программного продукта

Для расчета показателей экономической эффективности использования программного продукта необходимо полученные суммы результата (прироста чистой прибыли) и затрат (капитальных вложений) по годам приводят к единому времени - расчетному году (за расчетный год принят 2013 год) путем умножения результатов и затрат за каждый год на коэффициент приведения (ALFA_t), который рассчитывается по формуле:

,

где Е_Н - норматив приведения разновременных затрат и результатов;

t_Р - расчетный год, t_Р = 1;

t - номер года, результаты и затраты которого приводятся к расчетному (2013-1, 2014-2, 2015-3, 2016-4).

Е_Н = 40%

(2013 год);

(2014 год);

(2015 год);

(2016 год);

Результаты расчета показателей эффективности приведены в таблице 3.2.



Таблица 3.2 ? Расчет экономического эффекта от использования нового ПС

Наименование показателей	Ед. изм.	Усл. обозн.	По годам производства
			1-й	2-й	3-й	4-й
Результат
1. Прирост чистой прибыли	руб.	?	206 616 384	206 616 385	206 616 386	206 616 387
2. Прирост амортизационных отчислений	руб.	?А	64 862 585	64 862 585	64 862 585	64 862 585
2. Прирост результата	руб.	?	271 478 969	271 478 970	271 478 971	271 478 972
3.Коэффициент дисконтирования	руб.		1	0,714	0,510	0,364
4. Результат с учетом фактора времени	руб.		271 478 969	193 835 985	138 454 275	98 818 346
Затраты (инвестиции)	руб.
5. Инвестиции в разработку программного продукта	руб.	Иоб	405 391 157
6. Инвестиции с учетом фактора времени	руб.		405 391 157
7. Чистый дисконтированный доход по годам (п.4 - п.6)	руб.		-133 912 188	193 835 985	138 454 275	98 818 346
8. ЧДД нарастающим итогом	руб.		-133 912 188	59 923 797	198 378 072	297 196 418

Рассчитаем рентабельность инвестиций в разработку и внедрение программного продукта (Р_И) по формуле

,



где - среднегодовая величина чистой прибыли за расчетный период, руб., которая определяется по формуле

,

где - чистая прибыль, полученная в году t, руб.

П_ЧСР = (826 465 536) / 4= 206 616 386 руб.

Р_И = 206 616 386 / 405 391 157*100% = 50,96%

В результате технико-экономического обоснования применения программного продукта были получены следующие значения показателей их эффективности:

1. Чистый дисконтированный доход за четыре года работы системы составит 297 196 418 руб.

2. Затраты на разработку программного продукта окупятся на второй год его использования.

3. Рентабельность инвестиций составляет 50,96%.

Таким образом, применение программного продукта является эффективным и инвестиции в его разработку целесообразно осуществлять.



ЗАКЛЮЧЕНИЕ

В соответствии с выбранной темой была разработана онтологическая база знаний. Затем была проведена интеграция базы знаний с многоагентной системой. В итоге был получен прототип интеллектуального агента.

В дипломном проекте были подробно рассмотрены следующие темы:

- Семантическая сеть;

- Онтологические базы знаний;

- Многоагентные системы.

Был проведен расчет экономической эффективности от внедрения многоагентной системы в контексте полной автоматизации обработки информации в глобальной сети. По результатам расчетов данная программная система окупается за короткий период времени, поэтому можно судить о целесообразности его внедрения.

В процессе выполнения дипломного проекта изучены основные принципы построения интеллектуальных информационных систем, а также разобрана методология создания подобных систем.



СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ

1 ГОСТ 2.106-96. ЕСКД. Белов, С.В. Безопасность жизнедеятельности: учебник для вузов. М.: Высш. шк., [Текст]. - 1999.

2 ГОСТ 2.106-96. ЕСКД. Гаврилова, Т. А. Базы знаний интеллектуальных систем / Т. А. Гаврилова, В. Ф. Хорошевский СПб.: Питер, [Текст]. -2000. - 382 с.

3 ГОСТ 2.106-96. ЕСКД. Девисилов, В. А. Охрана труда: учебник. / В. А. Девисилов. 2-е изд. испр. И доп. - М.: Форум, ИНФРА - М., [Текст]. - 2006.

4 ГОСТ 2.106-96. ЕСКД. Палицын, В.А. Технико-экономическое обоснование дипломных проектов: Метод. пособие для студ. всех спец. БГУИР. В 4-х ч. Ч. 4: Проекты программного обеспечения / В.А. Палицын. - Мн.: БГУИР, [Текст]. -2006. - 76 с.

5 Jade programming for beginners / Giovanni Caire. - Telecom Italia S.p.A., 2009.

6 Онтологии и тезаурусы: модели, инструменты, приложения: [Электронный ресурс] - Соловьев В.Д., Добров Б.В., Иванов В.В., Лукашевич Н.В., - Режим доступа: http://www.intuit.ru/studies/courses/1078/270/info

7 Semantic Future: [Электронный ресурс] - Режим доступа: http://semanticfuture.net



Приложение 1

(обязательное) Общая методология создания онтологий

Концептуализация, соответствующая каждому классификационному дереву, состоит в построении:

Рис. А.1 - Общая методология создания онтологий



Приложение 2

(обязательное) Исходные коды интеллектуального агента

package agentpack;

import jade.core.Agent;

import jade.core.behaviours.Behaviour;

import jade.core.behaviours.CyclicBehaviour;

import owlapitools.DemoOwlApi;

/**

*

* @author neutrino

*/

public class AgentReader extends Agent {

protected void setup() {

System.out.println("Agent "+getLocalName()+" started.");

// Add the CyclicBehaviour

addBehaviour(new CyclicBehaviour(this) {

public void action() {

System.out.println("Cycling");

}

});

// Add the generic behaviour

addBehaviour(new AgentReader.StepBehaviour());

}

private class StepBehaviour extends Behaviour {

private int step = 1;

public void action() {

switch (step) {

case 1:

// Perform operation 1

System.out.println("Operation 1");

DemoOwlApi.DemoReadOntToManchesterSyntax();

break;

case 2:

// Perform operation 2

System.out.println("Operation 2");

DemoOwlApi.DemoReadOntToXMLSyntax();

break;

case 3:

// Perform operation 3

System.out.println("Operation 3");

DemoOwlApi.DemoReadClassOntRef();

break;

case 4:

// Perform operation 4

System.out.println("Operation 4");

DemoOwlApi.DemoFindSuperclass();

break;

}

step++;

}

public boolean done() {

return step == 5;

}

public int onEnd() {

myAgent.doDelete();

return super.onEnd();

}

}

}

package agentpack;

import jade.core.Agent;

import jade.core.behaviours.Behaviour;

import jade.core.behaviours.CyclicBehaviour;

import owlapitools.DemoOwlApi;

/**

*

* @author neutrino

*/

public class AgentBuilder extends Agent {

protected void setup() {

System.out.println("Agent "+getLocalName()+" started.");

// Add the CyclicBehaviour

addBehaviour(new CyclicBehaviour(this) {

public void action() {

System.out.println("Cycling");

}

});

// Add the generic behaviour

addBehaviour(new AgentBuilder.StepBehaviour());

}

private class StepBehaviour extends Behaviour {

private int step = 1;

public void action() {

switch (step) {

case 1:

// Perform operation 1

System.out.println("Operation 1");

DemoOwlApi.DemoCreateBaseClass();

break;

case 2:

// Perform operation 2

System.out.println("Operation 2");

DemoOwlApi.DemoCreateSubclass();

DemoOwlApi.DemoCreateClassRestriction();

break;

case 3:

// Perform operation 3

System.out.println("Operation 3");

DemoOwlApi.DemoCreateIndividual();

DemoOwlApi.DemoCreateIndividualRelation();

break;

case 4:

// Perform operation 4

System.out.println("Operation 4");

DemoOwlApi.DemoDeleteClass();

DemoOwlApi.DemoDeleteIndividual();

break;

}

step++;

}

public boolean done() {

return step == 5;

}

public int onEnd() {

myAgent.doDelete();

return super.onEnd();

}

}

}

package agentpack;

import jade.core.Agent;

import jade.core.behaviours.Behaviour;

import jade.core.behaviours.CyclicBehaviour;

import jade.core.behaviours.OneShotBehaviour;

/**

* This example shows the basic usage of JADE behaviours.<br>

* More in details this agent executes a <code>CyclicBehaviour</code> that shows

* a printout at each round and a generic behaviour that performs four successive

* "dummy" operations. The second operation in particular involves adding a

* <code>OneShotBehaviour</code>. When the generic behaviour completes the

* agent terminates.

* @author Giovanni Caire - TILAB

*/

public class SimpleAgent extends Agent {

protected void setup() {

System.out.println("Agent "+getLocalName()+" started.");

// Add the CyclicBehaviour

addBehaviour(new CyclicBehaviour(this) {

public void action() {

System.out.println("Cycling");

}

});

// Add the generic behaviour

addBehaviour(new FourStepBehaviour());

}

/**

* Inner class FourStepBehaviour

*/

private class FourStepBehaviour extends Behaviour {

private int step = 1;

public void action() {

switch (step) {

case 1:

// Perform operation 1: print out a message

System.out.println("Operation 1");

break;

case 2:

// Perform operation 2: Add a OneShotBehaviour

System.out.println("Operation 2. Adding one-shot behaviour");

myAgent.addBehaviour(new OneShotBehaviour(myAgent) {

public void action() {

System.out.println("One-shot");

}

});

break;

case 3:

// Perform operation 3: print out a message

System.out.println("Operation 3");

break;

case 4:

// Perform operation 3: print out a message

System.out.println("Operation 4");

ProtegeJena.FirstRequest();

break;

}

step++;

}

public boolean done() {

return step == 5;

}

public int onEnd() {

myAgent.doDelete();

return super.onEnd();

}

} // END of inner class FourStepBehaviour

}

package agentpack;

import com.hp.hpl.jena.ontology.OntModel;

import com.hp.hpl.jena.ontology.OntModelSpec;

import com.hp.hpl.jena.query.Query;

import com.hp.hpl.jena.query.QueryExecution;

import com.hp.hpl.jena.query.QueryExecutionFactory;

import com.hp.hpl.jena.query.QueryFactory;

import com.hp.hpl.jena.query.ResultSetFormatter;

import com.hp.hpl.jena.rdf.model.Model;

import com.hp.hpl.jena.rdf.model.ModelFactory;

import com.hp.hpl.jena.rdf.model.Resource;

import com.hp.hpl.jena.util.FileManager;

import java.io.FileInputStream;

import java.io.InputStream;

import org.apache.log4j.BasicConfigurator;

import org.apache.log4j.Logger;

/**

*

* @author neutrino

*/

public class ProtegeJena {

Resource rec = null;

static Logger logger = Logger.getLogger(ProtegeJena.class);

/**

* @param args the command line arguments

*/

public static void FirstRequest() {

BasicConfigurator.configure();

logger.info("Entering application.");

String inputFileName="./Education.owl";

OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_MICRO_RULE_INF);

FileManager.get().readModel( model, inputFileName );

String queryString =

" PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n" +

" PREFIX owl: <http://www.w3.org/2002/07/owl#>\n" +

" PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\n" +

" PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>" +

" PREFIX ont: <http://www.semanticweb.org/neutrino/ontologies/2013/5/education#>\n" +

" SELECT ?subject\n" +

" WHERE { ?subject rdfs:subClassOf ont:Sciens}";

Query query = QueryFactory.create(queryString);

QueryExecution qe = QueryExecutionFactory.create(query, model);

com.hp.hpl.jena.query.ResultSet results = qe.execSelect();

ResultSetFormatter.out(System.out, results, query);

qe.close();

package owlapitools;

import java.io.File;

import org.semanticweb.owlapi.apibinding.OWLManager;

import org.semanticweb.owlapi.model.IRI;

import org.semanticweb.owlapi.model.OWLOntology;

import org.semanticweb.owlapi.model.OWLOntologyCreationException;

import org.semanticweb.owlapi.model.OWLOntologyFormat;

import org.semanticweb.owlapi.model.OWLOntologyManager;

import org.semanticweb.owlapi.model.OWLOntologyStorageException;

/**

*

* @author neutrino

*/

public class OwlApiInitial {

protected String ontPath = "./Education.owl";

protected OWLOntologyManager manager;

protected OWLOntology localOnt;

protected IRI documentIRI;

protected String IRIString = "http://www.semanticweb.org/neutrino/ontologies/2013/5/education";

public void LoadOntology() throws OWLOntologyCreationException

{

// Get hold of an ontology manager

setManager(OWLManager.createOWLOntologyManager());

// We can also load ontologies from files. Create a file object that points to the local copy

File file = new File(ontPath);

// Load the local copy

setLocalOnt(getManager().loadOntologyFromOntologyDocument(file));

System.out.println("Loaded ontology: " + getLocalOnt());

// We can always obtain the location where an ontology was loaded from

setDocumentIRI(getManager().getOntologyDocumentIRI(getLocalOnt()));

System.out.println(" from: " + getDocumentIRI());

}

public void SaveOntology() throws OWLOntologyCreationException, OWLOntologyStorageException

{

// Save a local copy of the ontology. (Specify a path appropriate to your setup)

File file = new File(ontPath);

manager.saveOntology(localOnt, IRI.create(file.toURI()));

// Ontologies are saved in the format from which they were loaded.

// We can get information about the format of an ontology from its manager

OWLOntologyFormat format = manager.getOntologyFormat(localOnt);

System.out.println(" Saving format: " + format);

}

public void CloseOntology()

{

// Remove the ontology again so we can reload it later

getManager().removeOntology(getLocalOnt());

}

/**

* @return the ontPath

*/

public String getOntPath() {

return ontPath;

}

/**

* @param ontPath the ontPath to set

*/

public void setOntPath(String ontPath) {

this.ontPath = ontPath;

}

/**

* @return the manager

*/

public OWLOntologyManager getManager() {

return manager;

}

/**

* @param manager the manager to set

*/

public void setManager(OWLOntologyManager manager) {

this.manager = manager;

}

/**

* @return the localOnt

*/

public OWLOntology getLocalOnt() {

return localOnt;

}

/**

* @param localOnt the localOnt to set

*/

public void setLocalOnt(OWLOntology localOnt) {

this.localOnt = localOnt;

}

/**

* @return the documentIRI

*/

public IRI getDocumentIRI() {

return documentIRI;

}

/**

* @param documentIRI the documentIRI to set

*/

public void setDocumentIRI(IRI documentIRI) {

this.documentIRI = documentIRI;

}

/**

* @return the IRIString

*/

public String getIRIString() {

return IRIString;

}

/**

* @param IRIString the IRIString to set

*/

public void setIRIString(String IRIString) {

this.IRIString = IRIString;

}

}

package owlapitools;

import java.util.Set;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.coode.owlapi.manchesterowlsyntax.ManchesterOWLSyntaxOntologyFormat;

import org.semanticweb.owlapi.apibinding.OWLManager;

import org.semanticweb.owlapi.io.SystemOutDocumentTarget;

import org.semanticweb.owlapi.model.IRI;

import org.semanticweb.owlapi.model.OWLClass;

import org.semanticweb.owlapi.model.OWLClassExpression;

import org.semanticweb.owlapi.model.OWLDataFactory;

import org.semanticweb.owlapi.model.OWLOntologyCreationException;

import org.semanticweb.owlapi.model.OWLOntologyFormat;

import org.semanticweb.owlapi.model.OWLOntologyStorageException;

public class OwlApiScan extends OwlApiInitial {

/**

*

* @throws OWLOntologyStorageException

*/

public void DumpOwlManchesterSyntax() throws OWLOntologyStorageException

{

OWLOntologyFormat format = manager.getOntologyFormat(localOnt);

// Dump an ontology to System.out by specifying a different OWLOntologyOutputTarget

//Try another format - The Manchester OWL Syntax

ManchesterOWLSyntaxOntologyFormat manSyntaxFormat =

new ManchesterOWLSyntaxOntologyFormat();

if(format.isPrefixOWLOntologyFormat()) {

manSyntaxFormat.copyPrefixesFrom(format.asPrefixOWLOntologyFormat());

}

manager.saveOntology(localOnt, manSyntaxFormat,

new SystemOutDocumentTarget());

}

public void DumpOntology()

{

try {

manager.saveOntology(localOnt, new SystemOutDocumentTarget());

} catch (OWLOntologyStorageException ex) {

Logger.getLogger(OwlApiScan.class.getName()).log(Level.SEVERE, null, ex);

}

}

/**

*

* @throws OWLOntologyCreationException

*/

public void GetClassesRef() throws OWLOntologyCreationException

{

LoadOntology();

// Show ontology references

for (OWLClass cls : localOnt.getClassesInSignature()) {

System.out.println("Referenced class: " + cls);

}

CloseOntology();

}

/**

*

* @param owlSubClass

* @throws OWLOntologyCreationException

*/

public void FindSuperclass(String owlSubClass) throws OWLOntologyCreationException

{

// Create the manager that we will use to load ontologies.

manager = OWLManager.createOWLOntologyManager();

// Create the document IRI for our ontology

documentIRI = IRI.create(IRIString);

// Specify that A is a subclass of B. Add a subclass axiom.

OWLDataFactory factory = manager.getOWLDataFactory();

// Get hold of references to class A and class B.

OWLClass clsA = factory.getOWLClass(IRI.create(documentIRI + "#"+owlSubClass));

LoadOntology();

// We should also find that B is an ASSERTED superclass of A

Set<OWLClassExpression> superClasses = clsA.getSuperClasses(localOnt);

System.out.println("Asserted superclasses of " + clsA + ":");

for (OWLClassExpression desc : superClasses) {

System.out.println(desc);

}

CloseOntology();

}

}

package owlapitools;

import java.util.Collections;

import java.util.Set;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.semanticweb.owlapi.apibinding.OWLManager;

import org.semanticweb.owlapi.model.AddAxiom;

import org.semanticweb.owlapi.model.IRI;

import org.semanticweb.owlapi.model.OWLAxiom;

import org.semanticweb.owlapi.model.OWLClass;

import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;

import org.semanticweb.owlapi.model.OWLClassExpression;

import org.semanticweb.owlapi.model.OWLDataFactory;

import org.semanticweb.owlapi.model.OWLDeclarationAxiom;

import org.semanticweb.owlapi.model.OWLIndividual;

import org.semanticweb.owlapi.model.OWLNamedIndividual;

import org.semanticweb.owlapi.model.OWLObjectProperty;

import org.semanticweb.owlapi.model.OWLObjectPropertyAssertionAxiom;

import org.semanticweb.owlapi.model.OWLOntology;

import org.semanticweb.owlapi.model.OWLOntologyCreationException;

import org.semanticweb.owlapi.model.OWLOntologyManager;

import org.semanticweb.owlapi.model.OWLOntologyStorageException;

import org.semanticweb.owlapi.model.OWLSubClassOfAxiom;

import org.semanticweb.owlapi.model.PrefixManager;

import org.semanticweb.owlapi.util.DefaultPrefixManager;

import org.semanticweb.owlapi.util.OWLEntityRemover;

/**

*

* @author neutrino

*/

public class OwlBuilder extends OwlApiInitial{

/**

*

* @param owlClass

* @param owlSubClass

* @throws OWLOntologyCreationException

*/

public void CreateOwlSubclass(String owlClass, String owlSubClass) throws OWLOntologyCreationException

{

// Create the manager that we will use to load ontologies.

manager = OWLManager.createOWLOntologyManager();

// Create the document IRI for our ontology

documentIRI = IRI.create(IRIString);

// Specify that A is a subclass of B. Add a subclass axiom.

OWLDataFactory factory = manager.getOWLDataFactory();

// Get hold of references to class A and class B.

OWLClass clsA = factory.getOWLClass(IRI.create(documentIRI + "#"+owlSubClass));

OWLClass clsB = factory.getOWLClass(IRI.create(documentIRI + "#"+owlClass));

// Create the axiom

OWLAxiom axiom = factory.getOWLSubClassOfAxiom(clsA, clsB);

LoadOntology();

// Add the axiom to the ontology, so that the ontology states that A is a subclass of B.

AddAxiom addAxiom = new AddAxiom(localOnt, axiom);

// Use the manager to apply the change

manager.applyChange(addAxiom);

// The ontology will now contain references to class A and class B.

for (OWLClass cls : localOnt.getClassesInSignature()) {

System.out.println("Referenced class: " + cls);

}

// We should also find that B is an ASSERTED superclass of A

Set<OWLClassExpression> superClasses = clsA.getSuperClasses(localOnt);

System.out.println("Asserted superclasses of " + clsA + ":");

for (OWLClassExpression desc : superClasses) {

System.out.println(desc);

}

try {

// Save the ontology to the location where we loaded it from, in the default ontology format

SaveOntology();

} catch (OWLOntologyStorageException ex) {

Logger.getLogger(OwlBuilder.class.getName()).log(Level.SEVERE, null, ex);

}

}

/**

*

* @param owlClass

* @throws OWLOntologyCreationException

*/

public void CreateOwlClass(String owlClass) throws OWLOntologyCreationException

{

// In order to get access to objects that represent entities we need a data factory.

manager = OWLManager.createOWLOntologyManager();

// Get a reference to a data factory from an OWLOntologyManager.

OWLDataFactory factory = manager.getOWLDataFactory();

// Create the document IRI for our ontology

documentIRI = IRI.create(IRIString);

// Create the class

OWLClass clsAMethodA = factory.getOWLClass(IRI.create(documentIRI + "#"+owlClass));

LoadOntology();

// We can add a declaration axiom to the ontology, that essentially adds the class to the

// signature of our ontology.

OWLDeclarationAxiom declarationAxiom = factory.getOWLDeclarationAxiom(clsAMethodA);

manager.addAxiom(localOnt, declarationAxiom);

try {

// Save the ontology to the location where we loaded it from, in the default ontology format

SaveOntology();

} catch (OWLOntologyStorageException ex) {

Logger.getLogger(OwlBuilder.class.getName()).log(Level.SEVERE, null, ex);

}

System.out.println("Class " + clsAMethodA + "created");

}

/**

*

* @param owlClass

* @throws OWLOntologyCreationException

*/

public void DeleteClass(String owlClass) throws OWLOntologyCreationException

{

// Load ontology.

LoadOntology();

OWLDataFactory dataFactory = manager.getOWLDataFactory();

PrefixManager pm = new DefaultPrefixManager(IRIString);

// Get reference to the individual

OWLClass entityOwl = dataFactory.getOWLClass("#"+owlClass, pm);

// We can't directly delete individuals, properties or classes from an ontology because

// ontologies don't directly contain entities - they are merely referenced by the

// axioms that the ontology contains. We can use the OWLEntityRemove utility class, which

// will remove an entity (class, property or individual) from a set of ontologies.

OWLEntityRemover remover = new OWLEntityRemover(manager, Collections.singleton(localOnt));

entityOwl.accept(remover);

// Get all of the changes from the entity remover, which should be applied to remove all the

// individuals that we have visited from the pizza ontology. Notice that "batch" deletes can

// essentially be performed - we simply visit all of the classes, properties and individuals that we

// want to remove and then apply ALL of the changes after using the entity remover to collect them

manager.applyChanges(remover.getChanges());

System.out.println("Remove class: " + owlClass);

// At this point, if we wanted to reuse the entity remover, we would have to reset it

remover.reset();

try {

// Save the ontology to the location where we loaded it from, in the default ontology format

SaveOntology();

} catch (OWLOntologyStorageException ex) {

Logger.getLogger(OwlBuilder.class.getName()).log(Level.SEVERE, null, ex);

}

}

/**

*

* @throws OWLOntologyCreationException

* @throws OWLOntologyStorageException

*/

public void CreateIndividual(String owlClass, String owlIndividual)

throws OWLOntologyCreationException, OWLOntologyStorageException

{

// For example, suppose we wanted to specify that :Mary is an instance of the class :Person.

// First we need to obtain the individual :Mary and the class :Person

// Create an ontology manager to work with

manager = OWLManager.createOWLOntologyManager();

OWLDataFactory dataFactory = manager.getOWLDataFactory();

PrefixManager pm = new DefaultPrefixManager(IRIString);

// Get reference to the class

OWLClass entityOwl = dataFactory.getOWLClass("#"+owlClass, pm);

// Get reference to the individual

OWLNamedIndividual individ = dataFactory.getOWLNamedIndividual("#"+owlIndividual, pm);

// Create a ClassAssertion to specify that :Mary is an instance of :Person

OWLClassAssertionAxiom classAssertion =

dataFactory.getOWLClassAssertionAxiom(entityOwl, individ);

// Add the class assertion to the ontology

LoadOntology();

manager.addAxiom(localOnt, classAssertion);

try {

// Save the ontology to the location where we loaded it from, in the default ontology format

SaveOntology();

} catch (OWLOntologyStorageException ex) {

Logger.getLogger(OwlBuilder.class.getName()).log(Level.SEVERE, null, ex);

}

}

/**

*

* @param owlIndividual

* @throws OWLOntologyCreationException

*/

public void DeleteIndividual(String owlIndividual) throws OWLOntologyCreationException

{

// Load ontology.

LoadOntology();

OWLDataFactory dataFactory = manager.getOWLDataFactory();

PrefixManager pm = new DefaultPrefixManager(IRIString);

// Get reference to the individual

OWLNamedIndividual individ = dataFactory.getOWLNamedIndividual("#"+owlIndividual, pm);

// We can't directly delete individuals, properties or classes from an ontology because

// ontologies don't directly contain entities - they are merely referenced by the

// axioms that the ontology contains. We can use the OWLEntityRemove utility class, which

// will remove an entity (class, property or individual) from a set of ontologies.

OWLEntityRemover remover = new OWLEntityRemover(manager, Collections.singleton(localOnt));

System.out.println("Number of individuals: " + localOnt.getIndividualsInSignature().size());

individ.accept(remover);

// Get all of the changes from the entity remover, which should be applied to remove all the

// individuals that we have visited from the pizza ontology. Notice that "batch" deletes can

// essentially be performed - we simply visit all of the classes, properties and individuals that we

// want to remove and then apply ALL of the changes after using the entity remover to collect them

manager.applyChanges(remover.getChanges());

System.out.println("Number of individuals: " + localOnt.getIndividualsInSignature().size());

// At this point, if we wanted to reuse the entity remover, we would have to reset it

remover.reset();

try {

// Save the ontology to the location where we loaded it from, in the default ontology format

SaveOntology();

} catch (OWLOntologyStorageException ex) {

Logger.getLogger(OwlBuilder.class.getName()).log(Level.SEVERE, null, ex);

}

}

/**

*

* @param owlIndividual1

* @param indProperty

* @param owlIndividual2

* @throws OWLOntologyCreationException

* @throws OWLOntologyStorageException

*/

public void SetIndividualAssertions(String owlIndividual1, String indProperty, String owlIndividual2)

throws OWLOntologyCreationException, OWLOntologyStorageException

{

LoadOntology();

OWLDataFactory dataFactory = manager.getOWLDataFactory();

// We use the data factory to obtain references to individuals

OWLIndividual ind1 = dataFactory.getOWLNamedIndividual(

IRI.create(IRIString + "#"+owlIndividual1));

OWLIndividual ind2 = dataFactory.getOWLNamedIndividual(

IRI.create(IRIString + "#"+owlIndividual2));

// Link the subject and object with the property.

OWLObjectProperty objProperty = dataFactory.getOWLObjectProperty(

IRI.create(IRIString + "#" + indProperty));

// Create the actual assertion (triple), as an object property assertion axiom

OWLObjectPropertyAssertionAxiom assertion =

dataFactory.getOWLObjectPropertyAssertionAxiom(objProperty, ind1, ind2);

// Finally, add the axiom to our ontology

AddAxiom addAxiomChange = new AddAxiom(localOnt, assertion);

manager.applyChange(addAxiomChange);

// Save our ontology

try {

// Save the ontology to the location where we loaded it from, in the default ontology format

SaveOntology();

} catch (OWLOntologyStorageException ex) {

Logger.getLogger(OwlBuilder.class.getName()).log(Level.SEVERE, null, ex);

}

}

public void ClassPropertyRestrictions(String owlClass1, String classProperty, String owlClass2) throws OWLOntologyCreationException

{

LoadOntology();

OWLDataFactory dataFactory = manager.getOWLDataFactory();

// Add an axiom to state that all Heads have parts that are noses.

// First we need to obtain references to our property and our class

OWLDataFactory factory = manager.getOWLDataFactory();

OWLObjectProperty objProperty = factory.getOWLObjectProperty(IRI.create(IRIString + "#" + classProperty));

OWLClass owlClassForm2 = factory.getOWLClass(IRI.create(IRIString + "#" + owlClass2));

// Now create a restriction to describe the class of individuals

OWLClassExpression hasProperty =

factory.getOWLObjectSomeValuesFrom(objProperty, owlClassForm2);

// Obtain a reference to the class

OWLClass owlClassForm1 = factory.getOWLClass(IRI.create(IRIString + "#" + owlClass1));

// We now want to create statement

OWLSubClassOfAxiom ax = factory.getOWLSubClassOfAxiom(owlClassForm1, hasProperty);

// Add the axiom to our ontology

AddAxiom addAx = new AddAxiom(localOnt, ax);

manager.applyChange(addAx);

try {

// Save the ontology to the location where we loaded it from, in the default ontology format

SaveOntology();

} catch (OWLOntologyStorageException ex) {

Logger.getLogger(OwlBuilder.class.getName()).log(Level.SEVERE, null, ex);

}

}

}

package owlapitools;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.semanticweb.owlapi.model.OWLOntologyCreationException;

import org.semanticweb.owlapi.model.OWLOntologyStorageException;

/**

*

* @author neutrino

*/

public class DemoOwlApi {

/**

* @param args the command line arguments

*/

public static void DemoReadOntToManchesterSyntax()

{

//dump ontology

OwlApiScan owlkaReader = new OwlApiScan();

try {

owlkaReader.LoadOntology();

owlkaReader.DumpOwlManchesterSyntax();

} catch (OWLOntologyStorageException | OWLOntologyCreationException ex) {

Logger.getLogger(DemoOwlApi.class.getName()).log(Level.SEVERE, null, ex);

}

owlkaReader.CloseOntology();

}

public static void DemoReadOntToXMLSyntax()

{

//dump ontology

OwlApiScan owlkaReader = new OwlApiScan();

try {

owlkaReader.LoadOntology();

owlkaReader.DumpOntology();

} catch (OWLOntologyCreationException ex) {

Logger.getLogger(DemoOwlApi.class.getName()).log(Level.SEVERE, null, ex);

}

owlkaReader.CloseOntology();

}

public static void DemoReadClassOntRef()