(U1.03.01) Обзор супервизора и языка

Материал из ru.wiki.laduga.ru
Перейти к: навигация, поиск

Управление процессом:

Этот документ описывает роль и функционирование:

  • супервизора, который обеспечивает контроль выполнения Code_Aster;
  • языка управления процессом, который обеспечивает взаимодействие между пользователем и программой.


Содержание

1 Вступление

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

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

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



2 Общий механизм работы супервизора

2.1 Основные принципы архитектуры

Исходные понятия процесса вычислений Aster:

  • командный файл, предоставленный пользователем;
  • каталог команд – это модуль Python с именем cata в пакете Cata;
  • высокоуровневый объект SUPERVISEUR;
  • объект JDC, созданный последним, и выполняющийся в конце.

Объект SUPERVISEUR является объектом Python, который анализирует параметры, передаваемые в командной строке, импортирует каталог команд, создает объект JDC начиная с командного файла, и выполняет вышеупомянутое.

Объект JDC (имя для Набора команд) - это объект Python созданный объектом SUPERVISEUR начиная с текста командного файла и модуля каталогов команд. Он содержит объекты ETAPE. Объект JDC является представителем командного файла пользователя.

Объекты ETAPE являются характеристикой каждого вызова команд Aster в командном файле. Каждый объект ETAPE несет имя команды, на которую он ссылается, список активных ключевых слов и их значений, тип и название концепции продукта.

Построение и последующее выполнение объекта JDC включает следующие действия:

  • разбор командного файла пользователя: проверяется синтаксис Python (скобки, запятые между ключевыми словами, отступы и т.п.). Обнаружение ошибки (SyntaxError Python) приводит к остановке выполнения Aster. Первая ошибка критическая: дальнейший поиск ошибок производиться не будет;
  • формирование этапов: создание объекта ETAPE для каждого вызова команды Aster в командном файле. Этот объект записывается в JDC, который управляет списком этапов и связанными понятиями;
  • проверка каждого ETAPE: если вызов команды в файле пользователя не связан с каталогом команд, выводится отчет и выполнение останавливается на этом этапе - это семантическая проверка;
  • непосредственное выполнение команд: последовательно каждый этап.

2.2 Комплексное или пошаговое выполнение

Набор команд может быть составлен и выполнен в соответствии с двумя режимами:

  • комплексный режим, для которого все этапы набора команд первоначально построены, а затем выполнены в порядке их появления. Этот режим задается ключевым словом PAR_LOT='OUI' в команде DEBUT;
  • пошаговый режим, в котором каждый этап немедленно вызывается после его задания. Этот режим задается ключевым словом PAR_LOT='NON' в команде DEBUT;

Если пользователь явно не задает режим выполнения, по умолчанию выбирается комплексный режим (PAR_LOT='OUI'). Представленные режимы имеют свои преимущества и недостатки.

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

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

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

В этом режиме выполненный этап сразу освобождается из памяти. Используемая память независимо распределяется между выполняемыми этапами.

Ниже приведен пример цикла с вычисляемым значением в качестве критерия остановки, которое размещается в концепции counts : RELV [K]. Если, к примеру, обязательное ключевое слово отсутствует в вызове POST_RELEVE_T, это будет обнаружено только после полного выполнения первого MECA_STATIQUE. С другой стороны, пошаговый режим представляет возможным присвоение значения переменной SYY после того, как концепция RELV [K] будет полностью вычислена во время выполнения супервизором этой строки.

   DEBUT (PAR_LOT='NON')

    RESU= [None] *10
    RELV= [None] *10

    for K in arranges (1.10):

        RESU [K] =MECA_STATIQUE (…)
        RELV [K] =POST_RELEVE_T (…)
        SYY=RELV [K] [“VMIS”, 4]

        yew SYY < criterion:
        station-wagon

    FIN ()

Следует обратить внимание на выбор порядка выполнения семантического анализа (этап за этапом или полностью по всему JDC). Но в обоих случаях Python всегда производит предварительный разбор для всего командного файла.

 Примечание:
   EFICAS может генерировать и читать только наборы команд, содержащие исключительно команды ASTER 
   без других инструкций Python не зависимо от выбранного режима mode PAR_LOT.

2.3 Процесс формирования

На этапах формирования каждого объекта ETAPE выполняется проверка семантической согласованности с каталогом команд, к которому он относится. Каждая обнаруженная ошибка добавляется в отчет, который представляется после анализа всего командного файла.

Примеры семантических проверок:

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

Если команда является оператором и формирует концепцию, характерно вышеизложенное. Супервизор проверяет, не была ли уже определена концепция с таким же именем, или, если она используется повторно, разрешает её выполнение.

2.4 Обработка макрокоманд

Со стороны пользователя макрокоманда является обычной командой. На самом деле, она напрямую не вызывает высокоуровневую процедуру FORTRAN, а генерирует другие команды.

Существует два типа макрокоманд:

  • макросы Python;
  • контрольные макросы: специальные команды (DEBUT, FORMULA, INCLUDE, INCLUDE_MATERIAU, POURSUITE), необходимые для обработки уровней их конструкции.

Так же, как и JDC, вызов макро-команды производит родительский объект (типа MACROETAPE), который содержит связанные объекты: этапы которые генерируют другие макроэтапы, даже другие макросы.

Прежде всего, макрокоманда JDC рассматривается как другие команды (синтаксическая проверка, построение макроэтапа). Далее она формируется приложением с помощью метода Build объекта JDC. После её построения этапы команд, произведенных макрокомандами, замещаются макроэтапами для дальнейшего выполнения.

Важно отметить, что фаза формирования макрокоманд происходит непосредственно перед их выполнением и не во время нахождения главного ключа командного файла в режиме PAR_LOT='OUI'. Существует две последствия:

  • EFICAS анализирует синтаксис самой макрокоманды, но не подкоманды;
  • С другой стороны, в программировании макросов можно использовать данные, ранее вычисленные и репатриированные в области пространства имен Python, без необходимости установления пользователем режима PAR_LOT='NON'.

2.5 Процесс загрузки

Доступные процессы загрузки:

  • DEBUT
  • POURSUITE

По крайней мере, одна из этих двух процедур должна обязательно присутствовать в командном файле. Никакие другие команды Aster не должны предшествовать им. В другом случае выполнение будет остановлено в процессе создания JDC. Эти процедуры, содержат информацию о процедуре (PAR_LOT ='OUI' или 'NON'), которая обусловливает выполнение последующих команд.

Фактически супервизор вызывает подпрограммы ФОРТРАН, позволяющие инициализировать вычисление по следующим задачам:

  • "соединение" логических единиц стандартных файлов;
  • открытие баз данных;
  • чтение каталога элементов.

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

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

Последовательность команд, которые необходимо выполнить в конце, задается командой FIN. Текст, который сопровождает команду FIN должен быть закомментирован (т.е. начинаться с #). Для приведенного файла это команда RETOUR, которая обозначает конец инструкций, которые должны быть приняты во внимание ASTER.

  Примечание:
      В интерактивном режиме, осуществляемом при помощи ручного управления, не размещайте команду FIN и поместите аргумент interact в строке по порядку представления задания.

2.6 Ограничения с EFICAS

Ядро супервизора является общим с Eficas, редактором командных файлов Aster. В момент редактирования командного файла, вышеупомянутый осуществляет синтаксический анализ и проверку согласованности концепций путем формирования JDC и объектов ETAPE. Конечно, Eficas не выполняет задачу построения макро-команд, что потребует исходный код Aster.



3 Язык Python

3.1 Управление процессом и язык управления процессом

Командный файл для Code_Aster составлен исключительно из инструкций Python. Прежде всего, для того, чтобы соответствовать правилам этого языка. Можно прочитать учебное руководство по Python (www.python.org) или много книг по введению в Python для разъяснения подробностей, но это не необходимо для использования Aster.

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

Во фрейме "стандартного" использования кода, где командный файл содержит исключительно команды Aster, существуют два правила, определенные для Python, которые должны учитываться:

  • Отсутствие отступа на первой строке оператора инструкции
    e-mail = LIRE_MAILLAGE () 
    Нельзя помещать ни пробел, ни табуляцию перед символьной строкой e-mail.
  • Аргументы функций или, другими словами, ключевые слова команд разделены запятыми; они состоят из ключевых слов, знака “=”, содержимого ключевого слова.

Важно:

Редактор EFICAS позволяет создавать только командные файлы такого типа: содержащие исключительно команды ASTER без других инструкций Python. Использование EFICAS прежде всего гарантирует три вещи:

  • созданный файл будет иметь корректный синтаксиса Python;
  • генерируемые команды будут соответствовать каталогу команд,
  • результирующие концепции будут правильно соединены (не используются концепции, которые не были созданы предыдущей командой).

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

3.2 Определение концепции

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

Понятие концепции, таким образом, позволяет пользователю обработать объекты символически и независимо от их внутреннего представления (которое он может не знать). Кроме того, объект Python, обозначенный именем концепции, не содержит никакую другую информацию, кроме ее типа и класса в значении Python (cf Doc. D). Это имя, которое супервизор передает FORTRAN, позволяет Aster найти соответствующую структуру данных в общей базе. Но невозможно обнаружить структуру по имени командного файла. Например, следующие инструкции не позволяют распечатать структуру данных типа mesh и имени e-mail:

   mail=LIRE_MAILLAGE ()
   print e-mail

и сгенерируют следующее сообщение:

   <Cata.cata.maillage_sdaster object At 0x593cad0>

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

   to print a value: print resu [` DX' , 1]
   to assign it to a variable: valeur=resu [` DX' , 1]

Это предполагает, конечно, что структура данных resu типа COUNTS была уже вычислена к тому времени, как эта инструкция встретилась - посредством пошагового выполнения (PAR_LOT ='NON').

   Примечание:
        Длина имени концепции не должна превышать 8 символов. Разрешены буквенно-цифровые символы (строчные и заглавные буквы и цифры, не размещенные в начале имени), 
        а также нижнее подчеркивание ‘_’. Концепции “MAIL” и “Mail” могут использоваться в одном и том же командном файле и будут расценены как различные, 
        однако, это не советуется для разборчивости файла.

3.3 Возможные операции

Структура языка управления процессом определяется как линейная последовательность инструкций. В дополнение к инструкциям Python кроме команд Aster, которые сейчас не рассматриваются, доступны три типа инструкций (или команд):

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

Как правило, оператор будет упорядочиванием присваивания или разрешения, процедура будет упорядочиванием печати (в файле).

С синтаксической точки зрения оператор представляется в форме:

   nomconcept = operator (arguments…)

Таким образом, процедура представлена в виде:

   procedure (arguments…)

Синтаксис оператора или процедуры описан в следующем параграфе.

3.4 Правила концепции продукта

3.4.1 Руководящий принцип

Каждое выполнение оператора, как описано выше, производит новую концепцию продукта предопределенного типа в каталоге команд.

Концепции, использующиеся в аргументах ввода команд, не изменяются.

3.4.2 Концепция продукта и повторно используемая концепция

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

В соответствии с основным принципом использование повторно используемой концепции не представляется возможным:

  • разрешение на использование повторно используемых концепций оператору: атрибут reentrant каталога имеет значение ‘O’ или ‘F’;
  • Явный запрос пользователя на повторное использование концепции продукта осуществляется с помощью атрибута reuse=nom_du_concept в аргументах команд, которые позволяют это.

3.4.3 Проверки производимых концепций, выполняемые супервизором

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

Супервизор удостоверяется в том, что имя концепции продукта еще не выделено одной из предыдущих команд, в частности путем упорядочивания выполнения в случае POURSUITE или INCLUDE.

Повторно используемая концепция:

Супервизор удостоверяется в том, что:

  • имя концепции продукта правильно выделено;
  • оператор вправе использовать повторно используемые концепции;
  • тип концепции соответствует типу концепции продукта оператора

Примеры с примечаниями:

   DEBUT ()
   concept=operator ()		# (1) корректно: определение концепции;
   concept=operator ()		# (2) некорректно: попытка переопределения концепции без объявления этого;
   concept=operator (reuse = concept) 	# (3) корректно, если оператор принимает существующую концепцию соответствующего типа; 
   FIN ()

Фактически концепция может быть создана только один раз: что определяется использованием знака = (равно) без reuse, используемого в параметрах команды.

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

   Примечание:
       Можно уничтожить концепцию, а после повторно использовать её имя.

3.5 Тело команды

3.5.1 Вступление

Тело команды содержит "переменную" часть команды. Операторы разделены запятыми и за исключением упомянутого выше атрибута reuse, они все имеют вид:

   [mot_clé] = [argument]	

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

3.5.2 Ключевое слово

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

Пример: STAMP =…

Замечания по синтаксису:

  • Порядок появления ключевых слов произвольный, на него не влияет порядок расположения операторов в каталогах;
  • Длина ключевых слов не может превышать 16 символов (но только первые 10 символов - значащие).

Существует два типа ключевых слов: асимметричные слова и факторы ключевых слов, которые по своей природе отличаются от их параметров.

3.5.3 Параметры простого ключевого слова

3.5.3.1 Тип параметров

Основные типы, распознаваемые супервизором:

  • целые числа;
  • вещественные числа;
  • комплексные числа;
  • текстовые;
  • логические;
  • концепции;
  • а также списки этих основных типов

Целые и вещественные числа полностью соответствуют эквивалентным типам Python.

•Дополнительное простое ключевое слово, обозначающее вещественное число:

   Каталог: VALE= SIMP (statut='F' , typ = ` R' ),
   Командный файл: VALE=10.

•Дополнительное простое ключевое слово, обозначающее целое число:

   Каталог: INFO= SIMP (statut='F' , typ = ` I' ),
   Командный файл: INFO=1.

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

   Каталог: VALE_C= SIMP (statut='F' , typ = ` It),
   Командный файл: VALE_C = (` IH', 0,732,-0 732),
   Командный файл: VALE_C = (` MP', 1. -45. ),

Эти две нотации строго эквивалентны. В нотации ‘MP’ фаза задается в градусах.

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

   Каталог: TOUT=SIMP (typ= ` TXM', into= (` OUI','NON')),
   Командный файл: TOUT= ` OUI',

Следующая командная строка не будет работать:

   Командный файл: TOUT= ` yes',

Логический тип сегодня не используется в каталоге команд.

Концепция объявлена просто по ее имени без использования кавычек.

3.5.3.2 Концепция внимания

Список:

Здесь слово "список" является неподходящим. Это не тип списков Python, а, скорее, кортеж в терминологии Python: различные элементы объявляются между открывающей и закрывающей круглыми скобками и разделяются запятыми.

Списки - гомогенные, т.е. их элементы имеют тот же основной тип. Любой основной тип может использоваться в списке.

Примеры списков:

  • список целых чисел (1, 2,3,4);
  • текстовый список (“this”, “is”, “one”, “list”, “of”, “text”);
  • список концепций (resu1, resu2, resu3).

Удобство для пользователя:

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

Пример ошибочного задания списка:

Разнородный список целых и вещественных чисел (1, 3.4.)

3.5.4 Фактор ключевого слова

Некоторая информация не может быть выдана полностью (сразу в одной команде), таким образом, важно предусмотреть повторение определенных ключевых слов, чтобы иметь возможность влиять на различные их параметры. Фактор ключевого слова предоставляет такую возможность; под фактором ключевого слова можно найти ряд ключевых слов, которые могут использоваться при каждом появлении фактора ключевого слова. Кроме всего прочего, это позволяет улучшить четкость командного файла, путем объединения ключевых слов, которые имеют общее значение: например, различные параметры одного и того же материала.

В отличие от простого ключевого слова фактор ключевого слова может принимать один тип объекта: контролирующий объект "_F" или список вышеупомянутого.

Если фактор ключевого слова появляется только один раз, можно записать, например, на выбор:

   IMPRESSION=_F ( RESULTAT =resu , UNITE = 6),

или

   IMPRESSION= ( _F ( RESULTAT =resu , UNITE = 6),).

В первом случае, фактор ключевого слова PRINTING получает объект _F, во втором - одиночный элемент. Особое внимание следует обратить на запятую; в Python записан кортеж с элементом: (element,).

Фактор ключевого слова может использоваться несколько раз, в этом примере - два:

   IMPRESSION= ( _F ( RESULTAT =RESU1 , UNITE = 6),
                 _F ( RESULTAT =RESU2 , UNITE = 7) ),

Число ожидаемых возникновений (минимум и/или максимум) фактора ключевого слова определено в каталоге команд.

Значение по умолчанию

Супервизор имеет возможность влиять на значения по умолчанию. Эти значения определены в каталоге команд, а не в FORTRAN.

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

Спускайтесь на веревке: нельзя дать значение по умолчанию понятию.

Напоминание: нельзя задавать значение по умолчанию концепции.



4 Определение значений и оценок операторов

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

Пример:

   young=2.E+11
   mat=DEFI_MATERIAU (ELAS = _F ( E = Young, NU = 0.3))

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

Возможно выполнять операции в Python с простыми параметрами ключевых слов:

   Pisur2=pi /2.
   mat=MA_COMMANDE (VALE = Pisur2)

или

   var= ' world'
   mat=MA_COMMANDE ( VALE= pi/2. ,
   VALE2= Pisur2+cos (30.),
   TEXTE= ` hello'+var )



5 Использование Python в командных файлах

Нет необходимости знать язык Python для использования Code_Aster. Действительно, с помощью некоторых основных правил, относящихся к добавлению отступа и заключению в скобки, необходимо только знание языка управления процессом, используемого в каталогах команд. И тем не менее, EFICAS позволяет освободить пользователя от обращения к каталогу или абзацу "синтаксис" команд, предоставляя ключевые слова графически для информирования.

Однако, опытный пользователь сможет использовать силу языка PYTHON в своем командном файле, так как вышеупомянутое уже записано на этом языке.

Четырьмя основными случаями использования могут быть: запись персонализированных макрокоманд, использование общих инструкций Python, импорт полезных модулей Python, восстановление информации структур данных Code_Aster в переменных PYTHON.

  Примечание:
        Если Вы хотите использовать французские акцентированные символы в командном файле или импортированных модулях, необходимо поместить следующие инструкции в первый или вторую строку файла:
        # - * - coding: Iso-8859-1 - *En
        В Python 2.3 отсутствие этой строки вызывает предупреждение, которое становится ошибкой в Python 2.4; в Aster это также ошибка.

5.1 Персонализированные макрокоманды

Персонализированные макрокоманды очень просты к программе. Они могут использоваться для капитализации повторяющихся схем вычисления и, таким образом, образования инструмента торговли. Строго рекомендовано брать пример с существующих макрокоманд:

   пакет Macro в директории bibpyt.

5.2 Общие инструкции Python и полезные модули

Опытные пользователи могут извлечь большую пользу из использования циклов, проверок, исключений и вообще из всей мощи языка PYTHON непосредственно в своем командном файле. Невозможно составить исчерпывающий список вариантов использования. Есть много примеров использования проверок из базы проверок. Можно, например, сделать адаптацию цикла при размещении последовательности вычислений/исправлений в цикле, путем задания критерия остановки итераций в виде проверки вычисленного значения.

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

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

  • чтение-запись файла;
  • численные вычисления (например, используя Numerical Python);
  • вызов с помощью модуля bone скриптовых языков и, в частности, запуск другого кода (os.system);
  • обработка символьных строк;
  • вызов графических модулей (grace, gnuplot)

5.3 Исключения PYTHON модулей Aster

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

   try:
       block of instructions
   except ErreurIdentifiée, message:
       block of instructions executed if ErreurIdentifiée occurs…

В командном файле можно использовать этот механизм с любым исключением стандартных модулей Python. Есть исключения, подходящие для Code_Aster (с модулем Aster), разделенные на две категории: связанные с ошибками <S> и связанные с ошибками <F>.

5.3.1 Исключения ошибок <S>

Ошибка <S> идентифицирована одним из следующих исключений:

   aster.NonConvergenceError - в случае несходимости вычислений,
   aster.EchecComportementError - проблема во время интеграции учредительного закона,
   aster.BandeFrequenceVideError - в режиме, не найденном в диапазоне волн,
   aster.MatriceSinguliereError - одиночная матрица,
   aster.TraitementContactError - проблема во время обработки контакта,
   aster.MatriceContactSinguliereError - одиночная контактная матрица,
   aster.ArretCPUError - остановка из-за нехватки времени ЦП.

Все эти исключения проистекают из общего исключения <S>, в aster.error. Что означает, что исключение aster.error перехватывает все исключения, заключенные в кавычки ниже. Тем не менее, более предпочтительно явно указывать, какую именно ошибку ожидает каждое.

Примеры использования:

   try:
      resu = STAT_NON_LINE (...)
   except aster.NonConvergenceError, message:
      print ` Arrêt for this reason: %s' % str (message)
      # Известно, что нужно в намного больше итераций, для схождения
      print “One continues by increasing the iteration count.”
      resu = STAT_NON_LINE (reuse = resu,
                           …,
                           CONVERGENCE=_F (ITER_GLOB_MAXI=400,),)
   except aster.error, message:
      print “Une autre error occurred: %s” % str (message)
      print “Stop”
      from Utilitai.Utmess importation UTMESS
      UTMESS (` F', ` Example', ` unexpected <S> Error')

5.3.2 Исключения ошибок <F>

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

По умолчанию, программа останавливается по ошибке <F>, можно увидеть увеличение ошибки (вызвать подпрограммы FORTRAN) в выходном файле.

По желанию программа может увеличить исключение aster.FatalError, и в этом случае (относительно ошибок <S>), если исключение прервано except, пользователь снова принимает участие, если программа не остановлена (не увеличена ошибка FORTRAN).

Этот выбор предоставляется в командах DEBUT/POURSUITE, фактором ключевого слова ERREUR и в любое время методом aster.onFatalError.

Последний вызываемый элемент без параметра меняет текущее поведение в случае фатальной ошибки:

   comport = aster.onFatalError ()
   print “Comportement running in the event of fatal error: %s” % comport

и предоставляет возможность определить нужное поведение:

   aster.onFatalError (` EXCEPTION') # повышение исключения FatalError

или

   aster.onFatalError (` ABORT') # остановка с увеличением ошибки.

5.3.3 Обоснованность концепций

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

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

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

В случае ошибки <S>, сформированной в STAT/DYNA_NON_LINE, концепция обычно допустима, и может быть снова использована (ключевое слово reuse), чтобы продолжить вычисление по другой стратегии.

Наконец, прежде чем предоставить управление пользователю, объекты базы удаляются вызовом JEDETV и метки Jeveux меняют местоположение на 1 (с JEDEMA), чтобы освободить объекты, возвращенные в память.

5.3.4 Предостережения для использования исключений

Два исключения aster.error и aster.FatalError независимы (не происходят друг из друга), это означает что, в случае ошибки <S> и <F>:

необходимо активировать поднятие исключения в случае ошибки <F> с помощью
   aster.FatalError (“EXCEPTION') or in DEBUT/POURSUITE.
эти два исключения должны быть прерваны:
   except (aster.FatalError, aster.error), message: …

Не рекомендуется использовать “except: ” не определяя, какое исключение ожидается (это общее правило Python независимо от исключений Aster). Действительно, обработка, выполняемая после исключения, маловероятно допустима во всех случаях ошибок.

Таким же образом, как в примере, описанном выше, предпочтительно использовать конкретизированные исключения NonConvergenceError, ArretCPUError и другие исключения более низкого уровня, чем aster.error; чтобы знать точно, что было произведено.

5.4 Восстановление вычисленных значений переменных PYTHON

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

Существуют определенные связи между Python и структурами данных, вычисленными программой и представленными в памяти JEVEUX. Остальные должны быть запрограммированы; это поле дальнейшего развития и будущих разработок.

Важно понимать, что для восстановления вычисленных данных требуется, чтобы инструкции, участвующие в их получении, действительно выполнялись предварительно. Другими словами, важно выполнять программу в режиме PAR_LOT ='NON' (ключевое слово команды DEBUT). На самом деле, в этом случае, нет никакого общего анализа командного файла, но каждая инструкция выполняется последовательно. Когда выполняется очередная инструкция, все концепции, ей предшествующие, таким образом, уже вычислены.

Ниже приведены некоторые методы доступа к структурам данных.

Структура данных Метод Тип возвращаемого значения Python Возвращаемая информация
listr8 LIST_VALEURS lists Список значений
mesh LIST_GROUP_NO lists Список групп узлов
LIST_GROUP_MA lists Список групп сетки
counts […] contenu Действительный массив
function LISTE_VALEURS lists Список значений
result LIST_CHAMPS lists Список вычисленных полей
LIST_NOM_CMP lists Список компонентов
LIST_VARI_ACCES lists Список переменных доступа
LIST_PARA lists Список параметров
cham_no EXTR_COMP post_comp_cham_no Содержание поля в массиве
cham_elem EXTR_COMP post_comp_cham_el Содержание поля в массиве
Любой объект JEVEUX getvectjev lists Список объектов в векторе jeveux

5.5 Примеры динамического создания факторов ключевых слов

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

   DEBUT (PAR_LOT='NON”)

    ooo= [ _F (JUSQU_A=1., PAS=0.1),
           _F (JUSQU_A=2., PAS=0.1),
           _F (JUSQU_A=3., PAS=0.1)]

    ppp= [_F (JUSQU_A=float (I), PAS=0.1) for I in arranges (1.4)]

    qqq= [{“JUSQU_A”: float (I), “PAS”: 0.1} for I in arranges (1.4)]

    rrr= [_F (** arguments) for arguments in qqq]

    li1=DEFI_LISTE_REEL ( DEBUT=0.,
                         INTERVALLE=ooo
                         / or
                         INTERVALLE=ppp
                         / or
                         INTERVALLE=rrr
                         )
    FIN ()