From ac5d9b13f011568ca5394013ee2db396b15d7849 Mon Sep 17 00:00:00 2001 From: labatale Date: Wed, 16 Apr 2025 23:56:15 +0200 Subject: [PATCH 1/2] Replace LecFicDiffuse_JDD with DataFile. --- src/Kernel/Utilitaires/DataFile.cpp | 948 ++++++++++++++ src/Kernel/Utilitaires/DataFile.h | 132 ++ src/Kernel/Utilitaires/DataFileExpression.cpp | 884 +++++++++++++ src/Kernel/Utilitaires/DataFileExpression.h | 137 ++ src/Kernel/Utilitaires/DataFileStream.cpp | 116 ++ .../{EChaineJDD.h => DataFileStream.h} | 39 +- src/Kernel/Utilitaires/DataFileToken.cpp | 1151 +++++++++++++++++ src/Kernel/Utilitaires/DataFileToken.h | 165 +++ src/Kernel/Utilitaires/EChaineJDD.cpp | 56 - src/Kernel/Utilitaires/Entree.cpp | 12 + src/Kernel/Utilitaires/Entree.h | 3 +- src/Kernel/Utilitaires/Entree_complete.cpp | 9 +- src/Kernel/Utilitaires/Entree_complete.h | 3 +- src/Kernel/Utilitaires/Execute_parallel.cpp | 2 +- src/Kernel/Utilitaires/LecFicDiffuse_JDD.cpp | 230 ---- src/Kernel/Utilitaires/LecFicDiffuse_JDD.h | 47 - src/Kernel/Utilitaires/Lec_Diffuse_base.cpp | 9 +- src/Kernel/Utilitaires/Lec_Diffuse_base.h | 3 +- src/Kernel/Utilitaires/Lire_Fichier.cpp | 30 +- src/Kernel/Utilitaires/Process.cpp | 17 +- src/Kernel/Utilitaires/Process.h | 4 + src/Kernel/Utilitaires/TextFormatting.cpp | 179 +++ src/Kernel/Utilitaires/TextFormatting.h | 80 ++ src/MAIN/mon_main.cpp | 25 +- src/MAIN/mon_main.h | 2 +- 25 files changed, 3900 insertions(+), 383 deletions(-) create mode 100644 src/Kernel/Utilitaires/DataFile.cpp create mode 100644 src/Kernel/Utilitaires/DataFile.h create mode 100644 src/Kernel/Utilitaires/DataFileExpression.cpp create mode 100644 src/Kernel/Utilitaires/DataFileExpression.h create mode 100644 src/Kernel/Utilitaires/DataFileStream.cpp rename src/Kernel/Utilitaires/{EChaineJDD.h => DataFileStream.h} (68%) create mode 100644 src/Kernel/Utilitaires/DataFileToken.cpp create mode 100644 src/Kernel/Utilitaires/DataFileToken.h delete mode 100644 src/Kernel/Utilitaires/EChaineJDD.cpp delete mode 100644 src/Kernel/Utilitaires/LecFicDiffuse_JDD.cpp delete mode 100644 src/Kernel/Utilitaires/LecFicDiffuse_JDD.h create mode 100644 src/Kernel/Utilitaires/TextFormatting.cpp create mode 100644 src/Kernel/Utilitaires/TextFormatting.h diff --git a/src/Kernel/Utilitaires/DataFile.cpp b/src/Kernel/Utilitaires/DataFile.cpp new file mode 100644 index 0000000000..e9c78b7ce6 --- /dev/null +++ b/src/Kernel/Utilitaires/DataFile.cpp @@ -0,0 +1,948 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ + +#include +#include +#include +#include +#include +#include + +Implemente_instanciable_sans_constructeur(DataFile,"DataFile",Lec_Diffuse_base); + +Entree& DataFile::readOn(Entree& s) +{ + throw; +} + +Sortie& DataFile::printOn(Sortie& s) const +{ + throw; +} + +// constructors +DataFile::DataFile() {} + +DataFile::DataFile(const char* root_data_file_name, IOS_OPEN_MODE mode, bool do_check_obsolete_keywords_): + do_check_obsolete_keywords(do_check_obsolete_keywords_) { + ouvrir(root_data_file_name, mode); +} + +int DataFile::ouvrir(const char* root_data_file_name, IOS_OPEN_MODE mode) { + // only the master process load the file + int ok = 0; + + if (Process::je_suis_maitre()) { + + Cerr << "Opening the data file" << finl; + + // register this file as included + included_files.push_back(root_data_file_name); + + tokens = process(root_data_file_name, mode); + + // check syntax + check_curly_brackets(); // only check after the includes has been made + + // check obsolete keywords + if (do_check_obsolete_keywords) + check_obsolete_keywords(); + + // check reserved keyword + check_reserved_keywords(); + + // set this as the EChaine data + data.init(to_string(tokens), tokens); + + // we also store the result in an file for debugging + write(tokens, "." + std::string(root_data_file_name) + ".parsed"); + + ok = 1; + } + + // share data accross processors + envoyer_broadcast(ok, 0); + + return ok; +} + +/** + * @brief Processes a file by tokenizing its content, analyzing the tokens, + * and applying macros to compute expressions. + * + * @param file_name The name of the file to process. + * @param mode The mode in which the file should be opened (e.g., read or write). + * @return DataFile::Tokens A list of processed tokens representing the file's content. + * + * This function performs the following steps: + * 1. Tokenizes the content of the specified file. + * 2. Adds a dummy initial space token to handle cases where the file starts with an expression. + * 3. Iterates through the tokens, applying macros and computing expressions as needed. + * + * Note: + * - The function uses a while loop to handle cases where applying a macro modifies + * the size of the token list, ensuring the iteration remains valid. + * - The function returns the final list of processed tokens. + */ +DataFile::Tokens DataFile::process(const std::string& file_name, IOS_OPEN_MODE mode) { + // first get the token for that file + std::list tokens_output = tokenize(file_name, mode); + + // add a dummy first space so that the following work in case the file start + // with an expression + tokens_output.push_front(DataFileToken("", 0, 0, 0, 0, DataFileToken::Type::Space, "")); + + // then analyze the tokens to compute expressions and apply macros + // (use a while loop to avoid calling next with token == tokens_output.end()) + auto token = tokens_output.begin(); + while (token != tokens_output.end()) { + + if (token->type == DataFileToken::Type::Macro) { + token = apply_macro(tokens_output, token, mode); + } + + // macro may have change the size of tokens_output and know token is equal o tokens_output.end() + if (token != tokens_output.end()) + token = next(tokens_output, token); + } + + return tokens_output; +} + +/** + * @brief Tokenizes the content of a file into a list of DataFileToken objects. + * + * This function reads the content of the specified file and breaks it into tokens + * based on predefined token types. It handles various token types such as names, + * operators, spaces, comments, and more. The function also tracks the line and column + * positions of each token for precise error reporting and debugging. + * + * @param file_name The name of the file to be tokenized. + * @param mode The mode in which the file should be opened (e.g., read or write). + * @return A list of DataFileToken objects representing the tokens found in the file. + * + * @note If the file cannot be opened, the function will terminate the process. + * @note If an unclosed comment block is encountered, the function will report an error + * and terminate the process. + * @note The function stops reading further tokens if it encounters the keywords "fin" or "end". + * + * @throws The function terminates the process in case of critical errors such as: + * - Failure to open the file. + * - Parsing mistakes. + * - End-of-file reached inside a comment block. + * - Unprocessed token types at the end of the file. + */ +std::list DataFile::tokenize(const std::string& file_name, IOS_OPEN_MODE mode) const { + // the output + std::list output_tokens; + + // open the file + EFichier file; + if (!file.ouvrir(file_name.c_str(), mode)) { + Cerr << "Failed to open file '" << file_name << "'." << finl; + Process::exit(DONT_PRINT_TOKEN); + } + + // read the first character + std::string token_string; + char character; + if (!file.get(character)) { + // the file is empty, we can return + file.close(); + return output_tokens; + } + + std::set potential_token_types = DataFileToken::get_types_full_set(); + + // temporaty stored valid potential tokens + std::set new_potential_token_types; + + size_t line = 1; + size_t column = 1; + size_t token_start_line = line; + size_t token_start_column = column; + while (true) { + // for each potential token types, check if the new token_string is a valid type + new_potential_token_types.clear(); + for (DataFileToken::Type token_type: potential_token_types) { + if (DataFileToken::check(token_type, token_string + character)) { + new_potential_token_types.insert(token_type); + } + } + + if (new_potential_token_types.empty()) { + + // get the token type + DataFileToken::Type token_type = DataFileToken::Type::Space; + if (potential_token_types.size() == 0) { + Cerr << "A mistake occure during parsing." << finl; + Process::exit(DONT_PRINT_TOKEN); + } else if (potential_token_types.size() == 1) { + token_type = *potential_token_types.begin(); + } else { + // choose among the potential token types the most appropriate + token_type = DataFileToken::choose(potential_token_types, token_string); + } + + // its possible than some names could be interpreted has operators + // (min, max…), so correct the type if it is the case + if (token_type == DataFileToken::Type::Name) { + if (DataFileToken::check_operator(token_string)) + token_type = DataFileToken::Type::Operator; + } + + // append the token to the tokens vector + DataFileToken token( + file_name, + token_start_line, + token_start_column, + line, + column, + token_type, + token_string); + output_tokens.push_back(token); + + // capture the 'end' keyword to stope reading + if (token_type == DataFileToken::Type::Name) { + // if the keyword is name as is 'fin' or 'end', we stop reading + // only to it after the occurent of the word to keep in the tokens list + std::string lower_string = TextFormatting::lower(token_string); + if (lower_string == "fin" || lower_string == "end") { + file.close(); + return output_tokens; + } + } + + // reset the token_string and the potential_token_types + token_string = ""; + potential_token_types = DataFileToken::get_types_full_set(); + + token_start_line = line; + token_start_column = column; + } else { + // add the previously read character to the current token_string + token_string += character; + + // swap the new_potential_token_types with potential_token_types + std::swap(potential_token_types, new_potential_token_types); + + // update the cursor + if (character == '\n') { + line++; + column = 1; + } else { + column++; + } + + // read a new character + if (!file.get(character)) + break; + } + } + + file.close(); + + // check for unclosed comments + if (!potential_token_types.empty()) { + if (potential_token_types.size() == 1) { + + // get the token type + DataFileToken::Type token_type = *potential_token_types.begin(); + + // create a token with the last token properties + DataFileToken token( + file_name, + token_start_line, + token_start_column, + line, + column, + token_type, + token_string); + + switch (token_type) { + case DataFileToken::Type::CommentBlockHash: + case DataFileToken::Type::CommentBlockCStyle: + token.print_as_error("End-of-file reached inside a comment."); + Process::exit(DONT_PRINT_TOKEN); + break; + case DataFileToken::Type::Name: + case DataFileToken::Type::Space: + case DataFileToken::Type::OpenParenthesis: + case DataFileToken::Type::CloseParenthesis: + // add the last token + output_tokens.push_back(token); + break; + default: + token.print_as_error("End-of-file while still been process."); + + Process::exit(DONT_PRINT_TOKEN); + } + } else { + Cerr << "End-of-file error with token types "; + for (auto& type: potential_token_types) { + Cerr << type << " "; + } + Cerr << "still not process." << finl; + + if (output_tokens.size() > 0) + output_tokens.back().print_as_note("After this token."); + + Process::exit(DONT_PRINT_TOKEN); + } + } + + file.close(); + return output_tokens; +} + +/** + * @brief Replaces a token with its corresponding constant value if it exists in the constants map. + * + * This function checks if the provided token is of type `Name`. If it is, the function looks up + * the token's string value in the `constants` map. If a matching constant is found, the token's + * type and value are updated to match the type and value of the constant. + * + * @param token An iterator pointing to the token to be replaced. The token's type and value + * may be modified if a matching constant is found. + * + * @note If the token is not of type `Name` or if no matching constant is found in the `constants` + * map, the function does nothing. + */ +void DataFile::replace(Tokens::iterator& token) const { + // if the token is not a Name, it cannot be a constant + if (token->type != DataFileToken::Type::Name) + return; + + if (auto it = constants.find(token->string); it != constants.end()) { + token->type = it->second.second.type; + token->value = it->second.second.value; + + // and set the string to "" to signify that the value changed + token->string = ""; + } +} + +/** + * @brief Processes the next token in a sequence of tokens, handling expressions and ensuring + * syntactic correctness. + * + * This function advances the iterator to the next token in the provided sequence of tokens. + * If the next token is an open parenthesis, it processes the entire expression enclosed by + * the parentheses, validates its syntax, and replaces it with a single token representing + * the expression. The function ensures that the expression adheres to the expected rules + * for operators, operands, and parentheses. + * + * @param input_tokens The sequence of tokens to process. + * @param token An iterator pointing to the current token in the sequence. + * It must not point to `input_tokens.end()`. + * @return An iterator pointing to the next token after processing. + * + * @note This function performs several validations: + * - Ensures that expressions are syntactically correct. + * - Validates alternation between operators and operands. + * - Checks for mismatched or misplaced parentheses. + * - Ensures no invalid token types are present in expressions. + * - Handles unary operators and function composition. + * + * @throws The function terminates the program with an error message if: + * - An invalid token type is encountered in an expression. + * - Parentheses are mismatched or misplaced. + * - Consecutive operators or operands are found where not allowed. + * - An operand is followed directly by an open parenthesis without an operator. + * - The end of the file is reached before the expression is closed. + * + * @details If the next token is an expression, the function: + * - Identifies the range of tokens forming the expression. + * - Validates the expression's syntax. + * - Replaces the tokens of the expression with a single token representing it. + * - If the expression is numeric, replaces it with its computed value. + * + * @pre The `token` iterator must not point to `input_tokens.end()`. + * @post The `token` iterator is updated to point to the next token after processing. + */ +DataFile::Tokens::iterator DataFile::next(Tokens& input_tokens, Tokens::iterator token) const { + // should not be call on input_tokens.end() + assert(token != input_tokens.end()); + + // go to the next token + token = std::next(token); + + // replace it with constant if possible + replace(token); + + // if the next token is not a parenthesis, then it is not an expression + if (token->type != DataFileToken::Type::OpenParenthesis) { + return token; + } + + // it is an expression, we search the closing parenthesis + int number_of_consecutive_operators = 0; + std::optional last_operator_or_operand; + std::optional previous_non_space; + bool last_was_close_parenthesis = false; + + size_t depth = 0; + auto start = token; + auto end = token; + do { + // replace with constant if possible + replace(end); + + // check the depth + if (end->type == DataFileToken::Type::OpenParenthesis) { + depth++; + } else if (end->type == DataFileToken::Type::CloseParenthesis) { + depth--; + if (depth == 0) { // reach the end of the expression { + break; + } + } + + // check the type + if (!end->is_space() && !end->is_operand() && !end->is_operator() && !end->is_parenthesis() && !end->is_name()) { + std::ostringstream oss; + oss << end->type; + end->print_as_error("An expression cannot contain a value type '" + + TextFormatting::Err::format(oss.str(), 0,1) + "'."); + Process::exit(DONT_PRINT_TOKEN); + } + + // if the previous token was a ')' and the new token is '(', then it is not a + // valid expression + if (end->type == DataFileToken::Type::OpenParenthesis && last_was_close_parenthesis) { + end->print_as_error("')' cannot be followed by a '(' inside an expression."); + Process::exit(DONT_PRINT_TOKEN); + } + + // if it is not a space nor a parenthesis, check if we alternate between operands + // and operators + if (!end->is_space() && !end->is_parenthesis()) { + if (last_operator_or_operand.has_value()) { + // expressions can have two consecutives operators if the second one is + // the unary + or - operator + if (end->is_operator() && last_operator_or_operand.value()->is_operator()) { + if (number_of_consecutive_operators >= 2) { + end->print_as_error("Cannot have a unary operator following two other operators."); + last_operator_or_operand.value()->print_as_note("Previous operator."); + Process::exit(DONT_PRINT_TOKEN); + + } else if (!end->is_plus_or_minus()) { + end->print_as_error("Cannot have two following binary operators."); + last_operator_or_operand.value()->print_as_note("Previous operator."); + Process::exit(DONT_PRINT_TOKEN); + } + } + // if two consecutive operands + else if (end->is_operand() && last_operator_or_operand.value()->is_operand()) { + end->print_as_error("Cannot have two consecutive operands in an expression."); + last_operator_or_operand.value()->print_as_note("The previous operand."); + Process::exit(DONT_PRINT_TOKEN); + } + } + + // check if it is a function + if (end->is_function()) { + // insert a composition operator after the function + // we set the same file and position then the function for error + // messages + input_tokens.insert( + std::next(end), + DataFileToken( + end->file_name, + end->start_line, + end->start_column, + end->end_line, + end->end_column, + DataFileToken::Type::Operator, + "c")); // 'c' for composition + end = std::next(end); + number_of_consecutive_operators = 0; + } + + last_operator_or_operand = end; + if (end->is_operator()) { + number_of_consecutive_operators++; + } + else + number_of_consecutive_operators = 0; + } else { + if (previous_non_space.has_value()) { + // if operand followed by an open parenthesis + if (previous_non_space.value()->is_operand() && end->type == DataFileToken::Type::OpenParenthesis) { + end->print_as_error("Missing operator between the open parenthesis and the previous operand."); + previous_non_space.value()->print_as_note("Previous operand."); + Process::exit(DONT_PRINT_TOKEN); + } + } + } + + if (!end->is_space()) + previous_non_space = end; + + // update the last_was_close_parenthesis flag + if (end->type != DataFileToken::Type::Space) + last_was_close_parenthesis = (end->type == DataFileToken::Type::CloseParenthesis); + + // update end + end = std::next(end); + } while (end != input_tokens.end()); + + if (end == input_tokens.end() && depth != 0) { + std::prev(end)->print_as_error("End-of-file before the end of the expression."); + Process::exit(DONT_PRINT_TOKEN); + } + + // then create an token expression from those input_tokens + DataFileToken token_expression( + start->file_name, + start->start_line, + start->start_column, + end->end_line, + end->end_column, + DataFileToken::Type::Expression, + "" // we don't use the string representation of the expression + ); + + // create list of the tokens for that expression and create the expression object + assert(end != input_tokens.end()); + std::list tokens_expression(start, std::next(end)); + + DataFileExpression expression(tokens_expression.begin(), std::prev(tokens_expression.end())); + + // set the expression as value of the token_expression and replace the token byt the expression value if the expression could be fully evaluated (without unknown field in it) + token_expression.value = expression; + + if (expression.is_numeric()) + token_expression = expression.value(); + + // replace the tokens from the expression with token_expression, encapsulating + // all the tokens of the expression + // first add the token_expression after end, otherwise we would not have a + // valid iterator to insert it after + auto inserted = input_tokens.insert(std::next(end), token_expression); + // then erase the tokens of the expression + input_tokens.erase(start, inserted); + + // and set end as the inserted element + end = inserted; + + // then go to the end of the expression to continue + token = end; + return token; +} + +/** + * @brief Processes a macro directive in the input tokens and applies the corresponding action. + * + * This function handles two types of macros: `#include` and `#define`. It modifies the input tokens + * list based on the macro's behavior and updates internal state as necessary. + * + * @param input_tokens The list of tokens to process. + * @param token An iterator pointing to the macro token in the input tokens list. + * @param mode The mode in which the file is being processed (e.g., read or write). + * @return DataFile::Tokens::iterator An iterator pointing to the next token after the macro processing. + * + * @details + * - **#include**: + * - Expects the next non-space token to be the name of the file to include. + * - Validates that the file name is either a literal string or a name. + * - Checks for circular dependencies by ensuring the file has not already been included. + * - Tokenizes the included file and inserts its tokens into the current token list. + * - Removes the `#include` directive and the file name from the token list. + * + * - **#define**: + * - Expects the next non-space token to be the name of the constant. + * - Expects the token after the constant name to be its value (name, int, float, or expression). + * - Validates that the constant name is not already defined or used as an unknown symbol. + * - Adds the constant to the list of defined constants. + * - Removes the `#define` directive, constant name, and value from the token list. + * + * @note If an error occurs (e.g., missing tokens, invalid types, circular dependencies, or redefinitions), + * the function prints an error message and terminates the process. + * @note If the value for the constant is an expression, it spaces can still be placed in the expression inside its outer parenthesis. + * + * @throws std::bad_any_cast If a token's value cannot be cast to the expected type. + */ +DataFile::Tokens::iterator DataFile::apply_macro(Tokens& input_tokens, Tokens::iterator token, IOS_OPEN_MODE mode) { + assert(token->type == DataFileToken::Type::Macro); + + std::string macro_name = std::any_cast(token->value); + + if (macro_name == "include") { + // the next non-space token is the name of the file to include + auto token_file_name = std::next(token); + while (token_file_name != input_tokens.end() && token_file_name->type == DataFileToken::Type::Space) + token_file_name = std::next(token_file_name); + + if (token_file_name == input_tokens.end()) { + token->print_as_error("End of file reached before the name of the file to include could be specified."); + Process::exit(DONT_PRINT_TOKEN); + } + + // me expect a literal string or a name + if (token_file_name->type != DataFileToken::Type::Name && token_file_name->type != DataFileToken::Type::LiteralString) { + std::ostringstream oss; + oss << token_file_name->type; + token_file_name->print_as_error("Expected a literal-string or a name as file-name, not a '" + oss.str() + "'."); + Process::exit(DONT_PRINT_TOKEN); + } + + // get the file name + std::string include_file_name = std::any_cast(token_file_name->value); + + // check if this file has not already been included + if (std::find(included_files.begin(), included_files.end(), include_file_name) != included_files.end()) { + token_file_name->print_as_error("This file as already been included (circular dependency)."); + Process::exit(DONT_PRINT_TOKEN); + } + + // register this file has being included + included_files.push_back(include_file_name); + + // tokenize this file + std::list tokens_include = process(include_file_name, mode); + + // then insert this new tokens inside the current tokens list, just before the '#include' token + input_tokens.splice(token, tokens_include); + + // then remove the '#include' and file name from the tokens list + while (token != token_file_name) + token = input_tokens.erase(token); + token = input_tokens.erase(token); // delete the include file name + + return token; + + } else if (macro_name == "define") { + // the next token is the Name of the constant + // and the token after is the value of the constant + auto token_constant_name = std::next(token); + while (token_constant_name != input_tokens.end() && token_constant_name->type == DataFileToken::Type::Space) + token_constant_name = std::next(token_constant_name); + + if (token_constant_name == input_tokens.end()) { + token->print_as_error("End of file reached before the name of the constant could be specified."); + Process::exit(DONT_PRINT_TOKEN); + } + + // me expect a name + if (token_constant_name->type != DataFileToken::Type::Name) { + std::ostringstream oss; + oss << token_constant_name->type; + token_constant_name->print_as_error("Expected a name as constant name, not a '" + oss.str() + "'."); + Process::exit(DONT_PRINT_TOKEN); + } + + // then get the value + auto token_constant_value = std::next(token_constant_name); + while (token_constant_value != input_tokens.end() && token_constant_value->type == DataFileToken::Type::Space) { + //token_constant_value = next(input_tokens, token_constant_value); + token_constant_value = next(input_tokens, token_constant_value); + } + + if (token_constant_value == input_tokens.end()) { + token->print_as_error("End of file reached before the value of the constant could be specified."); + Process::exit(DONT_PRINT_TOKEN); + } + + // me expect a name, an int or a float, or an expression + if (token_constant_value->type != DataFileToken::Type::Name && + token_constant_value->type != DataFileToken::Type::Int && + token_constant_value->type != DataFileToken::Type::Float && + token_constant_value->type != DataFileToken::Type::Expression) { + + std::ostringstream oss; + oss << token_constant_value->type; + token_constant_value->print_as_error("Expected a name, an int, a float or an expression as constant value, not a '" + oss.str() + "'."); + Process::exit(DONT_PRINT_TOKEN); + } + + // check if this constant has already been definied + std::string constant_name = + std::any_cast(token_constant_name->value); + + if (auto it = constants.find(constant_name); it != constants.end()) { + // it may be a native constant (it is not associated with a file) + if (it->second.second.file_name == "") { + token_constant_name->print_as_error("Constant '" + + TextFormatting::Err::format(constant_name, 0,1) + + "' is already definied as a native constant.."); + } else { + token_constant_name->print_as_error("Constant '" + + TextFormatting::Err::format(constant_name, 0,1) + + "' is already definied."); + + it->second.first.print_as_note("First declared here."); + } + + Process::exit(DONT_PRINT_TOKEN); + } + + // check if this constant name is already use as an unknown (symbol that can appear in an expression but don't have any value) + if (auto it = unknowns.find(constant_name); it != unknowns.end()) { + // it may be a native constant (it is not associated with a file) + token_constant_name->print_as_error("The symbol '" + + TextFormatting::Err::format(constant_name, 0,1) + + "' is already definied as an unknown for '" + it->second + "'."); + + Process::exit(DONT_PRINT_TOKEN); + } + + // check if its the type + if (Type_info::est_un_type(constant_name.c_str())) { + token_constant_name->print_as_error("The symbol '" + + TextFormatting::Err::format(constant_name, 0,1) + + "' is already definied as a type in TRUST."); + Process::exit(DONT_PRINT_TOKEN); + } + + // append this constant to the list of constants (constants + constants.insert({constant_name, + {*token_constant_name, *token_constant_value}}); + + // then remove the '#define' and parameters + while (token != token_constant_value) + token = input_tokens.erase(token); + token = input_tokens.erase(token); // delete the include file name + + return token; + + + } else { + token->print_as_error( + "Unknown macro name '" + + TextFormatting::Err::format(macro_name, 0,1) + "'."); + Process::exit(DONT_PRINT_TOKEN); + return token; // return token any way to avoid compilation error + } +} + +/** + * @brief Validates the matching of curly brackets in the token list. + * + * This function checks whether all curly brackets in the `tokens` list are properly + * opened and closed. It ensures that: + * - Every closing curly bracket has a corresponding opening curly bracket. + * - Every opening curly bracket has a corresponding closing curly bracket. + * + * If an unmatched closing curly bracket is found, an error message is printed + * using `token.print_as_error`, and the program exits. + * + * If there are unmatched opening curly brackets, the function identifies the + * last unmatched opening curly bracket, prints an error message, and exits + * the program. + * + * @throws This function terminates the program using `Process::exit(DONT_PRINT_TOKEN)` if + * unmatched curly brackets are detected. + */ +void DataFile::check_curly_brackets() const { + size_t depth = 0; + for (auto& token: tokens) { + if (token.type == DataFileToken::Type::OpenCurlyBracket) { + depth++; + } else if (token.type == DataFileToken::Type::CloseCurlyBracket) { + if (depth == 0) { + token.print_as_error("This curly bracket has never been opened."); + Process::exit(DONT_PRINT_TOKEN); + } else { + depth--; + } + } + } + + // if one curly brackets has not been closed + if (depth != 0) { + // search the last opened curly brackets at the same depth + size_t depth_tmp = depth; + for (auto token = tokens.rbegin(); token != tokens.rend(); token++) { + if (token->type == DataFileToken::Type::OpenCurlyBracket) + depth_tmp--; + else if (token->type == DataFileToken::Type::CloseCurlyBracket) + depth_tmp++; + + if (depth_tmp == depth - 1) { + token->print_as_error("This curly brackets has never been closed."); + Process::exit(DONT_PRINT_TOKEN); + } + } + } +} + +/** + * @brief Checks for obsolete keywords in the data file. + * + * This method iterates through the tokens in the data file and identifies + * keywords that may be considered obsolete. It performs the following checks: + * - Ensures the token is a name. + * - Verifies that the token is followed by either a space or an opening curly + * bracket, which indicates the end of the word. This accounts for cases + * where special characters like '-' or '%' are used in names. + * + * If a valid keyword is identified, it is passed to the `verifie` method for + * further validation. + * + * @note This function assumes that the `tokens` container is properly populated + * and that each token has a valid type and string representation. + */ +void DataFile::check_obsolete_keywords() const { + for (auto token = tokens.begin(); token != tokens.end(); token++) { + // if this token is followed by a space or a curyl bracket, it means it the 'real' + // end of this word (because some people use like '-' or '%' in their name + if (token->is_name() && + token != tokens.end() && + (std::next(token)->is_space() || + std::next(token)->type == DataFileToken::Type::OpenCurlyBracket)) { + + Nom word = token->string; + verifie(word); + } + } +} + +/** + * @brief Checks for reserved keywords in the tokens and issues warnings if any + * token could be interpreted as a function name or an operator. + * + * This method iterates through the list of tokens and examines each token to + * determine if it is a name. If the token is identified as a name, it further + * checks whether it could be interpreted as a function or an operator in an + * expression. If so, a warning is printed to notify the user that the token + * might need to be enclosed in parentheses to avoid ambiguity in expressions. + * + * @note This function does not modify the tokens; it only performs checks and + * prints warnings if necessary. + */ +void DataFile::check_reserved_keywords() const { + for (auto token = tokens.begin(); token != tokens.end(); token++) { + // if a name could be a function name or an operator, print a warning + if (token->is_name()) { + if (token->is_function()) + token->print_as_warning("The keyword '" + + TextFormatting::Err::format(token->string, 0,1) + + "' could be use as a function in an expression. Are you sure this should not be an expression (surounded in parenthesis)?."); + + else if (token->is_operator()) + token->print_as_warning("The keyword '" + + TextFormatting::Err::format(token->string, 0,1) + + "' could be use as an operator in an expression. Are you sure this should not be an expression (surounded in parenthesis)?."); + } + } +} + +/** + * @brief Converts a list of DataFileToken objects into a formatted string representation. + * + * This function iterates through a list of tokens and constructs a string that represents + * the tokens in a readable format. It handles special formatting for curly brackets, comments, + * operators, and functions to ensure the output closely resembles the original data file's + * structure and spacing. + * + * @param input_tokens A list of DataFileToken objects to be converted into a string. + * @return A formatted string representation of the input tokens. + * + * @details + * - Curly brackets and comments are followed by a newline character. + * - Comments are excluded from the output string. + * - Operators and functions are formatted to suppress unnecessary spaces around them + * when adjacent to mathematical expressions or names. + * - Spaces are added after tokens unless they are operators or functions. + */ +std::string DataFile::to_string(const std::list& input_tokens) const { + std::string output; + for (auto token = input_tokens.begin(); token != input_tokens.end(); token++) { + if (token->is_curly_bracket() || token->is_comment()) + output += '\n'; + + if (!token->is_comment()) { + // small hack to make expressions appearing outside of parenthesis in original + // data files still look identical + + // spaces that would have been added around the expressions are suppressed + // if there is operator around them + if (token->is_operator() || token->is_function()) { + if (token != input_tokens.begin() && ( + std::prev(token)->is_math() || std::prev(token)->is_name())) { + while (output.length() > 0 && output.back() == ' ') + // remove the last space + output.pop_back(); + } + + output += token->to_string(); + } else { + output += token->to_string(); + output += ' '; + } + } + + if (token->is_curly_bracket()) + output += '\n'; + + } + + return output; +} + +/** + * @brief Writes a list of DataFileToken objects to a file after processing. + * + * This function converts a list of tokens into a string representation and writes it to a file. + * The file name is sanitized to ensure it is written in the current folder by replacing '/' with '_'. + * This operation is performed only by the master process. + * + * @param input_tokens A list of DataFileToken objects to be written to the file. + * @param file_name The name of the file where the data will be written. Any '/' in the file name + * will be replaced with '_' to ensure the file is created in the current directory. + * + * @note This function is executed only by the master process (Process::je_suis_maitre()). + * If the file cannot be opened, the program will terminate using Process::exit(DONT_PRINT_TOKEN). + */ +void DataFile::write(const std::list& input_tokens, const std::string& file_name) const { + + if (Process::je_suis_maitre()) { + // convertl the list of tokens to a string + std::string output = to_string(input_tokens); + + // remove the '/' from the file name to always write the result in the current folder + std::string corrected_file_name = file_name; + std::replace(corrected_file_name.begin(), corrected_file_name.end(), '/', '_'); + + Cout << "Dump the data file after pre-processor in file '" << corrected_file_name << "'." << finl; + + // open file + SFichier file; + if (!file.ouvrir(corrected_file_name.c_str(), ios::out)) { + Cerr << "Failed to open file '" << corrected_file_name << "'." << finl; + Process::exit(DONT_PRINT_TOKEN); + } + + // write data + file << output; + + // close file + file.close(); + } +} + +/** + * @brief Retrieves the master input stream associated with the DataFile object. + * + * This function provides access to the `data` member, which represents the + * main input stream for the DataFile. It allows reading data from the + * associated input source. + * + * @return A reference to the `Entree` object representing the master input stream. + */ +Entree& DataFile::get_entree_master() { + return data; +} diff --git a/src/Kernel/Utilitaires/DataFile.h b/src/Kernel/Utilitaires/DataFile.h new file mode 100644 index 0000000000..a358fcd270 --- /dev/null +++ b/src/Kernel/Utilitaires/DataFile.h @@ -0,0 +1,132 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ + +#ifndef DataFile_included +#define DataFile_included + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +class Objet_U; + +class DataFile: public Lec_Diffuse_base { + + /////////// + // TRUST // + /////////// + + private: + + Declare_instanciable_sans_constructeur(DataFile); + + ///////////// + // aliases // + ///////////// + + private: + + using Token = DataFileToken; + using Tokens = std::list; + + ////////////////// + // constructors // + ////////////////// + + public: + + DataFile(); + DataFile(const char* root_data_file_name, IOS_OPEN_MODE mode=ios::in, bool do_check_obsolete_keywords_ = true); + + ///////////// + // methods // + ///////////// + + public: + + int ouvrir(const char* name, IOS_OPEN_MODE mode=ios::in ) override; + Entree& get_entree_master() override; + + private: + + Tokens tokenize(const std::string& file_name, IOS_OPEN_MODE mode=ios::in) const; + Tokens process(const std::string& file_name, IOS_OPEN_MODE mode=ios::in); + Tokens::iterator apply_macro(Tokens& tokens, Tokens::iterator token, IOS_OPEN_MODE mode=ios::in); + void replace(Tokens::iterator& token) const; + Tokens::iterator next(Tokens& tokens, Tokens::iterator token) const; + void check_curly_brackets() const; + void check_obsolete_keywords() const; + void check_reserved_keywords() const; + + std::string to_string(const Tokens& tokens) const; + void write(const Tokens& tokens, const std::string& file_name) const; + + //////////////// + // attributes // + //////////////// + + public: + + Tokens tokens; + std::vector included_files; + + private: + + // stringstream-like object to store the parsed data + // with their tokens + DataFileStream data; + + // map the name of a constant to a + // pair of {the token of the name, the token of the value} + // initialize the constants with some predefined values (like pi, e…) + std::map> constants = { + {"PI", { + DataFileToken("default", 0, 0, 0, 0, DataFileToken::Type::Name, "PI"), + DataFileToken("default", 0, 0, 0, 0, DataFileToken::Type::Float, "3.14159265358979323846264338327950288419716939937511")}}, + {"E", { + DataFileToken("default", 0, 0, 0, 0, DataFileToken::Type::Name, "E"), + DataFileToken("default", 0, 0, 0, 0, DataFileToken::Type::Float, "2.71828182845904523536028747135266249775724709369996")}} + }; + + // map of unknowns with the name and their description + // unknowns can appear in expression without having any values + std::map unknowns = { + {"x", "X-component"}, + {"X", "X-component"}, + {"y", "Y-component"}, + {"Y", "Y-component"}, + {"z", "Z-component"}, + {"Z", "Z-component"}, + {"t", "Time component"}, + {"T", "Time component"}, + + }; + + // flag for checking or not obsolete keywords + bool do_check_obsolete_keywords; +}; + +#endif diff --git a/src/Kernel/Utilitaires/DataFileExpression.cpp b/src/Kernel/Utilitaires/DataFileExpression.cpp new file mode 100644 index 0000000000..93dd17b4e5 --- /dev/null +++ b/src/Kernel/Utilitaires/DataFileExpression.cpp @@ -0,0 +1,884 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ + +#include // to use drand48 + +#include +#include + +////////////////////////////////////// +// DataFileExpression::Node methods // +////////////////////////////////////// + +// create a Node by copying a DataFileToken +DataFileExpression::Node::Node(const DataFileToken& token): DataFileToken(token) {} + +/** + * @brief Constructs a Node object representing an operation or a value in a data file expression. + * + * @param token The token representing the operation or value. + * @param a Pointer to the left operand node (can be nullptr for unary operations). + * @param b Pointer to the right operand node (can be nullptr for unary operations). + * + * This constructor handles the following cases: + * - If the operation is a composition (e.g., "c") and the right operand is numeric: + * - Applies specific functions such as `int()`, `float()`, or `rand()`. + * - Computes the result and sets the node's value and type accordingly. + * - If at least one of the operands is not numeric: + * - Creates a node representing the operation without computing the result. + * - If both operands are numeric: + * - Computes the result based on the operation. + * - Preserves the result as an integer if both operands are integers (except for division). + * - Promotes the result to a float if one or both operands are floats, or if the operation is division. + * + * @note The constructor ensures deterministic behavior for pseudo-random operations (`rand`) + * to validate test cases consistently. + * + * @throws std::bad_any_cast If the value of the left operand cannot be cast to a string + * when applying a function. + * @throws std::invalid_argument If an unsupported function name is encountered during composition. + */ +DataFileExpression::Node::Node(const DataFileToken& token, std::shared_ptr a, std::shared_ptr b): + Node(token) { + assert(is_operator()); + + // if the operation is a composition + if (string == "c" && b->is_numeric()) { + // compute function as float + // but there a few special cases: the int(), float() + std::string function_name = TextFormatting::lower( + std::any_cast(a->value)); + + // apply all functions except the rand (rnd) so that the same + // deterministic pseudo-random generated validate the test-cases + if (function_name == "int") { + value = b->cast(); + type = DataFileToken::Type::Int; + is_original = false; + } else if (function_name == "float") { + value = b->cast(); + type = DataFileToken::Type::Float; + is_original = false; + } else if (function_name == "rand") { + // get the string representation of the double value + std::string string_value = DataFileToken::to_string(b->cast()); + + // compose the expression + value = "rnd(" + string_value + ")"; + type = DataFileToken::Type::Name; + is_original = false; + } else { + value = apply_function(function_name, b); + type = DataFileToken::Type::Float; + is_original = false; + } + + // if at least one of the two operand a or b is not an int nor a float, + // then we don't compute anything and create a node for that operation + } else if (!a->is_numeric() || !b->is_numeric()) { + left = a; + right = b; + } else { + // if both operands are int, preserve the result as int + // otherwise, promote the int to float + // an exception with division that always return a float + if (a->is_int() && b->is_int() && token.string != "/") { + //Cout << "Compute as ints" << finl; + value = compute(a, b); + type = DataFileToken::Type::Int; + is_original = false; + } else { + //Cout << "Compute as floats" << finl; + value = compute(a, b); + type = DataFileToken::Type::Float; + is_original = false; + } + } +} + +/** + * @brief Constructs a Node object with a given token and a single operand. + * + * This constructor initializes a Node object representing an operation + * or value in an expression tree. It ensures that the node is an operator + * and determines how to handle the operand based on its numeric type. + * + * @param token The token representing the operator or value for this node. + * @param a A pointer to the operand node. + * + * @note If the operand `a` is not numeric, the node is created with `a` as + * the right child and no left child. If the operand `a` is numeric, + * the value of the node is computed based on the operand's type: + * - If `a` is an integer, the result is computed as an integer. + * - If `a` is a float, the result is computed as a double. + * - Division operations always promote the result to an integer. + * + * @throws std::logic_error If the node is not an operator. + */ +DataFileExpression::Node::Node(const DataFileToken& token, std::shared_ptr a): + Node(token) { + + assert(is_operator()); + + // if at least one of the two operand a or b is not an int nor a float, + // then we don't compute anything and create a node for that operation + if (!a->is_numeric()) { + left = nullptr; + right = a; + } else { + // if both operands are float, preserve the result as int + // otherwise, promote the int to float + // always promote to int on division + if (a->is_int()) { + value = compute(a); + type = DataFileToken::Type::Int; + is_original = false; + } else { + value = compute(a); + type = DataFileToken::Type::Float; + is_original = false; + + } + } +} + + + +/** + * @brief Converts the current node of the expression tree into a string representation. + * + * This function recursively traverses the expression tree and generates a string + * representation of the node and its children. The output format depends on the type + * of the node (e.g., operator, operand, or function) and its associated value. + * + * @return A string representation of the node and its subtree. + * + * The behavior is as follows: + * - If the node is a leaf (no children): + * - If the node is marked as original (`is_original`), the original string is returned. + * - Otherwise, the value is reinterpreted based on its type and converted to a string. + * - If the node is an operator with both left and right children: + * - For function operators (e.g., "c"), the function name is processed and its arguments + * are enclosed in parentheses. + * - For binary operators, the left and right subtrees are recursively converted to strings, + * and the operator is inserted between them. Special cases for operators like "<=", ">=", + * "min", "max", "mod", and "&&" are handled with custom formatting. + * - If the node is a unary operator with only a right child: + * - The operator and the right subtree are combined into a string with appropriate formatting. + * - If the node does not match any of the above cases, an error message is printed, and the + * program exits. + * + * @note This function assumes that the node's type and value are valid and consistent. + * If an invalid state is encountered, the program will terminate with an error message. + */ +std::string DataFileExpression::Node::to_string() const { + // output recursively + if (left == nullptr && right == nullptr) { + // if the token is original (is_original flag is set; the value has not + // been change by evuating an expression or something else), simply return + // the original string + if (is_original) + return string; + + // otherwise, reinterpret the value with the correct type + switch (type) { + case DataFileToken::Type::Int: + return std::to_string(std::any_cast(value)); + case DataFileToken::Type::Float: + return DataFileToken::to_string(std::any_cast(value)); + default: + return std::any_cast(value); + } + } else if (left != nullptr && right != nullptr && type == DataFileToken::Type::Operator) { + std::string output; + if (std::any_cast(value) == "c") { // its a function + std::string function_name = left->to_string(); + if (function_name == "rand") { + output = "rnd"; + } else if (function_name == "sign") { + output = "sgn"; + } else { + output = function_name; + } + + output += "(" + right->to_string() + ")"; + return output; + } else { + output = "(" + left->to_string() + ")"; + if (std::any_cast(value) == "<=") + output += "["; + else if (std::any_cast(value) == ">=") + output += "]"; + else if (std::any_cast(value) == "min") + output += "_min_"; + else if (std::any_cast(value) == "max") + output += "_max_"; + else if (std::any_cast(value) == "mod") + output += "_mod_"; + else if (std::any_cast(value) == "&&") + output += "_and_"; + else + output += std::any_cast(value); + + output += "(" + right->to_string() + ")"; + return "(" + output + ")"; + + } + + } else if (left == nullptr && right != nullptr && type == DataFileToken::Type::OperatorUnary) { + return "(" + std::any_cast(value) + "(" + right->to_string() + "))"; + } else { + Cerr << "Fail to print" << finl; + Cerr << "type is " << type << finl; + Process::exit(DONT_PRINT_TOKEN); + return ""; + } +} + + +/** + * @brief Checks if the current node represents an integer type. + * + * This method determines whether the type of the current node + * is of type `DataFileToken::Type::Int`. + * + * @return true if the node type is `DataFileToken::Type::Int`, false otherwise. + */ +bool DataFileExpression::Node::is_int() const { + return type == DataFileToken::Type::Int; +} + +/** + * @brief Checks if the current node represents a floating-point value. + * + * @return true if the node's type is a floating-point value, false otherwise. + */ +bool DataFileExpression::Node::is_float() const { + return type == DataFileToken::Type::Float; +} + +/** + * @brief Checks if the current node represents a numeric value. + * + * This method determines whether the node is numeric by verifying + * if it is either an integer or a floating-point number. + * + * @return true if the node is numeric (integer or float), false otherwise. + */ +bool DataFileExpression::Node::is_numeric() const { + return is_int() || is_float(); +} + +/** + * @brief Computes the result of an operation between two nodes based on the operator stored in the current node. + * + * @tparam Type The data type of the values being computed (e.g., int, double). + * @param a Pointer to the left operand node. + * @param b Pointer to the right operand node. + * @return Type The result of the computation. + * + * @note The function supports the following operators: + * - Arithmetic: "+", "-", "*", "/", "^" (power) + * - Comparison: "<", ">", "<=", ">=" + * - Functions: "min", "max", "mod" (modulus) + * + * @warning Division by zero will terminate the program with an error message. + * @warning The operation 0^0 is considered undefined and will terminate the program with an error message. + * @warning If an unsupported operator is encountered, the program will terminate with an error message. + * + * @throws Process::exit(DONT_PRINT_TOKEN) If the right operand of a division is zero or if the operation is 0^0. + * @throws Process::exit(DONT_PRINT_TOKEN) If an unsupported operator is used. + */ +template +Type DataFileExpression::Node::compute(const std::shared_ptr a, const std::shared_ptr b) { + assert(is_operator()); + + + Type a_value = a->cast(); + Type b_value = b->cast(); + + Type output = 0; + + if (string == "+") { + output = a_value + b_value; + } else if (string == "-") { + output = a_value - b_value; + } else if (string == "*") { + output = a_value * b_value; + } else if (string == "/") { + if (b_value == 0) { + print_as_error("The right side of this division evaluates to 0, leading to undefinied result."); + Process::exit(DONT_PRINT_TOKEN); + } else { + output = a_value / b_value; + } + } else if (string == "^") { + if (a_value == 0 && b_value == 0) { + print_as_error("This operation evaluates to 0^0, which is undefined."); + Process::exit(DONT_PRINT_TOKEN); + } + output = static_cast(std::pow(static_cast(a_value), static_cast(b_value))); + } else if (string == "<") { + return static_cast(a_value < b_value); + } else if (string == ">") { + return static_cast(a_value > b_value); + } else if (string == "<=") { + return static_cast(a_value <= b_value); + } else if (string == ">=") { + return static_cast(a_value >= b_value); + } else if (string == "min") { + return std::min(a_value, b_value); + } else if (string == "max") { + return std::min(a_value, b_value); + } else if (string == "mod") { + return static_cast(std::fmod(a_value, b_value)); + } else { + print_as_error("Operator not supported for expression evaluation."); + Process::exit(DONT_PRINT_TOKEN); + } + + return output; +} + +/** + * @brief Computes the result of applying a unary operator to a given node. + * + * @tparam Type The type of the value to be computed. + * @param a Pointer to the node whose value will be used in the computation. + * @return Type The result of applying the unary operator to the value of the node. + * + * @note This function assumes that the current node represents an operator. + * It asserts that the node is an operator before proceeding. + * + * @details The function supports the following unary operators: + * - "+" (positive sign, returns the value as is) + * - "-" (negative sign, returns the negated value) + * + * @throws This function terminates the program if an unsupported unary operator + * is encountered, printing an error message before exiting. + * + * @warning Ensure that the node represents a valid unary operator before calling + * this function. Unsupported operators will cause the program to exit. + */ +template +Type DataFileExpression::Node::compute(const std::shared_ptr a) { + assert(is_operator()); + + Type a_value = a->cast(); + + //Cout << "Compute " << token.string << a_value << finl; + + if (string == "+") { + return +a_value; + } else if (string == "-") { + return -a_value; + } else { + print_as_error("Unary operator not supported for expression evaluation."); + Process::exit(DONT_PRINT_TOKEN); + return +a_value; // return to avoid compilation error + } +} + +/** + * @brief Applies a mathematical function to the given node's value. + * + * This template function evaluates a mathematical function specified by its name + * on the value of the provided node. The node's value must be either an integer + * or a floating-point number. The function handles various mathematical operations + * and performs domain checks where applicable. + * + * @tparam Type The type of the value to be processed (e.g., float, double). + * @param function_name The name of the mathematical function to apply. Supported + * functions include: + * - Trigonometric: "sin", "cos", "tan", "asin", "acos", "atan" + * - Hyperbolic: "sinh", "cosh", "tanh" + * - Exponential and logarithmic: "exp", "ln", "log10" + * - Miscellaneous: "sqrt", "rand", "abs", "sign" + * @param a A pointer to the node containing the value to process. + * @return The result of applying the specified function to the node's value. + * + * @throws std::runtime_error If the function name is not recognized or if the + * input value is outside the domain of the specified + * function. + * + * @note The function performs domain checks for operations like "tan", "asin", + * "acos", "ln", "log10", and "sqrt". If the input value is outside the + * valid domain, an error message is printed, and the program exits. + * + * @warning The "tan" function is undefined at odd multiples of π/2. The "ln" and + * "log10" functions require positive input values. The "sqrt" function + * requires non-negative input values. + */ +template +Type DataFileExpression::Node::apply_function(const std::string& function_name, const std::shared_ptr a) { + assert(a->is_int() || a->is_float()); + Type a_value = a->cast(); + + Type output = 0; + + if (function_name == "sin") { + output = sin(a_value); + } else if (function_name == "cos") { + output = cos(a_value); + } else if (function_name == "tan") { + if (fmod(fabs(a_value - M_PI_2), M_PI) < 1e-9) { + print_as_error("Domain error: tan() is undefined at odd multiples of π/2, not " + std::to_string(a_value) + "."); + Process::exit(DONT_PRINT_TOKEN); + } + output = tan(a_value); + } else if (function_name == "asin") { + if (a_value < -1 || a_value > 1) { + print_as_error("Domain error: asin() input must be in [-1, 1], not " + std::to_string(a_value) + "."); + Process::exit(DONT_PRINT_TOKEN); + } + output = asin(a_value); + } else if (function_name == "acos") { + if (a_value < -1 || a_value > 1) { + print_as_error("Domain error: acos() input must be in [-1, 1], not " + std::to_string(a_value) + "."); + Process::exit(DONT_PRINT_TOKEN); + } + output = acos(a_value); + } else if (function_name == "atan") { + output = atan(a_value); + } else if (function_name == "sinh") { + output = sinh(a_value); + } else if (function_name == "cosh") { + output = cosh(a_value); + } else if (function_name == "tanh") { + output = tanh(a_value); + } else if (function_name == "exp") { + output = exp(a_value); + } else if (function_name == "ln") { + if (a_value <= 0) { + print_as_error("Domain error: ln() input must be greater than 0, not " + std::to_string(a_value) + "."); + Process::exit(DONT_PRINT_TOKEN); + } + output = log(a_value); + } else if (function_name == "log10") { + if (a_value <= 0) { + print_as_error("Domain error: log10() input must be greater than 0, not " + std::to_string(a_value) + "."); + Process::exit(DONT_PRINT_TOKEN); + } + + output = log10(a_value); + } else if (function_name == "sqrt") { + if (a_value < 0) { + print_as_error("Domain error: sqrt() input must be greater or equal to 0, not " + std::to_string(a_value) + "."); + Process::exit(DONT_PRINT_TOKEN); + } + + output = sqrt(a_value); + } else if (function_name == "rand") { + output = a_value * drand48(); + } else if (function_name == "abs") { + output = std::abs(a_value); + } else if (function_name == "sign") { + output = static_cast(a_value > 0) - static_cast(a_value < 0); + } else { + print_as_error("Could not compute the value for this function."); + Process::exit(DONT_PRINT_TOKEN); + } + + return static_cast(output); +} + +//////////////////////////////// +// DataFileExpression methods // +//////////////////////////////// + +/** + * @brief Casts the stored value in the node to the specified type. + * + * This function attempts to cast the value stored in the node to the + * template type `Type`. The function checks the type of the stored + * value and performs the appropriate cast. If the type of the stored + * value is not supported, the function logs an error message and + * terminates the program. + * + * @tparam Type The type to which the stored value should be cast. + * @return The casted value of type `Type`. + * + * @throws std::bad_any_cast If the stored value cannot be cast to the + * expected type (e.g., if the type does not match the stored value). + * + * @note The function will terminate the program if the stored value + * is of an invalid type. + * + * @warning Ensure that the stored value is compatible with the + * requested cast type to avoid unexpected behavior. + */ +template +Type DataFileExpression::Node::cast() const { + if (is_int()) { + return static_cast(std::any_cast(value)); + } else if (is_float()) { + return static_cast(std::any_cast(value)); + } else { + Cerr << "Cannot cast value during evaluation of expression, invalid type." << finl; + Process::exit(DONT_PRINT_TOKEN); + return static_cast(0); // dummy return to avoid compilation error + } +} + +/** + * @brief Constructs a DataFileExpression object by parsing a range of tokens. + * + * This constructor processes a range of tokens representing a mathematical or logical + * expression. It validates the tokens, removes spaces, checks for balanced parentheses, + * and prepares the expression for evaluation by constructing a tree representation. + * + * @param start An iterator pointing to the beginning of the token range. + * @param end An iterator pointing to the end of the token range. + * + * @details + * - Tokens are validated to ensure they are of valid types (space, operator, operand, + * parenthesis, or name). Invalid tokens result in an error message and program termination. + * - Spaces are ignored, and only meaningful tokens are stored. + * - Parentheses are checked for balance. + * - If the expression starts with a '+' or '-' operator, a '0' is prepended to ensure + * compatibility with the Shunting Yard algorithm. Any other starting operator results + * in an error message and program termination. + * - A tree representation of the expression is constructed for further evaluation. + * + * @throws Terminates the program if invalid tokens are encountered, parentheses are unbalanced, + * or the expression starts with an invalid operator. + */ +DataFileExpression::DataFileExpression( + const DataFileExpression::Tokens::iterator& start, + const DataFileExpression::Tokens::iterator& end) { + + // copy the tokens of the expression without the spaces + auto token = start; + do { + // check the types + if (!token->is_space() && !token->is_operator() && !token->is_operand() && !token->is_parenthesis() && !token->is_name()) { + token->print_as_error("Invalid token inside an expression."); + Process::exit(DONT_PRINT_TOKEN); + } + + if (!token->is_space()) + tokens.push_back(*token); + } while (token++ != end); + + // check parenthesis + check_parenthesis(tokens); + + // if the expression start with an operator + or -, add a 0 in front + // to make the Shuting Yard algorithm + // if we have any other operators it is an error + if (tokens.front().is_operator()) { + if (tokens.front().string == "+" || tokens.front().string == "-") { + tokens.push_front(DataFileToken("", 0, 0, 0, 0, DataFileToken::Type::Int, "0")); + } else { + tokens.front().print_as_error("Expression cannot start with an operator '" + tokens.front().string + "'."); + Process::exit(DONT_PRINT_TOKEN); + } + } + + // construct the tree of the expression + root = treefy(tokens.begin(), std::prev(tokens.end())); +} + +/** + * @brief Retrieves the value of the DataFileExpression as a DataFileToken. + * + * This method constructs and returns a DataFileToken object representing + * the value of the DataFileExpression. The token is initialized using + * the file name, start line, start column, end line, and end column + * from the first and last tokens in the `tokens` list. The type and + * value of the token are then set based on the `root` node of the + * expression. + * + * @return A DataFileToken object representing the value of the expression. + */ +DataFileToken DataFileExpression::value() const { + + DataFileToken token( + tokens.front().file_name, + tokens.front().start_line, + tokens.front().start_column, + tokens.back().end_line, + tokens.back().end_column, + DataFileToken::Type::Name, + ""); + token.type= root->type; + token.value = root->value; + + return token; +} + +/** + * @brief Determines if the expression represented by the DataFileExpression object is numeric. + * + * This method checks whether the root node of the expression tree is numeric. + * A numeric expression typically consists of constant values or expressions + * that can be evaluated to a numeric result without any symbolic variables. + * + * @return true if the expression is numeric, false otherwise. + */ +bool DataFileExpression::is_numeric() { + return root->is_numeric(); +} + +/** + * @brief Validates the proper usage of parentheses in a sequence of tokens. + * + * This function performs the following checks: + * - Ensures that all opened parentheses are properly closed. + * - Verifies that an open parenthesis is preceded by another open parenthesis + * or an operator, and is followed by an operand, a unary operator, or another open parenthesis. + * - Ensures that a closing parenthesis is preceded by another closing parenthesis + * or an operand, and is followed by an operator or another open parenthesis. + * - Detects unmatched parentheses and provides detailed error messages indicating the issue. + * + * If any of the above conditions are violated, the function prints an error message + * and terminates the program. + * + * @param tokens A collection of tokens representing the expression to be validated. + */ +void DataFileExpression::check_parenthesis(const DataFileExpression::Tokens& tokens) { + // check that all opened parenthesis are properly closed + // also check if if open parenthesis are precede by another + // open parenthesis or an operator, and are followed by an operand or and unary operator or and another open parenthesis + // and check if closing parenthesis are precede by another closing parenthesis + // or and operand, and followed by an operator or another open parenthesis + size_t depth = 0; + for (auto token = tokens.begin(); token != tokens.end(); token++) { + if (token->type == DataFileToken::Type::OpenParenthesis) { + depth++; + if (token != tokens.begin() && std::prev(token)->is_operand()) { + token->print_as_error("An operand cannot be followed by an open parenthesis."); + std::prev(token)->print_as_note("The operand."); + Process::exit(DONT_PRINT_TOKEN); + } + } else if (token->type == DataFileToken::Type::CloseParenthesis) { + if (depth == 0) { + token->print_as_error("This parenthesis has never been opened."); + Process::exit(DONT_PRINT_TOKEN); + } else { + depth--; + } + + if (token != tokens.begin() && std::prev(token)->is_operator()) { + token->print_as_error("An operator cannot be followed by a close parenthesis."); + std::prev(token)->print_as_note("The operator."); + Process::exit(DONT_PRINT_TOKEN); + } + } + } + + // if one parentesis has not been closed + if (depth != 0) { + // search the last open parenthesis at the same depth + size_t depth_tmp = depth; + for (auto token = tokens.rbegin(); token!= tokens.rend(); token++) { + if (token->type == DataFileToken::Type::OpenParenthesis) + depth_tmp--; + else if (token->type == DataFileToken::Type::CloseParenthesis) + depth_tmp++; + + if (depth_tmp == depth - 1) { + token->print_as_error("This parenthesis has never been closed."); + Process::exit(DONT_PRINT_TOKEN); + } + } + + Cerr << "Not matching parenthesis. Failed to identify where." << finl; + Process::exit(DONT_PRINT_TOKEN); + } +} + +/** + * @brief Converts a sequence of tokens into an expression tree. + * + * This function takes a range of tokens and constructs an expression tree + * using the Shunting Yard algorithm to first convert the tokens into postfix + * notation (Reverse Polish Notation). It then processes the postfix tokens + * to build a tree structure representing the expression. + * + * @param start Iterator pointing to the beginning of the token sequence. + * @param end Iterator pointing to the end of the token sequence. + * @return A pointer to the root node of the constructed expression tree. + * + * @details + * The function performs the following steps: + * 1. Converts the input token sequence into postfix notation using the + * Shunting Yard algorithm. + * 2. Processes the postfix tokens to construct the expression tree: + * - If a token is an operand, it is wrapped in a Node and pushed onto a stack. + * - If a token is an operator: + * - For unary operators, one operand is popped from the stack, and a new + * Node is created with the operator and operand. + * - For binary operators, two operands are popped from the stack, and a + * new Node is created with the operator and the two operands. + * 3. Ensures that only one node remains in the stack, which becomes the root + * of the expression tree. + * + * @note The function assumes that the input tokens are valid and properly + * formatted. If an invalid token type is encountered, the program + * terminates with an error message. + * + * @throws std::assertion_failure If the stack does not contain exactly one + * node at the end of processing. + */ +std::shared_ptr DataFileExpression::treefy( + const DataFileExpression::Tokens::iterator& start, + const DataFileExpression::Tokens::iterator& end) { + + // first convert the token string to postfix notation / reverse Polish notation + // using the Shuting yard algorithm + std::vector tokens_postfix = Shuting_yard(start, end); + + // convert to tree + // since we have simple reversed Polish notation, we read each token: + // if an operand is read, wrap it in a Node and put it in a stack. + // if it is an operator, we pop the last two operand of the stack, perform + // the operation (may result in Int, Float, or an expression if there is unknown + // terms, and put it back on the stack. + // Additional support is added for unary operator + // at the end, we only have one node. + std::vector> stack; + + for (auto& token: tokens_postfix) { + if (token.is_operand()) { + stack.push_back(std::make_shared(token)); + } else if (token.is_operator()) { + if (token.type == DataFileToken::OperatorUnary) { + // pop one value + std::shared_ptr a = stack.back(); + stack.pop_back(); + + // then compute the unary operator + stack.push_back(std::make_shared(token, a)); // perform computation + } else { + // dual operator + assert(stack.size() >= 2); + std::shared_ptr b = stack.back(); + stack.pop_back(); + std::shared_ptr a = stack.back(); + stack.pop_back(); + stack.push_back(std::make_shared(token, a, b)); // perform computation + } + } else { + Cerr << "Invalid type " << token.type << " in expression tree." << finl; + Process::exit(DONT_PRINT_TOKEN); + } + } + + assert(stack.size() == 1); // check if we only have one node as the root of the tree + + // return the root of the tree + return stack.front(); +} + +/** + * @brief Converts a sequence of tokens into Reverse Polish Notation (RPN) using the Shunting-yard algorithm. + * + * This function processes a range of tokens and rearranges them into a format suitable for evaluation + * by converting infix expressions to postfix (RPN). It handles operators, operands, parentheses, and + * operator precedence and associativity. + * + * @param start An iterator pointing to the beginning of the token sequence. + * @param end An iterator pointing to the end of the token sequence. + * @return A vector of DataFileToken objects representing the expression in RPN. + * + * @details + * - Operands are directly added to the output. + * - Operators are pushed onto a stack, respecting precedence and associativity rules. + * - Parentheses are used to group expressions and are handled accordingly: + * - Open parentheses are pushed onto the stack. + * - Close parentheses cause the stack to be unwound until the matching open parenthesis is found. + * - Unary operators are identified and promoted when necessary. + * - Any remaining operators in the stack are added to the output at the end. + * + * @note The function assumes that the input tokens are well-formed and does not handle malformed expressions. + * If mismatched parentheses are encountered, an error message is printed. + */ +std::vector DataFileExpression::Shuting_yard( + const DataFileExpression::Tokens::iterator& start, + const DataFileExpression::Tokens::iterator& end) { + + // implementation from + // https://en.wikipedia.org/wiki/Shunting_yard_algorithm + // with inspiration from + // https://inspirnathan.com/posts/155-handling-unary-operations-with-shunting-yard-algorithm + // to make it work with unary operators + auto token = start; + std::vector out; + std::vector stack; + + // initialize previous with a dummy token + DataFileToken previous("", 0, 0, 0, 0, DataFileToken::Type::Space, ""); + + do { + if (token->is_operand()) { + out.push_back(*token); + } else if (token->is_operator()) { + if (previous.is_operator() || previous.is_space() || previous.type == DataFileToken::Type::OpenParenthesis) { + + // promote this operator to unary + token->type = DataFileToken::Type::OperatorUnary; + } + while (stack.size() > 0 && + stack.back().is_operator() && + (stack.back().precedence() > token->precedence() || ( + stack.back().precedence() == token->precedence() && token->associativity() == 'l') + )) { + + out.push_back(stack.back()); + stack.pop_back(); + } + + stack.push_back(*token); + // skip the ',' case + } else if (token->type == DataFileToken::Type::OpenParenthesis) { + stack.push_back(*token); + } else if (token->type == DataFileToken::Type::CloseParenthesis) { + while (stack.size() > 0 && + stack.back().type != DataFileToken::Type::OpenParenthesis) { + + out.push_back(stack.back()); + stack.pop_back(); + } + if (stack.back().type != DataFileToken::Type::OpenParenthesis) { + stack.back().print_as_error("We expected an open parenthesis."); + } + stack.pop_back(); // remove the parenthesis + } + + previous = *token; + + } while (token++ != end); + + while (stack.size() > 0) { + out.push_back(stack.back()); + stack.pop_back(); + } + + return out; +} + +/** + * @brief Converts the DataFileExpression object to its string representation. + * + * This method generates a string representation of the DataFileExpression + * by invoking the `to_string` method on the root node of the expression tree. + * + * @return A string that represents the root of the expression tree. + */ +std::string DataFileExpression::to_string() const { + // print the root of the tree + return root->to_string(); +} diff --git a/src/Kernel/Utilitaires/DataFileExpression.h b/src/Kernel/Utilitaires/DataFileExpression.h new file mode 100644 index 0000000000..fce790d80f --- /dev/null +++ b/src/Kernel/Utilitaires/DataFileExpression.h @@ -0,0 +1,137 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ +#ifndef DataFileExpression_included +#define DataFileExpression_included + +#include +#include +#include +#include + +#include + +class DataFileExpression { + + ///////////////////// + // class / structs // + ///////////////////// + + private: + + struct Node: public DataFileToken { + + ////////////////// + // constructors // + ////////////////// + + // copy from a DataFileToken + Node(const DataFileToken& token); + + // performe computation if possible + Node(const DataFileToken& token, std::shared_ptr a, std::shared_ptr b); + + // performe computation if possible on unary operators + Node(const DataFileToken& token, std::shared_ptr a); + + ///////////// + // methods // + ///////////// + + bool is_int() const; + bool is_float() const; + bool is_numeric() const; + + template + Type compute(const std::shared_ptr a, const std::shared_ptr b); + + template + Type compute(const std::shared_ptr a); + + template + Type apply_function(const std::string& function_name, const std::shared_ptr a); + + // cast the value to the given Type + template + Type cast() const; + + // return string representation + std::string to_string() const; + + //////////////// + // attributes // + //////////////// + + std::shared_ptr left = nullptr; + std::shared_ptr right = nullptr; + + // boolean to register if the value store in the node is the one from the + // original token or not + bool is_original = true; + }; + + + ///////////// + // aliases // + ///////////// + + using Tokens = std::list; + + ////////////////// + // constructors // + ////////////////// + + public: + + DataFileExpression( + const Tokens::iterator& start, + const Tokens::iterator& end); + + ///////////// + // methods // + ///////////// + + public: + + void evaluate(); + bool is_numeric(); + DataFileToken value() const; + std::string to_string() const; + + private: + + static void check_parenthesis(const Tokens& tokens); + + static std::shared_ptr treefy( + const Tokens::iterator& start, + const Tokens::iterator& end); + + static std::vector Shuting_yard( + const DataFileExpression::Tokens::iterator& start, + const DataFileExpression::Tokens::iterator& end); + + //////////////// + // attributes // + //////////////// + + public: + + std::list tokens; + + private: + + std::shared_ptr root = nullptr; +}; + +#endif diff --git a/src/Kernel/Utilitaires/DataFileStream.cpp b/src/Kernel/Utilitaires/DataFileStream.cpp new file mode 100644 index 0000000000..94ad7ca99a --- /dev/null +++ b/src/Kernel/Utilitaires/DataFileStream.cpp @@ -0,0 +1,116 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ + +#include +#include + +// initialize the tokens list with an empty list and the current list iterator +DataFileStream::Tokens DataFileStream::tokens = Tokens(); +DataFileStream::Tokens::iterator DataFileStream::current_token_iterator = tokens.begin(); +size_t DataFileStream::tokens_to_skip = 0; + +DataFileStream::DataFileStream() : + Entree(), istrstream_(0) +{ + set_check_types(1); +} + +DataFileStream::DataFileStream(const std::string& string, const Tokens& tokens_) : + Entree(), istrstream_(0) +{ + set_check_types(1); + init(string, tokens_); +} + +DataFileStream::~DataFileStream() { } + +/** + * @brief Initializes the DataFileStream with a given input string and a list of tokens. + * + * This function sets up the DataFileStream by copying the provided list of tokens + * and initializing an input string stream with the given string. It also sets the + * current token iterator to the first non-space or non-comment token in the list. + * + * @param string The input string to be processed by the DataFileStream. + * @param tokens_ The list of tokens to be used for parsing the input string. + * + * @note The first token is skipped during the next read operation. + * @note If an existing input string stream is present, it will be deleted before + * creating a new one. + */ +void DataFileStream::init(const std::string& string, const Tokens& tokens_) +{ + // takes a string and a list of tokens (words in the string and tokens list should match) + + Cerr << "Initialize the DataFileStream" << finl; + // copy the list of tokens + tokens = tokens_; + + // set the current token iterator to the first non-space token or non-comment + current_token_iterator = tokens.begin(); + while (std::next(current_token_iterator) != tokens.end() && (current_token_iterator->is_space() || current_token_iterator->is_comment())) + current_token_iterator++; + + // sinc the first token is already set, we will skip the next read + tokens_to_skip = 1; + + // creat a istringstream with the given input string + if (istrstream_) + delete istrstream_; + istrstream_ = new istringstream(string); // a copy of str is taken + set_istream(istrstream_); +} + +Entree& DataFileStream::operator>>(True_int& ob) { return operator_template(ob); } +Entree& DataFileStream::operator>>(double& ob) { return operator_template(ob); } + +/** + * @brief Reads data into the provided buffer while maintaining synchronization + * with the internal token iterator and handling spaces and comments. + * + * This function overrides the `get` method to ensure that the internal token + * iterator of the `DataFileStream` remains synchronized with the input stream. + * It skips over spaces and comments in the token stream and adjusts the number + * of tokens to skip based on the spaces in the current token's string. + * + * @param ob Pointer to the buffer where the data will be stored. + * @param bufsize The size of the buffer. + * @return The number of characters read into the buffer. + */ +int DataFileStream::get(char *ob, std::streamsize bufsize) +{ + // Increment the current_token_index and skip spaces + // Some tokens may store in their string spaces. We must avoid incrementing the + // token iterator as much as the number of spaces in that literal string + // so that the internal istringstream of DataFileStream stay synchronyze with + // the token iterator + if (tokens_to_skip == 0 && current_token_iterator != tokens.end() && std::next(current_token_iterator) != tokens.end()) { + current_token_iterator++; + while (std::next(current_token_iterator) != tokens.end() && (current_token_iterator->is_space() || current_token_iterator->is_comment())) { + current_token_iterator++; + } + + // count the number of spaces and set this number as the number of + // tokens to skip + std::string str = current_token_iterator->string; + tokens_to_skip = static_cast(std::count(str.begin(), str.end(), ' ')); + + } else if (tokens_to_skip > 0) { + tokens_to_skip--; + } + + int ret = Entree::get(ob,bufsize); + return ret; +} diff --git a/src/Kernel/Utilitaires/EChaineJDD.h b/src/Kernel/Utilitaires/DataFileStream.h similarity index 68% rename from src/Kernel/Utilitaires/EChaineJDD.h rename to src/Kernel/Utilitaires/DataFileStream.h index b2c02813c1..932d223af8 100644 --- a/src/Kernel/Utilitaires/EChaineJDD.h +++ b/src/Kernel/Utilitaires/DataFileStream.h @@ -1,5 +1,5 @@ /**************************************************************************** -* Copyright (c) 2024, CEA +* Copyright (c) 2025, CEA * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -13,26 +13,29 @@ * *****************************************************************************/ -#ifndef EChaineJDD_included -#define EChaineJDD_included +#ifndef DataFileStream_included +#define DataFileStream_included #include +#include #include + using std::istringstream; /*! @brief * Same as EChaine except here the input string comes from a datafile. - * Keeps a track of the lines that have been read in the datafile so far, - * so in case of a TRUST crash, we can get the line in the datafile where the error occured + * Keeps a track of tokens that have been read in the datafile so far, + * so in case of a TRUST crash, we can get information in the datafile where the error occured */ -class EChaineJDD : public Entree +class DataFileStream : public Entree { public: + using Tokens = std::list; - EChaineJDD(); - EChaineJDD(const char* str); - ~EChaineJDD() override; - void init(const char *str); + DataFileStream(); + DataFileStream(const std::string& string, const Tokens& tokens_); + ~DataFileStream() override; + void init(const std::string& string, const Tokens& tokens_); using Entree::operator>>; using Entree::get; @@ -40,13 +43,19 @@ class EChaineJDD : public Entree Entree& operator>>(double& ob) override; int get(char *ob, std::streamsize bufsize) override; - void set_track_lines(bool b) { track_lines_ = b ;} + // store the list of tokens and store an iterator to the last read token + static Tokens tokens; + static Tokens::iterator current_token_iterator; + + // also store a static bool to know if we are reading the first word or not (to correctly initialize the current_token_iterator) + static bool first_token_readed; - static int file_cur_line_; + // also store the number of tokens to skip when reading a literal string that contain + // space characters + static size_t tokens_to_skip; protected: istringstream* istrstream_; - bool track_lines_; template Entree& operator_template(_TYPE_& ob); @@ -54,7 +63,7 @@ class EChaineJDD : public Entree template -Entree& EChaineJDD::operator_template(_TYPE_& ob) +Entree& DataFileStream::operator_template(_TYPE_& ob) { assert(istrstream_!=0); char buffer[100]; @@ -65,5 +74,3 @@ Entree& EChaineJDD::operator_template(_TYPE_& ob) } #endif - - diff --git a/src/Kernel/Utilitaires/DataFileToken.cpp b/src/Kernel/Utilitaires/DataFileToken.cpp new file mode 100644 index 0000000000..9903a79546 --- /dev/null +++ b/src/Kernel/Utilitaires/DataFileToken.cpp @@ -0,0 +1,1151 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ +#include +#include + +/** + * @brief Constructs a DataFileToken object and initializes its attributes. + * + * This constructor initializes the token with its file location, type, and string value. + * Depending on the token type, it computes and stores the corresponding value in a `std::any`. + * + * @param file_name_ The name of the file where the token is located. + * @param start_line_ The starting line number of the token in the file. + * @param start_column_ The starting column number of the token in the file. + * @param end_line_ The ending line number of the token in the file. + * @param end_column_ The ending column number of the token in the file. + * @param type_ The type of the token, as defined in the DataFileToken::Type enumeration. + * @param string_ The string representation of the token read from the input file. + * + * @note For certain token types, the constructor extracts or computes a value from the string + * representation and stores it in the `value` attribute. For example: + * - Comments have their delimiters removed. + * - String literals have their quotes removed. + * - Integer and floating-point tokens are parsed into their respective numeric types. + * + * @throws std::invalid_argument If the string cannot be converted to an integer or floating-point value. + * @throws std::out_of_range If the numeric value is out of range for its type. + * + * @warning If an error occurs during numeric conversion or an unsupported token type is encountered, + * the program will terminate using `Process::exit(DONT_PRINT_TOKEN)`. + */ +DataFileToken::DataFileToken( + const std::string& file_name_, + size_t start_line_, + size_t start_column_, + size_t end_line_, + size_t end_column_, + DataFileToken::Type type_, + std::string string_): + + file_name(file_name_), + start_line(start_line_), + start_column(start_column_), + end_line(end_line_), + end_column(end_column_), + type(type_), + string(string_) { + + // depending on the type, compute the value and store it in a std::any + switch (type) { + case DataFileToken::Type::CommentBlockHash: + case DataFileToken::Type::CommentBlockCStyle: + value = string.substr(2, string.size() - 4); break; + case DataFileToken::Type::CommentLineCStyle: + value = string.substr(2); break; + case DataFileToken::Type::OpenCurlyBracket: + case DataFileToken::Type::CloseCurlyBracket: + case DataFileToken::Type::OpenParenthesis: + case DataFileToken::Type::CloseParenthesis: + case DataFileToken::Type::Space: + case DataFileToken::Type::Expression: + value = std::string(""); break; + case DataFileToken::Type::Operator: + case DataFileToken::Type::OperatorUnary: + case DataFileToken::Type::Name: + value = string; break; + case DataFileToken::Type::LiteralString: + value = string.substr(1, string.size() - 2); break; + case DataFileToken::Type::Int: { + try { + value = std::stoi(string); + break; + } catch (std::invalid_argument const& ex) { + print_as_error("Failed to interpret this token as integer."); + Process::exit(DONT_PRINT_TOKEN); + break; + } catch (std::out_of_range const& ex) { + print_as_error("Integer value is out of available range."); + Process::exit(DONT_PRINT_TOKEN); + break; + }} + case DataFileToken::Type::Float: { + try { + value = std::stod(string); + break; + } catch (std::invalid_argument const& ex) { + print_as_error("Failed to interpret this token as floating point number."); + Process::exit(DONT_PRINT_TOKEN); + break; + } catch (std::out_of_range const& ex) { + print_as_error("Floating point value is out of available range."); + Process::exit(DONT_PRINT_TOKEN); + break; + }} + case DataFileToken::Type::Macro: + value = string.substr(1); break; + default: + print_as_error("Not valid token type for this token."); + Process::exit(DONT_PRINT_TOKEN); + } +} + +// return a set of all necessary Types for tokenization +std::set DataFileToken::get_types_full_set() { + std::set out = { + CommentBlockHash, + CommentBlockCStyle, + CommentLineCStyle, + OpenCurlyBracket, + CloseCurlyBracket, + OpenParenthesis, + CloseParenthesis, + Operator, + Space, + Name, + LiteralString, + Int, + Float, + Macro + }; + return out; +} + + +/** + * @brief Determines if a given character is considered a "letter" based on specific criteria. + * + * This function checks if the input character falls within one of the following categories: + * - Lowercase English letters ('a' to 'z') + * - Uppercase English letters ('A' to 'Z') + * - Underscore ('_') + * - Period ('.') + * - Percent sign ('%') + * - Equals sign ('=') + * - Digits ('0' to '9') + * + * @param c The character to be checked. + * @return true If the character matches any of the specified criteria. + * @return false Otherwise. + */ +bool DataFileToken::isletter(char c) { + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_' || c == '.' || c == '%' || c == '=' || ('0' <= c && c <= '9'); +} + +/** + * @brief Converts a double value to its string representation in scientific notation. + * + * This function takes a double value and converts it to a string using scientific + * notation with the maximum number of significant digits that can be represented + * without loss of precision for a double type. + * + * @param value The double value to be converted to a string. + * @return A string representation of the input value in scientific notation. + */ +std::string DataFileToken::to_string(double value) { + std::ostringstream oss; + oss << std::scientific << std::setprecision(std::numeric_limits::max_digits10) << value; + return oss.str(); +} + +/** + * @brief Overloads the stream insertion operator to output a DataFileToken::Type. + * + * This function allows a DataFileToken::Type to be written to a Sortie stream. + * It uses an intermediate std::ostringstream to convert the token type to a string + * representation before inserting it into the output stream. + * + * @param os The output stream (Sortie) to which the token type will be written. + * @param token_type The DataFileToken::Type to be written to the output stream. + * @return A reference to the output stream (Sortie) after the token type has been written. + */ +Sortie& operator<<(Sortie& os, const DataFileToken::Type& token_type) { + std::ostringstream oss; + oss << token_type; + return os << oss.str(); +} + +/** + * @brief Overloads the stream insertion operator to output a string representation + * of a DataFileToken::Type enumeration value. + * + * @param os The output stream to which the string representation will be written. + * @param token_type The DataFileToken::Type enumeration value to be converted to a string. + * @return A reference to the output stream after the string representation has been written. + * + * @details This function maps each enumeration value of DataFileToken::Type to its + * corresponding string representation. If the enumeration value does not + * match any of the predefined cases, "UNKNOWN_TOKEN_TYPE" is written to the stream. + * + * @note The function assumes that all possible enumeration values are handled explicitly + * in the switch statement. If a new enumeration value is added to DataFileToken::Type, + * the switch statement should be updated accordingly. + */ +std::ostream& operator<<(std::ostream& os, const DataFileToken::Type& token_type) { + switch (token_type) { + case DataFileToken::Type::CommentBlockHash: + return os << "CommentBlockHash"; + case DataFileToken::Type::CommentBlockCStyle: + return os << "CommentBlockCStyle"; + case DataFileToken::Type::CommentLineCStyle: + return os << "CommentLineCStyle"; + case DataFileToken::Type::OpenCurlyBracket: + return os << "OpenCurlyBracket"; + case DataFileToken::Type::CloseCurlyBracket: + return os << "CloseCurlyBracket"; + case DataFileToken::Type::OpenParenthesis: + return os << "OpenParenthesis"; + case DataFileToken::Type::CloseParenthesis: + return os << "CloseParenthesis"; + case DataFileToken::Type::Operator: + return os << "Operator"; + case DataFileToken::Type::OperatorUnary: + return os << "OperatorUnary"; + case DataFileToken::Type::Space: + return os << "Space"; + case DataFileToken::Type::Name: + return os << "Name"; + case DataFileToken::Type::LiteralString: + return os << "LiteralString"; + case DataFileToken::Type::Int: + return os << "Int"; + case DataFileToken::Type::Float: + return os << "Float"; + case DataFileToken::Type::Macro: + return os << "Macro"; + case DataFileToken::Type::Expression: + return os << "Expression"; + default: + return os << "UNKNOWN_TOKEN_TYPE"; + } +} + +/** + * @brief Checks if a given string is a valid comment block based on hash ('#') characters. + * + * This function determines the validity of a comment block string by checking: + * - If the string has a single character and it is '#'. + * - If the string has two characters and the second character is a whitespace. + * - If the string has more than two characters and the third-to-last character is not a whitespace. + * - If the string has more than three characters and the second-to-last character is not '#'. + * + * @param string The input string to validate as a comment block. + * @return true if the string satisfies the conditions for a valid comment block, false otherwise. + */ +bool DataFileToken::check_comment_block_hash(const std::string& string) { + // is valid if the first character is '#' and until the last character is '#' + size_t length = string.length(); + return (length == 1 && string[0] == '#') || + (length == 2 && isspace(string[1])) || + (length > 2 && !isspace(string[length - 3])) || + (length > 3 && string[length - 2] != '#'); +} + +/** + * @brief Checks if a given string represents a valid C-style comment block. + * + * A valid C-style comment block, and has matching + * pairs of delimiter patterns within the comment body. + * + * @param string The input string to check. + * @return true if the string is a valid C-style comment block, false otherwise. + * + * @note The function considers the following cases: + * - If the string length is 1, it is valid only if it contains '/'. + * - If the string length is 2, it is valid only if it contains the starting delimiter. + * - For longer strings, it checks the balance of starting delimiter and ending delimiter patterns within + * the comment body. + */ +bool DataFileToken::check_comment_block_c_style(const std::string& string) { + // is valid if the first character is '/', the second is '*', and until the penultimate is '*' and the last is '/' + size_t length = string.length(); + if (length <= 2) { + return (length == 1 && string[0] == '/') || + (length == 2 && string[1] == '*'); + } else { + // counte the number of "/*" pattern and close pattern and close pattern + size_t count_open = 0; + size_t count_close = 0; + + std::string substring = string.substr(2, length - 3); + + size_t pos = 0; + while ((pos = substring.find("/*", pos)) != std::string::npos) { + count_open++; + pos += 2; + } + + pos = 0; + while ((pos = substring.find("*/", pos)) != std::string::npos) { + count_close++; + pos += 2; + } + + return count_open + 1 != count_close; + } +} + +/** + * @brief Checks if a given string represents a C-style comment line. + * + * This function determines whether the input string is a valid C-style comment line. + * A valid C-style comment line satisfies one of the following conditions: + * - The string has a length of 1 and the first character is '/'. + * - The string has a length of 2 and the second character is '/'. + * - The string has a length greater than 2 and the last character is not '\n'. + * + * @param string The input string to check. + * @return true if the string is a valid C-style comment line, false otherwise. + */ +bool DataFileToken::check_comment_line_c_style(const std::string& string) { + // is valid if the first two characters are '/' and until the last character is '\n' + size_t length = string.length(); + return (length == 1 && string[0] == '/') || + (length == 2 && string[1] == '/') || + (length > 2 && string[length - 1] != '\n'); +} + +/** + * @brief Checks if the given string contains exactly one character and that character is an open curly bracket '{'. + * + * @param string The input string to be checked. + * @return true If the string has a length of 1 and the character is '{'. + * @return false Otherwise. + */ +bool DataFileToken::check_open_curly_bracket(const std::string& string) { + return (string.length() == 1 && string[0] == '{'); +} + +/** + * @brief Checks if the given string is a single closing curly bracket ('}'). + * + * This function verifies whether the input string has a length of exactly one + * and contains the closing curly bracket character ('}'). + * + * @param string The input string to check. + * @return true if the string is exactly one character long and is '}', false otherwise. + */ +bool DataFileToken::check_close_curly_bracket(const std::string& string) { + return (string.length() == 1 && string[0] == '}'); +} + +/** + * @brief Checks if the given string is a single open parenthesis '('. + * + * @param string The input string to check. + * @return true If the string has a length of 1 and contains the character '('. + * @return false Otherwise. + */ +bool DataFileToken::check_open_parenthesis(const std::string& string) { + return (string.length() == 1 && string[0] == '('); +} + +/** + * @brief Checks if the given string is a single closing parenthesis. + * + * This function verifies whether the input string consists of exactly one + * character and that character is a closing parenthesis ')'. + * + * @param string The input string to check. + * @return true if the string is exactly one character long and is ')', + * false otherwise. + */ +bool DataFileToken::check_close_parenthesis(const std::string& string) { + return (string.length() == 1 && string[0] == ')'); +} + +/** + * @brief Checks if the given string represents a valid operator. + * + * This function evaluates whether the input string matches any of the predefined + * operators or symbols. The supported operators include arithmetic, logical, + * comparison, and other miscellaneous symbols. + * + * @param string The input string to check. + * @return true If the input string matches one of the predefined operators. + * @return false If the input string does not match any of the predefined operators. + */ +bool DataFileToken::check_operator(const std::string& string) { + return (string == "+") || + (string == "-") || + (string == "*") || + (string == "/") || + (string == "^") || + (string == "min") || + (string == "max") || + (string == "mod") || + (string == "$") || + (string == ":") || + (string == ";") || + (string == ",") || + (string == "&") || + (string == "&&") || + (string == ">") || + (string == "<") || + (string == ">=") || + (string == "]") || + (string == "<=") || + (string == "["); +} + +/** + * @brief Checks if the last character of a given string is a whitespace character. + * + * @param string The input string to be checked. + * @return true If the last character of the string is a whitespace character. + * @return false Otherwise. + */ +bool DataFileToken::check_space(const std::string& string) { + return isspace(string[string.length() - 1]); +} + +/** + * @brief Checks if the given string is a valid name based on specific rules. + * + * A valid name must satisfy the following conditions: + * - It can only contain alphanumeric characters. + * - It cannot start with a digit. + * - If the string has only one character, it must be a letter. + * - If the string has more than one character, the last character can be either a letter or a digit. + * + * @param string The input string to validate. + * @return true if the string is valid according to the rules, false otherwise. + */ +bool DataFileToken::check_name(const std::string& string) { + // valid if it only contains alphanumeric but not digits + // it can contain numbers in it but not on the first character + size_t size = string.length(); + if (string.length() == 1) + return isletter(string[size - 1]); + else + return isletter(string[size - 1]) || isdigit(string[size - 1]); +} + +/** + * @brief Checks if a given string is a valid literal string. + * + * A string is considered valid if it meets the following conditions: + * - It contains only ASCII characters. + * - It has a length of 1 and the single character is a double quote (`"`). + * - It has a length of 2. + * - It has a length greater than 2 and the second-to-last character is not a double quote (`"`). + * + * @param string The string to be checked. + * @return true if the string is a valid literal string, false otherwise. + */ +bool DataFileToken::check_literal_string(const std::string& string) { + // valid if it only contains ascii characters + return (string.length() == 1 && string[0] == '"') || + (string.length() == 2) || + (string.length() > 2 && string[string.length() - 2] != '"'); +} + +/** + * @brief Checks if the given string represents an integer value. + * + * This function determines whether the provided string is a valid integer. + * It allows for hexadecimal values in the format "0x". + * + * @param string The input string to check. + * @return true If the string represents an integer or a valid hexadecimal value. + * @return false Otherwise. + */ +bool DataFileToken::check_int(const std::string& string) { + size_t length = string.length(); + + // allow for hexadecimal values + if (length == 2 && + string[length - 2] == '0' && + string[length - 1] == 'x') + return true; + + return (isdigit(string[length - 1])); +} + +/** + * @brief Checks if a given string represents a valid floating-point number. + * + * This function validates whether the input string conforms to the format of a + * floating-point number. It considers the following rules: + * - The string can contain digits, at most one decimal point, and an optional '+' or '-' sign at the beginning. + * - If the string ends with a '.', it is valid only if there is no other '.' in the string. + * - If the string ends with 'e' or 'E', it is valid only if it is preceded by a digit or a '.'. + * - If the string ends with '+' or '-', it is valid only if it is preceded by 'e' or 'E'. + * - The string must not contain multiple occurrences of 'e' or 'E'. + * - The string must not contain invalid characters other than digits, '.', 'e', 'E', '+', or '-'. + * + * @param string The input string to validate. + * @return true If the string represents a valid floating-point number. + * @return false Otherwise. + */ +bool DataFileToken::check_float(const std::string& string) { + size_t length = string.length(); + + // valid if contains only digits, one point at most, and potential '+-' sign in front + if (string[length - 1] == '.') { + // check if a point is already present in the string + if (length > 1 || true) { + for (size_t index = 0; index < length - 1; index++) { + // if yes, its not a valid float string representation + if (string[index] == '.') + return false; + } + } + + return true; + } + + if (string[length - 1] == 'e' || string[length - 1] == 'E') { + if (length == 1) + return false; + else if (!isdigit(string[length - 2]) && string[length - 2] != '.') + return false; + + // check if an exponent is already present in the string + if (string.length() > 1 || true) { + for (size_t index = 0; index < length - 1; index++) { + if (string[index] == 'e' || string[index] == 'E') + return false; + } + } + + return true; + } + + // the exponent can have a + or - sign in front of it + if (string[length - 1] == '+' || string[length - 1] == '-') { + // the previous character should be the exponent 'e' + if (length <= 1) + return false; + + return string[length - 2] == 'e' || string[length-2] == 'E'; + } + + return (isdigit(string[length - 1])); +} + +/** + * @brief Checks if the given string represents a valid macro. + * + * A string is considered a valid macro if it meets one of the following conditions: + * - The string has a length of 1 and its only character is '#'. + * - The string has a length greater than 1, starts with '#', and ends with an alphabetic character. + * + * @param string The input string to check. + * @return true if the string is a valid macro, false otherwise. + */ +bool DataFileToken::check_macro(const std::string& string) { + // valid if the first character is '#', and the rest is alpha + return (string.length() == 1 && string[0] == '#') || + (string.length() > 1 && isletter(string[string.length() - 1])); +} + +/** + * @brief Checks if the given string matches the specified token type. + * + * This function validates whether the provided string corresponds to the + * expected format or pattern for a given token type. The token types + * include various categories such as comments, brackets, operators, + * spaces, names, literals, and macros. + * + * @param token_type The type of token to check against. This is an + * enumeration value of DataFileToken::Type. + * @param string The string to be validated against the specified token type. + * @return true If the string matches the specified token type. + * @return false If the string does not match the specified token type. + */ +bool DataFileToken::check(DataFileToken::Type token_type, const std::string& string) { + switch (token_type) { + case DataFileToken::Type::CommentBlockHash: + return check_comment_block_hash(string); + case DataFileToken::Type::CommentBlockCStyle: + return check_comment_block_c_style(string); + case DataFileToken::Type::CommentLineCStyle: + return check_comment_line_c_style(string); + case DataFileToken::Type::OpenCurlyBracket: + return check_open_curly_bracket(string); + case DataFileToken::Type::CloseCurlyBracket: + return check_close_curly_bracket(string); + case DataFileToken::Type::OpenParenthesis: + return check_open_parenthesis(string); + case DataFileToken::Type::CloseParenthesis: + return check_close_parenthesis(string); + case DataFileToken::Type::Operator: // note that we don't test for unary operators, regular operator will be promoted to unary if needed + return check_operator(string); + case DataFileToken::Type::Space: + return check_space(string); + case DataFileToken::Type::Name: + return check_name(string); + case DataFileToken::Type::LiteralString: + return check_literal_string(string); + case DataFileToken::Type::Int: + return check_int(string); + case DataFileToken::Type::Float: + return check_float(string); + case DataFileToken::Type::Macro: + return check_macro(string); + default: + return false; + } +} + +/** + * @brief Chooses the most appropriate token type from a set of possible types based on predefined rules. + * + * @param types A set of possible token types to choose from. + * @param token_string The string representation of the token being evaluated. + * @return The chosen token type based on the following rules: + * - If the 'Operator' type is present in the set, it is chosen. + * - If both 'Int' and 'Float' types are present, 'Int' is chosen. + * - If the set contains exactly 'Name' and 'Float', 'Float' is chosen. + * - If none of the above conditions are met, the function logs an error message + * and terminates the process. + * + * @note If the function encounters an ambiguous situation where it cannot choose a type, + * it outputs an error message listing the potential types and exits the program. + * A dummy return value is provided to avoid compilation errors, but it is never + * reached during normal execution. + */ +DataFileToken::Type DataFileToken::choose(const std::set& types, const std::string & token_string) { + // if token type 'operator' is possible, we choose it + if (types.find(DataFileToken::Type::Operator) != types.end()) { + return DataFileToken::Type::Operator; + // if types Int and Floats are possible, choose Int + } else if (types.find(DataFileToken::Type::Int) != types.end() && + types.find(DataFileToken::Type::Float) != types.end()) { + return DataFileToken::Type::Int; + } else if (types.size() == 2 && + types.find(DataFileToken::Type::Name) != types.end() && + types.find(DataFileToken::Type::Float) != types.end()) { + return DataFileToken::Type::Float; + } else { + Cerr << "Cannot choose with two potential types for token '" << token_string << "': "; + for (DataFileToken::Type type: types) + Cout << type << ' '; + Cout << finl; + + Process::exit(); + return DataFileToken::Type::Space; // return dummy type to avoid compilation error + } +} + +/** + * @brief Converts the DataFileToken object to its string representation. + * + * This method provides a string representation of the token based on its type. + * It handles various token types such as integers, floats, brackets, comments, + * macros, expressions, and literal strings. For tokens with assigned values, + * it converts the stored value to a string. For tokens read from a file, it + * returns the original string representation. + * + * @return A string representation of the token. + * + * Token types and their string representations: + * - Int: Returns the integer value as a string or the original string if available. + * - Float: Returns the float value as a string with precision or the original string if available. + * - OpenCurlyBracket: Returns "{". + * - CloseCurlyBracket: Returns "}". + * - OpenParenthesis: Returns "(". + * - CloseParenthesis: Returns ")". + * - CommentBlockHash, CommentBlockCStyle, CommentLineCStyle: Returns the comment in "# ... #" format. + * - Macro: Returns the macro in "#..." format. + * - Expression: Converts the expression to a string using its `to_string` method. + * - LiteralString: Returns the string enclosed in double quotes. + * - Default: Returns the stored value as a string. + */ +std::string DataFileToken::to_string() const { + switch (type) { + case (DataFileToken::Type::Int): + if (string == "") // token with assigned value + return std::to_string(std::any_cast(value)); + else // token read from the file that still store the original string + return string; + case (DataFileToken::Type::Float): + if (string == "") // token with assigned value + // call the method to_string for double of DataFileToken to set the precision + return DataFileToken::to_string(std::any_cast(value)); + else // token read from the file that still store the original string + return string; + case (DataFileToken::Type::OpenCurlyBracket): + return "{"; + case (DataFileToken::Type::CloseCurlyBracket): + return "}"; + case (DataFileToken::Type::OpenParenthesis): + return "("; + case (DataFileToken::Type::CloseParenthesis): + return ")"; + case (DataFileToken::Type::CommentBlockHash): + case (DataFileToken::Type::CommentBlockCStyle): + case (DataFileToken::Type::CommentLineCStyle): + // write every comment with '#' notation + return "# " + std::any_cast(value) + " #"; + case (DataFileToken::Type::Macro): + return "#" + std::any_cast(value); + case (DataFileToken::Type::Expression): { + DataFileExpression expression = std::any_cast(value); + return expression.to_string(); } + case (DataFileToken::Type::LiteralString): + return '"' + std::any_cast(value) + '"'; + default: + return std::any_cast(value); + } +} + +/** + * @brief Prints the details of the DataFileToken object to the output stream. + * + * This function outputs the type, value, start line, and start column of the + * DataFileToken object. The output format depends on the type of the token: + * - For `DataFileToken::Type::Int`, the value is cast to an integer. + * - For `DataFileToken::Type::Float`, the value is cast to a double. + * - For other types, the value is cast to a string. + * + * The output format is as follows: + * `()::` + * + * @note The function assumes that the `value` member contains a valid value + * that can be cast to the appropriate type using `std::any_cast`. + */ +void DataFileToken::print() const { + switch (type) { + case (DataFileToken::Type::Int): + Cout << type << "(" << std::any_cast(value) << "):" + << start_line << ":" + << start_column; + break; + case (DataFileToken::Type::Float): + Cout << type << "(" << std::any_cast(value) << "):" + << start_line << ":" + << start_column; + break; + default: + Cout << type << "(" << std::any_cast(value) << "):" + << start_line << ":" + << start_column; + break; + } +} + +void DataFileToken::print_as_error(const std::string& message) const { + print_as_message("Error", 31, message); +} + +void DataFileToken::print_as_note(const std::string& message) const { + print_as_message("Note", 32, message); +} + +void DataFileToken::print_as_warning(const std::string& message) const { + print_as_message("Warning", 33, message); +} + +/** + * @brief Prints a formatted message with source code context and highlights. + * + * This function generates a detailed error or informational message that includes + * the location in the source file, the relevant lines of code, and highlights + * the specific portion of the code related to the message. The output is formatted + * with colors and indentation for readability. + * + * @param label A label describing the type of message (e.g., "Error", "Warning"). + * @param color The ANSI color code to use for highlighting the message and code. + * @param message The detailed message to display. + * + * The function performs the following steps: + * - Writes the file name and location (line and column range) where the issue occurred. + * - Formats and appends the provided message. + * - Reads the source file to extract the relevant lines of code. + * - Highlights the specific portion of the code using the provided color. + * - Shortens the output if the number of lines to display exceeds a predefined limit. + * + * Notes: + * - Tabs in the source code are replaced with spaces for consistent formatting. + * - If the highlighted range spans multiple lines, the underline adapts accordingly. + * - The function ensures that the output is concise and skips excessive lines when necessary. + * + * Example usage: + * ``` + * DataFileToken token; + * token.print_as_message("Error", 31, "Syntax error detected."); + * ``` + */ +void DataFileToken::print_as_message(const std::string& label, int color, const std::string& message) const { + std::ostringstream oss; + + // write localization + oss << "In " + << TextFormatting::Err::start(0, 1) + << file_name << ":" + << start_line << ":" + << start_column << TextFormatting::Err::end() + << " to " << TextFormatting::Err::start(0, 1) + << end_line << ":" + << end_column << TextFormatting::Err::end() << ": "; + + // write the message + oss << TextFormatting::Err::format(label + ": ", color, 1) << message << std::endl; + + // open file to get the source + std::ifstream file(file_name); + + // get the correct line (the line before the first line + size_t current_line_number = 0; + std::string line_string; + while (current_line_number < start_line && std::getline(file, line_string)) { + current_line_number++; + } + + int margin = 8; + size_t tab_size = 4; + int gap = 2; + size_t max_lines_printed = 6; + bool first_line_skip = true; + + for (size_t line = start_line; line <= end_line; line++) { + // if there a more than max_lines_printed lines to print, we put '...' to shorten the error message + size_t number_of_lines = end_line - start_line; + if (number_of_lines > max_lines_printed) { + size_t number_of_lines_start = max_lines_printed / 2; + size_t number_of_lines_end = max_lines_printed - number_of_lines_start; + size_t relative_line = line - start_line; + + if (relative_line >= number_of_lines_start && + relative_line < number_of_lines - number_of_lines_end) { + + if (first_line_skip) { + oss << std::endl << std::setw(margin + gap) << " " + << TextFormatting::Err::format("... (skip) ...", 33, 0) + << std::endl << std::endl; + first_line_skip = false; + } + + continue; + } + } + + // replace tabs with spaces + std::string line_string_tabify = TextFormatting::tabify(line_string, tab_size); + + // compute underline position and size + int first_column = 1; + int last_column = static_cast(line_string_tabify.size()); + + if (line == start_line) { + first_column = static_cast(TextFormatting::tabify_get_index(start_column, line_string, tab_size)); + } + if (line == end_line) { + last_column = static_cast(TextFormatting::tabify_get_index(end_column - 1, line_string, tab_size)); + } + + // print the line + oss << TextFormatting::Err::start(32, 0) + << std::setw(margin) << line << ":" + << TextFormatting::Err::end() + << std::setw(gap) << " " << line_string_tabify.substr(0, first_column - 1); + if (line_string_tabify.size() > 0) { + oss << TextFormatting::Err::format( + line_string_tabify.substr( + first_column - 1, + last_column - first_column + 1), + color, 1) + << line_string_tabify.substr(last_column) << std::endl; + } + + // write the underline + oss << std::setw(margin + first_column + gap) << " "; + oss << TextFormatting::Err::start(color, 1); + for(int column = first_column; column <= last_column; column++) { + // draw the '^' character on the first and last character + if (line == start_line && column == first_column ) + oss << "^"; + else + oss << "~"; + } + oss << TextFormatting::Err::end() << std::endl; + + // read the next line + std::getline(file, line_string); + } + + // close the file + file.close(); + + Cerr << oss.str() << finl;; +} + +bool DataFileToken::is_space() const { + return type == DataFileToken::Type::Space; +} + +bool DataFileToken::is_operator() const { + return type == DataFileToken::Type::Operator || + type == DataFileToken::Type::OperatorUnary; +} + +/** + * @brief Determines if the current token is an operand. + * + * This method checks the type of the token and returns true if the token + * represents an operand. Operands are defined as tokens of type Int, Float, + * or Name. For all other token types, this method returns false. + * + * @return true if the token is an operand (Int, Float, or Name), false otherwise. + */ +bool DataFileToken::is_operand() const { + switch (type) { + case DataFileToken::Type::Int: + case DataFileToken::Type::Float: + case DataFileToken::Type::Name: + return true; + default: + return false; + } +} + +bool DataFileToken::is_parenthesis() const { + switch (type) { + case DataFileToken::Type::OpenParenthesis: + case DataFileToken::Type::CloseParenthesis: + return true; + default: + return false; + } +} + +bool DataFileToken::is_curly_bracket() const { + switch (type) { + case DataFileToken::Type::OpenCurlyBracket: + case DataFileToken::Type::CloseCurlyBracket: + return true; + default: + return false; + } +} + +bool DataFileToken::is_comment() const { + switch (type) { + case DataFileToken::Type::CommentBlockHash: + case DataFileToken::Type::CommentBlockCStyle: + case DataFileToken::Type::CommentLineCStyle: + return true; + default: + return false; + } +} + +/** + * @brief Determines if the current token represents a mathematical entity. + * + * This method checks the type of the token and returns true if the token + * is of type Int, Float, or Expression, indicating that it represents + * a mathematical value or expression. Otherwise, it returns false. + * + * @return true if the token is a mathematical entity (Int, Float, or Expression), + * false otherwise. + */ +bool DataFileToken::is_math() const { + switch (type) { + case DataFileToken::Type::Int: + case DataFileToken::Type::Float: + case DataFileToken::Type::Expression: + return true; + default: + return false; + } +} + +bool DataFileToken::is_plus_or_minus() const { + return (is_operator() && + (string == "+" || + string == "-")); +} + +bool DataFileToken::is_name() const { + return type == DataFileToken::Type::Name; +} + +/** + * @brief Determines if the current token represents a mathematical function. + * + * This method checks if the token is a valid name and matches one of the + * predefined mathematical function names. The comparison is case-insensitive. + * + * @return true if the token represents a mathematical function, false otherwise. + * + * The recognized mathematical functions are: + * - sin + * - cos + * - tan + * - asin + * - acos + * - atan + * - sinh + * - cosh + * - tanh + * - exp + * - ln + * - log10 + * - sqrt + * - abs + * - sign + * - rand + * - int + * - float + */ +bool DataFileToken::is_function() const { + if (!is_name()) + return false; + + std::string lower = TextFormatting::lower(string); + if (lower == "sin" || + lower == "cos" || + lower == "tan" || + lower == "asin" || + lower == "acos" || + lower == "atan" || + lower == "sinh" || + lower == "cosh" || + lower == "tanh" || + lower == "exp" || + lower == "ln" || + lower == "log10" || + lower == "sqrt" || + lower == "abs" || + lower == "sign" || + lower == "rand" || + lower == "int" || + lower == "float") + return true; + else + return false; +} + +bool DataFileToken::is_expression() const { + return type == DataFileToken::Type::Expression; +} + +/** + * @brief Determines the precedence level of the current operator token. + * + * This method evaluates the precedence of the token based on its type and string value. + * It is used to establish the order of operations for operators in expressions. + * + * @return An integer representing the precedence level of the token. + * Higher values indicate higher precedence. + * + * @note The precedence levels are defined as follows: + * - Relational operators (">", "<", ">=", "<="): 0 + * - Logical operators ("min", "max"): 1 + * - Addition and subtraction ("+", "-"): 2 + * - Multiplication and division ("*", "/"): 3 + * - Exponentiation ("^"): 4 + * - Composition ("c"): 6 + * - Unary operators ("+", "-"): 4 + * + * @throws If the token is not a valid operator or unary operator, an error message + * is printed, and the program exits. + * @throws If the token is not of type Operator or OperatorUnary, an error message + * is printed, and the program exits. + */ +int DataFileToken::precedence() const { + if (type == DataFileToken::Type::Operator) { + if (string == ">") + return 0; + else if (string == "<") + return 0; + else if (string == ">=") + return 0; + else if (string == "<=") + return 0; + else if (string == "^") // exponent + return 4; + else if (string == "c") // composition + return 6; + else if (string == "min") + return 1; + else if (string == "max") + return 1; + else if (string == "*") + return 3; + else if (string == "/") + return 3; + else if (string == "+") + return 2; + else if (string == "-") + return 2; + else { + print_as_error("Invalid operator."); + Process::exit(DONT_PRINT_TOKEN); + return 0; + } + } else if (type == DataFileToken::Type::OperatorUnary) { + if (string == "+") + return 4; + else if (string == "-") + return 4; + else { + print_as_error("Invalid unary operator."); + Process::exit(DONT_PRINT_TOKEN); + return 0; + } + } else { + print_as_error("This should have been an operator."); + Process::exit(DONT_PRINT_TOKEN); + return 0; + } +} + +/** + * @brief Determines the associativity of the operator represented by the DataFileToken. + * + * @details This method checks the type of the token and determines whether the operator + * is left-associative ('l') or right-associative ('r'). It assumes that the token + * is of type `Operator` or `OperatorUnary`. If the token is not an operator, an + * error message is printed, and the program exits. + * + * @return A character indicating the associativity: + * - 'r' for right-associative operators or unary operators. + * - 'l' for left-associative operators. + * + * @note The method asserts that the token type is `Operator` before proceeding. + * If the token type is invalid, the program will terminate. + */ +char DataFileToken::associativity() const { + assert(type == DataFileToken::Type::Operator); + + if (type == DataFileToken::Type::Operator) { + if (string == "^" || string == "c") + return 'r'; // right + else + return 'l'; // left + } else if (type == DataFileToken::Type::OperatorUnary) { + return 'r'; // right + } else { + print_as_error("This should have been an operator."); + Process::exit(DONT_PRINT_TOKEN); + return 'r'; // return something to avoid compilation error + } +} + + diff --git a/src/Kernel/Utilitaires/DataFileToken.h b/src/Kernel/Utilitaires/DataFileToken.h new file mode 100644 index 0000000000..436549fc35 --- /dev/null +++ b/src/Kernel/Utilitaires/DataFileToken.h @@ -0,0 +1,165 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ +#ifndef DataFileToken_included +#define DataFileToken_included + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +class DataFileToken { + + ///////////////// + // Token types // + ///////////////// + + public: + + enum Type { + CommentBlockHash, + CommentBlockCStyle, + CommentLineCStyle, + OpenCurlyBracket, + CloseCurlyBracket, + OpenParenthesis, + CloseParenthesis, + Operator, + OperatorUnary, + Space, + Name, + LiteralString, + Int, + Float, + Macro, + Expression + }; + + // Method that return a set of all token types + static std::set get_types_full_set(); + + // Use operator<< to print token type + friend std::ostream& operator<<(std::ostream& os, const Type& type); + friend Sortie& operator<<(Sortie& os, const Type& type); + + // Methods that check if a given string string is a valid representation + // a of each type. + // Those methods assume for a string of N+1 character that the N first characters + // of the string give a valid representation of the type, and only test the last + // character. + // For example, if '10.38' is a valid representation of a Float, the '10.384' + // will return true. + static bool check_comment_block_hash(const std::string& token_string); + static bool check_comment_block_c_style(const std::string& token_string); + static bool check_comment_line_c_style(const std::string& token_string); + static bool check_open_curly_bracket(const std::string& token_string); + static bool check_close_curly_bracket(const std::string& token_string); + static bool check_open_parenthesis(const std::string& token_string); + static bool check_close_parenthesis(const std::string& token_string); + static bool check_operator(const std::string& token_string); + static bool check_space(const std::string& token_string); + static bool check_name(const std::string& token_string); + static bool check_literal_string(const std::string& token_string); + static bool check_int(const std::string& token_string); + static bool check_float(const std::string& token_string); + static bool check_macro(const std::string& token_string); + + // this last method test for any type + static bool check(Type type, const std::string& token_string); + + // choose the DataFileToken::Type to keep among a set of types + static Type choose(const std::set& types, const std::string & string); + + std::string to_string() const; + + public: + + ///////////////// + // constructor // + ///////////////// + + public: + + DataFileToken( + const std::string& file_name_, + size_t start_line_, + size_t start_column_, + size_t end_line_, + size_t end_column_, + Type type_, + std::string string_); + + ///////////// + // methods // + ///////////// + + void print() const; + + private: + + void print_as_message(const std::string& label, int color, const std::string& message) const; + + public: + + void print_as_error(const std::string& message) const; + void print_as_note(const std::string& message) const; + void print_as_warning(const std::string& message) const; + + std::string str() const; + bool is_space() const; + bool is_operator() const; + bool is_operand() const; + bool is_parenthesis() const; + bool is_curly_bracket() const; + bool is_comment() const; + bool is_math() const; + bool is_plus_or_minus() const; + bool is_name() const; + bool is_function() const; + bool is_expression() const; + + // for operator manipulations in expressions + int precedence() const; + char associativity() const; + + // convert a double to string representation + static std::string to_string(double value); + + private: + + static bool isletter(char c); + + //////////////// + // attributes // + //////////////// + + public: + + std::string file_name; + size_t start_line, start_column, end_line, end_column; + + Type type; // type of this token + std::string string; // string representation of token + std::any value; // value of this token +}; + +#endif diff --git a/src/Kernel/Utilitaires/EChaineJDD.cpp b/src/Kernel/Utilitaires/EChaineJDD.cpp deleted file mode 100644 index 9f566ebed4..0000000000 --- a/src/Kernel/Utilitaires/EChaineJDD.cpp +++ /dev/null @@ -1,56 +0,0 @@ -/**************************************************************************** -* Copyright (c) 2024, CEA -* All rights reserved. -* -* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: -* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. -* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. -* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -* -*****************************************************************************/ - -#include - -int EChaineJDD::file_cur_line_ = 1; - -EChaineJDD::EChaineJDD() : - Entree(), istrstream_(0), track_lines_(true) -{ - set_check_types(1); -} - -EChaineJDD::EChaineJDD(const char* str) : - Entree(), istrstream_(0), track_lines_(true) -{ - set_check_types(1); - init(str); -} - -EChaineJDD::~EChaineJDD() { } - -void EChaineJDD::init(const char *str) -{ - if (istrstream_) - delete istrstream_; - istrstream_ = new istringstream(str); // a copy of str is taken - set_istream(istrstream_); -} - -Entree& EChaineJDD::operator>>(True_int& ob) { return operator_template(ob); } -Entree& EChaineJDD::operator>>(double& ob) { return operator_template(ob); } - -int EChaineJDD::get(char *ob, std::streamsize bufsize) -{ - if(track_lines_) - { - int jol = jumpOfLines(); - for(int jump=0; jumpfail())) + character = '\0'; + + return (!istream_->fail()); +} + + /*! @brief Lecture d'une chaine dans ostream_ bufsize est la taille du buffer alloue pour ob (y compris * * le caractere 0 final). diff --git a/src/Kernel/Utilitaires/Entree.h b/src/Kernel/Utilitaires/Entree.h index 835504b1f1..ac7e157159 100644 --- a/src/Kernel/Utilitaires/Entree.h +++ b/src/Kernel/Utilitaires/Entree.h @@ -1,5 +1,5 @@ /**************************************************************************** -* Copyright (c) 2024, CEA +* Copyright (c) 2025, CEA * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -75,6 +75,7 @@ class Entree: public AbstractIO // final virtual Entree& operator>>(Objet_U& ob) final; + virtual int get(char& character); virtual int get(True_int *ob, std::streamsize n); virtual int get(long *ob, std::streamsize n); virtual int get(long long *ob, std::streamsize n); diff --git a/src/Kernel/Utilitaires/Entree_complete.cpp b/src/Kernel/Utilitaires/Entree_complete.cpp index 9413c075a2..7ba806f2b4 100644 --- a/src/Kernel/Utilitaires/Entree_complete.cpp +++ b/src/Kernel/Utilitaires/Entree_complete.cpp @@ -1,5 +1,5 @@ /**************************************************************************** -* Copyright (c) 2024, CEA +* Copyright (c) 2025, CEA * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -49,6 +49,13 @@ Entree& Entree_complete::get_input() return *entree2_; } + +// read one char from the stream +int Entree_complete::get(char& character) +{ + return get_template(&character, 1); +} + int Entree_complete::get(char* ob, std::streamsize bufsize) { Entree& is = get_input(); diff --git a/src/Kernel/Utilitaires/Entree_complete.h b/src/Kernel/Utilitaires/Entree_complete.h index 51df13b9a9..2a6438d921 100644 --- a/src/Kernel/Utilitaires/Entree_complete.h +++ b/src/Kernel/Utilitaires/Entree_complete.h @@ -1,5 +1,5 @@ /**************************************************************************** -* Copyright (c) 2024, CEA +* Copyright (c) 2025, CEA * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -39,6 +39,7 @@ class Entree_complete: public Entree Entree& operator>>(float& ob) override; Entree& operator>>(double& ob) override; + int get(char& character) override; int get(True_int *ob, std::streamsize n) override; int get(long *ob, std::streamsize n) override; int get(long long*ob, std::streamsize n) override; diff --git a/src/Kernel/Utilitaires/Execute_parallel.cpp b/src/Kernel/Utilitaires/Execute_parallel.cpp index 05f17ec762..905ee83bad 100644 --- a/src/Kernel/Utilitaires/Execute_parallel.cpp +++ b/src/Kernel/Utilitaires/Execute_parallel.cpp @@ -13,7 +13,7 @@ * *****************************************************************************/ -#include +#include #include #include #include diff --git a/src/Kernel/Utilitaires/LecFicDiffuse_JDD.cpp b/src/Kernel/Utilitaires/LecFicDiffuse_JDD.cpp deleted file mode 100644 index 5de8f84c3c..0000000000 --- a/src/Kernel/Utilitaires/LecFicDiffuse_JDD.cpp +++ /dev/null @@ -1,230 +0,0 @@ -/**************************************************************************** -* Copyright (c) 2025, CEA -* All rights reserved. -* -* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: -* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. -* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. -* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -* -*****************************************************************************/ - -#include -#include -#include -#include -#include - -Implemente_instanciable_sans_constructeur(LecFicDiffuse_JDD,"LecFicDiffuse_JDD",Lec_Diffuse_base); - -Entree& LecFicDiffuse_JDD::readOn(Entree& s) -{ - throw; -} - -Sortie& LecFicDiffuse_JDD::printOn(Sortie& s) const -{ - throw; -} - -LecFicDiffuse_JDD::LecFicDiffuse_JDD() : - apply_verif(true) -{ - // file_.set_error_action(ERROR_CONTINUE); -} - -/*! @brief ouverture du fichier name. - * - * Cette methode doit etre appelee sur tous les processeurs. En cas - * d'echec : exit() - * - */ -LecFicDiffuse_JDD::LecFicDiffuse_JDD(const char* name, - IOS_OPEN_MODE mode, - bool apply_verification) : - apply_verif(apply_verification) -{ - - //file_.set_error_action(ERROR_CONTINUE); - int ok = ouvrir(name, mode); - if (!ok && Process::je_suis_maitre()) - { - Cerr << "File " << name << " does not exist (LecFicDiffuse_JDD)" << finl; - Process::exit(); - } -} - - -/*! @brief Ouverture du fichier. - * - * Cette methode doit etre appelee par tous les processeurs du groupe. - * Valeur de retour: 1 si ok, 0 sinon - * - */ -int LecFicDiffuse_JDD::ouvrir(const char* name, - IOS_OPEN_MODE mode) -{ - int ok = 0; - if(Process::je_suis_maitre()) - { - Cout <<"Reading data file "<>motlu; - int nb_accolade=0; - int nb_accolade_sa=-1; - int line=1; - bool petsc_format = false; - while (!fin_lu) - { - if (file_.eof()) - { - break; - } - if (motlu=="{") - nb_accolade++; - if (motlu=="}") - nb_accolade--; - if (fin==motlu) - { - fin_lu = true; - nb_accolade_sa=nb_accolade; - } - if (!fin_lu) - { - if (motlu=="#") - { - // Cerr<<" on passe les commentaires"<>motlu; - while (motlu!="#") - { - if (file_.eof()) - { - Cerr << comments; - Nom msg = "\nProblem while reading some # \n # not closed.\n"; - msg+= "============================================\nExiting TRUST."; - Process::exit(msg); - } - jol = file_.jumpOfLines(); - for(int jump=0; jump> motlu; - } - comments += "and ends at line " + std::to_string(line)+"\n"; - jol = file_.jumpOfLines(); - for(int jump=0; jump>motlu; - if (file_.eof()) - { - Cerr << comments; - Nom msg = "\nProblem while reading some /* \n not closed.\n"; - msg+= "============================================\nExiting TRUST."; - Process::exit(msg); - } - if (motlu=="/*") ouvrante++; - if (motlu=="*/") ouvrante--; - } - comments += "and ends at line " + std::to_string(line)+"\n"; - int jol = file_.jumpOfLines(); - for(int jump=0; jump>motlu; - - } - } - if (fin_lu) - nb_accolade=nb_accolade_sa; - if (nb_accolade!=0) - { - if (nb_accolade<0) - Cerr<<"Error perhaps extra \"}\" or missing \"#\" in data file"< -#include - -class Objet_U; - -/*! @brief Cette classe implemente les operateurs et les methodes virtuelles de la classe EFichier de la facon suivante : Le fichier a lire est physiquement localise sur le disque de la machine hebergeant la tache maitre de l'application Trio-U (le processus de rang 0 dans le groupe "tous") - * - * et chaque item lu dans ce fichier est diffuse a tous les autres processus du groupe tous. - * Il en est de meme pour les methodes d'inspection de l'etat d'un fichier. - * - */ - -class LecFicDiffuse_JDD : public Lec_Diffuse_base -{ - Declare_instanciable_sans_constructeur(LecFicDiffuse_JDD); - // le maitre lit le fichier et propage l'information -public: - LecFicDiffuse_JDD(); - LecFicDiffuse_JDD(const char* name, IOS_OPEN_MODE mode=ios::in, bool apply_verification=true); - int ouvrir(const char* name, IOS_OPEN_MODE mode=ios::in ) override; - Entree& get_entree_master() override; - void track_lines(bool b) { chaine_.set_track_lines(b); } - -protected: - EChaineJDD chaine_; - ///! whether obsolete keywords should be checked or not. True by default. - bool apply_verif; -}; -#endif diff --git a/src/Kernel/Utilitaires/Lec_Diffuse_base.cpp b/src/Kernel/Utilitaires/Lec_Diffuse_base.cpp index d9c30dbb01..2a612a334d 100644 --- a/src/Kernel/Utilitaires/Lec_Diffuse_base.cpp +++ b/src/Kernel/Utilitaires/Lec_Diffuse_base.cpp @@ -1,5 +1,5 @@ /**************************************************************************** -* Copyright (c) 2024, CEA +* Copyright (c) 2025, CEA * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -45,6 +45,13 @@ Lec_Diffuse_base& Lec_Diffuse_base::operator=(const Lec_Diffuse_base& ) return *this; } + +// read one char from the stream +int Lec_Diffuse_base::get(char& character) +{ + return get_template(&character, 1); +} + Entree& Lec_Diffuse_base::operator>>(True_int& ob) { return operator_template(ob); } int Lec_Diffuse_base::get(True_int* ob, std::streamsize n) { return get_template(ob, n); } diff --git a/src/Kernel/Utilitaires/Lec_Diffuse_base.h b/src/Kernel/Utilitaires/Lec_Diffuse_base.h index c376825db5..648bc49eca 100644 --- a/src/Kernel/Utilitaires/Lec_Diffuse_base.h +++ b/src/Kernel/Utilitaires/Lec_Diffuse_base.h @@ -1,5 +1,5 @@ /**************************************************************************** -* Copyright (c) 2024, CEA +* Copyright (c) 2025, CEA * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -46,6 +46,7 @@ class Lec_Diffuse_base: public EFichier Entree& operator>>(float& ob) override; Entree& operator>>(double& ob) override; + int get(char& character) override; int get(True_int *ob, std::streamsize n) override; int get(long *ob, std::streamsize n) override; int get(long long *ob, std::streamsize n) override; diff --git a/src/Kernel/Utilitaires/Lire_Fichier.cpp b/src/Kernel/Utilitaires/Lire_Fichier.cpp index 723339a2a2..6ae0eed887 100644 --- a/src/Kernel/Utilitaires/Lire_Fichier.cpp +++ b/src/Kernel/Utilitaires/Lire_Fichier.cpp @@ -1,5 +1,5 @@ /**************************************************************************** -* Copyright (c) 2024, CEA +* Copyright (c) 2025, CEA * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: @@ -16,7 +16,7 @@ #include #include #include -#include +#include #include #include @@ -89,16 +89,34 @@ Entree& Lire_Fichier::interpreter(Entree& is) else { Cerr << "Lire_Fichier: interpreting file " << nom1 << finl; - // Not counting lines inside this file - LecFicDiffuse_JDD data_file(nom1); - data_file.track_lines(false); - data_file.set_check_types(1); + + // store the previous static attributes of the DataFileStream class + // (loading a new datafile will mess-up those attributes) + DataFileStream::Tokens old_tokens = DataFileStream::tokens; + // store the index and not the iterator has copy will occure and the iterator + // will become invalid + size_t old_index = std::distance(DataFileStream::tokens.begin(), DataFileStream::current_token_iterator); + size_t old_skip = DataFileStream::tokens_to_skip; + + // Load the DataFile + DataFile data_file(nom1); + //data_file.track_lines(false); + data_file.set_check_types(1); + // On cree un nouvel interprete. A la fin de la lecture // les objets seront detruits. Interprete_bloc interp; interp.interpreter_bloc(data_file, Interprete_bloc::BLOC_EOF /* fin du bloc a la fin du fichier */, 0 /* verifie_sans_interpreter=0 */); + + // reset the old DataFileStream static attributes + DataFileStream::tokens = old_tokens; + auto it = DataFileStream::tokens.begin(); + std::advance(it, old_index); + DataFileStream::current_token_iterator = it; + DataFileStream::tokens_to_skip = old_skip; + Cerr << "Lire_Fichier: end of file " << nom1 << finl; } Cerr << "Lire_Fichier: end of file " << nom1 << finl; diff --git a/src/Kernel/Utilitaires/Process.cpp b/src/Kernel/Utilitaires/Process.cpp index 032cf39087..95f28d1c0f 100644 --- a/src/Kernel/Utilitaires/Process.cpp +++ b/src/Kernel/Utilitaires/Process.cpp @@ -29,7 +29,7 @@ #include // sleep() pour certaines machines #include #include -#include +#include #include #include @@ -58,6 +58,7 @@ static int cerr_to_journal_ = 0; extern Stat_Counter_Id mpi_allreduce_counter_; int Process::exception_sur_exit=0; int Process::multiple_files=5120; // Valeur modifiable avec la variable d'environnement TRUST_MultipleFiles + bool Process::force_single_file(const int ranks, const Nom& filename) { char* theValue = getenv("TRUST_MultipleFiles"); @@ -286,11 +287,21 @@ void Process::Kokkos_exit(const char* str) */ void Process::exit(int i) { + // display the last readed token from the input data file + // don't print the token if int is 1 + if (i != DONT_PRINT_TOKEN && + DataFileStream::tokens.size() > 0 && + DataFileStream::current_token_iterator != DataFileStream::tokens.end()) { + + DataFileStream::current_token_iterator->print_as_error("Error triggered while reading this token."); + } + + // print the TRUST error message Nom message="=========================================\nTRUST has caused an error and will stop.\nUnexpected error during TRUST calculation."; - std::string jddLine = "\nError triggered at line " + std::to_string(EChaineJDD::file_cur_line_) + " in " + Objet_U::nom_du_cas().getString() + ".data"; - message+=jddLine; + exit(message,i); } + void Process::exit(const Nom& message ,int i) { if (exception_sur_exit == 2) diff --git a/src/Kernel/Utilitaires/Process.h b/src/Kernel/Utilitaires/Process.h index 758c979947..3c667e4676 100644 --- a/src/Kernel/Utilitaires/Process.h +++ b/src/Kernel/Utilitaires/Process.h @@ -26,6 +26,10 @@ #include #endif + +// flag to ask Process::exit to not print the last token +#define DONT_PRINT_TOKEN 7 + class Objet_U; class Nom; class Sortie; diff --git a/src/Kernel/Utilitaires/TextFormatting.cpp b/src/Kernel/Utilitaires/TextFormatting.cpp new file mode 100644 index 0000000000..0bdec3fc48 --- /dev/null +++ b/src/Kernel/Utilitaires/TextFormatting.cpp @@ -0,0 +1,179 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ +#include + +/** + * @namespace TextFormatting + * @brief Provides utilities for text formatting, including color and style + * manipulation for terminal output, tab replacement, and string + * transformations. + * Contains functions to format text using ANSI escapement sequences. + * Also contain methods to emulate tab formatting in a terminal. + * + * The main purpose of the formatting method is to check the stream redirection before + * applying the formatting ANSI sequences: if the stream does not go to a terminal, + * then no formatting occurs. + * + * For example + * + * std::cout << "This is unformatted" + * << TextFormat::Out::format(" but this is bold and red", 31, 1) + * << "will this is unformatted." << std::endl; + * + * will print the message "Test message" in bold-red only if std::cout go to the terminal. + * It is also possible to avoid reseting the formatting using the 'start' and + * 'end' (reset) functions. + * + * The functions are provided for Out (stdout) and Err (stderr) streams. + */ +namespace TextFormatting { + + std::string start(FILE* stream, int color, int mode) { + std::stringstream oss; + if (isatty(fileno(stream))) { + if (mode == 0) + oss << "\033[" << color << "m"; + else + oss << "\033[" << color << ";" << mode << "m"; + return oss.str(); + } else + return ""; + } + + std::string end(FILE* stream) { + if (isatty(fileno(stream))) { + return "\033[0m"; + } else + return ""; + } + + std::string format(FILE* stream, const std::string& message, int color, int mode) { + return start(stream, color, mode) + message + end(stream); + } + + namespace Out { + std::string start(int color, int mode) { + return TextFormatting::start(stdout, color, mode); + } + + std::string end() { + return TextFormatting::end(stdout); + } + + std::string format(const std::string& message, int color, int mode) { + return TextFormatting::format(stdout, message, color, mode); + } + } + + namespace Err { + std::string start(int color, int mode) { + return TextFormatting::start(stderr, color, mode); + } + + std::string end() { + return TextFormatting::end(stderr); + } + + std::string format(const std::string& message, int color, int mode) { + return TextFormatting::format(stderr, message, color, mode); + } + } + + /** + * @brief Replaces tab characters in a string with spaces, ensuring proper alignment based on the specified tab size. + * + * @param string The input string that may contain tab characters. + * @param tab_size The number of spaces that represent a single tab stop. + * @return A new string where all tab characters are replaced with the appropriate number of spaces. + * + * @details + * This function processes the input string character by character. When a tab character ('\t') is encountered, + * it calculates the number of spaces required to align to the next tab stop and appends those spaces to the output. + * For newline characters ('\n'), it increments the column count and appends a space. All other characters are + * directly appended to the output string. + */ + std::string tabify(const std::string& string, size_t tab_size) { + std::string out; + + size_t column = 0; + for (char c: string) { + if (c == '\t') { + size_t number_of_spaces = ((column / tab_size) + 1) * tab_size - column; + for (size_t index = 0; index < number_of_spaces; index++) + out += " "; + + column += number_of_spaces; + } else if (c == '\n') { + column++; + out += " "; + } else { + out += c; + column++; + } + } + + return out; + } + + /** + * @brief Computes the new index in a string where tab characters are expanded to spaces. + * + * This function calculates the adjusted index in a string when tabs are replaced + * with spaces, based on a specified tab size. It iterates through the string, + * accounting for the expansion of tab characters and other characters until the + * original index is reached. + * + * @param original_index The original index in the string to be adjusted. + * @param string The input string containing characters, including potential tab characters. + * @param tab_size The number of spaces a tab character should expand to. + * @return The adjusted index in the string after accounting for tab expansion. + */ + size_t tabify_get_index(size_t original_index, const std::string& string, size_t tab_size) { + + size_t new_index = 0; + for (char c: string) { + if (original_index == 0) + return new_index; + + if (c == '\t') { + size_t number_of_spaces = ((new_index / tab_size) + 1) * tab_size - new_index; + + new_index += number_of_spaces; + } else if (c == '\n') { + new_index++; + } else { + new_index++; + } + + original_index--; + } + + return new_index; + } + + // convert a string to lowercase + std::string lower(std::string string) { + std::transform( + string.begin(), + string.end(), + string.begin(), + [](unsigned char c) { + return std::tolower(c); + } + ); + + return string; + } +} diff --git a/src/Kernel/Utilitaires/TextFormatting.h b/src/Kernel/Utilitaires/TextFormatting.h new file mode 100644 index 0000000000..948d768a6b --- /dev/null +++ b/src/Kernel/Utilitaires/TextFormatting.h @@ -0,0 +1,80 @@ +/**************************************************************************** +* Copyright (c) 2025, CEA +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: +* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*****************************************************************************/ +#ifndef TEXT_FORMATTING_H +#define TEXT_FORMATTING_H + +#include +#include +#include +#include + +/* + * Contains functions to format text using ANSI escapement sequences. + * Also contain methods to emulate tab formatting in a terminal. + * + * The main purpose of the formatting method is to check the stream redirection before + * applying the formatting ANSI sequences: if the stream does not go to a terminal, + * then no formatting occure. + * + * For example + * + * std::cout << "This is unformatted" + * << TextFormat::Out::format(" but this is bold and red", 31, 1) + * << "will this is unformatted." << std::endl; + * + * will print the message "Test message" in bold-red only if std::cout go to the terminal. + * It is also possible to avoid reseting the formatting using the 'start' and + * 'end' (reset) functions. + * + * The functions are provided for Out (stdout) and Err (stderr) streams. + */ + +namespace TextFormatting { + + std::string start(FILE* stream, int color, int mode); + std::string end(FILE* stream); + std::string format(FILE* stream, const std::string& message, int color, int mode); + + namespace Out { + std::string start(int color, int mode); + std::string end(); + std::string format(const std::string& message, int color, int mode); + } + + namespace Err { + std::string start(int color, int mode); + std::string end(); + std::string format(const std::string& message, int color, int mode); + } + + /* + * @brief Take a string as input and return a string that replace the tabs + * with spaces, 'rounding' up to the next tab each time like in a terminal. + * @return (std::string) Formatted string. + */ + std::string tabify(const std::string& string, size_t tab_size = 4); + + /* + * @brief Compute the new index of a character of a string after the tabify + * function has been applied. + * @return (size_t) New index. + */ + size_t tabify_get_index(size_t original_index, const std::string& string, size_t tab_size = 4); + + // convert a string to lowercase + std::string lower(std::string string); +} + +#endif diff --git a/src/MAIN/mon_main.cpp b/src/MAIN/mon_main.cpp index d68c606fbc..f090d50a2b 100644 --- a/src/MAIN/mon_main.cpp +++ b/src/MAIN/mon_main.cpp @@ -14,7 +14,7 @@ *****************************************************************************/ #include -#include +#include #include // To clear caches before exiting, notably Domaine_dis_cache #include #include @@ -40,12 +40,12 @@ extern void end_stat_counters(); extern Stat_Counter_Id temps_total_execution_counter_; extern Stat_Counter_Id initialisation_calcul_counter_; -mon_main::mon_main(int verbose_level, bool journal_master, Nom log_directory, bool apply_verification, bool disable_stop) +mon_main::mon_main(int verbose_level, bool journal_master, Nom log_directory, bool check_obsolete_keywords, bool disable_stop) { verbose_level_ = verbose_level; journal_master_ = journal_master; log_directory_ = log_directory; - apply_verification_ = apply_verification; + check_obsolete_keywords_ = check_obsolete_keywords; // Creation d'un journal temporaire qui ecrit dans Cerr init_journal_file(verbose_level, 0 /* filename = 0 => Cerr */, 0 /* append */); trio_began_mpi_=false; @@ -436,23 +436,12 @@ void mon_main::dowork(const Nom& nom_du_cas) SFichier es("convert_jdd"); } #endif */ - // La verfication est faite maintenant dans LecFicDiffuse_JDD - // mias je garde les lignes au cas ou - if (0) - { - Cerr << "MAIN: Checking data file for matching { and }" << finl; - { - LecFicDiffuse_JDD verifie_entree(nomentree, ios::in, apply_verification_); - interprete_principal_.interpreter_bloc(verifie_entree, - Interprete_bloc::FIN /* on attend FIN a la fin */, - 1 /* verifie_sans_interpreter */); - } - } + // syntax is checked during the loading of DataFile Cerr << "MAIN: Reading and executing data file" << finl; { - LecFicDiffuse_JDD lit_entree(nomentree, ios::in, apply_verification_); - lit_entree.set_check_types(1); - interprete_principal_.interpreter_bloc(lit_entree, + DataFile data_file(nomentree, ios::in, check_obsolete_keywords_); + data_file.set_check_types(1); + interprete_principal_.interpreter_bloc(data_file, Interprete_bloc::FIN /* on attend FIN a la fin */, 0 /* interprete pour de vrai */); } diff --git a/src/MAIN/mon_main.h b/src/MAIN/mon_main.h index a9b5a8d8e5..087ad15c28 100644 --- a/src/MAIN/mon_main.h +++ b/src/MAIN/mon_main.h @@ -51,7 +51,7 @@ class mon_main Nom log_directory_; bool trio_began_mpi_; - bool apply_verification_; + bool check_obsolete_keywords_; bool disable_stop_; OWN_PTR(Comm_Group) groupe_trio_; OWN_PTR(Comm_Group) node_group_; From 81b7750861d1ad0a7f3af2dec4369d8d53223f01 Mon Sep 17 00:00:00 2001 From: labatale Date: Thu, 17 Apr 2025 00:35:34 +0200 Subject: [PATCH 2/2] Update the reference case to be compatible with the new syntax (expressions must be suround by parenthesis now). --- .../Outils/Genere_courbe/src/filelist.py | 1 - .../src/eclt_coude_Genepi2.data | 6 +- .../src/eclt_coude_frottement2.data | 10 +- .../src/eclt_coude_frottement3.data | 12 +- .../src/eclt_coude_pression_3D.data | 2 +- .../IBM_PDF/src/template_taylor_couette.data | 2 +- .../Pb_multi_vs_WC_QC/src/jdd_multi.data | 4 +- .../Multiphase/tubes_a_choc/src/jdd.data | 6 +- .../Multiphase/vap_paroi/src/canal.data | 10 +- .../Multiphase/vap_paroi/vap_paroi.ipynb | 2 +- .../QC_temperature_bounds_MUSCL/src/Cas.data | 6 +- .../Abort_timestep/src/abort_QC.data | 6 +- .../Abort_timestep/src/abort_QC_Pimp.data | 6 +- .../Champ_front_xyz_debit/src/prepare | 2 +- .../Inward_field/src/prepare | 108 +++++++++--------- .../Multistep_Methods/src/template.data | 4 +- .../PeChaReg_VEF/src/3D_sym_inout/test.data | 2 +- .../PeChaReg_VEF/src/prepare | 2 +- .../src/Perte_Charge_Circulaire.data | 4 +- .../QC_EOS_rhoT/src/_Cas.data | 8 +- .../conduc_mil_var/src/conduc_bar_ef_ana.data | 6 +- .../convection/src/jdd.data | 12 +- .../fvca/src/bercovier_engelman.data | 6 +- .../fvca/src/navier_stokes_2d.data | 4 +- .../fvca/src/navier_stokes_3d.data | 6 +- .../fvca/src/taylor_green_3d.data | 16 +-- .../poiseuille/src/jdd.data | 4 +- .../poiseuille_vdf/src/jdd.data | 4 +- .../src/manufactured_solution.data | 24 ++-- .../porosite_1D/src/jdd.data | 4 +- .../porosite_2D/src/jdd.data | 6 +- src/Kernel/Postraitement/Postraitement.cpp | 22 ++-- src/Kernel/Postraitement/Sondes.cpp | 2 +- src/Kernel/Utilitaires/Execute_parallel.cpp | 2 +- .../Perte_Charge_Circulaire_QC_VEF.data | 4 +- .../QCRhoT_variable/QCRhoT_variable.data | 6 +- tests/GPU/ColdLegMixing/ColdLegMixing.data | 6 +- tests/GPU/GPU4/GPU4.data | 2 +- tests/GPU/OpenMP_QC/OpenMP_QC.data | 6 +- tests/Reference/2DParoiX/2DParoiX.data | 2 +- tests/Reference/2DPerioX/2DPerioX.data | 4 +- tests/Reference/3DPerio/3DPerio.data | 4 +- tests/Reference/3D_P0/3D_P0.data | 3 +- .../Canal_tanh_bruit/Canal_tanh_bruit.data | 4 +- tests/Reference/ChFrontTXYZ/ChFrontTXYZ.data | 2 +- tests/Reference/ChFrontXYZ/ChFrontXYZ.data | 2 +- .../Champ_Fonc_txyz/Champ_Fonc_txyz.data | 2 +- .../Champ_front_xyz_debit.data | 2 +- .../Champ_tabule_temps/Champ_fonc_t.data | 4 +- .../Champ_tabule_temps.data | 2 +- .../Changing_porosity_py/Poreux_stab_VDF.data | 2 +- .../Reference/Domaine_post/Domaine_post.data | 2 +- .../Fluides_miscibles/Fluides_miscibles.data | 2 +- tests/Reference/IBM_aucune/IBM_aucune.data | 2 +- .../IBM_gradient_moyen.data | 2 +- tests/Reference/IBM_hybrid/IBM_hybrid.data | 2 +- .../ICoCo_ChDonXYZ/ICoCo_ChDonXYZ.data | 2 +- .../Kernel_Parser/Kernel_Parser.data | 4 +- .../Kernel_Sous_Domaine_Fonction.data | 2 +- tests/Reference/MED_docond/MED_docond.data | 2 +- .../MED_docond_64/MED_docond_64.data | 4 +- tests/Reference/Macro/Macro.data | 89 +++++++++++++++ tests/Reference/Macro/Macro.geo | 21 ++++ tests/Reference/Macro/Macro.lml.gz | Bin 0 -> 48570 bytes .../PDI_Pb_couple/PDI_Pb_couple.data | 2 +- tests/Reference/PDI_Pb_couple/prepare.data | 2 +- .../PETSC_Canal_perio_VEF_3D.data | 2 +- .../POISEUILLE_ALIGNED.data | 4 +- .../POISEUILLE_ALIGNED_power_law.data | 4 +- .../POISEUILLE_ALIGNED_th.data | 8 +- .../P_out_var_impl/P_out_var_impl.data | 2 +- tests/Reference/Parallele/Parallele.data | 16 +-- .../Repere_Rotation_Periodique.data | 2 +- .../Reprise_xyz_ancien_format.data | 5 +- .../Sauve_xyz_ascii/Sauve_xyz_ascii.data | 2 +- .../TAYLOR_COUETTE/TAYLOR_COUETTE.data | 2 +- .../TP_THI_VDF_LAM/TP_THI_VDF_LAM.data | 2 +- tests/Reference/TP_THI_VEF/TP_THI_VEF.data | 2 +- .../ThHyd_3D_VEFPreP1B.data | 2 +- .../U_in_var_impl_vef/U_in_var_impl_vef.data | 2 +- .../cond_coup_fictif_vdf_impl.data | 8 +- .../cond_coup_fictif_vef_impl.data | 8 +- .../cond_couple_vef_impl.data | 6 +- .../reprise.data | 4 +- tests/Reference/conduc_PDF/conduc_PDF.data | 8 +- tests/Reference/muscl_new/muscl_new.data | 2 +- tests/Reference/upwind/upwind.data | 2 +- .../EF_stab_Turb_Null/EF_stab_Turb_Null.data | 4 +- .../Quasi_Comp_Coupl_Incomp.data | 2 +- .../Quasi_Comp_Coupl_Incomp/prepare.data | 2 +- tests/Turbulence/THI_VEF/THI_VEF.data | 6 +- tests/UnitTests/unit_array.cpp | 28 ----- .../Abort_timestep_jdd1.data | 6 +- .../Abort_timestep_jdd2.data | 6 +- .../Champ_front_xyz_debit_jdd3.data | 2 +- .../EF_Eclt_coude_Genepi2_jdd1.data | 6 +- .../EF_Eclt_coude_frottement_jdd2.data | 10 +- .../EF_Eclt_coude_frottement_jdd3.data | 12 +- .../EF_Eclt_coude_pression_3D_jdd1.data | 2 +- .../Incorrect_syntax/Incorrect_syntax.data | 2 + .../Incorrect_syntax/Incorrect_syntax.lml.gz | 0 .../Incorrect_syntax/circular_include.data | 2 + .../end_of_file_in_comment_1.data | 3 + .../end_of_file_in_comment_2.data | 3 + .../end_of_file_in_expression.data | 3 + .../end_of_file_in_literal_string.data | 1 + .../Incorrect_syntax/invalid_define_1.data | 2 + .../Incorrect_syntax/invalid_define_2.data | 2 + .../Incorrect_syntax/invalid_include.data | 2 + .../invalid_operand_sequence.data | 1 + .../invalid_operator_sequence_1.data | 2 + .../invalid_operator_sequence_2.data | 2 + .../invalid_parenthesis_1.data | 1 + .../invalid_parenthesis_2.data | 1 + .../invalid_parenthesis_in_expression_1.data | 1 + .../invalid_parenthesis_in_expression_2.data | 1 + .../invalid_reserved_keyword_1.data | 3 + .../invalid_reserved_keyword_2.data | 2 + .../invalid_reserved_keyword_3.data | 1 + .../Incorrect_syntax/list_tests.txt | 23 ++++ .../Incorrect_syntax/macro_in_expression.data | 2 + .../string_literal_in_expression.data | 2 + .../unclosed_curly_bracket.data | 4 + .../unopened_curly_bracket.data | 6 + tests/Verification/Incorrect_syntax/verifie | 15 +++ .../Inward_field_jdd15.data | 14 +-- .../Inward_field_jdd16.data | 14 +-- .../Inward_field_jdd17.data | 14 +-- .../Inward_field_jdd18.data | 14 +-- .../Inward_field_jdd19.data | 14 +-- .../Inward_field_jdd20.data | 14 +-- .../Inward_field_jdd5/Inward_field_jdd5.data | 8 +- .../Inward_field_jdd6/Inward_field_jdd6.data | 8 +- .../Inward_field_jdd7/Inward_field_jdd7.data | 8 +- .../Inward_field_jdd8/Inward_field_jdd8.data | 8 +- .../Multistep_Methods_jdd1.data | 2 +- .../Multistep_Methods_jdd2.data | 2 +- .../Multistep_Methods_jdd3.data | 2 +- .../Multistep_Methods_jdd4.data | 2 +- .../Multistep_Methods_jdd5.data | 2 +- .../Multistep_Methods_jdd6.data | 2 +- .../Multistep_Methods_jdd7.data | 2 +- .../Multistep_Methods_jdd8.data | 2 +- .../Multistep_Methods_jdd9.data | 2 +- .../Pb_multi_vs_WC_QC_jdd3.data | 4 +- .../PeChaReg_VEF_jdd5/PeChaReg_VEF_jdd5.data | 2 +- .../PeChaReg_VEF_jdd6/PeChaReg_VEF_jdd6.data | 2 +- .../PeChaReg_VEF_jdd7/PeChaReg_VEF_jdd7.data | 4 +- .../Perte_Charge_Circulaire_VEF_jdd1.data | 4 +- .../Perte_Charge_Circulaire_VEF_jdd2.data | 4 +- .../Perte_Charge_Circulaire_VEF_jdd3.data | 4 +- .../Perte_Charge_Circulaire_VEF_jdd4.data | 4 +- .../QC_EOS_rhoT_jdd1/QC_EOS_rhoT_jdd1.data | 8 +- .../QC_EOS_rhoT_jdd10/QC_EOS_rhoT_jdd10.data | 8 +- .../QC_EOS_rhoT_jdd11/QC_EOS_rhoT_jdd11.data | 8 +- .../QC_EOS_rhoT_jdd12/QC_EOS_rhoT_jdd12.data | 8 +- .../QC_EOS_rhoT_jdd2/QC_EOS_rhoT_jdd2.data | 8 +- .../QC_EOS_rhoT_jdd3/QC_EOS_rhoT_jdd3.data | 8 +- .../QC_EOS_rhoT_jdd4/QC_EOS_rhoT_jdd4.data | 8 +- .../QC_EOS_rhoT_jdd5/QC_EOS_rhoT_jdd5.data | 8 +- .../QC_EOS_rhoT_jdd6/QC_EOS_rhoT_jdd6.data | 8 +- .../QC_EOS_rhoT_jdd7/QC_EOS_rhoT_jdd7.data | 8 +- .../QC_EOS_rhoT_jdd8/QC_EOS_rhoT_jdd8.data | 8 +- .../QC_EOS_rhoT_jdd9/QC_EOS_rhoT_jdd9.data | 8 +- .../QC_temperature_bounds_MUSCL_jdd1.data | 6 +- .../QC_temperature_bounds_MUSCL_jdd2.data | 6 +- .../conduc_mil_var_jdd10.data | 6 +- .../conduction_couple_jdd1.data | 8 +- .../conduction_couple_jdd2.data | 8 +- .../conduction_couple_jdd4.data | 6 +- .../convection_jdd1/convection_jdd1.data | 12 +- .../convection_jdd10/convection_jdd10.data | 12 +- .../convection_jdd11/convection_jdd11.data | 12 +- .../convection_jdd12/convection_jdd12.data | 12 +- .../convection_jdd13/convection_jdd13.data | 12 +- .../convection_jdd14/convection_jdd14.data | 12 +- .../convection_jdd15/convection_jdd15.data | 12 +- .../convection_jdd16/convection_jdd16.data | 12 +- .../convection_jdd17/convection_jdd17.data | 12 +- .../convection_jdd18/convection_jdd18.data | 12 +- .../convection_jdd19/convection_jdd19.data | 12 +- .../convection_jdd2/convection_jdd2.data | 12 +- .../convection_jdd20/convection_jdd20.data | 12 +- .../convection_jdd21/convection_jdd21.data | 12 +- .../convection_jdd22/convection_jdd22.data | 12 +- .../convection_jdd23/convection_jdd23.data | 12 +- .../convection_jdd24/convection_jdd24.data | 12 +- .../convection_jdd25/convection_jdd25.data | 12 +- .../convection_jdd26/convection_jdd26.data | 12 +- .../convection_jdd27/convection_jdd27.data | 12 +- .../convection_jdd28/convection_jdd28.data | 12 +- .../convection_jdd29/convection_jdd29.data | 12 +- .../convection_jdd3/convection_jdd3.data | 12 +- .../convection_jdd30/convection_jdd30.data | 12 +- .../convection_jdd31/convection_jdd31.data | 12 +- .../convection_jdd32/convection_jdd32.data | 12 +- .../convection_jdd33/convection_jdd33.data | 12 +- .../convection_jdd34/convection_jdd34.data | 12 +- .../convection_jdd35/convection_jdd35.data | 12 +- .../convection_jdd36/convection_jdd36.data | 12 +- .../convection_jdd37/convection_jdd37.data | 12 +- .../convection_jdd38/convection_jdd38.data | 12 +- .../convection_jdd39/convection_jdd39.data | 12 +- .../convection_jdd4/convection_jdd4.data | 12 +- .../convection_jdd40/convection_jdd40.data | 12 +- .../convection_jdd41/convection_jdd41.data | 12 +- .../convection_jdd42/convection_jdd42.data | 12 +- .../convection_jdd43/convection_jdd43.data | 12 +- .../convection_jdd44/convection_jdd44.data | 12 +- .../convection_jdd45/convection_jdd45.data | 12 +- .../convection_jdd46/convection_jdd46.data | 12 +- .../convection_jdd47/convection_jdd47.data | 12 +- .../convection_jdd48/convection_jdd48.data | 12 +- .../convection_jdd5/convection_jdd5.data | 12 +- .../convection_jdd6/convection_jdd6.data | 12 +- .../convection_jdd7/convection_jdd7.data | 12 +- .../convection_jdd8/convection_jdd8.data | 12 +- .../convection_jdd9/convection_jdd9.data | 12 +- tests/Verification/fvca_jdd1/fvca_jdd1.data | 6 +- tests/Verification/fvca_jdd10/fvca_jdd10.data | 6 +- tests/Verification/fvca_jdd11/fvca_jdd11.data | 6 +- tests/Verification/fvca_jdd12/fvca_jdd12.data | 6 +- tests/Verification/fvca_jdd13/fvca_jdd13.data | 6 +- tests/Verification/fvca_jdd14/fvca_jdd14.data | 6 +- tests/Verification/fvca_jdd15/fvca_jdd15.data | 6 +- tests/Verification/fvca_jdd16/fvca_jdd16.data | 6 +- tests/Verification/fvca_jdd17/fvca_jdd17.data | 6 +- tests/Verification/fvca_jdd18/fvca_jdd18.data | 6 +- tests/Verification/fvca_jdd19/fvca_jdd19.data | 16 +-- tests/Verification/fvca_jdd2/fvca_jdd2.data | 6 +- tests/Verification/fvca_jdd20/fvca_jdd20.data | 16 +-- tests/Verification/fvca_jdd21/fvca_jdd21.data | 16 +-- tests/Verification/fvca_jdd22/fvca_jdd22.data | 16 +-- tests/Verification/fvca_jdd23/fvca_jdd23.data | 16 +-- tests/Verification/fvca_jdd24/fvca_jdd24.data | 16 +-- tests/Verification/fvca_jdd25/fvca_jdd25.data | 16 +-- tests/Verification/fvca_jdd26/fvca_jdd26.data | 16 +-- tests/Verification/fvca_jdd27/fvca_jdd27.data | 16 +-- tests/Verification/fvca_jdd28/fvca_jdd28.data | 16 +-- tests/Verification/fvca_jdd29/fvca_jdd29.data | 16 +-- tests/Verification/fvca_jdd3/fvca_jdd3.data | 6 +- tests/Verification/fvca_jdd30/fvca_jdd30.data | 16 +-- tests/Verification/fvca_jdd31/fvca_jdd31.data | 16 +-- tests/Verification/fvca_jdd32/fvca_jdd32.data | 16 +-- tests/Verification/fvca_jdd33/fvca_jdd33.data | 16 +-- tests/Verification/fvca_jdd34/fvca_jdd34.data | 16 +-- tests/Verification/fvca_jdd35/fvca_jdd35.data | 16 +-- tests/Verification/fvca_jdd36/fvca_jdd36.data | 16 +-- tests/Verification/fvca_jdd37/fvca_jdd37.data | 16 +-- tests/Verification/fvca_jdd38/fvca_jdd38.data | 16 +-- tests/Verification/fvca_jdd39/fvca_jdd39.data | 16 +-- tests/Verification/fvca_jdd4/fvca_jdd4.data | 6 +- tests/Verification/fvca_jdd40/fvca_jdd40.data | 16 +-- tests/Verification/fvca_jdd41/fvca_jdd41.data | 16 +-- tests/Verification/fvca_jdd42/fvca_jdd42.data | 16 +-- tests/Verification/fvca_jdd43/fvca_jdd43.data | 4 +- tests/Verification/fvca_jdd44/fvca_jdd44.data | 4 +- tests/Verification/fvca_jdd45/fvca_jdd45.data | 4 +- tests/Verification/fvca_jdd46/fvca_jdd46.data | 4 +- tests/Verification/fvca_jdd47/fvca_jdd47.data | 4 +- tests/Verification/fvca_jdd48/fvca_jdd48.data | 4 +- tests/Verification/fvca_jdd49/fvca_jdd49.data | 4 +- tests/Verification/fvca_jdd5/fvca_jdd5.data | 6 +- tests/Verification/fvca_jdd50/fvca_jdd50.data | 4 +- tests/Verification/fvca_jdd51/fvca_jdd51.data | 4 +- tests/Verification/fvca_jdd52/fvca_jdd52.data | 4 +- tests/Verification/fvca_jdd53/fvca_jdd53.data | 4 +- tests/Verification/fvca_jdd54/fvca_jdd54.data | 4 +- tests/Verification/fvca_jdd55/fvca_jdd55.data | 4 +- tests/Verification/fvca_jdd56/fvca_jdd56.data | 4 +- tests/Verification/fvca_jdd57/fvca_jdd57.data | 4 +- tests/Verification/fvca_jdd58/fvca_jdd58.data | 4 +- tests/Verification/fvca_jdd59/fvca_jdd59.data | 4 +- tests/Verification/fvca_jdd6/fvca_jdd6.data | 6 +- tests/Verification/fvca_jdd60/fvca_jdd60.data | 4 +- tests/Verification/fvca_jdd61/fvca_jdd61.data | 6 +- tests/Verification/fvca_jdd62/fvca_jdd62.data | 6 +- tests/Verification/fvca_jdd63/fvca_jdd63.data | 6 +- tests/Verification/fvca_jdd64/fvca_jdd64.data | 6 +- tests/Verification/fvca_jdd65/fvca_jdd65.data | 6 +- tests/Verification/fvca_jdd66/fvca_jdd66.data | 6 +- tests/Verification/fvca_jdd67/fvca_jdd67.data | 6 +- tests/Verification/fvca_jdd68/fvca_jdd68.data | 6 +- tests/Verification/fvca_jdd69/fvca_jdd69.data | 6 +- tests/Verification/fvca_jdd7/fvca_jdd7.data | 6 +- tests/Verification/fvca_jdd70/fvca_jdd70.data | 6 +- tests/Verification/fvca_jdd71/fvca_jdd71.data | 6 +- tests/Verification/fvca_jdd72/fvca_jdd72.data | 6 +- tests/Verification/fvca_jdd73/fvca_jdd73.data | 6 +- tests/Verification/fvca_jdd74/fvca_jdd74.data | 6 +- tests/Verification/fvca_jdd75/fvca_jdd75.data | 6 +- tests/Verification/fvca_jdd76/fvca_jdd76.data | 6 +- tests/Verification/fvca_jdd77/fvca_jdd77.data | 6 +- tests/Verification/fvca_jdd78/fvca_jdd78.data | 6 +- tests/Verification/fvca_jdd79/fvca_jdd79.data | 6 +- tests/Verification/fvca_jdd8/fvca_jdd8.data | 6 +- tests/Verification/fvca_jdd80/fvca_jdd80.data | 6 +- tests/Verification/fvca_jdd81/fvca_jdd81.data | 6 +- tests/Verification/fvca_jdd82/fvca_jdd82.data | 6 +- tests/Verification/fvca_jdd83/fvca_jdd83.data | 6 +- tests/Verification/fvca_jdd84/fvca_jdd84.data | 6 +- tests/Verification/fvca_jdd9/fvca_jdd9.data | 6 +- .../poiseuille_jdd1/poiseuille_jdd1.data | 4 +- .../poiseuille_jdd10/poiseuille_jdd10.data | 4 +- .../poiseuille_jdd2/poiseuille_jdd2.data | 4 +- .../poiseuille_jdd3/poiseuille_jdd3.data | 4 +- .../poiseuille_jdd4/poiseuille_jdd4.data | 4 +- .../poiseuille_jdd5/poiseuille_jdd5.data | 4 +- .../poiseuille_jdd6/poiseuille_jdd6.data | 4 +- .../poiseuille_jdd7/poiseuille_jdd7.data | 4 +- .../poiseuille_jdd8/poiseuille_jdd8.data | 4 +- .../poiseuille_jdd9/poiseuille_jdd9.data | 4 +- .../poiseuille_vdf_jdd1.data | 4 +- .../poiseuille_vdf_jdd2.data | 4 +- .../poiseuille_vdf_jdd3.data | 4 +- .../poiseuille_vdf_jdd4.data | 4 +- .../poiseuille_vdf_jdd5.data | 4 +- .../poiseuille_vdf_jdd6.data | 4 +- .../poissonSolver_PolyMAC_jdd1.data | 24 ++-- .../poissonSolver_PolyMAC_jdd10.data | 24 ++-- .../poissonSolver_PolyMAC_jdd11.data | 24 ++-- .../poissonSolver_PolyMAC_jdd12.data | 24 ++-- .../poissonSolver_PolyMAC_jdd13.data | 24 ++-- .../poissonSolver_PolyMAC_jdd14.data | 24 ++-- .../poissonSolver_PolyMAC_jdd15.data | 24 ++-- .../poissonSolver_PolyMAC_jdd16.data | 24 ++-- .../poissonSolver_PolyMAC_jdd2.data | 24 ++-- .../poissonSolver_PolyMAC_jdd3.data | 24 ++-- .../poissonSolver_PolyMAC_jdd4.data | 24 ++-- .../poissonSolver_PolyMAC_jdd5.data | 24 ++-- .../poissonSolver_PolyMAC_jdd6.data | 24 ++-- .../poissonSolver_PolyMAC_jdd7.data | 24 ++-- .../poissonSolver_PolyMAC_jdd8.data | 24 ++-- .../poissonSolver_PolyMAC_jdd9.data | 24 ++-- .../porosite_1D_jdd1/porosite_1D_jdd1.data | 4 +- .../porosite_1D_jdd2/porosite_1D_jdd2.data | 4 +- .../porosite_1D_jdd3/porosite_1D_jdd3.data | 4 +- .../porosite_1D_jdd4/porosite_1D_jdd4.data | 4 +- .../porosite_1D_jdd5/porosite_1D_jdd5.data | 4 +- .../porosite_1D_jdd6/porosite_1D_jdd6.data | 4 +- .../porosite_1D_jdd7/porosite_1D_jdd7.data | 4 +- .../porosite_1D_jdd8/porosite_1D_jdd8.data | 4 +- .../porosite_2D_jdd1/porosite_2D_jdd1.data | 6 +- .../porosite_2D_jdd10/porosite_2D_jdd10.data | 6 +- .../porosite_2D_jdd2/porosite_2D_jdd2.data | 6 +- .../porosite_2D_jdd3/porosite_2D_jdd3.data | 6 +- .../porosite_2D_jdd4/porosite_2D_jdd4.data | 6 +- .../porosite_2D_jdd5/porosite_2D_jdd5.data | 6 +- .../porosite_2D_jdd6/porosite_2D_jdd6.data | 6 +- .../porosite_2D_jdd7/porosite_2D_jdd7.data | 6 +- .../porosite_2D_jdd8/porosite_2D_jdd8.data | 6 +- .../porosite_2D_jdd9/porosite_2D_jdd9.data | 6 +- .../tubes_a_choc_jdd1/tubes_a_choc_jdd1.data | 6 +- .../tubes_a_choc_jdd10.data | 6 +- .../tubes_a_choc_jdd11.data | 6 +- .../tubes_a_choc_jdd12.data | 6 +- .../tubes_a_choc_jdd13.data | 6 +- .../tubes_a_choc_jdd14.data | 6 +- .../tubes_a_choc_jdd15.data | 6 +- .../tubes_a_choc_jdd16.data | 6 +- .../tubes_a_choc_jdd17.data | 6 +- .../tubes_a_choc_jdd18.data | 6 +- .../tubes_a_choc_jdd19.data | 6 +- .../tubes_a_choc_jdd2/tubes_a_choc_jdd2.data | 6 +- .../tubes_a_choc_jdd20.data | 6 +- .../tubes_a_choc_jdd21.data | 6 +- .../tubes_a_choc_jdd22.data | 6 +- .../tubes_a_choc_jdd23.data | 6 +- .../tubes_a_choc_jdd24.data | 6 +- .../tubes_a_choc_jdd25.data | 6 +- .../tubes_a_choc_jdd26.data | 6 +- .../tubes_a_choc_jdd27.data | 6 +- .../tubes_a_choc_jdd28.data | 6 +- .../tubes_a_choc_jdd29.data | 6 +- .../tubes_a_choc_jdd3/tubes_a_choc_jdd3.data | 6 +- .../tubes_a_choc_jdd30.data | 6 +- .../tubes_a_choc_jdd31.data | 6 +- .../tubes_a_choc_jdd32.data | 6 +- .../tubes_a_choc_jdd33.data | 6 +- .../tubes_a_choc_jdd34.data | 6 +- .../tubes_a_choc_jdd35.data | 6 +- .../tubes_a_choc_jdd36.data | 6 +- .../tubes_a_choc_jdd4/tubes_a_choc_jdd4.data | 6 +- .../tubes_a_choc_jdd5/tubes_a_choc_jdd5.data | 6 +- .../tubes_a_choc_jdd6/tubes_a_choc_jdd6.data | 6 +- .../tubes_a_choc_jdd7/tubes_a_choc_jdd7.data | 6 +- .../tubes_a_choc_jdd8/tubes_a_choc_jdd8.data | 6 +- .../tubes_a_choc_jdd9/tubes_a_choc_jdd9.data | 6 +- .../vap_paroi_jdd1/vap_paroi_jdd1.data | 10 +- .../vap_paroi_jdd1/vap_paroi_jdd1.lml.gz | Bin 8096 -> 14213 bytes .../vap_paroi_jdd2/vap_paroi_jdd2.data | 10 +- .../vap_paroi_jdd2/vap_paroi_jdd2.lml.gz | Bin 7342 -> 12205 bytes 392 files changed, 1654 insertions(+), 1486 deletions(-) create mode 100644 tests/Reference/Macro/Macro.data create mode 100644 tests/Reference/Macro/Macro.geo create mode 100644 tests/Reference/Macro/Macro.lml.gz create mode 100644 tests/Verification/Incorrect_syntax/Incorrect_syntax.data create mode 100644 tests/Verification/Incorrect_syntax/Incorrect_syntax.lml.gz create mode 100644 tests/Verification/Incorrect_syntax/circular_include.data create mode 100644 tests/Verification/Incorrect_syntax/end_of_file_in_comment_1.data create mode 100644 tests/Verification/Incorrect_syntax/end_of_file_in_comment_2.data create mode 100644 tests/Verification/Incorrect_syntax/end_of_file_in_expression.data create mode 100644 tests/Verification/Incorrect_syntax/end_of_file_in_literal_string.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_define_1.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_define_2.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_include.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_operand_sequence.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_operator_sequence_1.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_operator_sequence_2.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_parenthesis_1.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_parenthesis_2.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_parenthesis_in_expression_1.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_parenthesis_in_expression_2.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_reserved_keyword_1.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_reserved_keyword_2.data create mode 100644 tests/Verification/Incorrect_syntax/invalid_reserved_keyword_3.data create mode 100644 tests/Verification/Incorrect_syntax/list_tests.txt create mode 100644 tests/Verification/Incorrect_syntax/macro_in_expression.data create mode 100644 tests/Verification/Incorrect_syntax/string_literal_in_expression.data create mode 100644 tests/Verification/Incorrect_syntax/unclosed_curly_bracket.data create mode 100644 tests/Verification/Incorrect_syntax/unopened_curly_bracket.data create mode 100755 tests/Verification/Incorrect_syntax/verifie diff --git a/Validation/Outils/Genere_courbe/src/filelist.py b/Validation/Outils/Genere_courbe/src/filelist.py index ee7563c3c3..08b533a21f 100644 --- a/Validation/Outils/Genere_courbe/src/filelist.py +++ b/Validation/Outils/Genere_courbe/src/filelist.py @@ -234,7 +234,6 @@ def AppendTestCase(cls, case, dir): if not cls.active: return cls.Append(dir + "/" + case + ".data") cls.Append(dir + "/" + case + ".err") - cls.Append(dir + "/" + case + ".TU") # Commenting those 2 - they might be huge if many timesteps: # cls.Append(dir + "/" + case + ".out") # cls.Append(dir + "/" + case + ".dt_ev") diff --git a/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_Genepi2/src/eclt_coude_Genepi2.data b/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_Genepi2/src/eclt_coude_Genepi2.data index 1e0d07c8cb..a1d131b8c7 100644 --- a/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_Genepi2/src/eclt_coude_Genepi2.data +++ b/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_Genepi2/src/eclt_coude_Genepi2.data @@ -22,7 +22,7 @@ Mailler dom } } -transformer dom (1.+x)*cos(0.3141592653589793E1*y/2.) (1.+x)*sin(0.3141592653589793E1*y/2.) +transformer dom ((1.+x)*cos(0.3141592653589793E1*y/2.)) ((1.+x)*sin(0.3141592653589793E1*y/2.)) EF dis @@ -61,11 +61,11 @@ Read pb convection { negligeable } diffusion { } initial_conditions { - vitesse Champ_Fonc_XYZ dom 2 (-(8.0*ln(2.0)*x*x+8.0*ln(2.0)*y*y-8.0*ln(2.0)-3.0*ln(x*x+y*y)*x*x-3.0*ln(x*x+y*y)*y*y)*sqrt(y*y/(x*x+y*y))/sqrt(x*x+y*y)/ln(2.0)/8.0) ((8.0*ln(2.0)*x*x+8.0*ln(2.0)*y*y-8.0*ln(2.0)-3.0*ln(x*x+y*y)*x*x-3.0*ln(x*x+y*y)*y*y)*x/(x*x+y*y)/ln(2.0)/8.0) + vitesse Champ_Fonc_XYZ dom 2 ((-(8.0*ln(2.0)*x*x+8.0*ln(2.0)*y*y-8.0*ln(2.0)-3.0*ln(x*x+y*y)*x*x-3.0*ln(x*x+y*y)*y*y)*sqrt(y*y/(x*x+y*y))/sqrt(x*x+y*y)/ln(2.0)/8.0)) (((8.0*ln(2.0)*x*x+8.0*ln(2.0)*y*y-8.0*ln(2.0)-3.0*ln(x*x+y*y)*x*x-3.0*ln(x*x+y*y)*y*y)*x/(x*x+y*y)/ln(2.0)/8.0)) } boundary_conditions { Bas frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 (0.) (0.1183687798)*(x>1.01)*(x<1.99) + Champ_Front_Fonc_tXYZ 2 (0.) ((0.1183687798)*(x>1.01)*(x<1.99)) Gauche frontiere_ouverte_vitesse_imposee Champ_Front_Uniforme 2 0. 0. Droit frontiere_ouverte_vitesse_imposee diff --git a/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_frottement/src/eclt_coude_frottement2.data b/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_frottement/src/eclt_coude_frottement2.data index 1a0b2e50a5..7e07a005c6 100644 --- a/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_frottement/src/eclt_coude_frottement2.data +++ b/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_frottement/src/eclt_coude_frottement2.data @@ -60,17 +60,17 @@ Read pb } convection { negligeable } diffusion { negligeable } - sources { source_qdm Champ_Fonc_XYZ dom 2 1000.*(y/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.) 1000.*(-x/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.) } + sources { source_qdm Champ_Fonc_XYZ dom 2 (1000.*(y/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.)) (1000.*(-x/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.)) } initial_conditions { - vitesse Champ_Fonc_XYZ dom 2 10.*(-y/sqrt(x*x+y*y)) 10.*(x/sqrt(x*x+y*y)) + vitesse Champ_Fonc_XYZ dom 2 (10.*(-y/sqrt(x*x+y*y))) (10.*(x/sqrt(x*x+y*y))) } boundary_conditions { Gauche frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y/sqrt(x*x+y*y)) 10.*(x/sqrt(x*x+y*y)) + Champ_Front_Fonc_tXYZ 2 (10.*(-y/sqrt(x*x+y*y))) (10.*(x/sqrt(x*x+y*y))) Droit frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y/sqrt(x*x+y*y)) 10.*(x/sqrt(x*x+y*y)) + Champ_Front_Fonc_tXYZ 2 (10.*(-y/sqrt(x*x+y*y))) (10.*(x/sqrt(x*x+y*y))) Bas frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 (0.) 10.*(1.) + Champ_Front_Fonc_tXYZ 2 (0.) (10.*(1.)) Haut frontiere_ouverte_pression_imposee Champ_Front_Uniforme 1 0. } diff --git a/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_frottement/src/eclt_coude_frottement3.data b/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_frottement/src/eclt_coude_frottement3.data index c0f98598cd..cfb074dcb9 100644 --- a/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_frottement/src/eclt_coude_frottement3.data +++ b/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_frottement/src/eclt_coude_frottement3.data @@ -22,7 +22,7 @@ Mailler dom } } -transformer dom (1.+x)*cos(0.3141592653589793E1*y/2.) (1.+x)*sin(0.3141592653589793E1*y/2.) +transformer dom ((1.+x)*cos(0.3141592653589793E1*y/2.)) ((1.+x)*sin(0.3141592653589793E1*y/2.)) EF dis @@ -60,17 +60,17 @@ Read pb } convection { negligeable } diffusion { negligeable } - sources { source_qdm Champ_Fonc_XYZ dom 2 1000.*(y/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.) 1000.*(-x/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.) } + sources { source_qdm Champ_Fonc_XYZ dom 2 (1000.*(y/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.)) (1000.*(-x/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.)) } initial_conditions { - vitesse Champ_Fonc_XYZ dom 2 10.*(-y) 10.*(x) + vitesse Champ_Fonc_XYZ dom 2 (-10.*(y)) (10.*(x)) } boundary_conditions { Gauche frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y) 10.*(x) + Champ_Front_Fonc_tXYZ 2 (-10.*(y)) (10.*(x)) Droit frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y) 10.*(x) + Champ_Front_Fonc_tXYZ 2 (-10.*(y)) (10.*(x)) Bas frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y) 10.*(x) + Champ_Front_Fonc_tXYZ 2 (-10.*(y)) (10.*(x)) Haut frontiere_ouverte_pression_imposee Champ_Front_Uniforme 1 0. } diff --git a/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_pression_3D/src/eclt_coude_pression_3D.data b/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_pression_3D/src/eclt_coude_pression_3D.data index 696054b1dc..6daff87686 100644 --- a/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_pression_3D/src/eclt_coude_pression_3D.data +++ b/Validation/Rapports_automatiques/Verification/EF/EF_Eclt_coude_pression_3D/src/eclt_coude_pression_3D.data @@ -24,7 +24,7 @@ Mailler dom } } -transformer dom (1.+x)*cos(0.3141592653589793E1*y/2.) (1.+x)*sin(0.3141592653589793E1*y/2.) z +transformer dom ((1.+x)*cos(0.3141592653589793E1*y/2.)) ((1.+x)*sin(0.3141592653589793E1*y/2.)) z EF dis diff --git a/Validation/Rapports_automatiques/Verification/IBM_PDF/src/template_taylor_couette.data b/Validation/Rapports_automatiques/Verification/IBM_PDF/src/template_taylor_couette.data index 01d4a3ead2..0c9c0e6de7 100644 --- a/Validation/Rapports_automatiques/Verification/IBM_PDF/src/template_taylor_couette.data +++ b/Validation/Rapports_automatiques/Verification/IBM_PDF/src/template_taylor_couette.data @@ -114,7 +114,7 @@ Lire pb { eta 1.E-12 local - vitesse_imposee_fonction 3 0. -(((x*x)+(y*y))_LE_(0.75*0.75))*0.5+(((x*x)+(y*y))_GE_(0.75*0.75))*1.0 0. + vitesse_imposee_fonction 0. (-(((x*x)+(y*y))<=(0.75*0.75))*0.5+(((x*x)+(y*y))>=(0.75*0.75))*1.0) 0. } interpolation @INTERP_TYPE@ { diff --git a/Validation/Rapports_automatiques/Verification/Multiphase/Pb_multi_vs_WC_QC/src/jdd_multi.data b/Validation/Rapports_automatiques/Verification/Multiphase/Pb_multi_vs_WC_QC/src/jdd_multi.data index 8f36cdf58c..9803b54167 100644 --- a/Validation/Rapports_automatiques/Verification/Multiphase/Pb_multi_vs_WC_QC/src/jdd_multi.data +++ b/Validation/Rapports_automatiques/Verification/Multiphase/Pb_multi_vs_WC_QC/src/jdd_multi.data @@ -55,7 +55,7 @@ Read sch { pression_degeneree 0 criteres_convergence { alpha 1e-5 pression 1 vitesse 1 } - solveur petsc cholesky { quiet } + solveur petsc cli { } seuil_convergence_implicite 1e30 } } @@ -76,7 +76,7 @@ Read pb QDM_Multiphase { evanescence { homogene { alpha_res 1 alpha_res_min 0.5 } } - solveur_pression petsc cholesky { quiet } /* cli_quiet { -pc_type hypre -pc_hypre_type boomeramg } */ + solveur_pression petsc cli_quiet { -pc_type hypre -pc_hypre_type boomeramg } convection { amont } diffusion { } initial_conditions diff --git a/Validation/Rapports_automatiques/Verification/Multiphase/tubes_a_choc/src/jdd.data b/Validation/Rapports_automatiques/Verification/Multiphase/tubes_a_choc/src/jdd.data index 79e27b29d7..403a6486bc 100644 --- a/Validation/Rapports_automatiques/Verification/Multiphase/tubes_a_choc/src/jdd.data +++ b/Validation/Rapports_automatiques/Verification/Multiphase/tubes_a_choc/src/jdd.data @@ -71,8 +71,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 __vl__*(x[__x__)+(__vr__)*(x>__x__) 0 - pression Champ_fonc_xyz dom 1 __pl__*(x[__x__)+__pr__*(x>__x__) + vitesse Champ_fonc_xyz dom 2 (__vl__*(x[__x__)+(__vr__)*(x>__x__)) 0 + pression Champ_fonc_xyz dom 1 (__pl__*(x[__x__)+__pr__*(x>__x__)) } boundary_conditions { @@ -98,7 +98,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((__pl__*(x[__x__)+__pr__*(x>__x__))+__pinf__)/((__rl__*(x[__x__)+__rr__*(x>__x__))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((__pl__*(x[__x__)+__pr__*(x>__x__))+__pinf__)/((__rl__*(x[__x__)+__rr__*(x>__x__))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/Validation/Rapports_automatiques/Verification/Multiphase/vap_paroi/src/canal.data b/Validation/Rapports_automatiques/Verification/Multiphase/vap_paroi/src/canal.data index 34a4af29c3..ffddc4dabe 100644 --- a/Validation/Rapports_automatiques/Verification/Multiphase/vap_paroi/src/canal.data +++ b/Validation/Rapports_automatiques/Verification/Multiphase/vap_paroi/src/canal.data @@ -77,7 +77,7 @@ Read pb correlations { - /* multiplicateur_diphasique friedel { } */ + multiplicateur_diphasique friedel { } flux_interfacial coef_constant { liquide_sodium 1e8 /* coeff echange liquide-interface (interface tjrs a Tsat) => petit echange => liquide loin de Tsat */ gaz_sodium 1e10 /* coeff echange gaz-interface (interface tjrs a Tsat) => grande echange => gaz toujours a Tsat */ @@ -133,13 +133,13 @@ Read pb } sources { - source_qdm champ_uniforme 6 0 0 0 0 -9.81 -9.81 /* , + source_qdm champ_uniforme 6 0 0 0 0 -9.81 -9.81 , Perte_Charge_Isotrope { diam_hydr Champ_Uniforme 1 0.00385 sous_zone tot lambda - ((2000_min_((Re-1000)_max_0))*0.194*Re^(-0.2)+(2000_min_((3000-Re)_max_0))*64/Re)/2000 - } */ + ((2000 min ((Re-1000) max 0))*0.194*Re^(-0.2)+(2000 min ((3000-Re) max 0))*64/Re)/2000 + } } } Masse_Multiphase @@ -203,7 +203,7 @@ Read pb vitesse_g_trust grav vitesse_gaz_sodium periode 1 segment 500 1e-3 1e-3 0. 1e-3 1e-3 1.508 } Format cgns - fields dt_post 100 + fields dt_post 0 { vitesse_liquide_sodium elem vitesse_gaz_sodium elem diff --git a/Validation/Rapports_automatiques/Verification/Multiphase/vap_paroi/vap_paroi.ipynb b/Validation/Rapports_automatiques/Verification/Multiphase/vap_paroi/vap_paroi.ipynb index 07f0fce5d3..2542485387 100644 --- a/Validation/Rapports_automatiques/Verification/Multiphase/vap_paroi/vap_paroi.ipynb +++ b/Validation/Rapports_automatiques/Verification/Multiphase/vap_paroi/vap_paroi.ipynb @@ -114,7 +114,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "base", "language": "python", "name": "python3" }, diff --git a/Validation/Rapports_automatiques/Verification/Schemes/QC_temperature_bounds_MUSCL/src/Cas.data b/Validation/Rapports_automatiques/Verification/Schemes/QC_temperature_bounds_MUSCL/src/Cas.data index a02625c97b..c74a4e9113 100644 --- a/Validation/Rapports_automatiques/Verification/Schemes/QC_temperature_bounds_MUSCL/src/Cas.data +++ b/Validation/Rapports_automatiques/Verification/Schemes/QC_temperature_bounds_MUSCL/src/Cas.data @@ -52,14 +52,14 @@ lire pb fluide_quasi_compressible { gravite champ_uniforme 3 0 -9.81 0 - mu champ_fonc_fonction pb temperature 1 ((val*0.00109+(1-val)*0.00245)_MAX_0.00109)_MIN_0.00245 + mu champ_fonc_fonction pb temperature 1 (((val*0.00109+(1-val)*0.00245)max 0.00109)min 0.00245) lambda champ_fonc_fonction pb temperature 1 1.77e-6 pression 1 loi_etat rhoT_gaz_parfait_QC { Prandtl 1 Cp 1 - rho_T ((T*1064.7+(1-T)*956.54)_MAX_956.54)_MIN_1064.7 + rho_T (((T*1064.7+(1-T)*956.54)max 956.54) min 1064.7) } traitement_pth constant traitement_rho_gravite standard @@ -97,7 +97,7 @@ lire pb } convection { $CONV } diffusion { } - conditions_initiales { temperature champ_fonc_xyz dom 1 (x<0)*(1)+(x>0)*(0) } + conditions_initiales { temperature champ_fonc_xyz dom 1 ((x<0)*(1)+(x>0)*(0)) } conditions_limites { Paroi_tube paroi_adiabatique Reservoir_froid paroi_adiabatique diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/Abort_timestep/src/abort_QC.data b/Validation/Rapports_automatiques/Verification/Verification_codage/Abort_timestep/src/abort_QC.data index cc5f5cc62e..feed33d394 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/Abort_timestep/src/abort_QC.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/Abort_timestep/src/abort_QC.data @@ -162,8 +162,8 @@ Read pb1 } sources { Perte_Charge_isotrope { - diam_hydr champ_fonc_txyz dom_fluid 1 1.4-1.3908*(y]1)*(y[3) - lambda 4*((16/Re)$(0.079/(Re^0.25))$0.003) + diam_hydr champ_fonc_txyz dom_fluid 1 (1.4-1.3908*(y>=1)*(y<=3)) + lambda (4*((16/Re) max (0.079/(Re^0.25)) max 0.003)) } } @@ -186,7 +186,7 @@ Read pb1 sources { - Puissance_thermique champ_fonc_xyz dom_fluid 1 2400e6*2/3./10./(3*3.1416*0.7*0.7)*0.6/1.8*1.53*(y]1)*(y[3) + Puissance_thermique champ_fonc_xyz dom_fluid 1 (2400e6*2/3./10./(3*3.1416*0.7*0.7)*0.6/1.8*1.53*(y>=1)*(y<=3)) } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/Abort_timestep/src/abort_QC_Pimp.data b/Validation/Rapports_automatiques/Verification/Verification_codage/Abort_timestep/src/abort_QC_Pimp.data index 4586f2f6d5..4aed5f129a 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/Abort_timestep/src/abort_QC_Pimp.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/Abort_timestep/src/abort_QC_Pimp.data @@ -165,8 +165,8 @@ Read pb1 } sources { Perte_Charge_isotrope { - diam_hydr champ_fonc_txyz dom_fluid 1 1.4-1.3908*(y]1)*(y[3) - lambda 4*((16/Re)$(0.079/(Re^0.25))$0.003) + diam_hydr champ_fonc_txyz dom_fluid 1 (1.4-1.3908*(y>=1)*(y<=3)) + lambda (4*((16/Re) max (0.079/(Re^0.25)) max 0.003)) } } @@ -190,7 +190,7 @@ Read pb1 sources { - Puissance_thermique champ_fonc_xyz dom_fluid 1 2400e6*2/3./10./(3*3.1416*0.7*0.7)*0.6/1.8*1.53*(y]1)*(y[3) + Puissance_thermique champ_fonc_xyz dom_fluid 1 (2400e6*2/3./10./(3*3.1416*0.7*0.7)*0.6/1.8*1.53*(y>=1)*(y<=3)) } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/Champ_front_xyz_debit/src/prepare b/Validation/Rapports_automatiques/Verification/Verification_codage/Champ_front_xyz_debit/src/prepare index 670d4feafb..94fa67e47e 100755 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/Champ_front_xyz_debit/src/prepare +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/Champ_front_xyz_debit/src/prepare @@ -17,7 +17,7 @@ sed -i "s/vitesseX periode 100/vitesseX periode 2.1/" Champ_front_xyz_debit_4.da sed -i "s/vitesseY periode 100/vitesseY periode 2.1/" Champ_front_xyz_debit_4.data # chap 4 : cas 2 VEF 2D inclined -sed "s/ENTREE/champ\_front\_fonc\_xyz 2 0*(y<0.5)-0.25*(y_GE_0.5)*(y_LT_1)-0.75*(y_GE_1)*(y_LT_1.5)-0.5*(y_GE_1.5)*(y_LT_2) 2/; s/VALUE/champ\_front\_uniforme 1 2.5/; s/VDF/VEFPreP1B/; s/10 5 0.1 5 2/20 5 0.01 6. 2/g" Champ_front_xyz_debit.data > Champ_front_xyz_debit_2.data +sed "s/ENTREE/champ\_front\_fonc\_xyz 2 0*(y<0.5)-0.25*(y>=0.5)*(y<1)-0.75*(y>=1)*(y<1.5)-0.5*(y>=1.5)*(y<2) 2/; s/VALUE/champ\_front\_uniforme 1 2.5/; s/VDF/VEFPreP1B/; s/10 5 0.1 5 2/20 5 0.01 6. 2/g" Champ_front_xyz_debit.data > Champ_front_xyz_debit_2.data sed -i "23a transformer dom x+0.5*y y" Champ_front_xyz_debit_2.data sed -i "24a trianguler_h dom" Champ_front_xyz_debit_2.data sed -i "25a raffiner_isotrope dom" Champ_front_xyz_debit_2.data diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/Inward_field/src/prepare b/Validation/Rapports_automatiques/Verification/Verification_codage/Inward_field/src/prepare index a40d8232d2..52cc49ebef 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/Inward_field/src/prepare +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/Inward_field/src/prepare @@ -35,60 +35,60 @@ sed "s/Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_valu sed "s/vdf dis/ VEFPreP1B dis/ s/\/\* tetra_here \*\// tetraedriser_homogene_compact dom/ - s/\/\* Transformer_here \*\//Transformer dom x*cos(pi\/4)+y*sin(pi\/4) -x*sin(pi\/4)+y*cos(pi\/4) z/ - s/\/\* TransformerZ_here \*\//Transformer dom x*cos(pi\/4)+z*sin(pi\/4) y -x*sin(pi\/4)+z*cos(pi\/4)/ - s/Top paroi_fixe/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 -sqrt(1.\/2) -1.\/2/ - s/Bottom paroi_fixe/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 -sqrt(1.\/2) -1.\/2/ - s/Left paroi_fixe/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 -sqrt(1.\/2) -1.\/2/ - s/Right paroi_fixe/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 -sqrt(1.\/2) -1.\/2/ - s/methode vecteur expression 3 1. 0. 0./methode vecteur expression 3 1.\/2 -sqrt(1.\/2) -1.\/2/" inward_field_VDF_3D_Back.data > inward_field_VEF_3D_Back.data + s/\/\* Transformer_here \*\//Transformer dom (x*cos(pi\/4)+y*sin(pi\/4)) (-x*sin(pi\/4)+y*cos(pi\/4)) z/ + s/\/\* TransformerZ_here \*\//Transformer dom (x*cos(pi\/4)+z*sin(pi\/4)) y (-x*sin(pi\/4)+z*cos(pi\/4))/ + s/Top paroi_fixe/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/ + s/Bottom paroi_fixe/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/ + s/Left paroi_fixe/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/ + s/Right paroi_fixe/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/ + s/methode vecteur expression 3 1. 0. 0./methode vecteur expression 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/" inward_field_VDF_3D_Back.data > inward_field_VEF_3D_Back.data sed "s/Back frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Back frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ s/Front frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Front frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/ s/Domaine boundary_Back/Domaine boundary_Front/; s/nom_frontiere Back/nom_frontiere Front/ - s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 -sqrt(1.\/2) -1.\/2/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1.\/2 sqrt(1.\/2) 1.\/2/ - s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 -sqrt(1.\/2) -1.\/2/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1.\/2 sqrt(1.\/2) 1.\/2/ - s/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 -sqrt(1.\/2) -1.\/2/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1.\/2 sqrt(1.\/2) 1.\/2/ - s/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 -sqrt(1.\/2) -1.\/2/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1.\/2 sqrt(1.\/2) 1.\/2/ - s/methode vecteur expression 3 1.\/2 -sqrt(1.\/2) -1.\/2/methode vecteur expression 3 -1.\/2 sqrt(1.\/2) 1.\/2/" inward_field_VEF_3D_Back.data > inward_field_VEF_3D_Front.data - -sed "s/Front frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1.\/2) 0 sqrt(1.\/2)/ - s/Back frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1.\/2) 0 sqrt(1.\/2)/ - s/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1.\/2 sqrt(1.\/2) 1.\/2/Left frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/ - s/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1.\/2 sqrt(1.\/2) 1.\/2/Right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ - s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1.\/2 sqrt(1.\/2) 1.\/2/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1.\/2) 0 sqrt(1.\/2)/ - s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1.\/2 sqrt(1.\/2) 1.\/2/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1.\/2) 0 sqrt(1.\/2)/ + s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/ + s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/ + s/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/ + s/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/ + s/methode vecteur expression 3 (1.\/2) (-sqrt(1.\/2)) (-1.\/2)/methode vecteur expression 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/" inward_field_VEF_3D_Back.data > inward_field_VEF_3D_Front.data + +sed "s/Front frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/ + s/Back frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/ + s/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/Left frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/ + s/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/Right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ + s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/ + s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/ s/Domaine boundary_Front/Domaine boundary_Left/ s/nom_frontiere Front/nom_frontiere Left/ - s/methode vecteur expression 3 -1.\/2 sqrt(1.\/2) 1.\/2/methode vecteur expression 3 sqrt(1.\/2) 0 sqrt(1.\/2)/" inward_field_VEF_3D_Front.data > inward_field_VEF_3D_Left.data + s/methode vecteur expression 3 (-1.\/2) (sqrt(1.\/2)) (1.\/2)/methode vecteur expression 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/" inward_field_VEF_3D_Front.data > inward_field_VEF_3D_Left.data sed "s/Left frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Left frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ s/Right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Right frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/ - s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1.\/2) 0 sqrt(1.\/2)/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/ - s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1.\/2) 0 sqrt(1.\/2)/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/ - s/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1.\/2) 0 sqrt(1.\/2)/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/ - s/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1.\/2) 0 sqrt(1.\/2)/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/ + s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/ + s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/ + s/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/ + s/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/ s/Domaine boundary_Left/Domaine boundary_Right/; s/nom_frontiere Left/nom_frontiere Right/ - s/methode vecteur expression 3 sqrt(1.\/2) 0 sqrt(1.\/2)/methode vecteur expression 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/" inward_field_VEF_3D_Left.data > inward_field_VEF_3D_Right.data - -sed "s/Right frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5.\/2 -5*sqrt(1.\/2) 5.\/2/ - s/Left frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5.\/2 -5*sqrt(1.\/2) 5.\/2/ - s/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5.\/2 -5*sqrt(1.\/2) 5.\/2/ - s/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5.\/2 -5*sqrt(1.\/2) 5.\/2/ - s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 5.0 }/ - s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/Bottom frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ + s/methode vecteur expression 3 (sqrt(1.\/2)) 0 (sqrt(1.\/2))/methode vecteur expression 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/" inward_field_VEF_3D_Left.data > inward_field_VEF_3D_Right.data + +sed "s/Right frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5.\/2) (-5*sqrt(1.\/2)) (5.\/2)/ + s/Left frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5.\/2) (-5*sqrt(1.\/2)) (5.\/2)/ + s/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5.\/2) (-5*sqrt(1.\/2)) (5.\/2)/ + s/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5.\/2) (-5*sqrt(1.\/2)) (5.\/2)/ + s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 5.0 }/ + s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/Bottom frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ s/Domaine boundary_Right/Domaine boundary_Top/; s/nom_frontiere Right/nom_frontiere Top/ - s/methode vecteur expression 3 -sqrt(1.\/2) 0 -sqrt(1.\/2)/methode vecteur expression 3 -5.\/2 -5*sqrt(1.\/2) 5.\/2/" inward_field_VEF_3D_Right.data > inward_field_VEF_3D_Top.data + s/methode vecteur expression 3 (-sqrt(1.\/2)) 0 (-sqrt(1.\/2))/methode vecteur expression 3 (-5.\/2) (-5*sqrt(1.\/2)) (5.\/2)/" inward_field_VEF_3D_Right.data > inward_field_VEF_3D_Top.data sed "s/Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 5.0 }/Top frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ s/Bottom frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Bottom frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/ - s/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5.\/2 -5\*sqrt(1.\/2) 5.\/2/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 sqrt(1.\/2) -1.\/2/ - s/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5.\/2 -5\*sqrt(1.\/2) 5.\/2/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 sqrt(1.\/2) -1.\/2/ - s/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5.\/2 -5\*sqrt(1.\/2) 5.\/2/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 sqrt(1.\/2) -1.\/2/ - s/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5.\/2 -5\*sqrt(1.\/2) 5.\/2/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1.\/2 sqrt(1.\/2) -1.\/2/ + s/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5.\/2) (-5\*sqrt(1.\/2)) (5.\/2)/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (sqrt(1.\/2)) (-1.\/2)/ + s/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5.\/2) (-5\*sqrt(1.\/2)) (5.\/2)/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (sqrt(1.\/2)) (-1.\/2)/ + s/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5.\/2) (-5\*sqrt(1.\/2)) (5.\/2)/Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (sqrt(1.\/2)) (-1.\/2)/ + s/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5.\/2) (-5\*sqrt(1.\/2)) (5.\/2)/Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1.\/2) (sqrt(1.\/2)) (-1.\/2)/ s/Domaine boundary_Top/Domaine boundary_Bottom/; s/nom_frontiere Top/nom_frontiere Bottom/; s/nom_frontiere Top/nom_frontiere Bottom/ - s/methode vecteur expression 3 -5.\/2 -5\*sqrt(1.\/2) 5.\/2/methode vecteur expression 3 1.\/2 sqrt(1.\/2) -1.\/2/" inward_field_VEF_3D_Top.data > inward_field_VEF_3D_Bottom.data + s/methode vecteur expression 3 (-5.\/2) (-5\*sqrt(1.\/2)) (5.\/2)/methode vecteur expression 3 (1.\/2) (sqrt(1.\/2)) (-1.\/2)/" inward_field_VEF_3D_Top.data > inward_field_VEF_3D_Bottom.data @@ -119,34 +119,34 @@ sed "s/Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_valu sed "s/vdf dis/VEFPreP1B dis/ s/\/\* tetra_here \*\//Trianguler_H dom/ - s/\/\* Transformer_here \*\//Transformer dom x*cos(pi\/4)+y*sin(pi\/4) -x*sin(pi\/4)+y*cos(pi\/4)/ - s/methode vecteur expression 2 1. 0./methode vecteur expression 2 1.\/sqrt(2) -1.\/sqrt(2)/ - s/Top paroi_fixe/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 1.\/sqrt(2) -1.\/sqrt(2)/ - s/Bottom paroi_fixe/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 1.\/sqrt(2) -1.\/sqrt(2)/" inward_field_VDF_2D_Left.data > inward_field_VEF_2D_Left.data + s/\/\* Transformer_here \*\//Transformer dom (x*cos(pi\/4)+y*sin(pi\/4)) (-x*sin(pi\/4)+y*cos(pi\/4))/ + s/methode vecteur expression 2 1. 0./methode vecteur expression 2 (1.\/sqrt(2)) (-1.\/sqrt(2))/ + s/Top paroi_fixe/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (1.\/sqrt(2)) (-1.\/sqrt(2))/ + s/Bottom paroi_fixe/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (1.\/sqrt(2)) (-1.\/sqrt(2))/" inward_field_VDF_2D_Left.data > inward_field_VEF_2D_Left.data sed "s/Left frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Left frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ s/Right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Right frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/ s/Domaine boundary_Left/Domaine boundary_Right/ s/nom_frontiere Left/nom_frontiere Right/ - s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 1.\/sqrt(2) -1.\/sqrt(2)/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -1.\/sqrt(2) 1.\/sqrt(2)/ - s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 1.\/sqrt(2) -1.\/sqrt(2)/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -1.\/sqrt(2) 1.\/sqrt(2)/ - s/methode vecteur expression 2 1.\/sqrt(2) -1.\/sqrt(2)/methode vecteur expression 2 -1.\/sqrt(2) 1.\/sqrt(2)/" inward_field_VEF_2D_Left.data > inward_field_VEF_2D_Right.data - -sed "s/Left frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -sqrt(12.5) -sqrt(12.5)/ - s/Right frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -sqrt(12.5) -sqrt(12.5)/ - s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -1.\/sqrt(2) 1.\/sqrt(2)/Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 5.0 }/ - s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -1.\/sqrt(2) 1.\/sqrt(2)/Bottom frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ + s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (1.\/sqrt(2)) (-1.\/sqrt(2))/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-1.\/sqrt(2)) (1.\/sqrt(2))/ + s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (1.\/sqrt(2)) (-1.\/sqrt(2))/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-1.\/sqrt(2)) (1.\/sqrt(2))/ + s/methode vecteur expression 2 (1.\/sqrt(2)) (-1.\/sqrt(2))/methode vecteur expression 2 (-1.\/sqrt(2)) (1.\/sqrt(2))/" inward_field_VEF_2D_Left.data > inward_field_VEF_2D_Right.data + +sed "s/Left frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-sqrt(12.5)) (-sqrt(12.5))/ + s/Right frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-sqrt(12.5)) (-sqrt(12.5))/ + s/Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-1.\/sqrt(2)) (1.\/sqrt(2))/Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 5.0 }/ + s/Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-1.\/sqrt(2)) (1.\/sqrt(2))/Bottom frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ s/Domaine boundary_Right/Domaine boundary_Top/ s/nom_frontiere Right/nom_frontiere Top/ - s/methode vecteur expression 2 -1.\/sqrt(2) 1.\/sqrt(2)/methode vecteur expression 2 -sqrt(12.5) -sqrt(12.5)/" inward_field_VEF_2D_Right.data > inward_field_VEF_2D_Top.data + s/methode vecteur expression 2 (-1.\/sqrt(2)) (1.\/sqrt(2))/methode vecteur expression 2 (-sqrt(12.5)) (-sqrt(12.5))/" inward_field_VEF_2D_Right.data > inward_field_VEF_2D_Top.data sed "s/Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 5.0 }/Top frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/ s/Bottom frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0/Bottom frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 }/ s/Domaine boundary_Top/Domaine boundary_Bottom/ s/nom_frontiere Top/nom_frontiere Bottom/ - s/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -sqrt(12.5) -sqrt(12.5)/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 sqrt(0.5) sqrt(0.5)/ - s/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -sqrt(12.5) -sqrt(12.5)/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 sqrt(0.5) sqrt(0.5)/ - s/methode vecteur expression 2 -sqrt(12.5) -sqrt(12.5)/methode vecteur expression 2 sqrt(0.5) sqrt(0.5)/" inward_field_VEF_2D_Top.data > inward_field_VEF_2D_Bottom.data + s/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-sqrt(12.5)) (-sqrt(12.5))/Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (sqrt(0.5)) (sqrt(0.5))/ + s/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-sqrt(12.5)) (-sqrt(12.5))/Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (sqrt(0.5)) (sqrt(0.5))/ + s/methode vecteur expression 2 (-sqrt(12.5)) (-sqrt(12.5))/methode vecteur expression 2 (sqrt(0.5)) (sqrt(0.5))/" inward_field_VEF_2D_Top.data > inward_field_VEF_2D_Bottom.data diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/Multistep_Methods/src/template.data b/Validation/Rapports_automatiques/Verification/Verification_codage/Multistep_Methods/src/template.data index 5f94adc003..9aefbbc0f8 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/Multistep_Methods/src/template.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/Multistep_Methods/src/template.data @@ -43,7 +43,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } @@ -66,4 +66,4 @@ Navier_Stokes_standard Solve pb - \ No newline at end of file + diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/PeChaReg_VEF/src/3D_sym_inout/test.data b/Validation/Rapports_automatiques/Verification/Verification_codage/PeChaReg_VEF/src/3D_sym_inout/test.data index 8a59b0f86c..ee42444e57 100755 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/PeChaReg_VEF/src/3D_sym_inout/test.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/PeChaReg_VEF/src/3D_sym_inout/test.data @@ -21,7 +21,7 @@ Mailler dom } } -transformer dom x-0.5 y-0.5 z +transformer dom (x-0.5) (y-0.5) z tetraedriser_homogene_fin dom # marqueur # diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/PeChaReg_VEF/src/prepare b/Validation/Rapports_automatiques/Verification/Verification_codage/PeChaReg_VEF/src/prepare index 191b01c910..af3f9a21eb 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/PeChaReg_VEF/src/prepare +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/PeChaReg_VEF/src/prepare @@ -1,4 +1,4 @@ #!/bin/bash cd 3D_sym_inout sed "s/# Porosites_champ champ_uniforme 1 0.5 #/Porosites_champ champ_uniforme 1 0.5/" test.data > test_poreux.data -sed "s?# marqueur #?transformer dom (x+y)/sqrt(2) (x-y)/sqrt(2) z transformer dom x (y+z)/sqrt(2) (y-z)/sqrt(2) transformer dom (x+z)/sqrt(2) y (x-z)/sqrt(2)?" test.data > test_rotation.data +sed "s?# marqueur #?transformer dom ((x+y)/sqrt(2)) ((x-y)/sqrt(2)) z transformer dom x ((y+z)/sqrt(2)) ((y-z)/sqrt(2)) transformer dom ((x+z)/sqrt(2)) y ((x-z)/sqrt(2))?" test.data > test_rotation.data diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/Perte_Charge_Circulaire_VEF/src/Perte_Charge_Circulaire.data b/Validation/Rapports_automatiques/Verification/Verification_codage/Perte_Charge_Circulaire_VEF/src/Perte_Charge_Circulaire.data index a28b953e9b..57f75144d4 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/Perte_Charge_Circulaire_VEF/src/Perte_Charge_Circulaire.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/Perte_Charge_Circulaire_VEF/src/Perte_Charge_Circulaire.data @@ -103,8 +103,8 @@ Read pb { Perte_charge_circulaire { diam_hydr champ_uniforme 1 0.01 diam_hydr_ortho champ_uniforme 1 0.02 - lambda 96/Re_tot*0+1.*(Re_long)^(-0.25) - lambda_ortho 96/Re_tot*0+2.*(Re_ortho)^(-0.27) + lambda (96/Re_tot*0+1.*(Re_long)^(-0.25)) + lambda_ortho (96/Re_tot*0+2.*(Re_ortho)^(-0.27)) sous_zone zone1 direction champ_uniforme 2 1 0 } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/QC_EOS_rhoT/src/_Cas.data b/Validation/Rapports_automatiques/Verification/Verification_codage/QC_EOS_rhoT/src/_Cas.data index 816cd7b94e..d006829874 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/QC_EOS_rhoT/src/_Cas.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/QC_EOS_rhoT/src/_Cas.data @@ -94,8 +94,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - (_SOURCE1_)/(_RHO_) - (_SOURCE2_)/(_RHO_) , + ((_SOURCE1_)/(_RHO_)) + ((_SOURCE2_)/(_RHO_)) , canal_perio { bord periox debit_impose _DEBITX_ } , canal_perio { bord perioy debit_impose _DEBITY_ } } @@ -132,7 +132,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(_REFU_) + methode formule expression 1 ((u-uex)/(_REFU_)) nom_source u_uex localisation _LOC_ sources { @@ -155,7 +155,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(_REFP_) + methode formule expression 1 ((p-pmoy-pex)/(_REFP_)) localisation elem sources { diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/conduc_mil_var/src/conduc_bar_ef_ana.data b/Validation/Rapports_automatiques/Verification/Verification_codage/conduc_mil_var/src/conduc_bar_ef_ana.data index 6d4f70a86c..40e2329ab7 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/conduc_mil_var/src/conduc_bar_ef_ana.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/conduc_mil_var/src/conduc_bar_ef_ana.data @@ -68,8 +68,8 @@ Read pb rho Champ_uniforme 1 1.0 /* lambda Champ_uniforme 1 1.0 Cp Champ_uniforme 1 1.0 */ - lambda Champ_fonc_txyz dom 1 sin(t)*sin(x)+1.5 - Cp Champ_fonc_txyz dom 1 sin(t)*sin(x)+2.0 + lambda Champ_fonc_txyz dom 1 (sin(t)*sin(x)+1.5) + Cp Champ_fonc_txyz dom 1 (sin(t)*sin(x)+2.0) } @@ -81,7 +81,7 @@ Read pb # temperature Champ_fonc_xyz dom 1 sin(3.1415926535898*x) # } sources { - Puissance_Thermique champ_fonc_txyz dom 1 (sin(x)*sin(t)+2.0)*(sin(3.1415926535898*x)*cos(t))+3.1415926535898*sin(t)*(3.1415926535898*(sin(x)*sin(t)+1.5)*sin(3.1415926535898*x)-cos(x)*cos(3.1415926535898*x)*sin(t)) + Puissance_Thermique champ_fonc_txyz dom 1 ((sin(x)*sin(t)+2.0)*(sin(3.1415926535898*x)*cos(t))+3.1415926535898*sin(t)*(3.1415926535898*(sin(x)*sin(t)+1.5)*sin(3.1415926535898*x)-cos(x)*cos(3.1415926535898*x)*sin(t))) /* Puissance_Thermique champ_fonc_txyz dom 1 sin(3.1415926535898*x)*((sin(t)*sin(x)+2.0)*cos(t)+3.1415926535898*3.1415926535898*sin(t)) */ } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/convection/src/jdd.data b/Validation/Rapports_automatiques/Verification/Verification_codage/convection/src/jdd.data index bdd161942a..0c8f8c3fac 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/convection/src/jdd.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/convection/src/jdd.data @@ -52,13 +52,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos($theta)+sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y) - (cos($theta)-sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y) + vitesse champ_fonc_xyz dom 2 ((cos($theta)+sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y)) + ((cos($theta)-sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos($theta)+sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y) - (cos($theta)-sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos($theta)+sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y)) + ((cos($theta)-sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down $cl_down up $cl_up @@ -71,8 +71,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos($theta)+sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos($theta)-sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos($theta)+sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos($theta)-sin($theta))*exp((cos($theta)-sin($theta))*x-(sin($theta)+cos($theta))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/bercovier_engelman.data b/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/bercovier_engelman.data index 5338f0fee7..2274acfb6c 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/bercovier_engelman.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/bercovier_engelman.data @@ -59,7 +59,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/navier_stokes_2d.data b/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/navier_stokes_2d.data index 320fb537e6..da2555411c 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/navier_stokes_2d.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/navier_stokes_2d.data @@ -90,7 +90,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -98,7 +98,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/navier_stokes_3d.data b/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/navier_stokes_3d.data index 1c76653952..c3a043b2bb 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/navier_stokes_3d.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/navier_stokes_3d.data @@ -61,7 +61,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -93,7 +93,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -105,7 +105,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/taylor_green_3d.data b/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/taylor_green_3d.data index db9af5d370..c18fc4035e 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/taylor_green_3d.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/fvca/src/taylor_green_3d.data @@ -58,7 +58,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -66,7 +66,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -76,7 +76,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -85,12 +85,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -98,7 +98,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,11 +106,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/poiseuille/src/jdd.data b/Validation/Rapports_automatiques/Verification/Verification_codage/poiseuille/src/jdd.data index 1de0a1239a..6d47872840 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/poiseuille/src/jdd.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/poiseuille/src/jdd.data @@ -78,7 +78,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 $pout+($pout-$pin)/$lx*(x-$lx) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ($pout+($pout-$pin)/$lx*(x-$lx)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -90,7 +90,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/$mu*($pin-$pout)/($lx)*y*($ly-y)+$vwall*y/$ly 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/$mu*($pin-$pout)/($lx)*y*($ly-y)+$vwall*y/$ly) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/poiseuille_vdf/src/jdd.data b/Validation/Rapports_automatiques/Verification/Verification_codage/poiseuille_vdf/src/jdd.data index d70d2e81b7..7d8108aa71 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/poiseuille_vdf/src/jdd.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/poiseuille_vdf/src/jdd.data @@ -61,8 +61,8 @@ Read pb { Definition_champs { - p_exact transformation { methode formule expression 1 $pout+($pout-$pin)/$lx*(x-$lx) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } - v_exact transformation { methode vecteur expression 2 0.5/$mu*($pin-$pout)/($lx)*y*($ly-y)+$vwall*y/$ly 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + p_exact transformation { methode formule expression 1 ($pout+($pout-$pin)/$lx*(x-$lx)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + v_exact transformation { methode vecteur expression 2 (0.5/$mu*($pin-$pout)/($lx)*y*($ly-y)+$vwall*y/$ly) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } probes { diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/poissonSolver_PolyMAC/src/manufactured_solution.data b/Validation/Rapports_automatiques/Verification/Verification_codage/poissonSolver_PolyMAC/src/manufactured_solution.data index da3dd8d436..74eebb2a64 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/poissonSolver_PolyMAC/src/manufactured_solution.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/poissonSolver_PolyMAC/src/manufactured_solution.data @@ -54,14 +54,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 $source_ } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 ($source_) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -$dx_ - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 $func_ - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 $func_ - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -$dy_ + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-$dx_) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ($func_) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ($func_) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-$dy_) } } @@ -73,14 +73,14 @@ Read pb Definition_champs { solution transformation { - Localisation $loc_ - methode formule expression 1 $func_ + Localisation ($loc_) + methode formule expression 1 ($func_) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation $loc_ + methode formule expression 1 (abs(temp-solution)) + localisation ($loc_) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -114,9 +114,9 @@ Read pb format LATA fields dt_post 30. { - temperature $loc_ - solution $loc_ - erreur $loc_ + temperature ($loc_) + solution ($loc_) + erreur ($loc_) } } } diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/porosite_1D/src/jdd.data b/Validation/Rapports_automatiques/Verification/Verification_codage/porosite_1D/src/jdd.data index e8ab8607dd..4b4e7e1b29 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/porosite_1D/src/jdd.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/porosite_1D/src/jdd.data @@ -84,13 +84,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/Validation/Rapports_automatiques/Verification/Verification_codage/porosite_2D/src/jdd.data b/Validation/Rapports_automatiques/Verification/Verification_codage/porosite_2D/src/jdd.data index 5394047ad0..b3bdca4bf0 100644 --- a/Validation/Rapports_automatiques/Verification/Verification_codage/porosite_2D/src/jdd.data +++ b/Validation/Rapports_automatiques/Verification/Verification_codage/porosite_2D/src/jdd.data @@ -47,7 +47,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -76,7 +76,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -88,7 +88,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/src/Kernel/Postraitement/Postraitement.cpp b/src/Kernel/Postraitement/Postraitement.cpp index 61f860ba69..d9b2c659d8 100644 --- a/src/Kernel/Postraitement/Postraitement.cpp +++ b/src/Kernel/Postraitement/Postraitement.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include #include #include @@ -394,10 +394,10 @@ static Nom translate_keyword(const Nom& french_keyword) return english_keyword; } -static EChaineJDD read_and_broadcast_file(const Nom& filename) +static EChaine read_and_broadcast_file(const Nom& filename) { // Proc 0 read file and fills its "file_content" - LecFicDiffuse_JDD file_stream(filename, ios::in, true); + DataFile file_stream(filename, ios::in); long unsigned int file_char_number; Nom file_content("{ "); if (Process::je_suis_maitre()) @@ -415,10 +415,10 @@ static EChaineJDD read_and_broadcast_file(const Nom& filename) file_content.getString()[file_char_number+2] = ' '; file_content.getString()[file_char_number+3] = '}'; // We build an EChaine to interpret the file - return EChaineJDD(file_content); + return EChaine(file_content); } -static EChaineJDD get_file_content_for_bloc(const Nom& associated_word, Entree& s, bool with_acco) +static EChaine get_file_content_for_bloc(const Nom& associated_word, Entree& s, bool with_acco) { Nom filename; if (!with_acco) @@ -658,8 +658,8 @@ int Postraitement::lire_motcle_non_standard(const Motcle& mot, Entree& s) if (keyword=="Fields_file") { Nom associated_word("Fields"); - EChaineJDD file_content = get_file_content_for_bloc(associated_word, s, expect_acco); - lire_champs_a_postraiter(file_content, true); + EChaine file_content = get_file_content_for_bloc(associated_word, s, expect_acco); + lire_champs_a_postraiter(file_content, expect_acco); } else lire_champs_a_postraiter(s, expect_acco); @@ -690,7 +690,7 @@ int Postraitement::lire_motcle_non_standard(const Motcle& mot, Entree& s) if (keyword=="Statistics_file") { Nom associated_word("Statistics"); - EChaineJDD file_content = get_file_content_for_bloc(associated_word, s, expect_acco); + EChaine file_content = get_file_content_for_bloc(associated_word, s, expect_acco); lire_champs_stat_a_postraiter(file_content); } else @@ -790,7 +790,7 @@ int Postraitement::lire_motcle_non_standard(const Motcle& mot, Entree& s) if (keyword=="Int_array_file") { - EChaineJDD file_content = get_file_content_for_bloc(Nom("Int_array"), s, true); + EChaine file_content = get_file_content_for_bloc(Nom("Int_array"), s, true); lire_tableaux_a_postraiter(file_content); } else @@ -813,7 +813,7 @@ int Postraitement::lire_motcle_non_standard(const Motcle& mot, Entree& s) if (keyword=="Serial_statistics_file") { - EChaineJDD file_content = get_file_content_for_bloc(Nom("Serial_statistics"), s, true); + EChaine file_content = get_file_content_for_bloc(Nom("Serial_statistics"), s, true); lire_champs_stat_a_postraiter(file_content); } else @@ -832,7 +832,7 @@ int Postraitement::lire_motcle_non_standard(const Motcle& mot, Entree& s) else if (keyword.finit_par("_file")) { Nom keyword_prefix = keyword.getPrefix("_file"); - EChaineJDD file_content = get_file_content_for_bloc(keyword_prefix, s, true); + EChaine file_content = get_file_content_for_bloc(keyword_prefix, s, true); this->lire_motcle_non_standard(keyword_prefix, file_content); return 1; } diff --git a/src/Kernel/Postraitement/Sondes.cpp b/src/Kernel/Postraitement/Sondes.cpp index b9a3947fc2..3ff23523c4 100644 --- a/src/Kernel/Postraitement/Sondes.cpp +++ b/src/Kernel/Postraitement/Sondes.cpp @@ -13,7 +13,7 @@ * *****************************************************************************/ -#include + #include #include diff --git a/src/Kernel/Utilitaires/Execute_parallel.cpp b/src/Kernel/Utilitaires/Execute_parallel.cpp index 905ee83bad..90b1914639 100644 --- a/src/Kernel/Utilitaires/Execute_parallel.cpp +++ b/src/Kernel/Utilitaires/Execute_parallel.cpp @@ -171,7 +171,7 @@ Entree& Execute_parallel::interpreter(Entree& is) { // Ouverture du fichier (on cree l'objet LecFicDiffuse a l'interieur // de l'accolade pour detruire le fichier avant de sortir du groupe) - LecFicDiffuse_JDD data_file(nom_fichier); + DataFile data_file(nom_fichier); data_file.set_check_types(1); // On cree un nouvel interprete. A la fin de la lecture du cas // les objets seront detruits. diff --git a/tests/Dilatable/Perte_Charge_Circulaire_QC_VEF/Perte_Charge_Circulaire_QC_VEF.data b/tests/Dilatable/Perte_Charge_Circulaire_QC_VEF/Perte_Charge_Circulaire_QC_VEF.data index b5c546bcb8..e7c35489ca 100644 --- a/tests/Dilatable/Perte_Charge_Circulaire_QC_VEF/Perte_Charge_Circulaire_QC_VEF.data +++ b/tests/Dilatable/Perte_Charge_Circulaire_QC_VEF/Perte_Charge_Circulaire_QC_VEF.data @@ -113,8 +113,8 @@ Read pb { Perte_charge_circulaire { diam_hydr champ_uniforme 1 0.01 diam_hydr_ortho champ_uniforme 1 0.02 - lambda 96/Re_tot*0+1.*(Re_long)^(-0.25) - lambda_ortho 96/Re_tot*0+2.*(Re_ortho)^(-0.27) + lambda (96/Re_tot*0+1.*(Re_long)^(-0.25)) + lambda_ortho (96/Re_tot*0+2.*(Re_ortho)^(-0.27)) sous_zone zone1 direction champ_uniforme 2 1 0 } diff --git a/tests/Dilatable/QCRhoT_variable/QCRhoT_variable.data b/tests/Dilatable/QCRhoT_variable/QCRhoT_variable.data index e08b5490d1..b2d5fd3bb6 100644 --- a/tests/Dilatable/QCRhoT_variable/QCRhoT_variable.data +++ b/tests/Dilatable/QCRhoT_variable/QCRhoT_variable.data @@ -101,12 +101,12 @@ Read pb gravite champ_uniforme 2 0. 0. pression 5.e6 - mu Champ_Fonc_Fonction pb temperature 1 3.64910e-2*val^(-1.06130) - lambda Champ_Fonc_Fonction pb temperature 1 ((-5.792978E-06*val+1.580872E-03)*val)+5.832125E-01 + mu Champ_Fonc_Fonction pb temperature 1 (3.64910e-2*val^(-1.06130)) + lambda Champ_Fonc_Fonction pb temperature 1 (((-5.792978E-06*val+1.580872E-03)*val)+5.832125E-01) loi_etat rhoT_gaz_parfait_QC { Cp 4305. - rho_t ((-2.3864182E-03*T-2.2507878E-01)*T)+1.0071165E+03 + rho_t (((-2.3864182E-03*T-2.2507878E-01)*T)+1.0071165E+03) T_min -1000 # default value, if T<-1000 computation crashes. This value added to test this keyword and should not appear in your datafile # } traitement_pth CONSTANT diff --git a/tests/GPU/ColdLegMixing/ColdLegMixing.data b/tests/GPU/ColdLegMixing/ColdLegMixing.data index b8c810d5d0..3cfe54f5b8 100644 --- a/tests/GPU/ColdLegMixing/ColdLegMixing.data +++ b/tests/GPU/ColdLegMixing/ColdLegMixing.data @@ -68,10 +68,10 @@ lire pb fluide_quasi_compressible # water/ethanol water/saccarose mixture # { - mu champ_fonc_fonction pb temperature 1 ((val*0.00109+(1-val)*0.00245)_MAX_0.00109)_MIN_0.00245 + mu champ_fonc_fonction pb temperature 1 (((val*0.00109+(1-val)*0.00245) max 0.00109) min 0.00245) lambda champ_fonc_fonction pb temperature 1 1.77e-6 pression 1 - loi_etat rhoT_gaz_parfait_QC { Prandtl 1 Cp 1 rho_T ((T*1064.7+(1-T)*956.54)_MAX_956.54)_MIN_1064.7 } + loi_etat rhoT_gaz_parfait_QC { Prandtl 1 Cp 1 rho_T (((T*1064.7+(1-T)*956.54) max 956.54) min 1064.7) } gravite champ_uniforme 3 0 -9.81 0 traitement_pth constant traitement_rho_gravite standard @@ -105,7 +105,7 @@ lire pb } convection { MUSCL } diffusion { } - conditions_initiales { temperature champ_fonc_xyz dom 1 (x<0)*(1)+(x>0)*(0) } + conditions_initiales { temperature champ_fonc_xyz dom 1 ((x<0)*(1)+(x>0)*(0)) } conditions_limites { WALL paroi_adiabatique } diff --git a/tests/GPU/GPU4/GPU4.data b/tests/GPU/GPU4/GPU4.data index 64d85e6341..921a367333 100644 --- a/tests/GPU/GPU4/GPU4.data +++ b/tests/GPU/GPU4/GPU4.data @@ -81,7 +81,7 @@ Read pb diffusion { } initial_conditions { vitesse Champ_Uniforme 3 0. 0. 0. } boundary_conditions { - entree Frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 0.1145*(2.44*LN((0.077-SQRT(x*x+y*y))*0.1145/2.35e-7)+5.1) 0. 0. + entree Frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 (0.1145*(2.44*LN((0.077-SQRT(x*x+y*y))*0.1145/2.35e-7)+5.1)) 0. 0. sortie Frontiere_ouverte_pression_imposee Champ_front_Uniforme 1 0. paroi paroi_fixe perio periodique diff --git a/tests/GPU/OpenMP_QC/OpenMP_QC.data b/tests/GPU/OpenMP_QC/OpenMP_QC.data index aa129c85ff..1af8201327 100644 --- a/tests/GPU/OpenMP_QC/OpenMP_QC.data +++ b/tests/GPU/OpenMP_QC/OpenMP_QC.data @@ -54,14 +54,14 @@ lire pb fluide_quasi_compressible { gravite champ_uniforme 3 0 -9.81 0 - mu champ_fonc_fonction pb temperature 1 ((val*0.00109+(1-val)*0.00245)_MAX_0.00109)_MIN_0.00245 + mu champ_fonc_fonction pb temperature 1 (((val*0.00109+(1-val)*0.00245) max 0.00109) min 0.00245) lambda champ_fonc_fonction pb temperature 1 1.77e-6 pression 1 loi_etat rhoT_gaz_parfait_QC { Prandtl 1 Cp 1 - rho_T ((T*1064.7+(1-T)*956.54)_MAX_956.54)_MIN_1064.7 + rho_T (((T*1064.7+(1-T)*956.54) max 956.54) min 1064.7) } traitement_pth constant traitement_rho_gravite standard @@ -99,7 +99,7 @@ lire pb } convection { MUSCL } diffusion { } - conditions_initiales { temperature champ_fonc_xyz dom 1 (x<0)*(1)+(x>0)*(0) } + conditions_initiales { temperature champ_fonc_xyz dom 1 ((x<0)*(1)+(x>0)*(0)) } conditions_limites { Paroi_tube paroi_adiabatique Reservoir_froid paroi_adiabatique diff --git a/tests/Reference/2DParoiX/2DParoiX.data b/tests/Reference/2DParoiX/2DParoiX.data index 4ee72e1063..dc235d54ed 100644 --- a/tests/Reference/2DParoiX/2DParoiX.data +++ b/tests/Reference/2DParoiX/2DParoiX.data @@ -97,7 +97,7 @@ Read pb Post_processings { lata { - fichier 2dParoiX + fichier 2DParoiX format lata Probes { diff --git a/tests/Reference/2DPerioX/2DPerioX.data b/tests/Reference/2DPerioX/2DPerioX.data index 01f5d1e4ae..5a07b88bcd 100644 --- a/tests/Reference/2DPerioX/2DPerioX.data +++ b/tests/Reference/2DPerioX/2DPerioX.data @@ -21,8 +21,8 @@ Mailler dom } Trianguler_h dom Transformer dom -x+4*x*(1-x)*y*(1-y)*(0.5-y) -y+4*x*(1-x)*y*(1-y)*(0.5+x) +(x+4*x*(1-x)*y*(1-y)*(0.5-y)) +(y+4*x*(1-x)*y*(1-y)*(0.5+x)) # END MESH # # BEGIN PARTITION Partition dom diff --git a/tests/Reference/3DPerio/3DPerio.data b/tests/Reference/3DPerio/3DPerio.data index 559c545820..73e0a578c4 100644 --- a/tests/Reference/3DPerio/3DPerio.data +++ b/tests/Reference/3DPerio/3DPerio.data @@ -23,8 +23,8 @@ Mailler dom } Tetraedriser_homogene dom Transformer dom -x+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5-y) -y+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5+x) +(x+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5-y)) +(y+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5+x)) z Corriger_frontiere_periodique { domaine dom bord paroiY } # END MESH # diff --git a/tests/Reference/3D_P0/3D_P0.data b/tests/Reference/3D_P0/3D_P0.data index 41dde23d41..15505d54b8 100644 --- a/tests/Reference/3D_P0/3D_P0.data +++ b/tests/Reference/3D_P0/3D_P0.data @@ -22,7 +22,7 @@ Mailler dom } } Tetraedriser_homogene dom -Transformer dom x+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5-y) y+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5+x) z +Transformer dom (x+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5-y)) (y+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5+x)) z Corriger_frontiere_periodique { domaine dom bord paroiY } # END MESH # @@ -87,7 +87,6 @@ Read pb initial_conditions { vitesse Champ_fonc_xyz dom 3 0. 0. 0. - pression champ_uniforme 1 0. } boundary_conditions { diff --git a/tests/Reference/Canal_tanh_bruit/Canal_tanh_bruit.data b/tests/Reference/Canal_tanh_bruit/Canal_tanh_bruit.data index eee0f67793..82b496a4e1 100644 --- a/tests/Reference/Canal_tanh_bruit/Canal_tanh_bruit.data +++ b/tests/Reference/Canal_tanh_bruit/Canal_tanh_bruit.data @@ -78,7 +78,7 @@ Read pb diffusion { } initial_conditions { vitesse Champ_Fonc_XYZ Canal 2 - tanh(4*y)*(0.95+0.1*rnd(1)) 0. + (tanh(4*y)*(0.95+0.1*rand(1.))) 0. } boundary_conditions { Paroi paroi_fixe @@ -94,7 +94,7 @@ Read pb Paroi paroi_adiabatique Perio periodique } - initial_conditions { Temperature Champ_Fonc_XYZ Canal 1 tanh(4*y) } + initial_conditions { Temperature Champ_Fonc_XYZ Canal 1 (tanh(4*y)) } } Post_processing diff --git a/tests/Reference/ChFrontTXYZ/ChFrontTXYZ.data b/tests/Reference/ChFrontTXYZ/ChFrontTXYZ.data index 6b89ffc14f..fd9838eda5 100644 --- a/tests/Reference/ChFrontTXYZ/ChFrontTXYZ.data +++ b/tests/Reference/ChFrontTXYZ/ChFrontTXYZ.data @@ -93,7 +93,7 @@ Read pb { Haut paroi_adiabatique Bas paroi_adiabatique - Gauche frontiere_ouverte_temperature_imposee Champ_Front_fonc_txyz 1 10*SIN(t) + Gauche frontiere_ouverte_temperature_imposee Champ_Front_fonc_txyz 1 (10*SIN(t)) Droit frontiere_ouverte T_ext Champ_Front_Uniforme 1 0. } initial_conditions { Temperature Champ_fonc_xyz dom 1 0 } diff --git a/tests/Reference/ChFrontXYZ/ChFrontXYZ.data b/tests/Reference/ChFrontXYZ/ChFrontXYZ.data index 722ef1f441..1fc13d7cb6 100644 --- a/tests/Reference/ChFrontXYZ/ChFrontXYZ.data +++ b/tests/Reference/ChFrontXYZ/ChFrontXYZ.data @@ -79,7 +79,7 @@ Read pb boundary_conditions { Haut paroi_fixe Bas paroi_fixe - Gauche frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 5*y*(1-y)-cos(y) 0. + Gauche frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (5*y*(1-y)-cos(y)) 0. Droit frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 } } diff --git a/tests/Reference/Champ_Fonc_txyz/Champ_Fonc_txyz.data b/tests/Reference/Champ_Fonc_txyz/Champ_Fonc_txyz.data index 86910a5219..3b7c563b97 100644 --- a/tests/Reference/Champ_Fonc_txyz/Champ_Fonc_txyz.data +++ b/tests/Reference/Champ_Fonc_txyz/Champ_Fonc_txyz.data @@ -91,7 +91,7 @@ Read pb diffusion { } convection { quick } sources { - Puissance_Thermique Champ_fonc_txyz dom 1 t*((x-0.5)^2+(y-0.5)^2<0.3*0.3)*100 + Puissance_Thermique Champ_fonc_txyz dom 1 (t*((x-0.5)^2+(y-0.5)^2<0.3*0.3)*100) } boundary_conditions { diff --git a/tests/Reference/Champ_front_xyz_debit/Champ_front_xyz_debit.data b/tests/Reference/Champ_front_xyz_debit/Champ_front_xyz_debit.data index f9415b7336..474c567624 100644 --- a/tests/Reference/Champ_front_xyz_debit/Champ_front_xyz_debit.data +++ b/tests/Reference/Champ_front_xyz_debit/Champ_front_xyz_debit.data @@ -79,7 +79,7 @@ Read pb Inlet frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 Outlet frontiere_ouverte_vitesse_imposee champ_front_xyz_debit { flow_rate champ_front_uniforme 1 -1 - velocity_profil champ_front_fonc_xyz 2 (y_LT_0.5)*y+((y_GE_0.5)_AND_(y_LE_1.5))*0.5+(y_GT_1.5)*(2-y) 0 + velocity_profil champ_front_fonc_xyz 2 ((y<0.5)*y+((y>=0.5) && (y<=1.5))*0.5+(y>1.5)*(2-y)) 0 } } } diff --git a/tests/Reference/Champ_tabule_temps/Champ_fonc_t.data b/tests/Reference/Champ_tabule_temps/Champ_fonc_t.data index 5f98637eeb..4e59236be8 100644 --- a/tests/Reference/Champ_tabule_temps/Champ_fonc_t.data +++ b/tests/Reference/Champ_tabule_temps/Champ_fonc_t.data @@ -80,7 +80,7 @@ Read pb { acceleration { - acceleration Champ_Fonc_t 2 (-0.02*t+0.01)*(t<0.5) 0. + acceleration Champ_Fonc_t 2 ((-0.02*t+0.01)*(t<0.5)) 0. } } @@ -98,7 +98,7 @@ Read pb Definition_champs { solution transformation { - methode vecteur expression 2 -(-0.02*t*t/2+0.01*t)*(t<0.5)+(t_ge_0.5)*(-0.0025) 0 + methode vecteur expression 2 (-(-0.02*t*t/2+0.01*t)*(t<0.5)+(t_ge_0.5)*(-0.0025)) 0 sources { refchamp { pb_champ pb pression } } } } diff --git a/tests/Reference/Champ_tabule_temps/Champ_tabule_temps.data b/tests/Reference/Champ_tabule_temps/Champ_tabule_temps.data index dd0e499559..8773d01c9a 100644 --- a/tests/Reference/Champ_tabule_temps/Champ_tabule_temps.data +++ b/tests/Reference/Champ_tabule_temps/Champ_tabule_temps.data @@ -104,7 +104,7 @@ Read pb Definition_champs { solution transformation { - methode vecteur expression 2 -(-0.02*t*t/2+0.01*t)*(t<0.5)+(t_ge_0.5)*(-0.0025) 0 + methode vecteur expression 2 (-(-0.02*t*t/2+0.01*t)*(t<0.5)+(t_ge_0.5)*(-0.0025)) 0 sources { refchamp { pb_champ pb pression } } } } diff --git a/tests/Reference/Changing_porosity_py/Poreux_stab_VDF.data b/tests/Reference/Changing_porosity_py/Poreux_stab_VDF.data index 8936c31ea9..60c6fce7e7 100644 --- a/tests/Reference/Changing_porosity_py/Poreux_stab_VDF.data +++ b/tests/Reference/Changing_porosity_py/Poreux_stab_VDF.data @@ -58,7 +58,7 @@ Read pb Cp champ_Uniforme 1 1000 porosites_champ champ_input_P0_composite { - initial_field champ_fonc_xyz dom 1 1-0.5*(x>0.2)*(x<0.8) + initial_field champ_fonc_xyz dom 1 (1-0.5*(x>0.2)*(x<0.8)) input_field { nom POROSITY_INN nb_comp 1 probleme pb } } diff --git a/tests/Reference/Domaine_post/Domaine_post.data b/tests/Reference/Domaine_post/Domaine_post.data index adb8829622..f0c79eb6cc 100644 --- a/tests/Reference/Domaine_post/Domaine_post.data +++ b/tests/Reference/Domaine_post/Domaine_post.data @@ -121,7 +121,7 @@ Read pb } initial_conditions { - vitesse Champ_fonc_xyz dom 3 20_MIN_30 (0)_MAX_(-1) 4_MOD_2 + vitesse Champ_fonc_xyz dom 3 (20 min 30) ((0) max (-1)) (4 mod 2) } boundary_conditions { diff --git a/tests/Reference/Fluides_miscibles/Fluides_miscibles.data b/tests/Reference/Fluides_miscibles/Fluides_miscibles.data index 6b92842f78..e7a114bdef 100644 --- a/tests/Reference/Fluides_miscibles/Fluides_miscibles.data +++ b/tests/Reference/Fluides_miscibles/Fluides_miscibles.data @@ -107,7 +107,7 @@ Read pb Bas Paroi } initial_conditions { - concentration champ_fonc_xyz dom 1 (x-y[0) + concentration champ_fonc_xyz dom 1 ((x-y)<=0) } } diff --git a/tests/Reference/IBM_aucune/IBM_aucune.data b/tests/Reference/IBM_aucune/IBM_aucune.data index f38e3f7114..d9edfc358a 100644 --- a/tests/Reference/IBM_aucune/IBM_aucune.data +++ b/tests/Reference/IBM_aucune/IBM_aucune.data @@ -131,7 +131,7 @@ Lire pb { eta 1.E-12 local - vitesse_imposee_fonction 3 0. -(((x*x)+(y*y))_LE_(0.75*0.75))*0.5+(((x*x)+(y*y))_GE_(0.75*0.75))*1.0 0. + vitesse_imposee_fonction 3 0. (-(((x*x)+(y*y))<=(0.75*0.75))*0.5+(((x*x)+(y*y))>=(0.75*0.75))*1.0) 0. } # Attention: cas test qui verifie seulement que le code lit les mots cles prevus de cette interpolation # interpolation IBM_aucune diff --git a/tests/Reference/IBM_gradient_moyen/IBM_gradient_moyen.data b/tests/Reference/IBM_gradient_moyen/IBM_gradient_moyen.data index 114c64b1b5..6c300372b8 100644 --- a/tests/Reference/IBM_gradient_moyen/IBM_gradient_moyen.data +++ b/tests/Reference/IBM_gradient_moyen/IBM_gradient_moyen.data @@ -133,7 +133,7 @@ Lire pb temps_relaxation_coefficient_pdf 1 eta 1.E-10 local - vitesse_imposee_fonction 3 0. -(((x*x)+(y*y))_LE_(0.75*0.75))*0.5+(((x*x)+(y*y))_GE_(0.75*0.75))*1.0 0. + vitesse_imposee_fonction 3 0. (-(((x*x)+(y*y))<=(0.75*0.75))*0.5+(((x*x)+(y*y))>=(0.75*0.75))*1.0) 0. } interpolation IBM_gradient_moyen { diff --git a/tests/Reference/IBM_hybrid/IBM_hybrid.data b/tests/Reference/IBM_hybrid/IBM_hybrid.data index 979ba5c52e..9b98414f96 100644 --- a/tests/Reference/IBM_hybrid/IBM_hybrid.data +++ b/tests/Reference/IBM_hybrid/IBM_hybrid.data @@ -130,7 +130,7 @@ Lire pb { eta 1.E-12 local - vitesse_imposee_fonction 3 0. -(((x*x)+(y*y))_LE_(0.75*0.75))*0.5+(((x*x)+(y*y))_GE_(0.75*0.75))*1.0 0. + vitesse_imposee_fonction 3 0. (-(((x*x)+(y*y))<=(0.75*0.75))*0.5+(((x*x)+(y*y))>=(0.75*0.75))*1.0) 0. } interpolation IBM_hybride { diff --git a/tests/Reference/ICoCo_ChDonXYZ/ICoCo_ChDonXYZ.data b/tests/Reference/ICoCo_ChDonXYZ/ICoCo_ChDonXYZ.data index 03d63a1852..e71e181cfd 100644 --- a/tests/Reference/ICoCo_ChDonXYZ/ICoCo_ChDonXYZ.data +++ b/tests/Reference/ICoCo_ChDonXYZ/ICoCo_ChDonXYZ.data @@ -91,7 +91,7 @@ Read pb diffusion { } convection { quick } sources { - Puissance_Thermique Champ_fonc_xyz dom 1 ((x-0.5)^2+(y-0.5)^2<0.3*0.3)*10 + Puissance_Thermique Champ_fonc_xyz dom 1 (((x-0.5)^2+(y-0.5)^2<0.3*0.3)*10) } boundary_conditions { diff --git a/tests/Reference/Kernel_Parser/Kernel_Parser.data b/tests/Reference/Kernel_Parser/Kernel_Parser.data index 7f7815575c..cb4f9955a8 100644 --- a/tests/Reference/Kernel_Parser/Kernel_Parser.data +++ b/tests/Reference/Kernel_Parser/Kernel_Parser.data @@ -14,8 +14,8 @@ Mailler dom { } } -transformer dom sqrt(x*x+y*y)*COS(Atan(y/x)+PI/3.) sqrt(x*x+y*y)*SIN(Atan(y/x)+PI/3.) -transformer dom asin(sin(x))+sgn(0) -sgn(-x)*sgn(x)*acos(cos(y)) # Test acos et asin et sgn # +transformer dom (sqrt(x*x+y*y)*cos(atan(y/x)+PI/3.)) (sqrt(x*x+y*y)*sin(atan(y/x)+PI/3.)) +transformer dom (asin(sin(x))+sign(0)) (-sign(-x)*sign(x)*acos(cos(y))) # Test acos et asin et sgn # Postraiter_domaine { format lata fichier dom.lata domaine dom } Postraiter_domaine { format lml fichier Kernel_Parser.lml domaine dom } diff --git a/tests/Reference/Kernel_Sous_Domaine_Fonction/Kernel_Sous_Domaine_Fonction.data b/tests/Reference/Kernel_Sous_Domaine_Fonction/Kernel_Sous_Domaine_Fonction.data index c6323c2e3a..6902ed0035 100644 --- a/tests/Reference/Kernel_Sous_Domaine_Fonction/Kernel_Sous_Domaine_Fonction.data +++ b/tests/Reference/Kernel_Sous_Domaine_Fonction/Kernel_Sous_Domaine_Fonction.data @@ -31,7 +31,7 @@ Sous_domaine milieu Associate milieu hexaedre Read milieu { - fonction_sous_zone ((z>0.25)_and_(z<0.75)) + fonction_sous_zone ((z>0.25)&&(z<0.75)) } Sous_domaine sous_domaine_milieu Associate sous_domaine_milieu hexaedre diff --git a/tests/Reference/MED_docond/MED_docond.data b/tests/Reference/MED_docond/MED_docond.data index 9c8cee0ffe..0087fb85c1 100644 --- a/tests/Reference/MED_docond/MED_docond.data +++ b/tests/Reference/MED_docond/MED_docond.data @@ -23,7 +23,7 @@ Domaine dom_fluide Domaine dom # BEGIN MESH # -Read_MED { domaine dom file ./MESH/geom.med } +Read_MED { domaine dom file MESH/geom.med } Mailler tmp { Pave Cavite1 diff --git a/tests/Reference/MED_docond_64/MED_docond_64.data b/tests/Reference/MED_docond_64/MED_docond_64.data index 797bb01248..3504e31bac 100644 --- a/tests/Reference/MED_docond_64/MED_docond_64.data +++ b/tests/Reference/MED_docond_64/MED_docond_64.data @@ -29,7 +29,7 @@ Domaine dom_solide Domaine dom_fluide Domaine dom -Read_MED { domaine dom file ./MESH/geom.med } +Read_MED { domaine dom file MESH/geom.med } Mailler dom_solide { Pave Cavite1 @@ -81,7 +81,7 @@ Domaine_64 dom_solide2 Domaine_64 dom_fluide2 Domaine_64 dom2 -Read_MED_64 { domaine dom2 file ./MESH/geom.med } +Read_MED_64 { domaine dom2 file MESH/geom.med } Mailler_64 dom_solide2 { Pave_64 Cavite1 diff --git a/tests/Reference/Macro/Macro.data b/tests/Reference/Macro/Macro.data new file mode 100644 index 0000000000..a170c7ccae --- /dev/null +++ b/tests/Reference/Macro/Macro.data @@ -0,0 +1,89 @@ +// define constants +#define IMPR_PERIOD 1. + +// dimension +dimension 2 + +// create the domain using the include macro +Domaine dom + +// create the mesh in an external file +#include Macro.geo + +VDF discretization + +# Time scheme explicit or implicit # +Scheme_euler_explicit time_scheme +Read time_scheme { + tinit 0 + tmax 5.0 + + dt_min 5.e-3 + dt_max 5.e-3 + + dt_impr IMPR_PERIOD +} + +# Problem definition # +Pb_hydraulique problem + +# Association between the different objects # +Associate problem dom +Associate problem time_scheme +Discretize problem discretization + +# Problem description # +Read problem { + + # Physical characteristcs of medium # + fluide_incompressible { + # hydraulic problem # + # Dynamic viscosity [kg/m/s] # + mu Champ_Uniforme 1 3.7e-05 + # Volumic mass [kg/m3] # + rho Champ_Uniforme 1 2 + } + + + # hydraulic problem # + Navier_Stokes_standard + { + # Pressure matrix solved with # + solveur_pression GCP { + precond ssor { omega 1.500000 } + seuil 1.000000e-06 + impr + } + + # Two operators are defined # + convection { quick } + diffusion { } + + # Uniform initial condition for velocity # + initial_conditions { + vitesse Champ_Uniforme 2 0. 0. + } + + # Boundary conditions # + boundary_conditions { + Left paroi_fixe + Right paroi_fixe + Bottom frontiere_ouverte_vitesse_imposee Champ_front_Uniforme 2 0. 1. + Top frontiere_ouverte_pression_imposee Champ_front_Uniforme 1 0. + } + } + + Post_processing + { + format lml + fields dt_post IMPR_PERIOD + { + pression elem + pression som + vitesse elem + } + } +} + +Solve problem +End diff --git a/tests/Reference/Macro/Macro.geo b/tests/Reference/Macro/Macro.geo new file mode 100644 index 0000000000..2ef3c3d3d0 --- /dev/null +++ b/tests/Reference/Macro/Macro.geo @@ -0,0 +1,21 @@ +// create a mesh using macros +#define LX 0.1 +#define LY 0.22 + +#define NUMBER_OF_ELEMENTS_PER_METER 100 +#define NX (INT(LX * NUMBER_OF_ELEMENTS_PER_METER)) +#define NY (INT(LY * NUMBER_OF_ELEMENTS_PER_METER)) + +Mailler dom { + Pave Entree { + Origine 0. 0. + Longueurs LX LY + Nombre_de_Noeuds NX NY + } + { + bord Left X = 0. 0. <= Y <= LY + bord Right X = LX 0. <= Y <= LY + bord Bottom Y = 0. 0. <= X <= LX + bord Top Y = LY 0. <= X <= LX + } +} diff --git a/tests/Reference/Macro/Macro.lml.gz b/tests/Reference/Macro/Macro.lml.gz new file mode 100644 index 0000000000000000000000000000000000000000..7b9f3f77c80e560a631457fa50e95910aea29a9f GIT binary patch literal 48570 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 literal 0 HcmV?d00001 diff --git a/tests/Reference/PDI_Pb_couple/PDI_Pb_couple.data b/tests/Reference/PDI_Pb_couple/PDI_Pb_couple.data index a196df71e4..de732fc618 100644 --- a/tests/Reference/PDI_Pb_couple/PDI_Pb_couple.data +++ b/tests/Reference/PDI_Pb_couple/PDI_Pb_couple.data @@ -65,7 +65,7 @@ Fluide_Incompressible Canal_perio { bord periox } , Source_qdm_lambdaup { lambda 2. } } - conditions_initiales { vitesse champ_fonc_xyz dom_boite 3 3.73024 60.*(1.-rnd(1)) 60.*(1.-rnd(1)) } + conditions_initiales { vitesse champ_fonc_xyz dom_boite 3 (3.73024) (60.*(1.-rand(1.))) (60.*(1.-rand(1.))) } boundary_conditions { periox periodique diff --git a/tests/Reference/PDI_Pb_couple/prepare.data b/tests/Reference/PDI_Pb_couple/prepare.data index dd365e6849..45ccca6687 100644 --- a/tests/Reference/PDI_Pb_couple/prepare.data +++ b/tests/Reference/PDI_Pb_couple/prepare.data @@ -120,7 +120,7 @@ Fluide_Incompressible diffusion { standard defaut_bar } Sources { Canal_perio { bord periox } } Sources { Source_qdm_lambdaup { lambda 2. } } - conditions_initiales { vitesse champ_fonc_xyz dom_boite 3 3.73024 60.*(1.-rnd(1)) 60.*(1.-rnd(1)) } + conditions_initiales { vitesse champ_fonc_xyz dom_boite 3 3.73024 60.*(1.-rand(1.)) 60.*(1.-rand(1.)) } boundary_conditions { periox periodique diff --git a/tests/Reference/PETSC_Canal_perio_VEF_3D/PETSC_Canal_perio_VEF_3D.data b/tests/Reference/PETSC_Canal_perio_VEF_3D/PETSC_Canal_perio_VEF_3D.data index 57b6ef8224..753bffa2b6 100644 --- a/tests/Reference/PETSC_Canal_perio_VEF_3D/PETSC_Canal_perio_VEF_3D.data +++ b/tests/Reference/PETSC_Canal_perio_VEF_3D/PETSC_Canal_perio_VEF_3D.data @@ -79,7 +79,7 @@ Read pb convection { muscl } diffusion { } initial_conditions { - vitesse champ_fonc_xyz dom 3 0.5*cos(45/360*(8*atan(1))) 0 -0.5*sin(45/360*(8*atan(1))) + vitesse champ_fonc_xyz dom 3 (0.5*cos(45/360*(8*atan(1)))) 0 (-0.5*sin(45/360*(8*atan(1)))) } sources { Canal_perio { bord periox } } boundary_conditions { diff --git a/tests/Reference/POISEUILLE_ALIGNED/POISEUILLE_ALIGNED.data b/tests/Reference/POISEUILLE_ALIGNED/POISEUILLE_ALIGNED.data index 6cde2d0b43..cb4c6c3c2b 100644 --- a/tests/Reference/POISEUILLE_ALIGNED/POISEUILLE_ALIGNED.data +++ b/tests/Reference/POISEUILLE_ALIGNED/POISEUILLE_ALIGNED.data @@ -115,7 +115,7 @@ Read pb diffusion { option { grad_u_transpose_partout 1 } } initial_conditions { - vitesse Champ_fonc_xyz dom 3 0. (x_GT_0.5)*(x_LT_1.5)*(-4.0*x*x+8.0*x-3.0) 0. + vitesse Champ_fonc_xyz dom 3 0. ((x>0.5)*(x<1.5)*(-4.0*x*x+8.0*x-3.0)) 0. } sources { @@ -175,7 +175,7 @@ Read pb Wall Symetrie Postpro Symetrie Sortie frontiere_ouverte_pression_imposee Champ_front_Uniforme 1 1.0 - Entree frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 0. (x_GT_0.5)*(x_LT_1.5)*(-4.0*x*x+8.0*x-3.0) 0. + Entree frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 0. ((x>0.5)*(x<1.5)*(-4.0*x*x+8.0*x-3.0)) 0. } } diff --git a/tests/Reference/POISEUILLE_ALIGNED_power_law/POISEUILLE_ALIGNED_power_law.data b/tests/Reference/POISEUILLE_ALIGNED_power_law/POISEUILLE_ALIGNED_power_law.data index ae01c0c5b5..4c1f86d1f6 100644 --- a/tests/Reference/POISEUILLE_ALIGNED_power_law/POISEUILLE_ALIGNED_power_law.data +++ b/tests/Reference/POISEUILLE_ALIGNED_power_law/POISEUILLE_ALIGNED_power_law.data @@ -96,7 +96,7 @@ Read pb diffusion { option { grad_u_transpose_partout 1 } } initial_conditions { - vitesse Champ_fonc_xyz dom 3 0. (x_GT_0.5)*(x_LT_1.5)*(-4.0*x*x+8.0*x-3.0) 0. + vitesse Champ_fonc_xyz dom 3 0. ((x>0.5)*(x<1.5)*(-4.0*x*x+8.0*x-3.0)) 0. } sources { @@ -125,7 +125,7 @@ Read pb Wall Symetrie Postpro Symetrie Sortie frontiere_ouverte_pression_imposee Champ_front_Uniforme 1 1.0 - Entree frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 0. (x_GT_0.5)*(x_LT_1.5)*(-4.0*x*x+8.0*x-3.0) 0. + Entree frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 0. ((x>0.5)*(x<1.5)*(-4.0*x*x+8.0*x-3.0)) 0. } } diff --git a/tests/Reference/POISEUILLE_ALIGNED_th/POISEUILLE_ALIGNED_th.data b/tests/Reference/POISEUILLE_ALIGNED_th/POISEUILLE_ALIGNED_th.data index 922e7e9dd2..5221cf79d8 100644 --- a/tests/Reference/POISEUILLE_ALIGNED_th/POISEUILLE_ALIGNED_th.data +++ b/tests/Reference/POISEUILLE_ALIGNED_th/POISEUILLE_ALIGNED_th.data @@ -149,14 +149,14 @@ Read pb } initial_conditions { - vitesse Champ_fonc_xyz dom 3 0. (x_GT_0.5)*(x_LT_1.5)*(-4.0*x*x+8.0*x-3.0) 0. + vitesse Champ_fonc_xyz dom 3 0. ((x>0.5)*(x<1.5)*(-4.0*x*x+8.0*x-3.0)) 0. } boundary_conditions { Wall Symetrie Postpro Symetrie Sortie frontiere_ouverte_pression_imposee Champ_front_Uniforme 1 1.0 - Entree frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 0. (x_GT_0.5)*(x_LT_1.5)*(-4.0*x*x+8.0*x-3.0) 0. + Entree frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 0. ((x>0.5)*(x<1.5)*(-4.0*x*x+8.0*x-3.0)) 0. } } @@ -223,9 +223,9 @@ Read pb Wall Symetrie Postpro Symetrie Sortie frontiere_ouverte t_ext Champ_front_fonc_txyz 1 1.e12 - Entree frontiere_ouverte_temperature_imposee Champ_Front_fonc_txyz 1 (x_GT_0.5)*(x_LT_1.5)*1.00+(x_GT_0.6)*(x_LT_1.4)*1 + Entree frontiere_ouverte_temperature_imposee Champ_Front_fonc_txyz 1 ((x>0.5)*(x<1.5)*1.00+(x>0.6)*(x<1.4)*1) } - initial_conditions { Temperature champ_fonc_xyz dom 1 (x_GT_0.5)*(x_LT_1.5)*1.0 } + initial_conditions { Temperature champ_fonc_xyz dom 1 ((x>0.5)*(x<1.5)*1.0) } } Post_processings diff --git a/tests/Reference/P_out_var_impl/P_out_var_impl.data b/tests/Reference/P_out_var_impl/P_out_var_impl.data index 2876e50068..d13f7f4d27 100644 --- a/tests/Reference/P_out_var_impl/P_out_var_impl.data +++ b/tests/Reference/P_out_var_impl/P_out_var_impl.data @@ -78,7 +78,7 @@ Read pb } boundary_conditions { Haut paroi_fixe - Entree frontiere_ouverte_pression_imposee Champ_Front_fonc_txyz 1 t*(t_le_1)+(t_gt_1) + Entree frontiere_ouverte_pression_imposee Champ_Front_fonc_txyz 1 (t*(t<1)+(t>1)) Sortie frontiere_ouverte_pression_imposee Champ_Front_Uniforme 1 0. } } diff --git a/tests/Reference/Parallele/Parallele.data b/tests/Reference/Parallele/Parallele.data index 334a81d22c..331f486c3b 100644 --- a/tests/Reference/Parallele/Parallele.data +++ b/tests/Reference/Parallele/Parallele.data @@ -23,9 +23,9 @@ Mailler dom } Tetraedriser_homogene dom Transformer dom -(x+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5-y))*(1+atan(x)) -y+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5+x)*(1+atan(y)) -tanh(z)/tanh(1) +((x+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5-y))*(1+atan(x))) +(y+4*x*(1-x)*y*(1-y)*z*(1-z)*(0.5+x)*(1+atan(y))) +(tanh(z)/tanh(1)) Corriger_frontiere_periodique { domaine dom bord paroiY } # END MESH # @@ -69,7 +69,7 @@ Read pb { fluide_incompressible { - mu Champ_Fonc_xyz dom 1 1+cos(x)*cos(y)*cos(z) + mu Champ_Fonc_xyz dom 1 (1+cos(x)*cos(y)*cos(z)) rho Champ_Uniforme 1 1. } @@ -79,14 +79,14 @@ Read pb Solveur_Pression petsc cholesky { } convection { muscl } diffusion { } - Sources { Source_Qdm Champ_fonc_txyz dom 3 sin(x*y*z+t) cos(x*y*z+t) tan(x*y*z+t) } - initial_conditions { vitesse Champ_fonc_xyz dom 3 sin(x*y*z) cos(x*y*z) tan(x*y*z) } + Sources { Source_Qdm Champ_fonc_txyz dom 3 (sin(x*y*z+t)) (cos(x*y*z+t)) (tan(x*y*z+t)) } + initial_conditions { vitesse Champ_fonc_xyz dom 3 (sin(x*y*z)) (cos(x*y*z)) (tan(x*y*z)) } boundary_conditions { Sud paroi_fixe Nord Symetrie - Gauche Frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 x+y+z+t x+y+z+t x+y+z+t - Droit Frontiere_ouverte_pression_imposee Champ_front_fonc_txyz 1 x+y+z+t + Gauche Frontiere_ouverte_vitesse_imposee Champ_front_fonc_txyz 3 (x+y+z+t) (x+y+z+t) (x+y+z+t) + Droit Frontiere_ouverte_pression_imposee Champ_front_fonc_txyz 1 (x+y+z+t) paroiY periodique } } diff --git a/tests/Reference/Repere_Rotation_Periodique/Repere_Rotation_Periodique.data b/tests/Reference/Repere_Rotation_Periodique/Repere_Rotation_Periodique.data index 4ea9c41f9c..383f3b1c9a 100644 --- a/tests/Reference/Repere_Rotation_Periodique/Repere_Rotation_Periodique.data +++ b/tests/Reference/Repere_Rotation_Periodique/Repere_Rotation_Periodique.data @@ -73,7 +73,7 @@ Read pb Acceleration { option entrainement_seul omega Champ_fonc_t 3 0 0 1 domegadt champ_fonc_t 3 0 0 0 centre_rotation champ_fonc_t 3 0 0 -1.5 } } initial_conditions { - vitesse Champ_Fonc_xyz dom 3 cos(x) sin(y) cos(x)*sin(y) + vitesse Champ_Fonc_xyz dom 3 (cos(x)) (sin(y)) (cos(x)*sin(y)) } boundary_conditions { Surfa symetrie diff --git a/tests/Reference/Reprise_xyz_ancien_format/Reprise_xyz_ancien_format.data b/tests/Reference/Reprise_xyz_ancien_format/Reprise_xyz_ancien_format.data index 2c843df496..f5b4b044de 100644 --- a/tests/Reference/Reprise_xyz_ancien_format/Reprise_xyz_ancien_format.data +++ b/tests/Reference/Reprise_xyz_ancien_format/Reprise_xyz_ancien_format.data @@ -44,7 +44,8 @@ Read sch Associate pb dom Associate pb sch Discretize pb dis -EcritureLectureSpecial 1 +# Test old way to read .xyz file with EFichierBin # +EcritureLectureSpecial EFichierBin Read pb { @@ -93,6 +94,6 @@ Read pb reprise xyz old.xyz } # Test old way to write .xyz with EcrFicPartageBin # -EcritureLectureSpecial 1 +EcritureLectureSpecial EcrFicPartageBin Solve pb End diff --git a/tests/Reference/Sauve_xyz_ascii/Sauve_xyz_ascii.data b/tests/Reference/Sauve_xyz_ascii/Sauve_xyz_ascii.data index 65d6a0bb8b..251f18c725 100644 --- a/tests/Reference/Sauve_xyz_ascii/Sauve_xyz_ascii.data +++ b/tests/Reference/Sauve_xyz_ascii/Sauve_xyz_ascii.data @@ -1,6 +1,6 @@ # PARALLEL OK # -EcritureLectureSpecial 1 +EcritureLectureSpecial EcrFicPartage # Enable ASCII .xyz file # dimension 3 Pb_Hydraulique pb Domaine dom diff --git a/tests/Reference/TAYLOR_COUETTE/TAYLOR_COUETTE.data b/tests/Reference/TAYLOR_COUETTE/TAYLOR_COUETTE.data index f2126ab57c..8f5b8cc69c 100644 --- a/tests/Reference/TAYLOR_COUETTE/TAYLOR_COUETTE.data +++ b/tests/Reference/TAYLOR_COUETTE/TAYLOR_COUETTE.data @@ -129,7 +129,7 @@ Lire pb { eta 1.E-12 local - vitesse_imposee_fonction 3 0. -(((x*x)+(y*y))_LE_(0.75*0.75))*0.5+(((x*x)+(y*y))_GE_(0.75*0.75))*1.0 0. + vitesse_imposee_fonction 3 0. (-(((x*x)+(y*y))<=(0.75*0.75))*0.5+(((x*x)+(y*y))>=(0.75*0.75))*1.0) 0. } interpolation IBM_element_fluide { diff --git a/tests/Reference/TP_THI_VDF_LAM/TP_THI_VDF_LAM.data b/tests/Reference/TP_THI_VDF_LAM/TP_THI_VDF_LAM.data index cc8864eaf8..6fe4db4dab 100644 --- a/tests/Reference/TP_THI_VDF_LAM/TP_THI_VDF_LAM.data +++ b/tests/Reference/TP_THI_VDF_LAM/TP_THI_VDF_LAM.data @@ -74,7 +74,7 @@ Read pb convection { Centre } diffusion { } initial_conditions { - vitesse Champ_som_lu_VDF dom 3 1e-8 ./champ_k2_8 + vitesse Champ_som_lu_VDF dom 3 1e-8 champ_k2_8 } boundary_conditions { periox periodique diff --git a/tests/Reference/TP_THI_VEF/TP_THI_VEF.data b/tests/Reference/TP_THI_VEF/TP_THI_VEF.data index 0c2b9fd76e..063497e958 100644 --- a/tests/Reference/TP_THI_VEF/TP_THI_VEF.data +++ b/tests/Reference/TP_THI_VEF/TP_THI_VEF.data @@ -83,7 +83,7 @@ Read pb convection { EF_stab { } } diffusion { negligeable } initial_conditions { - vitesse Champ_som_lu_VEF dom 3 1e-8 ./champ_k2_8 + vitesse Champ_som_lu_VEF dom 3 1e-8 champ_k2_8 } boundary_conditions { diff --git a/tests/Reference/ThHyd_3D_VEFPreP1B/ThHyd_3D_VEFPreP1B.data b/tests/Reference/ThHyd_3D_VEFPreP1B/ThHyd_3D_VEFPreP1B.data index cdf01eeec4..61277e8d8a 100644 --- a/tests/Reference/ThHyd_3D_VEFPreP1B/ThHyd_3D_VEFPreP1B.data +++ b/tests/Reference/ThHyd_3D_VEFPreP1B/ThHyd_3D_VEFPreP1B.data @@ -102,7 +102,7 @@ Read pb DROIT Paroi_temperature_imposee Champ_Front_Uniforme 1 323.15 GAUCH Paroi_flux_impose Champ_front_Uniforme 1 400. } - initial_conditions { Temperature Champ_fonc_xyz dom_fluide 1 538.911933+((323.150000-538.911933)/0.02)*((SQRT(x^2+y^2))-0.01) } + initial_conditions { Temperature Champ_fonc_xyz dom_fluide 1 (538.911933+((323.150000-538.911933)/0.02)*((SQRT(x^2+y^2))-0.01)) } } Post_processing { diff --git a/tests/Reference/U_in_var_impl_vef/U_in_var_impl_vef.data b/tests/Reference/U_in_var_impl_vef/U_in_var_impl_vef.data index d22f10c3f7..eb98d22d2c 100644 --- a/tests/Reference/U_in_var_impl_vef/U_in_var_impl_vef.data +++ b/tests/Reference/U_in_var_impl_vef/U_in_var_impl_vef.data @@ -85,7 +85,7 @@ Read pb } boundary_conditions { Haut symetrie - Entree frontiere_ouverte_vitesse_imposee Champ_Front_fonc_txyz 2 t*(t_LE_100)+(t_GT_100)*100 0 + Entree frontiere_ouverte_vitesse_imposee Champ_Front_fonc_txyz 2 (t*(t<=100)+(t>100)*100) 0 Sortie frontiere_ouverte_pression_imposee Champ_Front_Uniforme 1 0. } } diff --git a/tests/Reference/cond_coup_fictif_vdf_impl/cond_coup_fictif_vdf_impl.data b/tests/Reference/cond_coup_fictif_vdf_impl/cond_coup_fictif_vdf_impl.data index 68434a1b79..7ccbe82516 100644 --- a/tests/Reference/cond_coup_fictif_vdf_impl/cond_coup_fictif_vdf_impl.data +++ b/tests/Reference/cond_coup_fictif_vdf_impl/cond_coup_fictif_vdf_impl.data @@ -141,14 +141,14 @@ Read pb2 Gauche paroi_contact_fictif pb1 Gauche 5. 0.1 Bas Paroi_ADIABATIQUE } - initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 (x_ge_0)*(20.00-401.*x)+(x<0)*20.00-40.*x } + initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 ((x>=0)*(20.00-401.*x)+(x<0)*20.00-40.*x) } } Post_processing { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temp-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x)) + methode formule expression 1 (temp-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x))) source refChamp { Pb_Champ pb2 temperature nom_source temp } @@ -185,7 +185,7 @@ Read pb1 Conduction { diffusion { } - initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 (x_ge_0)*(20.00-401.*x)+(x<0)*20.00-40.*x } + initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 ((x>=0)*(20.00-401.*x)+(x<0)*20.00-40.*x) } boundary_conditions { @@ -199,7 +199,7 @@ Read pb1 { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temp-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x)) + methode formule expression 1 (temp-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x))) source refChamp { Pb_Champ pb1 temperature nom_source temp } diff --git a/tests/Reference/cond_coup_fictif_vef_impl/cond_coup_fictif_vef_impl.data b/tests/Reference/cond_coup_fictif_vef_impl/cond_coup_fictif_vef_impl.data index e8def93125..2d3fcbf0c9 100644 --- a/tests/Reference/cond_coup_fictif_vef_impl/cond_coup_fictif_vef_impl.data +++ b/tests/Reference/cond_coup_fictif_vef_impl/cond_coup_fictif_vef_impl.data @@ -143,13 +143,13 @@ Read pb2 Gauche paroi_contact_fictif pb1 Gauche 5. 0.1 Bas Paroi_ADIABATIQUE } - initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 (x_ge_0)*(20.00-401.*x)+(x<0)*20.00-40.*x } + initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 ((x>=0)*(20.00-401.*x)+(x<0)*20.00-40.*x) } } Post_processing { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temperature-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x)) + methode formule expression 1 (temperature-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x))) source refChamp { Pb_Champ pb2 temperature nom_source temperature } @@ -185,7 +185,7 @@ Read pb1 Conduction { diffusion { } - initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 (x_ge_0)*(20.00-401.*x)+(x<0)*20.00-40.*x } + initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 ((x>=0)*(20.00-401.*x)+(x<0)*20.00-40.*x) } boundary_conditions { @@ -200,7 +200,7 @@ Read pb1 { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temperature-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x)) + methode formule expression 1 (temperature-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x))) source refChamp { Pb_Champ pb1 temperature nom_source temperature } diff --git a/tests/Reference/cond_couple_vef_impl/cond_couple_vef_impl.data b/tests/Reference/cond_couple_vef_impl/cond_couple_vef_impl.data index 5d78c94413..d4440f5b7e 100644 --- a/tests/Reference/cond_couple_vef_impl/cond_couple_vef_impl.data +++ b/tests/Reference/cond_couple_vef_impl/cond_couple_vef_impl.data @@ -141,14 +141,14 @@ Read pb2 } initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 - (x>0)*(18.31179308*SIN(30.79992798*x-1.539996399)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)+20.00-40.*x) + ((x>0)*(18.31179308*SIN(30.79992798*x-1.539996399)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)+20.00-40.*x)) } } Post_processing { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temperature-((x>0)*(18.31179308*SIN(30.79992798*x-1.539996399)*EXP(-0.9486355639*t)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)*EXP(-0.9486355639*t)+20.00-40.*x)) + methode formule expression 1 (temperature-((x>0)*(18.31179308*SIN(30.79992798*x-1.539996399)*EXP(-0.9486355639*t)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)*EXP(-0.9486355639*t)+20.00-40.*x))) source refChamp { Pb_Champ pb2 temperature nom_source temperature } @@ -188,7 +188,7 @@ Read pb1 diffusion { } initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 - (x]0)*(18.31179308*SIN(30.79992798*x-1.539996399)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)+20.00-40.*x) + ((x]0)*(18.31179308*SIN(30.79992798*x-1.539996399)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)+20.00-40.*x)) } boundary_conditions { diff --git a/tests/Reference/conditions_initiales_vitesse_pression/reprise.data b/tests/Reference/conditions_initiales_vitesse_pression/reprise.data index 44d0757ee6..3f9e0281ea 100644 --- a/tests/Reference/conditions_initiales_vitesse_pression/reprise.data +++ b/tests/Reference/conditions_initiales_vitesse_pression/reprise.data @@ -60,8 +60,8 @@ read pb_fluide convection { amont } diffusion { } initial_conditions { - vitesse champ_fonc_reprise binaire ./TRUST_backup.sauv pb_fluide vitesse last_time - pression champ_fonc_reprise binaire ./TRUST_backup.sauv pb_fluide pression last_time + vitesse champ_fonc_reprise binaire TRUST_backup.sauv pb_fluide vitesse last_time + pression champ_fonc_reprise binaire TRUST_backup.sauv pb_fluide pression last_time } boundary_conditions { diff --git a/tests/Reference/conduc_PDF/conduc_PDF.data b/tests/Reference/conduc_PDF/conduc_PDF.data index 1275d20c38..ce47a2e50c 100644 --- a/tests/Reference/conduc_PDF/conduc_PDF.data +++ b/tests/Reference/conduc_PDF/conduc_PDF.data @@ -80,7 +80,7 @@ Read pb solide { rho Champ_Uniforme 1 2 - lambda champ_fonc_fonction pb temperature 1 (0.01*(val_LE_7.0)+0.001*(val_GT_7.0)) + lambda champ_fonc_fonction pb temperature 1 (0.01*(val<=7.0)+0.001*(val>7.0)) Cp Champ_Uniforme 1 0.5 } @@ -88,7 +88,7 @@ Read pb { diffusion { } initial_conditions { - temperature Champ_fonc_xyz Mesh_dom 1 (((x-0)*(x-0)+(y-0)*(y-0))_LT_0.04)*20. + temperature Champ_fonc_xyz Mesh_dom 1 ((((x-0)*(x-0)+(y-0)*(y-0))<0.04)*20.) } boundary_conditions { Bords_Z paroi_adiabatique @@ -97,7 +97,7 @@ Read pb correction_variable_initiale 1 sources { - puissance_thermique champ_fonc_fonction pb temperature 1 (1*(val_GT_7.)) , + puissance_thermique champ_fonc_fonction pb temperature 1 (1*(val>7.)) , Source_PDF { aire Champ_Fonc_MED { @@ -121,7 +121,7 @@ Read pb eta 1.0e-10 bilan_PDF 0 # variable_imposee_data champ_uniforme 1 7. # - variable_imposee_fonction 1 (((x*x)+(y*y))_LE_(0.5*0.5))*7.0 + variable_imposee_fonction 1 ((((x*x)+(y*y))<=(0.5*0.5))*7.0) } interpolation Interpolation_IBM_element_fluide { diff --git a/tests/Reference/muscl_new/muscl_new.data b/tests/Reference/muscl_new/muscl_new.data index 9bf55bb361..c55612db0a 100644 --- a/tests/Reference/muscl_new/muscl_new.data +++ b/tests/Reference/muscl_new/muscl_new.data @@ -86,7 +86,7 @@ Read pb EST paroi_adiabatique } initial_conditions { - temperature champ_fonc_xyz dom 1 cos(sqrt(x^2+(y+0.6)^2)/0.25)*(sqrt(x^2+(y+0.6)^2)<0.25) + temperature champ_fonc_xyz dom 1 (cos(sqrt(x^2+(y+0.6)^2)/0.25)*(sqrt(x^2+(y+0.6)^2)<0.25)) } } diff --git a/tests/Reference/upwind/upwind.data b/tests/Reference/upwind/upwind.data index e5b7d80cc7..e295ff328c 100644 --- a/tests/Reference/upwind/upwind.data +++ b/tests/Reference/upwind/upwind.data @@ -204,7 +204,7 @@ Read pb } } } -EcritureLectureSpecial 1 +EcritureLectureSpecial EcrFicPartageBin # On doit trouver les resultantes des forces de pression et visqueuses exercees par le fluide sur la frontiere Obstacle positives # # On doit trouver le moment des forces de pression et visqueuses exercees par le fluide sur la frontiere Obstacle positifs # Calculer_moments dom centre_de_gravite 0.00 0.22 diff --git a/tests/Turbulence/EF_stab_Turb_Null/EF_stab_Turb_Null.data b/tests/Turbulence/EF_stab_Turb_Null/EF_stab_Turb_Null.data index f46737ca06..7403584b0d 100644 --- a/tests/Turbulence/EF_stab_Turb_Null/EF_stab_Turb_Null.data +++ b/tests/Turbulence/EF_stab_Turb_Null/EF_stab_Turb_Null.data @@ -80,7 +80,7 @@ Lire pb Navier_Stokes_Turbulent { - equation_non_resolue t<10000000 + equation_non_resolue (t<10000000) solveur_pression petsc cholesky { } solveur_bar GCP { @@ -115,7 +115,7 @@ Lire pb } conditions_initiales { Temperature Champ_Fonc_xyz dom 1 - (x>0.4)*(x<0.6)*(y>0.4)*(y<0.6) + ((x>0.4)*(x<0.6)*(y>0.4)*(y<0.6)) } modele_turbulence null { } diff --git a/tests/Turbulence/Quasi_Comp_Coupl_Incomp/Quasi_Comp_Coupl_Incomp.data b/tests/Turbulence/Quasi_Comp_Coupl_Incomp/Quasi_Comp_Coupl_Incomp.data index 6112a28fed..3ce6097977 100644 --- a/tests/Turbulence/Quasi_Comp_Coupl_Incomp/Quasi_Comp_Coupl_Incomp.data +++ b/tests/Turbulence/Quasi_Comp_Coupl_Incomp/Quasi_Comp_Coupl_Incomp.data @@ -128,7 +128,7 @@ Lire pb_boite Canal_perio { bord periox } , Source_qdm_lambdaup { lambda 2. } } - conditions_initiales { vitesse champ_fonc_xyz dom_boite 3 3.73024 60.*(1.-rnd(1)) 60.*(1.-rnd(1)) } + conditions_initiales { vitesse champ_fonc_xyz dom_boite 3 (3.73024) (60.*(1.-rand(1.))) (60.*(1.-rand(1.))) } boundary_conditions { periox periodique diff --git a/tests/Turbulence/Quasi_Comp_Coupl_Incomp/prepare.data b/tests/Turbulence/Quasi_Comp_Coupl_Incomp/prepare.data index 6842c458b7..b787bfb436 100644 --- a/tests/Turbulence/Quasi_Comp_Coupl_Incomp/prepare.data +++ b/tests/Turbulence/Quasi_Comp_Coupl_Incomp/prepare.data @@ -122,7 +122,7 @@ Lire pb_boite diffusion { standard defaut_bar } Sources { Canal_perio { bord periox } } Sources { Source_qdm_lambdaup { lambda 2. } } - conditions_initiales { vitesse champ_fonc_xyz dom_boite 3 3.73024 60.*(1.-rnd(1)) 60.*(1.-rnd(1)) } + conditions_initiales { vitesse champ_fonc_xyz dom_boite 3 3.73024 60.*(1.-rand(1.)) 60.*(1.-rand(1.)) } boundary_conditions { periox periodique diff --git a/tests/Turbulence/THI_VEF/THI_VEF.data b/tests/Turbulence/THI_VEF/THI_VEF.data index 072ef5c88e..f89e7cbd3f 100644 --- a/tests/Turbulence/THI_VEF/THI_VEF.data +++ b/tests/Turbulence/THI_VEF/THI_VEF.data @@ -107,9 +107,9 @@ Lire pb diffusion { standard defaut_bar } conditions_initiales { vitesse Champ_fonc_xyz dom 3 - 1.0*sin(y)+1.5*sin(2*(y+1))+1.0*sin(3*(y+1))+0.5*sin(4*(y+1)) - 1.5*sin(z)+1.0*sin(2*(z+1))+1.0*sin(3*(z+1))+0.5*sin(4*(z+1)) - 1.0*sin(x)+1.0*sin(2*(x+1))+1.5*sin(3*(x+1))+0.5*sin(4*(x+1)) + (1.0*sin(y)+1.5*sin(2*(y+1))+1.0*sin(3*(y+1))+0.5*sin(4*(y+1))) + (1.5*sin(z)+1.0*sin(2*(z+1))+1.0*sin(3*(z+1))+0.5*sin(4*(z+1))) + (1.0*sin(x)+1.0*sin(2*(x+1))+1.5*sin(3*(x+1))+0.5*sin(4*(x+1))) } boundary_conditions { diff --git a/tests/UnitTests/unit_array.cpp b/tests/UnitTests/unit_array.cpp index 8cd3ef7d77..73577de9ce 100644 --- a/tests/UnitTests/unit_array.cpp +++ b/tests/UnitTests/unit_array.cpp @@ -352,34 +352,6 @@ TEST(TRUSTTab, dim_int) { EXPECT_EQ(d1_, 3); } - -TEST(TRUSTArray, reshape) { - - IntTab a1(12); - - const int * ptr = a1.addr(); - - a1.reshape(6,2); - - EXPECT_NE(a1.get_mem(), nullptr); - EXPECT_EQ(a1.get_span().data(), a1.get_mem()->data()); - EXPECT_EQ(a1.get_data_location(), DataLocation::HostOnly); - EXPECT_EQ(a1.size_array(), 12); - - // Reshape down does not reallocate: - EXPECT_EQ(a1.addr(), ptr); - - a1.reshape(3,2,2); - - EXPECT_NE(a1.get_mem(), nullptr); - EXPECT_EQ(a1.get_span().data(), a1.get_mem()->data()); - EXPECT_EQ(a1.get_data_location(), DataLocation::HostOnly); - EXPECT_EQ(a1.size_array(), 12); - - // Reshape down does not reallocate: - EXPECT_EQ(a1.addr(), ptr); -} - TEST(MDVector, dump_restore) { MD_Vector md; MD_Vector_seq mdvs(6); diff --git a/tests/Verification/Abort_timestep_jdd1/Abort_timestep_jdd1.data b/tests/Verification/Abort_timestep_jdd1/Abort_timestep_jdd1.data index 65211a763b..24c4e4621b 100644 --- a/tests/Verification/Abort_timestep_jdd1/Abort_timestep_jdd1.data +++ b/tests/Verification/Abort_timestep_jdd1/Abort_timestep_jdd1.data @@ -163,8 +163,8 @@ Read pb1 } sources { Perte_Charge_isotrope { - diam_hydr champ_fonc_txyz dom_fluid 1 1.4-1.3908*(y]1)*(y[3) - lambda 4*((16/Re)$(0.079/(Re^0.25))$0.003) + diam_hydr champ_fonc_txyz dom_fluid 1 (1.4-1.3908*(y>=1)*(y<=3)) + lambda (4*((16/Re) max (0.079/(Re^0.25)) max 0.003)) } } @@ -187,7 +187,7 @@ Read pb1 sources { - Puissance_thermique champ_fonc_xyz dom_fluid 1 2400e6*2/3./10./(3*3.1416*0.7*0.7)*0.6/1.8*1.53*(y]1)*(y[3) + Puissance_thermique champ_fonc_xyz dom_fluid 1 (2400e6*2/3./10./(3*3.1416*0.7*0.7)*0.6/1.8*1.53*(y>=1)*(y<=3)) } diff --git a/tests/Verification/Abort_timestep_jdd2/Abort_timestep_jdd2.data b/tests/Verification/Abort_timestep_jdd2/Abort_timestep_jdd2.data index 9a278b6c51..0849fe2404 100644 --- a/tests/Verification/Abort_timestep_jdd2/Abort_timestep_jdd2.data +++ b/tests/Verification/Abort_timestep_jdd2/Abort_timestep_jdd2.data @@ -166,8 +166,8 @@ Read pb1 } sources { Perte_Charge_isotrope { - diam_hydr champ_fonc_txyz dom_fluid 1 1.4-1.3908*(y]1)*(y[3) - lambda 4*((16/Re)$(0.079/(Re^0.25))$0.003) + diam_hydr champ_fonc_txyz dom_fluid 1 (1.4-1.3908*(y>=1)*(y<=3)) + lambda (4*((16/Re) max (0.079/(Re^0.25)) max 0.003)) } } @@ -191,7 +191,7 @@ Read pb1 sources { - Puissance_thermique champ_fonc_xyz dom_fluid 1 2400e6*2/3./10./(3*3.1416*0.7*0.7)*0.6/1.8*1.53*(y]1)*(y[3) + Puissance_thermique champ_fonc_xyz dom_fluid 1 (2400e6*2/3./10./(3*3.1416*0.7*0.7)*0.6/1.8*1.53*(y>=1)*(y<=3)) } diff --git a/tests/Verification/Champ_front_xyz_debit_jdd3/Champ_front_xyz_debit_jdd3.data b/tests/Verification/Champ_front_xyz_debit_jdd3/Champ_front_xyz_debit_jdd3.data index 00b18445a4..3fa203fee4 100644 --- a/tests/Verification/Champ_front_xyz_debit_jdd3/Champ_front_xyz_debit_jdd3.data +++ b/tests/Verification/Champ_front_xyz_debit_jdd3/Champ_front_xyz_debit_jdd3.data @@ -85,7 +85,7 @@ Read pb Inlet frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 Outlet frontiere_ouverte_vitesse_imposee champ_front_xyz_debit { flow_rate champ_front_uniforme 1 2.5 - velocity_profil champ_front_fonc_xyz 2 0*(y<0.5)-0.25*(y_GE_0.5)*(y_LT_1)-0.75*(y_GE_1)*(y_LT_1.5)-0.5*(y_GE_1.5)*(y_LT_2) 2 + velocity_profil champ_front_fonc_xyz 2 0*(y<0.5)-0.25*(y>=0.5)*(y<1)-0.75*(y>=1)*(y<1.5)-0.5*(y>=1.5)*(y<2) 2 } } } diff --git a/tests/Verification/EF_Eclt_coude_Genepi2_jdd1/EF_Eclt_coude_Genepi2_jdd1.data b/tests/Verification/EF_Eclt_coude_Genepi2_jdd1/EF_Eclt_coude_Genepi2_jdd1.data index 95454569a2..fb6417e4f9 100644 --- a/tests/Verification/EF_Eclt_coude_Genepi2_jdd1/EF_Eclt_coude_Genepi2_jdd1.data +++ b/tests/Verification/EF_Eclt_coude_Genepi2_jdd1/EF_Eclt_coude_Genepi2_jdd1.data @@ -22,7 +22,7 @@ Mailler dom } } -transformer dom (1.+x)*cos(0.3141592653589793E1*y/2.) (1.+x)*sin(0.3141592653589793E1*y/2.) +transformer dom ((1.+x)*cos(0.3141592653589793E1*y/2.)) ((1.+x)*sin(0.3141592653589793E1*y/2.)) EF dis @@ -62,11 +62,11 @@ Read pb convection { negligeable } diffusion { } initial_conditions { - vitesse Champ_Fonc_XYZ dom 2 (-(8.0*ln(2.0)*x*x+8.0*ln(2.0)*y*y-8.0*ln(2.0)-3.0*ln(x*x+y*y)*x*x-3.0*ln(x*x+y*y)*y*y)*sqrt(y*y/(x*x+y*y))/sqrt(x*x+y*y)/ln(2.0)/8.0) ((8.0*ln(2.0)*x*x+8.0*ln(2.0)*y*y-8.0*ln(2.0)-3.0*ln(x*x+y*y)*x*x-3.0*ln(x*x+y*y)*y*y)*x/(x*x+y*y)/ln(2.0)/8.0) + vitesse Champ_Fonc_XYZ dom 2 ((-(8.0*ln(2.0)*x*x+8.0*ln(2.0)*y*y-8.0*ln(2.0)-3.0*ln(x*x+y*y)*x*x-3.0*ln(x*x+y*y)*y*y)*sqrt(y*y/(x*x+y*y))/sqrt(x*x+y*y)/ln(2.0)/8.0)) (((8.0*ln(2.0)*x*x+8.0*ln(2.0)*y*y-8.0*ln(2.0)-3.0*ln(x*x+y*y)*x*x-3.0*ln(x*x+y*y)*y*y)*x/(x*x+y*y)/ln(2.0)/8.0)) } boundary_conditions { Bas frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 (0.) (0.1183687798)*(x>1.01)*(x<1.99) + Champ_Front_Fonc_tXYZ 2 (0.) ((0.1183687798)*(x>1.01)*(x<1.99)) Gauche frontiere_ouverte_vitesse_imposee Champ_Front_Uniforme 2 0. 0. Droit frontiere_ouverte_vitesse_imposee diff --git a/tests/Verification/EF_Eclt_coude_frottement_jdd2/EF_Eclt_coude_frottement_jdd2.data b/tests/Verification/EF_Eclt_coude_frottement_jdd2/EF_Eclt_coude_frottement_jdd2.data index e294ea6308..b3d39ad635 100644 --- a/tests/Verification/EF_Eclt_coude_frottement_jdd2/EF_Eclt_coude_frottement_jdd2.data +++ b/tests/Verification/EF_Eclt_coude_frottement_jdd2/EF_Eclt_coude_frottement_jdd2.data @@ -61,17 +61,17 @@ Read pb } convection { negligeable } diffusion { negligeable } - sources { source_qdm Champ_Fonc_XYZ dom 2 1000.*(y/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.) 1000.*(-x/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.) } + sources { source_qdm Champ_Fonc_XYZ dom 2 (1000.*(y/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.)) (1000.*(-x/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.)) } initial_conditions { - vitesse Champ_Fonc_XYZ dom 2 10.*(-y/sqrt(x*x+y*y)) 10.*(x/sqrt(x*x+y*y)) + vitesse Champ_Fonc_XYZ dom 2 (10.*(-y/sqrt(x*x+y*y))) (10.*(x/sqrt(x*x+y*y))) } boundary_conditions { Gauche frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y/sqrt(x*x+y*y)) 10.*(x/sqrt(x*x+y*y)) + Champ_Front_Fonc_tXYZ 2 (10.*(-y/sqrt(x*x+y*y))) (10.*(x/sqrt(x*x+y*y))) Droit frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y/sqrt(x*x+y*y)) 10.*(x/sqrt(x*x+y*y)) + Champ_Front_Fonc_tXYZ 2 (10.*(-y/sqrt(x*x+y*y))) (10.*(x/sqrt(x*x+y*y))) Bas frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 (0.) 10.*(1.) + Champ_Front_Fonc_tXYZ 2 (0.) (10.*(1.)) Haut frontiere_ouverte_pression_imposee Champ_Front_Uniforme 1 0. } diff --git a/tests/Verification/EF_Eclt_coude_frottement_jdd3/EF_Eclt_coude_frottement_jdd3.data b/tests/Verification/EF_Eclt_coude_frottement_jdd3/EF_Eclt_coude_frottement_jdd3.data index e40046d1b9..7cec35a661 100644 --- a/tests/Verification/EF_Eclt_coude_frottement_jdd3/EF_Eclt_coude_frottement_jdd3.data +++ b/tests/Verification/EF_Eclt_coude_frottement_jdd3/EF_Eclt_coude_frottement_jdd3.data @@ -22,7 +22,7 @@ Mailler dom } } -transformer dom (1.+x)*cos(0.3141592653589793E1*y/2.) (1.+x)*sin(0.3141592653589793E1*y/2.) +transformer dom ((1.+x)*cos(0.3141592653589793E1*y/2.)) ((1.+x)*sin(0.3141592653589793E1*y/2.)) EF dis @@ -61,17 +61,17 @@ Read pb } convection { negligeable } diffusion { negligeable } - sources { source_qdm Champ_Fonc_XYZ dom 2 1000.*(y/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.) 1000.*(-x/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.) } + sources { source_qdm Champ_Fonc_XYZ dom 2 (1000.*(y/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.)) (1000.*(-x/sqrt(x*x+y*y)/sqrt(x*x+y*y)/2.)) } initial_conditions { - vitesse Champ_Fonc_XYZ dom 2 10.*(-y) 10.*(x) + vitesse Champ_Fonc_XYZ dom 2 (-10.*(y)) (10.*(x)) } boundary_conditions { Gauche frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y) 10.*(x) + Champ_Front_Fonc_tXYZ 2 (-10.*(y)) (10.*(x)) Droit frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y) 10.*(x) + Champ_Front_Fonc_tXYZ 2 (-10.*(y)) (10.*(x)) Bas frontiere_ouverte_vitesse_imposee - Champ_Front_Fonc_tXYZ 2 10.*(-y) 10.*(x) + Champ_Front_Fonc_tXYZ 2 (-10.*(y)) (10.*(x)) Haut frontiere_ouverte_pression_imposee Champ_Front_Uniforme 1 0. } diff --git a/tests/Verification/EF_Eclt_coude_pression_3D_jdd1/EF_Eclt_coude_pression_3D_jdd1.data b/tests/Verification/EF_Eclt_coude_pression_3D_jdd1/EF_Eclt_coude_pression_3D_jdd1.data index 7f3965253e..e68a81208b 100644 --- a/tests/Verification/EF_Eclt_coude_pression_3D_jdd1/EF_Eclt_coude_pression_3D_jdd1.data +++ b/tests/Verification/EF_Eclt_coude_pression_3D_jdd1/EF_Eclt_coude_pression_3D_jdd1.data @@ -24,7 +24,7 @@ Mailler dom } } -transformer dom (1.+x)*cos(0.3141592653589793E1*y/2.) (1.+x)*sin(0.3141592653589793E1*y/2.) z +transformer dom ((1.+x)*cos(0.3141592653589793E1*y/2.)) ((1.+x)*sin(0.3141592653589793E1*y/2.)) z EF dis diff --git a/tests/Verification/Incorrect_syntax/Incorrect_syntax.data b/tests/Verification/Incorrect_syntax/Incorrect_syntax.data new file mode 100644 index 0000000000..0d2f0037f5 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/Incorrect_syntax.data @@ -0,0 +1,2 @@ +# do nothing # +End diff --git a/tests/Verification/Incorrect_syntax/Incorrect_syntax.lml.gz b/tests/Verification/Incorrect_syntax/Incorrect_syntax.lml.gz new file mode 100644 index 0000000000..e69de29bb2 diff --git a/tests/Verification/Incorrect_syntax/circular_include.data b/tests/Verification/Incorrect_syntax/circular_include.data new file mode 100644 index 0000000000..67b5ecbfd9 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/circular_include.data @@ -0,0 +1,2 @@ + +#include circular_include.data diff --git a/tests/Verification/Incorrect_syntax/end_of_file_in_comment_1.data b/tests/Verification/Incorrect_syntax/end_of_file_in_comment_1.data new file mode 100644 index 0000000000..25972179b0 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/end_of_file_in_comment_1.data @@ -0,0 +1,3 @@ + + +# this is the start of a comment that never end diff --git a/tests/Verification/Incorrect_syntax/end_of_file_in_comment_2.data b/tests/Verification/Incorrect_syntax/end_of_file_in_comment_2.data new file mode 100644 index 0000000000..397c633a9e --- /dev/null +++ b/tests/Verification/Incorrect_syntax/end_of_file_in_comment_2.data @@ -0,0 +1,3 @@ + + +/* this is the start of a comment that never end diff --git a/tests/Verification/Incorrect_syntax/end_of_file_in_expression.data b/tests/Verification/Incorrect_syntax/end_of_file_in_expression.data new file mode 100644 index 0000000000..182d62a1da --- /dev/null +++ b/tests/Verification/Incorrect_syntax/end_of_file_in_expression.data @@ -0,0 +1,3 @@ + + +(1 + 4 * (32 diff --git a/tests/Verification/Incorrect_syntax/end_of_file_in_literal_string.data b/tests/Verification/Incorrect_syntax/end_of_file_in_literal_string.data new file mode 100644 index 0000000000..e4d6646222 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/end_of_file_in_literal_string.data @@ -0,0 +1 @@ +system "this is a never ending literal string diff --git a/tests/Verification/Incorrect_syntax/invalid_define_1.data b/tests/Verification/Incorrect_syntax/invalid_define_1.data new file mode 100644 index 0000000000..133ec6d21b --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_define_1.data @@ -0,0 +1,2 @@ +# end of file before the end of the define # +#define diff --git a/tests/Verification/Incorrect_syntax/invalid_define_2.data b/tests/Verification/Incorrect_syntax/invalid_define_2.data new file mode 100644 index 0000000000..80d6fd791e --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_define_2.data @@ -0,0 +1,2 @@ +# end of file before the end of the define # +#define variable diff --git a/tests/Verification/Incorrect_syntax/invalid_include.data b/tests/Verification/Incorrect_syntax/invalid_include.data new file mode 100644 index 0000000000..db67a2bb8d --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_include.data @@ -0,0 +1,2 @@ +# End-of-file before specifying the name of file to include # +#include diff --git a/tests/Verification/Incorrect_syntax/invalid_operand_sequence.data b/tests/Verification/Incorrect_syntax/invalid_operand_sequence.data new file mode 100644 index 0000000000..33aeeeda6c --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_operand_sequence.data @@ -0,0 +1 @@ +(1 + (2) 3) diff --git a/tests/Verification/Incorrect_syntax/invalid_operator_sequence_1.data b/tests/Verification/Incorrect_syntax/invalid_operator_sequence_1.data new file mode 100644 index 0000000000..663b1d3d27 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_operator_sequence_1.data @@ -0,0 +1,2 @@ + +(1 + *4) diff --git a/tests/Verification/Incorrect_syntax/invalid_operator_sequence_2.data b/tests/Verification/Incorrect_syntax/invalid_operator_sequence_2.data new file mode 100644 index 0000000000..c9afa6ae4c --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_operator_sequence_2.data @@ -0,0 +1,2 @@ + +(1 --+ 4) diff --git a/tests/Verification/Incorrect_syntax/invalid_parenthesis_1.data b/tests/Verification/Incorrect_syntax/invalid_parenthesis_1.data new file mode 100644 index 0000000000..51b185eca7 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_parenthesis_1.data @@ -0,0 +1 @@ +(1 + 3(4 * 5)) diff --git a/tests/Verification/Incorrect_syntax/invalid_parenthesis_2.data b/tests/Verification/Incorrect_syntax/invalid_parenthesis_2.data new file mode 100644 index 0000000000..d82a321318 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_parenthesis_2.data @@ -0,0 +1 @@ +(1 + 2 * (3+) + 4) diff --git a/tests/Verification/Incorrect_syntax/invalid_parenthesis_in_expression_1.data b/tests/Verification/Incorrect_syntax/invalid_parenthesis_in_expression_1.data new file mode 100644 index 0000000000..ae564f2f27 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_parenthesis_in_expression_1.data @@ -0,0 +1 @@ +(1 + (2 * 3)(4)) diff --git a/tests/Verification/Incorrect_syntax/invalid_parenthesis_in_expression_2.data b/tests/Verification/Incorrect_syntax/invalid_parenthesis_in_expression_2.data new file mode 100644 index 0000000000..4cbc49b110 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_parenthesis_in_expression_2.data @@ -0,0 +1 @@ +(1 + ()) diff --git a/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_1.data b/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_1.data new file mode 100644 index 0000000000..d7bd2b345b --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_1.data @@ -0,0 +1,3 @@ + +# the unknown 'x' (as 'y', 'z', 'X', 'Y', 'Z', 't' and 'T') is reserve # +#define x 3 diff --git a/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_2.data b/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_2.data new file mode 100644 index 0000000000..d76f46688c --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_2.data @@ -0,0 +1,2 @@ +#define TEST_CONSTANT 32 +#define TEST_CONSTANT 74 diff --git a/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_3.data b/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_3.data new file mode 100644 index 0000000000..3c125637ea --- /dev/null +++ b/tests/Verification/Incorrect_syntax/invalid_reserved_keyword_3.data @@ -0,0 +1 @@ +#define Pave 24 diff --git a/tests/Verification/Incorrect_syntax/list_tests.txt b/tests/Verification/Incorrect_syntax/list_tests.txt new file mode 100644 index 0000000000..ba0fbd9c1b --- /dev/null +++ b/tests/Verification/Incorrect_syntax/list_tests.txt @@ -0,0 +1,23 @@ +circular_include +end_of_file_in_comment_1 +end_of_file_in_comment_2 +end_of_file_in_expression +end_of_file_in_literal_string +invalid_define_1 +invalid_define_2 +invalid_include +invalid_operand_sequence +invalid_operator_sequence_1 +invalid_operator_sequence_2 +invalid_parenthesis_1 +invalid_parenthesis_2 +invalid_parenthesis_in_expression_1 +invalid_parenthesis_in_expression_2 +invalid_reserved_keyword_1 +invalid_reserved_keyword_2 +invalid_reserved_keyword_3 +list_tests.txt +macro_in_expression +string_literal_in_expression +unclosed_curly_bracket +unopened_curly_bracket diff --git a/tests/Verification/Incorrect_syntax/macro_in_expression.data b/tests/Verification/Incorrect_syntax/macro_in_expression.data new file mode 100644 index 0000000000..1f9937590a --- /dev/null +++ b/tests/Verification/Incorrect_syntax/macro_in_expression.data @@ -0,0 +1,2 @@ + +(1 + #define variable 8) diff --git a/tests/Verification/Incorrect_syntax/string_literal_in_expression.data b/tests/Verification/Incorrect_syntax/string_literal_in_expression.data new file mode 100644 index 0000000000..c670cf05e5 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/string_literal_in_expression.data @@ -0,0 +1,2 @@ + +(1 + "this is a test") diff --git a/tests/Verification/Incorrect_syntax/unclosed_curly_bracket.data b/tests/Verification/Incorrect_syntax/unclosed_curly_bracket.data new file mode 100644 index 0000000000..46c810827d --- /dev/null +++ b/tests/Verification/Incorrect_syntax/unclosed_curly_bracket.data @@ -0,0 +1,4 @@ +domaine dom +{ + + diff --git a/tests/Verification/Incorrect_syntax/unopened_curly_bracket.data b/tests/Verification/Incorrect_syntax/unopened_curly_bracket.data new file mode 100644 index 0000000000..b3d25d0a34 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/unopened_curly_bracket.data @@ -0,0 +1,6 @@ +domaine dom +{ + +}} + + diff --git a/tests/Verification/Incorrect_syntax/verifie b/tests/Verification/Incorrect_syntax/verifie new file mode 100755 index 0000000000..3b052e2076 --- /dev/null +++ b/tests/Verification/Incorrect_syntax/verifie @@ -0,0 +1,15 @@ +#!/bin/bash + +# verify if the tests in list_tests all failed +for file in $(cat list_tests.txt) +do + trust ${file} 1>${file}.out 2>${file}.err + status=$? + if [ $status -eq 0 ] + then + echo Test case ${file} should have produced an error. + exit 1 + fi +done + +exit 0 diff --git a/tests/Verification/Inward_field_jdd15/Inward_field_jdd15.data b/tests/Verification/Inward_field_jdd15/Inward_field_jdd15.data index 7d88718e0c..4668103abf 100644 --- a/tests/Verification/Inward_field_jdd15/Inward_field_jdd15.data +++ b/tests/Verification/Inward_field_jdd15/Inward_field_jdd15.data @@ -25,8 +25,8 @@ Mailler dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) z -Transformer dom x*cos(pi/4)+z*sin(pi/4) y -x*sin(pi/4)+z*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) z +Transformer dom (x*cos(pi/4)+z*sin(pi/4)) y (-x*sin(pi/4)+z*cos(pi/4)) # END MESH # @@ -78,10 +78,10 @@ Read pb initial_conditions { vitesse champ_uniforme 3 0. 0. 0. } boundary_conditions { - Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1./2 sqrt(1./2) -1./2 - Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1./2 sqrt(1./2) -1./2 - Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1./2 sqrt(1./2) -1./2 - Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1./2 sqrt(1./2) -1./2 + Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1./2) (sqrt(1./2)) (-1./2) + Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1./2) (sqrt(1./2)) (-1./2) + Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1./2) (sqrt(1./2)) (-1./2) + Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1./2) (sqrt(1./2)) (-1./2) Top frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 Bottom frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 } } @@ -117,7 +117,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Bottom nom_frontiere Bottom methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 3 1./2 sqrt(1./2) -1./2 localisation Faces } + true_vector Transformation { methode vecteur expression 3 (1./2) (sqrt(1./2)) (-1./2) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd16/Inward_field_jdd16.data b/tests/Verification/Inward_field_jdd16/Inward_field_jdd16.data index 37aff151f7..5d0cb841fd 100644 --- a/tests/Verification/Inward_field_jdd16/Inward_field_jdd16.data +++ b/tests/Verification/Inward_field_jdd16/Inward_field_jdd16.data @@ -25,8 +25,8 @@ Mailler dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) z -Transformer dom x*cos(pi/4)+z*sin(pi/4) y -x*sin(pi/4)+z*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) z +Transformer dom (x*cos(pi/4)+z*sin(pi/4)) y (-x*sin(pi/4)+z*cos(pi/4)) # END MESH # @@ -78,12 +78,12 @@ Read pb initial_conditions { vitesse champ_uniforme 3 0. 0. 0. } boundary_conditions { - Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1./2) 0 -sqrt(1./2) - Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1./2) 0 -sqrt(1./2) + Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1./2)) 0 (-sqrt(1./2)) + Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1./2)) 0 (-sqrt(1./2)) Left frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 Right frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 } - Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1./2) 0 -sqrt(1./2) - Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -sqrt(1./2) 0 -sqrt(1./2) + Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1./2)) 0 (-sqrt(1./2)) + Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-sqrt(1./2)) 0 (-sqrt(1./2)) } } @@ -117,7 +117,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Right nom_frontiere Right methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 3 -sqrt(1./2) 0 -sqrt(1./2) localisation Faces } + true_vector Transformation { methode vecteur expression 3 (-sqrt(1./2)) 0 (-sqrt(1./2)) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd17/Inward_field_jdd17.data b/tests/Verification/Inward_field_jdd17/Inward_field_jdd17.data index f57c82897d..2bee43bb46 100644 --- a/tests/Verification/Inward_field_jdd17/Inward_field_jdd17.data +++ b/tests/Verification/Inward_field_jdd17/Inward_field_jdd17.data @@ -25,8 +25,8 @@ Mailler dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) z -Transformer dom x*cos(pi/4)+z*sin(pi/4) y -x*sin(pi/4)+z*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) z +Transformer dom (x*cos(pi/4)+z*sin(pi/4)) y (-x*sin(pi/4)+z*cos(pi/4)) # END MESH # @@ -78,10 +78,10 @@ Read pb initial_conditions { vitesse champ_uniforme 3 0. 0. 0. } boundary_conditions { - Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5./2 -5*sqrt(1./2) 5./2 - Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5./2 -5*sqrt(1./2) 5./2 - Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5./2 -5*sqrt(1./2) 5./2 - Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -5./2 -5*sqrt(1./2) 5./2 + Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5./2) (-5*sqrt(1./2)) (5./2) + Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5./2) (-5*sqrt(1./2)) (5./2) + Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5./2) (-5*sqrt(1./2)) (5./2) + Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-5./2) (-5*sqrt(1./2)) (5./2) Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 5.0 } Bottom frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 } @@ -117,7 +117,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Top nom_frontiere Top methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 3 -5./2 -5*sqrt(1./2) 5./2 localisation Faces } + true_vector Transformation { methode vecteur expression 3 (-5./2) (-5*sqrt(1./2)) (5./2) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd18/Inward_field_jdd18.data b/tests/Verification/Inward_field_jdd18/Inward_field_jdd18.data index cd110a04b6..88becf2f2b 100644 --- a/tests/Verification/Inward_field_jdd18/Inward_field_jdd18.data +++ b/tests/Verification/Inward_field_jdd18/Inward_field_jdd18.data @@ -25,8 +25,8 @@ Mailler dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) z -Transformer dom x*cos(pi/4)+z*sin(pi/4) y -x*sin(pi/4)+z*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) z +Transformer dom (x*cos(pi/4)+z*sin(pi/4)) y (-x*sin(pi/4)+z*cos(pi/4)) # END MESH # @@ -78,12 +78,12 @@ Read pb initial_conditions { vitesse champ_uniforme 3 0. 0. 0. } boundary_conditions { - Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1./2) 0 sqrt(1./2) - Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1./2) 0 sqrt(1./2) + Back Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1./2)) 0 (sqrt(1./2)) + Front Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1./2)) 0 (sqrt(1./2)) Left frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 } Right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 - Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1./2) 0 sqrt(1./2) - Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 sqrt(1./2) 0 sqrt(1./2) + Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1./2)) 0 (sqrt(1./2)) + Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (sqrt(1./2)) 0 (sqrt(1./2)) } } @@ -117,7 +117,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Left nom_frontiere Left methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 3 sqrt(1./2) 0 sqrt(1./2) localisation Faces } + true_vector Transformation { methode vecteur expression 3 (sqrt(1./2)) 0 (sqrt(1./2)) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd19/Inward_field_jdd19.data b/tests/Verification/Inward_field_jdd19/Inward_field_jdd19.data index 4a2e94dfcb..907e781389 100644 --- a/tests/Verification/Inward_field_jdd19/Inward_field_jdd19.data +++ b/tests/Verification/Inward_field_jdd19/Inward_field_jdd19.data @@ -25,8 +25,8 @@ Mailler dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) z -Transformer dom x*cos(pi/4)+z*sin(pi/4) y -x*sin(pi/4)+z*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) z +Transformer dom (x*cos(pi/4)+z*sin(pi/4)) y (-x*sin(pi/4)+z*cos(pi/4)) # END MESH # @@ -80,10 +80,10 @@ Read pb { Back frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 } Front frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 - Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1./2 -sqrt(1./2) -1./2 - Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1./2 -sqrt(1./2) -1./2 - Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1./2 -sqrt(1./2) -1./2 - Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 1./2 -sqrt(1./2) -1./2 + Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1./2) (-sqrt(1./2)) (-1./2) + Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1./2) (-sqrt(1./2)) (-1./2) + Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1./2) (-sqrt(1./2)) (-1./2) + Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (1./2) (-sqrt(1./2)) (-1./2) } } @@ -117,7 +117,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Back nom_frontiere Back methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 3 1./2 -sqrt(1./2) -1./2 localisation Faces } + true_vector Transformation { methode vecteur expression 3 (1./2) (-sqrt(1./2)) (-1./2) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd20/Inward_field_jdd20.data b/tests/Verification/Inward_field_jdd20/Inward_field_jdd20.data index 6d7f05dbbb..4ed71aa92b 100644 --- a/tests/Verification/Inward_field_jdd20/Inward_field_jdd20.data +++ b/tests/Verification/Inward_field_jdd20/Inward_field_jdd20.data @@ -25,8 +25,8 @@ Mailler dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) z -Transformer dom x*cos(pi/4)+z*sin(pi/4) y -x*sin(pi/4)+z*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) z +Transformer dom (x*cos(pi/4)+z*sin(pi/4)) y (-x*sin(pi/4)+z*cos(pi/4)) # END MESH # @@ -80,10 +80,10 @@ Read pb { Back frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 Front frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 } - Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1./2 sqrt(1./2) 1./2 - Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1./2 sqrt(1./2) 1./2 - Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1./2 sqrt(1./2) 1./2 - Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 -1./2 sqrt(1./2) 1./2 + Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1./2) (sqrt(1./2)) (1./2) + Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1./2) (sqrt(1./2)) (1./2) + Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1./2) (sqrt(1./2)) (1./2) + Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 3 (-1./2) (sqrt(1./2)) (1./2) } } @@ -117,7 +117,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Front nom_frontiere Front methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 3 -1./2 sqrt(1./2) 1./2 localisation Faces } + true_vector Transformation { methode vecteur expression 3 (-1./2) (sqrt(1./2)) (1./2) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd5/Inward_field_jdd5.data b/tests/Verification/Inward_field_jdd5/Inward_field_jdd5.data index 050d8969fa..f58710f6da 100644 --- a/tests/Verification/Inward_field_jdd5/Inward_field_jdd5.data +++ b/tests/Verification/Inward_field_jdd5/Inward_field_jdd5.data @@ -23,7 +23,7 @@ Trianguler_H dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) # END MESH # # BEGIN PARTITION @@ -75,8 +75,8 @@ Read pb { Left frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 } Right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 - Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 1./sqrt(2) -1./sqrt(2) - Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 1./sqrt(2) -1./sqrt(2) + Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (1./sqrt(2)) (-1./sqrt(2)) + Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (1./sqrt(2)) (-1./sqrt(2)) } } @@ -111,7 +111,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Left nom_frontiere Left methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 2 1./sqrt(2) -1./sqrt(2) localisation Faces } + true_vector Transformation { methode vecteur expression 2 (1./sqrt(2)) (-1./sqrt(2)) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd6/Inward_field_jdd6.data b/tests/Verification/Inward_field_jdd6/Inward_field_jdd6.data index 8276459b18..204f1e5d30 100644 --- a/tests/Verification/Inward_field_jdd6/Inward_field_jdd6.data +++ b/tests/Verification/Inward_field_jdd6/Inward_field_jdd6.data @@ -23,7 +23,7 @@ Trianguler_H dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) # END MESH # # BEGIN PARTITION @@ -75,8 +75,8 @@ Read pb { Left frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 Right frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 } - Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -1./sqrt(2) 1./sqrt(2) - Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -1./sqrt(2) 1./sqrt(2) + Top Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-1./sqrt(2)) (1./sqrt(2)) + Bottom Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-1./sqrt(2)) (1./sqrt(2)) } } @@ -111,7 +111,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Right nom_frontiere Right methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 2 -1./sqrt(2) 1./sqrt(2) localisation Faces } + true_vector Transformation { methode vecteur expression 2 (-1./sqrt(2)) (1./sqrt(2)) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd7/Inward_field_jdd7.data b/tests/Verification/Inward_field_jdd7/Inward_field_jdd7.data index 57f88b9f3e..5707d9f508 100644 --- a/tests/Verification/Inward_field_jdd7/Inward_field_jdd7.data +++ b/tests/Verification/Inward_field_jdd7/Inward_field_jdd7.data @@ -23,7 +23,7 @@ Trianguler_H dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) # END MESH # # BEGIN PARTITION @@ -73,8 +73,8 @@ Read pb initial_conditions { vitesse champ_uniforme 2 0. 0. } boundary_conditions { - Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -sqrt(12.5) -sqrt(12.5) - Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 -sqrt(12.5) -sqrt(12.5) + Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-sqrt(12.5)) (-sqrt(12.5)) + Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (-sqrt(12.5)) (-sqrt(12.5)) Top frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 5.0 } Bottom frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 } @@ -111,7 +111,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Top nom_frontiere Top methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 2 -sqrt(12.5) -sqrt(12.5) localisation Faces } + true_vector Transformation { methode vecteur expression 2 (-sqrt(12.5)) (-sqrt(12.5)) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Inward_field_jdd8/Inward_field_jdd8.data b/tests/Verification/Inward_field_jdd8/Inward_field_jdd8.data index c9aa22ea73..129bc44bfb 100644 --- a/tests/Verification/Inward_field_jdd8/Inward_field_jdd8.data +++ b/tests/Verification/Inward_field_jdd8/Inward_field_jdd8.data @@ -23,7 +23,7 @@ Trianguler_H dom /* rotation of angle theta : */ /* x -> x cos(theta) + y sin (theta) */ /* y -> -x sin(theta) + y cos (theta) */ -Transformer dom x*cos(pi/4)+y*sin(pi/4) -x*sin(pi/4)+y*cos(pi/4) +Transformer dom (x*cos(pi/4)+y*sin(pi/4)) (-x*sin(pi/4)+y*cos(pi/4)) # END MESH # # BEGIN PARTITION @@ -73,8 +73,8 @@ Read pb initial_conditions { vitesse champ_uniforme 2 0. 0. } boundary_conditions { - Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 sqrt(0.5) sqrt(0.5) - Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 sqrt(0.5) sqrt(0.5) + Left Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (sqrt(0.5)) (sqrt(0.5)) + Right Frontiere_ouverte_vitesse_imposee Champ_front_fonc_xyz 2 (sqrt(0.5)) (sqrt(0.5)) Top frontiere_ouverte_pression_imposee champ_front_uniforme 1 0.0 Bottom frontiere_ouverte_vitesse_imposee Boundary_field_inward { normal_value 1.0 } } @@ -111,7 +111,7 @@ Read pb # velocity given by Trio on the boundary # velocity_trio Extraction { Domaine boundary_Bottom nom_frontiere Bottom methode trace source refChamp { Pb_champ pb vitesse } } # we know what is the vector shape on the boundary # - true_vector Transformation { methode vecteur expression 2 sqrt(0.5) sqrt(0.5) localisation Faces } + true_vector Transformation { methode vecteur expression 2 (sqrt(0.5)) (sqrt(0.5)) localisation Faces } # all this stuff is to compute error between velocity_trio and true_vector # true_vector_interp Interpolation { localisation elem sources_reference { true_vector } } diff --git a/tests/Verification/Multistep_Methods_jdd1/Multistep_Methods_jdd1.data b/tests/Verification/Multistep_Methods_jdd1/Multistep_Methods_jdd1.data index dcbdc27aa7..01359d676e 100644 --- a/tests/Verification/Multistep_Methods_jdd1/Multistep_Methods_jdd1.data +++ b/tests/Verification/Multistep_Methods_jdd1/Multistep_Methods_jdd1.data @@ -99,7 +99,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Multistep_Methods_jdd2/Multistep_Methods_jdd2.data b/tests/Verification/Multistep_Methods_jdd2/Multistep_Methods_jdd2.data index 3815f078c9..578c2f6b54 100644 --- a/tests/Verification/Multistep_Methods_jdd2/Multistep_Methods_jdd2.data +++ b/tests/Verification/Multistep_Methods_jdd2/Multistep_Methods_jdd2.data @@ -95,7 +95,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Multistep_Methods_jdd3/Multistep_Methods_jdd3.data b/tests/Verification/Multistep_Methods_jdd3/Multistep_Methods_jdd3.data index f4414af044..787b8cd197 100644 --- a/tests/Verification/Multistep_Methods_jdd3/Multistep_Methods_jdd3.data +++ b/tests/Verification/Multistep_Methods_jdd3/Multistep_Methods_jdd3.data @@ -95,7 +95,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Multistep_Methods_jdd4/Multistep_Methods_jdd4.data b/tests/Verification/Multistep_Methods_jdd4/Multistep_Methods_jdd4.data index 415a697b72..2fc597c5ba 100644 --- a/tests/Verification/Multistep_Methods_jdd4/Multistep_Methods_jdd4.data +++ b/tests/Verification/Multistep_Methods_jdd4/Multistep_Methods_jdd4.data @@ -96,7 +96,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Multistep_Methods_jdd5/Multistep_Methods_jdd5.data b/tests/Verification/Multistep_Methods_jdd5/Multistep_Methods_jdd5.data index 46a2aed933..f21c7c4268 100644 --- a/tests/Verification/Multistep_Methods_jdd5/Multistep_Methods_jdd5.data +++ b/tests/Verification/Multistep_Methods_jdd5/Multistep_Methods_jdd5.data @@ -96,7 +96,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Multistep_Methods_jdd6/Multistep_Methods_jdd6.data b/tests/Verification/Multistep_Methods_jdd6/Multistep_Methods_jdd6.data index 0074c03e83..f0aeed5dc9 100644 --- a/tests/Verification/Multistep_Methods_jdd6/Multistep_Methods_jdd6.data +++ b/tests/Verification/Multistep_Methods_jdd6/Multistep_Methods_jdd6.data @@ -99,7 +99,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Multistep_Methods_jdd7/Multistep_Methods_jdd7.data b/tests/Verification/Multistep_Methods_jdd7/Multistep_Methods_jdd7.data index f2a6bbc64b..fc9f2cf5d7 100644 --- a/tests/Verification/Multistep_Methods_jdd7/Multistep_Methods_jdd7.data +++ b/tests/Verification/Multistep_Methods_jdd7/Multistep_Methods_jdd7.data @@ -99,7 +99,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Multistep_Methods_jdd8/Multistep_Methods_jdd8.data b/tests/Verification/Multistep_Methods_jdd8/Multistep_Methods_jdd8.data index 6cd5cee521..9ee88d1871 100644 --- a/tests/Verification/Multistep_Methods_jdd8/Multistep_Methods_jdd8.data +++ b/tests/Verification/Multistep_Methods_jdd8/Multistep_Methods_jdd8.data @@ -99,7 +99,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Multistep_Methods_jdd9/Multistep_Methods_jdd9.data b/tests/Verification/Multistep_Methods_jdd9/Multistep_Methods_jdd9.data index 43cf1fcc83..131c2e3be6 100644 --- a/tests/Verification/Multistep_Methods_jdd9/Multistep_Methods_jdd9.data +++ b/tests/Verification/Multistep_Methods_jdd9/Multistep_Methods_jdd9.data @@ -99,7 +99,7 @@ Navier_Stokes_standard max_v Reduction_0D { methode max source Transformation { - methode formule expression 1 abs(v) + methode formule expression 1 (abs(v)) source Transformation { methode composante numero 1 source refChamp { Pb_champ pb vitesse } diff --git a/tests/Verification/Pb_multi_vs_WC_QC_jdd3/Pb_multi_vs_WC_QC_jdd3.data b/tests/Verification/Pb_multi_vs_WC_QC_jdd3/Pb_multi_vs_WC_QC_jdd3.data index 179024972f..ce6b0f7fca 100644 --- a/tests/Verification/Pb_multi_vs_WC_QC_jdd3/Pb_multi_vs_WC_QC_jdd3.data +++ b/tests/Verification/Pb_multi_vs_WC_QC_jdd3/Pb_multi_vs_WC_QC_jdd3.data @@ -56,7 +56,7 @@ Read sch { pression_degeneree 0 criteres_convergence { alpha 1e-5 pression 1 vitesse 1 } - solveur petsc cholesky { quiet } + solveur petsc cli { } seuil_convergence_implicite 1e30 } } @@ -77,7 +77,7 @@ Read pb QDM_Multiphase { evanescence { homogene { alpha_res 1 alpha_res_min 0.5 } } - solveur_pression petsc cholesky { quiet } /* cli_quiet { -pc_type hypre -pc_hypre_type boomeramg } */ + solveur_pression petsc cli_quiet { -pc_type hypre -pc_hypre_type boomeramg } convection { amont } diffusion { } initial_conditions diff --git a/tests/Verification/PeChaReg_VEF_jdd5/PeChaReg_VEF_jdd5.data b/tests/Verification/PeChaReg_VEF_jdd5/PeChaReg_VEF_jdd5.data index 7ff227977d..2b1411b417 100644 --- a/tests/Verification/PeChaReg_VEF_jdd5/PeChaReg_VEF_jdd5.data +++ b/tests/Verification/PeChaReg_VEF_jdd5/PeChaReg_VEF_jdd5.data @@ -21,7 +21,7 @@ Mailler dom } } -transformer dom x-0.5 y-0.5 z +transformer dom (x-0.5) (y-0.5) z tetraedriser_homogene_fin dom # marqueur # diff --git a/tests/Verification/PeChaReg_VEF_jdd6/PeChaReg_VEF_jdd6.data b/tests/Verification/PeChaReg_VEF_jdd6/PeChaReg_VEF_jdd6.data index a4d305246b..f7a0aad37a 100644 --- a/tests/Verification/PeChaReg_VEF_jdd6/PeChaReg_VEF_jdd6.data +++ b/tests/Verification/PeChaReg_VEF_jdd6/PeChaReg_VEF_jdd6.data @@ -21,7 +21,7 @@ Mailler dom } } -transformer dom x-0.5 y-0.5 z +transformer dom (x-0.5) (y-0.5) z tetraedriser_homogene_fin dom # marqueur # diff --git a/tests/Verification/PeChaReg_VEF_jdd7/PeChaReg_VEF_jdd7.data b/tests/Verification/PeChaReg_VEF_jdd7/PeChaReg_VEF_jdd7.data index 38072835c2..4878d1629c 100644 --- a/tests/Verification/PeChaReg_VEF_jdd7/PeChaReg_VEF_jdd7.data +++ b/tests/Verification/PeChaReg_VEF_jdd7/PeChaReg_VEF_jdd7.data @@ -21,10 +21,10 @@ Mailler dom } } -transformer dom x-0.5 y-0.5 z +transformer dom (x-0.5) (y-0.5) z tetraedriser_homogene_fin dom -transformer dom (x+y)/sqrt(2) (x-y)/sqrt(2) z transformer dom x (y+z)/sqrt(2) (y-z)/sqrt(2) transformer dom (x+z)/sqrt(2) y (x-z)/sqrt(2) +transformer dom ((x+y)/sqrt(2)) ((x-y)/sqrt(2)) z transformer dom x ((y+z)/sqrt(2)) ((y-z)/sqrt(2)) transformer dom ((x+z)/sqrt(2)) y ((x-z)/sqrt(2)) Sous_zone zone_tout Associate zone_tout dom diff --git a/tests/Verification/Perte_Charge_Circulaire_VEF_jdd1/Perte_Charge_Circulaire_VEF_jdd1.data b/tests/Verification/Perte_Charge_Circulaire_VEF_jdd1/Perte_Charge_Circulaire_VEF_jdd1.data index 367f88b128..8510e6d0de 100644 --- a/tests/Verification/Perte_Charge_Circulaire_VEF_jdd1/Perte_Charge_Circulaire_VEF_jdd1.data +++ b/tests/Verification/Perte_Charge_Circulaire_VEF_jdd1/Perte_Charge_Circulaire_VEF_jdd1.data @@ -105,8 +105,8 @@ Read pb { Perte_charge_circulaire { diam_hydr champ_uniforme 1 0.01 diam_hydr_ortho champ_uniforme 1 0.02 - lambda 96/Re_tot*0+1.*(Re_long)^(-0.25) - lambda_ortho 96/Re_tot*0+2.*(Re_ortho)^(-0.27) + lambda (96/Re_tot*0+1.*(Re_long)^(-0.25)) + lambda_ortho (96/Re_tot*0+2.*(Re_ortho)^(-0.27)) sous_zone zone1 direction champ_uniforme 2 1 0 } diff --git a/tests/Verification/Perte_Charge_Circulaire_VEF_jdd2/Perte_Charge_Circulaire_VEF_jdd2.data b/tests/Verification/Perte_Charge_Circulaire_VEF_jdd2/Perte_Charge_Circulaire_VEF_jdd2.data index f416a8d5da..fb9d7c1431 100644 --- a/tests/Verification/Perte_Charge_Circulaire_VEF_jdd2/Perte_Charge_Circulaire_VEF_jdd2.data +++ b/tests/Verification/Perte_Charge_Circulaire_VEF_jdd2/Perte_Charge_Circulaire_VEF_jdd2.data @@ -105,8 +105,8 @@ Read pb { Perte_charge_circulaire { diam_hydr champ_uniforme 1 0.01 diam_hydr_ortho champ_uniforme 1 0.02 - lambda 96/Re_tot*0+1.*(Re_long)^(-0.25) - lambda_ortho 96/Re_tot*0+2.*(Re_ortho)^(-0.27) + lambda (96/Re_tot*0+1.*(Re_long)^(-0.25)) + lambda_ortho (96/Re_tot*0+2.*(Re_ortho)^(-0.27)) sous_zone zone1 direction champ_uniforme 2 0 1 } diff --git a/tests/Verification/Perte_Charge_Circulaire_VEF_jdd3/Perte_Charge_Circulaire_VEF_jdd3.data b/tests/Verification/Perte_Charge_Circulaire_VEF_jdd3/Perte_Charge_Circulaire_VEF_jdd3.data index 1207ed227d..aee0868dd5 100644 --- a/tests/Verification/Perte_Charge_Circulaire_VEF_jdd3/Perte_Charge_Circulaire_VEF_jdd3.data +++ b/tests/Verification/Perte_Charge_Circulaire_VEF_jdd3/Perte_Charge_Circulaire_VEF_jdd3.data @@ -105,8 +105,8 @@ Read pb { Perte_charge_circulaire { diam_hydr champ_uniforme 1 0.01 diam_hydr_ortho champ_uniforme 1 0.02 - lambda 96/Re_tot*0+1.*(Re_long)^(-0.25) - lambda_ortho 96/Re_tot*0+2.*(Re_ortho)^(-0.27) + lambda (96/Re_tot*0+1.*(Re_long)^(-0.25)) + lambda_ortho (96/Re_tot*0+2.*(Re_ortho)^(-0.27)) sous_zone zone1 direction champ_uniforme 2 1 0 } diff --git a/tests/Verification/Perte_Charge_Circulaire_VEF_jdd4/Perte_Charge_Circulaire_VEF_jdd4.data b/tests/Verification/Perte_Charge_Circulaire_VEF_jdd4/Perte_Charge_Circulaire_VEF_jdd4.data index 6b7bafb80c..ecd26ac750 100644 --- a/tests/Verification/Perte_Charge_Circulaire_VEF_jdd4/Perte_Charge_Circulaire_VEF_jdd4.data +++ b/tests/Verification/Perte_Charge_Circulaire_VEF_jdd4/Perte_Charge_Circulaire_VEF_jdd4.data @@ -105,8 +105,8 @@ Read pb { Perte_charge_circulaire { diam_hydr champ_uniforme 1 0.01 diam_hydr_ortho champ_uniforme 1 0.02 - lambda 96/Re_tot*0+1.*(Re_long)^(-0.25) - lambda_ortho 96/Re_tot*0+2.*(Re_ortho)^(-0.27) + lambda (96/Re_tot*0+1.*(Re_long)^(-0.25)) + lambda_ortho (96/Re_tot*0+2.*(Re_ortho)^(-0.27)) sous_zone zone1 direction champ_uniforme 2 0 1 } diff --git a/tests/Verification/QC_EOS_rhoT_jdd1/QC_EOS_rhoT_jdd1.data b/tests/Verification/QC_EOS_rhoT_jdd1/QC_EOS_rhoT_jdd1.data index 1bf71f98ce..4dfe8688e1 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd1/QC_EOS_rhoT_jdd1.data +++ b/tests/Verification/QC_EOS_rhoT_jdd1/QC_EOS_rhoT_jdd1.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd10/QC_EOS_rhoT_jdd10.data b/tests/Verification/QC_EOS_rhoT_jdd10/QC_EOS_rhoT_jdd10.data index 8c9f352e85..04d48eb8b7 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd10/QC_EOS_rhoT_jdd10.data +++ b/tests/Verification/QC_EOS_rhoT_jdd10/QC_EOS_rhoT_jdd10.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd11/QC_EOS_rhoT_jdd11.data b/tests/Verification/QC_EOS_rhoT_jdd11/QC_EOS_rhoT_jdd11.data index 65a5b9ff52..f8a5448d66 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd11/QC_EOS_rhoT_jdd11.data +++ b/tests/Verification/QC_EOS_rhoT_jdd11/QC_EOS_rhoT_jdd11.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd12/QC_EOS_rhoT_jdd12.data b/tests/Verification/QC_EOS_rhoT_jdd12/QC_EOS_rhoT_jdd12.data index ec771c44bc..df976395de 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd12/QC_EOS_rhoT_jdd12.data +++ b/tests/Verification/QC_EOS_rhoT_jdd12/QC_EOS_rhoT_jdd12.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd2/QC_EOS_rhoT_jdd2.data b/tests/Verification/QC_EOS_rhoT_jdd2/QC_EOS_rhoT_jdd2.data index e419af72b7..89ca95bdde 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd2/QC_EOS_rhoT_jdd2.data +++ b/tests/Verification/QC_EOS_rhoT_jdd2/QC_EOS_rhoT_jdd2.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd3/QC_EOS_rhoT_jdd3.data b/tests/Verification/QC_EOS_rhoT_jdd3/QC_EOS_rhoT_jdd3.data index 09bbfef882..252ec90d54 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd3/QC_EOS_rhoT_jdd3.data +++ b/tests/Verification/QC_EOS_rhoT_jdd3/QC_EOS_rhoT_jdd3.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd4/QC_EOS_rhoT_jdd4.data b/tests/Verification/QC_EOS_rhoT_jdd4/QC_EOS_rhoT_jdd4.data index 77a6771565..5dec65b505 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd4/QC_EOS_rhoT_jdd4.data +++ b/tests/Verification/QC_EOS_rhoT_jdd4/QC_EOS_rhoT_jdd4.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd5/QC_EOS_rhoT_jdd5.data b/tests/Verification/QC_EOS_rhoT_jdd5/QC_EOS_rhoT_jdd5.data index 60e79dd7e2..3a655fbae1 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd5/QC_EOS_rhoT_jdd5.data +++ b/tests/Verification/QC_EOS_rhoT_jdd5/QC_EOS_rhoT_jdd5.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd6/QC_EOS_rhoT_jdd6.data b/tests/Verification/QC_EOS_rhoT_jdd6/QC_EOS_rhoT_jdd6.data index d92394b6b4..51dfa8dae1 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd6/QC_EOS_rhoT_jdd6.data +++ b/tests/Verification/QC_EOS_rhoT_jdd6/QC_EOS_rhoT_jdd6.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*1*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd7/QC_EOS_rhoT_jdd7.data b/tests/Verification/QC_EOS_rhoT_jdd7/QC_EOS_rhoT_jdd7.data index b702580280..3b0b22a580 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd7/QC_EOS_rhoT_jdd7.data +++ b/tests/Verification/QC_EOS_rhoT_jdd7/QC_EOS_rhoT_jdd7.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd8/QC_EOS_rhoT_jdd8.data b/tests/Verification/QC_EOS_rhoT_jdd8/QC_EOS_rhoT_jdd8.data index 9870d4aa86..4ec5264f72 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd8/QC_EOS_rhoT_jdd8.data +++ b/tests/Verification/QC_EOS_rhoT_jdd8/QC_EOS_rhoT_jdd8.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_EOS_rhoT_jdd9/QC_EOS_rhoT_jdd9.data b/tests/Verification/QC_EOS_rhoT_jdd9/QC_EOS_rhoT_jdd9.data index acd53f4944..fc0d6549ff 100644 --- a/tests/Verification/QC_EOS_rhoT_jdd9/QC_EOS_rhoT_jdd9.data +++ b/tests/Verification/QC_EOS_rhoT_jdd9/QC_EOS_rhoT_jdd9.data @@ -96,8 +96,8 @@ Lire pb Sources { source_qdm champ_fonc_xyz dom 2 - ((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) - (4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y))) , + (((8*1*pi^2+16*pi^2-16/3*0*pi^2+(8*1*1*pi^2+16*1*pi^2-16/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*sin(2*pi*x)*sin(2*pi*y)-2*pi*sin(2*pi*x)*cos(2*pi*y)+2*0*pi*cos(2*pi*x)*sin(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) + ((4*1*1*pi^2*sin(2*pi*x)^2*cos(2*pi*y)^2+(-2*pi-8/3*0*1*pi^2*cos(2*pi*x)*sin(2*pi*y))*cos(2*pi*x)*sin(2*pi*y)+(-8*1*pi^2+16/3*0*pi^2+(-4*1*1*pi^2+8/3*0*1*pi^2)*cos(2*pi*x)*cos(2*pi*y))*cos(2*pi*x)*cos(2*pi*y))/(1/(2+sin(2*pi*x)*sin(2*pi*y)))) , canal_perio { bord periox debit_impose 1 } , canal_perio { bord perioy debit_impose 0 } } @@ -134,7 +134,7 @@ Lire pb sources { # u-uex # transformation { - methode formule expression 1 (u-uex)/(sqrt(17)/2) + methode formule expression 1 ((u-uex)/(sqrt(17)/2)) nom_source u_uex localisation elem sources { @@ -157,7 +157,7 @@ Lire pb methode L2_norm source transformation { - methode formule expression 1 (p-pmoy-pex)/(1/4) + methode formule expression 1 ((p-pmoy-pex)/(1/4)) localisation elem sources { diff --git a/tests/Verification/QC_temperature_bounds_MUSCL_jdd1/QC_temperature_bounds_MUSCL_jdd1.data b/tests/Verification/QC_temperature_bounds_MUSCL_jdd1/QC_temperature_bounds_MUSCL_jdd1.data index 881d999572..33f04b1ab4 100644 --- a/tests/Verification/QC_temperature_bounds_MUSCL_jdd1/QC_temperature_bounds_MUSCL_jdd1.data +++ b/tests/Verification/QC_temperature_bounds_MUSCL_jdd1/QC_temperature_bounds_MUSCL_jdd1.data @@ -53,14 +53,14 @@ lire pb fluide_quasi_compressible { gravite champ_uniforme 3 0 -9.81 0 - mu champ_fonc_fonction pb temperature 1 ((val*0.00109+(1-val)*0.00245)_MAX_0.00109)_MIN_0.00245 + mu champ_fonc_fonction pb temperature 1 (((val*0.00109+(1-val)*0.00245)max 0.00109)min 0.00245) lambda champ_fonc_fonction pb temperature 1 1.77e-6 pression 1 loi_etat rhoT_gaz_parfait_QC { Prandtl 1 Cp 1 - rho_T ((T*1064.7+(1-T)*956.54)_MAX_956.54)_MIN_1064.7 + rho_T (((T*1064.7+(1-T)*956.54)max 956.54) min 1064.7) } traitement_pth constant traitement_rho_gravite standard @@ -98,7 +98,7 @@ lire pb } convection { MUSCL } diffusion { } - conditions_initiales { temperature champ_fonc_xyz dom 1 (x<0)*(1)+(x>0)*(0) } + conditions_initiales { temperature champ_fonc_xyz dom 1 ((x<0)*(1)+(x>0)*(0)) } conditions_limites { Paroi_tube paroi_adiabatique Reservoir_froid paroi_adiabatique diff --git a/tests/Verification/QC_temperature_bounds_MUSCL_jdd2/QC_temperature_bounds_MUSCL_jdd2.data b/tests/Verification/QC_temperature_bounds_MUSCL_jdd2/QC_temperature_bounds_MUSCL_jdd2.data index fb8ad205fc..2f605a6fc7 100644 --- a/tests/Verification/QC_temperature_bounds_MUSCL_jdd2/QC_temperature_bounds_MUSCL_jdd2.data +++ b/tests/Verification/QC_temperature_bounds_MUSCL_jdd2/QC_temperature_bounds_MUSCL_jdd2.data @@ -53,14 +53,14 @@ lire pb fluide_quasi_compressible { gravite champ_uniforme 3 0 -9.81 0 - mu champ_fonc_fonction pb temperature 1 ((val*0.00109+(1-val)*0.00245)_MAX_0.00109)_MIN_0.00245 + mu champ_fonc_fonction pb temperature 1 (((val*0.00109+(1-val)*0.00245)max 0.00109)min 0.00245) lambda champ_fonc_fonction pb temperature 1 1.77e-6 pression 1 loi_etat rhoT_gaz_parfait_QC { Prandtl 1 Cp 1 - rho_T ((T*1064.7+(1-T)*956.54)_MAX_956.54)_MIN_1064.7 + rho_T (((T*1064.7+(1-T)*956.54)max 956.54) min 1064.7) } traitement_pth constant traitement_rho_gravite standard @@ -98,7 +98,7 @@ lire pb } convection { MUSCL_NEW } diffusion { } - conditions_initiales { temperature champ_fonc_xyz dom 1 (x<0)*(1)+(x>0)*(0) } + conditions_initiales { temperature champ_fonc_xyz dom 1 ((x<0)*(1)+(x>0)*(0)) } conditions_limites { Paroi_tube paroi_adiabatique Reservoir_froid paroi_adiabatique diff --git a/tests/Verification/conduc_mil_var_jdd10/conduc_mil_var_jdd10.data b/tests/Verification/conduc_mil_var_jdd10/conduc_mil_var_jdd10.data index 2f87a5d7ae..23e72776b5 100644 --- a/tests/Verification/conduc_mil_var_jdd10/conduc_mil_var_jdd10.data +++ b/tests/Verification/conduc_mil_var_jdd10/conduc_mil_var_jdd10.data @@ -68,8 +68,8 @@ Read pb rho Champ_uniforme 1 1.0 /* lambda Champ_uniforme 1 1.0 Cp Champ_uniforme 1 1.0 */ - lambda Champ_fonc_txyz dom 1 sin(t)*sin(x)+1.5 - Cp Champ_fonc_txyz dom 1 sin(t)*sin(x)+2.0 + lambda Champ_fonc_txyz dom 1 (sin(t)*sin(x)+1.5) + Cp Champ_fonc_txyz dom 1 (sin(t)*sin(x)+2.0) } @@ -81,7 +81,7 @@ Read pb # temperature Champ_fonc_xyz dom 1 sin(3.1415926535898*x) # } sources { - Puissance_Thermique champ_fonc_txyz dom 1 (sin(x)*sin(t)+2.0)*(sin(3.1415926535898*x)*cos(t))+3.1415926535898*sin(t)*(3.1415926535898*(sin(x)*sin(t)+1.5)*sin(3.1415926535898*x)-cos(x)*cos(3.1415926535898*x)*sin(t)) + Puissance_Thermique champ_fonc_txyz dom 1 ((sin(x)*sin(t)+2.0)*(sin(3.1415926535898*x)*cos(t))+3.1415926535898*sin(t)*(3.1415926535898*(sin(x)*sin(t)+1.5)*sin(3.1415926535898*x)-cos(x)*cos(3.1415926535898*x)*sin(t))) /* Puissance_Thermique champ_fonc_txyz dom 1 sin(3.1415926535898*x)*((sin(t)*sin(x)+2.0)*cos(t)+3.1415926535898*3.1415926535898*sin(t)) */ } diff --git a/tests/Verification/conduction_couple_jdd1/conduction_couple_jdd1.data b/tests/Verification/conduction_couple_jdd1/conduction_couple_jdd1.data index e26a57158a..ef687adec1 100644 --- a/tests/Verification/conduction_couple_jdd1/conduction_couple_jdd1.data +++ b/tests/Verification/conduction_couple_jdd1/conduction_couple_jdd1.data @@ -142,14 +142,14 @@ Read pb2 Gauche paroi_contact_fictif pb1 Gauche 5. 0.1 Bas Paroi_ADIABATIQUE } - initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 (x_ge_0)*(20.00-401.*x)+(x<0)*20.00-40.*x } + initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 ((x>=0)*(20.00-401.*x)+(x<0)*20.00-40.*x) } } Post_processing { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temp-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x)) + methode formule expression 1 (temp-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x))) source refChamp { Pb_Champ pb2 temperature nom_source temp } @@ -186,7 +186,7 @@ Read pb1 Conduction { diffusion { } - initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 (x_ge_0)*(20.00-401.*x)+(x<0)*20.00-40.*x } + initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 ((x>=0)*(20.00-401.*x)+(x<0)*20.00-40.*x) } boundary_conditions { @@ -200,7 +200,7 @@ Read pb1 { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temp-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x)) + methode formule expression 1 (temp-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x))) source refChamp { Pb_Champ pb1 temperature nom_source temp } diff --git a/tests/Verification/conduction_couple_jdd2/conduction_couple_jdd2.data b/tests/Verification/conduction_couple_jdd2/conduction_couple_jdd2.data index 36bdcba968..173f93c5f6 100644 --- a/tests/Verification/conduction_couple_jdd2/conduction_couple_jdd2.data +++ b/tests/Verification/conduction_couple_jdd2/conduction_couple_jdd2.data @@ -144,13 +144,13 @@ Read pb2 Gauche paroi_contact_fictif pb1 Gauche 5. 0.1 Bas Paroi_ADIABATIQUE } - initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 (x_ge_0)*(20.00-401.*x)+(x<0)*20.00-40.*x } + initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 ((x>=0)*(20.00-401.*x)+(x<0)*20.00-40.*x) } } Post_processing { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temperature-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x)) + methode formule expression 1 (temperature-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x))) source refChamp { Pb_Champ pb2 temperature nom_source temperature } @@ -186,7 +186,7 @@ Read pb1 Conduction { diffusion { } - initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 (x_ge_0)*(20.00-401.*x)+(x<0)*20.00-40.*x } + initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 ((x>=0)*(20.00-401.*x)+(x<0)*20.00-40.*x) } boundary_conditions { @@ -201,7 +201,7 @@ Read pb1 { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temperature-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x)) + methode formule expression 1 (temperature-((x>0)*(20.00-400.*x)+(x<0)*(28.00-40.*x))) source refChamp { Pb_Champ pb1 temperature nom_source temperature } diff --git a/tests/Verification/conduction_couple_jdd4/conduction_couple_jdd4.data b/tests/Verification/conduction_couple_jdd4/conduction_couple_jdd4.data index f0167f2a11..d35cd2db96 100644 --- a/tests/Verification/conduction_couple_jdd4/conduction_couple_jdd4.data +++ b/tests/Verification/conduction_couple_jdd4/conduction_couple_jdd4.data @@ -142,14 +142,14 @@ Read pb2 } initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 - (x>0)*(18.31179308*SIN(30.79992798*x-1.539996399)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)+20.00-40.*x) + ((x>0)*(18.31179308*SIN(30.79992798*x-1.539996399)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)+20.00-40.*x)) } } Post_processing { Definition_champs { combinaison_champ Transformation { - methode formule expression 1 temperature-((x>0)*(18.31179308*SIN(30.79992798*x-1.539996399)*EXP(-0.9486355639*t)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)*EXP(-0.9486355639*t)+20.00-40.*x)) + methode formule expression 1 (temperature-((x>0)*(18.31179308*SIN(30.79992798*x-1.539996399)*EXP(-0.9486355639*t)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)*EXP(-0.9486355639*t)+20.00-40.*x))) source refChamp { Pb_Champ pb2 temperature nom_source temperature } @@ -189,7 +189,7 @@ Read pb1 diffusion { } initial_conditions { Temperature champ_fonc_xyz dom_fluide 1 - (x]0)*(18.31179308*SIN(30.79992798*x-1.539996399)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)+20.00-40.*x) + ((x]0)*(18.31179308*SIN(30.79992798*x-1.539996399)+20.00-400.*x)+(x<0)*(-18.31179308*COS(3.079992798*x+.3079992798e-1)+20.00-40.*x)) } boundary_conditions { diff --git a/tests/Verification/convection_jdd1/convection_jdd1.data b/tests/Verification/convection_jdd1/convection_jdd1.data index b9bcfaf416..8e08b01af4 100644 --- a/tests/Verification/convection_jdd1/convection_jdd1.data +++ b/tests/Verification/convection_jdd1/convection_jdd1.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd10/convection_jdd10.data b/tests/Verification/convection_jdd10/convection_jdd10.data index 6832d5e5fc..de003ea835 100644 --- a/tests/Verification/convection_jdd10/convection_jdd10.data +++ b/tests/Verification/convection_jdd10/convection_jdd10.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd11/convection_jdd11.data b/tests/Verification/convection_jdd11/convection_jdd11.data index 61982ac3c8..6525dc4262 100644 --- a/tests/Verification/convection_jdd11/convection_jdd11.data +++ b/tests/Verification/convection_jdd11/convection_jdd11.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd12/convection_jdd12.data b/tests/Verification/convection_jdd12/convection_jdd12.data index b7b9f761e9..2656283484 100644 --- a/tests/Verification/convection_jdd12/convection_jdd12.data +++ b/tests/Verification/convection_jdd12/convection_jdd12.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd13/convection_jdd13.data b/tests/Verification/convection_jdd13/convection_jdd13.data index ceb468d280..113764fe26 100644 --- a/tests/Verification/convection_jdd13/convection_jdd13.data +++ b/tests/Verification/convection_jdd13/convection_jdd13.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd14/convection_jdd14.data b/tests/Verification/convection_jdd14/convection_jdd14.data index 076b22349c..b85878515b 100644 --- a/tests/Verification/convection_jdd14/convection_jdd14.data +++ b/tests/Verification/convection_jdd14/convection_jdd14.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd15/convection_jdd15.data b/tests/Verification/convection_jdd15/convection_jdd15.data index d1565a8626..fbc5207fc8 100644 --- a/tests/Verification/convection_jdd15/convection_jdd15.data +++ b/tests/Verification/convection_jdd15/convection_jdd15.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd16/convection_jdd16.data b/tests/Verification/convection_jdd16/convection_jdd16.data index 14b3dfc138..8d05826800 100644 --- a/tests/Verification/convection_jdd16/convection_jdd16.data +++ b/tests/Verification/convection_jdd16/convection_jdd16.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd17/convection_jdd17.data b/tests/Verification/convection_jdd17/convection_jdd17.data index 54a575b3b8..06e4245796 100644 --- a/tests/Verification/convection_jdd17/convection_jdd17.data +++ b/tests/Verification/convection_jdd17/convection_jdd17.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd18/convection_jdd18.data b/tests/Verification/convection_jdd18/convection_jdd18.data index 5bbbf8f752..e0bfea753e 100644 --- a/tests/Verification/convection_jdd18/convection_jdd18.data +++ b/tests/Verification/convection_jdd18/convection_jdd18.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd19/convection_jdd19.data b/tests/Verification/convection_jdd19/convection_jdd19.data index a1ea7d12c4..e0863a75a7 100644 --- a/tests/Verification/convection_jdd19/convection_jdd19.data +++ b/tests/Verification/convection_jdd19/convection_jdd19.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd2/convection_jdd2.data b/tests/Verification/convection_jdd2/convection_jdd2.data index 3a5a5182af..b63c3dcfed 100644 --- a/tests/Verification/convection_jdd2/convection_jdd2.data +++ b/tests/Verification/convection_jdd2/convection_jdd2.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd20/convection_jdd20.data b/tests/Verification/convection_jdd20/convection_jdd20.data index 1a16ba20dd..de7903e7e9 100644 --- a/tests/Verification/convection_jdd20/convection_jdd20.data +++ b/tests/Verification/convection_jdd20/convection_jdd20.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd21/convection_jdd21.data b/tests/Verification/convection_jdd21/convection_jdd21.data index 605acf6431..19bc7975ae 100644 --- a/tests/Verification/convection_jdd21/convection_jdd21.data +++ b/tests/Verification/convection_jdd21/convection_jdd21.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd22/convection_jdd22.data b/tests/Verification/convection_jdd22/convection_jdd22.data index 489642c2c6..0ea430895d 100644 --- a/tests/Verification/convection_jdd22/convection_jdd22.data +++ b/tests/Verification/convection_jdd22/convection_jdd22.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd23/convection_jdd23.data b/tests/Verification/convection_jdd23/convection_jdd23.data index ab9a32ff97..8e73e67cd3 100644 --- a/tests/Verification/convection_jdd23/convection_jdd23.data +++ b/tests/Verification/convection_jdd23/convection_jdd23.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd24/convection_jdd24.data b/tests/Verification/convection_jdd24/convection_jdd24.data index 5d068ef353..c3252b57dd 100644 --- a/tests/Verification/convection_jdd24/convection_jdd24.data +++ b/tests/Verification/convection_jdd24/convection_jdd24.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd25/convection_jdd25.data b/tests/Verification/convection_jdd25/convection_jdd25.data index e6f48f6d9c..b8b6f79e7b 100644 --- a/tests/Verification/convection_jdd25/convection_jdd25.data +++ b/tests/Verification/convection_jdd25/convection_jdd25.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd26/convection_jdd26.data b/tests/Verification/convection_jdd26/convection_jdd26.data index 4281623fd7..eafae1d08c 100644 --- a/tests/Verification/convection_jdd26/convection_jdd26.data +++ b/tests/Verification/convection_jdd26/convection_jdd26.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd27/convection_jdd27.data b/tests/Verification/convection_jdd27/convection_jdd27.data index 5f05959b85..71e99e89ff 100644 --- a/tests/Verification/convection_jdd27/convection_jdd27.data +++ b/tests/Verification/convection_jdd27/convection_jdd27.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd28/convection_jdd28.data b/tests/Verification/convection_jdd28/convection_jdd28.data index 10cb4c03f9..f6713dfc80 100644 --- a/tests/Verification/convection_jdd28/convection_jdd28.data +++ b/tests/Verification/convection_jdd28/convection_jdd28.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd29/convection_jdd29.data b/tests/Verification/convection_jdd29/convection_jdd29.data index df8dea191a..a0387ad186 100644 --- a/tests/Verification/convection_jdd29/convection_jdd29.data +++ b/tests/Verification/convection_jdd29/convection_jdd29.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd3/convection_jdd3.data b/tests/Verification/convection_jdd3/convection_jdd3.data index 55f43a3d2a..a492c68a70 100644 --- a/tests/Verification/convection_jdd3/convection_jdd3.data +++ b/tests/Verification/convection_jdd3/convection_jdd3.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd30/convection_jdd30.data b/tests/Verification/convection_jdd30/convection_jdd30.data index a8f4482005..1100e3664e 100644 --- a/tests/Verification/convection_jdd30/convection_jdd30.data +++ b/tests/Verification/convection_jdd30/convection_jdd30.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd31/convection_jdd31.data b/tests/Verification/convection_jdd31/convection_jdd31.data index 3c9feaf7a1..44fea7679c 100644 --- a/tests/Verification/convection_jdd31/convection_jdd31.data +++ b/tests/Verification/convection_jdd31/convection_jdd31.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd32/convection_jdd32.data b/tests/Verification/convection_jdd32/convection_jdd32.data index 033c31afa5..f9d3767ef6 100644 --- a/tests/Verification/convection_jdd32/convection_jdd32.data +++ b/tests/Verification/convection_jdd32/convection_jdd32.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd33/convection_jdd33.data b/tests/Verification/convection_jdd33/convection_jdd33.data index 782b9ba43c..0fffeefd17 100644 --- a/tests/Verification/convection_jdd33/convection_jdd33.data +++ b/tests/Verification/convection_jdd33/convection_jdd33.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd34/convection_jdd34.data b/tests/Verification/convection_jdd34/convection_jdd34.data index 3207117b4a..45b6c76160 100644 --- a/tests/Verification/convection_jdd34/convection_jdd34.data +++ b/tests/Verification/convection_jdd34/convection_jdd34.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd35/convection_jdd35.data b/tests/Verification/convection_jdd35/convection_jdd35.data index b0e9ce91b5..d2e7297a18 100644 --- a/tests/Verification/convection_jdd35/convection_jdd35.data +++ b/tests/Verification/convection_jdd35/convection_jdd35.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd36/convection_jdd36.data b/tests/Verification/convection_jdd36/convection_jdd36.data index bb5bf10843..5ec332e9c5 100644 --- a/tests/Verification/convection_jdd36/convection_jdd36.data +++ b/tests/Verification/convection_jdd36/convection_jdd36.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd37/convection_jdd37.data b/tests/Verification/convection_jdd37/convection_jdd37.data index a114ebefa0..73c8dd7738 100644 --- a/tests/Verification/convection_jdd37/convection_jdd37.data +++ b/tests/Verification/convection_jdd37/convection_jdd37.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd38/convection_jdd38.data b/tests/Verification/convection_jdd38/convection_jdd38.data index 8854ea462c..4f2baab035 100644 --- a/tests/Verification/convection_jdd38/convection_jdd38.data +++ b/tests/Verification/convection_jdd38/convection_jdd38.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd39/convection_jdd39.data b/tests/Verification/convection_jdd39/convection_jdd39.data index 393ac9c667..d84ce8c116 100644 --- a/tests/Verification/convection_jdd39/convection_jdd39.data +++ b/tests/Verification/convection_jdd39/convection_jdd39.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd4/convection_jdd4.data b/tests/Verification/convection_jdd4/convection_jdd4.data index 395a87aa9a..6b22a5d2aa 100644 --- a/tests/Verification/convection_jdd4/convection_jdd4.data +++ b/tests/Verification/convection_jdd4/convection_jdd4.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + vitesse champ_fonc_xyz dom 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) - (cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) + ((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 exp(x-y) exp(x-y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(0)+sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(0)-sin(0))*exp((cos(0)-sin(0))*x-(sin(0)+cos(0))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd40/convection_jdd40.data b/tests/Verification/convection_jdd40/convection_jdd40.data index d4db219469..cee3df36e8 100644 --- a/tests/Verification/convection_jdd40/convection_jdd40.data +++ b/tests/Verification/convection_jdd40/convection_jdd40.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd41/convection_jdd41.data b/tests/Verification/convection_jdd41/convection_jdd41.data index 56574dcc41..846179d95e 100644 --- a/tests/Verification/convection_jdd41/convection_jdd41.data +++ b/tests/Verification/convection_jdd41/convection_jdd41.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd42/convection_jdd42.data b/tests/Verification/convection_jdd42/convection_jdd42.data index 9c2592936e..39250c23cb 100644 --- a/tests/Verification/convection_jdd42/convection_jdd42.data +++ b/tests/Verification/convection_jdd42/convection_jdd42.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd43/convection_jdd43.data b/tests/Verification/convection_jdd43/convection_jdd43.data index ee08b3c014..c4013598c8 100644 --- a/tests/Verification/convection_jdd43/convection_jdd43.data +++ b/tests/Verification/convection_jdd43/convection_jdd43.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd44/convection_jdd44.data b/tests/Verification/convection_jdd44/convection_jdd44.data index 9a2c62c1fc..2975383c6e 100644 --- a/tests/Verification/convection_jdd44/convection_jdd44.data +++ b/tests/Verification/convection_jdd44/convection_jdd44.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd45/convection_jdd45.data b/tests/Verification/convection_jdd45/convection_jdd45.data index ed4a68730d..3edd35937e 100644 --- a/tests/Verification/convection_jdd45/convection_jdd45.data +++ b/tests/Verification/convection_jdd45/convection_jdd45.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd46/convection_jdd46.data b/tests/Verification/convection_jdd46/convection_jdd46.data index 6c4571ccd5..8e7b060a57 100644 --- a/tests/Verification/convection_jdd46/convection_jdd46.data +++ b/tests/Verification/convection_jdd46/convection_jdd46.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd47/convection_jdd47.data b/tests/Verification/convection_jdd47/convection_jdd47.data index bd79981fec..dd123862a9 100644 --- a/tests/Verification/convection_jdd47/convection_jdd47.data +++ b/tests/Verification/convection_jdd47/convection_jdd47.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd48/convection_jdd48.data b/tests/Verification/convection_jdd48/convection_jdd48.data index ac4343e415..7ac8f74620 100644 --- a/tests/Verification/convection_jdd48/convection_jdd48.data +++ b/tests/Verification/convection_jdd48/convection_jdd48.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + vitesse champ_fonc_xyz dom 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) - (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) + ((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y) (cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40))*y) up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(40*pi/180)+sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(40*pi/180)-sin(40*pi/180))*exp((cos(40*pi/180)-sin(40*pi/180))*x-(sin(40*pi/180)+cos(40*pi/180))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd5/convection_jdd5.data b/tests/Verification/convection_jdd5/convection_jdd5.data index 2c16a03bfd..d94f33b3d0 100644 --- a/tests/Verification/convection_jdd5/convection_jdd5.data +++ b/tests/Verification/convection_jdd5/convection_jdd5.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd6/convection_jdd6.data b/tests/Verification/convection_jdd6/convection_jdd6.data index 2b99fa0dc6..6561997a95 100644 --- a/tests/Verification/convection_jdd6/convection_jdd6.data +++ b/tests/Verification/convection_jdd6/convection_jdd6.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd7/convection_jdd7.data b/tests/Verification/convection_jdd7/convection_jdd7.data index 52ff787bb7..de613b1b75 100644 --- a/tests/Verification/convection_jdd7/convection_jdd7.data +++ b/tests/Verification/convection_jdd7/convection_jdd7.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd8/convection_jdd8.data b/tests/Verification/convection_jdd8/convection_jdd8.data index 971663add2..e429259fcd 100644 --- a/tests/Verification/convection_jdd8/convection_jdd8.data +++ b/tests/Verification/convection_jdd8/convection_jdd8.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down symetrie up symetrie @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/convection_jdd9/convection_jdd9.data b/tests/Verification/convection_jdd9/convection_jdd9.data index f3f9aabbe1..deda74c96b 100644 --- a/tests/Verification/convection_jdd9/convection_jdd9.data +++ b/tests/Verification/convection_jdd9/convection_jdd9.data @@ -53,13 +53,13 @@ Lire pb convection { amont } diffusion { negligeable } conditions_initiales { - vitesse champ_fonc_xyz dom 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + vitesse champ_fonc_xyz dom 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) } conditions_limites { - left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 (cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) - (cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y) + left frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 ((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) + ((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) right frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 down frontiere_ouverte_vitesse_imposee champ_front_fonc_txyz 2 2*sin(pi/4)*exp(-2*sin(pi/4)*y) 0 up frontiere_ouverte_pression_imposee champ_front_uniforme 1 0 @@ -72,8 +72,8 @@ Lire pb { vx transformation { methode composante numero 0 localisation elem source refchamp { pb_champ pb vitesse } } vy transformation { methode composante numero 1 localisation elem source refchamp { pb_champ pb vitesse } } - erreur_v_x transformation { methode formule expression 1 vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vx } } - erreur_v_y transformation { methode formule expression 1 vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y)) sources_reference { vy } } + erreur_v_x transformation { methode formule expression 1 (vx-((cos(pi/4)+sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vx } } + erreur_v_y transformation { methode formule expression 1 (vy-((cos(pi/4)-sin(pi/4))*exp((cos(pi/4)-sin(pi/4))*x-(sin(pi/4)+cos(pi/4))*y))) sources_reference { vy } } erreur_mx Reduction_0d { methode max sources_reference { erreur_v_x } } erreur_my Reduction_0d { methode max sources_reference { erreur_v_y } } erreur_Lx Reduction_0d { methode L2_norm sources_reference { erreur_v_x } } diff --git a/tests/Verification/fvca_jdd1/fvca_jdd1.data b/tests/Verification/fvca_jdd1/fvca_jdd1.data index f1b5d574c2..ad7aa6f4d1 100644 --- a/tests/Verification/fvca_jdd1/fvca_jdd1.data +++ b/tests/Verification/fvca_jdd1/fvca_jdd1.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd10/fvca_jdd10.data b/tests/Verification/fvca_jdd10/fvca_jdd10.data index f1b5d574c2..ad7aa6f4d1 100644 --- a/tests/Verification/fvca_jdd10/fvca_jdd10.data +++ b/tests/Verification/fvca_jdd10/fvca_jdd10.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd11/fvca_jdd11.data b/tests/Verification/fvca_jdd11/fvca_jdd11.data index e945a219e2..efafed5356 100644 --- a/tests/Verification/fvca_jdd11/fvca_jdd11.data +++ b/tests/Verification/fvca_jdd11/fvca_jdd11.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd12/fvca_jdd12.data b/tests/Verification/fvca_jdd12/fvca_jdd12.data index 0feaed6d84..5eaf631a82 100644 --- a/tests/Verification/fvca_jdd12/fvca_jdd12.data +++ b/tests/Verification/fvca_jdd12/fvca_jdd12.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd13/fvca_jdd13.data b/tests/Verification/fvca_jdd13/fvca_jdd13.data index f1b5d574c2..ad7aa6f4d1 100644 --- a/tests/Verification/fvca_jdd13/fvca_jdd13.data +++ b/tests/Verification/fvca_jdd13/fvca_jdd13.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd14/fvca_jdd14.data b/tests/Verification/fvca_jdd14/fvca_jdd14.data index e945a219e2..efafed5356 100644 --- a/tests/Verification/fvca_jdd14/fvca_jdd14.data +++ b/tests/Verification/fvca_jdd14/fvca_jdd14.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd15/fvca_jdd15.data b/tests/Verification/fvca_jdd15/fvca_jdd15.data index 0feaed6d84..5eaf631a82 100644 --- a/tests/Verification/fvca_jdd15/fvca_jdd15.data +++ b/tests/Verification/fvca_jdd15/fvca_jdd15.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd16/fvca_jdd16.data b/tests/Verification/fvca_jdd16/fvca_jdd16.data index f1b5d574c2..ad7aa6f4d1 100644 --- a/tests/Verification/fvca_jdd16/fvca_jdd16.data +++ b/tests/Verification/fvca_jdd16/fvca_jdd16.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd17/fvca_jdd17.data b/tests/Verification/fvca_jdd17/fvca_jdd17.data index e945a219e2..efafed5356 100644 --- a/tests/Verification/fvca_jdd17/fvca_jdd17.data +++ b/tests/Verification/fvca_jdd17/fvca_jdd17.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd18/fvca_jdd18.data b/tests/Verification/fvca_jdd18/fvca_jdd18.data index 0feaed6d84..5eaf631a82 100644 --- a/tests/Verification/fvca_jdd18/fvca_jdd18.data +++ b/tests/Verification/fvca_jdd18/fvca_jdd18.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd19/fvca_jdd19.data b/tests/Verification/fvca_jdd19/fvca_jdd19.data index 43a0efc3c2..c756099139 100644 --- a/tests/Verification/fvca_jdd19/fvca_jdd19.data +++ b/tests/Verification/fvca_jdd19/fvca_jdd19.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd2/fvca_jdd2.data b/tests/Verification/fvca_jdd2/fvca_jdd2.data index e945a219e2..efafed5356 100644 --- a/tests/Verification/fvca_jdd2/fvca_jdd2.data +++ b/tests/Verification/fvca_jdd2/fvca_jdd2.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd20/fvca_jdd20.data b/tests/Verification/fvca_jdd20/fvca_jdd20.data index d1a7da9c7c..6a50ee9f93 100644 --- a/tests/Verification/fvca_jdd20/fvca_jdd20.data +++ b/tests/Verification/fvca_jdd20/fvca_jdd20.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd21/fvca_jdd21.data b/tests/Verification/fvca_jdd21/fvca_jdd21.data index 403dbafaf6..e2709500c7 100644 --- a/tests/Verification/fvca_jdd21/fvca_jdd21.data +++ b/tests/Verification/fvca_jdd21/fvca_jdd21.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd22/fvca_jdd22.data b/tests/Verification/fvca_jdd22/fvca_jdd22.data index 43a0efc3c2..c756099139 100644 --- a/tests/Verification/fvca_jdd22/fvca_jdd22.data +++ b/tests/Verification/fvca_jdd22/fvca_jdd22.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd23/fvca_jdd23.data b/tests/Verification/fvca_jdd23/fvca_jdd23.data index d1a7da9c7c..6a50ee9f93 100644 --- a/tests/Verification/fvca_jdd23/fvca_jdd23.data +++ b/tests/Verification/fvca_jdd23/fvca_jdd23.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd24/fvca_jdd24.data b/tests/Verification/fvca_jdd24/fvca_jdd24.data index 403dbafaf6..e2709500c7 100644 --- a/tests/Verification/fvca_jdd24/fvca_jdd24.data +++ b/tests/Verification/fvca_jdd24/fvca_jdd24.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd25/fvca_jdd25.data b/tests/Verification/fvca_jdd25/fvca_jdd25.data index 43a0efc3c2..c756099139 100644 --- a/tests/Verification/fvca_jdd25/fvca_jdd25.data +++ b/tests/Verification/fvca_jdd25/fvca_jdd25.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd26/fvca_jdd26.data b/tests/Verification/fvca_jdd26/fvca_jdd26.data index d1a7da9c7c..6a50ee9f93 100644 --- a/tests/Verification/fvca_jdd26/fvca_jdd26.data +++ b/tests/Verification/fvca_jdd26/fvca_jdd26.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd27/fvca_jdd27.data b/tests/Verification/fvca_jdd27/fvca_jdd27.data index 403dbafaf6..e2709500c7 100644 --- a/tests/Verification/fvca_jdd27/fvca_jdd27.data +++ b/tests/Verification/fvca_jdd27/fvca_jdd27.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd28/fvca_jdd28.data b/tests/Verification/fvca_jdd28/fvca_jdd28.data index 43a0efc3c2..c756099139 100644 --- a/tests/Verification/fvca_jdd28/fvca_jdd28.data +++ b/tests/Verification/fvca_jdd28/fvca_jdd28.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd29/fvca_jdd29.data b/tests/Verification/fvca_jdd29/fvca_jdd29.data index d1a7da9c7c..6a50ee9f93 100644 --- a/tests/Verification/fvca_jdd29/fvca_jdd29.data +++ b/tests/Verification/fvca_jdd29/fvca_jdd29.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd3/fvca_jdd3.data b/tests/Verification/fvca_jdd3/fvca_jdd3.data index 0feaed6d84..5eaf631a82 100644 --- a/tests/Verification/fvca_jdd3/fvca_jdd3.data +++ b/tests/Verification/fvca_jdd3/fvca_jdd3.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd30/fvca_jdd30.data b/tests/Verification/fvca_jdd30/fvca_jdd30.data index 403dbafaf6..e2709500c7 100644 --- a/tests/Verification/fvca_jdd30/fvca_jdd30.data +++ b/tests/Verification/fvca_jdd30/fvca_jdd30.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd31/fvca_jdd31.data b/tests/Verification/fvca_jdd31/fvca_jdd31.data index 43a0efc3c2..c756099139 100644 --- a/tests/Verification/fvca_jdd31/fvca_jdd31.data +++ b/tests/Verification/fvca_jdd31/fvca_jdd31.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd32/fvca_jdd32.data b/tests/Verification/fvca_jdd32/fvca_jdd32.data index d1a7da9c7c..6a50ee9f93 100644 --- a/tests/Verification/fvca_jdd32/fvca_jdd32.data +++ b/tests/Verification/fvca_jdd32/fvca_jdd32.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd33/fvca_jdd33.data b/tests/Verification/fvca_jdd33/fvca_jdd33.data index 403dbafaf6..e2709500c7 100644 --- a/tests/Verification/fvca_jdd33/fvca_jdd33.data +++ b/tests/Verification/fvca_jdd33/fvca_jdd33.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd34/fvca_jdd34.data b/tests/Verification/fvca_jdd34/fvca_jdd34.data index 43a0efc3c2..c756099139 100644 --- a/tests/Verification/fvca_jdd34/fvca_jdd34.data +++ b/tests/Verification/fvca_jdd34/fvca_jdd34.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd35/fvca_jdd35.data b/tests/Verification/fvca_jdd35/fvca_jdd35.data index d1a7da9c7c..6a50ee9f93 100644 --- a/tests/Verification/fvca_jdd35/fvca_jdd35.data +++ b/tests/Verification/fvca_jdd35/fvca_jdd35.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd36/fvca_jdd36.data b/tests/Verification/fvca_jdd36/fvca_jdd36.data index 403dbafaf6..e2709500c7 100644 --- a/tests/Verification/fvca_jdd36/fvca_jdd36.data +++ b/tests/Verification/fvca_jdd36/fvca_jdd36.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd37/fvca_jdd37.data b/tests/Verification/fvca_jdd37/fvca_jdd37.data index 43a0efc3c2..c756099139 100644 --- a/tests/Verification/fvca_jdd37/fvca_jdd37.data +++ b/tests/Verification/fvca_jdd37/fvca_jdd37.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd38/fvca_jdd38.data b/tests/Verification/fvca_jdd38/fvca_jdd38.data index d1a7da9c7c..6a50ee9f93 100644 --- a/tests/Verification/fvca_jdd38/fvca_jdd38.data +++ b/tests/Verification/fvca_jdd38/fvca_jdd38.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd39/fvca_jdd39.data b/tests/Verification/fvca_jdd39/fvca_jdd39.data index 403dbafaf6..e2709500c7 100644 --- a/tests/Verification/fvca_jdd39/fvca_jdd39.data +++ b/tests/Verification/fvca_jdd39/fvca_jdd39.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd4/fvca_jdd4.data b/tests/Verification/fvca_jdd4/fvca_jdd4.data index f1b5d574c2..ad7aa6f4d1 100644 --- a/tests/Verification/fvca_jdd4/fvca_jdd4.data +++ b/tests/Verification/fvca_jdd4/fvca_jdd4.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd40/fvca_jdd40.data b/tests/Verification/fvca_jdd40/fvca_jdd40.data index 43a0efc3c2..c756099139 100644 --- a/tests/Verification/fvca_jdd40/fvca_jdd40.data +++ b/tests/Verification/fvca_jdd40/fvca_jdd40.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd41/fvca_jdd41.data b/tests/Verification/fvca_jdd41/fvca_jdd41.data index d1a7da9c7c..6a50ee9f93 100644 --- a/tests/Verification/fvca_jdd41/fvca_jdd41.data +++ b/tests/Verification/fvca_jdd41/fvca_jdd41.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd42/fvca_jdd42.data b/tests/Verification/fvca_jdd42/fvca_jdd42.data index 403dbafaf6..e2709500c7 100644 --- a/tests/Verification/fvca_jdd42/fvca_jdd42.data +++ b/tests/Verification/fvca_jdd42/fvca_jdd42.data @@ -59,7 +59,7 @@ Read pb diffusion { } sources { - source_qdm champ_fonc_xyz dom 3 -36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) 0 0 + source_qdm champ_fonc_xyz dom 3 (-36*pi*pi*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) 0 0 } initial_conditions { @@ -67,7 +67,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) } } @@ -77,7 +77,7 @@ Read pb { p_moins_pmoy transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -86,12 +86,12 @@ Read pb } erreur_P transformation { - methode formule expression 1 abs(pmp-sol) + methode formule expression 1 (abs(pmp-sol)) sources { transformation { - methode formule expression 1 p-pmoy + methode formule expression 1 (p-pmoy) sources { refChamp { Pb_champ pb pression_pa nom_source p } , @@ -99,7 +99,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 -6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (-6*pi*sin(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -107,11 +107,11 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 -2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z) sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (-2*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)) (sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd43/fvca_jdd43.data b/tests/Verification/fvca_jdd43/fvca_jdd43.data index 0011d7ae2c..f150470d50 100644 --- a/tests/Verification/fvca_jdd43/fvca_jdd43.data +++ b/tests/Verification/fvca_jdd43/fvca_jdd43.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd44/fvca_jdd44.data b/tests/Verification/fvca_jdd44/fvca_jdd44.data index 73d3cca24a..19ef0fb377 100644 --- a/tests/Verification/fvca_jdd44/fvca_jdd44.data +++ b/tests/Verification/fvca_jdd44/fvca_jdd44.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd45/fvca_jdd45.data b/tests/Verification/fvca_jdd45/fvca_jdd45.data index 77275c559d..36f3c49833 100644 --- a/tests/Verification/fvca_jdd45/fvca_jdd45.data +++ b/tests/Verification/fvca_jdd45/fvca_jdd45.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd46/fvca_jdd46.data b/tests/Verification/fvca_jdd46/fvca_jdd46.data index 0011d7ae2c..f150470d50 100644 --- a/tests/Verification/fvca_jdd46/fvca_jdd46.data +++ b/tests/Verification/fvca_jdd46/fvca_jdd46.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd47/fvca_jdd47.data b/tests/Verification/fvca_jdd47/fvca_jdd47.data index 73d3cca24a..19ef0fb377 100644 --- a/tests/Verification/fvca_jdd47/fvca_jdd47.data +++ b/tests/Verification/fvca_jdd47/fvca_jdd47.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd48/fvca_jdd48.data b/tests/Verification/fvca_jdd48/fvca_jdd48.data index 77275c559d..36f3c49833 100644 --- a/tests/Verification/fvca_jdd48/fvca_jdd48.data +++ b/tests/Verification/fvca_jdd48/fvca_jdd48.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd49/fvca_jdd49.data b/tests/Verification/fvca_jdd49/fvca_jdd49.data index 0011d7ae2c..f150470d50 100644 --- a/tests/Verification/fvca_jdd49/fvca_jdd49.data +++ b/tests/Verification/fvca_jdd49/fvca_jdd49.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd5/fvca_jdd5.data b/tests/Verification/fvca_jdd5/fvca_jdd5.data index e945a219e2..efafed5356 100644 --- a/tests/Verification/fvca_jdd5/fvca_jdd5.data +++ b/tests/Verification/fvca_jdd5/fvca_jdd5.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd50/fvca_jdd50.data b/tests/Verification/fvca_jdd50/fvca_jdd50.data index 73d3cca24a..19ef0fb377 100644 --- a/tests/Verification/fvca_jdd50/fvca_jdd50.data +++ b/tests/Verification/fvca_jdd50/fvca_jdd50.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd51/fvca_jdd51.data b/tests/Verification/fvca_jdd51/fvca_jdd51.data index 77275c559d..36f3c49833 100644 --- a/tests/Verification/fvca_jdd51/fvca_jdd51.data +++ b/tests/Verification/fvca_jdd51/fvca_jdd51.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd52/fvca_jdd52.data b/tests/Verification/fvca_jdd52/fvca_jdd52.data index 0011d7ae2c..f150470d50 100644 --- a/tests/Verification/fvca_jdd52/fvca_jdd52.data +++ b/tests/Verification/fvca_jdd52/fvca_jdd52.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd53/fvca_jdd53.data b/tests/Verification/fvca_jdd53/fvca_jdd53.data index 73d3cca24a..19ef0fb377 100644 --- a/tests/Verification/fvca_jdd53/fvca_jdd53.data +++ b/tests/Verification/fvca_jdd53/fvca_jdd53.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd54/fvca_jdd54.data b/tests/Verification/fvca_jdd54/fvca_jdd54.data index 77275c559d..36f3c49833 100644 --- a/tests/Verification/fvca_jdd54/fvca_jdd54.data +++ b/tests/Verification/fvca_jdd54/fvca_jdd54.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd55/fvca_jdd55.data b/tests/Verification/fvca_jdd55/fvca_jdd55.data index 0011d7ae2c..f150470d50 100644 --- a/tests/Verification/fvca_jdd55/fvca_jdd55.data +++ b/tests/Verification/fvca_jdd55/fvca_jdd55.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd56/fvca_jdd56.data b/tests/Verification/fvca_jdd56/fvca_jdd56.data index 73d3cca24a..19ef0fb377 100644 --- a/tests/Verification/fvca_jdd56/fvca_jdd56.data +++ b/tests/Verification/fvca_jdd56/fvca_jdd56.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd57/fvca_jdd57.data b/tests/Verification/fvca_jdd57/fvca_jdd57.data index 77275c559d..36f3c49833 100644 --- a/tests/Verification/fvca_jdd57/fvca_jdd57.data +++ b/tests/Verification/fvca_jdd57/fvca_jdd57.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd58/fvca_jdd58.data b/tests/Verification/fvca_jdd58/fvca_jdd58.data index 0011d7ae2c..f150470d50 100644 --- a/tests/Verification/fvca_jdd58/fvca_jdd58.data +++ b/tests/Verification/fvca_jdd58/fvca_jdd58.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd59/fvca_jdd59.data b/tests/Verification/fvca_jdd59/fvca_jdd59.data index 73d3cca24a..19ef0fb377 100644 --- a/tests/Verification/fvca_jdd59/fvca_jdd59.data +++ b/tests/Verification/fvca_jdd59/fvca_jdd59.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd6/fvca_jdd6.data b/tests/Verification/fvca_jdd6/fvca_jdd6.data index 0feaed6d84..5eaf631a82 100644 --- a/tests/Verification/fvca_jdd6/fvca_jdd6.data +++ b/tests/Verification/fvca_jdd6/fvca_jdd6.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd60/fvca_jdd60.data b/tests/Verification/fvca_jdd60/fvca_jdd60.data index 77275c559d..36f3c49833 100644 --- a/tests/Verification/fvca_jdd60/fvca_jdd60.data +++ b/tests/Verification/fvca_jdd60/fvca_jdd60.data @@ -91,7 +91,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x*x+y*y)/2-1/3 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x*x+y*y)/2-1/3) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -99,7 +99,7 @@ Read pb /* aux elems */ erreur_V transformation { - methode formule expression 1 abs(v-sol) + methode formule expression 1 (abs(v-sol)) sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , diff --git a/tests/Verification/fvca_jdd61/fvca_jdd61.data b/tests/Verification/fvca_jdd61/fvca_jdd61.data index d2be7a53b4..23167e231c 100644 --- a/tests/Verification/fvca_jdd61/fvca_jdd61.data +++ b/tests/Verification/fvca_jdd61/fvca_jdd61.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd62/fvca_jdd62.data b/tests/Verification/fvca_jdd62/fvca_jdd62.data index 4af61dde43..418c54eaca 100644 --- a/tests/Verification/fvca_jdd62/fvca_jdd62.data +++ b/tests/Verification/fvca_jdd62/fvca_jdd62.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd63/fvca_jdd63.data b/tests/Verification/fvca_jdd63/fvca_jdd63.data index 05870c3a7f..99de945bea 100644 --- a/tests/Verification/fvca_jdd63/fvca_jdd63.data +++ b/tests/Verification/fvca_jdd63/fvca_jdd63.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd64/fvca_jdd64.data b/tests/Verification/fvca_jdd64/fvca_jdd64.data index d2be7a53b4..23167e231c 100644 --- a/tests/Verification/fvca_jdd64/fvca_jdd64.data +++ b/tests/Verification/fvca_jdd64/fvca_jdd64.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd65/fvca_jdd65.data b/tests/Verification/fvca_jdd65/fvca_jdd65.data index 4af61dde43..418c54eaca 100644 --- a/tests/Verification/fvca_jdd65/fvca_jdd65.data +++ b/tests/Verification/fvca_jdd65/fvca_jdd65.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd66/fvca_jdd66.data b/tests/Verification/fvca_jdd66/fvca_jdd66.data index 05870c3a7f..99de945bea 100644 --- a/tests/Verification/fvca_jdd66/fvca_jdd66.data +++ b/tests/Verification/fvca_jdd66/fvca_jdd66.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd67/fvca_jdd67.data b/tests/Verification/fvca_jdd67/fvca_jdd67.data index d2be7a53b4..23167e231c 100644 --- a/tests/Verification/fvca_jdd67/fvca_jdd67.data +++ b/tests/Verification/fvca_jdd67/fvca_jdd67.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd68/fvca_jdd68.data b/tests/Verification/fvca_jdd68/fvca_jdd68.data index 4af61dde43..418c54eaca 100644 --- a/tests/Verification/fvca_jdd68/fvca_jdd68.data +++ b/tests/Verification/fvca_jdd68/fvca_jdd68.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd69/fvca_jdd69.data b/tests/Verification/fvca_jdd69/fvca_jdd69.data index 05870c3a7f..99de945bea 100644 --- a/tests/Verification/fvca_jdd69/fvca_jdd69.data +++ b/tests/Verification/fvca_jdd69/fvca_jdd69.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd7/fvca_jdd7.data b/tests/Verification/fvca_jdd7/fvca_jdd7.data index f1b5d574c2..ad7aa6f4d1 100644 --- a/tests/Verification/fvca_jdd7/fvca_jdd7.data +++ b/tests/Verification/fvca_jdd7/fvca_jdd7.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd70/fvca_jdd70.data b/tests/Verification/fvca_jdd70/fvca_jdd70.data index d2be7a53b4..23167e231c 100644 --- a/tests/Verification/fvca_jdd70/fvca_jdd70.data +++ b/tests/Verification/fvca_jdd70/fvca_jdd70.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd71/fvca_jdd71.data b/tests/Verification/fvca_jdd71/fvca_jdd71.data index 4af61dde43..418c54eaca 100644 --- a/tests/Verification/fvca_jdd71/fvca_jdd71.data +++ b/tests/Verification/fvca_jdd71/fvca_jdd71.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd72/fvca_jdd72.data b/tests/Verification/fvca_jdd72/fvca_jdd72.data index 05870c3a7f..99de945bea 100644 --- a/tests/Verification/fvca_jdd72/fvca_jdd72.data +++ b/tests/Verification/fvca_jdd72/fvca_jdd72.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd73/fvca_jdd73.data b/tests/Verification/fvca_jdd73/fvca_jdd73.data index d2be7a53b4..23167e231c 100644 --- a/tests/Verification/fvca_jdd73/fvca_jdd73.data +++ b/tests/Verification/fvca_jdd73/fvca_jdd73.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd74/fvca_jdd74.data b/tests/Verification/fvca_jdd74/fvca_jdd74.data index 4af61dde43..418c54eaca 100644 --- a/tests/Verification/fvca_jdd74/fvca_jdd74.data +++ b/tests/Verification/fvca_jdd74/fvca_jdd74.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd75/fvca_jdd75.data b/tests/Verification/fvca_jdd75/fvca_jdd75.data index 05870c3a7f..99de945bea 100644 --- a/tests/Verification/fvca_jdd75/fvca_jdd75.data +++ b/tests/Verification/fvca_jdd75/fvca_jdd75.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd76/fvca_jdd76.data b/tests/Verification/fvca_jdd76/fvca_jdd76.data index d2be7a53b4..23167e231c 100644 --- a/tests/Verification/fvca_jdd76/fvca_jdd76.data +++ b/tests/Verification/fvca_jdd76/fvca_jdd76.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd77/fvca_jdd77.data b/tests/Verification/fvca_jdd77/fvca_jdd77.data index 4af61dde43..418c54eaca 100644 --- a/tests/Verification/fvca_jdd77/fvca_jdd77.data +++ b/tests/Verification/fvca_jdd77/fvca_jdd77.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd78/fvca_jdd78.data b/tests/Verification/fvca_jdd78/fvca_jdd78.data index 05870c3a7f..99de945bea 100644 --- a/tests/Verification/fvca_jdd78/fvca_jdd78.data +++ b/tests/Verification/fvca_jdd78/fvca_jdd78.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd79/fvca_jdd79.data b/tests/Verification/fvca_jdd79/fvca_jdd79.data index d2be7a53b4..23167e231c 100644 --- a/tests/Verification/fvca_jdd79/fvca_jdd79.data +++ b/tests/Verification/fvca_jdd79/fvca_jdd79.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd8/fvca_jdd8.data b/tests/Verification/fvca_jdd8/fvca_jdd8.data index e945a219e2..efafed5356 100644 --- a/tests/Verification/fvca_jdd8/fvca_jdd8.data +++ b/tests/Verification/fvca_jdd8/fvca_jdd8.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd80/fvca_jdd80.data b/tests/Verification/fvca_jdd80/fvca_jdd80.data index 4af61dde43..418c54eaca 100644 --- a/tests/Verification/fvca_jdd80/fvca_jdd80.data +++ b/tests/Verification/fvca_jdd80/fvca_jdd80.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd81/fvca_jdd81.data b/tests/Verification/fvca_jdd81/fvca_jdd81.data index 05870c3a7f..99de945bea 100644 --- a/tests/Verification/fvca_jdd81/fvca_jdd81.data +++ b/tests/Verification/fvca_jdd81/fvca_jdd81.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd82/fvca_jdd82.data b/tests/Verification/fvca_jdd82/fvca_jdd82.data index d2be7a53b4..23167e231c 100644 --- a/tests/Verification/fvca_jdd82/fvca_jdd82.data +++ b/tests/Verification/fvca_jdd82/fvca_jdd82.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd83/fvca_jdd83.data b/tests/Verification/fvca_jdd83/fvca_jdd83.data index 4af61dde43..418c54eaca 100644 --- a/tests/Verification/fvca_jdd83/fvca_jdd83.data +++ b/tests/Verification/fvca_jdd83/fvca_jdd83.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd84/fvca_jdd84.data b/tests/Verification/fvca_jdd84/fvca_jdd84.data index 05870c3a7f..99de945bea 100644 --- a/tests/Verification/fvca_jdd84/fvca_jdd84.data +++ b/tests/Verification/fvca_jdd84/fvca_jdd84.data @@ -62,7 +62,7 @@ Read pb } boundary_conditions { - boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 y-z z-x x-y + boundary frontiere_ouverte_vitesse_imposee champ_front_fonc_xyz 3 (y-z) (z-x) (x-y) } } @@ -94,7 +94,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 x^2+y^2+z^2-x*y-x*z-y*z-1/4 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (x^2+y^2+z^2-x*y-x*z-y*z-1/4) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode l2_norm sources_reference { erreur_P } } @@ -106,7 +106,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 3 y-z z-x x-y nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 3 (y-z) (z-x) (x-y) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode l2_norm source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/fvca_jdd9/fvca_jdd9.data b/tests/Verification/fvca_jdd9/fvca_jdd9.data index 0feaed6d84..5eaf631a82 100644 --- a/tests/Verification/fvca_jdd9/fvca_jdd9.data +++ b/tests/Verification/fvca_jdd9/fvca_jdd9.data @@ -60,7 +60,7 @@ Read pb { source_qdm champ_fonc_xyz dom 2 (256*(x^2*(x-1)^2*(12*y-6)+y*(y-1)*(2*y-1)*(12*x^2-12*x+2))+(y-1/2)) (-256*(y^2*(y-1)^2*(12*x-6)+x*(x-1)*(2*x-1)*(12*y^2-12*y+2))+(x-1/2)) } - initial_conditions { vitesse Champ_Fonc_xyz dom 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) } + initial_conditions { vitesse Champ_Fonc_xyz dom 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) } boundary_conditions { boundary paroi_fixe @@ -95,7 +95,7 @@ Read pb } nom_source pmp } , - transformation { methode formule expression 1 (x-1/2)*(y-1/2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 ((x-1/2)*(y-1/2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -107,7 +107,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 -256*x^2*(x-1)^2*y*(y-1)*(2*y-1) 256*y^2*(y-1)^2*x*(x-1)*(2*x-1) nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (-256*x^2*(x-1)^2*y*(y-1)*(2*y-1)) (256*y^2*(y-1)^2*x*(x-1)*(2*x-1)) nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd1/poiseuille_jdd1.data b/tests/Verification/poiseuille_jdd1/poiseuille_jdd1.data index 411ac8a50e..e759d9ff97 100644 --- a/tests/Verification/poiseuille_jdd1/poiseuille_jdd1.data +++ b/tests/Verification/poiseuille_jdd1/poiseuille_jdd1.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd10/poiseuille_jdd10.data b/tests/Verification/poiseuille_jdd10/poiseuille_jdd10.data index 76f2550bf7..6bcd11529e 100644 --- a/tests/Verification/poiseuille_jdd10/poiseuille_jdd10.data +++ b/tests/Verification/poiseuille_jdd10/poiseuille_jdd10.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd2/poiseuille_jdd2.data b/tests/Verification/poiseuille_jdd2/poiseuille_jdd2.data index 4ebcbda593..0d2df4aedb 100644 --- a/tests/Verification/poiseuille_jdd2/poiseuille_jdd2.data +++ b/tests/Verification/poiseuille_jdd2/poiseuille_jdd2.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd3/poiseuille_jdd3.data b/tests/Verification/poiseuille_jdd3/poiseuille_jdd3.data index 411ac8a50e..e759d9ff97 100644 --- a/tests/Verification/poiseuille_jdd3/poiseuille_jdd3.data +++ b/tests/Verification/poiseuille_jdd3/poiseuille_jdd3.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd4/poiseuille_jdd4.data b/tests/Verification/poiseuille_jdd4/poiseuille_jdd4.data index 76f2550bf7..6bcd11529e 100644 --- a/tests/Verification/poiseuille_jdd4/poiseuille_jdd4.data +++ b/tests/Verification/poiseuille_jdd4/poiseuille_jdd4.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd5/poiseuille_jdd5.data b/tests/Verification/poiseuille_jdd5/poiseuille_jdd5.data index 411ac8a50e..e759d9ff97 100644 --- a/tests/Verification/poiseuille_jdd5/poiseuille_jdd5.data +++ b/tests/Verification/poiseuille_jdd5/poiseuille_jdd5.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd6/poiseuille_jdd6.data b/tests/Verification/poiseuille_jdd6/poiseuille_jdd6.data index 411ac8a50e..e759d9ff97 100644 --- a/tests/Verification/poiseuille_jdd6/poiseuille_jdd6.data +++ b/tests/Verification/poiseuille_jdd6/poiseuille_jdd6.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd7/poiseuille_jdd7.data b/tests/Verification/poiseuille_jdd7/poiseuille_jdd7.data index 485f16ad37..d472075d91 100644 --- a/tests/Verification/poiseuille_jdd7/poiseuille_jdd7.data +++ b/tests/Verification/poiseuille_jdd7/poiseuille_jdd7.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd8/poiseuille_jdd8.data b/tests/Verification/poiseuille_jdd8/poiseuille_jdd8.data index 411ac8a50e..e759d9ff97 100644 --- a/tests/Verification/poiseuille_jdd8/poiseuille_jdd8.data +++ b/tests/Verification/poiseuille_jdd8/poiseuille_jdd8.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_jdd9/poiseuille_jdd9.data b/tests/Verification/poiseuille_jdd9/poiseuille_jdd9.data index 4ebcbda593..0d2df4aedb 100644 --- a/tests/Verification/poiseuille_jdd9/poiseuille_jdd9.data +++ b/tests/Verification/poiseuille_jdd9/poiseuille_jdd9.data @@ -79,7 +79,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -91,7 +91,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/poiseuille_vdf_jdd1/poiseuille_vdf_jdd1.data b/tests/Verification/poiseuille_vdf_jdd1/poiseuille_vdf_jdd1.data index 0657204a7d..c382f71bc1 100644 --- a/tests/Verification/poiseuille_vdf_jdd1/poiseuille_vdf_jdd1.data +++ b/tests/Verification/poiseuille_vdf_jdd1/poiseuille_vdf_jdd1.data @@ -69,8 +69,8 @@ Read pb { Definition_champs { - p_exact transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } - v_exact transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + p_exact transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + v_exact transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } probes { diff --git a/tests/Verification/poiseuille_vdf_jdd2/poiseuille_vdf_jdd2.data b/tests/Verification/poiseuille_vdf_jdd2/poiseuille_vdf_jdd2.data index 1057e2ea33..3dfbee25f2 100644 --- a/tests/Verification/poiseuille_vdf_jdd2/poiseuille_vdf_jdd2.data +++ b/tests/Verification/poiseuille_vdf_jdd2/poiseuille_vdf_jdd2.data @@ -69,8 +69,8 @@ Read pb { Definition_champs { - p_exact transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } - v_exact transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + p_exact transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + v_exact transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } probes { diff --git a/tests/Verification/poiseuille_vdf_jdd3/poiseuille_vdf_jdd3.data b/tests/Verification/poiseuille_vdf_jdd3/poiseuille_vdf_jdd3.data index 21302c849f..7712643470 100644 --- a/tests/Verification/poiseuille_vdf_jdd3/poiseuille_vdf_jdd3.data +++ b/tests/Verification/poiseuille_vdf_jdd3/poiseuille_vdf_jdd3.data @@ -69,8 +69,8 @@ Read pb { Definition_champs { - p_exact transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } - v_exact transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + p_exact transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + v_exact transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } probes { diff --git a/tests/Verification/poiseuille_vdf_jdd4/poiseuille_vdf_jdd4.data b/tests/Verification/poiseuille_vdf_jdd4/poiseuille_vdf_jdd4.data index 0657204a7d..c382f71bc1 100644 --- a/tests/Verification/poiseuille_vdf_jdd4/poiseuille_vdf_jdd4.data +++ b/tests/Verification/poiseuille_vdf_jdd4/poiseuille_vdf_jdd4.data @@ -69,8 +69,8 @@ Read pb { Definition_champs { - p_exact transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } - v_exact transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + p_exact transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + v_exact transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } probes { diff --git a/tests/Verification/poiseuille_vdf_jdd5/poiseuille_vdf_jdd5.data b/tests/Verification/poiseuille_vdf_jdd5/poiseuille_vdf_jdd5.data index 1057e2ea33..3dfbee25f2 100644 --- a/tests/Verification/poiseuille_vdf_jdd5/poiseuille_vdf_jdd5.data +++ b/tests/Verification/poiseuille_vdf_jdd5/poiseuille_vdf_jdd5.data @@ -69,8 +69,8 @@ Read pb { Definition_champs { - p_exact transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } - v_exact transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + p_exact transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + v_exact transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } probes { diff --git a/tests/Verification/poiseuille_vdf_jdd6/poiseuille_vdf_jdd6.data b/tests/Verification/poiseuille_vdf_jdd6/poiseuille_vdf_jdd6.data index 21302c849f..7712643470 100644 --- a/tests/Verification/poiseuille_vdf_jdd6/poiseuille_vdf_jdd6.data +++ b/tests/Verification/poiseuille_vdf_jdd6/poiseuille_vdf_jdd6.data @@ -69,8 +69,8 @@ Read pb { Definition_champs { - p_exact transformation { methode formule expression 1 100+(100-400)/1*(x-1) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } - v_exact transformation { methode vecteur expression 2 0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + p_exact transformation { methode formule expression 1 (100+(100-400)/1*(x-1)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + v_exact transformation { methode vecteur expression 2 (0.5/2.5*(400-100)/(1)*y*(1-y)+1*y/1) 0 localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } probes { diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd1/poissonSolver_PolyMAC_jdd1.data b/tests/Verification/poissonSolver_PolyMAC_jdd1/poissonSolver_PolyMAC_jdd1.data index 5769e987a5..712e2d72ab 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd1/poissonSolver_PolyMAC_jdd1.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd1/poissonSolver_PolyMAC_jdd1.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 2*cos(x)*sin(y) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (2*cos(x)*sin(y)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-sin(x)*sin(y)) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -cos(x)*cos(y) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-sin(x)*sin(y))) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-cos(x)*cos(y)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 cos(x)*sin(y) + Localisation (elem) + methode formule expression 1 (cos(x)*sin(y)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd10/poissonSolver_PolyMAC_jdd10.data b/tests/Verification/poissonSolver_PolyMAC_jdd10/poissonSolver_PolyMAC_jdd10.data index b7a631c843..6f8b8258a5 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd10/poissonSolver_PolyMAC_jdd10.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd10/poissonSolver_PolyMAC_jdd10.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 -(12*x^2+4*y-42+4*x+12*y^2-26) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (-(12*x^2+4*y-42+4*x+12*y^2-26)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(4*x^3+4*x*y-42*x+2*y^2-14) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-22+2*x^2-26*y+4*x*y+4*y^3) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(4*x^3+4*x*y-42*x+2*y^2-14)) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-22+2*x^2-26*y+4*x*y+4*y^3)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation FACES - methode formule expression 1 ((x^2+y-11)^2+(x+y^2-7)^2) + Localisation (FACES) + methode formule expression 1 (((x^2+y-11)^2+(x+y^2-7)^2)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation FACES + methode formule expression 1 (abs(temp-solution)) + localisation (FACES) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature FACES - solution FACES - erreur FACES + temperature (FACES) + solution (FACES) + erreur (FACES) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd11/poissonSolver_PolyMAC_jdd11.data b/tests/Verification/poissonSolver_PolyMAC_jdd11/poissonSolver_PolyMAC_jdd11.data index a27a6bc516..b879f0e326 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd11/poissonSolver_PolyMAC_jdd11.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd11/poissonSolver_PolyMAC_jdd11.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 2*cos(x)*sin(y) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (2*cos(x)*sin(y)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-sin(x)*sin(y)) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -cos(x)*cos(y) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-sin(x)*sin(y))) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-cos(x)*cos(y)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 cos(x)*sin(y) + Localisation (elem) + methode formule expression 1 (cos(x)*sin(y)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd12/poissonSolver_PolyMAC_jdd12.data b/tests/Verification/poissonSolver_PolyMAC_jdd12/poissonSolver_PolyMAC_jdd12.data index 291d409853..05a3383255 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd12/poissonSolver_PolyMAC_jdd12.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd12/poissonSolver_PolyMAC_jdd12.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 -(12*x^2+4*y-42+4*x+12*y^2-26) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (-(12*x^2+4*y-42+4*x+12*y^2-26)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(4*x^3+4*x*y-42*x+2*y^2-14) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-22+2*x^2-26*y+4*x*y+4*y^3) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(4*x^3+4*x*y-42*x+2*y^2-14)) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-22+2*x^2-26*y+4*x*y+4*y^3)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 ((x^2+y-11)^2+(x+y^2-7)^2) + Localisation (elem) + methode formule expression 1 (((x^2+y-11)^2+(x+y^2-7)^2)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd13/poissonSolver_PolyMAC_jdd13.data b/tests/Verification/poissonSolver_PolyMAC_jdd13/poissonSolver_PolyMAC_jdd13.data index 4e2c67fe5f..8db508ce06 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd13/poissonSolver_PolyMAC_jdd13.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd13/poissonSolver_PolyMAC_jdd13.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 2*cos(x)*sin(y) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (2*cos(x)*sin(y)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-sin(x)*sin(y)) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -cos(x)*cos(y) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-sin(x)*sin(y))) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-cos(x)*cos(y)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 cos(x)*sin(y) + Localisation (elem) + methode formule expression 1 (cos(x)*sin(y)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd14/poissonSolver_PolyMAC_jdd14.data b/tests/Verification/poissonSolver_PolyMAC_jdd14/poissonSolver_PolyMAC_jdd14.data index bd57599d80..bc6823e99a 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd14/poissonSolver_PolyMAC_jdd14.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd14/poissonSolver_PolyMAC_jdd14.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 -(12*x^2+4*y-42+4*x+12*y^2-26) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (-(12*x^2+4*y-42+4*x+12*y^2-26)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(4*x^3+4*x*y-42*x+2*y^2-14) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-22+2*x^2-26*y+4*x*y+4*y^3) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(4*x^3+4*x*y-42*x+2*y^2-14)) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-22+2*x^2-26*y+4*x*y+4*y^3)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 ((x^2+y-11)^2+(x+y^2-7)^2) + Localisation (elem) + methode formule expression 1 (((x^2+y-11)^2+(x+y^2-7)^2)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd15/poissonSolver_PolyMAC_jdd15.data b/tests/Verification/poissonSolver_PolyMAC_jdd15/poissonSolver_PolyMAC_jdd15.data index 33aeb316b9..19282d79da 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd15/poissonSolver_PolyMAC_jdd15.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd15/poissonSolver_PolyMAC_jdd15.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 2*cos(x)*sin(y) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (2*cos(x)*sin(y)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-sin(x)*sin(y)) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -cos(x)*cos(y) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-sin(x)*sin(y))) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-cos(x)*cos(y)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 cos(x)*sin(y) + Localisation (elem) + methode formule expression 1 (cos(x)*sin(y)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd16/poissonSolver_PolyMAC_jdd16.data b/tests/Verification/poissonSolver_PolyMAC_jdd16/poissonSolver_PolyMAC_jdd16.data index e57941aae6..1b71ded681 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd16/poissonSolver_PolyMAC_jdd16.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd16/poissonSolver_PolyMAC_jdd16.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 -(12*x^2+4*y-42+4*x+12*y^2-26) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (-(12*x^2+4*y-42+4*x+12*y^2-26)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(4*x^3+4*x*y-42*x+2*y^2-14) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-22+2*x^2-26*y+4*x*y+4*y^3) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(4*x^3+4*x*y-42*x+2*y^2-14)) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-22+2*x^2-26*y+4*x*y+4*y^3)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 ((x^2+y-11)^2+(x+y^2-7)^2) + Localisation (elem) + methode formule expression 1 (((x^2+y-11)^2+(x+y^2-7)^2)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd2/poissonSolver_PolyMAC_jdd2.data b/tests/Verification/poissonSolver_PolyMAC_jdd2/poissonSolver_PolyMAC_jdd2.data index 1ba90a7792..b2fc30cba1 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd2/poissonSolver_PolyMAC_jdd2.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd2/poissonSolver_PolyMAC_jdd2.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 -(12*x^2+4*y-42+4*x+12*y^2-26) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (-(12*x^2+4*y-42+4*x+12*y^2-26)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(4*x^3+4*x*y-42*x+2*y^2-14) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-22+2*x^2-26*y+4*x*y+4*y^3) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(4*x^3+4*x*y-42*x+2*y^2-14)) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-22+2*x^2-26*y+4*x*y+4*y^3)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 ((x^2+y-11)^2+(x+y^2-7)^2) + Localisation (elem) + methode formule expression 1 (((x^2+y-11)^2+(x+y^2-7)^2)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd3/poissonSolver_PolyMAC_jdd3.data b/tests/Verification/poissonSolver_PolyMAC_jdd3/poissonSolver_PolyMAC_jdd3.data index a27a6bc516..b879f0e326 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd3/poissonSolver_PolyMAC_jdd3.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd3/poissonSolver_PolyMAC_jdd3.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 2*cos(x)*sin(y) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (2*cos(x)*sin(y)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-sin(x)*sin(y)) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -cos(x)*cos(y) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-sin(x)*sin(y))) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-cos(x)*cos(y)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 cos(x)*sin(y) + Localisation (elem) + methode formule expression 1 (cos(x)*sin(y)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd4/poissonSolver_PolyMAC_jdd4.data b/tests/Verification/poissonSolver_PolyMAC_jdd4/poissonSolver_PolyMAC_jdd4.data index 291d409853..05a3383255 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd4/poissonSolver_PolyMAC_jdd4.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd4/poissonSolver_PolyMAC_jdd4.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 -(12*x^2+4*y-42+4*x+12*y^2-26) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (-(12*x^2+4*y-42+4*x+12*y^2-26)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(4*x^3+4*x*y-42*x+2*y^2-14) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-22+2*x^2-26*y+4*x*y+4*y^3) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(4*x^3+4*x*y-42*x+2*y^2-14)) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-22+2*x^2-26*y+4*x*y+4*y^3)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 ((x^2+y-11)^2+(x+y^2-7)^2) + Localisation (elem) + methode formule expression 1 (((x^2+y-11)^2+(x+y^2-7)^2)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd5/poissonSolver_PolyMAC_jdd5.data b/tests/Verification/poissonSolver_PolyMAC_jdd5/poissonSolver_PolyMAC_jdd5.data index 4e2c67fe5f..8db508ce06 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd5/poissonSolver_PolyMAC_jdd5.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd5/poissonSolver_PolyMAC_jdd5.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 2*cos(x)*sin(y) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (2*cos(x)*sin(y)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-sin(x)*sin(y)) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -cos(x)*cos(y) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-sin(x)*sin(y))) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-cos(x)*cos(y)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 cos(x)*sin(y) + Localisation (elem) + methode formule expression 1 (cos(x)*sin(y)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd6/poissonSolver_PolyMAC_jdd6.data b/tests/Verification/poissonSolver_PolyMAC_jdd6/poissonSolver_PolyMAC_jdd6.data index bd57599d80..bc6823e99a 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd6/poissonSolver_PolyMAC_jdd6.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd6/poissonSolver_PolyMAC_jdd6.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 -(12*x^2+4*y-42+4*x+12*y^2-26) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (-(12*x^2+4*y-42+4*x+12*y^2-26)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(4*x^3+4*x*y-42*x+2*y^2-14) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-22+2*x^2-26*y+4*x*y+4*y^3) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(4*x^3+4*x*y-42*x+2*y^2-14)) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-22+2*x^2-26*y+4*x*y+4*y^3)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 ((x^2+y-11)^2+(x+y^2-7)^2) + Localisation (elem) + methode formule expression 1 (((x^2+y-11)^2+(x+y^2-7)^2)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd7/poissonSolver_PolyMAC_jdd7.data b/tests/Verification/poissonSolver_PolyMAC_jdd7/poissonSolver_PolyMAC_jdd7.data index 33aeb316b9..19282d79da 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd7/poissonSolver_PolyMAC_jdd7.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd7/poissonSolver_PolyMAC_jdd7.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 2*cos(x)*sin(y) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (2*cos(x)*sin(y)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-sin(x)*sin(y)) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -cos(x)*cos(y) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-sin(x)*sin(y))) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-cos(x)*cos(y)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 cos(x)*sin(y) + Localisation (elem) + methode formule expression 1 (cos(x)*sin(y)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd8/poissonSolver_PolyMAC_jdd8.data b/tests/Verification/poissonSolver_PolyMAC_jdd8/poissonSolver_PolyMAC_jdd8.data index e57941aae6..1b71ded681 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd8/poissonSolver_PolyMAC_jdd8.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd8/poissonSolver_PolyMAC_jdd8.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 -(12*x^2+4*y-42+4*x+12*y^2-26) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (-(12*x^2+4*y-42+4*x+12*y^2-26)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(4*x^3+4*x*y-42*x+2*y^2-14) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 ((x^2+y-11)^2+(x+y^2-7)^2) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-22+2*x^2-26*y+4*x*y+4*y^3) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(4*x^3+4*x*y-42*x+2*y^2-14)) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (((x^2+y-11)^2+(x+y^2-7)^2)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-22+2*x^2-26*y+4*x*y+4*y^3)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation elem - methode formule expression 1 ((x^2+y-11)^2+(x+y^2-7)^2) + Localisation (elem) + methode formule expression 1 (((x^2+y-11)^2+(x+y^2-7)^2)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation elem + methode formule expression 1 (abs(temp-solution)) + localisation (elem) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature elem - solution elem - erreur elem + temperature (elem) + solution (elem) + erreur (elem) } } } diff --git a/tests/Verification/poissonSolver_PolyMAC_jdd9/poissonSolver_PolyMAC_jdd9.data b/tests/Verification/poissonSolver_PolyMAC_jdd9/poissonSolver_PolyMAC_jdd9.data index 54ed659f88..7789130bc1 100644 --- a/tests/Verification/poissonSolver_PolyMAC_jdd9/poissonSolver_PolyMAC_jdd9.data +++ b/tests/Verification/poissonSolver_PolyMAC_jdd9/poissonSolver_PolyMAC_jdd9.data @@ -55,14 +55,14 @@ Read pb Conduction { diffusion { } - sources { Puissance_thermique Champ_Fonc_XYZ dom 1 2*cos(x)*sin(y) } + sources { Puissance_thermique Champ_Fonc_XYZ dom 1 (2*cos(x)*sin(y)) } initial_conditions { temperature Champ_Uniforme 1 0 } boundary_conditions { - left paroi_flux_impose Champ_Front_fonc_XYZ 1 -(-sin(x)*sin(y)) - right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 cos(x)*sin(y) - down paroi_flux_impose Champ_Front_fonc_XYZ 1 -cos(x)*cos(y) + left paroi_flux_impose Champ_Front_fonc_XYZ 1 (-(-sin(x)*sin(y))) + right paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + up paroi_temperature_imposee Champ_Front_fonc_XYZ 1 (cos(x)*sin(y)) + down paroi_flux_impose Champ_Front_fonc_XYZ 1 (-cos(x)*cos(y)) } } @@ -74,14 +74,14 @@ Read pb Definition_champs { solution transformation { - Localisation FACES - methode formule expression 1 cos(x)*sin(y) + Localisation (FACES) + methode formule expression 1 (cos(x)*sin(y)) } erreur transformation { - methode formule expression 1 abs(temp-solution) - localisation FACES + methode formule expression 1 (abs(temp-solution)) + localisation (FACES) sources { refChamp { Pb_champ pb temperature nom_source temp } @@ -115,9 +115,9 @@ Read pb format LATA fields dt_post 30. { - temperature FACES - solution FACES - erreur FACES + temperature (FACES) + solution (FACES) + erreur (FACES) } } } diff --git a/tests/Verification/porosite_1D_jdd1/porosite_1D_jdd1.data b/tests/Verification/porosite_1D_jdd1/porosite_1D_jdd1.data index 6eaad73eee..e9f40d0a6c 100644 --- a/tests/Verification/porosite_1D_jdd1/porosite_1D_jdd1.data +++ b/tests/Verification/porosite_1D_jdd1/porosite_1D_jdd1.data @@ -85,13 +85,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/tests/Verification/porosite_1D_jdd2/porosite_1D_jdd2.data b/tests/Verification/porosite_1D_jdd2/porosite_1D_jdd2.data index 8bbd9a4465..da293d5398 100644 --- a/tests/Verification/porosite_1D_jdd2/porosite_1D_jdd2.data +++ b/tests/Verification/porosite_1D_jdd2/porosite_1D_jdd2.data @@ -85,13 +85,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/tests/Verification/porosite_1D_jdd3/porosite_1D_jdd3.data b/tests/Verification/porosite_1D_jdd3/porosite_1D_jdd3.data index 67e965564b..efbdb2045c 100644 --- a/tests/Verification/porosite_1D_jdd3/porosite_1D_jdd3.data +++ b/tests/Verification/porosite_1D_jdd3/porosite_1D_jdd3.data @@ -85,13 +85,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/tests/Verification/porosite_1D_jdd4/porosite_1D_jdd4.data b/tests/Verification/porosite_1D_jdd4/porosite_1D_jdd4.data index 319313b205..073f3a6f0c 100644 --- a/tests/Verification/porosite_1D_jdd4/porosite_1D_jdd4.data +++ b/tests/Verification/porosite_1D_jdd4/porosite_1D_jdd4.data @@ -85,13 +85,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/tests/Verification/porosite_1D_jdd5/porosite_1D_jdd5.data b/tests/Verification/porosite_1D_jdd5/porosite_1D_jdd5.data index deebbaf78a..d3245aaf47 100644 --- a/tests/Verification/porosite_1D_jdd5/porosite_1D_jdd5.data +++ b/tests/Verification/porosite_1D_jdd5/porosite_1D_jdd5.data @@ -85,13 +85,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/tests/Verification/porosite_1D_jdd6/porosite_1D_jdd6.data b/tests/Verification/porosite_1D_jdd6/porosite_1D_jdd6.data index 02325e20b3..b0ca7165f0 100644 --- a/tests/Verification/porosite_1D_jdd6/porosite_1D_jdd6.data +++ b/tests/Verification/porosite_1D_jdd6/porosite_1D_jdd6.data @@ -85,13 +85,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/tests/Verification/porosite_1D_jdd7/porosite_1D_jdd7.data b/tests/Verification/porosite_1D_jdd7/porosite_1D_jdd7.data index cf81d944af..697da3e2c2 100644 --- a/tests/Verification/porosite_1D_jdd7/porosite_1D_jdd7.data +++ b/tests/Verification/porosite_1D_jdd7/porosite_1D_jdd7.data @@ -85,13 +85,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/tests/Verification/porosite_1D_jdd8/porosite_1D_jdd8.data b/tests/Verification/porosite_1D_jdd8/porosite_1D_jdd8.data index ad053be71e..e1e998874e 100644 --- a/tests/Verification/porosite_1D_jdd8/porosite_1D_jdd8.data +++ b/tests/Verification/porosite_1D_jdd8/porosite_1D_jdd8.data @@ -85,13 +85,13 @@ Read pb { P_ex transformation { - methode formule expression 1 1e5+(z>1)*(z<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } + methode formule expression 1 (1e5+(z>1)*(z<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } /* aux elems */ V_ex transformation { - methode vecteur expression 3 0 0 1+(z>1)*(z<2) nom_source sol source refChamp { Pb_champ pb pression } + methode vecteur expression 3 0 0 (1+(z>1)*(z<2)) nom_source sol source refChamp { Pb_champ pb pression } } } probes diff --git a/tests/Verification/porosite_2D_jdd1/porosite_2D_jdd1.data b/tests/Verification/porosite_2D_jdd1/porosite_2D_jdd1.data index 47b84329f7..d9c81fc30c 100644 --- a/tests/Verification/porosite_2D_jdd1/porosite_2D_jdd1.data +++ b/tests/Verification/porosite_2D_jdd1/porosite_2D_jdd1.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd10/porosite_2D_jdd10.data b/tests/Verification/porosite_2D_jdd10/porosite_2D_jdd10.data index 30e8a6c62b..734984375f 100644 --- a/tests/Verification/porosite_2D_jdd10/porosite_2D_jdd10.data +++ b/tests/Verification/porosite_2D_jdd10/porosite_2D_jdd10.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd2/porosite_2D_jdd2.data b/tests/Verification/porosite_2D_jdd2/porosite_2D_jdd2.data index 466f7c04bf..a523925512 100644 --- a/tests/Verification/porosite_2D_jdd2/porosite_2D_jdd2.data +++ b/tests/Verification/porosite_2D_jdd2/porosite_2D_jdd2.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd3/porosite_2D_jdd3.data b/tests/Verification/porosite_2D_jdd3/porosite_2D_jdd3.data index 47b84329f7..d9c81fc30c 100644 --- a/tests/Verification/porosite_2D_jdd3/porosite_2D_jdd3.data +++ b/tests/Verification/porosite_2D_jdd3/porosite_2D_jdd3.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd4/porosite_2D_jdd4.data b/tests/Verification/porosite_2D_jdd4/porosite_2D_jdd4.data index 30e8a6c62b..734984375f 100644 --- a/tests/Verification/porosite_2D_jdd4/porosite_2D_jdd4.data +++ b/tests/Verification/porosite_2D_jdd4/porosite_2D_jdd4.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd5/porosite_2D_jdd5.data b/tests/Verification/porosite_2D_jdd5/porosite_2D_jdd5.data index 47b84329f7..d9c81fc30c 100644 --- a/tests/Verification/porosite_2D_jdd5/porosite_2D_jdd5.data +++ b/tests/Verification/porosite_2D_jdd5/porosite_2D_jdd5.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd6/porosite_2D_jdd6.data b/tests/Verification/porosite_2D_jdd6/porosite_2D_jdd6.data index 47b84329f7..d9c81fc30c 100644 --- a/tests/Verification/porosite_2D_jdd6/porosite_2D_jdd6.data +++ b/tests/Verification/porosite_2D_jdd6/porosite_2D_jdd6.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd7/porosite_2D_jdd7.data b/tests/Verification/porosite_2D_jdd7/porosite_2D_jdd7.data index af6cd0be63..765f4afa3e 100644 --- a/tests/Verification/porosite_2D_jdd7/porosite_2D_jdd7.data +++ b/tests/Verification/porosite_2D_jdd7/porosite_2D_jdd7.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd8/porosite_2D_jdd8.data b/tests/Verification/porosite_2D_jdd8/porosite_2D_jdd8.data index 47b84329f7..d9c81fc30c 100644 --- a/tests/Verification/porosite_2D_jdd8/porosite_2D_jdd8.data +++ b/tests/Verification/porosite_2D_jdd8/porosite_2D_jdd8.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/porosite_2D_jdd9/porosite_2D_jdd9.data b/tests/Verification/porosite_2D_jdd9/porosite_2D_jdd9.data index 466f7c04bf..a523925512 100644 --- a/tests/Verification/porosite_2D_jdd9/porosite_2D_jdd9.data +++ b/tests/Verification/porosite_2D_jdd9/porosite_2D_jdd9.data @@ -48,7 +48,7 @@ Read pb fluide_incompressible { mu Champ_Uniforme 1 2.5 rho Champ_Uniforme 1 1000 - porosites_champ champ_fonc_xyz dom 1 1-0.5*(y>1)*(y<2) + porosites_champ champ_fonc_xyz dom 1 (1-0.5*(y>1)*(y<2)) } @@ -77,7 +77,7 @@ Read pb sources { Interpolation { localisation elem nom_source p source refChamp { Pb_champ pb pression_pa } } , - transformation { methode formule expression 1 1e5+(y>1)*(y<2)*500*(1-1/0.5^2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode formule expression 1 (1e5+(y>1)*(y<2)*500*(1-1/0.5^2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_P_max reduction_0D { methode max sources_reference { erreur_P } } @@ -89,7 +89,7 @@ Read pb sources { Interpolation { localisation elem nom_source v source refChamp { Pb_champ pb vitesse } } , - transformation { methode vecteur expression 2 0 1+(y>1)*(y<2) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } + transformation { methode vecteur expression 2 0 (1+(y>1)*(y<2)) localisation elem nom_source sol source refChamp { Pb_champ pb pression } } } } erreur_V_max reduction_0D { methode max source transformation { methode norme sources_reference { erreur_V } } } diff --git a/tests/Verification/tubes_a_choc_jdd1/tubes_a_choc_jdd1.data b/tests/Verification/tubes_a_choc_jdd1/tubes_a_choc_jdd1.data index 05e0cc0bcb..d89a7021ab 100644 --- a/tests/Verification/tubes_a_choc_jdd1/tubes_a_choc_jdd1.data +++ b/tests/Verification/tubes_a_choc_jdd1/tubes_a_choc_jdd1.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0.75*(x[0.3)+(0)*(x>0.3) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.3)+0.1*(x>0.3) + vitesse Champ_fonc_xyz dom 2 (0.75*(x[0.3)+(0)*(x>0.3)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.3)+0.1*(x>0.3)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.3)+0.1*(x>0.3))+0)/((1*(x[0.3)+0.125*(x>0.3))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.3)+0.1*(x>0.3))+0)/((1*(x[0.3)+0.125*(x>0.3))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd10/tubes_a_choc_jdd10.data b/tests/Verification/tubes_a_choc_jdd10/tubes_a_choc_jdd10.data index bc81b325cc..e5d97a8ba6 100644 --- a/tests/Verification/tubes_a_choc_jdd10/tubes_a_choc_jdd10.data +++ b/tests/Verification/tubes_a_choc_jdd10/tubes_a_choc_jdd10.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0.75*(x[0.3)+(0)*(x>0.3) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.3)+0.1*(x>0.3) + vitesse Champ_fonc_xyz dom 2 (0.75*(x[0.3)+(0)*(x>0.3)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.3)+0.1*(x>0.3)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.3)+0.1*(x>0.3))+0)/((1*(x[0.3)+0.125*(x>0.3))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.3)+0.1*(x>0.3))+0)/((1*(x[0.3)+0.125*(x>0.3))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd11/tubes_a_choc_jdd11.data b/tests/Verification/tubes_a_choc_jdd11/tubes_a_choc_jdd11.data index 752c33a35c..c8bdeb23a3 100644 --- a/tests/Verification/tubes_a_choc_jdd11/tubes_a_choc_jdd11.data +++ b/tests/Verification/tubes_a_choc_jdd11/tubes_a_choc_jdd11.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 -2*(x[0.5)+(2)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 0.4*(x[0.5)+0.4*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (-2*(x[0.5)+(2)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (0.4*(x[0.5)+0.4*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((0.4*(x[0.5)+0.4*(x>0.5))+0)/((1*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((0.4*(x[0.5)+0.4*(x>0.5))+0)/((1*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd12/tubes_a_choc_jdd12.data b/tests/Verification/tubes_a_choc_jdd12/tubes_a_choc_jdd12.data index 17f33cea68..49086d7e62 100644 --- a/tests/Verification/tubes_a_choc_jdd12/tubes_a_choc_jdd12.data +++ b/tests/Verification/tubes_a_choc_jdd12/tubes_a_choc_jdd12.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 19.5975*(x[0.4)+(-6.19633)*(x>0.4) 0 - pression Champ_fonc_xyz dom 1 460.894*(x[0.4)+46.095*(x>0.4) + vitesse Champ_fonc_xyz dom 2 (19.5975*(x[0.4)+(-6.19633)*(x>0.4)) 0 + pression Champ_fonc_xyz dom 1 (460.894*(x[0.4)+46.095*(x>0.4)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((460.894*(x[0.4)+46.095*(x>0.4))+0)/((5.99924*(x[0.4)+5.99242*(x>0.4))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((460.894*(x[0.4)+46.095*(x>0.4))+0)/((5.99924*(x[0.4)+5.99242*(x>0.4))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd13/tubes_a_choc_jdd13.data b/tests/Verification/tubes_a_choc_jdd13/tubes_a_choc_jdd13.data index c0798cc0bd..9d79a2132b 100644 --- a/tests/Verification/tubes_a_choc_jdd13/tubes_a_choc_jdd13.data +++ b/tests/Verification/tubes_a_choc_jdd13/tubes_a_choc_jdd13.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 -19.5975*(x[0.8)+(-19.59745)*(x>0.8) 0 - pression Champ_fonc_xyz dom 1 1000*(x[0.8)+0.01*(x>0.8) + vitesse Champ_fonc_xyz dom 2 (-19.5975*(x[0.8)+(-19.59745)*(x>0.8)) 0 + pression Champ_fonc_xyz dom 1 (1000*(x[0.8)+0.01*(x>0.8)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1000*(x[0.8)+0.01*(x>0.8))+0)/((1*(x[0.8)+1*(x>0.8))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1000*(x[0.8)+0.01*(x>0.8))+0)/((1*(x[0.8)+1*(x>0.8))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd14/tubes_a_choc_jdd14.data b/tests/Verification/tubes_a_choc_jdd14/tubes_a_choc_jdd14.data index 59867e0608..9917a66ee9 100644 --- a/tests/Verification/tubes_a_choc_jdd14/tubes_a_choc_jdd14.data +++ b/tests/Verification/tubes_a_choc_jdd14/tubes_a_choc_jdd14.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.5)+1*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.5)+1*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1.4*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1.4*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd15/tubes_a_choc_jdd15.data b/tests/Verification/tubes_a_choc_jdd15/tubes_a_choc_jdd15.data index f3dd4eb729..63dc67d3a5 100644 --- a/tests/Verification/tubes_a_choc_jdd15/tubes_a_choc_jdd15.data +++ b/tests/Verification/tubes_a_choc_jdd15/tubes_a_choc_jdd15.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0.1*(x[0.5)+(0.1)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.5)+1*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0.1*(x[0.5)+(0.1)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.5)+1*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd16/tubes_a_choc_jdd16.data b/tests/Verification/tubes_a_choc_jdd16/tubes_a_choc_jdd16.data index ae0578c095..4306bba6c4 100644 --- a/tests/Verification/tubes_a_choc_jdd16/tubes_a_choc_jdd16.data +++ b/tests/Verification/tubes_a_choc_jdd16/tubes_a_choc_jdd16.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+100000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+100000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+100000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+100000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd17/tubes_a_choc_jdd17.data b/tests/Verification/tubes_a_choc_jdd17/tubes_a_choc_jdd17.data index a8f7b157eb..8bdebb003c 100644 --- a/tests/Verification/tubes_a_choc_jdd17/tubes_a_choc_jdd17.data +++ b/tests/Verification/tubes_a_choc_jdd17/tubes_a_choc_jdd17.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(20)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+15500000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(20)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+15500000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd18/tubes_a_choc_jdd18.data b/tests/Verification/tubes_a_choc_jdd18/tubes_a_choc_jdd18.data index e6550c8748..44683bcaa2 100644 --- a/tests/Verification/tubes_a_choc_jdd18/tubes_a_choc_jdd18.data +++ b/tests/Verification/tubes_a_choc_jdd18/tubes_a_choc_jdd18.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+15500000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+15500000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+650*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+650*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd19/tubes_a_choc_jdd19.data b/tests/Verification/tubes_a_choc_jdd19/tubes_a_choc_jdd19.data index 1829c4ab1d..32d86185d5 100644 --- a/tests/Verification/tubes_a_choc_jdd19/tubes_a_choc_jdd19.data +++ b/tests/Verification/tubes_a_choc_jdd19/tubes_a_choc_jdd19.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0.75*(x[0.3)+(0)*(x>0.3) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.3)+0.1*(x>0.3) + vitesse Champ_fonc_xyz dom 2 (0.75*(x[0.3)+(0)*(x>0.3)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.3)+0.1*(x>0.3)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.3)+0.1*(x>0.3))+0)/((1*(x[0.3)+0.125*(x>0.3))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.3)+0.1*(x>0.3))+0)/((1*(x[0.3)+0.125*(x>0.3))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd2/tubes_a_choc_jdd2.data b/tests/Verification/tubes_a_choc_jdd2/tubes_a_choc_jdd2.data index 67af44f06d..d1df46bf13 100644 --- a/tests/Verification/tubes_a_choc_jdd2/tubes_a_choc_jdd2.data +++ b/tests/Verification/tubes_a_choc_jdd2/tubes_a_choc_jdd2.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 -2*(x[0.5)+(2)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 0.4*(x[0.5)+0.4*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (-2*(x[0.5)+(2)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (0.4*(x[0.5)+0.4*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((0.4*(x[0.5)+0.4*(x>0.5))+0)/((1*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((0.4*(x[0.5)+0.4*(x>0.5))+0)/((1*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd20/tubes_a_choc_jdd20.data b/tests/Verification/tubes_a_choc_jdd20/tubes_a_choc_jdd20.data index b375fa645e..374c655078 100644 --- a/tests/Verification/tubes_a_choc_jdd20/tubes_a_choc_jdd20.data +++ b/tests/Verification/tubes_a_choc_jdd20/tubes_a_choc_jdd20.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 -2*(x[0.5)+(2)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 0.4*(x[0.5)+0.4*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (-2*(x[0.5)+(2)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (0.4*(x[0.5)+0.4*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((0.4*(x[0.5)+0.4*(x>0.5))+0)/((1*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((0.4*(x[0.5)+0.4*(x>0.5))+0)/((1*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd21/tubes_a_choc_jdd21.data b/tests/Verification/tubes_a_choc_jdd21/tubes_a_choc_jdd21.data index 42b0ca3b6b..3c48318a36 100644 --- a/tests/Verification/tubes_a_choc_jdd21/tubes_a_choc_jdd21.data +++ b/tests/Verification/tubes_a_choc_jdd21/tubes_a_choc_jdd21.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 19.5975*(x[0.4)+(-6.19633)*(x>0.4) 0 - pression Champ_fonc_xyz dom 1 460.894*(x[0.4)+46.095*(x>0.4) + vitesse Champ_fonc_xyz dom 2 (19.5975*(x[0.4)+(-6.19633)*(x>0.4)) 0 + pression Champ_fonc_xyz dom 1 (460.894*(x[0.4)+46.095*(x>0.4)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((460.894*(x[0.4)+46.095*(x>0.4))+0)/((5.99924*(x[0.4)+5.99242*(x>0.4))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((460.894*(x[0.4)+46.095*(x>0.4))+0)/((5.99924*(x[0.4)+5.99242*(x>0.4))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd22/tubes_a_choc_jdd22.data b/tests/Verification/tubes_a_choc_jdd22/tubes_a_choc_jdd22.data index 1c8a6ad039..0663c73d4a 100644 --- a/tests/Verification/tubes_a_choc_jdd22/tubes_a_choc_jdd22.data +++ b/tests/Verification/tubes_a_choc_jdd22/tubes_a_choc_jdd22.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 -19.5975*(x[0.8)+(-19.59745)*(x>0.8) 0 - pression Champ_fonc_xyz dom 1 1000*(x[0.8)+0.01*(x>0.8) + vitesse Champ_fonc_xyz dom 2 (-19.5975*(x[0.8)+(-19.59745)*(x>0.8)) 0 + pression Champ_fonc_xyz dom 1 (1000*(x[0.8)+0.01*(x>0.8)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1000*(x[0.8)+0.01*(x>0.8))+0)/((1*(x[0.8)+1*(x>0.8))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1000*(x[0.8)+0.01*(x>0.8))+0)/((1*(x[0.8)+1*(x>0.8))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd23/tubes_a_choc_jdd23.data b/tests/Verification/tubes_a_choc_jdd23/tubes_a_choc_jdd23.data index 960c223791..d6d0e0fb9f 100644 --- a/tests/Verification/tubes_a_choc_jdd23/tubes_a_choc_jdd23.data +++ b/tests/Verification/tubes_a_choc_jdd23/tubes_a_choc_jdd23.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.5)+1*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.5)+1*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1.4*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1.4*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd24/tubes_a_choc_jdd24.data b/tests/Verification/tubes_a_choc_jdd24/tubes_a_choc_jdd24.data index 24241ccb96..d972092f68 100644 --- a/tests/Verification/tubes_a_choc_jdd24/tubes_a_choc_jdd24.data +++ b/tests/Verification/tubes_a_choc_jdd24/tubes_a_choc_jdd24.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0.1*(x[0.5)+(0.1)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.5)+1*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0.1*(x[0.5)+(0.1)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.5)+1*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd25/tubes_a_choc_jdd25.data b/tests/Verification/tubes_a_choc_jdd25/tubes_a_choc_jdd25.data index f80150c489..27b5d70e56 100644 --- a/tests/Verification/tubes_a_choc_jdd25/tubes_a_choc_jdd25.data +++ b/tests/Verification/tubes_a_choc_jdd25/tubes_a_choc_jdd25.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+100000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+100000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+100000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+100000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd26/tubes_a_choc_jdd26.data b/tests/Verification/tubes_a_choc_jdd26/tubes_a_choc_jdd26.data index 609015fc96..fae708f9ef 100644 --- a/tests/Verification/tubes_a_choc_jdd26/tubes_a_choc_jdd26.data +++ b/tests/Verification/tubes_a_choc_jdd26/tubes_a_choc_jdd26.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(20)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+15500000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(20)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+15500000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd27/tubes_a_choc_jdd27.data b/tests/Verification/tubes_a_choc_jdd27/tubes_a_choc_jdd27.data index 4beb80aeb3..8164b9dc76 100644 --- a/tests/Verification/tubes_a_choc_jdd27/tubes_a_choc_jdd27.data +++ b/tests/Verification/tubes_a_choc_jdd27/tubes_a_choc_jdd27.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+15500000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+15500000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+650*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+650*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd28/tubes_a_choc_jdd28.data b/tests/Verification/tubes_a_choc_jdd28/tubes_a_choc_jdd28.data index 2fe86b1dbd..b7905bc40c 100644 --- a/tests/Verification/tubes_a_choc_jdd28/tubes_a_choc_jdd28.data +++ b/tests/Verification/tubes_a_choc_jdd28/tubes_a_choc_jdd28.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0.75*(x[0.3)+(0)*(x>0.3) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.3)+0.1*(x>0.3) + vitesse Champ_fonc_xyz dom 2 (0.75*(x[0.3)+(0)*(x>0.3)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.3)+0.1*(x>0.3)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.3)+0.1*(x>0.3))+0)/((1*(x[0.3)+0.125*(x>0.3))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.3)+0.1*(x>0.3))+0)/((1*(x[0.3)+0.125*(x>0.3))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd29/tubes_a_choc_jdd29.data b/tests/Verification/tubes_a_choc_jdd29/tubes_a_choc_jdd29.data index 4e7a72bf2c..e89b60c266 100644 --- a/tests/Verification/tubes_a_choc_jdd29/tubes_a_choc_jdd29.data +++ b/tests/Verification/tubes_a_choc_jdd29/tubes_a_choc_jdd29.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 -2*(x[0.5)+(2)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 0.4*(x[0.5)+0.4*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (-2*(x[0.5)+(2)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (0.4*(x[0.5)+0.4*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((0.4*(x[0.5)+0.4*(x>0.5))+0)/((1*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((0.4*(x[0.5)+0.4*(x>0.5))+0)/((1*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd3/tubes_a_choc_jdd3.data b/tests/Verification/tubes_a_choc_jdd3/tubes_a_choc_jdd3.data index 1a92ddbd39..a8899c216b 100644 --- a/tests/Verification/tubes_a_choc_jdd3/tubes_a_choc_jdd3.data +++ b/tests/Verification/tubes_a_choc_jdd3/tubes_a_choc_jdd3.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 19.5975*(x[0.4)+(-6.19633)*(x>0.4) 0 - pression Champ_fonc_xyz dom 1 460.894*(x[0.4)+46.095*(x>0.4) + vitesse Champ_fonc_xyz dom 2 (19.5975*(x[0.4)+(-6.19633)*(x>0.4)) 0 + pression Champ_fonc_xyz dom 1 (460.894*(x[0.4)+46.095*(x>0.4)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((460.894*(x[0.4)+46.095*(x>0.4))+0)/((5.99924*(x[0.4)+5.99242*(x>0.4))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((460.894*(x[0.4)+46.095*(x>0.4))+0)/((5.99924*(x[0.4)+5.99242*(x>0.4))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd30/tubes_a_choc_jdd30.data b/tests/Verification/tubes_a_choc_jdd30/tubes_a_choc_jdd30.data index 67ee570088..1a1035790c 100644 --- a/tests/Verification/tubes_a_choc_jdd30/tubes_a_choc_jdd30.data +++ b/tests/Verification/tubes_a_choc_jdd30/tubes_a_choc_jdd30.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 19.5975*(x[0.4)+(-6.19633)*(x>0.4) 0 - pression Champ_fonc_xyz dom 1 460.894*(x[0.4)+46.095*(x>0.4) + vitesse Champ_fonc_xyz dom 2 (19.5975*(x[0.4)+(-6.19633)*(x>0.4)) 0 + pression Champ_fonc_xyz dom 1 (460.894*(x[0.4)+46.095*(x>0.4)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((460.894*(x[0.4)+46.095*(x>0.4))+0)/((5.99924*(x[0.4)+5.99242*(x>0.4))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((460.894*(x[0.4)+46.095*(x>0.4))+0)/((5.99924*(x[0.4)+5.99242*(x>0.4))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd31/tubes_a_choc_jdd31.data b/tests/Verification/tubes_a_choc_jdd31/tubes_a_choc_jdd31.data index bdfd0454f3..1697ff2836 100644 --- a/tests/Verification/tubes_a_choc_jdd31/tubes_a_choc_jdd31.data +++ b/tests/Verification/tubes_a_choc_jdd31/tubes_a_choc_jdd31.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 -19.5975*(x[0.8)+(-19.59745)*(x>0.8) 0 - pression Champ_fonc_xyz dom 1 1000*(x[0.8)+0.01*(x>0.8) + vitesse Champ_fonc_xyz dom 2 (-19.5975*(x[0.8)+(-19.59745)*(x>0.8)) 0 + pression Champ_fonc_xyz dom 1 (1000*(x[0.8)+0.01*(x>0.8)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1000*(x[0.8)+0.01*(x>0.8))+0)/((1*(x[0.8)+1*(x>0.8))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1000*(x[0.8)+0.01*(x>0.8))+0)/((1*(x[0.8)+1*(x>0.8))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd32/tubes_a_choc_jdd32.data b/tests/Verification/tubes_a_choc_jdd32/tubes_a_choc_jdd32.data index 859ea731da..2a671ceb47 100644 --- a/tests/Verification/tubes_a_choc_jdd32/tubes_a_choc_jdd32.data +++ b/tests/Verification/tubes_a_choc_jdd32/tubes_a_choc_jdd32.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.5)+1*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.5)+1*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1.4*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1.4*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd33/tubes_a_choc_jdd33.data b/tests/Verification/tubes_a_choc_jdd33/tubes_a_choc_jdd33.data index 0f2188327f..7ae82fb01d 100644 --- a/tests/Verification/tubes_a_choc_jdd33/tubes_a_choc_jdd33.data +++ b/tests/Verification/tubes_a_choc_jdd33/tubes_a_choc_jdd33.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0.1*(x[0.5)+(0.1)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.5)+1*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0.1*(x[0.5)+(0.1)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.5)+1*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd34/tubes_a_choc_jdd34.data b/tests/Verification/tubes_a_choc_jdd34/tubes_a_choc_jdd34.data index 999936b531..0a4e32f5f0 100644 --- a/tests/Verification/tubes_a_choc_jdd34/tubes_a_choc_jdd34.data +++ b/tests/Verification/tubes_a_choc_jdd34/tubes_a_choc_jdd34.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+100000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+100000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+100000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+100000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd35/tubes_a_choc_jdd35.data b/tests/Verification/tubes_a_choc_jdd35/tubes_a_choc_jdd35.data index c3cb972d28..b96d96c101 100644 --- a/tests/Verification/tubes_a_choc_jdd35/tubes_a_choc_jdd35.data +++ b/tests/Verification/tubes_a_choc_jdd35/tubes_a_choc_jdd35.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(20)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+15500000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(20)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+15500000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd36/tubes_a_choc_jdd36.data b/tests/Verification/tubes_a_choc_jdd36/tubes_a_choc_jdd36.data index e3b7596b0e..0dc535c791 100644 --- a/tests/Verification/tubes_a_choc_jdd36/tubes_a_choc_jdd36.data +++ b/tests/Verification/tubes_a_choc_jdd36/tubes_a_choc_jdd36.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+15500000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+15500000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+650*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+650*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd4/tubes_a_choc_jdd4.data b/tests/Verification/tubes_a_choc_jdd4/tubes_a_choc_jdd4.data index 91d7b1f5ff..ac7d76e7c6 100644 --- a/tests/Verification/tubes_a_choc_jdd4/tubes_a_choc_jdd4.data +++ b/tests/Verification/tubes_a_choc_jdd4/tubes_a_choc_jdd4.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 -19.5975*(x[0.8)+(-19.59745)*(x>0.8) 0 - pression Champ_fonc_xyz dom 1 1000*(x[0.8)+0.01*(x>0.8) + vitesse Champ_fonc_xyz dom 2 (-19.5975*(x[0.8)+(-19.59745)*(x>0.8)) 0 + pression Champ_fonc_xyz dom 1 (1000*(x[0.8)+0.01*(x>0.8)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1000*(x[0.8)+0.01*(x>0.8))+0)/((1*(x[0.8)+1*(x>0.8))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1000*(x[0.8)+0.01*(x>0.8))+0)/((1*(x[0.8)+1*(x>0.8))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd5/tubes_a_choc_jdd5.data b/tests/Verification/tubes_a_choc_jdd5/tubes_a_choc_jdd5.data index 1800fdf85d..7e4bbbaacc 100644 --- a/tests/Verification/tubes_a_choc_jdd5/tubes_a_choc_jdd5.data +++ b/tests/Verification/tubes_a_choc_jdd5/tubes_a_choc_jdd5.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.5)+1*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.5)+1*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1.4*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1.4*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd6/tubes_a_choc_jdd6.data b/tests/Verification/tubes_a_choc_jdd6/tubes_a_choc_jdd6.data index abbd381c89..b673c11887 100644 --- a/tests/Verification/tubes_a_choc_jdd6/tubes_a_choc_jdd6.data +++ b/tests/Verification/tubes_a_choc_jdd6/tubes_a_choc_jdd6.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0.1*(x[0.5)+(0.1)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 1*(x[0.5)+1*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0.1*(x[0.5)+(0.1)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (1*(x[0.5)+1*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((1*(x[0.5)+1*(x>0.5))+0)/((1.4*(x[0.5)+1*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd7/tubes_a_choc_jdd7.data b/tests/Verification/tubes_a_choc_jdd7/tubes_a_choc_jdd7.data index 39c5743ca8..d6eeda9bb3 100644 --- a/tests/Verification/tubes_a_choc_jdd7/tubes_a_choc_jdd7.data +++ b/tests/Verification/tubes_a_choc_jdd7/tubes_a_choc_jdd7.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+100000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+100000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+100000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+100000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd8/tubes_a_choc_jdd8.data b/tests/Verification/tubes_a_choc_jdd8/tubes_a_choc_jdd8.data index 104c396ab6..2a07724fc0 100644 --- a/tests/Verification/tubes_a_choc_jdd8/tubes_a_choc_jdd8.data +++ b/tests/Verification/tubes_a_choc_jdd8/tubes_a_choc_jdd8.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(20)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+15500000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(20)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+15500000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+700*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/tubes_a_choc_jdd9/tubes_a_choc_jdd9.data b/tests/Verification/tubes_a_choc_jdd9/tubes_a_choc_jdd9.data index 0475efb379..51aacf88b3 100644 --- a/tests/Verification/tubes_a_choc_jdd9/tubes_a_choc_jdd9.data +++ b/tests/Verification/tubes_a_choc_jdd9/tubes_a_choc_jdd9.data @@ -72,8 +72,8 @@ Read pb diffusion { negligeable } initial_conditions { - vitesse Champ_fonc_xyz dom 2 0*(x[0.5)+(0)*(x>0.5) 0 - pression Champ_fonc_xyz dom 1 15500000.0*(x[0.5)+15500000.0*(x>0.5) + vitesse Champ_fonc_xyz dom 2 (0*(x[0.5)+(0)*(x>0.5)) 0 + pression Champ_fonc_xyz dom 1 (15500000.0*(x[0.5)+15500000.0*(x>0.5)) } boundary_conditions { @@ -99,7 +99,7 @@ Read pb { diffusion { negligeable } convection { amont } - initial_conditions { temperature Champ_fonc_xyz dom 1 ((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+650*(x>0.5))*8.31446261815324)-273.15 } + initial_conditions { temperature Champ_fonc_xyz dom 1 (((15500000.0*(x[0.5)+15500000.0*(x>0.5))+353637173.0)/((700*(x[0.5)+650*(x>0.5))*8.31446261815324)-273.15) } boundary_conditions { haut paroi_adiabatique diff --git a/tests/Verification/vap_paroi_jdd1/vap_paroi_jdd1.data b/tests/Verification/vap_paroi_jdd1/vap_paroi_jdd1.data index c36e8303b8..ca1769ee3e 100644 --- a/tests/Verification/vap_paroi_jdd1/vap_paroi_jdd1.data +++ b/tests/Verification/vap_paroi_jdd1/vap_paroi_jdd1.data @@ -78,7 +78,7 @@ Read pb correlations { - /* multiplicateur_diphasique friedel { } */ + multiplicateur_diphasique friedel { } flux_interfacial coef_constant { liquide_sodium 1e8 /* coeff echange liquide-interface (interface tjrs a Tsat) => petit echange => liquide loin de Tsat */ gaz_sodium 1e10 /* coeff echange gaz-interface (interface tjrs a Tsat) => grande echange => gaz toujours a Tsat */ @@ -134,13 +134,13 @@ Read pb } sources { - source_qdm champ_uniforme 6 0 0 0 0 -9.81 -9.81 /* , + source_qdm champ_uniforme 6 0 0 0 0 -9.81 -9.81 , Perte_Charge_Isotrope { diam_hydr Champ_Uniforme 1 0.00385 sous_zone tot lambda - ((2000_min_((Re-1000)_max_0))*0.194*Re^(-0.2)+(2000_min_((3000-Re)_max_0))*64/Re)/2000 - } */ + ((2000 min ((Re-1000) max 0))*0.194*Re^(-0.2)+(2000 min ((3000-Re) max 0))*64/Re)/2000 + } } } Masse_Multiphase @@ -204,7 +204,7 @@ Read pb vitesse_g_trust grav vitesse_gaz_sodium periode 1 segment 500 1e-3 1e-3 0. 1e-3 1e-3 1.508 } Format lml - fields dt_post 100 + fields dt_post 0 { vitesse_liquide_sodium elem vitesse_gaz_sodium elem diff --git a/tests/Verification/vap_paroi_jdd1/vap_paroi_jdd1.lml.gz b/tests/Verification/vap_paroi_jdd1/vap_paroi_jdd1.lml.gz index e230d61181660c64deadf9e890f5247fbd2427fb..f1e6b19eacdee5baec79ce590a231e2055672d20 100644 GIT binary patch literal 14213 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 OK^q>co`KQUuK6#RaH8Y@ literal 8096 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 diff --git a/tests/Verification/vap_paroi_jdd2/vap_paroi_jdd2.data b/tests/Verification/vap_paroi_jdd2/vap_paroi_jdd2.data index a67b6e1994..26905e5c17 100644 --- a/tests/Verification/vap_paroi_jdd2/vap_paroi_jdd2.data +++ b/tests/Verification/vap_paroi_jdd2/vap_paroi_jdd2.data @@ -78,7 +78,7 @@ Read pb correlations { - /* multiplicateur_diphasique friedel { } */ + multiplicateur_diphasique friedel { } flux_interfacial coef_constant { liquide_sodium 1e8 /* coeff echange liquide-interface (interface tjrs a Tsat) => petit echange => liquide loin de Tsat */ gaz_sodium 1e10 /* coeff echange gaz-interface (interface tjrs a Tsat) => grande echange => gaz toujours a Tsat */ @@ -134,13 +134,13 @@ Read pb } sources { - source_qdm champ_uniforme 6 0 0 0 0 -9.81 -9.81 /* , + source_qdm champ_uniforme 6 0 0 0 0 -9.81 -9.81 , Perte_Charge_Isotrope { diam_hydr Champ_Uniforme 1 0.00385 sous_zone tot lambda - ((2000_min_((Re-1000)_max_0))*0.194*Re^(-0.2)+(2000_min_((3000-Re)_max_0))*64/Re)/2000 - } */ + ((2000 min ((Re-1000) max 0))*0.194*Re^(-0.2)+(2000 min ((3000-Re) max 0))*64/Re)/2000 + } } } Masse_Multiphase @@ -204,7 +204,7 @@ Read pb vitesse_g_trust grav vitesse_gaz_sodium periode 1 segment 500 1e-3 1e-3 0. 1e-3 1e-3 1.508 } Format lml - fields dt_post 100 + fields dt_post 0 { vitesse_liquide_sodium elem vitesse_gaz_sodium elem diff --git a/tests/Verification/vap_paroi_jdd2/vap_paroi_jdd2.lml.gz b/tests/Verification/vap_paroi_jdd2/vap_paroi_jdd2.lml.gz index f674197ee19c519940e3c5326d16ca1aa25f8f86..61adebd90ee9a4c297a1436845d442a90d75c323 100644 GIT binary patch literal 12205 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 literal 7342 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