diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 00000000..59a6916d --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,46 @@ +--- +Checks: 'clang-diagnostic-*,clang-analyzer-*,readability-braces-around-statements' +WarningsAsErrors: '' +HeaderFilterRegex: '' +AnalyzeTemporaryDtors: false +FormatStyle: none +User: user +CheckOptions: + - key: llvm-else-after-return.WarnOnConditionVariables + value: 'false' + - key: modernize-loop-convert.MinConfidence + value: reasonable + - key: modernize-replace-auto-ptr.IncludeStyle + value: llvm + - key: cert-str34-c.DiagnoseSignedUnsignedCharComparisons + value: 'false' + - key: google-readability-namespace-comments.ShortNamespaceLines + value: '10' + - key: cert-err33-c.CheckedFunctions + value: '::aligned_alloc;::asctime_s;::at_quick_exit;::atexit;::bsearch;::bsearch_s;::btowc;::c16rtomb;::c32rtomb;::calloc;::clock;::cnd_broadcast;::cnd_init;::cnd_signal;::cnd_timedwait;::cnd_wait;::ctime_s;::fclose;::fflush;::fgetc;::fgetpos;::fgets;::fgetwc;::fopen;::fopen_s;::fprintf;::fprintf_s;::fputc;::fputs;::fputwc;::fputws;::fread;::freopen;::freopen_s;::fscanf;::fscanf_s;::fseek;::fsetpos;::ftell;::fwprintf;::fwprintf_s;::fwrite;::fwscanf;::fwscanf_s;::getc;::getchar;::getenv;::getenv_s;::gets_s;::getwc;::getwchar;::gmtime;::gmtime_s;::localtime;::localtime_s;::malloc;::mbrtoc16;::mbrtoc32;::mbsrtowcs;::mbsrtowcs_s;::mbstowcs;::mbstowcs_s;::memchr;::mktime;::mtx_init;::mtx_lock;::mtx_timedlock;::mtx_trylock;::mtx_unlock;::printf_s;::putc;::putwc;::raise;::realloc;::remove;::rename;::scanf;::scanf_s;::setlocale;::setvbuf;::signal;::snprintf;::snprintf_s;::sprintf;::sprintf_s;::sscanf;::sscanf_s;::strchr;::strerror_s;::strftime;::strpbrk;::strrchr;::strstr;::strtod;::strtof;::strtoimax;::strtok;::strtok_s;::strtol;::strtold;::strtoll;::strtoul;::strtoull;::strtoumax;::strxfrm;::swprintf;::swprintf_s;::swscanf;::swscanf_s;::thrd_create;::thrd_detach;::thrd_join;::thrd_sleep;::time;::timespec_get;::tmpfile;::tmpfile_s;::tmpnam;::tmpnam_s;::tss_create;::tss_get;::tss_set;::ungetc;::ungetwc;::vfprintf;::vfprintf_s;::vfscanf;::vfscanf_s;::vfwprintf;::vfwprintf_s;::vfwscanf;::vfwscanf_s;::vprintf_s;::vscanf;::vscanf_s;::vsnprintf;::vsnprintf_s;::vsprintf;::vsprintf_s;::vsscanf;::vsscanf_s;::vswprintf;::vswprintf_s;::vswscanf;::vswscanf_s;::vwprintf_s;::vwscanf;::vwscanf_s;::wcrtomb;::wcschr;::wcsftime;::wcspbrk;::wcsrchr;::wcsrtombs;::wcsrtombs_s;::wcsstr;::wcstod;::wcstof;::wcstoimax;::wcstok;::wcstok_s;::wcstol;::wcstold;::wcstoll;::wcstombs;::wcstombs_s;::wcstoul;::wcstoull;::wcstoumax;::wcsxfrm;::wctob;::wctrans;::wctype;::wmemchr;::wprintf_s;::wscanf;::wscanf_s;' + - key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField + value: 'false' + - key: cert-dcl16-c.NewSuffixes + value: 'L;LL;LU;LLU' + - key: google-readability-braces-around-statements.ShortStatementLines + value: '1' + - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic + value: 'true' + - key: google-readability-namespace-comments.SpacesBeforeComments + value: '2' + - key: modernize-loop-convert.MaxCopySize + value: '16' + - key: modernize-pass-by-value.IncludeStyle + value: llvm + - key: modernize-use-nullptr.NullMacros + value: 'NULL' + - key: llvm-qualified-auto.AddConstToQualified + value: 'false' + - key: modernize-loop-convert.NamingStyle + value: CamelCase + - key: llvm-else-after-return.WarnOnUnfixable + value: 'false' + - key: google-readability-function-size.StatementThreshold + value: '800' +... + diff --git a/.cmake-format.py b/.cmake-format.py new file mode 100644 index 00000000..3df985a2 --- /dev/null +++ b/.cmake-format.py @@ -0,0 +1,241 @@ +# ---------------------------------- +# Options affecting listfile parsing +# ---------------------------------- +with section("parse"): + + # Specify structure for custom cmake functions + additional_commands = { 'foo': { 'flags': ['BAR', 'BAZ'], + 'kwargs': {'DEPENDS': '*', 'HEADERS': '*', 'SOURCES': '*'}}} + + # Override configurations per-command where available + override_spec = {} + + # Specify variable tags. + vartags = [] + + # Specify property tags. + proptags = [] + +# ----------------------------- +# Options affecting formatting. +# ----------------------------- +with section("format"): + + # Disable formatting entirely, making cmake-format a no-op + disable = False + + # How wide to allow formatted cmake files + line_width = 80 + + # How many spaces to tab for indent + tab_size = 2 + + # If true, lines are indented using tab characters (utf-8 0x09) instead of + # space characters (utf-8 0x20). In cases where the layout would + # require a fractional tab character, the behavior of the fractional + # indentation is governed by + use_tabchars = False + + # If is True, then the value of this variable indicates how + # fractional indentions are handled during whitespace replacement. If set to + # 'use-space', fractional indentation is left as spaces (utf-8 0x20). If set + # to `round-up` fractional indentation is replaced with a single tab character + # (utf-8 0x09) effectively shifting the column to the next tabstop + fractional_tab_policy = 'use-space' + + # If an argument group contains more than this many sub-groups (parg or kwarg + # groups) then force it to a vertical layout. + max_subgroups_hwrap = 2 + + # If a positional argument group contains more than this many arguments, then + # force it to a vertical layout. + max_pargs_hwrap = 6 + + # If a cmdline positional group consumes more than this many lines without + # nesting, then invalidate the layout (and nest) + max_rows_cmdline = 2 + + # If true, separate flow control names from their parentheses with a space + separate_ctrl_name_with_space = False + + # If true, separate function names from parentheses with a space + separate_fn_name_with_space = False + + # If a statement is wrapped to more than one line, than dangle the closing + # parenthesis on its own line. + dangle_parens = False + + # If the trailing parenthesis must be 'dangled' on its on line, then align it + # to this reference: `prefix`: the start of the statement, `prefix-indent`: + # the start of the statement, plus one indentation level, `child`: align to + # the column of the arguments + dangle_align = 'prefix' + + # If the statement spelling length (including space and parenthesis) is + # smaller than this amount, then force reject nested layouts. + min_prefix_chars = 4 + + # If the statement spelling length (including space and parenthesis) is larger + # than the tab width by more than this amount, then force reject un-nested + # layouts. + max_prefix_chars = 10 + + # If a candidate layout is wrapped horizontally but it exceeds this many + # lines, then reject the layout. + max_lines_hwrap = 2 + + # What style line endings to use in the output. + line_ending = 'unix' + + # Format command names consistently as 'lower' or 'upper' case + command_case = 'canonical' + + # Format keywords consistently as 'lower' or 'upper' case + keyword_case = 'unchanged' + + # A list of command names which should always be wrapped + always_wrap = [] + + # If true, the argument lists which are known to be sortable will be sorted + # lexicographicall + enable_sort = True + + # If true, the parsers may infer whether or not an argument list is sortable + # (without annotation). + autosort = False + + # By default, if cmake-format cannot successfully fit everything into the + # desired linewidth it will apply the last, most agressive attempt that it + # made. If this flag is True, however, cmake-format will print error, exit + # with non-zero status code, and write-out nothing + require_valid_layout = False + + # A dictionary mapping layout nodes to a list of wrap decisions. See the + # documentation for more information. + layout_passes = {} + +# ------------------------------------------------ +# Options affecting comment reflow and formatting. +# ------------------------------------------------ +with section("markup"): + + # What character to use for bulleted lists + bullet_char = '*' + + # What character to use as punctuation after numerals in an enumerated list + enum_char = '.' + + # If comment markup is enabled, don't reflow the first comment block in each + # listfile. Use this to preserve formatting of your copyright/license + # statements. + first_comment_is_literal = False + + # If comment markup is enabled, don't reflow any comment block which matches + # this (regex) pattern. Default is `None` (disabled). + literal_comment_pattern = None + + # Regular expression to match preformat fences in comments default= + # ``r'^\s*([`~]{3}[`~]*)(.*)$'`` + fence_pattern = '^\\s*([`~]{3}[`~]*)(.*)$' + + # Regular expression to match rulers in comments default= + # ``r'^\s*[^\w\s]{3}.*[^\w\s]{3}$'`` + ruler_pattern = '^\\s*[^\\w\\s]{3}.*[^\\w\\s]{3}$' + + # If a comment line matches starts with this pattern then it is explicitly a + # trailing comment for the preceeding argument. Default is '#<' + explicit_trailing_pattern = '#<' + + # If a comment line starts with at least this many consecutive hash + # characters, then don't lstrip() them off. This allows for lazy hash rulers + # where the first hash char is not separated by space + hashruler_min_length = 10 + + # If true, then insert a space between the first hash char and remaining hash + # chars in a hash ruler, and normalize its length to fill the column + canonicalize_hashrulers = True + + # enable comment markup parsing and reflow + enable_markup = True + +# ---------------------------- +# Options affecting the linter +# ---------------------------- +with section("lint"): + + # a list of lint codes to disable + disabled_codes = [] + + # regular expression pattern describing valid function names + function_pattern = '[0-9a-z_]+' + + # regular expression pattern describing valid macro names + macro_pattern = '[0-9A-Z_]+' + + # regular expression pattern describing valid names for variables with global + # (cache) scope + global_var_pattern = '[A-Z][0-9A-Z_]+' + + # regular expression pattern describing valid names for variables with global + # scope (but internal semantic) + internal_var_pattern = '_[A-Z][0-9A-Z_]+' + + # regular expression pattern describing valid names for variables with local + # scope + local_var_pattern = '[a-z][a-z0-9_]+' + + # regular expression pattern describing valid names for privatedirectory + # variables + private_var_pattern = '_[0-9a-z_]+' + + # regular expression pattern describing valid names for public directory + # variables + public_var_pattern = '[A-Z][0-9A-Z_]+' + + # regular expression pattern describing valid names for function/macro + # arguments and loop variables. + argument_var_pattern = '[a-z][a-z0-9_]+' + + # regular expression pattern describing valid names for keywords used in + # functions or macros + keyword_pattern = '[A-Z][0-9A-Z_]+' + + # In the heuristic for C0201, how many conditionals to match within a loop in + # before considering the loop a parser. + max_conditionals_custom_parser = 2 + + # Require at least this many newlines between statements + min_statement_spacing = 1 + + # Require no more than this many newlines between statements + max_statement_spacing = 2 + max_returns = 6 + max_branches = 12 + max_arguments = 5 + max_localvars = 15 + max_statements = 50 + +# ------------------------------- +# Options affecting file encoding +# ------------------------------- +with section("encode"): + + # If true, emit the unicode byte-order mark (BOM) at the start of the file + emit_byteorder_mark = False + + # Specify the encoding of the input file. Defaults to utf-8 + input_encoding = 'utf-8' + + # Specify the encoding of the output file. Defaults to utf-8. Note that cmake + # only claims to support utf-8 so be careful when using anything else + output_encoding = 'utf-8' + +# ------------------------------------- +# Miscellaneous configurations options. +# ------------------------------------- +with section("misc"): + + # A dictionary containing any per-command configuration overrides. Currently + # only `command_case` is supported. + per_command = {} + diff --git a/.codecov.yaml b/.codecov.yaml index 53ba0463..ab6968bd 100644 --- a/.codecov.yaml +++ b/.codecov.yaml @@ -12,3 +12,9 @@ ignore: - "src/models/ClassPotentialOrigin_deprecated.cpp" - "src/models/ClassTemplate.cpp" - "src/WallThickness/WallThickness1D.cpp" + - "standalone/**" + - "src/utility/spline/spline.cpp" + - "src/utility/asciiplotter/asciiplotter.cpp" + - "example/**" + - ".github" + - "**/README.md" diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 00000000..185eff9a --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +* @phbasler @lisabiermann @JonasMueller1991 @vollous diff --git a/.github/GetProfile.py b/.github/GetProfile.py new file mode 100644 index 00000000..bfb0a734 --- /dev/null +++ b/.github/GetProfile.py @@ -0,0 +1,16 @@ +import os +import sys + +current = os.path.dirname(os.path.realpath(__file__)) +parent = os.path.dirname(current) +sys.path.append(parent) + +import Build + +if __name__ == "__main__": + + env_file = os.getenv('GITHUB_ENV') + with open(env_file, "a") as myfile: + myfile.write(f"GeneratedCMakeProfile={Build.get_preset()}") + + print(f"Setting GeneratedCMakeProfile={Build.get_preset()}") diff --git a/.github/codeql/codeql-config.yml b/.github/codeql/codeql-config.yml new file mode 100644 index 00000000..97b860e3 --- /dev/null +++ b/.github/codeql/codeql-config.yml @@ -0,0 +1,3 @@ +paths-ignore: + - build + - '.cmake-format.py' diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml index 0deb26e0..9b557e7a 100644 --- a/.github/workflows/benchmark.yml +++ b/.github/workflows/benchmark.yml @@ -7,17 +7,21 @@ on: push: branches: [master] +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + jobs: benchmark: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: persist-credentials: false - name : installPackages run : sudo apt-get update && sudo apt-get install --no-install-recommends --yes libgsl-dev libeigen3-dev libnlopt-dev libnlopt-cxx-dev libboost-all-dev libbenchmark-dev - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 + uses: SimenB/github-actions-cpu-cores@v2 id: cpu-cores - name: cmake run: mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release @@ -26,7 +30,7 @@ jobs: - name: run benchmarks run: cd build && ./bin/benchmarks --benchmark_format=json --benchmark_out=benchmark_result.json - name: Archive benchmark results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: benchmark_result path: build/benchmark_result.json diff --git a/.github/workflows/benchmark_on_pr.yml b/.github/workflows/benchmark_on_pr.yml index 0936718f..90646bca 100644 --- a/.github/workflows/benchmark_on_pr.yml +++ b/.github/workflows/benchmark_on_pr.yml @@ -12,17 +12,21 @@ on: - '**.h' - '**.hpp' +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + jobs: PRbenchmark: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: persist-credentials: false - name : installPackages run : sudo apt-get update && sudo apt-get install --no-install-recommends --yes libgsl-dev libeigen3-dev libnlopt-dev libnlopt-cxx-dev libboost-all-dev libbenchmark-dev - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 + uses: SimenB/github-actions-cpu-cores@v2 id: cpu-cores - name: cmake run: mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release @@ -31,7 +35,7 @@ jobs: - name: run benchmarks run: cd build && ./bin/benchmarks --benchmark_format=json --benchmark_out=benchmark_result.json - name: Archive benchmark results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: benchmark_result path: build/benchmark_result.json diff --git a/.github/workflows/build-mac.yml b/.github/workflows/build-mac.yml deleted file mode 100644 index 5277fc01..00000000 --- a/.github/workflows/build-mac.yml +++ /dev/null @@ -1,28 +0,0 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller -# -# SPDX-License-Identifier: GPL-3.0-or-later - -name: Mac build develop branch - -on: - push: - branches: [ develop ] - -jobs: - build-mac: - runs-on: macos-latest - if: "!contains(github.event.head_commit.message, 'skip-ci')" - - steps: - - uses: actions/checkout@v3 - with: - persist-credentials: false - - name: installPackages - run: brew install eigen && brew install gsl && brew install nlopt && brew install boost && brew install libomp - - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 - id: cpu-cores - - name: cmake - run: mkdir build && cd build && cmake .. - - name: make - run: cd build && cmake --build . -j${{ steps.cpu-cores.outputs.count }} diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml deleted file mode 100644 index 2a30c9d2..00000000 --- a/.github/workflows/build.yml +++ /dev/null @@ -1,31 +0,0 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller -# -# SPDX-License-Identifier: GPL-3.0-or-later - -name: Ubuntu build develop branch - -on: - push: - branches: [ develop ] - -jobs: - build: - runs-on: ubuntu-20.04 - if: "!contains(github.event.head_commit.message, 'skip-ci')" - - steps: - - uses: actions/checkout@v3 - with: - persist-credentials: false - - name : installPackages - run : sudo apt-get install --no-install-recommends --yes libgsl-dev libeigen3-dev libnlopt-dev libnlopt-cxx-dev libboost-all-dev - - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 - id: cpu-cores - - name: cmake - run: mkdir build && cd build && cmake .. - - name: make - run: cd build && cmake --build . -j${{ steps.cpu-cores.outputs.count }} - - - diff --git a/.github/workflows/build_on_windows.yml b/.github/workflows/build_on_windows.yml deleted file mode 100644 index 5178e044..00000000 --- a/.github/workflows/build_on_windows.yml +++ /dev/null @@ -1,37 +0,0 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller -# -# SPDX-License-Identifier: GPL-3.0-or-later - -name: Windows build develop branch - -on: - push: - branches: [ develop ] - -jobs: - build: - runs-on: windows-2019 - if: "!contains(github.event.head_commit.message, 'skip-ci')" - - steps: - - uses: actions/checkout@v3 - with: - persist-credentials: false - - uses: actions/setup-python@v4 - with: - python-version: '3.x' # Version range or exact version of a Python version to use, using SemVer's version range syntax - architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified - - name: Install conan - run: pip install conan - - name: Refresh Shell - run: refreshenv - - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 - id: cpu-cores - - name: cmake - run: cmake -S . -B build -DUseConan=On -DCMAKE_BUILD_TYPE=Release - - name: make - run: cd build && cmake --build . -j${{ steps.cpu-cores.outputs.count }} --config Release - - - diff --git a/.github/workflows/cmake-format-linter.yml b/.github/workflows/cmake-format-linter.yml new file mode 100644 index 00000000..ee9073ae --- /dev/null +++ b/.github/workflows/cmake-format-linter.yml @@ -0,0 +1,29 @@ +name: Run cmake-format linter + +on: + pull_request: + branches: [ master, develop ] + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Format CMake files + id: cmake-format + uses: PuneetMatharu/cmake-format-lint-action@v1.0.4 + with: + args: --config-files .cmake-format.py --in-place + + - name: Commit changes + uses: stefanzweifel/git-auto-commit-action@v5 + with: + commit_user_name: cmake-format-bot + commit_message: 'Automated commit of cmake-format changes.' \ No newline at end of file diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index 77926ddf..675020cf 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -12,6 +12,8 @@ on: - '**.c' - '**.h' - '**.hpp' + - '**CMakeLists.txt' + - 'conanfile.py' pull_request: branches: [ master, develop ] paths: @@ -19,31 +21,49 @@ on: - '**.c' - '**.h' - '**.hpp' + - '**CMakeLists.txt' + - 'conanfile.py' workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true jobs: coverage: - runs-on: ubuntu-20.04 + runs-on: ubuntu-latest if: "!contains(github.event.head_commit.message, 'skip-ci')" steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: persist-credentials: false - - name : installPackages - run : sudo apt-get update && sudo apt-get install --no-install-recommends --yes libgsl-dev libeigen3-dev libnlopt-dev libnlopt-cxx-dev libboost-all-dev lcov - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 + uses: SimenB/github-actions-cpu-cores@v2 id: cpu-cores - - name: cmake - run: mkdir build && cd build && cmake .. -DEnableCoverage=On + - name : installPackages + run : sudo apt-get update && sudo apt-get install --no-install-recommends --yes lcov + + - uses: actions/setup-python@v5 + with: + python-version: '3.x' # Version range or exact version of a Python version to use, using SemVer's version range syntax + architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified + - name: Install conan + run: pip install conan>2 + - run: python3 Setup.py --options EnableCoverage=True CompileBaryo=True UseVectorization=False --build-missing + + - name: Set cmake preset name + run: python3 .github/GetProfile.py + + - run: cmake --preset $GeneratedCMakeProfile - name: compile - run: cd build && cmake --build . -j${{ steps.cpu-cores.outputs.count }} + run: cmake --build --preset $GeneratedCMakeProfile -j${{ steps.cpu-cores.outputs.count }} - name: Generate Coverage - run: cd build && cmake --build . -j${{ steps.cpu-cores.outputs.count }} -t coverage + run: cmake --build --preset $GeneratedCMakeProfile -j${{ steps.cpu-cores.outputs.count }} -t coverage - name: Upload coverage - uses: codecov/codecov-action@v3 + uses: codecov/codecov-action@v4 with: + token: ${{ secrets.BSMPT_CODECOV_UPLOAD_TOKEN }} flags: unittests # optional name: codecov-umbrella # optional fail_ci_if_error: true # optional (default = false) diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml new file mode 100644 index 00000000..2cb4968f --- /dev/null +++ b/.github/workflows/codeql.yml @@ -0,0 +1,76 @@ +name: "CodeQL" + +on: + push: + branches: [ "master" ] + pull_request: + branches: [ "master" ] + schedule: + - cron: "14 17 * * 1" + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + analyze: + name: Analyze + runs-on: ubuntu-latest + permissions: + actions: read + contents: read + security-events: write + + strategy: + fail-fast: false + matrix: + language: [ python, cpp ] + + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Initialize CodeQL + uses: github/codeql-action/init@v3 + with: + languages: ${{ matrix.language }} + queries: +security-and-quality + config-file: ./.github/codeql/codeql-config.yml + + - uses: actions/setup-python@v5 + with: + python-version: '3.x' # Version range or exact version of a Python version to use, using SemVer's version range syntax + architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified + - name: Install conan + run: pip install conan>2 + if: matrix.language == 'cpp' + + - name: Get number of CPU cores + uses: SimenB/github-actions-cpu-cores@v2 + id: cpu-cores + if: matrix.language == 'cpp' + - name: Setup + run: python3 Setup.py --options CompileBaryo=True --build-missing + if: matrix.language == 'cpp' + + - name: Set cmake preset name + run: python3 .github/GetProfile.py + if: matrix.language == 'cpp' + + - name: Preset cmake + run: cmake --preset $GeneratedCMakeProfile + if: matrix.language == 'cpp' + - name: build + run: cmake --build --preset $GeneratedCMakeProfile -j${{ steps.cpu-cores.outputs.count }} + if: matrix.language == 'cpp' + + - name: Autobuild + uses: github/codeql-action/autobuild@v3 + if: matrix.language != 'cpp' + + - name: Perform CodeQL Analysis + uses: github/codeql-action/analyze@v3 + with: + category: "/language:${{ matrix.language }}" diff --git a/.github/workflows/cpp-linter.yml b/.github/workflows/cpp-linter.yml index 7ce03b3d..50b092f2 100644 --- a/.github/workflows/cpp-linter.yml +++ b/.github/workflows/cpp-linter.yml @@ -1,28 +1,58 @@ -# Workflow syntax: -# https://help.github.com/en/articles/workflow-syntax-for-github-actions name: cpp-linter on: - push: - paths-ignore: "docs/**" pull_request: - paths-ignore: "docs/**" + branches: [master] + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true jobs: cpp-linter: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - - uses: shenxianpeng/cpp-linter-action@master - id: linter - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + - uses: actions/checkout@v4 with: - style: file + fetch-depth: 0 + ref: ${{ github.head_ref }} + + - name: Install clang-format + if: inputs.apply_clang_format + run: pip3 install clang-format==14.0.0 + + - run: git fetch origin $GITHUB_BASE_REF + + - name: Set Branch name + id: branch-name + run: + echo "branchName=$GITHUB_BASE_REF" >> $GITHUB_OUTPUT + + - name: Define base git diff args + id: git-diff-args + run: | + echo "args=origin/${{steps.branch-name.outputs.branchName}}..HEAD" >> $GITHUB_OUTPUT + + - name: Apply clang-format on changed files + run: | + changedFileList=`git diff ${{steps.git-diff-args.outputs.args}} --name-only --diff-filter=d -- '***.hpp' '***.cpp' '***.h' '***.c'` + for file in $changedFileList; do echo "Checking file " $file; clang-format --style=file -i $file; done + + - name: Check if we have local changes + id: check-changes + shell: bash + run: | + if [[ -z $(git status --porcelain --untracked-files=no) ]]; then echo "ChangesFound=False" >> $GITHUB_OUTPUT; else echo "ChangesFound=True" >> $GITHUB_OUTPUT; fi - - name: Fail fast?! - if: steps.linter.outputs.checks-failed > 0 + - name: setup git config run: | - echo "Some files failed the linting checks!" - # for actual deployment - # run: exit 1 + # setup the username and email. I tend to use 'GitHub Actions Bot' with no email by default + git config user.name "GitHub Actions Bot" + git config user.email "<>" + + - name: Commit changes + if: steps.check-changes.outputs.ChangesFound == 'True' + run: | + git commit -am "Automatically applied linter" + git push + diff --git a/.github/workflows/doc.yml b/.github/workflows/doc.yml index 0eb1818d..7f4d27b0 100644 --- a/.github/workflows/doc.yml +++ b/.github/workflows/doc.yml @@ -6,27 +6,56 @@ name: Doxygen Deploy on: push: - branches: [ master ] + branches: + - master + pull_request: + branches: + - master +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true jobs: - Deploy: - runs-on: ubuntu-20.04 + CreateDocumentation: + runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: persist-credentials: false - name: installPackages - run: sudo apt-get install --no-install-recommends --yes libgsl-dev libeigen3-dev libnlopt-cxx-dev libboost-all-dev doxygen + run: sudo apt-get install --no-install-recommends --yes doxygen + - uses: actions/setup-python@v5 + with: + python-version: '3.x' # Version range or exact version of a Python version to use, using SemVer's version range syntax + architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified + - name: Install conan + run: pip install conan>2 - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 + uses: SimenB/github-actions-cpu-cores@v2 id: cpu-cores - - name: cmake - run: mkdir build && cd build && cmake .. && cmake --build . -j${{ steps.cpu-cores.outputs.count }} -t doc - - name: Deploy - uses: JamesIves/github-pages-deploy-action@v4.3.4 + - run: python3 Setup.py --build-missing + - run: cmake --preset conan-linux-x86_64-release + - run: cmake --build --preset conan-linux-x86_64-release -j${{ steps.cpu-cores.outputs.count }} -t doc + - uses: actions/upload-artifact@v4 with: - branch: gh-pages # The branch the action should deploy to. - folder: build/html # The folder the action should deploy. - target-folder: documentation + path: build/linux-x86_64-release/html + name: documentation + + UploadDocumentation: + if: github.event_name == 'push' && github.ref == 'refs/heads/master' + needs: CreateDocumentation + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/download-artifact@v4 + with: + name: documentation + path: documentation + - name: Deploy + uses: JamesIves/github-pages-deploy-action@v4.6.4 + with: + branch: gh-pages # The branch the action should deploy to. + folder: documentation # The folder the action should deploy. + target-folder: documentation diff --git a/.github/workflows/test-mac.yml b/.github/workflows/test-mac.yml deleted file mode 100644 index 72288bd0..00000000 --- a/.github/workflows/test-mac.yml +++ /dev/null @@ -1,55 +0,0 @@ - -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller -# -# SPDX-License-Identifier: GPL-3.0-or-later - -name: Mac unit tests - -on: - push: - branches: [ master ] - pull_request: - branches: [ master, develop ] - workflow_dispatch: - -jobs: - mac-tests-fullSetup: - runs-on: macos-latest - if: "!contains(github.event.head_commit.message, 'skip-ci')" - - steps: - - uses: actions/checkout@v3 - with: - persist-credentials: false - - name : installPackages - run : brew install eigen gsl nlopt boost libomp - - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 - id: cpu-cores - - name: cmake - run: mkdir build && cd build && cmake .. - - name: make - run: cd build && cmake --build . -j${{ steps.cpu-cores.outputs.count }} - - name: Test - run: cd build && ctest -j${{ steps.cpu-cores.outputs.count }} --output-on-failure - - mac-tests-NoNLopt: - runs-on: macos-latest - if: "!contains(github.event.head_commit.message, 'skip-ci')" - - steps: - - uses: actions/checkout@v3 - with: - persist-credentials: false - - name : installPackages - run : brew install eigen gsl boost libomp - - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 - id: cpu-cores - - name: cmake - run: mkdir buildNoNLOPT && cd buildNoNLOPT && cmake .. - - name: make - run: cd buildNoNLOPT && cmake --build . -j${{ steps.cpu-cores.outputs.count }} - - name: Test - run: cd buildNoNLOPT && ctest -j${{ steps.cpu-cores.outputs.count }} --output-on-failure - diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 536293fb..2a0e7159 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -2,56 +2,70 @@ # # SPDX-License-Identifier: GPL-3.0-or-later -name: Ubuntu unit tests +name: Unit tests on: push: - branches: [ master ] + branches: + - master pull_request: - branches: [ master, develop ] + branches: + - master + - develop workflow_dispatch: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + jobs: - ubuntu-tests-fullSetup: - runs-on: ubuntu-20.04 + tests-fullSetup: + strategy: + matrix: + setup: [ {os: ubuntu-latest}, {os: windows-latest}, {os: macos-latest}, {os: ubuntu-20.04}] + runs-on: ${{matrix.setup.os}} if: "!contains(github.event.head_commit.message, 'skip-ci')" steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: persist-credentials: false - - name : installPackages - run : sudo apt-get update && sudo apt-get install --no-install-recommends --yes libgsl-dev libeigen3-dev libnlopt-dev libnlopt-cxx-dev libboost-all-dev - - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 - id: cpu-cores - - name: cmake - run: mkdir build && cd build && cmake .. - - name: make - run: cd build && cmake --build . -j${{ steps.cpu-cores.outputs.count }} - - name: Test - run: cd build && ctest -j${{ steps.cpu-cores.outputs.count }} --output-on-failure - - ubuntu-tests-NoNLopt: - runs-on: ubuntu-20.04 - if: "!contains(github.event.head_commit.message, 'skip-ci')" - - steps: - - uses: actions/checkout@v3 + - uses: actions/setup-python@v5 with: - persist-credentials: false - - name : installPackages - run : sudo apt-get update && sudo apt-get install --no-install-recommends --yes libgsl-dev libeigen3-dev libboost-all-dev + python-version: '3.x' # Version range or exact version of a Python version to use, using SemVer's version range syntax + architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified + - name: Install conan + run: pip install conan>2 + - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 + uses: SimenB/github-actions-cpu-cores@v2 id: cpu-cores + - run: python3 Setup.py --options CompileBaryo=True --build-missing + + - name: Set cmake preset name + run: python3 .github/GetProfile.py + - name: cmake - run: mkdir buildNoNLOPT && cd buildNoNLOPT && cmake .. - - name: make - run: cd buildNoNLOPT && cmake --build . -j${{ steps.cpu-cores.outputs.count }} - - name: Test - run: cd buildNoNLOPT && ctest -j${{ steps.cpu-cores.outputs.count }} --output-on-failure + run: cmake --preset $GeneratedCMakeProfile + if: runner.os != 'Windows' + - name: build + run: cmake --build --preset $GeneratedCMakeProfile -j${{ steps.cpu-cores.outputs.count }} + if: runner.os != 'Windows' + - name: run tests + run: ctest --preset $GeneratedCMakeProfile -j --output-on-failure + if: runner.os != 'Windows' + - name: cmake + run: cmake --preset $env:GeneratedCMakeProfile + if: runner.os == 'Windows' + - name: build + run: cmake --build --preset $env:GeneratedCMakeProfile -j${{ steps.cpu-cores.outputs.count }} + if: runner.os == 'Windows' + - name: run tests + run: ctest --preset $env:GeneratedCMakeProfile -j --output-on-failure + if: runner.os == 'Windows' + + diff --git a/.github/workflows/windows_unit_tests.yml b/.github/workflows/windows_unit_tests.yml deleted file mode 100644 index 7d9d777e..00000000 --- a/.github/workflows/windows_unit_tests.yml +++ /dev/null @@ -1,43 +0,0 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller -# -# SPDX-License-Identifier: GPL-3.0-or-later - -name: Windows unit tests - -on: - push: - branches: [ master ] - pull_request: - branches: [ master, develop ] - workflow_dispatch: - - -jobs: - windows-tests-fullSetup: - runs-on: windows-2019 - if: "!contains(github.event.head_commit.message, 'skip-ci')" - - steps: - - uses: actions/checkout@v3 - with: - persist-credentials: false - - uses: actions/setup-python@v4 - with: - python-version: '3.x' # Version range or exact version of a Python version to use, using SemVer's version range syntax - architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified - - name: Install conan - run: pip install conan - - name: Refresh Shell - run: refreshenv - - name: Get number of CPU cores - uses: SimenB/github-actions-cpu-cores@v1 - id: cpu-cores - - name: cmake - run: cmake -S . -B build -DUseConan=On -DCMAKE_BUILD_TYPE=Release - - name: make - run: cd build && cmake --build . -j${{ steps.cpu-cores.outputs.count }} --config Release - - name: Test - run: cd build && ctest -j${{ steps.cpu-cores.outputs.count }} --output-on-failure - - - diff --git a/.gitignore b/.gitignore index 7ac79230..f102b91a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,13 +1,19 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller # -# SPDX-License-Identifier: GPL-3.0-or-later - -build +# SPDX-License-Identifier: GPL-3.0-or-later +build/ +tmp/ +tmp* +local/ +.* .vscode .atom - +analyze*.py *.aux *.log *.out *.synctex.gz + +CMakeUserPresets.json +__pycache__/* diff --git a/Build.py b/Build.py new file mode 100644 index 00000000..ec3a902a --- /dev/null +++ b/Build.py @@ -0,0 +1,42 @@ +import Setup +import subprocess +import sys + +def get_preset(): + preset = "conan-" + os = sys.platform + if os == "win32": + preset += "windows" + elif os == "linux": + preset += "linux" + elif os == "darwin": + preset += "macos" + + preset += "-" + preset += Setup.get_arch() + + preset += "-release" + + return preset + +def build(preset): + cmd=f"cmake --preset {preset} --fresh".split() + subprocess.check_call(cmd) + + cmd=f"cmake --build --preset {preset}".split() + subprocess.check_call(cmd) + + +def main(): + opts = Setup.parse_arguments() + Setup.setup_profiles() + Setup.conan_install_all(Setup.BuildMode.release, + opts.options if opts.options is not None else [], + build_missing=True, + custom_profile=opts.profile + ) + build(get_preset()) + +if __name__ == "__main__": + main() + \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index e799e8ea..61c7245b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,23 +1,26 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later -cmake_minimum_required(VERSION 3.13) +cmake_minimum_required(VERSION 3.23) project( BSMPT - VERSION 2.4.0 + VERSION 3.0.7 LANGUAGES C CXX - DESCRIPTION "BSMPT - Beyond the Standard Model Phase Transitions : A C++ package for the computation of the EWPT in BSM models") + DESCRIPTION + "BSMPT - Beyond the Standard Model Phase Transitions : A C++ package for the computation of the EWPT in BSM models" +) # -------------------------------- options -------------------------------- option(UseLibCMAES "Use libcmaes to minimize the potential" ON) option(UseNLopt "Use NLopt to minimize the potential" ON) -option(MakeAdditionalTesting "Build the executables used for further testing" OFF) -option(BSMPTCompileBaryo "Compile Baryogenesis" ON) -option(UseConan "Use conan to get dependencies" OFF) +option(MakeAdditionalTesting "Build the executables used for further testing" + OFF) +option(BSMPTCompileBaryo "Compile Baryogenesis" OFF) option(EnableCoverage "Enable code coverage" OFF) - +option(BSMPTUseVectorization "Disable vectorization" ON) set(BSMPT_IS_TOPLEVEL NO) if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) @@ -28,10 +31,13 @@ if(NOT BSMPT_IS_TOPLEVEL) set(EnableCoverage OFF) endif() -set(BSMPT_USE_VECTORIZATION ON) if(EnableCoverage) # The compiler flags don't mix well, so we turn it off in this scenario - set(BSMPT_USE_VECTORIZATION OFF) + set(BSMPTUseVectorization OFF) +endif() + +if(BSMPT_IS_TOPLEVEL) + include(CTest) endif() # -------------------------------- setup cmake -------------------------------- @@ -47,140 +53,113 @@ if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release") endif(NOT CMAKE_BUILD_TYPE) - - set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin") - - include(LTO) - - -if(UseConan) - list(APPEND CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR}) - include(conan) - set(ConanPkgList eigen/3.4.0 - gsl/2.7 - boost/1.78.0) - - if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) - set(ConanPkgList ${ConanPkgList} benchmark/1.6.1) - endif() - if(UseNLopt) - set(ConanPkgList ${ConanPkgList} nlopt/2.7.1) - endif(UseNLopt) - conan_cmake_configure(REQUIRES ${ConanPkgList} - GENERATORS cmake_find_package) - - - conan_cmake_autodetect(settings) - - conan_cmake_install(PATH_OR_REFERENCE . - BUILD missing - REMOTE conancenter - SETTINGS ${settings}) - -endif(UseConan) - - find_package(PkgConfig) -find_package(Eigen3 3.3.0 REQUIRED) -find_package(Boost 1.66) -find_package(GSL 2.1 REQUIRED) - - +find_package(Eigen3 CONFIG REQUIRED) +find_package(Boost CONFIG) +find_package(GSL CONFIG REQUIRED) +find_package(nlohmann_json CONFIG) find_package(Threads REQUIRED) -if(NOT BOOST_FOUND) +if(NOT Boost_FOUND) set(BSMPTCompileBaryo OFF) endif() +set(CodeCoverageExcludesFromOtherPkgs "") +if(NOT "${EIGEN3_ROOT_DIR}" STREQUAL "") + list(APPEND CodeCoverageExcludesFromOtherPkgs "${EIGEN3_ROOT_DIR}/*") +endif() -set(CodeCoverageExcludesFromOtherPkgs - "${EIGEN3_ROOT_DIR}/*" - "${GSL_ROOT_DIR}/*") +if(NOT "${GSL_ROOT_DIR}" STREQUAL "") + list(APPEND CodeCoverageExcludesFromOtherPkgs "${GSL_ROOT_DIR}/*") +endif() if(Boost_FOUND) if(NOT "${Boost_DIR}" STREQUAL "") - set(CodeCoverageExcludesFromOtherPkgs - ${CodeCoverageExcludesFromOtherPkgs} - "${Boost_DIR}/*" - ) + list(APPEND CodeCoverageExcludesFromOtherPkgs "${Boost_DIR}/*") endif() if(NOT "${Boost_ROOT_DIR}" STREQUAL "") - set(CodeCoverageExcludesFromOtherPkgs - ${CodeCoverageExcludesFromOtherPkgs} - "${Boost_ROOT_DIR}/*" - ) + list(APPEND CodeCoverageExcludesFromOtherPkgs "${Boost_ROOT_DIR}/*") + endif() +endif() + +if(nlohmann_json_FOUND) + if(NOT "${nlohmann_json}" STREQUAL "") + list(APPEND CodeCoverageExcludesFromOtherPkgs "${nlohmann_json}/*") endif() endif() set(EXPORT_CMAES FALSE) include(FetchContent) if(UseLibCMAES AND NOT WIN32) - include(CMAES) + include(CMAES) endif(UseLibCMAES AND NOT WIN32) if(UseNLopt) - find_package(NLopt QUIET) + find_package(NLopt CONFIG QUIET) if(NLopt_FOUND) if(NOT "${NLopt_ROOT_DIR}" STREQUAL "") - set(CodeCoverageExcludesFromOtherPkgs - ${CodeCoverageExcludesFromOtherPkgs} - "${NLopt_ROOT_DIR}/*" - ) + set(CodeCoverageExcludesFromOtherPkgs ${CodeCoverageExcludesFromOtherPkgs} + "${NLopt_ROOT_DIR}/*") endif() if(NOT "${NLopt_DIR}" STREQUAL "") - set(CodeCoverageExcludesFromOtherPkgs - ${CodeCoverageExcludesFromOtherPkgs} - "${NLopt_DIR}/*" - ) + set(CodeCoverageExcludesFromOtherPkgs ${CodeCoverageExcludesFromOtherPkgs} + "${NLopt_DIR}/*") endif() endif() endif(UseNLopt) if(NOT libcmaes_FOUND AND NOT NLopt_FOUND) - message( FATAL_ERROR "You need at least libcmaes or NLopt." ) + message(FATAL_ERROR "You need at least libcmaes or NLopt.") endif() configure_file(include/BSMPT/config.h.in include/BSMPT/config.h) -# -------------------- Coverage -------------------------------------------------- +# -------------------- Coverage +# -------------------------------------------------- if(EnableCoverage) include(CodeCoverage) append_coverage_compiler_flags() -# set(LCOV_ARGS "--no-external") + # set(LCOV_ARGS "--no-external") set(COVERAGE_EXCLUDES - "/usr/include/*" - "/usr/lib/*" - ${CodeCoverageExcludesFromOtherPkgs} - "${PROJECT_SOURCE_DIR}/tests/*" - "tests/*" - "${PROJECT_SOURCE_DIR}/src/prog/*" - "${PROJECT_SOURCE_DIR}/src/utility/*" - "${PROJECT_SOURCE_DIR}/include/BSMPT/utility/Logger.h" - "${PROJECT_SOURCE_DIR}/src/Kfactors/Kfactors.cpp" - "${PROJECT_SOURCE_DIR}/src/models/ClassPotentialOrigin_deprecated.cpp" - "${PROJECT_SOURCE_DIR}/src/models/ClassTemplate.cpp" - "${PROJECT_SOURCE_DIR}/src/WallThickness/WallThickness1D.cpp" - ) - SETUP_TARGET_FOR_COVERAGE_LCOV( - NAME coverage # New target name - EXECUTABLE ctest -j ${n_cores} # Executable in PROJECT_BINARY_DIR - BASE_DIRECTORY "${PROJECT_SOURCE_DIR}" - ) + "/usr/include/*" + "/usr/lib/*" + ${CodeCoverageExcludesFromOtherPkgs} + "${PROJECT_SOURCE_DIR}/tests/*" + "tests/*" + "${PROJECT_SOURCE_DIR}/src/prog/*" + "${PROJECT_SOURCE_DIR}/src/utility/*" + "${PROJECT_SOURCE_DIR}/include/BSMPT/utility/Logger.h" + "${PROJECT_SOURCE_DIR}/src/Kfactors/Kfactors.cpp" + "${PROJECT_SOURCE_DIR}/src/models/ClassPotentialOrigin_deprecated.cpp" + "${PROJECT_SOURCE_DIR}/src/models/ClassTemplate.cpp" + "${PROJECT_SOURCE_DIR}/src/WallThickness/WallThickness1D.cpp" + "${PROJECT_SOURCE_DIR}/src/standalone/*" + "${PROJECT_SOURCE_DIR}/src/utility/spline/spline.cpp" + "${PROJECT_SOURCE_DIR}/src/utility/asciiplotter/asciiplotter.cpp") + setup_target_for_coverage_lcov( + NAME + coverage # New target name + EXECUTABLE + ctest + -j + ${n_cores} # Executable in PROJECT_BINARY_DIR + BASE_DIRECTORY + "${PROJECT_SOURCE_DIR}" + DEPENDS + GenericTests) endif(EnableCoverage) - find_lto(CXX) - add_subdirectory(src) - +add_subdirectory(standalone) # -------------------------- export as cmake package -------------------------- if(PROJECT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) @@ -190,49 +169,30 @@ if(PROJECT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) VERSION ${PACKAGE_VERSION} COMPATIBILITY AnyNewerVersion) - set(ExportList - Models - Minimizer - ThermalFunctions - Utility - ) - + set(ExportList Models Minimizer ThermalFunctions Utility Spline ASCIIPlotter) if(BSMPTCompileBaryo) - set(ExportList - ${ExportList} - Baryo - LibWallThickness - Kfactors - ) + set(ExportList ${ExportList} Baryo LibWallThickness Kfactors) endif(BSMPTCompileBaryo) - export( TARGETS ${ExportList} NAMESPACE BSMPT:: - FILE BSMPTTargets.cmake - ) + FILE BSMPTTargets.cmake) if(EXPORT_CMAES) export( TARGETS cmaes NAMESPACE libcmaes:: - APPEND FILE BSMPTTargets.cmake - ) + APPEND + FILE BSMPTTargets.cmake) endif(EXPORT_CMAES) - - - configure_file(tools/cmake/BSMPTConfig.cmake.in BSMPTConfig.cmake @ONLY) - export(PACKAGE BSMPT) endif() - - # ------------------------ Doxygen -------------------------------------------- if(BSMPT_IS_TOPLEVEL) find_package(Doxygen) @@ -241,37 +201,36 @@ if(BSMPT_IS_TOPLEVEL) set(DOXYGEN_USE_MATHJAX YES) set(DOXYGEN_STRIP_FROM_INC_PATH "${CMAKE_CURRENT_SOURCE_DIR}/include") set(DOXYGEN_EXCLUDE - ${CMAKE_CURRENT_SOURCE_DIR}/src/Kfactors/Kfunctions_grid_Part1.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/src/Kfactors/Kfunctions_grid_Part2.cpp - ) + ${CMAKE_CURRENT_SOURCE_DIR}/src/Kfactors/Kfunctions_grid_Part1.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/Kfactors/Kfunctions_grid_Part2.cpp) + set(DOXYGEN_EXCLUDE_PATTERNS ${CMAKE_CURRENT_SOURCE_DIR}/src/*/README.md) set(DOXYGEN_PROJECT_BRIEF ${CMAKE_PROJECT_DESCRIPTION}) set(DOXYGEN_EXTRACT_PRIVATE YES) set(DOXYGEN_GENERATE_TREEVIEW YES) set(DOXYGEN_DISTRIBUTE_GROUP_DOC YES) set(DOXYGEN_WARN_IF_UNDOCUMENTED YES) set(DOXYGEN_WARN_IF_DOC_ERROR YES) - set(DOXYGEN_USE_MDFILE_AS_MAINPAGE README.md) + set(DOXYGEN_USE_MDFILE_AS_MAINPAGE ${CMAKE_CURRENT_SOURCE_DIR}/README.md) - doxygen_add_docs(doc + doxygen_add_docs( + doc "${CMAKE_CURRENT_SOURCE_DIR}/include/" "${CMAKE_CURRENT_SOURCE_DIR}/src/" "${CMAKE_CURRENT_SOURCE_DIR}/README.md" - "${CMAKE_CURRENT_SOURCE_DIR}/Changelog.md") + "${CMAKE_CURRENT_SOURCE_DIR}/Changelog.md" + "${CMAKE_CURRENT_SOURCE_DIR}/tests/") - else () - message("Doxygen need to be installed to generate the doxygen documentation") + else() + message( + "Doxygen need to be installed to generate the doxygen documentation") endif() endif(BSMPT_IS_TOPLEVEL) +# -------------------- Testing +# --------------------------------------------------- -# -------------------- Testing --------------------------------------------------- -if(BSMPT_IS_TOPLEVEL) - include(CTest) -endif() - +include(CTest) if(BSMPT_IS_TOPLEVEL AND BUILD_TESTING) - add_subdirectory(tests) + add_subdirectory(tests) endif() - - diff --git a/README.md b/README.md index 9367f120..8f35a739 100644 --- a/README.md +++ b/README.md @@ -4,42 +4,39 @@ SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas M SPDX-License-Identifier: GPL-3.0-or-later --> -Program: BSMPT version 2.4.0 +Program: BSMPT version 3.0.7 -Released by: Philipp Basler and Lisa Biermann and Margarete Mühlleitner and Jonas Müller +Released by: Philipp Basler, Lisa Biermann, Margarete Mühlleitner, Jonas Müller, Rui Santos and João Viana -[!["GitHub Discussions"](https://img.shields.io/badge/%20GitHub-%20Discussions-gray.svg?longCache=true&logo=github&colorB=purple)](https://github.com/phbasler/BSMPT/discussions) -[![Ubuntu unit tests](https://github.com/phbasler/BSMPT/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/phbasler/BSMPT/actions/workflows/test.yml) -[![Mac unit tests](https://github.com/phbasler/BSMPT/actions/workflows/test-mac.yml/badge.svg?branch=master)](https://github.com/phbasler/BSMPT/actions/workflows/test-mac.yml) -[![Windows unit tests](https://github.com/phbasler/BSMPT/actions/workflows/windows_unit_tests.yml/badge.svg?branch=master)](https://github.com/phbasler/BSMPT/actions/workflows/windows_unit_tests.yml) +[![GitHub Discussions](https://img.shields.io/badge/%20GitHub-%20Discussions-gray.svg?longCache=true&logo=github&colorB=purple)](https://github.com/phbasler/BSMPT/discussions) +[![Unit tests](https://github.com/phbasler/BSMPT/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/phbasler/BSMPT/actions/workflows/test.yml) [![codecov master](https://codecov.io/gh/phbasler/BSMPT/branch/master/graph/badge.svg?token=LDGNQTADB5)](https://codecov.io/gh/phbasler/BSMPT) [![Documentation](https://img.shields.io/badge/Documentation-master-success)][DoxygenLink] [![Benchmarks](https://img.shields.io/badge/Benchmark-master-success)](https://phbasler.github.io/BSMPT/benchmarks/) [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/phbasler/bsmpt/graphs/commit-activity) [![GitHub license](https://img.shields.io/github/license/phbasler/bsmpt.svg)](https://github.com/phbasler/BSMPT/blob/master/LICENSE.md) [![Latest release](https://badgen.net/github/release/phbasler/bsmpt)](https://github.com/phbasler/bsmpt/releases) -[![Language grade: C/C++](https://img.shields.io/lgtm/grade/cpp/g/phbasler/BSMPT.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/phbasler/BSMPT/context:cpp) - -Manual: version 2.0 +Manual: version 3.0 BSMPT - Beyond the Standard Model Phase Transitions: -The C++ program package BSMPT calculates the strength of the electroweak phase transition in extended Higgs sectors. For this the loop-corrected effective potential at finite temperature is calculated including the daisy resummation of the bosonic masses. -The program computes the vacuum expectation value (VEV) \f$ v \f$ of the potential -as a function of the temperature, and in particular the critical VEV -\f$v_c\f$ at the temperature \f$T_c\f$ where the phase transition takes -place. -In addition, the loop-corrected trilinear Higgs self-couplings are -provided. We apply an 'on-shell' renormalization scheme in the sense + +The C++ program package BSMPT allows for the detailed study of (multi-step) phase transitions between temperature-dependent minima in the one-loop daisy-resummed finite-temperature effective potential. + +The program tracks temperature-dependent minima, calculates the bounce solution, the characteristic temperatures and gravitational wave signals of first-order phase transitions. +The code also allows to derive the loop-corrected trilinear Higgs self-couplings and provides the computation of the baryon asymmetry for the CP-violating 2-Higgs Doublet Model (C2HDM). + +We apply an 'on-shell' renormalization scheme in the sense that the loop-corrected masses and mixing angles are required to be equal to their tree-level input values. This allows for efficient scans in the parameter space of the models. The models implemented so far are - - CP-conserving 2-Higgs-Doublet Models (R2HDM) - - CP-violating 2-Higgs-Doublet Models (C2HDM) + - Standard Model (SM) + - CP-conserving 2-Higgs-Doublet Model (R2HDM) + - CP-violating 2-Higgs-Doublet Model (C2HDM) - Next-to-Minimal 2HDM (N2HDM) - CP in the Dark ([arXiv 1807.10322](https://arxiv.org/abs/1807.10322), [arXiv 2204.13425](https://arxiv.org/abs/2204.13425)) - Complex Singlet Extension (CxSM) @@ -59,8 +56,7 @@ Modifications and corrected bugs are reported in the file 'Changelog.md'. -For additional information, comments, complaints or suggestions please e-mail -to: bsmpt@lists.kit.edu, open a corresponding [issue](https://github.com/phbasler/BSMPT/issues) or start a [discussion](https://github.com/phbasler/BSMPT/discussions). +For additional information, comments, complaints or suggestions open a corresponding [issue](https://github.com/phbasler/BSMPT/issues) or start a [discussion](https://github.com/phbasler/BSMPT/discussions). For non-public matters please send an e-mail to bsmpt@lists.kit.edu. --- @@ -69,65 +65,85 @@ If you use this program for your work, please cite - [1803.02846](https://arxiv.org/abs/1803.02846) - [2007.01725](https://arxiv.org/abs/2007.01725) + - [2404.19037](https://arxiv.org/abs/2404.19037) ## Installation: +BSMPT uses cmake and [conan 2](https://conan.io/) for its installation which can be installed through pip with `pip3 install cmake conan`. +In addition, you need a `C` and `C++` compiler installed. + +### build - simple +If you want the default installation of BSMPT, you can then use the `Build.py` script. +The script `Build.py` installs the necessary conan profiles for your operating system, handles the dependencies and compiles `BSMPT` with its default settings in release mode. You can execute it with + +```bash +python3 Build.py +``` ### Dependencies -BSMPT uses cmake which will try to find the following libraries. If they are not found automatically, you can use the -DpackageName_ROOT option of cmake to tell it where to look for the package. +BSMPT uses cmake and [conan 2](https://conan.io/) for dependencies. The used dependencies are: 1. [GSL library](https://www.gnu.org/software/gsl/). 2. [Eigen3](https://eigen.tuxfamily.org/index.php?title=Main_Page) -3. [libcmaes](https://github.com/CMA-ES/libcmaes): Additionally to GSL you should either use libcmaes or NLopt. If libcmaes is installed through cmake BSMPT should find it automatically, otherwise you can point it to the install direction with - `-Dlibcmaes_ROOT=/path/to/cmaes` - - If cmaes is not installed then it will be installed in your build directory. For more details on the libcmaes installation, e.g. possible dependencies, visit their [wiki](https://github.com/CMA-ES/libcmaes/wiki). If you don't want to install or use it, you can set `-DUseLibCMAES=OFF` - -4. [NLopt](https://nlopt.readthedocs.io/en/latest/): If you do not want to use NLopt, you can set `-DUseNLopt=OFF` -5. [Boost](https://www.boost.org/) : This is optional and only required for the Baryogenesis calculations. If it is not found then these parts are not available. - -### Alternative Install method -If you have [conan](https://conan.io/) installed, then you can set the `-DUseConan=ON` flag for cmake and it will download boost, gsl, eigen3 and NLopt (if UseNLopt was not turned off) through [conancenter](https://conan.io/center/). - -### build -With the dependencies and options you can build the programm with - - mkdir build && cd build - cmake (OPTIONS from Dependencies) .. - cmake --build . -j - cmake --build . -j -t doc +3. [libcmaes](https://github.com/CMA-ES/libcmaes): Additionally to GSL you should either use libcmaes or NLopt. For more details on the libcmaes installation, e.g. possible dependencies, visit their [wiki](https://github.com/CMA-ES/libcmaes/wiki). If you don't want to install or use it, you can set `--options UseLibCMAES=False` when using the detailed build, as described below. +4. [NLopt](https://nlopt.readthedocs.io/en/latest/): If you do not want to use NLopt, you can set `--options UseNLopt=False` when using the detailed build, as described below. +5. [Boost](https://www.boost.org/) : This is optional and only required for the Baryogenesis calculations. In order to compile the Baryogenesis calculation, set `--options CompileBaryo=True` when using the detailed build, as described below. + + +### build - detailed +We provide the script `Setup.py` which installs conan profiles for your operating system and runs `conan install` to download the dependencies. If you want to use other profiles feel free to execute `conan install` with your profile manually or add it to the script. + +You can build the code with + +```bash +python3 Setup.py +cmake --preset ${profile} +cmake --build --preset ${profile} -j +cmake --build --preset ${profile} -j -t doc +``` The `-t doc` will use doxygen to create the online help in build/html which can be opened locally. +The `${profile}` parameter depends on your operating system. After running the `Setup` script you can call `cmake --list-presets` to show the found presets. + +The script `Setup.py` can take several optional arguments, run `python3 Setup.py -h` or `python3 Setup.py --help` to display them. ### Unit tests -After compiling the code call `ctest -j` in the build folder to run some checks. Here the NLO VEV and EWPT for the R2HDM, C2HDM and N2HDM example points will be calculated and compared to the expected results. +After compiling the code call `ctest --preset ${profile} -j` in the root folder to run some checks. Here the NLO VEV and EWPT for the R2HDM, C2HDM and N2HDM example points will be calculated and compared to the expected results. + + +### Development +Most modern IDEs support cmake profiles. After running the `Setup.py` script you can open the root folder in an IDE of your choice (e.g. VSCode with cmake extension) and it will recognise the cmake profile. + + +Code from the following repositories is used in BSMPT: +- [`ttk592::spline`](https://github.com/ttk592/spline) by Tino Kluge, a C++ cubic spline interpolation library +- [`AsciiPlotter`](https://github.com/joehood/asciiplotter) by Joe Hood, for ASCII plots in the terminal --- -## How to add a new model (for further details, also see the manual): +## How to add a new model: -To add a new model you have to modify/create five files +To add a new model, you have to modify/create five files (for further details, also consult the manual): -1. Go to include/BSMPT/models and copy ClassTemplate.h to YourModel.h. Adjust the Class_Template name to your new model. For step 5 I will assume that your class is named Class_YourModel. +1. Go to `include/BSMPT/models` and copy `ClassTemplate.h` to `YourModel.h`. Adjust the name of the class `Class_Template` to `Class_YourModel`. -2. Go to src/models and copy ClassTemplate.cpp to YourModel.cpp, and change the Class_Template class name in the file to your model name. Also follow the instructions in here and in the manual to set up your new model. +2. Go to `src/models` and copy `ClassTemplate.cpp` to `YourModel.cpp`, and again change `Class_Template` to `Class_YourModel`. Also, follow the instructions in this file and in the manual to set up your new model. -3. For your model to compile you have to open src/models/CMakeLists.txt and add ${header_path}/YourModel.h in the set(header enviroment as well as YourModel.cpp in the set(src enviroment) +3. For your model to compile, you have to open `src/models/CMakeLists.txt` and add `${header_path}/YourModel.h` as well as `YourModel.cpp` to the listed headers and source files. -4. In include/BSMPT/models/IncludeAllModels.h you need to add a new entry in the ModelIDs enum above the `stop` entry which is different from the ones already in the enum, e.g. YourModel. Additionally, you have to create a new entry in the `const std::unordered_map ModelNames` map in the same file and add a new line with {"YourModelName",ModelIDs::YourModel} , the matching will be done automatically. -Then you can call your model with `./binary YourModelName ...` . +4. In `include/BSMPT/models/IncludeAllModels.h` you need to add a new entry in the `enum class ModelIDs` above the `stop` entry which is different from the already defined `ModelIDs`, e.g. `YourModel`. Additionally, you have to create a new entry in the `const std::unordered_map ModelNames` map in the same file and add a new line with `{"YourModelName",ModelIDs::YourModel}`. -5. In src/models/IncludeAllModels.cpp you have to add `#include ` to the include list. Also to actually call your model you have to extend the FChoose function. For this you add a new case to the switch statement, which reads +5. In `src/models/IncludeAllModels.cpp` you have to add `#include ` to the include list. Also, to be able to call your model, you have to extend the `FChoose` function. For this you add a new case to the switch statement, which reads case ModelIDs::YourModel: return std::make_unique(); break; - + ### Generate the C++ code for a model We provide currently two methods to generate the tensors and calculate the counter terms for a new model. -1. At tools/ModelGeneration/Maple we provide the maple Worksheet CreateModel.mw which you can use to implement your model and get the tensors. -2. At tools/ModelGeneration/sympy we provide a setup using only python3 with sympy (at least version 1.10!, if your packet manager only has an older installed, e.g. ubuntu 20.04 only has v1.6, then you have to install v1.10 or up with pip). Here we provide two examples, SM.py and G2HDM.py which both implement two different models and use the ModelGenerator.py module to calculate the tensors and CT. You can get the CT using `python3 SM.py --show ct` and the tensors by calling `python3 SM.py --show tensors`. If your counterterms don't have a unique solution, then the solution space will be shown to you and you have to add additional equations until you have a unique solution (e.g. the G2HDM example). -3. To show the simplified Tree level and counterterm potentials you can use `python3 SM.py --show treeSimpl` und `python3 SM.py --show CTSimpl`. +1. At `tools/ModelGeneration/Maple` we provide the maple Worksheet `CreateModel.mw` which you can use to implement your model and get the tensors. +2. At `tools/ModelGeneration/sympy` we provide a setup using only `python3` with `sympy` (at least version 1.10!, if your packet manager only has an older installed, e.g. ubuntu 20.04 only has v1.6, then you have to install v1.10 or up with pip). Here we provide two examples, `SM.py` and `G2HDM.py` (generic 2HDM) which both use the `ModelGenerator.py` module to calculate the tensors and CT. You can get the CT using `python3 SM.py --show ct` and the tensors by calling `python3 SM.py --show tensors`. If your counterterms don't have a unique solution, then the solution space will be shown to you and you have to add additional equations until you have a unique solution (e.g. in the G2HDM example). +3. To show the simplified tree-level and counterterm potentials, you can use `python3 SM.py --show treeSimpl` and `python3 SM.py --show CTSimpl`. @@ -136,92 +152,62 @@ You can use the Test executable to detect possible errors in your implementation Also contact us if you have a custom model for BSMPT v1.x and you have trouble converting it to the new notation. ## Executables -BSMPT provides multiple executables. Here we give a quick overview of them. For every executable you can call them with the `--help` option to get an overview of possible input parameters. -For the following examples the C2HDM with the example/C2HDM_Input.dat file is used. +BSMPT provides multiple executables. Here we give a quick overview of them. +Every executable can be called with the `--help` option to see how it can be run and to get an overview of all its required and optional arguments. +Also, consult the manuals ([BSMPTv1](https://arxiv.org/abs/1803.02846), [BSMPTv2](https://arxiv.org/abs/2007.01725), [BSMPTv3](https://arxiv.org/abs/24XX.XXXXX])) for more details on the executables and their input parameters. -### BSMPT -BSMPT calculates the EWPT for every parameter point in the input file and gives out the results of those parameter points for which \f$v_c/T_c\f$ > 1. -To find these points a bisection method is used with the temperature starting between 0 and 300 GeV. The executable is called through: +Note, that every executable has the option to set the `--json=/path/to/your/file.json` which contains a json string with the parameters you can set through the CLI. This can be useful if you want to store the parameters you used for a given call. Please beware that all paths in the json file are considered relative to the current working directory and not to the location of the json file. Examples can be found in `example/JSON`. If you want to be sure to have the correct output file we recommend using absolute paths. - ./bin/BSMPT Model Inputfile Outputfile LineStart LineEnd -This will call the specific model to be used, identified through 'Model', and calculate the EWPT for each parameter point (corresponding to one line) between 'LineStart' and 'LineEnd'. +In BSMPTv3, the following four executables are added: -For our example the command - ./bin/BSMPT c2hdm example/C2HDM_Input.dat example/test_BSMPT.dat 2 2 +### MinimaTracer +MinimaTracer tracks temperature-dependent local minima in a user-defined temperature interval. -will calculate for the C2HDM the EWPT for one parameter point given in line 2 in C2HDM_Input.dat. This will generate the output file example/test_BSMPT.dat 2 2 which can be compared with the already available file example/C2HDM_Input.dat_BSMPT. +### CalcTemps +CalcTemps identifies regions of coexisting minima, calculates the bounce solutions and characteristic temperature scales (critical, nucleation, percolation and completion temperature) of first-order phase transitions. Based on that, we report a transition history for the point. -### CalcCT -This will calculate the counterterms. In the output file the information on the input parameter point is given and the counterterms are added at the end of the line. +### CalcGW +CalcGW expands CalcTemps by the additional calculation of the gravitational waves spectra sourced by first-order phase transitions. -It is called through the command +### PotPlotter +PotPlotter calculates user-defined data grids that can be used for the visualization of multi-dimensional potential contours. - ./bin/CalcCT Model Inputfile Outputfile LineStart LineEnd -For the C2HDM example this reads +The following executables were released with BSMPTv1 and BSMPTv2: - ./bin/CalcCT c2hdm example/C2HDM_Input.dat example/test_CalcCT.dat 2 2 -which will generate the output file example/test_CalcCT.dat. This can be compared with the already available file example/C2HDM_Input.dat_CalcCT. +### Test +Test checks the model implementation for a provided parameter point. Some of the performed tests are e.g.: matching fermion masses and tree-level electroweak minimum with SM, tadpole relations, matching scalar masses between tree-level and NLO and symmetries of the coupling-tensors. The number of passed/failed tests is reported. -### NLOVEV -This calculates the VEV at 1-loop order at vanishing temperature in the effective potential approach. This can be used to investigate the vacuum stability of the model. It is called through - - ./bin/NLOVEV Model Inputfile Outputfile LineStart LineEnd - -and for the C2HDM example it is given by +### BSMPT +BSMPT calculates the strength of a single-step electroweak phase transition (EWPT), defined as the ratio of the vacuum expectation value (VEV) at the critical temperature \f$v_c\f$ over the critical temperature \f$T_c\f$, based on finding a discontinuity in the electroweak VEV of the temperature-dependent global minimum. - ./bin/NLOVEV c2hdm example/C2HDM_Input.dat example/test_NLOVEV.dat 2 2 +### CalcCT +CalcCT calculates the (finite) counterterms for the 'on-shell' renormalization scheme. -where the result is written into the file example/test_NLOVEV.dat which can be compared with the already available file example/C2HDM_Input.dat_NLOVEV. +### NLOVEV +NLOVEV calculates the zero-temperature VEV at one-loop order. This can be used to investigate the vacuum stability of the model. ### VEVEVO -This program calculates the evolution of the vacuum expecation value of a given point with the temperature. It is called through - - ./bin/VEVEVO Model Inputfile Outputfile Line Tempstart Tempstep Tempend - -where 'Tempstart' is the starting value of the temperature which increases with 'Tempstep' until 'Tempend'. - -For our C2HDM example this would be - - ./bin/VEVEVO c2hdm example/C2HDM_Input.dat example/test_VEVEVO.dat 2 0 5 150 - -where the result for the NLO VEV is given in example/test_VEVEVO.dat as function of the temperature in the interval between 0 and 150 GeV in steps of 5 GeV. This can be compared with the already available file example/C2HDM_Input.dat_vevevo. +VEVEVO calculates the evolution of the global minimum of a given point in a user-specified temperature range. ### TripleHiggsCouplingNLO -This program calculates the trilinear Higgs self-couplings at NLO at zero temperature. It is called through - - ./bin/TripleHiggsNLO Model Inputfile Outputfile LineStart LineEnd - -The C2HDM example is called through - - ./bin/TripleHiggsNLO c2hdm example/C2HDM_Input.dat example/test_TripleHiggsCouplingNLO.dat 2 2 - -with the result given in example/test_TripleHiggsNLO.dat which can be compared with the already available file example/C2HDM_Input.dat_TripleHiggsCouplingNLO . +TripleHiggsCouplingNLO calculates the trilinear Higgs self-couplings at NLO at zero temperature. ### CalculateEWBG -This program calculates the difference between baryons and anti-baryons +CalculateEWBG calculates the difference between baryons and anti-baryons normalized to the photon density generated through the EWPT. Please beware that this is only tested for the C2HDM so far and the general -implementation is future work. It is called through - - ./bin/CalculateEWBG c2hdm Inputfile Outputfile LineStart LineEnd config_file - - An example is given for the example/C2HDM_Input.dat parameter point through - - ./bin/CalculateEWBG c2hdm example/C2HDM_Input.dat example/test_EWBG.dat 2 2 example/EWBG_config.txt - -with the result given in example/test_EWBG.dat which can be compared with -the already available file example/C2HDM_Input.dat_EWBG. +implementation is future work. ### PlotEWBG_vw -This executable varies the wall velocity of a given parameter point and -calculates the EWBG for each velocity. +PlotEWBG_vw varies the wall velocity of a given parameter point and +calculates the baryon asymmetry for each velocity. ### PlotEWBG_nL -This executable calculates the left-handed fermion density in front of the +PlotEWBG_nL calculates the left-handed fermion density in front of the wall as a function of the distance to the bubble wall. diff --git a/Setup.py b/Setup.py new file mode 100644 index 00000000..d84fc202 --- /dev/null +++ b/Setup.py @@ -0,0 +1,231 @@ +import subprocess +import sys +import os +import shutil +from enum import Enum +import fileinput +from argparse import ArgumentParser, ArgumentTypeError +import platform + + +class ArgTypeEnum(Enum): + @classmethod + def argtype(cls, s: str) -> Enum: + try: + return cls[s] + except KeyError: + raise ArgumentTypeError(f"{s!r} is not a valid {cls.__name__}") + + def __str__(self): + return self.name + + +class BuildMode(ArgTypeEnum, Enum): + all = (0,) + release = (1,) + debug = 2 + + +def get_compiler(): + compiler = "" + + if sys.platform != "linux" and sys.platform != "darwin": + return compiler + + if (sys.platform == "linux"): + compiler += "-gcc-" + + if (sys.platform == "darwin"): + compiler += "-clang-" + compiler += get_compiler_version() + + return compiler + + +def get_profile(os: str, arch: str, build_type: BuildMode): + profile = "" + if os == "win32": + profile += "windows" + elif os == "linux": + profile += "linux" + elif os == "darwin": + profile += "macos" + + profile += "-" + + if build_type == BuildMode.release: + profile += "release" + elif build_type == BuildMode.debug: + profile += "debug" + + profile += "-" + profile += arch + + profile += get_compiler() + + return profile + +def set_setting(file, setting, value): + for line in fileinput.input([file], inplace=True): + if line.strip().startswith(setting): + line = setting + "=" + value + "\n" + sys.stdout.write(line) + +def check_profile(profile): + path = os.path.join("profiles", "BSMPT", profile) + if not os.path.isfile(path): + conan_home = subprocess.check_output("conan config home".split(), encoding="UTF-8").split("\n")[0] + print(f"Profile does not exist in BSMPT/profiles.\nUsing profile {profile} created from the default profile. Change it accordingly.") + if not os.path.isfile(conan_home + "/profiles/default"): + cmd = "conan profile detect".split() + subprocess.check_output(cmd) + if (sys.platform != "win32"): + cmd = "cp " + conan_home + "/profiles/default profiles/BSMPT/" + str(profile) + subprocess.check_call(cmd, shell=True) + set_setting(path, "compiler.cppstd", "gnu17") + + else: + cmd = "copy " + conan_home + "\\profiles\\default profiles\\BSMPT\\" + str(profile) + subprocess.check_call(cmd, shell=True) + set_setting(path, "compiler.cppstd", "17") + + setup_profiles() + check_profile(profile) + + +def get_compiler_version(): + if (sys.platform == "linux"): + version_response = subprocess.check_output( + "gcc --version".split(), encoding="UTF-8" + ).partition("\n")[0] + semver_string = version_response[version_response.rfind(" ") + 1 :] + return semver_string.partition(".")[0] + if (sys.platform == "darwin"): + version_response = subprocess.check_output( + "clang --version".split(), encoding="UTF-8" + ).partition("\n")[0] + semver_string = version_response[version_response.rfind("version") + 8 :] + return semver_string.partition(".")[0] + return "" + + +def get_arch(): + arch = "x86_64" + if platform.machine() == "aarch64" or platform.machine() == "arm64": + arch = "armv8" + return arch + + +def setup_profiles(): + conan_home = subprocess.check_output("conan config home".split(), encoding="UTF-8") + profile_dir = os.path.join(str(conan_home.split()[0]), "profiles", "BSMPT") + print(profile_dir) + if os.path.exists(profile_dir): + shutil.rmtree(profile_dir) + shutil.copytree("profiles/BSMPT", profile_dir) + + +def conan_install(profile, additional_options=[], build_missing=False): + config_settings = [ + "tools.cmake.cmake_layout:build_folder_vars=['settings.os','settings.arch','settings.build_type']" + ] + + build_profile = get_profile(sys.platform, get_arch(), BuildMode.release) + + cmd = f"conan install . -pr:h BSMPT/{profile} -pr:b BSMPT/{build_profile} ".split() + + for option in additional_options: + cmd += ["--options", option] + + for conf in config_settings: + cmd += ["-c", conf] + + if build_missing: + cmd += ["--build=missing"] + + subprocess.check_call(cmd) + + +def conan_install_all( + mode: BuildMode, options=[], build_missing=False, custom_profile="" +): + if mode == BuildMode.all or mode == BuildMode.release: + profile = ( + custom_profile + if custom_profile != "" + else get_profile(sys.platform, get_arch(), BuildMode.release) + ) + check_profile(profile) + conan_install( + profile, + options, + build_missing, + ) + if mode == BuildMode.all or mode == BuildMode.debug: + profile = ( + custom_profile + if custom_profile != "" + else get_profile(sys.platform, get_arch(), BuildMode.debug) + ) + check_profile(profile) + conan_install( + profile, + options, + build_missing, + ) + + +class ArgTypeEnum(Enum): + @classmethod + def argtype(cls, s: str) -> Enum: + try: + return cls[s] + except KeyError: + raise argparse.ArgumentTypeError(f"{s!r} is not a valid {cls.__name__}") + + def __str__(self): + return self.name + + +def parse_arguments(): + parser = ArgumentParser() + parser.add_argument( + "--mode", + "-m", + default=BuildMode.release, + type=BuildMode.argtype, + choices=BuildMode, + help="Should BSMPT be build in Debug, Release or both?", + ) + parser.add_argument( + "--options", + "-o", + nargs="+", + action="extend", + help="Options to pass through to conan. For the available options please look into the conanfile.", + ) + parser.add_argument( + "--build-missing", "-b", action="store_true", help="Build missing dependencies." + ) + + parser.add_argument( + "-p", + "--profile", + type=str, + help="The name of a custom profile. If you leave this empty we will try to deduce a matching profile.", + default="", + ) + + return parser.parse_args() + + +if __name__ == "__main__": + + opts = parse_arguments() + setup_profiles() + conan_install_all( + opts.mode, + opts.options if opts.options is not None else [], + opts.build_missing, + opts.profile, + ) diff --git a/conanfile.py b/conanfile.py new file mode 100644 index 00000000..de5d6969 --- /dev/null +++ b/conanfile.py @@ -0,0 +1,86 @@ +from conan import ConanFile, tools +from conan.tools.cmake import cmake_layout, CMakeToolchain +from conan.tools.system.package_manager import Apt +from conan.errors import ConanInvalidConfiguration + +required_conan_version = ">=2.0.0 <3" + + +class BSMPT(ConanFile): + settings = "os", "compiler", "build_type", "arch" + generators = "CMakeDeps" + + options = { + "EnableTests": [True, False], # enables the unit tests + "UseLibCMAES": [ + True, + False, + ], # Use CMAES. Fetches it through cmake_fetch if not installed + "UseNLopt": [True, False], # Use NLopt for minimization + "MakeAdditionalTesting": [True, False], # build additional test executables + "CompileBaryo": [ + True, + False, + ], # compile the electroweak baryogenesis for the C2HDM + "EnableCoverage": [True, False], # enable code coverage + "UseVectorization": [True, False], # use vectorization for the build + } + default_options = { + "EnableTests": True, + "UseLibCMAES": True, + "UseNLopt": True, + "MakeAdditionalTesting": False, + "CompileBaryo": False, + "EnableCoverage": False, + "UseVectorization": True, + } + + def requirements(self): + self.requires("eigen/3.4.0") + self.requires("gsl/2.7.1") + self.requires("nlohmann_json/3.11.3") + + if self.options.CompileBaryo: + self.requires("boost/1.84.0") + + if self.options.UseNLopt: + self.requires("nlopt/2.7.1") + + def build_requirements(self): + self.tool_requires("cmake/3.29.0") + + if self.options.EnableTests: + self.test_requires("catch2/3.5.3") + self.test_requires("benchmark/1.6.2") + + def system_requirements(self): + if self.options.EnableCoverage: + apt = Apt(self) + apt.install(["lcov"], update=True, check=True) + + def layout(self): + cmake_layout(self) + + def generate(self): + tc = CMakeToolchain(self) + + tc.variables["BUILD_TESTING"] = self.options.EnableTests + tc.variables["UseLibCMAES"] = self.options.UseLibCMAES + tc.variables["UseNLopt"] = self.options.UseNLopt + tc.variables["MakeAdditionalTesting"] = self.options.MakeAdditionalTesting + tc.variables["BSMPTCompileBaryo"] = self.options.CompileBaryo + tc.variables["EnableCoverage"] = self.options.EnableCoverage + tc.variables["BSMPTUseVectorization"] = self.options.UseVectorization + + tc.generate() + + def validate(self): + if self.options.UseVectorization and self.options.EnableCoverage: + raise ConanInvalidConfiguration( + "Vectorization and coverage are not supported simultaneously." + ) + + if self.settings.os != "Linux" and self.options.EnableCoverage: + raise ConanInvalidConfiguration("We depend on lcov for coverage.") + + tools.build.check_min_cppstd(self, "17") diff --git a/example/JSON/BSMPT.json b/example/JSON/BSMPT.json new file mode 100644 index 00000000..b91c8474 --- /dev/null +++ b/example/JSON/BSMPT.json @@ -0,0 +1,17 @@ +{ + "firstLine": "2", + "lastLine": "2", + "input": "../../example/C2HDM_Input.dat", + "output": "test.tsv", + "model": "c2hdm", + "useNLopt": "true", + "useCMAES": "true", + "useGSL": "true", + "useMultiThreading": "true", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/JSON/CalcCT.json b/example/JSON/CalcCT.json new file mode 100644 index 00000000..7f1f3353 --- /dev/null +++ b/example/JSON/CalcCT.json @@ -0,0 +1,13 @@ +{ + "firstLine": "2", + "lastLine": "2", + "input": "../../example/C2HDM_Input.dat", + "output": "test.tsv", + "model": "c2hdm", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/JSON/CalcGW.json b/example/JSON/CalcGW.json new file mode 100644 index 00000000..2d606387 --- /dev/null +++ b/example/JSON/CalcGW.json @@ -0,0 +1,23 @@ +{ + "model": "r2hdm", + "input": "../../example/example_v3_BP1.tsv", + "output": "test.tsv", + "firstline": "2", + "lastline": "2", + "thigh": "400", + "multistepmode": "default", + "num_pts": "10", + "vwall": "0.95", + "perc_prbl": "0.71", + "compl_prbl": "0.01", + "trans_temp": "perc", + "epsturb": "0.1", + "checknlo": "on", + "checkewsr": "on", + "maxpathintegrations": "7", + "usenlopt": "true", + "usecmaes": "true", + "usegsl": "true", + "usemultithreading": "true", + "logginglevel::complete": "false" +} \ No newline at end of file diff --git a/example/JSON/CalcTemps.json b/example/JSON/CalcTemps.json new file mode 100644 index 00000000..07c2b32e --- /dev/null +++ b/example/JSON/CalcTemps.json @@ -0,0 +1,21 @@ +{ + "model": "r2hdm", + "input": "../../example/example_v3_BP1.tsv", + "output": "test.tsv", + "firstline": "2", + "lastline": "2", + "thigh": "400", + "multistepmode": "default", + "num_pts": "10", + "vwall": "0.95", + "perc_prbl": "0.71", + "compl_prbl": "0.01", + "checknlo": "on", + "checkewsr": "on", + "maxpathintegrations": "7", + "usenlopt": "true", + "usecmaes": "true", + "usegsl": "true", + "usemultithreading": "true", + "logginglevel::complete": "false" +} \ No newline at end of file diff --git a/example/JSON/CalculateEWBG.json b/example/JSON/CalculateEWBG.json new file mode 100644 index 00000000..32a0ac9c --- /dev/null +++ b/example/JSON/CalculateEWBG.json @@ -0,0 +1,19 @@ +{ + "firstLine": "2", + "lastLine": "2", + "input": "../../example/C2HDM_Input.dat", + "output": "test.tsv", + "model": "c2hdm", + "config": "../../example/EWBG_config.txt", + + "useNLopt": "true", + "useCMAES": "true", + "useGSL": "true", + "useMultiThreading": "true", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/JSON/MinimaTracer.json b/example/JSON/MinimaTracer.json new file mode 100644 index 00000000..093d1448 --- /dev/null +++ b/example/JSON/MinimaTracer.json @@ -0,0 +1,16 @@ +{ + "model": "r2hdm", + "input": "../../example/example_v3_BP1.tsv", + "output": "test", + "firstline": "2", + "lastline": "2", + "thigh": "400", + "multistepmode": "default", + "num_pts": "10", + "checkewsr": "on", + "usenlopt": "true", + "usecmaes": "true", + "usegsl": "true", + "usemultithreading": "true", + "logginglevel::complete": "false" +} \ No newline at end of file diff --git a/example/JSON/NLOVEV.json b/example/JSON/NLOVEV.json new file mode 100644 index 00000000..b91c8474 --- /dev/null +++ b/example/JSON/NLOVEV.json @@ -0,0 +1,17 @@ +{ + "firstLine": "2", + "lastLine": "2", + "input": "../../example/C2HDM_Input.dat", + "output": "test.tsv", + "model": "c2hdm", + "useNLopt": "true", + "useCMAES": "true", + "useGSL": "true", + "useMultiThreading": "true", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/JSON/PlotEWBG_nL.json b/example/JSON/PlotEWBG_nL.json new file mode 100644 index 00000000..65905092 --- /dev/null +++ b/example/JSON/PlotEWBG_nL.json @@ -0,0 +1,19 @@ +{ + "line": "2", + "input": "../../example/C2HDM_Input.dat", + "output": "test.tsv", + "model": "c2hdm", + "config": "../../example/EWBG_config.txt", + "vw": "0.1", + + "useNLopt": "true", + "useCMAES": "true", + "useGSL": "true", + "useMultiThreading": "true", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/JSON/PlotEWBG_vw.json b/example/JSON/PlotEWBG_vw.json new file mode 100644 index 00000000..3f3ad721 --- /dev/null +++ b/example/JSON/PlotEWBG_vw.json @@ -0,0 +1,21 @@ +{ + "line": "2", + "input": "../../example/C2HDM_Input.dat", + "output": "test.tsv", + "model": "c2hdm", + "config": "../../example/EWBG_config.txt", + "vw_min": "0.1", + "vw_max": "0.2", + "vw_stepsize": "0.05", + + "useNLopt": "true", + "useCMAES": "true", + "useGSL": "true", + "useMultiThreading": "true", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/JSON/PotPlotter.json b/example/JSON/PotPlotter.json new file mode 100644 index 00000000..c503f190 --- /dev/null +++ b/example/JSON/PotPlotter.json @@ -0,0 +1,15 @@ +{ + "model": "r2hdm", + "input": "../example/example_v3_BP1.tsv", + "output": "test.tsv", + "line": "2", + "temperature": "0", + "point": "0,0,0,0", + "npoints2": "50", + "npoints3": "50", + "low2": "-300", + "low3": "-300", + "high2": "300", + "high3": "300", + "logginglevel::complete": "false" +} \ No newline at end of file diff --git a/example/JSON/Test.json b/example/JSON/Test.json new file mode 100644 index 00000000..6b2d7440 --- /dev/null +++ b/example/JSON/Test.json @@ -0,0 +1,14 @@ +{ + "line": "2", + "input": "../../example/C2HDM_Input.dat", + "model": "c2hdm", + "useNLopt": "true", + "useCMAES": "true", + "useGSL": "true", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/JSON/TripleHiggsCouplingsNLO.json b/example/JSON/TripleHiggsCouplingsNLO.json new file mode 100644 index 00000000..7f1f3353 --- /dev/null +++ b/example/JSON/TripleHiggsCouplingsNLO.json @@ -0,0 +1,13 @@ +{ + "firstLine": "2", + "lastLine": "2", + "input": "../../example/C2HDM_Input.dat", + "output": "test.tsv", + "model": "c2hdm", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/JSON/VEVEVO.json b/example/JSON/VEVEVO.json new file mode 100644 index 00000000..15ee3250 --- /dev/null +++ b/example/JSON/VEVEVO.json @@ -0,0 +1,20 @@ +{ + "line": "2", + "input": "../../example/C2HDM_Input.dat", + "output": "test.tsv", + "model": "c2hdm", + "temperatureStart": "0", + "temperatureEnd": "100", + "temperatureStep": "5", + + "useNLopt": "true", + "useCMAES": "true", + "useGSL": "true", + "useMultiThreading": "true", + "logginglevel::default": "true", + "logginglevel::minimizerdetailed": "false", + "logginglevel::ewbgdetailed": "false", + "logginglevel::debug": "false", + "logginglevel::progdetailed": "false", + "logginglevel::disabled_comment": "remove _comment from key to disable logger" +} diff --git a/example/SM_Input.dat b/example/SM_Input.dat new file mode 100644 index 00000000..062493ef --- /dev/null +++ b/example/SM_Input.dat @@ -0,0 +1,2 @@ +muSq lambda +-7823.7540500000005 0.12905349405143487 \ No newline at end of file diff --git a/example/SM_Input.dat_BSMPT b/example/SM_Input.dat_BSMPT new file mode 100644 index 00000000..76fde085 --- /dev/null +++ b/example/SM_Input.dat_BSMPT @@ -0,0 +1,2 @@ +muSq lambda dmuSq dlambda dT1 dT2 dT3 dT4 T_c v_c omega_c/T_c omega_c +-7823.7540500000005 0.12905349405143487 -1049.65 -0.0105927 -0 -0 -5.82077e-11 -0 160.208 24.2806 0.151557 24.2806 diff --git a/example/SM_Input.dat_VEVEVO b/example/SM_Input.dat_VEVEVO new file mode 100644 index 00000000..31f1d788 --- /dev/null +++ b/example/SM_Input.dat_VEVEVO @@ -0,0 +1,3002 @@ +T v omega Veff(v,T) +0 246.2196478710799 -246.2196478710799 -126174978.1898605 +0.1 246.2196478710799 -246.2196478710799 -126174978.1997104 +0.2 246.2196478710799 -246.2196478710799 -126174978.2733171 +0.3 246.2196417567254 -246.2196417567254 -126174978.4874305 +0.4 246.2196332847427 -246.2196332847427 -126174978.9353135 +0.5 246.2196220980566 -246.2196220980566 -126174979.7289798 +0.6 246.2196066898343 246.2196066898343 -126174980.9996496 +0.7 246.219602241657 -246.219602241657 -126174982.8979424 +0.7999999999999999 246.2195828659805 -246.2195828659805 -126174985.5943484 +0.8999999999999999 246.2195687133747 246.2195687133747 -126174989.2797417 +0.9999999999999999 246.2195459292698 -246.2195459292698 -126174994.1656792 +1.1 246.2195258007674 -246.2195258007674 -126175000.4849657 +1.2 246.2195066512195 -246.2195066512195 -126175008.492393 +1.3 246.2194770390977 246.2194770390977 -126175018.4639419 +1.4 246.2194542104817 246.2194542104817 -126175030.6969969 +1.5 246.2194217624378 -246.2194217624378 -126175045.5098678 +1.6 246.2193933929267 246.2193933929267 -126175063.2417555 +1.7 246.2193606434671 246.2193606434671 -126175084.2525742 +1.8 246.2193266473232 246.2193266473232 -126175108.9227845 +1.900000000000001 246.2192816601424 -246.2192816601424 -126175137.6532404 +2 246.2192558871191 -246.2192558871191 -126175170.8650539 +2.100000000000001 246.2192100698567 246.2192100698567 -126175208.9994652 +2.200000000000001 246.2191777784811 246.2191777784811 -126175252.5177327 +2.300000000000001 246.2191338168066 -246.2191338168066 -126175301.9010295 +2.400000000000001 246.2190804321247 246.2190804321247 -126175357.6503455 +2.500000000000001 246.2190314051629 -246.2190314051629 -126175420.2863971 +2.600000000000001 246.2189842147335 246.2189842147335 -126175490.3495453 +2.700000000000001 246.2189336378561 246.2189336378561 -126175568.3997113 +2.800000000000001 246.2188896761816 -246.2188896761816 -126175655.0162985 +2.900000000000001 246.2188234700234 246.2188234700234 -126175750.7981166 +3.000000000000001 246.2187742293445 -246.2187742293445 -126175856.3633027 +3.100000000000001 246.2187162957607 246.2187162957607 -126175972.3492466 +3.200000000000002 246.2186567222427 -246.2186567222427 -126176099.4125151 +3.300000000000002 246.2185997182942 246.2185997182942 -126176238.228775 +3.400000000000002 246.2185346519302 -246.2185346519302 -126176389.4983208 +3.500000000000002 246.2184728291455 246.2184728291455 -126176553.9446621 +3.600000000000002 246.218408018407 -246.218408018407 -126176732.3058213 +3.700000000000002 246.2183351887734 246.2183351887734 -126176925.3395582 +3.800000000000002 246.2182793246191 -246.2182793246191 -126177133.8233818 +3.900000000000002 246.2182012159811 246.2182012159811 -126177358.5545478 +4.000000000000002 246.2181312764981 246.2181312764981 -126177600.3500575 +4.100000000000001 246.2180609570174 -246.2180609570174 -126177860.0466587 +4.200000000000001 246.2179838738857 246.2179838738857 -126178138.5008456 +4.300000000000001 246.2179131136816 -246.2179131136816 -126178436.5888588 +4.4 246.2178350050436 246.2178350050436 -126178755.2066866 +4.5 246.2177522295829 -246.2177522295829 -126179095.2700661 +4.6 246.217675596532 -246.217675596532 -126179457.714485 +4.699999999999999 246.2175908644186 246.2175908644186 -126179843.4951833 +4.799999999999999 246.2175145129152 -246.2175145129152 -126180253.5871561 +4.899999999999999 246.2174248324316 -246.2174248324316 -126180688.9851561 +4.999999999999998 246.2173467237936 246.2173467237936 -126181150.7036969 +5.099999999999998 246.2172569448567 246.2172569448567 -126181639.7770573 +5.199999999999998 246.2171652835843 246.2171652835843 -126182157.2592851 +5.299999999999997 246.2170782801629 -246.2170782801629 -126182704.2242033 +5.399999999999997 246.2169924153359 246.2169924153359 -126183281.7654153 +5.499999999999996 246.2168977452666 246.2168977452666 -126183890.996312 +5.599999999999996 246.2167990726468 246.2167990726468 -126184533.0500789 +5.699999999999996 246.2167108278567 -246.2167108278567 -126185209.0797076 +5.799999999999995 246.2166162417698 -246.2166162417698 -126185920.2580005 +5.899999999999995 246.2165218349093 246.2165218349093 -126186667.7775867 +5.999999999999995 246.2164222921231 246.2164222921231 -126187452.850931 +6.099999999999994 246.2163261996191 -246.2163261996191 -126188276.7103489 +6.199999999999994 246.2162237879754 -246.2162237879754 -126189140.6080204 +6.299999999999994 246.2161260206686 246.2161260206686 -126190045.8160066 +6.399999999999993 246.2160282641876 -246.2160282641876 -126190993.626266 +6.499999999999993 246.2159211748954 -246.2159211748954 -126191985.3506753 +6.599999999999993 246.2158206044046 246.2158206044046 -126193022.3210479 +6.699999999999992 246.2157158480566 -246.2157158480566 -126194105.8891568 +6.799999999999992 246.2156092132392 246.2156092132392 -126195237.4267578 +6.899999999999991 246.2154974804549 -246.2154974804549 -126196418.3256142 +6.999999999999991 246.2153935987936 246.2153935987936 -126197649.9975238 +7.099999999999991 246.2152834309609 246.2152834309609 -126198933.8743461 +7.19999999999999 246.2151741821247 246.2151741821247 -126200271.4080324 +7.29999999999999 246.2150636033259 246.2150636033259 -126201664.0706569 +7.39999999999999 246.2149541704955 -246.2149541704955 -126203113.3544488 +7.499999999999989 246.2148383672227 246.2148383672227 -126204620.7718268 +7.599999999999989 246.2147238773343 246.2147238773343 -126206187.8554341 +7.699999999999989 246.2146172152441 -246.2146172152441 -126207816.1581753 +7.799999999999988 246.2144951449316 -246.2144951449316 -126209507.2532558 +7.899999999999988 246.2143796980945 -246.2143796980945 -126211262.7342182 +7.999999999999988 246.2142621909927 -246.2142621909927 -126213084.2149866 +8.099999999999987 246.2141443694892 246.2141443694892 -126214973.3299063 +8.199999999999987 246.2140222991767 246.2140222991767 -126216931.7337877 +8.299999999999986 246.2139032106692 -246.2139032106692 -126218961.1019503 +8.399999999999986 246.2137811403567 -246.2137811403567 -126221063.130268 +8.499999999999986 246.2136590700442 -246.2136590700442 -126223239.535215 +8.599999999999985 246.2135369997317 -246.2135369997317 -126225492.0539131 +8.699999999999985 246.2134119476142 246.2134119476142 -126227822.4441794 +8.799999999999985 246.2132898773017 246.2132898773017 -126230232.4845752 +8.899999999999984 246.2131635581802 -246.2131635581802 -126232723.9744552 +8.999999999999984 246.213036924657 -246.213036924657 -126235298.7340174 +9.099999999999984 246.2129082308691 -246.2129082308691 -126237958.6043541 +9.199999999999983 246.2127861605566 -246.2127861605566 -126240705.4475024 +9.299999999999983 246.2126486820218 246.2126486820218 -126243541.1464967 +9.399999999999983 246.2125190312852 246.2125190312852 -126246467.6054193 +9.499999999999982 246.212390693933 -246.212390693933 -126249486.7494538 +9.599999999999982 246.2122590733916 246.2122590733916 -126252600.5249371 +9.699999999999982 246.2121244988857 246.2121244988857 -126255810.8994128 +9.799999999999981 246.2119875325234 246.2119875325234 -126259119.8616833 +9.899999999999981 246.2118554995823 -246.2118554995823 -126262529.4218636 +9.99999999999998 246.2117133007674 -246.2117133007674 -126266041.6114338 +10.09999999999998 246.2115808929267 246.2115808929267 -126269658.4832936 +10.19999999999998 246.2114433871191 -246.2114433871191 -126273382.1118131 +10.29999999999998 246.211301460407 -246.211301460407 -126277214.5928885 +10.39999999999998 246.211160014418 -246.211160014418 -126281158.0439932 +10.49999999999998 246.2110237914997 246.2110237914997 -126285214.6042316 +10.59999999999998 246.2108768405628 -246.2108768405628 -126289386.434392 +10.69999999999998 246.2107306239129 -246.2107306239129 -126293675.716998 +10.79999999999998 246.2105888949316 -246.2105888949316 -126298084.6563617 +10.89999999999998 246.2104392928585 246.2104392928585 -126302615.4786357 +10.99999999999998 246.2102913696247 246.2102913696247 -126307270.4318641 +11.09999999999998 246.2101445753561 246.2101445753561 -126312051.7860352 +11.19999999999998 246.2099897300552 -246.2099897300552 -126316961.8331312 +11.29999999999998 246.2098391590921 246.2098391590921 -126322002.8871799 +11.39999999999998 246.2096830926357 246.2096830926357 -126327177.2843049 +11.49999999999998 246.2095342237936 246.2095342237936 -126332487.3827752 +11.59999999999997 246.2093681918066 -246.2093681918066 -126337935.5630567 +11.69999999999997 246.2092073155791 246.2092073155791 -126343524.2278581 +11.79999999999997 246.2090478823948 -246.2090478823948 -126349255.8021833 +11.89999999999997 246.208886534032 -246.208886534032 -126355132.7333778 +11.99999999999997 246.2087284562855 246.2087284562855 -126361157.4911775 +12.09999999999997 246.2085576612936 246.2085576612936 -126367332.5677566 +12.19999999999997 246.2083916293066 -246.2083916293066 -126373660.4777738 +12.29999999999997 246.2082210536593 246.2082210536593 -126380143.7584206 +12.39999999999997 246.2080511913924 -246.2080511913924 -126386784.9694666 +12.49999999999997 246.207873964098 246.207873964098 -126393586.6933062 +12.59999999999997 246.2077031691061 246.2077031691061 -126400551.5350038 +12.69999999999997 246.2075217288968 246.2075217288968 -126407682.1223396 +12.79999999999997 246.2073388980198 -246.2073388980198 -126414981.1058532 +12.89999999999997 246.2071555179593 246.2071555179593 -126422451.1588899 +12.99999999999997 246.2069726870823 -246.2069726870823 -126430094.9776427 +13.09999999999997 246.2067874012796 246.2067874012796 -126437915.2811975 +13.19999999999997 246.2066043796253 -246.2066043796253 -126445914.811575 +13.29999999999997 246.2064092486205 -246.2064092486205 -126454096.333776 +13.39999999999997 246.2062097991767 246.2062097991767 -126462462.6358206 +13.49999999999997 246.2060090983018 -246.2060090983018 -126471016.5287924 +13.59999999999997 246.2058108387796 246.2058108387796 -126479760.8468811 +13.69999999999997 246.2056097851424 -246.2056097851424 -126488698.4474216 +13.79999999999997 246.2054085571247 246.2054085571247 -126497832.2109371 +13.89999999999997 246.2051948125352 246.2051948125352 -126507165.0411797 +13.99999999999997 246.204980284032 -246.204980284032 -126516699.8651697 +14.09999999999997 246.2047733249378 -246.2047733249378 -126526439.6332372 +14.19999999999997 246.2045442545518 -246.2045442545518 -126536387.3190624 +14.29999999999997 246.2043245030791 246.2043245030791 -126546545.9197128 +14.39999999999996 246.2040993119695 -246.2040993119695 -126556918.4556851 +14.49999999999996 246.2038750277441 -246.2038750277441 -126567507.9709432 +14.59999999999996 246.2036375105945 -246.2036375105945 -126578317.532958 +14.69999999999996 246.2034021819892 246.2034021819892 -126589350.232744 +14.79999999999996 246.2031580413642 246.2031580413642 -126600609.1848998 +14.89999999999996 246.2029168825442 -246.2029168825442 -126612097.5276454 +14.99999999999996 246.2026697601142 246.2026697601142 -126623818.4228596 +15.09999999999996 246.2024168074695 -246.2024168074695 -126635775.0561185 +15.19999999999996 246.2021660433691 -246.2021660433691 -126647970.6367321 +15.29999999999996 246.2018989140977 246.2018989140977 -126660408.3977835 +15.39999999999996 246.2016319448567 246.2016319448567 -126673091.5961623 +15.49999999999996 246.2013674153359 246.2013674153359 -126686023.512605 +15.59999999999996 246.2010870692254 -246.2010870692254 -126699207.4517307 +15.69999999999996 246.2008078617093 246.2008078617093 -126712646.7420761 +15.79999999999996 246.2005257446247 246.2005257446247 -126726344.7361335 +15.89999999999996 246.2002386913924 -246.2002386913924 -126740304.8103864 +15.99999999999996 246.1999393937854 246.1999393937854 -126754530.3653454 +16.09999999999996 246.1996463718128 -246.1996463718128 -126769024.8255835 +16.19999999999996 246.199338569782 -246.199338569782 -126783791.639773 +16.29999999999996 246.1990361769186 246.1990361769186 -126798834.280719 +16.39999999999996 246.1987092687041 246.1987092687041 -126814156.2453982 +16.49999999999996 246.198388487157 -246.198388487157 -126829761.0549887 +16.59999999999997 246.1980615542698 -246.1980615542698 -126845652.25491 +16.69999999999997 246.1977296189509 246.1977296189509 -126861833.4148554 +16.79999999999997 246.1973898929593 246.1973898929593 -126878308.1288274 +16.89999999999997 246.1970457137195 -246.1970457137195 -126895080.0151718 +16.99999999999997 246.1966925379754 -246.1966925379754 -126912152.7166125 +17.09999999999997 246.1963324413924 -246.1963324413924 -126929529.9002855 +17.19999999999997 246.1959662304549 -246.1959662304549 -126947215.2577736 +17.29999999999998 246.1956000195174 -246.1956000195174 -126965212.5051398 +17.39999999999998 246.1952192222427 -246.1952192222427 -126983525.3829607 +17.49999999999998 246.1948418246191 -246.1948418246191 -127002157.6563614 +17.59999999999998 246.1944462297229 246.1944462297229 -127021113.1150488 +17.69999999999998 246.1940431965859 246.1940431965859 -127040395.5733435 +17.79999999999998 246.1936365569892 246.1936365569892 -127060008.8702151 +17.89999999999998 246.193225526598 246.193225526598 -127079956.8693141 +17.99999999999999 246.1927924023299 -246.1927924023299 -127100243.4590051 +18.09999999999999 246.1923710344105 246.1923710344105 -127120872.5524007 +18.19999999999999 246.1919305544192 -246.1919305544192 -127141848.0873915 +18.29999999999999 246.1914827311143 -246.1914827311143 -127163174.026681 +18.39999999999999 246.191030113171 246.191030113171 -127184854.3578179 +18.49999999999999 246.1905693636816 -246.1905693636816 -127206893.0932266 +18.59999999999999 246.1900965179267 246.1900965179267 -127229294.2702412 +18.7 246.1896124598504 -246.1896124598504 -127252061.9511357 +18.8 246.1891241786004 -246.1891241786004 -127275200.223157 +18.9 246.1886274253677 -246.1886274253677 -127298713.1985558 +19 246.1881125492093 246.1881125492093 -127322605.0146179 +19.1 246.1876008702666 246.1876008702666 -127346879.8336968 +19.2 246.1870731296253 -246.1870731296253 -127371541.8432416 +19.3 246.1865410433691 -246.1865410433691 -127396595.2558315 +19.40000000000001 246.1859895670516 -246.1859895670516 -127422044.3092045 +19.50000000000001 246.1854270023343 246.1854270023343 -127447893.2662878 +19.60000000000001 246.1848760206686 246.1848760206686 -127474146.4152293 +19.70000000000001 246.1842899829376 -246.1842899829376 -127500808.0694275 +19.80000000000001 246.183704042223 246.183704042223 -127527882.5675588 +19.90000000000001 246.1831000859727 246.1831000859727 -127555374.2736118 +20.00000000000001 246.182492866657 -246.182492866657 -127583287.5769134 +20.10000000000002 246.1818729875355 246.1818729875355 -127611626.8921598 +20.20000000000002 246.1812386352497 246.1812386352497 -127640396.6594447 +20.30000000000002 246.1806035597311 246.1806035597311 -127669601.3442885 +20.40000000000002 246.1799338382718 246.1799338382718 -127699245.4376692 +20.50000000000002 246.1792726887734 246.1792726887734 -127729333.4560465 +20.60000000000002 246.1785910648343 246.1785910648343 -127759869.9413936 +20.70000000000002 246.1778998242049 -246.1778998242049 -127790859.4612245 +20.80000000000003 246.177196794875 -246.177196794875 -127822306.6086221 +20.90000000000003 246.1764799676357 246.1764799676357 -127854216.0022648 +21.00000000000003 246.1757454711872 246.1757454711872 -127886592.2864552 +21.10000000000003 246.1750032389267 -246.1750032389267 -127919440.1311464 +21.20000000000003 246.1742557468128 -246.1742557468128 -127952764.2319693 +21.30000000000003 246.1734795199316 -246.1734795199316 -127986569.3102611 +21.40000000000003 246.1726957879482 246.1726957879482 -128020860.1130876 +21.50000000000004 246.1718992293445 -246.1718992293445 -128055641.4132736 +21.60000000000004 246.1710840152074 -246.1710840152074 -128090918.0094273 +21.70000000000004 246.1702598745442 246.1702598745442 -128126694.7259662 +21.80000000000004 246.1694218156605 246.1694218156605 -128162976.4131425 +21.90000000000004 246.1685643176027 -246.1685643176027 -128199767.9470688 +22.00000000000004 246.1676937099093 246.1676937099093 -128237074.2297431 +22.10000000000004 246.1668094577503 -246.1668094577503 -128274900.1890734 +22.20000000000005 246.1659111605566 -246.1659111605566 -128313250.7789023 +22.30000000000005 246.1649904622109 246.1649904622109 -128352130.9790319 +22.40000000000005 246.1640602494695 -246.1640602494695 -128391545.7952471 +22.50000000000005 246.1631147300552 -246.1631147300552 -128431500.2593395 +22.60000000000005 246.1621527538924 -246.1621527538924 -128471999.4291317 +22.70000000000005 246.1611700770379 -246.1611700770379 -128513048.3884998 +22.80000000000005 246.1601738558691 -246.1601738558691 -128554652.2473964 +22.90000000000006 246.159158061293 -246.159158061293 -128596816.1418743 +23.00000000000006 246.1581244335799 -246.1581244335799 -128639545.2341079 +23.10000000000006 246.1570762807942 246.1570762807942 -128682844.7124162 +23.20000000000006 246.1560080570218 246.1560080570218 -128726719.7912843 +23.30000000000006 246.154931455907 -246.154931455907 -128771175.7113854 +23.40000000000006 246.1538261996191 -246.1538261996191 -128816217.7396023 +23.50000000000006 246.152707710407 -246.152707710407 -128861851.1690479 +23.60000000000007 246.1515627278359 246.1515627278359 -128908081.319087 +23.70000000000007 246.1504082308691 -246.1504082308691 -128954913.5353573 +23.80000000000007 246.1492334292699 -246.1492334292699 -129002353.1897874 +23.90000000000007 246.1480403895968 246.1480403895968 -129050405.6806198 +24.00000000000007 246.1468223745442 246.1468223745442 -129099076.4324288 +24.10000000000007 246.1455941039997 246.1455941039997 -129148370.8961409 +24.20000000000007 246.1443304882674 -246.1443304882674 -129198294.549054 +24.30000000000008 246.1430610234727 246.1430610234727 -129248852.8948564 +24.40000000000008 246.1417670117049 -246.1417670117049 -129300051.4636444 +24.50000000000008 246.1404536308125 -246.1404536308125 -129351895.8119429 +24.60000000000008 246.1391115559609 246.1391115559609 -129404391.5227221 +24.70000000000008 246.1377568800436 246.1377568800436 -129457544.2054153 +24.80000000000008 246.136376768407 -246.136376768407 -129511359.4959376 +24.90000000000008 246.1349760613857 246.1349760613857 -129565843.0567022 +25.00000000000009 246.1335471195218 246.1335471195218 -129621000.576638 +25.10000000000009 246.1321088706802 -246.1321088706802 -129676837.7712073 +25.20000000000009 246.1306394637195 -246.1306394637195 -129733360.3824201 +25.30000000000009 246.1291506825296 246.1291506825296 -129790574.1788524 +25.40000000000009 246.1276369465859 246.1276369465859 -129848484.9556614 +25.50000000000009 246.1261008304593 246.1261008304593 -129907098.5346017 +25.60000000000009 246.1245447601142 246.1245447601142 -129966420.7640401 +25.7000000000001 246.1229608278567 -246.1229608278567 -130026457.5189712 +25.8000000000001 246.1213554964941 -246.1213554964941 -130087214.7010327 +25.9000000000001 246.1197227651692 246.1197227651692 -130148698.2385194 +26.0000000000001 246.118066221532 -246.118066221532 -130210914.0863979 +26.1000000000001 246.1163945753561 246.1163945753561 -130273868.2263204 +26.2000000000001 246.1146416293066 -246.1146416293066 -130337566.8991577 +26.3000000000001 246.1128664387734 246.1128664387734 -130402016.5043348 +26.40000000000011 246.111072334558 -246.111072334558 -130467223.1146566 +26.50000000000011 246.1092475469102 246.1092475469102 -130533192.8260817 +26.60000000000011 246.1073975877009 246.1073975877009 -130599931.7616643 +26.70000000000011 246.1055121288924 -246.1055121288924 -130667446.071562 +26.80000000000011 246.1036134080134 246.1036134080134 -130735741.9330469 +26.90000000000011 246.101682319782 -246.101682319782 -130804825.5505109 +27.00000000000011 246.099721519421 246.099721519421 -130874703.1554774 +27.10000000000012 246.0977327311142 -246.0977327311142 -130945381.0066085 +27.20000000000012 246.0957207308691 -246.0957207308691 -131016865.3897142 +27.30000000000012 246.0936713085799 -246.0936713085799 -131089162.6177601 +27.40000000000012 246.0916141452503 -246.0916141452503 -131162279.0308766 +27.50000000000012 246.0895063316177 -246.0895063316177 -131236220.9963675 +27.60000000000012 246.0873741323567 246.0873741323567 -131310994.9087152 +27.70000000000012 246.0852226839941 -246.0852226839941 -131386607.1895926 +27.80000000000013 246.0830254183691 -246.0830254183691 -131463064.2878702 +27.90000000000013 246.0808051640977 246.0808051640977 -131540372.6796214 +28.00000000000013 246.0785547183324 -246.0785547183324 -131618538.8681329 +28.10000000000013 246.0762727452666 246.0762727452666 -131697569.3839116 +28.20000000000013 246.0739628312855 246.0739628312855 -131777470.7846915 +28.30000000000013 246.0716215691982 246.0716215691982 -131858249.6554415 +28.40000000000013 246.0692498903567 -246.0692498903567 -131939912.6083727 +28.50000000000014 246.0668459309609 246.0668459309609 -132022466.282945 +28.60000000000014 246.0644045247109 246.0644045247109 -132105917.3458752 +28.70000000000014 246.0619330273299 -246.0619330273299 -132190272.491142 +28.80000000000014 246.0594266159805 -246.0594266159805 -132275538.4399945 +28.90000000000014 246.0568869632718 246.0568869632718 -132361721.9409576 +29.00000000000014 246.0543231380919 -246.0543231380919 -132448829.7698395 +29.10000000000014 246.0517220336872 246.0517220336872 -132536868.7297361 +29.20000000000014 246.0490744632718 246.0490744632718 -132625845.6510393 +29.30000000000015 246.0464109480945 -246.0464109480945 -132715767.3914422 +29.40000000000015 246.0437014637796 246.0437014637796 -132806640.835944 +29.50000000000015 246.0409570620824 -246.0409570620824 -132898472.8968571 +29.60000000000015 246.0381797964192 246.0381797964192 -132991270.513812 +29.70000000000015 246.0353398878561 246.0353398878561 -133085040.8049727 +29.80000000000015 246.0324623311856 246.0324623311856 -133179790.9981656 +29.90000000000015 246.0295432132718 246.0295432132718 -133275528.1213608 +30.00000000000016 246.0265901280791 246.0265901280791 -133372259.2277022 +30.10000000000016 246.0236029492049 -246.0236029492049 -133469991.3978508 +30.20000000000016 246.0205805839375 -246.0205805839375 -133568731.7399876 +30.30000000000016 246.0175176222311 246.0175176222311 -133668487.3898174 +30.40000000000016 246.0144064945218 246.0144064945218 -133769265.5105709 +30.50000000000016 246.0112738476424 -246.0112738476424 -133871073.2930089 +30.60000000000016 246.0080939051629 -246.0080939051629 -133973917.9554231 +30.70000000000017 246.0048774297227 246.0048774297227 -134077806.7436408 +30.80000000000017 246.0016199554267 246.0016199554267 -134182746.9310262 +30.90000000000017 245.9983240569892 245.9983240569892 -134288745.818484 +31.00000000000017 245.9949867452481 245.9949867452481 -134395810.7344613 +31.10000000000017 245.9916131716067 -245.9916131716067 -134503949.0349502 +31.20000000000017 245.9881922210517 245.9881922210517 -134613168.1034901 +31.30000000000017 245.9847358281602 245.9847358281602 -134723475.3511702 +31.40000000000018 245.9812384364129 -245.9812384364129 -134834878.2166312 +31.50000000000018 245.9776971559817 -245.9776971559817 -134947384.1660683 +31.60000000000018 245.9741157109727 245.9741157109727 -135061000.6932322 +31.70000000000018 245.9704920257392 245.9704920257392 -135175735.3194318 +31.80000000000018 245.9668299163642 245.9668299163642 -135291595.5935355 +31.90000000000018 245.9631229875355 245.9631229875355 -135408589.0919735 +32.00000000000018 245.9593681918066 -245.9593681918066 -135526723.4187393 +32.10000000000019 245.9555686038968 245.9555686038968 -135646006.2053908 +32.20000000000019 245.9517336262734 245.9517336262734 -135766445.1110528 +32.30000000000019 245.9478516892634 245.9478516892634 -135888047.8224174 +32.40000000000019 245.9439204276875 -245.9439204276875 -136010822.053746 +32.50000000000019 245.9399436038968 245.9399436038968 -136134775.54687 +32.60000000000019 245.9359306918066 -245.9359306918066 -136259916.0711938 +32.70000000000019 245.931873115808 -245.931873115808 -136386251.4236923 +32.8000000000002 245.9277631675552 -245.9277631675552 -136513789.4289151 +32.9000000000002 245.9236127769302 -245.9236127769302 -136642537.9389861 +33.0000000000002 245.9194093064509 245.9194093064509 -136772504.8336048 +33.1000000000002 245.9151614247171 245.9151614247171 -136903698.0200463 +33.2000000000002 245.9108670456679 -245.9108670456679 -137036125.4331625 +33.3000000000002 245.9065271819892 245.9065271819892 -137169795.0353827 +33.4000000000002 245.9021368739129 -245.9021368739129 -137304714.8167136 +33.50000000000021 245.8977028275945 -245.8977028275945 -137440892.7947405 +33.60000000000021 245.8932172691177 -245.8932172691177 -137578337.0146264 +33.70000000000021 245.8886894808691 -245.8886894808691 -137717055.5491134 +33.80000000000021 245.8841066731484 245.8841066731484 -137857056.4985225 +33.90000000000021 245.8794710123642 -245.8794710123642 -137998347.9907531 +34.00000000000021 245.8747918825441 -245.8747918825441 -138140938.1812837 +34.10000000000021 245.8700586245824 -245.8700586245824 -138284835.2531713 +34.20000000000022 245.8652777538924 -245.8652777538924 -138430047.4170515 +34.30000000000022 245.8604454214192 245.8604454214192 -138576582.9111381 +34.40000000000022 245.8555665330134 245.8555665330134 -138724450.0012229 +34.50000000000022 245.8506293163924 -245.8506293163924 -138873656.9806752 +34.60000000000022 245.8456426222311 245.8456426222311 -139024212.1704412 +34.70000000000022 245.8406092132392 245.8406092132392 -139176123.9190435 +34.80000000000022 245.8355226887734 245.8355226887734 -139329400.6025804 +34.90000000000023 245.8303838331686 245.8303838331686 -139484050.6247254 +35.00000000000023 245.8251835344105 245.8251835344105 -139640082.4167267 +35.10000000000023 245.8199379171231 245.8199379171231 -139797504.4374047 +35.20000000000023 245.8146366061878 -245.8146366061878 -139956325.1731533 +35.30000000000023 245.8092805826766 -245.8092805826766 -140116553.1379372 +35.40000000000023 245.8038702723504 -245.8038702723504 -140278196.8732921 +35.50000000000023 245.7984126151875 -245.7984126151875 -140441264.9483222 +35.60000000000024 245.7928900585799 -245.7928900585799 -140605765.9597003 +35.70000000000024 245.7873177368122 245.7873177368122 -140771708.5316654 +35.80000000000024 245.7816896809609 245.7816896809609 -140939101.3160222 +35.90000000000024 245.7760031742093 245.7760031742093 -141107952.992139 +36.00000000000024 245.7702639637796 245.7702639637796 -141278272.2669469 +36.10000000000024 245.7644658644186 245.7644658644186 -141450067.8749377 +36.20000000000024 245.7586183918984 245.7586183918984 -141623348.5781625 +36.30000000000025 245.7527031527441 -245.7527031527441 -141798123.1662303 +36.40000000000025 245.7467371429267 245.7467371429267 -141974400.4563057 +36.50000000000025 245.740711006433 -245.740711006433 -142152189.2931074 +36.60000000000025 245.7346213382718 245.7346213382718 -142331498.5489063 +36.70000000000025 245.7284874136067 245.7284874136067 -142512337.1235247 +36.80000000000025 245.7222846562852 245.7222846562852 -142694713.9443315 +36.90000000000025 245.7160286743122 245.7160286743122 -142878637.9662434 +37.00000000000026 245.7097084249356 245.7097084249356 -143064118.1717207 +37.10000000000026 245.7033333618122 245.7033333618122 -143251163.5707664 +37.20000000000026 245.6968910421231 245.6968910421231 -143439783.2009231 +37.30000000000026 245.6903934985625 -245.6903934985625 -143629986.1272714 +37.40000000000026 245.6838356400945 -245.6838356400945 -143821781.4424272 +37.50000000000026 245.6772151942843 245.6772151942843 -144015178.2665398 +37.60000000000026 245.6705325184671 245.6705325184671 -144210185.7472891 +37.70000000000027 245.6637901479817 245.6637901479817 -144406813.0598833 +37.80000000000027 245.6569846195218 245.6569846195218 -144605069.4070567 +37.90000000000027 245.6501221970758 245.6501221970758 -144804964.0190669 +38.00000000000027 245.6431906742093 245.6431906742093 -145006506.153692 +38.10000000000027 245.6361995692843 245.6361995692843 -145209705.0962287 +38.20000000000027 245.6291420186856 245.6291420186856 -145414570.1594886 +38.30000000000027 245.6220247233017 -245.6220247233017 -145621110.6837968 +38.40000000000028 245.6148438767633 245.6148438767633 -145829336.036988 +38.50000000000028 245.6076055128561 245.6076055128561 -146039255.6144037 +38.60000000000028 245.6002832339574 -245.6002832339574 -146250878.8388919 +38.70000000000028 245.5929131136816 -245.5929131136816 -146464215.1607994 +38.80000000000028 245.5854734480945 -245.5854734480945 -146679274.0579734 +38.90000000000028 245.5779671508747 245.5779671508747 -146896065.0357563 +39.00000000000028 245.5703889811143 -245.5703889811143 -147114597.6269834 +39.10000000000029 245.5627617464941 -245.5627617464941 -147334881.3919794 +39.20000000000029 245.555051460407 -245.555051460407 -147556925.9185569 +39.30000000000029 245.5472784754754 -245.5472784754754 -147780740.8220101 +39.40000000000029 245.5394463168066 -245.5394463168066 -148006335.7451151 +39.50000000000029 245.5315375195175 -245.5315375195175 -148233720.3581252 +39.60000000000029 245.5235617679593 245.5235617679593 -148462904.3587672 +39.70000000000029 245.515527159032 -245.515527159032 -148693897.4722396 +39.8000000000003 245.5074180776692 245.5074180776692 -148926709.4512079 +39.9000000000003 245.4992393667317 245.4992393667317 -149161350.0758024 +40.0000000000003 245.4909955894303 -245.4909955894303 -149397829.1536141 +40.1000000000003 245.4826836214941 -245.4826836214941 -149636156.5196922 +40.2000000000003 245.474286542955 -245.474286542955 -149876342.0365398 +40.3000000000003 245.4658379183691 -245.4658379183691 -150118395.5941124 +40.4000000000003 245.4573187695175 -245.4573187695175 -150362327.1098107 +40.50000000000031 245.4487061814508 245.4487061814508 -150608146.5479429 +40.60000000000031 245.4400029737936 245.4400029737936 -150855864.064827 +40.70000000000031 245.4312251151875 -245.4312251151875 -151105489.7067563 +40.80000000000031 245.4223654788968 245.4223654788968 -151357033.5028575 +40.90000000000031 245.4134524403421 245.4134524403421 -151610505.5097521 +41.00000000000031 245.4044562098504 -245.4044562098504 -151865915.8115496 +41.10000000000031 245.3953879398343 245.3953879398343 -152123274.5198467 +41.20000000000032 245.3862546980945 -245.3862546980945 -152382591.7737218 +41.30000000000032 245.3770442958468 245.3770442958468 -152643877.7397305 +41.40000000000032 245.3677620727497 245.3677620727497 -152907142.6119028 +41.50000000000032 245.3584006351468 245.3584006351468 -153172396.6117385 +41.60000000000032 245.3489708120442 245.3489708120442 -153439649.9882034 +41.70000000000032 245.339465760973 245.339465760973 -153708913.0177253 +41.80000000000032 245.3298773632675 -245.3298773632675 -153980196.00419 +41.90000000000033 245.3202264528565 -245.3202264528565 -154253509.2789373 +42.00000000000033 245.310497576125 -245.310497576125 -154528863.2007566 +42.10000000000033 245.300683409032 -245.300683409032 -154806268.1558844 +42.20000000000033 245.2908045257392 245.2908045257392 -155085734.5579978 +42.30000000000033 245.280847600125 -245.280847600125 -155367272.8482129 +42.40000000000033 245.2708135206686 245.2708135206686 -155650893.4950795 +42.50000000000033 245.2606935872109 245.2606935872109 -155936606.9945779 +42.60000000000034 245.2505058871191 -245.2505058871191 -156224423.8701131 +42.70000000000034 245.2402346669046 245.2402346669046 -156514354.6725135 +42.80000000000034 245.2298914398017 245.2298914398017 -156806409.9800246 +42.90000000000034 245.2194706437855 245.2194706437855 -157100600.3983062 +43.00000000000034 245.2089627487929 -245.2089627487929 -157396936.560428 +43.10000000000034 245.1983818636816 -245.1983818636816 -157695429.1268656 +43.20000000000034 245.1877229405791 245.1877229405791 -157996088.7854964 +43.30000000000035 245.1769807530791 245.1769807530791 -158298926.2515957 +43.40000000000035 245.1661664878678 -245.1661664878678 -158603952.267833 +43.50000000000035 245.1552650655606 245.1552650655606 -158911177.6042672 +43.60000000000035 245.1442893070218 245.1442893070218 -159220613.0583431 +43.70000000000035 245.13322208983 -245.13322208983 -159532269.4548872 +43.80000000000035 245.1220879183691 -245.1220879183691 -159846157.6461047 +43.90000000000035 245.1108640730945 -245.1108640730945 -160162288.5115731 +44.00000000000036 245.0995607747109 245.0995607747109 -160480672.9582407 +44.10000000000036 245.0881720301629 -245.0881720301629 -160801321.920421 +44.20000000000036 245.0767035351425 -245.0767035351425 -161124246.3597895 +44.30000000000036 245.0651573354817 245.0651573354817 -161449457.2653797 +44.40000000000036 245.0535282077503 -245.0535282077503 -161776965.6535776 +44.50000000000036 245.0418096144186 245.0418096144186 -162106782.5681206 +44.60000000000036 245.0300080968291 245.0300080968291 -162438919.0800903 +44.70000000000037 245.0181278171253 -245.0181278171253 -162773386.2879106 +44.80000000000037 245.0061649265003 -245.0061649265003 -163110195.3173426 +44.90000000000037 244.9941069207607 244.9941069207607 -163449357.321483 +45.00000000000037 244.9819666351142 244.9819666351142 -163790883.4807548 +45.10000000000037 244.9697441683691 -244.9697441683691 -164134785.0029092 +45.20000000000037 244.95744083983 -244.95744083983 -164481073.1230187 +45.30000000000037 244.9450471593291 244.9450471593291 -164829759.1034727 +45.40000000000038 244.9325685872109 244.9325685872109 -165180854.2339749 +45.50000000000038 244.9200081664997 244.9200081664997 -165534369.8315386 +45.60000000000038 244.9073508304593 244.9073508304593 -165890317.2404828 +45.70000000000038 244.8946196160732 244.8946196160732 -166248707.8324288 +45.80000000000038 244.8818001586872 244.8818001586872 -166609553.0062944 +45.90000000000038 244.868884834558 -244.868884834558 -166972864.1882931 +46.00000000000038 244.85587833983 -244.85587833983 -167338652.8319265 +46.10000000000039 244.8427976668445 -244.8427976668445 -167706930.4179835 +46.20000000000039 244.8296186363053 -244.8296186363053 -168077708.4545341 +46.30000000000039 244.8163576497109 244.8163576497109 -168450998.4769268 +46.40000000000039 244.8030027449695 -244.8030027449695 -168826812.0477841 +46.50000000000039 244.7895683871191 -244.7895683871191 -169205160.7569982 +46.60000000000039 244.7760297691178 -244.7760297691178 -169586056.2217293 +46.70000000000039 244.7624055826767 -244.7624055826767 -169969510.0863974 +46.8000000000004 244.7486944911004 -244.7486944911004 -170355534.0226828 +46.9000000000004 244.7348963226142 244.7348963226142 -170744139.7295194 +47.0000000000004 244.7210086765003 -244.7210086765003 -171135338.9330918 +47.1000000000004 244.7070194719106 244.7070194719106 -171529143.3868323 +47.2000000000004 244.6929445637734 244.6929445637734 -171925564.8714144 +47.3000000000004 244.6787744448948 -244.6787744448948 -172324615.1947514 +47.4000000000004 244.6645225698567 244.6645225698567 -172726306.191992 +47.50000000000041 244.6501707137196 -244.6501707137196 -173130649.7255153 +47.60000000000041 244.635730537683 -244.635730537683 -173537657.6849282 +47.70000000000041 244.6211946202666 244.6211946202666 -173947341.9870609 +47.80000000000041 244.606565132282 -244.606565132282 -174359714.5759631 +47.90000000000041 244.5918402538925 -244.5918402538925 -174774787.4229005 +48.00000000000041 244.5770285648343 244.5770285648343 -175192572.5263508 +48.10000000000041 244.5621220109731 244.5621220109731 -175613081.9119992 +48.20000000000041 244.5471168900945 -244.5471168900945 -176036327.632736 +48.30000000000042 244.5320184450438 -244.5320184450438 -176462321.7686512 +48.40000000000042 244.5168245030791 244.5168245030791 -176891076.4270321 +48.50000000000042 244.5015383137734 244.5015383137734 -177322603.7423583 +48.60000000000042 244.4861574543984 244.4861574543984 -177756915.8762989 +48.70000000000042 244.4706749136067 244.4706749136067 -178194025.0177079 +48.80000000000042 244.4551023543446 -244.4551023543446 -178633943.3826212 +48.90000000000042 244.4394314987929 -244.4394314987929 -179076683.2142522 +49.00000000000043 244.4236702758747 244.4236702758747 -179522256.782988 +49.10000000000043 244.4078011352497 244.4078011352497 -179970676.3863868 +49.20000000000043 244.3918403203477 244.3918403203477 -180421954.3491722 +49.30000000000043 244.3757758007675 -244.3757758007675 -180876103.0232309 +49.40000000000043 244.3596213382718 244.3596213382718 -181333134.7876096 +49.50000000000043 244.343373863171 244.343373863171 -181793062.0485091 +49.60000000000043 244.3270209844102 244.3270209844102 -182255897.2392817 +49.70000000000044 244.3105711043446 -244.3105711043446 -182721652.8204283 +49.80000000000044 244.2940187825234 244.2940187825234 -183190341.2795939 +49.90000000000044 244.2773725425553 -244.2773725425553 -183661975.1315635 +50.00000000000044 244.2606223148343 244.2606223148343 -184136566.9182596 +50.10000000000044 244.2437747059671 244.2437747059671 -184614129.2087373 +50.20000000000044 244.2268242464941 -244.2268242464941 -185094674.5991813 +50.30000000000044 244.2097782077503 -244.2097782077503 -185578215.7129025 +50.40000000000045 244.1926291507718 244.1926291507718 -186064765.2003336 +50.50000000000045 244.1753841395968 244.1753841395968 -186554335.7390261 +50.60000000000045 244.1580324543984 244.1580324543984 -187046940.0336463 +50.70000000000045 244.1405763997109 244.1405763997109 -187542590.8159716 +50.80000000000045 244.1230256749541 244.1230256749541 -188041300.8448882 +50.90000000000045 244.1053709090321 -244.1053709090321 -188543082.9063848 +51.00000000000045 244.0876155849093 244.0876155849093 -189047949.8135519 +51.10000000000046 244.0697635593128 -244.0697635593128 -189555914.4065757 +51.20000000000046 244.0517908538642 244.0517908538642 -190066989.5527384 +51.30000000000046 244.0337274294187 -244.0337274294187 -190581188.1464084 +51.40000000000046 244.015564497231 244.015564497231 -191098523.1090424 +51.50000000000046 243.9972862417317 243.9972862417317 -191619007.3891805 +51.60000000000046 243.9789060652821 -243.9789060652821 -192142653.9624401 +51.70000000000046 243.9604280187041 243.9604280187041 -192669475.8315154 +51.80000000000047 243.941845232375 -243.941845232375 -193199486.0261723 +51.90000000000047 243.9231571140003 -243.9231571140003 -193732697.6032456 +52.00000000000047 243.9043582858753 -243.9043582858753 -194269123.6466354 +52.10000000000047 243.885452457677 -243.885452457677 -194808777.2673024 +52.20000000000047 243.8664496953477 243.8664496953477 -195351671.6032667 +52.30000000000047 243.847333417955 -243.847333417955 -195897819.8196018 +52.40000000000047 243.8281196172227 243.8281196172227 -196447235.1084338 +52.50000000000048 243.8088017016875 -243.8088017016875 -196999930.688935 +52.60000000000048 243.7893682081685 243.7893682081685 -197555919.8073233 +52.70000000000048 243.7698187695175 -243.7698187695175 -198115215.736856 +52.80000000000048 243.7501834811878 -243.7501834811878 -198677831.7778301 +52.90000000000048 243.7304329711872 243.7304329711872 -199243781.2575736 +53.00000000000048 243.710569038532 -243.710569038532 -199813077.5304472 +53.10000000000048 243.690595136705 -243.690595136705 -200385733.9778379 +53.20000000000049 243.6705238546231 243.6705238546231 -200961764.0081569 +53.30000000000049 243.6503420247109 243.6503420247109 -201541181.056835 +53.40000000000049 243.6300409059811 -243.6300409059811 -202123998.586321 +53.50000000000049 243.6096367464942 -243.6096367464942 -202710230.0860763 +53.60000000000049 243.5891289339942 -243.5891289339942 -203299889.0725732 +53.70000000000049 243.5685056746571 -243.5685056746571 -203892989.0892906 +53.80000000000049 243.5477728710801 -243.5477728710801 -204489543.706711 +53.9000000000005 243.5269289387734 243.5269289387734 -205089566.5223171 +54.0000000000005 243.5059760625352 243.5059760625352 -205693071.1605882 +54.1000000000005 243.4849066601426 -243.4849066601426 -206300071.2729974 +54.2000000000005 243.463735191296 243.463735191296 -206910580.5380083 +54.3000000000005 243.4424443800435 243.4424443800435 -207524612.6610705 +54.4000000000005 243.4210493003678 -243.4210493003678 -208142181.3746181 +54.5000000000005 243.3995379818418 -243.3995379818418 -208763300.4380649 +54.60000000000051 243.3779179094106 243.3779179094106 -209387983.6378022 +54.70000000000051 243.3561799718291 243.3561799718291 -210016244.7871949 +54.80000000000051 243.3343293780206 -243.3343293780206 -210648097.7265779 +54.90000000000051 243.3123725469102 243.3123725469102 -211283556.3232542 +55.00000000000051 243.2903008089942 -243.2903008089942 -211922634.4714899 +55.10000000000051 243.2681097851426 -243.2681097851426 -212565346.0925124 +55.20000000000051 243.2458138305622 243.2458138305622 -213211705.1345062 +55.30000000000052 243.2233908695218 243.2233908695218 -213861725.5726105 +55.40000000000052 243.2008670749378 -243.2008670749378 -214515421.408915 +55.50000000000052 243.1782204057195 -243.1782204057195 -215172806.6724575 +55.60000000000052 243.1554590152076 -243.1554590152076 -215833895.4192204 +55.70000000000052 243.1325859652442 -243.1325859652442 -216498701.7321274 +55.80000000000052 243.1095979405791 243.1095979405791 -217167239.7210405 +55.90000000000052 243.0864892886451 -243.0864892886451 -217839523.5227564 +56.00000000000053 243.0632696864129 -243.0632696864129 -218515567.3010042 +56.10000000000053 243.0399345980567 -243.0399345980567 -219195385.2464412 +56.20000000000053 243.0164797840921 243.0164797840921 -219878991.5766504 +56.30000000000053 242.9929099959835 242.9929099959835 -220566400.5361368 +56.40000000000053 242.969226631433 -242.969226631433 -221257626.3963249 +56.50000000000053 242.9454229204955 -242.9454229204955 -221952683.4555553 +56.60000000000053 242.9214970109732 242.9214970109732 -222651586.0390814 +56.70000000000054 242.8974555547227 242.8974555547227 -223354348.499066 +56.80000000000054 242.8732932132718 242.8732932132718 -224060985.2145787 +56.90000000000054 242.8490232527821 -242.8490232527821 -224771510.5915933 +57.00000000000054 242.8246283398301 -242.8246283398301 -225485939.0629827 +57.10000000000054 242.8001123355201 -242.8001123355201 -226204285.0885181 +57.20000000000054 242.7754789910732 242.7754789910732 -226926563.1548644 +57.30000000000054 242.7507270390977 242.7507270390977 -227652787.7755775 +57.40000000000055 242.7258543074696 -242.7258543074696 -228382973.4911017 +57.50000000000055 242.700867231606 242.700867231606 -229117134.868766 +57.60000000000055 242.6757530386067 242.6757530386067 -229855286.5027809 +57.70000000000055 242.6505148929593 242.6505148929593 -230597443.0142357 +57.80000000000055 242.6251654492052 -242.6251654492052 -231343619.0510961 +57.90000000000055 242.5996956664997 242.5996956664997 -232093829.2881993 +58.00000000000055 242.5740969715921 242.5740969715921 -232848088.4272528 +58.10000000000056 242.5483832226427 -242.5483832226427 -233606411.1968302 +58.20000000000056 242.5225472289997 242.5225472289997 -234368812.3523685 +58.30000000000056 242.4965823231546 242.4965823231546 -235135306.6761656 +58.40000000000056 242.4705023632677 -242.4705023632677 -235905908.977376 +58.50000000000056 242.4443001586872 242.4443001586872 -236680634.0920088 +58.60000000000056 242.4179633672227 242.4179633672227 -237459496.882925 +58.70000000000056 242.3915155153559 -242.3915155153559 -238242512.2398326 +58.80000000000057 242.3649416340859 242.3649416340859 -239029695.0792859 +58.90000000000057 242.3382451861205 -242.3382451861205 -239821060.3446805 +59.00000000000057 242.3114255965322 -242.3114255965322 -240616623.0062522 +59.10000000000057 242.2844853956684 242.2844853956684 -241416398.0610717 +59.20000000000057 242.257410100125 -242.257410100125 -242220400.5330449 +59.30000000000057 242.2302128312857 242.2302128312857 -243028645.4729055 +59.40000000000057 242.2028984652442 -242.2028984652442 -243841147.9582154 +59.50000000000058 242.1754480804267 242.1754480804267 -244657923.0933612 +59.60000000000058 242.1478705273302 -242.1478705273302 -245478986.0095491 +59.70000000000058 242.1201806948951 -242.1201806948951 -246304351.8648065 +59.80000000000058 242.0923586262734 242.0923586262734 -247134035.8439722 +59.90000000000058 242.0644173461872 242.0644173461872 -247968053.1586998 +60.00000000000058 242.0363411743122 242.0363411743122 -248806419.0474512 +60.10000000000058 242.0081429321247 242.0081429321247 -249649148.7754946 +60.20000000000059 241.9798097981484 241.9798097981484 -250496257.6349019 +60.30000000000059 241.9513574527076 -241.9513574527076 -251347760.9445447 +60.40000000000059 241.9227728710802 -241.9227728710802 -252203674.0500924 +60.50000000000059 241.8940717613053 -241.8940717613053 -253064012.3240085 +60.60000000000059 241.8652289922227 241.8652289922227 -253928791.1655483 +60.70000000000059 241.8362679321247 241.8362679321247 -254798026.0007547 +60.80000000000059 241.8071722851427 -241.8071722851427 -255671732.282457 +60.9000000000006 241.7779487187852 241.7779487187852 -256549925.4902664 +61.0000000000006 241.7485967237934 241.7485967237934 -257432621.130574 +61.1000000000006 241.719113960407 -241.719113960407 -258319834.7365472 +61.2000000000006 241.6895145358753 -241.6895145358753 -259211581.8681269 +61.3000000000006 241.6597657517632 241.6597657517632 -260107878.1120264 +61.4000000000006 241.6299004183692 -241.6299004183692 -261008739.0817236 +61.5000000000006 241.5998968945177 -241.5998968945177 -261914180.4174638 +61.60000000000061 241.5697637159809 241.5697637159809 -262824217.7862531 +61.70000000000061 241.539505192052 -241.539505192052 -263738866.8818564 +61.80000000000061 241.5091096842395 -241.5091096842395 -264658143.4247947 +61.90000000000061 241.4785883964375 -241.4785883964375 -265582063.1623424 +62.00000000000061 241.4479373874378 -241.4479373874378 -266510641.8685232 +62.10000000000061 241.4171472991767 241.4171472991767 -267443895.3441083 +62.20000000000061 241.3862282182195 -241.3862282182195 -268381839.4166129 +62.30000000000062 241.355179020177 -241.355179020177 -269324489.9402934 +62.40000000000062 241.3239922152442 -241.3239922152442 -270271862.7961444 +62.50000000000062 241.292679020177 -241.292679020177 -271223973.8918959 +62.60000000000062 241.2612307606546 241.2612307606546 -272180839.1620102 +62.70000000000062 241.2296472991767 241.2296472991767 -273142474.5676786 +62.80000000000062 241.1979373874378 -241.1979373874378 -274108896.0968193 +62.90000000000062 241.1660890950234 241.1660890950234 -275080119.7640739 +63.00000000000063 241.1340967105202 -241.1340967105202 -276056161.6108043 +63.10000000000063 241.1019902784809 241.1019902784809 -277037037.7050898 +63.20000000000063 241.0697351898017 241.0697351898017 -278022764.1417252 +63.30000000000063 241.0373435897335 241.0373435897335 -279013357.0422156 +63.40000000000063 241.0048223097309 241.0048223097309 -280008832.5547757 +63.50000000000063 240.9721682606546 240.9721682606546 -281009206.8543257 +63.60000000000063 240.9393744335802 -240.9393744335802 -282014496.1424882 +63.70000000000064 240.906448551427 -240.906448551427 -283024716.6475863 +63.80000000000064 240.8733848745442 240.8733848745442 -284039884.6246393 +63.90000000000064 240.8401856736382 240.8401856736382 -285060016.3553606 +64.00000000000064 240.8068489868122 240.8068489868122 -286085128.1481541 +64.10000000000063 240.7733768405628 -240.7733768405628 -287115236.3381121 +64.20000000000063 240.7397636996192 -240.7397636996192 -288150357.2870114 +64.30000000000062 240.7060189086872 240.7060189086872 -289190507.383311 +64.40000000000062 240.6721367464942 -240.6721367464942 -290235703.0421484 +64.50000000000061 240.6381049023303 -240.6381049023303 -291285960.7053376 +64.60000000000061 240.6039453433327 -240.6039453433327 -292341296.8413653 +64.7000000000006 240.5696535481484 240.5696535481484 -293401727.945388 +64.80000000000059 240.5352178175433 240.5352178175433 -294467270.539229 +64.90000000000059 240.5006345809072 -240.5006345809072 -295537941.171376 +65.00000000000058 240.4659211827666 240.4659211827666 -296613756.4169772 +65.10000000000058 240.4310736523303 -240.4310736523303 -297694732.8778387 +65.20000000000057 240.3960823852497 240.3960823852497 -298780887.1824219 +65.30000000000057 240.3609471301027 -240.3609471301027 -299872235.9858398 +65.40000000000056 240.325671943933 -240.325671943933 -300968795.9698541 +65.50000000000055 240.2902620030791 240.2902620030791 -302070583.8428722 +65.60000000000055 240.2547021792702 -240.2547021792702 -303177616.3399442 +65.70000000000054 240.2190117464942 -240.2190117464942 -304289910.2227609 +65.80000000000054 240.1831789387734 240.1831789387734 -305407482.2796482 +65.90000000000053 240.1472050187857 240.1472050187857 -306530349.3255665 +66.00000000000053 240.1110861820218 240.1110861820218 -307658528.2021065 +66.10000000000052 240.074826851032 -240.074826851032 -308792035.7774862 +66.20000000000051 240.0384305222302 -240.0384305222302 -309930888.9465482 +66.30000000000051 240.0018924655628 -240.0018924655628 -311075104.6307559 +66.4000000000005 239.9651981828482 239.9651981828482 -312224699.7781927 +66.5000000000005 239.9283735191179 -239.9283735191179 -313379691.3635538 +66.60000000000049 239.8914008007678 -239.8914008007678 -314540096.3881491 +66.70000000000049 239.8542914257678 -239.8542914257678 -315705931.8798963 +66.80000000000048 239.8170342074317 -239.8170342074317 -316877214.8933191 +66.90000000000047 239.7796348745442 239.7796348745442 -318053962.5095435 +67.00000000000047 239.7420896590322 -239.7420896590322 -319236191.8362952 +67.10000000000046 239.7044071140003 -239.7044071140003 -320423920.0078964 +67.20000000000046 239.6665653171253 -239.6665653171253 -321617164.1852621 +67.30000000000045 239.6286014499378 -239.6286014499378 -322815941.5558972 +67.40000000000045 239.5904717074317 -239.5904717074317 -324020269.3338947 +67.50000000000044 239.5522103149372 239.5522103149372 -325230164.7599292 +67.60000000000043 239.5137961429593 239.5137961429593 -326445645.1012573 +67.70000000000043 239.4752373324317 -239.4752373324317 -327666727.6517123 +67.80000000000042 239.4365410433692 -239.4365410433692 -328893429.7317015 +67.90000000000042 239.3976838780791 239.3976838780791 -330125768.6882035 +68.00000000000041 239.3586859570178 -239.3586859570178 -331363761.8947635 +68.10000000000041 239.3195518667317 239.3195518667317 -332607426.7514932 +68.2000000000004 239.2802650655606 239.2802650655606 -333856780.6850626 +68.3000000000004 239.2408330767455 -239.2408330767455 -335111841.1487015 +68.40000000000039 239.2012453450234 239.2012453450234 -336372625.6221936 +68.50000000000038 239.1615232527822 -239.1615232527822 -337639151.6118741 +68.60000000000038 239.1216435987932 239.1216435987932 -338911436.6506262 +68.70000000000037 239.0816164387734 239.0816164387734 -340189498.2978774 +68.80000000000037 239.0414453433328 -239.0414453433328 -341473354.1395977 +68.90000000000036 239.0011316741767 239.0011316741767 -342763021.7882939 +69.00000000000036 238.9606596551357 238.9606596551357 -344058518.8830081 +69.10000000000035 238.9200442372171 238.9200442372171 -345359863.0893137 +69.20000000000034 238.8792746585843 238.8792746585843 -346667072.0993123 +69.30000000000034 238.8383576983333 -238.8383576983333 -347980163.6316298 +69.40000000000033 238.7973026218128 -238.7973026218128 -349299155.4314134 +69.50000000000033 238.7560818894175 -238.7560818894175 -350624065.2703289 +69.60000000000032 238.7147156104908 -238.7147156104908 -351954910.946555 +69.70000000000032 238.6732061236205 -238.6732061236205 -353291710.2847825 +69.80000000000031 238.6315332339578 -238.6315332339578 -354634481.1362098 +69.9000000000003 238.589719429157 -238.589719429157 -355983241.3785387 +70.0000000000003 238.5477537215323 -238.5477537215323 -357338008.9159722 +70.10000000000029 238.5056328402442 -238.5056328402442 -358698801.6792099 +70.20000000000029 238.4633671281608 238.4633671281608 -360065637.6254457 +70.30000000000028 238.4209418163929 -238.4209418163929 -361438534.7383628 +70.40000000000028 238.3783723795521 -238.3783723795521 -362817511.0281318 +70.50000000000027 238.3356477701772 -238.3356477701772 -364202584.5314056 +70.60000000000026 238.2927679882679 -238.2927679882679 -365593773.3113168 +70.70000000000026 238.249744209558 -238.249744209558 -366991095.4574744 +70.80000000000025 238.2065605746192 -238.2065605746192 -368394569.0859583 +70.90000000000025 238.1632256136817 -238.1632256136817 -369804212.3393188 +71.00000000000024 238.1197391984733 238.1197391984733 -371220043.38657 +71.10000000000024 238.0760931835804 -238.0760931835804 -372642080.4231877 +71.20000000000023 238.0323000325234 238.0323000325234 -374070341.671106 +71.30000000000022 237.9883577311147 -237.9883577311147 -375504845.3787123 +71.40000000000022 237.9442511317254 -237.9442511317254 -376945609.8208443 +71.50000000000021 237.8999962026692 237.8999962026692 -378392653.2987868 +71.60000000000021 237.8555854375352 237.8555854375352 -379845994.1402672 +71.7000000000002 237.8110233781608 237.8110233781608 -381305650.6994522 +71.8000000000002 237.7662969191057 237.7662969191057 -382771641.356944 +71.90000000000019 237.7214237687858 237.7214237687858 -384243984.5197758 +72.00000000000018 237.676389351032 -237.676389351032 -385722698.6214092 +72.10000000000018 237.63120395973 -237.63120395973 -387207802.1217293 +72.20000000000017 237.5858588085804 -237.5858588085804 -388699313.5070415 +72.30000000000017 237.5403596842397 -237.5403596842397 -390197251.2900673 +72.40000000000016 237.4947053873647 -237.4947053873647 -391701634.0099405 +72.50000000000016 237.4488898036004 -237.4488898036004 -393212480.2322037 +72.60000000000015 237.4029258901692 237.4029258901692 -394729808.5488032 +72.70000000000014 237.3567997453483 237.3567997453483 -396253637.5780864 +72.80000000000014 237.3105186636067 237.3105186636067 -397783985.9647971 +72.90000000000013 237.2640711273017 237.2640711273017 -399320872.3800719 +73.00000000000013 237.2174806965859 237.2174806965859 -400864315.5214351 +73.10000000000012 237.1707178042704 -237.1707178042704 -402414334.1127969 +73.20000000000012 237.1238080894305 -237.1238080894305 -403970946.9044462 +73.30000000000011 237.0767366373647 -237.0767366373647 -405534172.67305 +73.40000000000011 237.0295052368122 237.0295052368122 -407104030.2216462 +73.5000000000001 236.9821170749378 -236.9821170749378 -408680538.3796411 +73.60000000000009 236.9345619405606 236.9345619405606 -410263716.0028057 +73.70000000000009 236.8868584261817 -236.8868584261817 -411853581.9732696 +73.80000000000008 236.8389914554593 236.8389914554593 -413450155.1995189 +73.90000000000008 236.790966326125 -236.790966326125 -415053454.6163905 +74.00000000000007 236.7427766515166 236.7427766515166 -416663499.1850686 +74.10000000000007 236.6944297964192 236.6944297964192 -418280307.8930802 +74.20000000000006 236.6459174023304 -236.6459174023304 -419903899.7542903 +74.30000000000005 236.5972569485066 -236.5972569485066 -421534293.8088998 +74.40000000000005 236.548428883833 236.548428883833 -423171509.1234365 +74.50000000000004 236.4994330273305 -236.4994330273305 -424815564.7907557 +74.60000000000004 236.4502891714192 236.4502891714192 -426466479.9300343 +74.70000000000003 236.4009766892631 236.4009766892631 -428124273.6867635 +74.80000000000003 236.3515019972306 236.3515019972306 -429788965.232748 +74.90000000000002 236.3018715108731 236.3018715108731 -431460573.7661004 +75.00000000000001 236.2520698125352 236.2520698125352 -433139118.5112355 +75.10000000000001 236.2021147332607 236.2021147332607 -434824618.7188674 +75.2 236.1519951449317 -236.1519951449317 -436517093.6660037 +75.3 236.1017087996573 -236.1017087996573 -438216562.6559417 +75.39999999999999 236.0512641484727 236.0512641484727 -439923045.0182635 +75.49999999999999 236.0006537304555 -236.0006537304555 -441636560.1088303 +75.59999999999998 235.9498724804555 -235.9498724804555 -443357127.3097799 +75.69999999999997 235.8989433871192 -235.8989433871192 -445084766.0295209 +75.79999999999997 235.847841827708 -235.847841827708 -446819495.7027262 +75.89999999999996 235.7965822590859 235.7965822590859 -448561335.7903315 +75.99999999999996 235.7451502288642 235.7451502288642 -450310305.7795275 +76.09999999999995 235.6935549153359 235.6935549153359 -452066425.1837573 +76.19999999999995 235.6417971028359 235.6417971028359 -453829713.5427101 +76.29999999999994 235.5898797731668 -235.5898797731668 -455600190.4223174 +76.39999999999993 235.5377931965859 235.5377931965859 -457377875.414746 +76.49999999999993 235.4855471028359 235.4855471028359 -459162788.1383957 +76.59999999999992 235.4331296980948 -235.4331296980948 -460954948.2378925 +76.69999999999992 235.3805547316055 235.3805547316055 -462754375.3840839 +76.79999999999991 235.3277948122292 -235.3277948122292 -464561089.2740356 +76.89999999999991 235.2748807175424 -235.2748807175424 -466375109.631022 +76.9999999999999 235.2218039554593 235.2218039554593 -468196456.2045258 +77.09999999999989 235.1685579015166 235.1685579015166 -470025148.7702302 +77.19999999999989 235.1151453460517 235.1151453460517 -471861207.1300143 +77.29999999999988 235.0615668163931 -235.0615668163931 -473704651.111948 +77.39999999999988 235.0078146976468 235.0078146976468 -475555500.5702867 +77.49999999999987 234.9539008007681 -234.9539008007681 -477413775.3854656 +77.59999999999987 234.8998236523306 -234.8998236523306 -479279495.4640949 +77.69999999999986 234.8455756719102 234.8455756719102 -481152680.7389536 +77.79999999999986 234.7911619246573 -234.7911619246573 -483033351.1689844 +77.89999999999985 234.7365741146542 -234.7365741146542 -484921526.739289 +77.99999999999984 234.681826202708 -234.681826202708 -486817227.4611223 +78.09999999999984 234.6269045247109 234.6269045247109 -488720473.3718847 +78.19999999999983 234.5718207226431 -234.5718207226431 -490631284.5351197 +78.29999999999983 234.5165657836872 234.5165657836872 -492549681.0405067 +78.39999999999982 234.4611330403359 234.4611330403359 -494475683.003855 +78.49999999999982 234.4055418074699 -234.4055418074699 -496409310.5670991 +78.59999999999981 234.3497748242056 -234.3497748242056 -498350583.8982917 +78.6999999999998 234.2938408480567 -234.2938408480567 -500299523.1915994 +78.7999999999998 234.237743669875 -234.237743669875 -502256148.6672949 +78.89999999999979 234.1814699543984 234.1814699543984 -504220480.571754 +78.99999999999979 234.1250242293449 -234.1250242293449 -506192539.1774458 +79.09999999999978 234.068420942543 234.068420942543 -508172344.7829298 +79.19999999999978 234.0116297210517 234.0116297210517 -510159917.7128504 +79.29999999999977 233.9546761352497 233.9546761352497 -512155278.3179269 +79.39999999999976 233.8975547964192 233.8975547964192 -514158446.9749511 +79.49999999999976 233.8402533398306 -233.8402533398306 -516169444.0867802 +79.59999999999975 233.7827913248647 -233.7827913248647 -518188290.0823295 +79.69999999999975 233.725159223793 233.725159223793 -520215005.4165674 +79.79999999999974 233.6673371983916 233.6673371983916 -522249610.5705099 +79.89999999999974 233.6093632219109 233.6093632219109 -524292126.0512107 +79.99999999999973 233.5512109683331 -233.5512109683331 -526342572.3917592 +80.09999999999972 233.4928862176357 233.4928862176357 -528400970.1512706 +80.19999999999972 233.4343875827503 -233.4343875827503 -530467339.9148821 +80.29999999999971 233.375720772058 -233.375720772058 -532541702.2937447 +80.39999999999971 233.316882881433 -233.316882881433 -534624077.9250171 +80.4999999999997 233.2578739108753 -233.2578739108753 -536714487.4718585 +80.5999999999997 233.1986848795522 -233.1986848795522 -538812951.6234245 +80.69999999999969 233.1393182497288 -233.1393182497288 -540919491.0948557 +80.79999999999968 233.0797883951772 -233.0797883951772 -543034126.6272755 +80.89999999999968 233.0200830386456 -233.0200830386456 -545156878.9877803 +80.99999999999967 232.9601996953477 232.9601996953477 -547287768.969435 +81.09999999999967 232.9001467762796 232.9001467762796 -549426817.3912632 +81.19999999999966 232.8399300414997 232.8399300414997 -551574045.098243 +81.29999999999966 232.7795198077087 -232.7795198077087 -553729472.9612991 +81.39999999999965 232.7189455403359 232.7189455403359 -555893121.8772935 +81.49999999999964 232.6582034169046 232.6582034169046 -558065012.7690221 +81.59999999999964 232.5972782609734 232.5972782609734 -560245166.5852051 +81.69999999999963 232.5361761913932 -232.5361761913932 -562433604.3004797 +81.79999999999963 232.4749149265003 -232.4749149265003 -564630346.9153938 +81.89999999999962 232.4134543460843 232.4134543460843 -566835415.4563997 +81.99999999999962 232.3518396819892 232.3518396819892 -569048830.9758426 +82.09999999999961 232.2900368119695 -232.2900368119695 -571270614.5519575 +82.1999999999996 232.2280646082879 -232.2280646082879 -573500787.288859 +82.2999999999996 232.1659177840324 -232.1659177840324 -575739370.316535 +82.39999999999959 232.1035921061147 -232.1035921061147 -577986384.7908387 +82.49999999999959 232.0410883964375 -232.0410883964375 -580241851.893481 +82.59999999999958 231.9784177840324 -231.9784177840324 -582505792.8320223 +82.69999999999958 231.9155603851142 231.9155603851142 -584778228.8398649 +82.79999999999957 231.8525368119695 -231.8525368119695 -587059181.176245 +82.89999999999957 231.7893308699699 -231.7893308699699 -589348671.1262252 +82.99999999999956 231.725949897907 -231.725949897907 -591646720.0006866 +83.09999999999955 231.6623895387909 -231.6623895387909 -593953349.1363192 +83.19999999999955 231.5986570418449 -231.5986570418449 -596268579.8956156 +83.29999999999954 231.5347407401875 -231.5347407401875 -598592433.6668617 +83.39999999999954 231.4706575358022 -231.4706575358022 -600924931.8641291 +83.49999999999953 231.4063896761817 -231.4063896761817 -603266095.9272665 +83.59999999999953 231.3419477378682 -231.3419477378682 -605615947.3218906 +83.69999999999952 231.2773225499541 231.2773225499541 -607974507.5393788 +83.79999999999951 231.212522163532 -231.212522163532 -610341798.0968602 +83.89999999999951 231.1475493035732 231.1475493035732 -612717840.5372064 +83.9999999999995 231.0823977528421 231.0823977528421 -615102656.429024 +84.0999999999995 231.0170616323567 231.0170616323567 -617496267.3666446 +84.19999999999949 230.9515556918067 -230.9515556918067 -619898694.9701173 +84.29999999999949 230.8858661068417 -230.8858661068417 -622309960.8851988 +84.39999999999948 230.8200078566053 230.8200078566053 -624730086.783344 +84.49999999999947 230.7539496288933 -230.7539496288933 -627159094.3617002 +84.59999999999947 230.687732362536 230.687732362536 -629597005.343093 +84.69999999999946 230.6213279647335 230.6213279647335 -632043841.4760205 +84.79999999999946 230.5547489108753 -230.5547489108753 -634499624.5346437 +84.89999999999945 230.4879885090859 230.4879885090859 -636964376.3187768 +84.99999999999945 230.4210493003682 -230.4210493003682 -639438118.6538777 +85.09999999999944 230.3539252148308 -230.3539252148308 -641920873.3910382 +85.19999999999943 230.2866386996192 -230.2866386996192 -644412662.406976 +85.29999999999943 230.2191522341031 -230.2191522341031 -646913507.6040233 +85.39999999999942 230.1514914554593 230.1514914554593 -649423430.9101173 +85.49999999999942 230.0836615429558 -230.0836615429558 -651942454.2787926 +85.59999999999941 230.0156426058692 -230.0156426058692 -654470599.689168 +85.69999999999941 229.9474512027083 -229.9474512027083 -657007889.1459397 +85.7999999999994 229.8790716992058 -229.8790716992058 -659554344.6793691 +85.89999999999939 229.8105186636067 229.8105186636067 -662109988.3452742 +85.99999999999939 229.7417875848232 229.7417875848232 -664674842.225019 +86.09999999999938 229.6728691683692 -229.6728691683692 -667248928.4255017 +86.19999999999938 229.6037773714942 -229.6037773714942 -669832269.0791473 +86.29999999999937 229.5344972981484 229.5344972981484 -672424886.3438954 +86.39999999999937 229.4650517016873 -229.4650517016873 -675026802.4031897 +86.49999999999936 229.3954099715325 -229.3954099715325 -677638039.4659679 +86.59999999999935 229.3255945648017 229.3255945648017 -680258619.7666507 +86.69999999999935 229.2555940264589 -229.2555940264589 -682888565.5651318 +86.79999999999934 229.1854194219102 229.1854194219102 -685527899.1467662 +86.89999999999934 229.1150537417709 -229.1150537417709 -688176642.8223593 +86.99999999999933 229.0445225735066 -229.0445225735066 -690834818.9281576 +87.09999999999933 228.9737982617059 -228.9737982617059 -693502449.8258348 +87.19999999999932 228.9028955386459 -228.9028955386459 -696179557.9024826 +87.29999999999932 228.8318201507392 228.8318201507392 -698866165.5705999 +87.39999999999931 228.7605596144177 228.7605596144177 -701562295.2680793 +87.4999999999993 228.6891111434075 -228.6891111434075 -704267969.4581981 +87.5999999999993 228.6174750195185 -228.6174750195185 -706983210.6296041 +87.69999999999929 228.5456785262201 -228.5456785262201 -709708041.2963076 +87.79999999999929 228.4736942233753 -228.4736942233753 -712442483.9976649 +87.89999999999928 228.4015180503682 -228.4015180503682 -715186561.2983718 +87.99999999999928 228.3291629733753 -228.3291629733753 -717940295.7884469 +88.09999999999927 228.2566351757685 -228.2566351757685 -720703710.0832233 +88.19999999999926 228.1839237719998 -228.1839237719998 -723476826.8233352 +88.29999999999926 228.1110254214584 -228.1110254214584 -726259668.6747035 +88.39999999999925 228.0379554952481 228.0379554952481 -729052258.3285279 +88.49999999999925 227.9646934682942 227.9646934682942 -731854618.5012709 +88.59999999999924 227.8912529574317 -227.8912529574317 -734666771.9346467 +88.69999999999924 227.8176291507718 227.8176291507718 -737488741.395609 +88.79999999999923 227.7438359816051 227.7438359816051 -740320549.6763382 +88.89999999999922 227.669843183581 -227.669843183581 -743162219.5942268 +88.99999999999922 227.5956814987919 -227.5956814987919 -746013773.9918699 +89.09999999999921 227.5213340932942 227.5213340932942 -748875235.7370491 +89.19999999999921 227.4468061363058 -227.4468061363058 -751746627.7227211 +89.2999999999992 227.3721033538642 227.3721033538642 -754627972.8670038 +89.3999999999992 227.2972050219998 -227.2972050219998 -757519294.1131644 +89.49999999999919 227.2221321899372 227.2221321899372 -760420614.4296037 +89.59999999999918 227.1468748152826 -227.1468748152826 -763331956.8098441 +89.69999999999918 227.0714399253683 -227.0714399253683 -766253344.2725172 +89.79999999999917 226.9958187099093 226.9958187099093 -769184799.8613465 +89.89999999999917 226.9200157339192 226.9200157339192 -772126346.6451372 +89.99999999999916 226.8440375195185 -226.8440375195185 -775078007.7177601 +90.09999999999916 226.7678656445185 -226.7678656445185 -778039806.1981385 +90.19999999999915 226.6915301693416 -226.6915301693416 -781011765.2302351 +90.29999999999914 226.6149924320218 226.6149924320218 -783993907.9830345 +90.39999999999914 226.5382844889273 -226.5382844889273 -786986257.6505318 +90.49999999999913 226.4613975698567 226.4613975698567 -789988837.4517171 +90.59999999999913 226.3843207226436 -226.3843207226436 -793001670.6305612 +90.69999999999912 226.3070833170523 -226.3070833170523 -796024780.456001 +90.79999999999912 226.2296384871576 -226.2296384871576 -799058190.2219239 +90.89999999999911 226.1520209179561 -226.1520209179561 -802101923.2471527 +90.9999999999991 226.0742209476468 226.0742209476468 -805156002.8754324 +91.0999999999991 225.9962488616767 225.9962488616767 -808220452.4754138 +91.19999999999909 225.9180911122171 225.9180911122171 -811295295.4406376 +91.29999999999909 225.8397504722433 -225.8397504722433 -814380555.1895196 +91.39999999999908 225.7612250859727 225.7612250859727 -817476255.1653361 +91.49999999999908 225.6825193465324 -225.6825193465324 -820582418.8362062 +91.59999999999907 225.6036398929593 225.6036398929593 -823699069.6950799 +91.69999999999906 225.5245733973504 -225.5245733973504 -826826231.2597156 +91.79999999999906 225.4453301058692 -225.4453301058692 -829963927.0726719 +91.89999999999905 225.3659061374378 -225.3659061374378 -833112180.7012854 +91.99999999999905 225.2862982617061 -225.2862982617061 -836271015.737657 +92.09999999999904 225.2065147573567 225.2065147573567 -839440455.7986366 +92.19999999999904 225.1265413248648 -225.1265413248648 -842620524.5258033 +92.29999999999903 225.0464043246192 -225.0464043246192 -845811245.585453 +92.39999999999903 224.9660666507718 224.9660666507718 -849012642.6685784 +92.49999999999902 224.8855594577503 -224.8855594577503 -852224739.4908514 +92.59999999999901 224.8048709811878 -224.8048709811878 -855447559.7926102 +92.69999999999901 224.7240012210843 224.7240012210843 -858681127.3388395 +92.799999999999 224.6429619418067 -224.6429619418067 -861925465.9191525 +92.899999999999 224.5617317993122 224.5617317993122 -865180599.3477759 +92.99999999999899 224.4803223923877 224.4803223923877 -868446551.4635297 +93.09999999999899 224.3987250195187 -224.3987250195187 -871723346.1298115 +93.19999999999898 224.3169673026875 -224.3169673026875 -875011007.2345791 +93.29999999999897 224.2350213747267 -224.2350213747267 -878309558.6903296 +93.39999999999897 224.1528934421253 -224.1528934421253 -881619024.4340844 +93.49999999999896 224.0705926637892 -224.0705926637892 -884939428.4273703 +93.59999999999896 223.9881105793984 223.9881105793984 -888270794.6562006 +93.69999999999895 223.9054569186878 -223.9054569186878 -891613147.1310569 +93.79999999999895 223.8226102097292 -223.8226102097292 -894966509.8868701 +93.89999999999894 223.7395958120442 223.7395958120442 -898330906.9830024 +93.99999999999893 223.6564051116767 223.6564051116767 -901706362.5032282 +94.09999999999893 223.5730310882392 223.5730310882392 -905092900.5557152 +94.19999999999892 223.4894807452092 -223.4894807452092 -908490545.2730043 +94.29999999999892 223.4057594682195 -223.4057594682195 -911899320.8119913 +94.39999999999891 223.3218508137734 223.3218508137734 -915319251.3539078 +94.49999999999891 223.2377717608342 -223.2377717608342 -918750361.1043012 +94.5999999999989 223.15351515425 -223.15351515425 -922192674.293014 +94.69999999999889 223.069080147058 -223.069080147058 -925646215.1741652 +94.79999999999889 222.9844688589192 222.9844688589192 -929111008.0261296 +94.89999999999888 222.8996758089942 -222.8996758089942 -932587077.1515192 +94.99999999999888 222.8147214949702 -222.8147214949702 -936074446.8771602 +95.09999999999887 222.7295805535732 222.7295805535732 -939573141.5540754 +95.19999999999887 222.6442588979817 222.6442588979817 -943083185.557461 +95.29999999999886 222.5587772311878 -222.5587772311878 -946604603.2866681 +95.39999999999885 222.4731108270107 222.4731108270107 -950137419.1651804 +95.49999999999885 222.3872705386462 -222.3872705386462 -953681657.640595 +95.59999999999884 222.3012634620533 -222.3012634620533 -957237343.1845978 +95.69999999999884 222.2150662644166 -222.2150662644166 -960804500.2929463 +95.79999999999883 222.1287054882688 -222.1287054882688 -964383153.4854443 +95.89999999999883 222.0421758253548 222.0421758253548 -967973327.3059239 +95.99999999999882 221.9554685652827 -221.9554685652827 -971575046.3222215 +96.09999999999881 221.8685937808337 -221.8685937808337 -975188335.1261551 +96.19999999999881 221.7815271819892 221.7815271819892 -978813218.3335071 +96.2999999999988 221.6943029072705 221.6943029072705 -982449720.5839939 +96.3999999999988 221.6068998895107 221.6068998895107 -986097866.5412511 +96.49999999999879 221.5193304882688 -221.5193304882688 -989757680.8928065 +96.59999999999879 221.4315920247109 221.4315920247109 -993429188.3500608 +96.69999999999878 221.3436713085813 -221.3436713085813 -997112413.6482617 +96.79999999999878 221.2555940264593 -221.2555940264593 -1000807381.546483 +96.89999999999877 221.1673367722291 -221.1673367722291 -1004514116.827598 +96.99999999999876 221.0789188327503 -221.0789188327503 -1008232644.298263 +97.09999999999876 220.9903227410732 220.9903227410732 -1011962988.788886 +97.19999999999875 220.9015508253547 220.9015508253547 -1015705175.153609 +97.29999999999875 220.8126239193415 -220.8126239193415 -1019459228.270282 +97.39999999999874 220.7235283480567 -220.7235283480567 -1023225173.040438 +97.49999999999874 220.6342561437041 220.6342561437041 -1027003034.389272 +97.59999999999873 220.5448174105567 -220.5448174105567 -1030792837.265611 +97.69999999999872 220.4552178011817 -220.4552178011817 -1034594606.641898 +97.79999999999872 220.3654454853955 220.3654454853955 -1038408367.51416 +97.89999999999871 220.275502769421 220.275502769421 -1042234144.901988 +97.99999999999871 220.1853965932942 220.1853965932942 -1046071963.848509 +98.0999999999987 220.0951300379754 -220.0951300379754 -1049921849.420364 +98.1999999999987 220.0047002394172 220.0047002394172 -1053783826.707678 +98.29999999999869 219.9140955413642 219.9140955413642 -1057657920.824043 +98.39999999999868 219.8233284789997 219.8233284789997 -1061544156.906483 +98.49999999999868 219.7324006670844 -219.7324006670844 -1065442560.115434 +98.59999999999867 219.6413118326774 -219.6413118326774 -1069353155.634717 +98.69999999999867 219.5500510257718 219.5500510257718 -1073275968.671513 +98.79999999999866 219.4586357699317 -219.4586357699317 -1077211024.456336 +98.89999999999866 219.3670570577481 219.3670570577481 -1081158348.243005 +98.99999999999865 219.2753119335815 -219.2753119335815 -1085117965.308618 +99.09999999999864 219.1834110202503 -219.1834110202503 -1089089900.953531 +99.19999999999864 219.091351972644 -219.091351972644 -1093074180.501324 +99.29999999999863 218.9991338579955 -218.9991338579955 -1097070829.298776 +99.39999999999863 218.9067385731546 218.9067385731546 -1101079872.715841 +99.49999999999862 218.8142036015977 218.8142036015977 -1105101336.145618 +99.59999999999862 218.7215083183125 -218.7215083183125 -1109135245.004323 +99.69999999999861 218.6286537374356 218.6286537374356 -1113181624.731264 +99.7999999999986 218.5356327531613 218.5356327531613 -1117240500.788812 +99.8999999999986 218.4424691039997 218.4424691039997 -1121311898.662372 +99.99999999999859 218.3491386996192 -218.3491386996192 -1125395843.860357 +100.0999999999986 218.2556512575379 -218.2556512575379 -1129492361.91416 +100.1999999999986 218.1620203460517 218.1620203460517 -1133601478.378122 +100.2999999999986 218.0682256548705 -218.0682256548705 -1137723218.829508 +100.3999999999986 217.9742804286004 -217.9742804286004 -1141857608.868476 +100.4999999999986 217.8801883640003 -217.8801883640003 -1146004674.118049 +100.5999999999986 217.785932050769 -217.785932050769 -1150164440.224086 +100.6999999999986 217.6915286122171 217.6915286122171 -1154336932.85525 +100.7999999999985 217.5969852390003 -217.5969852390003 -1158522177.702986 +100.8999999999985 217.5022737467399 -217.5022737467399 -1162720200.481484 +100.9999999999985 217.4074100436878 -217.4074100436878 -1166931026.927652 +101.0999999999985 217.3124151942254 -217.3124151942254 -1171154682.801089 +101.1999999999985 217.2172635300414 -217.2172635300414 -1175391193.884051 +101.2999999999985 217.1219658480567 -217.1219658480567 -1179640585.981423 +101.3999999999985 217.0265222991767 217.0265222991767 -1183902884.920691 +101.4999999999985 216.9309369956811 -216.9309369956811 -1188178116.551905 +101.5999999999985 216.835193428308 -216.835193428308 -1192466306.747658 +101.6999999999985 216.7393192233753 -216.7393192233753 -1196767481.403046 +101.7999999999985 216.6432889206663 -216.6432889206663 -1201081666.435644 +101.8999999999985 216.5471194325296 216.5471194325296 -1205408887.785473 +101.9999999999985 216.4444297964192 216.4444297964192 -1209749180.928628 +102.0999999999985 216.3409066039997 216.3409066039997 -1214102585.250279 +102.1999999999985 216.2371219577503 -216.2371219577503 -1218469127.215793 +102.2999999999985 216.1330808699704 -216.1330808699704 -1222848833.259724 +102.3999999999985 216.0287803823567 216.0287803823567 -1227241729.843273 +102.4999999999985 215.9242231284936 -215.9242231284936 -1231647843.454283 +102.5999999999984 215.8194094075234 215.8194094075234 -1236067200.607248 +102.6999999999984 215.7143338425412 -215.7143338425412 -1240499827.843306 +102.7999999999984 215.609006538532 -215.609006538532 -1244945751.730246 +102.8999999999984 215.5034095968106 215.5034095968106 -1249404998.862503 +102.9999999999984 215.3975547964192 215.3975547964192 -1253877595.861165 +103.0999999999984 215.2914432468128 -215.2914432468128 -1258363569.37397 +103.1999999999984 215.1850761996192 -215.1850761996192 -1262862946.075306 +103.2999999999984 215.0784305515003 -215.0784305515003 -1267375752.666215 +103.3999999999984 214.9715333298874 214.9715333298874 -1271902015.874393 +103.4999999999984 214.8643715108731 214.8643715108731 -1276441762.454187 +103.5999999999984 214.756946229724 214.756946229724 -1280995019.186604 +103.6999999999984 214.6492562133747 214.6492562133747 -1285561812.879302 +103.7999999999984 214.5412928069892 214.5412928069892 -1290142170.366602 +103.8999999999984 214.4330717645107 214.4330717645107 -1294736118.509477 +103.9999999999984 214.3245868099664 -214.3245868099664 -1299343684.195564 +104.0999999999984 214.2158379183692 -214.2158379183692 -1303964894.339155 +104.1999999999984 214.1068133724664 -214.1068133724664 -1308599775.881209 +104.2999999999983 213.9975228149372 213.9975228149372 -1313248355.78934 +104.3999999999983 213.8879682456811 -213.8879682456811 -1317910661.05783 +104.4999999999983 213.7781375827503 -213.7781375827503 -1322586718.707624 +104.5999999999983 213.6680415214375 -213.6680415214375 -1327276555.78633 +104.6999999999983 213.5576605663943 -213.5576605663943 -1331980199.368224 +104.7999999999983 213.4470217762796 213.4470217762796 -1336697676.554249 +104.8999999999983 213.3361209811878 -213.3361209811878 -1341429014.472013 +104.9999999999983 213.2249262870625 -213.2249262870625 -1346174240.275798 +105.0999999999983 213.1134668277093 -213.1134668277093 -1350933381.146552 +105.1999999999983 213.0017420257392 213.0017420257392 -1355706464.291898 +105.2999999999983 212.8897422964192 212.8897422964192 -1360493516.946129 +105.3999999999983 212.7774676693414 -212.7774676693414 -1365294566.370211 +105.4999999999983 212.664905214099 212.664905214099 -1370109639.851786 +105.5999999999983 212.5520878344996 -212.5520878344996 -1374938764.705174 +105.6999999999983 212.4389666927789 -212.4389666927789 -1379781968.271367 +105.7999999999983 212.3255945648017 212.3255945648017 -1384639277.91804 +105.8999999999983 212.2119316683692 -212.2119316683692 -1389510721.039543 +105.9999999999983 212.0979887566982 212.0979887566982 -1394396325.056911 +106.0999999999982 211.9837585792408 -211.9837585792408 -1399296117.417857 +106.1999999999982 211.8692645443414 -211.8692645443414 -1404210125.596778 +106.2999999999982 211.754483571333 211.754483571333 -1409138377.094757 +106.3999999999982 211.6394285262205 -211.6394285262205 -1414080899.439559 +106.4999999999982 211.5240808929267 211.5240808929267 -1419037720.185638 +106.5999999999982 211.4084648714942 -211.4084648714942 -1424008866.914134 +106.6999999999982 211.2925532401875 -211.2925532401875 -1428994367.23288 +106.7999999999982 211.1763607020968 211.1763607020968 -1433994248.776394 +106.8999999999982 211.0598760206666 211.0598760206666 -1439008539.205891 +106.9999999999982 210.9431174320218 210.9431174320218 -1444037266.209273 +107.0999999999982 210.826074034033 -210.826074034033 -1449080457.501141 +107.1999999999982 210.7087348515977 210.7087348515977 -1454138140.822791 +107.2999999999982 210.5911078320195 -210.5911078320195 -1459210343.942214 +107.3999999999982 210.4732080386469 -210.4732080386469 -1464297094.6541 +107.4999999999982 210.3550046980956 -210.3550046980956 -1469398420.77984 +107.5999999999982 210.2365116061878 -210.2365116061878 -1474514350.167524 +107.6999999999982 210.1177371921253 -210.1177371921253 -1479644910.691945 +107.7999999999981 209.9986748324317 -209.9986748324317 -1484790130.2546 +107.8999999999981 209.8793084840984 -209.8793084840984 -1489950036.783691 +107.9999999999981 209.7596611605567 -209.7596611605567 -1495124658.234127 +108.0999999999981 209.6397119448969 -209.6397119448969 -1500314022.587524 +108.1999999999981 209.5194826497109 209.5194826497109 -1505518157.852208 +108.2999999999981 209.3989433871192 -209.3989433871192 -1510737092.063215 +108.3999999999981 209.2781092132392 209.2781092132392 -1515970853.282294 +108.4999999999981 209.1570000277442 -209.1570000277442 -1521219469.597908 +108.5999999999981 209.0355838718128 -209.0355838718128 -1526482969.125236 +108.6999999999981 208.9138617382695 -208.9138617382695 -1531761380.006171 +108.7999999999981 208.7918484909783 -208.7918484909783 -1537054730.409325 +108.8999999999981 208.6695472921231 208.6695472921231 -1542363048.530031 +108.9999999999981 208.546938507397 -208.546938507397 -1547686362.590344 +109.0999999999981 208.42402296675 -208.42402296675 -1553024700.839038 +109.1999999999981 208.3008142913642 208.3008142913642 -1558378091.551615 +109.2999999999981 208.1772833582879 -208.1772833582879 -1563746563.030303 +109.3999999999981 208.0534686459038 -208.0534686459038 -1569130143.604053 +109.4999999999981 207.929357312223 -207.929357312223 -1574528861.62855 +109.599999999998 207.8049293900945 -207.8049293900945 -1579942745.486204 +109.699999999998 207.6802088226142 207.6802088226142 -1585371823.586166 +109.799999999998 207.5551735307195 -207.5551735307195 -1590816124.364312 +109.899999999998 207.4298426116767 207.4298426116767 -1596275676.283257 +109.999999999998 207.3041969682195 -207.3041969682195 -1601750507.832354 +110.099999999998 207.1782468855956 -207.1782468855956 -1607240647.527694 +110.199999999998 207.0519807452101 -207.0519807452101 -1612746123.912105 +110.299999999998 206.9254153309671 206.9254153309671 -1618266965.555164 +110.399999999998 206.7985346855 -206.7985346855 -1623803201.053184 +110.499999999998 206.6713411295528 -206.6713411295528 -1629354859.029231 +110.599999999998 206.5438474715332 -206.5438474715332 -1634921968.133111 +110.699999999998 206.4160398543457 -206.4160398543457 -1640504557.041384 +110.799999999998 206.2879032077503 -206.2879032077503 -1646102654.457358 +110.899999999998 206.1594672070197 -206.1594672070197 -1651716289.111094 +110.999999999998 206.0307161295526 -206.0307161295526 -1657345489.759408 +111.099999999998 205.9016443694892 205.9016443694892 -1662990285.18587 +111.199999999998 205.7722498382392 205.7722498382392 -1668650704.200809 +111.299999999998 205.6425569249541 205.6425569249541 -1674326775.641313 +111.3999999999979 205.5125239433125 -205.5125239433125 -1680018528.371229 +111.4999999999979 205.3821873644777 -205.3821873644777 -1685725991.281173 +111.5999999999979 205.2515262546253 -205.2515262546253 -1691449193.28852 +111.6999999999979 205.1205449659788 205.1205449659788 -1697188163.337414 +111.7999999999979 204.9892494405606 204.9892494405606 -1702942930.398766 +111.8999999999979 204.8576204264276 -204.8576204264276 -1708713523.470261 +111.9999999999979 204.7256837205122 204.7256837205122 -1714499971.576354 +112.0999999999979 204.5934080184082 -204.5934080184082 -1720302303.768272 +112.1999999999979 204.4608100469102 204.4608100469102 -1726120549.124021 +112.2999999999979 204.3278984652442 -204.3278984652442 -1731954736.748388 +112.3999999999979 204.1946535481484 204.1946535481484 -1737804895.772932 +112.4999999999979 204.0610724207879 -204.0610724207879 -1743671055.355999 +112.5999999999979 203.9271674023323 -203.9271674023323 -1749553244.682719 +112.6999999999979 203.7929471237906 -203.7929471237906 -1755451492.965007 +112.7999999999979 203.6583866061878 -203.6583866061878 -1761365829.441566 +112.8999999999979 203.5234989108753 -203.5234989108753 -1767296283.377888 +112.9999999999979 203.388272633833 203.388272633833 -1773242884.066257 +113.0999999999978 203.2527097762207 -203.2527097762207 -1779205660.82575 +113.1999999999978 203.1168231380913 -203.1168231380913 -1785184643.002244 +113.2999999999978 202.9806084261817 -202.9806084261817 -1791179859.968407 +113.3999999999978 202.8440555515003 -202.8440555515003 -1797191341.123716 +113.4999999999978 202.7071449483731 202.7071449483731 -1803219115.894441 +113.5999999999978 202.5699180776692 202.5699180776692 -1809263213.73366 +113.6999999999978 202.4323448354817 202.4323448354817 -1815323664.12126 +113.7999999999978 202.2944313432195 -202.2944313432195 -1821400496.563931 +113.8999999999978 202.1561894972286 202.1561894972286 -1827493740.595178 +113.9999999999978 202.0176111663642 202.0176111663642 -1833603425.775316 +114.0999999999978 201.8786797152442 -201.8786797152442 -1839729581.691476 +114.1999999999978 201.7393974886817 -201.7393974886817 -1845872237.957605 +114.2999999999978 201.5997949527099 -201.5997949527099 -1852031424.214471 +114.3999999999978 201.4598272173705 -201.4598272173705 -1858207170.12966 +114.4999999999978 201.3195195753536 201.3195195753536 -1864399505.397586 +114.5999999999978 201.1788702723504 -201.1788702723504 -1870608459.739485 +114.6999999999978 201.0378594027442 -201.0378594027442 -1876834062.903422 +114.7999999999978 200.8965174163642 200.8965174163642 -1883076344.664294 +114.8999999999977 200.7548223097286 200.7548223097286 -1889335334.823831 +114.9999999999977 200.6127713425404 -200.6127713425404 -1895611063.210593 +115.0999999999977 200.4703699554267 200.4703699554267 -1901903559.679983 +115.1999999999977 200.3276124314496 200.3276124314496 -1908212854.114241 +115.2999999999977 200.1845098097285 200.1845098097285 -1914538976.422445 +115.3999999999977 200.0410486663642 200.0410486663642 -1920881956.540527 +115.4999999999977 199.8972410262209 -199.8972410262209 -1927241824.431257 +115.5999999999977 199.7530693636817 -199.7530693636817 -1933618610.084255 +115.6999999999977 199.6085381136817 -199.6085381136817 -1940012343.515996 +115.7999999999977 199.4636560882392 199.4636560882392 -1946423054.769806 +115.8999999999977 199.3184027538951 -199.3184027538951 -1952850773.915868 +115.9999999999977 199.1727910597285 199.1727910597285 -1959295531.051223 +116.0999999999977 199.0268223781941 -199.0268223781941 -1965757356.299774 +116.1999999999977 198.8804847921231 198.8804847921231 -1972236279.812287 +116.2999999999977 198.7337934409941 -198.7337934409941 -1978732331.766394 +116.3999999999977 198.5867464029899 -198.5867464029899 -1985245542.366595 +116.4999999999977 198.4393098467731 -198.4393098467731 -1991775941.844264 +116.5999999999976 198.2915215121192 -198.2915215121192 -1998323560.457644 +116.6999999999976 198.1433539257702 -198.1433539257702 -2004888428.491858 +116.7999999999976 197.9948274576773 -197.9948274576773 -2011470576.258906 +116.8999999999976 197.8459256394152 -197.8459256394152 -2018070034.097671 +116.9999999999976 197.6966571224662 -197.6966571224662 -2024686832.373916 +117.0999999999976 197.5470212996584 -197.5470212996584 -2031321001.480294 +117.1999999999976 197.3969902621192 -197.3969902621192 -2037972571.836349 +117.2999999999976 197.2465996371192 -197.2465996371192 -2044641573.888514 +117.3999999999976 197.0958428011817 -197.0958428011817 -2051328038.110113 +117.4999999999976 196.9446809405232 -196.9446809405232 -2058031995.001375 +117.5999999999976 196.7931673014273 -196.7931673014273 -2064753475.089426 +117.6999999999976 196.6412683929267 196.6412683929267 -2071492508.928291 +117.7999999999976 196.4889799676357 196.4889799676357 -2078249127.098905 +117.8999999999976 196.3363279402835 -196.3363279402835 -2085023360.20911 +117.9999999999976 196.1832635622204 -196.1832635622204 -2091815238.893658 +118.0999999999976 196.0298486636477 -196.0298486636477 -2098624793.814217 +118.1999999999976 195.8760125856577 -195.8760125856577 -2105452055.659369 +118.2999999999976 195.7218305503691 -195.7218305503691 -2112297055.144617 +118.3999999999975 195.5672391159776 -195.5672391159776 -2119159823.012387 +118.4999999999975 195.4122490511817 -195.4122490511817 -2126040390.032028 +118.5999999999975 195.2568973483753 -195.2568973483753 -2132938786.99982 +118.6999999999975 195.1011357862907 195.1011357862907 -2139855044.738973 +118.7999999999975 194.9449793304267 194.9449793304267 -2146789194.099628 +118.8999999999975 194.7884437764981 194.7884437764981 -2153741265.958869 +118.9999999999975 194.6314939559085 -194.6314939559085 -2160711291.220715 +119.0999999999975 194.4741644726454 -194.4741644726454 -2167699300.81613 +119.1999999999975 194.3164350425567 -194.3164350425567 -2174705325.703023 +119.2999999999975 194.1583168233731 194.1583168233731 -2181729396.866254 +119.3999999999975 193.9997734652442 -193.9997734652442 -2188771545.317633 +119.4999999999975 193.8408533538642 193.8408533538642 -2195831802.095927 +119.5999999999975 193.681516304157 -193.681516304157 -2202910198.266859 +119.6999999999975 193.5217718945204 -193.5217718945204 -2210006764.923115 +119.7999999999975 193.3616336765003 -193.3616336765003 -2217121533.184345 +119.8999999999975 193.2010828460517 193.2010828460517 -2224254534.197168 +119.9999999999975 193.0401368455118 193.0401368455118 -2231405799.135174 +120.0999999999975 192.8787725298705 -192.8787725298705 -2238575359.198923 +120.1999999999974 192.7169924153359 192.7169924153359 -2245763245.615957 +120.2999999999974 192.5548011983731 192.5548011983731 -2252969489.640799 +120.3999999999974 192.392209663532 -192.392209663532 -2260194122.554952 +120.4999999999974 192.229198748 -192.229198748 -2267437175.666908 +120.5999999999974 192.0657621941982 192.0657621941982 -2274698680.31215 +120.6999999999974 191.901918976148 -191.901918976148 -2281978667.853158 +120.7999999999974 191.7376625264981 191.7376625264981 -2289277169.679401 +120.8999999999974 191.5729764206649 -191.5729764206649 -2296594217.207358 +120.9999999999974 191.4078729372193 -191.4078729372193 -2303929841.880507 +121.0999999999974 191.2423468348504 -191.2423468348504 -2311284075.169332 +121.1999999999974 191.0763948155791 191.0763948155791 -2318656948.571333 +121.2999999999974 190.9100258077481 190.9100258077481 -2326048493.611022 +121.3999999999974 190.7432256300405 190.7432256300405 -2333458741.839928 +121.4999999999974 190.575991241773 -190.575991241773 -2340887724.836602 +121.5999999999974 190.408322944782 -190.408322944782 -2348335474.206624 +121.6999999999974 190.2402362240286 -190.2402362240286 -2355802021.582597 +121.7999999999974 190.0717187808356 -190.0717187808356 -2363287398.624159 +121.8999999999973 189.9027459840939 -189.9027459840939 -2370791637.017985 +121.9999999999973 189.7333654072705 189.7333654072705 -2378314768.477789 +122.0999999999973 189.5635379733753 -189.5635379733753 -2385856824.744327 +122.1999999999973 189.3932747680622 189.3932747680622 -2393417837.585406 +122.2999999999973 189.2225629722444 -189.2225629722444 -2400997838.795878 +122.3999999999973 189.0514092074317 -189.0514092074317 -2408596860.197655 +122.4999999999973 188.8798221530628 -188.8798221530628 -2416214933.639705 +122.5999999999973 188.7077879012211 -188.7077879012211 -2423852090.998058 +122.6999999999973 188.5352959261817 -188.5352959261817 -2431508364.175812 +122.7999999999973 188.3623660983753 -188.3623660983753 -2439183785.103134 +122.8999999999973 188.1889890730962 -188.1889890730962 -2446878385.737266 +122.9999999999973 188.0151543246192 -188.0151543246192 -2454592198.062527 +123.0999999999973 187.8408817233753 -187.8408817233753 -2462325254.090317 +123.1999999999973 187.666135444782 -187.666135444782 -2470077585.859125 +123.2999999999973 187.4909385854817 187.4909385854817 -2477849225.434526 +123.3999999999973 187.3152794057942 187.3152794057942 -2485640204.909194 +123.4999999999973 187.1391620052785 -187.1391620052785 -2493450556.402896 +123.5999999999973 186.9626155849093 186.9626155849093 -2501280312.062507 +123.6999999999972 186.7855859683357 -186.7855859683357 -2509129504.062002 +123.7999999999972 186.6080694911004 -186.6080694911004 -2516998164.602474 +123.8999999999972 186.4301152784777 186.4301152784777 -2524886325.912125 +123.9999999999972 186.2516752801357 186.2516752801357 -2532794020.24628 +124.0999999999972 186.0727826988069 -186.0727826988069 -2540721279.887384 +124.1999999999972 185.893410990977 -185.893410990977 -2548668137.145014 +124.2999999999972 185.7135644839608 -185.7135644839608 -2556634624.355877 +124.3999999999972 185.5332646925402 185.5332646925402 -2564620773.883814 +124.4999999999972 185.3524603710834 -185.3524603710834 -2572626618.119814 +124.5999999999972 185.1711798426629 -185.1711798426629 -2580652189.482006 +124.6999999999972 184.9894414503527 184.9894414503527 -2588697520.415668 +124.7999999999972 184.8072016776875 -184.8072016776875 -2596762643.393241 +124.8999999999972 184.6244835073567 184.6244835073567 -2604847590.914312 +124.9999999999972 184.4412787969102 184.4412787969102 -2612952395.505644 +125.0999999999972 184.257611738271 -184.257611738271 -2621077089.721163 +125.1999999999972 184.0734277652109 -184.0734277652109 -2629221706.141966 +125.2999999999972 183.8887727373989 -183.8887727373989 -2637386277.376332 +125.3999999999971 183.7036033553585 183.7036033553585 -2645570836.059723 +125.4999999999971 183.5179389531602 183.5179389531602 -2653775414.854783 +125.5999999999971 183.3318047152442 -183.3318047152442 -2662000046.451353 +125.6999999999971 183.145143450591 -183.145143450591 -2670244763.56647 +125.7999999999971 182.9580055619695 -182.9580055619695 -2678509598.944374 +125.8999999999971 182.7703499633747 182.7703499633747 -2686794585.356508 +125.9999999999971 182.5821966992086 -182.5821966992086 -2695099755.601532 +126.0999999999971 182.3935330612894 -182.3935330612894 -2703425142.505318 +126.1999999999971 182.2043787444892 182.2043787444892 -2711770778.920967 +126.2999999999971 182.0146844606546 -182.0146844606546 -2720136697.728798 +126.3999999999971 181.8244989137796 -181.8244989137796 -2728522931.836371 +126.4999999999971 181.6338066683692 -181.6338066683692 -2736929514.17848 +126.5999999999971 181.4425932488857 181.4425932488857 -2745356477.717161 +126.6999999999971 181.2508427140999 181.2508427140999 -2753803855.4417 +126.7999999999971 181.0585853780606 181.0585853780606 -2762271680.368634 +126.8999999999971 180.865811696333 180.865811696333 -2770759985.541759 +126.9999999999971 180.6725183929267 180.6725183929267 -2779268804.032137 +127.0999999999971 180.4786707366767 180.4786707366767 -2787798168.938105 +127.199999999997 180.2843259871589 -180.2843259871589 -2796348113.385264 +127.299999999997 180.0894289387734 180.0894289387734 -2804918670.526504 +127.399999999997 179.8940098781941 -179.8940098781941 -2813509873.541997 +127.499999999997 179.6980594577503 -179.6980594577503 -2822121755.63921 +127.599999999997 179.5015560145968 179.5015560145968 -2830754350.052907 +127.699999999997 179.3045292407491 -179.3045292407491 -2839407690.045158 +127.799999999997 179.1069252218106 179.1069252218106 -2848081808.905338 +127.899999999997 178.9088153255909 -178.9088153255909 -2856776739.95014 +127.999999999997 178.7101713738857 178.7101713738857 -2865492516.523576 +128.099999999997 178.5109526238857 178.5109526238857 -2874229171.99699 +128.199999999997 178.3111902679267 178.3111902679267 -2882986739.769053 +128.299999999997 178.1108574496192 -178.1108574496192 -2891765253.265782 +128.399999999997 177.9099855793984 177.9099855793984 -2900564745.940534 +128.499999999997 177.7085576612898 177.7085576612898 -2909385251.274018 +128.599999999997 177.5065462076786 -177.5065462076786 -2918226802.774304 +128.699999999997 177.3039984570214 -177.3039984570214 -2927089433.976824 +128.799999999997 177.1008914890003 -177.1008914890003 -2935973178.444386 +128.899999999997 176.8972107276783 -176.8972107276783 -2944878069.767162 +128.999999999997 176.6929445637734 176.6929445637734 -2953804141.562722 +129.099999999997 176.4881254754482 176.4881254754482 -2962751427.476016 +129.1999999999969 176.2827125932195 -176.2827125932195 -2971719961.179395 +129.2999999999969 176.0767215671253 -176.0767215671253 -2980709776.372612 +129.3999999999969 175.8701787550397 175.8701787550397 -2989720906.782832 +129.4999999999969 175.6630252780628 -175.6630252780628 -2998753386.164635 +129.5999999999969 175.455300639414 -175.455300639414 -3007807248.300021 +129.6999999999969 175.2469812835517 175.2469812835517 -3016882526.998426 +129.7999999999969 175.0380647295869 -175.0380647295869 -3025979256.096723 +129.8999999999969 174.8285795770107 174.8285795770107 -3035097469.459226 +129.9999999999969 174.6184846842405 -174.6184846842405 -3044237200.9777 +130.0999999999969 174.4077883137734 174.4077883137734 -3053398484.571376 +130.1999999999969 174.1964846028359 174.1964846028359 -3062581354.186947 +130.2999999999969 173.9845882411593 173.9845882411593 -3071785843.798572 +130.3999999999969 173.7720863546231 173.7720863546231 -3081011987.407902 +130.4999999999969 173.5589621585844 173.5589621585844 -3090259819.04407 +130.5999999999969 173.3452521082879 -173.3452521082879 -3099529372.763705 +130.6999999999969 173.1309027538966 -173.1309027538966 -3108820682.650941 +130.7999999999969 172.9159549655628 -172.9159549655628 -3118133782.817423 +130.8999999999969 172.7003808902115 -172.7003808902115 -3127468707.402314 +130.9999999999968 172.4841681239129 -172.4841681239129 -3136825490.572301 +131.0999999999968 172.2673361820223 172.2673361820223 -3146204166.521612 +131.1999999999968 172.049893727583 172.049893727583 -3155604769.472008 +131.2999999999968 171.8317893070221 171.8317893070221 -3165027333.67281 +131.3999999999968 171.6130701507392 171.6130701507392 -3174471893.400889 +131.4999999999968 171.3937055503699 -171.3937055503699 -3183938482.960691 +131.5999999999968 171.1736999854908 -171.1736999854908 -3193427136.684235 +131.6999999999968 170.9530389528396 -170.9530389528396 -3202937888.931114 +131.7999999999968 170.7317529605241 -170.7317529605241 -3212470774.08853 +131.8999999999968 170.509801648152 -170.509801648152 -3222025826.571271 +131.9999999999968 170.2871977410732 170.2871977410732 -3231603080.82174 +132.0999999999968 170.0639594609727 170.0639594609727 -3241202571.309962 +132.1999999999968 169.8400273878518 169.8400273878518 -3250824332.533582 +132.2999999999968 169.6154427368122 169.6154427368122 -3260468399.017884 +132.3999999999968 169.3902002261492 -169.3902002261492 -3270134805.315795 +132.4999999999968 169.1642854327123 -169.1642854327123 -3279823586.0079 +132.5999999999968 168.9376834811878 -168.9376834811878 -3289534775.702442 +132.6999999999967 168.7104134399372 168.7104134399372 -3299268409.035342 +132.7999999999967 168.4824834425392 168.4824834425392 -3309024520.670197 +132.8999999999967 168.2538476870868 -168.2538476870868 -3318803145.2983 +132.9999999999967 168.0245364247171 168.0245364247171 -3328604317.638646 +133.0999999999967 167.7945225735066 -167.7945225735066 -3338428072.437934 +133.1999999999967 167.5638184861361 167.5638184861361 -3348274444.470591 +133.2999999999967 167.3323977528421 167.3323977528421 -3358143468.538769 +133.3999999999967 167.1003135854817 167.1003135854817 -3368035179.472366 +133.4999999999967 166.8675044120625 -166.8675044120625 -3377949612.129027 +133.5999999999967 166.6340001728955 166.6340001728955 -3387886801.394156 +133.6999999999967 166.399758647226 -166.399758647226 -3397846782.180937 +133.7999999999967 166.1648237144325 -166.1648237144325 -3407829589.430325 +133.8999999999967 165.9291710073567 165.9291710073567 -3417835258.11108 +133.9999999999967 165.6927850465884 -165.6927850465884 -3427863823.219755 +134.0999999999967 165.4556766984753 165.4556766984753 -3437915319.780716 +134.1999999999967 165.2178499186156 -165.2178499186156 -3447989782.846165 +134.2999999999967 164.9792419776783 -164.9792419776783 -3458087247.496132 +134.3999999999967 164.739931671462 -164.739931671462 -3468207748.838497 +134.4999999999966 164.499868003796 164.499868003796 -3478351322.008997 +134.5999999999966 164.2590662444892 164.2590662444892 -3488518002.171245 +134.6999999999966 164.0175174655628 -164.0175174655628 -3498707824.516728 +134.7999999999966 163.7752099917745 -163.7752099917745 -3508920824.264833 +134.8999999999966 163.5321375335517 163.5321375335517 -3519157036.662852 +134.9999999999966 163.2882938891864 -163.2882938891864 -3529416496.985993 +135.0999999999966 163.0436989213445 -163.0436989213445 -3539699240.537393 +135.1999999999966 162.7983186358376 -162.7983186358376 -3550005302.648137 +135.2999999999966 162.5521854343128 -162.5521854343128 -3560334718.677257 +135.3999999999966 162.3052522623657 -162.3052522623657 -3570687524.01176 +135.4999999999966 162.0575193465344 -162.0575193465344 -3581063754.066629 +135.5999999999966 161.8090334309609 161.8090334309609 -3591463444.284843 +135.6999999999966 161.5597284059625 -161.5597284059625 -3601886630.137383 +135.7999999999966 161.3096318800388 161.3096318800388 -3612333347.123255 +135.8999999999966 161.0587446128702 -161.0587446128702 -3622803630.769496 +135.9999999999966 160.8070356284952 -160.8070356284952 -3633297516.631187 +136.0999999999966 160.5545168293984 160.5545168293984 -3643815040.291476 +136.1999999999965 160.3011847254754 -160.3011847254754 -3654356237.361581 +136.2999999999965 160.0470258628702 -160.0470258628702 -3664921143.480809 +136.3999999999965 159.7920537550388 159.7920537550388 -3675509794.316568 +136.4999999999965 159.5362495000352 159.5362495000352 -3686122225.564391 +136.5999999999965 159.2796025831637 159.2796025831637 -3696758472.947935 +136.6999999999965 159.022092476032 -159.022092476032 -3707418572.219009 +136.7999999999965 158.7637657339192 158.7637657339192 -3718102559.157581 +136.8999999999965 158.5045781691011 158.5045781691011 -3728810469.5718 +136.9999999999965 158.2445244418067 -158.2445244418067 -3739542339.298004 +137.0999999999965 157.9836342061856 157.9836342061856 -3750298204.200744 +137.1999999999965 157.7218633253511 157.7218633253511 -3761078100.172788 +137.2999999999965 157.4591927368122 157.4591927368122 -3771882063.135154 +137.3999999999965 157.195668785046 157.195668785046 -3782710129.037109 +137.4999999999965 156.9312766117093 156.9312766117093 -3793562333.856199 +137.5999999999965 156.6659794360613 -156.6659794360613 -3804438713.598254 +137.6999999999965 156.3997978793067 -156.3997978793067 -3815339304.297416 +137.7999999999965 156.1326922787156 -156.1326922787156 -3826264142.016151 +137.8999999999965 155.8647103149372 155.8647103149372 -3837213262.845265 +137.9999999999964 155.5958168233731 155.5958168233731 -3848186702.90392 +138.0999999999964 155.3259891452503 -155.3259891452503 -3859184498.339666 +138.1999999999964 155.0552492512734 155.0552492512734 -3870206685.328434 +138.2999999999964 154.7835711849656 -154.7835711849656 -3881253300.074582 +138.3999999999964 154.5109764022335 154.5109764022335 -3892324378.810889 +138.4999999999964 154.2374051316003 -154.2374051316003 -3903419957.7986 +138.5999999999964 153.9629194175578 -153.9629194175578 -3914540073.327411 +138.6999999999964 153.6874691005343 153.6874691005343 -3925684761.715528 +138.7999999999964 153.4110872233033 -153.4110872233033 -3936854059.309658 +138.8999999999964 153.1336957847454 -153.1336957847454 -3948048002.485034 +138.9999999999964 152.8553469715921 152.8553469715921 -3959266627.645449 +139.0999999999964 152.5760215932942 152.5760215932942 -3970509971.223257 +139.1999999999964 152.2957270683125 -152.2957270683125 -3981778069.679414 +139.2999999999964 152.0143982276783 -152.0143982276783 -3993070959.503481 +139.3999999999964 151.7321172316008 151.7321172316008 -4004388677.213662 +139.4999999999964 151.4488188348232 151.4488188348232 -4015731259.356808 +139.5999999999964 151.1644901218128 -151.1644901218128 -4027098742.508459 +139.6999999999964 150.879152239653 -150.879152239653 -4038491163.272851 +139.7999999999963 150.5927910433692 -150.5927910433692 -4049908558.282946 +139.8999999999963 150.3053917104817 150.3053917104817 -4061350964.200451 +139.9999999999963 150.0169561236205 -150.0169561236205 -4072818417.715853 +140.0999999999963 149.7274784030628 -149.7274784030628 -4084310955.548427 +140.1999999999963 149.4369138777848 -149.4369138777848 -4095828614.446267 +140.2999999999963 149.1453070507729 -149.1453070507729 -4107371431.186318 +140.3999999999963 148.8526399249009 -148.8526399249009 -4118939442.574391 +140.4999999999963 148.558866683183 -148.558866683183 -4130532685.445192 +140.5999999999963 148.2640264361205 -148.2640264361205 -4142151196.662353 +140.6999999999963 147.9681059441982 147.9681059441982 -4153795013.118443 +140.7999999999963 147.6710381136817 -147.6710381136817 -4165464171.735021 +140.8999999999963 147.3728965932942 147.3728965932942 -4177158709.462633 +140.9999999999963 147.0736414398017 147.0736414398017 -4188878663.280865 +141.0999999999963 146.7732264007392 146.7732264007392 -4200624070.198355 +141.1999999999963 146.471681536528 -146.471681536528 -4212394967.25283 +141.2999999999963 146.169006880038 146.169006880038 -4224191391.51113 +141.3999999999963 145.8651738722255 145.8651738722255 -4236013380.069242 +141.4999999999962 145.5601752812852 145.5601752812852 -4247860970.052328 +141.5999999999962 145.2540001089192 145.2540001089192 -4259734198.614752 +141.6999999999962 144.9466498906602 144.9466498906602 -4271633102.94012 +141.7999999999962 144.6381229343128 -144.6381229343128 -4283557720.241302 +141.8999999999962 144.3283867464942 -144.3283867464942 -4295508087.76047 +141.9999999999962 144.0174344284747 -144.0174344284747 -4307484242.769135 +142.0999999999962 143.7052616061878 -143.7052616061878 -4319486222.568161 +142.1999999999962 143.3918787444892 143.3918787444892 -4331514064.487824 +142.2999999999962 143.0772621358731 143.0772621358731 -4343567805.887832 +142.3999999999962 142.7613855804267 142.7613855804267 -4355647484.157361 +142.4999999999962 142.4442469085517 142.4442469085517 -4367753136.715096 +142.5999999999962 142.1549931079361 -142.1549931079361 -4379884799.390224 +142.6999999999962 142.1549931079361 -142.1549931079361 -4392042283.338249 +142.7999999999962 142.1549931079361 -142.1549931079361 -4404225464.803179 +142.8999999999962 142.1549931079361 -142.1549931079361 -4416434379.892985 +142.9999999999962 142.1549931079361 -142.1549931079361 -4428669064.740988 +143.0999999999962 142.1549806965859 142.1549806965859 -4440929555.512715 +143.1999999999962 142.1549806965859 142.1549806965859 -4453215888.393487 +143.2999999999961 142.1549806965859 142.1549806965859 -4465528099.584546 +143.3999999999961 142.1549806965859 142.1549806965859 -4477866225.320626 +143.4999999999961 142.1549806965859 142.1549806965859 -4490230301.861804 +143.5999999999961 142.1549806965859 142.1549806965859 -4502620365.493501 +143.6999999999961 142.1549806965859 142.1549806965859 -4515036452.526492 +143.7999999999961 142.1549707339633 -142.1549707339633 -4527478599.250299 +143.8999999999961 142.1549707339632 -142.1549707339632 -4539946842.131559 +143.9999999999961 142.1549707339632 -142.1549707339632 -4552441217.498529 +144.0999999999961 142.1549707339632 -142.1549707339632 -4564961761.763371 +144.1999999999961 142.1142908538642 142.1142908538642 -4577508514.093884 +144.2999999999961 141.7572197543067 -141.7572197543067 -4590081770.140513 +144.3999999999961 141.4029232020968 141.4029232020968 -4602681732.166774 +144.4999999999961 141.0489678011817 -141.0489678011817 -4615308434.981191 +144.5999999999961 140.6947197543067 -140.6947197543067 -4627961914.886209 +144.6999999999961 140.3398810145379 -140.3398810145379 -4640642208.756438 +144.7999999999961 139.9841922702503 -139.9841922702503 -4653349353.787461 +144.8999999999961 139.6275846844576 139.6275846844576 -4666083387.387164 +144.999999999996 139.2699186688327 139.2699186688327 -4678844347.118494 +145.099999999996 138.9111244405606 138.9111244405606 -4691632270.665558 +145.199999999996 138.551114430708 138.551114430708 -4704447195.811901 +145.299999999996 138.1898807468128 -138.1898807468128 -4717289160.425737 +145.399999999996 137.8273439778359 137.8273439778359 -4730158202.449485 +145.499999999996 137.463498726032 -137.463498726032 -4743054359.892086 +145.599999999996 137.0982684505904 -137.0982684505904 -4755977670.823201 +145.699999999996 136.7316004241767 136.7316004241767 -4768928173.36873 +145.799999999996 136.3634916863857 136.3634916863857 -4781905905.707288 +145.899999999996 135.9939599917761 -135.9939599917761 -4794910906.067389 +145.999999999996 135.6229031784742 -135.6229031784742 -4807943212.72516 +146.099999999996 135.2503353114718 135.2503353114718 -4821002864.002468 +146.199999999996 134.8762209950296 134.8762209950296 -4834089898.265363 +146.299999999996 134.5005058871192 -134.5005058871192 -4847204353.922794 +146.399999999996 134.1231605733731 134.1231605733731 -4860346269.425509 +146.499999999996 133.7442509172258 133.7442509172258 -4873515683.265134 +146.599999999996 133.3636493099653 -133.3636493099653 -4886712633.973385 +146.699999999996 132.9813846530628 -132.9813846530628 -4899937160.121407 +146.7999999999959 132.5974139584028 -132.5974139584028 -4913189300.31919 +146.8999999999959 132.2116911297706 132.2116911297706 -4926469093.215073 +146.9999999999959 131.8242475425582 -131.8242475425582 -4939776577.495322 +147.0999999999959 131.435013004554 -131.435013004554 -4953111791.883767 +147.1999999999959 131.0439456044046 131.0439456044046 -4966474775.14148 +147.2999999999959 130.651111397058 -130.651111397058 -4979865566.066511 +147.3999999999959 130.2564090671253 -130.2564090671253 -4993284203.493646 +147.4999999999959 129.8598350698567 129.8598350698567 -5006730726.294219 +147.5999999999959 129.4613470898366 -129.4613470898366 -5020205173.375939 +147.6999999999959 129.0609461273017 129.0609461273017 -5033707583.682756 +147.7999999999959 128.6585905438333 128.6585905438333 -5047237996.194737 +147.8999999999959 128.2542415614718 128.2542415614718 -5060796449.92797 +147.9999999999959 127.8479361694378 -127.8479361694378 -5074382983.934505 +148.0999999999959 127.4395770443402 -127.4395770443402 -5087997637.302278 +148.1999999999959 127.029164878796 127.029164878796 -5101640449.155085 +148.2999999999959 126.6166655145107 126.6166655145107 -5115311458.652548 +148.3999999999959 126.2020209844102 126.2020209844102 -5129010704.990114 +148.4999999999959 125.7853143434543 -125.7853143434543 -5142738227.399051 +148.5999999999958 125.3664064778359 125.3664064778359 -5156494065.146461 +148.6999999999958 124.945300850183 -124.945300850183 -5170278257.535312 +148.7999999999958 124.521961006433 -124.521961006433 -5184090843.90448 +148.8999999999958 124.0963748874381 -124.0963748874381 -5197931863.628786 +148.9999999999958 123.6684746371192 -123.6684746371192 -5211801356.119057 +149.0999999999958 123.2382728780606 123.2382728780606 -5225699360.8222 +149.1999999999958 122.8057499438733 -122.8057499438733 -5239625917.221278 +149.2999999999958 122.3708396834835 122.3708396834835 -5253581064.835594 +149.3999999999958 121.9334719715921 121.9334719715921 -5267564843.220784 +149.4999999999958 121.4936881225628 -121.4936881225628 -5281577291.968931 +149.5999999999958 121.0513832296231 121.0513832296231 -5295618450.708663 +149.6999999999958 120.6066287936877 -120.6066287936877 -5309688359.105287 +149.7999999999958 120.1592412550365 120.1592412550365 -5323787056.860925 +149.8999999999958 119.7093223745443 119.7093223745443 -5337914583.714622 +149.9999999999958 119.2567469085517 119.2567469085517 -5352070979.442537 +150.0999999999958 118.8014893845745 118.8014893845745 -5366256283.858062 +150.1999999999958 118.3435492382747 -118.3435492382747 -5380470536.811994 +150.2999999999957 117.8828337078964 117.8828337078964 -5394713778.192736 +150.3999999999957 117.4193445648017 117.4193445648017 -5408986047.926446 +150.4999999999957 116.9529912798705 -116.9529912798705 -5423287385.977232 +150.5999999999957 116.4837822543067 -116.4837822543067 -5437617832.347381 +150.6999999999957 116.0116339442254 -116.0116339442254 -5451977427.07753 +150.7999999999957 115.536571794875 -115.536571794875 -5466366210.246918 +150.8999999999957 115.0584230793984 115.0584230793984 -5480784221.973599 +150.9999999999957 114.577268257282 -114.577268257282 -5495231502.414692 +151.0999999999957 114.0929285491767 114.0929285491767 -5509708091.766623 +151.1999999999957 113.6054863558692 -113.6054863558692 -5524214030.265391 +151.2999999999957 113.1148372645968 113.1148372645968 -5538749358.186847 +151.3999999999957 112.6209101121642 -112.6209101121642 -5553314115.846981 +151.4999999999957 112.1236511573658 -112.1236511573658 -5567908343.602203 +151.5999999999957 111.6229578460517 111.6229578460517 -5582532081.849678 +151.6999999999957 111.1188911015977 111.1188911015977 -5597185371.027635 +151.7999999999957 110.6113163469126 110.6113163469126 -5611868251.615713 +151.8999999999957 110.1001985265166 110.1001985265166 -5626580764.135304 +151.9999999999957 109.5853876512266 -109.5853876512266 -5641322949.149941 +152.0999999999956 109.0669233238076 -109.0669233238076 -5656094847.265673 +152.1999999999956 108.5447689052218 108.5447689052218 -5670896499.131454 +152.2999999999956 108.0186979657095 108.0186979657095 -5685727945.439586 +152.3999999999956 107.488757881433 -107.488757881433 -5700589226.926138 +152.4999999999956 106.9548627769325 -106.9548627769325 -5715480384.371423 +152.5999999999956 106.4169038214268 -106.4169038214268 -5730401458.600456 +152.6999999999956 105.874844899458 105.874844899458 -5745352490.483476 +152.7999999999956 105.3285517137263 -105.3285517137263 -5760333520.936435 +152.8999999999956 104.7779901246996 -104.7779901246996 -5775344590.921602 +152.9999999999956 104.2230140889981 104.2230140889981 -5790385741.448077 +153.0999999999956 103.6636356296252 -103.6636356296252 -5805457013.572429 +153.1999999999956 103.0996071244695 -103.0996071244695 -5820558448.399308 +153.2999999999956 102.5310061512796 102.5310061512796 -5835690087.082114 +153.3999999999956 101.9576133901693 101.9576133901693 -5850851970.823683 +153.4999999999956 101.3793663198568 101.3793663198568 -5866044140.877024 +153.5999999999956 100.7961762823643 -100.7961762823643 -5881266638.546064 +153.6999999999956 100.2078740923705 -100.2078740923705 -5896519505.186466 +153.7999999999955 99.6143795909079 -99.6143795909079 -5911802782.20646 +153.8999999999955 99.01561662806057 99.01561662806057 -5927116511.067741 +153.9999999999955 98.41136858118557 98.41136858118557 -5942460733.286407 +154.0999999999955 97.80159955324794 -97.80159955324794 -5957835490.433919 +154.1999999999955 97.18609565903836 -97.18609565903836 -5973240824.138177 +154.2999999999955 96.56478630570803 96.56478630570803 -5988676776.084584 +154.3999999999955 95.93746381106041 -95.93746381106041 -6004143388.01724 +154.4999999999955 95.3039762860227 95.3039762860227 -6019640701.740126 +154.5999999999955 94.66425804033588 94.66425804033588 -6035168759.118438 +154.6999999999955 94.01804520620408 94.01804520620408 -6050727602.079955 +154.7999999999955 93.36523212446954 -93.36523212446954 -6066317272.616479 +154.8999999999955 92.70554478003794 -92.70554478003794 -6081937812.785415 +154.9999999999955 92.03889113081254 -92.03889113081254 -6097589264.711391 +155.0999999999955 91.36502749891292 -91.36502749891292 -6113271670.588025 +155.1999999999955 90.68371043753518 90.68371043753518 -6128985072.679785 +155.2999999999955 89.99478406711842 89.99478406711842 -6144729513.32399 +155.3999999999955 89.29800242536953 -89.29800242536953 -6160505034.932931 +155.4999999999955 88.59311844839158 88.59311844839158 -6176311679.996147 +155.5999999999954 87.87983722330435 -87.87983722330435 -6192149491.082859 +155.6999999999954 87.15799202573919 87.15799202573919 -6208018510.844595 +155.7999999999954 86.42718258633624 86.42718258633624 -6223918782.017974 +155.8999999999954 85.68717716796405 -85.68717716796405 -6239850347.427754 +155.9999999999954 84.93768348118772 -84.93768348118772 -6255813249.990077 +156.0999999999954 84.17829612627338 84.17829612627338 -6271807532.715961 +156.1999999999954 83.40866978003845 -83.40866978003845 -6287833238.715131 +156.2999999999954 82.62847847153753 -82.62847847153753 -6303890411.20012 +156.3999999999954 81.83727802290704 -81.83727802290704 -6319979093.49073 +156.4999999999954 81.03470101011419 81.03470101011419 -6336099329.018911 +156.5999999999954 80.22015418431275 -80.22015418431275 -6352251161.334051 +156.6999999999954 79.39332815274417 -79.39332815274417 -6368434634.108759 +156.7999999999954 78.5535645798881 78.5535645798881 -6384649791.145228 +156.8999999999954 77.70035042417669 77.70035042417669 -6400896676.38219 +156.9999999999954 76.83310167141926 76.83310167141926 -6417175333.902577 +157.0999999999954 75.95108706922542 -75.95108706922542 -6433485807.942041 +157.1999999999954 75.05372854336917 -75.05372854336917 -6449828142.89828 +157.2999999999954 74.14019812962522 -74.14019812962522 -6466202383.341514 +157.3999999999953 73.20975257568784 -73.20975257568784 -6482608574.026102 +157.4999999999953 72.26126351011419 72.26126351011419 -6499046759.903567 +157.5999999999953 71.2940557329955 -71.2940557329955 -6515516986.137232 +157.6999999999953 70.30683917642938 -70.30683917642938 -6532019298.118719 +157.7999999999953 69.29858173384454 -69.29858173384454 -6548553741.486686 +157.8999999999953 68.26785804443784 -68.26785804443784 -6565120362.148142 +157.9999999999953 67.21325145316018 67.21325145316018 -6581719206.302842 +158.0999999999953 66.13320750349388 -66.13320750349388 -6598350320.471427 +158.1999999999953 65.02590769880632 -65.02590769880632 -6615013751.527971 +158.2999999999953 63.88934078946252 63.88934078946252 -6631709546.73801 +158.3999999999953 62.72119360389684 62.72119360389684 -6648437753.803168 +158.4999999999953 61.51901475735676 61.51901475735676 -6665198420.914081 +158.5999999999953 60.27979352818943 -60.27979352818943 -6681991596.813608 +158.6999999999953 58.99988630162693 -58.99988630162693 -6698817330.873197 +158.7999999999953 57.6756588877829 -57.6756588877829 -6715675673.186045 +158.8999999999953 56.30216128797542 -56.30216128797542 -6732566674.682292 +158.9999999999953 54.87404463754592 -54.87404463754592 -6749490387.273397 +159.0999999999952 53.3843991221579 -53.3843991221579 -6766446864.036067 +159.1999999999952 51.82498420210447 -51.82498420210447 -6783436159.450966 +159.2999999999952 50.18574763671573 50.18574763671573 -6800458329.719297 +159.3999999999952 48.45357750243716 48.45357750243716 -6817513433.193583 +159.4999999999952 46.61154347307183 46.61154347307183 -6834601530.982141 +159.5999999999952 44.63648638746679 -44.63648638746679 -6851722687.829916 +159.6999999999952 42.49630699115932 42.49630699115932 -6868876973.464283 +159.7999999999952 40.14295270787693 -40.14295270787693 -6886064464.781581 +159.8999999999952 37.49926532759454 -37.49926532759454 -6903285249.708036 +159.9999999999952 34.42571968247231 -34.42571968247231 -6920539434.889266 +160.0999999999952 30.61387399569333 30.61387399569333 -6937827164.280186 +160.1999999999952 24.95758094212518 -24.95758094212518 -6955148686.030867 +160.2999999999952 0 0.008533143784485372 -6972506188.860198 +160.3999999999952 0 0.008533143784485372 -6989896625.223186 +160.4999999999952 0 0.008533143784485372 -7007319616.299928 +160.5999999999952 0 0.008533143784485372 -7024775202.644162 +160.6999999999952 0 0.008533143784485372 -7042263424.835292 +160.7999999999952 0 0.008533143784485372 -7059784323.478389 +160.8999999999951 0 0.008533143784485372 -7077337939.204179 +160.9999999999951 0 0.008533143784485372 -7094924312.669031 +161.0999999999951 0 0.008533143784485372 -7112543484.554972 +161.1999999999951 0 0.008533143784485372 -7130195495.569678 +161.2999999999951 0 0.008533143784485372 -7147880386.446451 +161.3999999999951 0 0.008533143784485372 -7165598197.944221 +161.4999999999951 0 0.008533143784485372 -7183348970.847568 +161.5999999999951 0 0.008533143784485372 -7201132745.966683 +161.6999999999951 0 0.008533143784485372 -7218949564.137376 +161.7999999999951 0 0.008533143784485372 -7236799466.221077 +161.8999999999951 0 0.008533143784485372 -7254682493.104826 +161.9999999999951 0 0.008533143784485372 -7272598685.701271 +162.0999999999951 0 0.008533143784485372 -7290548084.948668 +162.1999999999951 0 0.008533143784485372 -7308530731.810864 +162.2999999999951 0 0.008533143784485372 -7326546667.277311 +162.3999999999951 0 0.008533143784485372 -7344595932.363043 +162.4999999999951 0 0.008533143784485372 -7362678568.108694 +162.599999999995 0 0.008533143784485372 -7380794615.580472 +162.699999999995 0 0.008533143784485372 -7398944115.870166 +162.799999999995 0 0.008533143784485372 -7417127110.095145 +162.899999999995 0 0.008533143784485372 -7435343639.398359 +162.999999999995 0 0.008533143784485372 -7453593744.948311 +163.099999999995 0 0.008533143784485372 -7471877467.939082 +163.199999999995 0 0.008533143784485372 -7490194849.590323 +163.299999999995 0 0.008533143784485372 -7508545931.147223 +163.399999999995 0 0.008533143784485372 -7526930753.88055 +163.499999999995 0 0.008533143784485372 -7545349359.086613 +163.599999999995 0 0.008533143784485372 -7563801788.087272 +163.699999999995 0 0.008533143784485372 -7582288082.229938 +163.799999999995 0 0.008533143784485372 -7600808282.88757 +163.899999999995 0 0.008533143784485372 -7619362431.458656 +163.999999999995 0 0.008533143784485372 -7637950569.367229 +164.099999999995 0 0.008533143784485372 -7656572738.062862 +164.199999999995 0 0.008533143784485372 -7675228979.020649 +164.299999999995 0 0.008533143784485372 -7693919333.741224 +164.3999999999949 0 0.008533143784485372 -7712643843.750738 +164.4999999999949 0 0.008533143784485372 -7731402550.600882 +164.5999999999949 0 0.008533143784485372 -7750195495.868851 +164.6999999999949 0 0.008533143784485372 -7769022721.157364 +164.7999999999949 0 0.008533143784485372 -7787884268.094655 +164.8999999999949 0 0.008533143784485372 -7806780178.334483 +164.9999999999949 0 0.008533143784485372 -7825710493.556111 +165.0999999999949 0 0.008533143784485372 -7844675255.464297 +165.1999999999949 0 0.008533143784485372 -7863674505.78933 +165.2999999999949 0 0.008533143784485372 -7882708286.286973 +165.3999999999949 0 0.008533143784485372 -7901776638.73852 +165.4999999999949 0 0.008533143784485372 -7920879604.950748 +165.5999999999949 0 0.008533143784485372 -7940017226.755929 +165.6999999999949 0 0.008533143784485372 -7959189546.011837 +165.7999999999949 0 0.008533143784485372 -7978396604.601734 +165.8999999999949 0 0.008533143784485372 -7997638444.434373 +165.9999999999949 0 0.008533143784485372 -8016915107.443989 +166.0999999999948 0 0.008533143784485372 -8036226635.590319 +166.1999999999948 0 0.008533143784485372 -8055573070.858556 +166.2999999999948 0 0.008533143784485372 -8074954455.259406 +166.3999999999948 0 0.008533143784485372 -8094370830.829033 +166.4999999999948 0 0.008533143784485372 -8113822239.629084 +166.5999999999948 0 0.008533143784485372 -8133308723.746679 +166.6999999999948 0 0.008533143784485372 -8152830325.294419 +166.7999999999948 0 0.008533143784485372 -8172387086.41037 +166.8999999999948 0 0.008533143784485372 -8191979049.25807 +166.9999999999948 0 0.008533143784485372 -8211606256.026521 +167.0999999999948 0 0.008533143784485372 -8231268748.930188 +167.1999999999948 0 0.008533143784485372 -8250966570.209022 +167.2999999999948 0 0.008533143784485372 -8270699762.128404 +167.3999999999948 0 0.008533143784485372 -8290468366.979201 +167.4999999999948 0 0.008533143784485372 -8310272427.07772 +167.5999999999948 0 0.008533143784485372 -8330111984.765746 +167.6999999999948 0 0.008533143784485372 -8349987082.410496 +167.7999999999948 0 0.008533143784485372 -8369897762.40466 +167.8999999999947 0 0.008533143784485372 -8389844067.166363 +167.9999999999947 0 0.008533143784485372 -8409826039.139191 +168.0999999999947 0 0.008533143784485372 -8429843720.792185 +168.1999999999947 0 0.008533143784485372 -8449897154.61981 +168.2999999999947 0 0.008533143784485372 -8469986383.142008 +168.3999999999947 0 0.008533143784485372 -8490111448.904132 +168.4999999999947 0 0.008533143784485372 -8510272394.477005 +168.5999999999947 0 0.008533143784485372 -8530469262.456877 +168.6999999999947 0 0.008533143784485372 -8550702095.465446 +168.7999999999947 0 0.008533143784485372 -8570970936.149822 +168.8999999999947 0 0.008533143784485372 -8591275827.182596 +168.9999999999947 0 0.008533143784485372 -8611616811.261749 +169.0999999999947 0 0.008533143784485372 -8631993931.110739 +169.1999999999947 0 0.008533143784485372 -8652407229.478411 +169.2999999999947 0 0.008533143784485372 -8672856749.13908 +169.3999999999947 0 0.008533143784485372 -8693342532.892469 +169.4999999999947 0 0.008533143784485372 -8713864623.563732 +169.5999999999947 0 0.008533143784485372 -8734423064.003466 +169.6999999999946 0 0.008533143784485372 -8755017897.087664 +169.7999999999946 0 0.008533143784485372 -8775649165.71777 +169.8999999999946 0 0.008533143784485372 -8796316912.820641 +169.9999999999946 0 0.008533143784485372 -8817021181.348558 +170.0999999999946 0 0.008533143784485372 -8837762014.279215 +170.1999999999946 0 0.008533143784485372 -8858539454.615732 +170.2999999999946 0 0.008533143784485372 -8879353545.386656 +170.3999999999946 0 0.008533143784485372 -8900204329.645929 +170.4999999999946 0 0.008533143784485372 -8921091850.472939 +170.5999999999946 0 0.008533143784485372 -8942016150.972452 +170.6999999999946 0 0.008533143784485372 -8962977274.274685 +170.7999999999946 0 0.008533143784485372 -8983975263.535238 +170.8999999999946 0 0.008533143784485372 -9005010161.935135 +170.9999999999946 0 0.008533143784485372 -9026082012.68082 +171.0999999999946 0 0.008533143784485372 -9047190859.004128 +171.1999999999946 0 0.008533143784485372 -9068336744.162312 +171.2999999999946 0 0.008533143784485372 -9089519711.438026 +171.3999999999945 0 0.008533143784485372 -9110739804.139341 +171.4999999999945 0 0.008533143784485372 -9131997065.59972 +171.5999999999945 0 0.008533143784485372 -9153291539.178041 +171.6999999999945 0 0.008533143784485372 -9174623268.258585 +171.7999999999945 0 0.008533143784485372 -9195992296.251019 +171.8999999999945 0 0.008533143784485372 -9217398666.590427 +171.9999999999945 0 0.008533143784485372 -9238842422.737293 +172.0999999999945 0 0.008533143784485372 -9260323608.177486 +172.1999999999945 0 0.008533143784485372 -9281842266.422295 +172.2999999999945 0 0.008533143784485372 -9303398441.008385 +172.3999999999945 0 0.008533143784485372 -9324992175.497829 +172.4999999999945 0 0.008533143784485372 -9346623513.478092 +172.5999999999945 0 0.008533143784485372 -9368292498.562042 +172.6999999999945 0 0.008533143784485372 -9389999174.387917 +172.7999999999945 0 0.008533143784485372 -9411743584.619377 +172.8999999999945 0 0.008533143784485372 -9433525772.945457 +172.9999999999945 0 0.008533143784485372 -9455345783.080587 +173.0999999999945 0 0.008533143784485372 -9477203658.764584 +173.1999999999944 0 0.008533143784485372 -9499099443.762657 +173.2999999999944 0 0.008533143784485372 -9521033181.865406 +173.3999999999944 0 0.008533143784485372 -9543004916.888815 +173.4999999999944 0 0.008533143784485372 -9565014692.674259 +173.5999999999944 0 0.008533143784485372 -9587062553.08849 +173.6999999999944 0 0.008533143784485372 -9609148542.023655 +173.7999999999944 0 0.008533143784485372 -9631272703.39728 +173.8999999999944 0 0.008533143784485372 -9653435081.152279 +173.9999999999944 0 0.008533143784485372 -9675635719.256948 +174.0999999999944 0 0.008533143784485372 -9697874661.70496 +174.1999999999944 0 0.008533143784485372 -9720151952.515375 +174.2999999999944 0 0.008533143784485372 -9742467635.732624 +174.3999999999944 0 0.008533143784485372 -9764821755.426544 +174.4999999999944 0 0.008533143784485372 -9787214355.692316 +174.5999999999944 0 0.008533143784485372 -9809645480.650526 +174.6999999999944 0 0.008533143784485372 -9832115174.447123 +174.7999999999944 0 0.008533143784485372 -9854623481.253437 +174.8999999999943 0 0.008533143784485372 -9877170445.266193 +174.9999999999943 0 0.008533143784485372 -9899756110.707453 +175.0999999999943 0 0.008533143784485372 -9922380521.82469 +175.1999999999943 0 0.008533143784485372 -9945043722.890726 +175.2999999999943 0 0.008533143784485372 -9967745758.203777 +175.3999999999943 0 0.008533143784485372 -9990486672.087437 +175.4999999999943 0 0.008533143784485372 -10013266508.89062 +175.5999999999943 0 0.008533143784485372 -10036085312.98769 +175.6999999999943 0 0.008533143784485372 -10058943128.77833 +175.7999999999943 0 0.008533143784485372 -10081840000.68759 +175.8999999999943 0 0.008533143784485372 -10104775973.16593 +175.9999999999943 0 0.008533143784485372 -10127751090.68914 +176.0999999999943 0 0.008533143784485372 -10150765397.75841 +176.1999999999943 0 0.008533143784485372 -10173818938.90027 +176.2999999999943 0 0.008533143784485372 -10196911758.66663 +176.3999999999943 0 0.008533143784485372 -10220043901.63479 +176.4999999999943 0 0.008533143784485372 -10243215412.40735 +176.5999999999943 0 0.008533143784485372 -10266426335.61236 +176.6999999999942 0 0.008533143784485372 -10289676715.90318 +176.7999999999942 0 0.008533143784485372 -10312966597.95855 +176.8999999999942 0 0.008533143784485372 -10336296026.48258 +176.9999999999942 0 0.008533143784485372 -10359665046.20472 +177.0999999999942 0 0.008533143784485372 -10383073701.87982 +177.1999999999942 0 0.008533143784485372 -10406522038.28807 +177.2999999999942 0 0.008533143784485372 -10430010100.23502 +177.3999999999942 0 0.008533143784485372 -10453537932.55158 +177.4999999999942 0 0.008533143784485372 -10477105580.09404 +177.5999999999942 0 0.008533143784485372 -10500713087.74403 +177.6999999999942 0 0.008533143784485372 -10524360500.40857 +177.7999999999942 0 0.008533143784485372 -10548047863.01997 +177.8999999999942 0 0.008533143784485372 -10571775220.536 +177.9999999999942 0 0.008533143784485372 -10595542617.93971 +178.0999999999942 0 0.008533143784485372 -10619350100.23952 +178.1999999999942 0 0.008533143784485372 -10643197712.46924 +178.2999999999942 0 0.008533143784485372 -10667085499.68802 +178.3999999999942 0 0.008533143784485372 -10691013506.98034 +178.4999999999941 0 0.008533143784485372 -10714981779.45609 +178.5999999999941 0 0.008533143784485372 -10738990362.25047 +178.6999999999941 0 0.008533143784485372 -10763039300.52405 +178.7999999999941 0 0.008533143784485372 -10787128639.46276 +178.8999999999941 0 0.008533143784485372 -10811258424.27787 +178.9999999999941 0 0.008533143784485372 -10835428700.20603 +179.0999999999941 0 0.008533143784485372 -10859639512.50922 +179.1999999999941 0 0.008533143784485372 -10883890906.47478 +179.2999999999941 0 0.008533143784485372 -10908182927.41541 +179.3999999999941 0 0.008533143784485372 -10932515620.66912 +179.4999999999941 0 0.008533143784485372 -10956889031.59935 +179.5999999999941 0 0.008533143784485372 -10981303205.59483 +179.6999999999941 0 0.008533143784485372 -11005758188.06966 +179.7999999999941 0 0.008533143784485372 -11030254024.46329 +179.8999999999941 0 0.008533143784485372 -11054790760.2405 +179.9999999999941 0 0.008533143784485372 -11079368440.89146 +180.0999999999941 0 0.008533143784485372 -11103987111.93166 +180.199999999994 0 0.008533143784485372 -11128646818.90195 +180.299999999994 0 0.008533143784485372 -11153347607.36853 +180.399999999994 0 0.008533143784485372 -11178089522.92293 +180.499999999994 0 0.008533143784485372 -11202872611.18204 +180.599999999994 0 0.008533143784485372 -11227696917.78812 +180.699999999994 0 0.008533143784485372 -11252562488.40873 +180.799999999994 0 0.008533143784485372 -11277469368.73681 +180.899999999994 0 0.008533143784485372 -11302417604.49064 +180.999999999994 0 0.008533143784485372 -11327407241.41383 +181.099999999994 0 0.008533143784485372 -11352438325.27537 +181.199999999994 0 0.008533143784485372 -11377510901.86956 +181.299999999994 0 0.008533143784485372 -11402625017.01606 +181.399999999994 0 0.008533143784485372 -11427780716.55987 +181.499999999994 0 0.008533143784485372 -11452978046.37136 +181.599999999994 0 0.008533143784485372 -11478217052.34618 +181.699999999994 0 0.008533143784485372 -11503497780.40541 +181.799999999994 0 0.008533143784485372 -11528820276.49538 +181.899999999994 0 0.008533143784485372 -11554184586.58783 +181.9999999999939 0 0.008533143784485372 -11579590756.67984 +182.0999999999939 0 0.008533143784485372 -11605038832.7938 +182.1999999999939 0 0.008533143784485372 -11630528860.97745 +182.2999999999939 0 0.008533143784485372 -11656060887.30388 +182.3999999999939 0 0.008533143784485372 -11681634957.87153 +182.4999999999939 0 0.008533143784485372 -11707251118.80415 +182.5999999999939 0 0.008533143784485372 -11732909416.25085 +182.6999999999939 0 0.008533143784485372 -11758609896.38611 +182.7999999999939 0 0.008533143784485372 -11784352605.40968 +182.8999999999939 0 0.008533143784485372 -11810137589.54671 +182.9999999999939 0 0.008533143784485372 -11835964895.04768 +183.0999999999939 0 0.008533143784485372 -11861834568.18836 +183.1999999999939 0 0.008533143784485372 -11887746655.26993 +183.2999999999939 0 0.008533143784485372 -11913701202.61885 +183.3999999999939 0 0.008533143784485372 -11939698256.58698 +183.4999999999939 0 0.008533143784485372 -11965737863.55143 +183.5999999999939 0 0.008533143784485372 -11991820069.91472 +183.6999999999938 0 0.008533143784485372 -12017944922.10469 +183.7999999999938 0 0.008533143784485372 -12044112466.5745 +183.8999999999938 0 0.008533143784485372 -12070322749.80267 +183.9999999999938 0 0.008533143784485372 -12096575818.29305 +184.0999999999938 0 0.008533143784485372 -12122871718.5748 +184.1999999999938 0 0.008533143784485372 -12149210497.20245 +184.2999999999938 0 0.008533143784485372 -12175592200.75584 +184.3999999999938 0 0.008533143784485372 -12202016875.84015 +184.4999999999938 0 0.008533143784485372 -12228484569.08594 +184.5999999999938 0 0.008533143784485372 -12254995327.14903 +184.6999999999938 0 0.008533143784485372 -12281549196.71063 +184.7999999999938 0 0.008533143784485372 -12308146224.47726 +184.8999999999938 0 0.008533143784485372 -12334786457.18078 +184.9999999999938 0 0.008533143784485372 -12361469941.5784 +185.0999999999938 0 0.008533143784485372 -12388196724.45261 +185.1999999999938 0 0.008533143784485372 -12414966852.61129 +185.2999999999938 0 0.008533143784485372 -12441780372.88764 +185.3999999999938 0 0.008533143784485372 -12468637332.14018 +185.4999999999937 0 0.008533143784485372 -12495537777.25277 +185.5999999999937 0 0.008533143784485372 -12522481755.13459 +185.6999999999937 0 0.008533143784485372 -12549469312.72018 +185.7999999999937 0 0.008533143784485372 -12576500496.96939 +185.8999999999937 0 0.008533143784485372 -12603575354.8674 +185.9999999999937 0 0.008533143784485372 -12630693933.42472 +186.0999999999937 0 0.008533143784485372 -12657856279.67722 +186.1999999999937 0 0.008533143784485372 -12685062440.68607 +186.2999999999937 0 0.008533143784485372 -12712312463.53778 +186.3999999999937 0 0.008533143784485372 -12739606395.34417 +186.4999999999937 0 0.008533143784485372 -12766944283.24245 +186.5999999999937 0 0.008533143784485372 -12794326174.39509 +186.6999999999937 0 0.008533143784485372 -12821752115.98994 +186.7999999999937 0 0.008533143784485372 -12849222155.24016 +186.8999999999937 0 0.008533143784485372 -12876736339.38423 +186.9999999999937 0 0.008533143784485372 -12904294715.68596 +187.0999999999937 0 0.008533143784485372 -12931897331.43453 +187.1999999999937 0 0.008533143784485372 -12959544233.94438 +187.2999999999936 0 0.008533143784485372 -12987235470.55534 +187.3999999999936 0 0.008533143784485372 -13014971088.63253 +187.4999999999936 0 0.008533143784485372 -13042751135.56642 +187.5999999999936 0 0.008533143784485372 -13070575658.7728 +187.6999999999936 0 0.008533143784485372 -13098444705.69279 +187.7999999999936 0 -0.008523295668195333 -13126358323.79283 +187.8999999999936 0 0.008533143784485372 -13154316560.56469 +187.9999999999936 0 0.008533143784485372 -13182319463.52545 +188.0999999999936 0 0.008533143784485372 -13210367080.21759 +188.1999999999936 0 -0.0005219854892857256 -13238459458.20902 +188.2999999999936 0 0.000155111676690467 -13266596645.09275 +188.3999999999936 0 -0.0003046434078471938 -13294778688.48705 +188.4999999999936 0 2.120790310624482e-05 -13323005636.0357 +188.5999999999936 0 -0.0001502817057428274 -13351277535.40773 +188.6999999999936 0 0.000155111676690467 -13379594434.2975 +188.7999999999936 0 0.0001432782156062379 -13407956380.42476 +188.8999999999936 0 0 -13436363421.53452 +188.9999999999935 0 0 -13464815605.39718 +189.0999999999935 0 -2.82113932428274e-05 -13493312979.80837 +189.1999999999935 0 4.558919598218227e-05 -13521855592.58913 +189.2999999999935 0 -7.648111651781947e-05 -13550443491.5858 +189.3999999999935 0 3.304136419046699e-05 -13579076724.67005 +189.4999999999935 0 -0.0001502817057428274 -13607755339.73884 +189.5999999999935 0 -6.050278284717991e-05 -13636479384.71448 +189.6999999999935 0 -1.760586917498586e-05 -13665248907.54462 +189.7999999999935 0 4.558919598218227e-05 -13694063956.20222 +189.8999999999935 0 -2.82113932428274e-05 -13722924578.68555 +189.9999999999935 0 3.304136419046699e-05 -13751830823.0182 +190.0999999999935 0 0 -13780782737.24913 +190.1999999999935 0 0 -13809780369.45257 +190.2999999999935 0 -2.82113932428274e-05 -13838823767.7281 +190.3999999999935 0 -1.760586917498586e-05 -13867912980.20063 +190.4999999999935 0 2.120790310624482e-05 -13897048055.02036 +190.5999999999935 0 -1.760586917498586e-05 -13926229040.36286 +190.6999999999935 0 -8.371939429707709e-06 -13955455984.42896 +190.7999999999934 0 -1.760586917498586e-05 -13984728935.44486 +190.8999999999934 0 4.929887495563889e-05 -14014047941.66208 +190.9999999999934 0 0 -14043413051.35746 +191.0999999999934 0 4.558919598218227e-05 -14072824312.83314 +191.1999999999934 0 -1.760586917498586e-05 -14102281774.41661 +191.2999999999934 0 -1.760586917498586e-05 -14131785484.46064 +191.3999999999934 0 0 -14161335491.34337 +191.4999999999934 0 -0.0001008624093937482 -14190931843.46825 +191.5999999999934 0 0 -14220574589.26402 +191.6999999999934 0 6.065943733091217e-05 -14250263777.18476 +191.7999999999934 0 -2.82113932428274e-05 -14279999455.70991 +191.8999999999934 0 0 -14309781673.34416 +191.9999999999934 0 0 -14339610478.61755 +192.0999999999934 0 0 -14369485920.08548 +192.1999999999934 0 3.304136419046699e-05 -14399408046.3286 +192.2999999999934 0 -1.760586917498586e-05 -14429376905.95294 +192.3999999999934 0 0 -14459392547.5898 +192.4999999999933 0 -2.82113932428274e-05 -14489455019.89586 +192.5999999999933 0 4.929887495563889e-05 -14519564371.55307 +192.6999999999933 0 3.304136419046699e-05 -14549720651.26871 +192.7999999999933 0 -2.82113932428274e-05 -14579923907.77539 +192.8999999999933 0 -1.760586917498586e-05 -14610174189.83104 +192.9999999999933 0 1.164981699730561e-05 -14640471546.21888 +193.0999999999933 0 3.304136419046699e-05 -14670816025.74751 +193.1999999999933 0 3.304136419046699e-05 -14701207677.25078 +193.2999999999933 0 3.304136419046699e-05 -14731646549.5879 +193.3999999999933 0 3.304136419046699e-05 -14762132691.64341 +193.4999999999933 0 -2.82113932428274e-05 -14792666152.32711 +193.5999999999933 0 -2.82113932428274e-05 -14823246980.57418 +193.6999999999933 0 0 -14853875225.3451 +193.7999999999933 0 1.164981699730561e-05 -14884550935.62566 +193.8999999999933 0 3.304136419046699e-05 -14915274160.42696 +193.9999999999933 0 3.304136419046699e-05 -14946044948.78544 +194.0999999999933 0 3.304136419046699e-05 -14976863349.76284 +194.1999999999933 0 0 -15007729412.44624 +194.2999999999932 0 0 -15038643185.948 +194.3999999999932 0 -1.760586917498586e-05 -15069604719.40584 +194.4999999999932 0 3.304136419046699e-05 -15100614061.98277 +194.5999999999932 0 -1.760586917498586e-05 -15131671262.86712 +194.6999999999932 0 -2.82113932428274e-05 -15162776371.27256 +194.7999999999932 0 -1.760586917498586e-05 -15193929436.43804 +194.8999999999932 0 -1.760586917498586e-05 -15225130507.62786 +194.9999999999932 0 3.304136419046699e-05 -15256379634.13162 +195.0999999999932 0 3.304136419046699e-05 -15287676865.26425 +195.1999999999932 0 0 -15319022250.36595 +195.2999999999932 0 3.304136419046699e-05 -15350415838.80232 +195.3999999999932 0 -1.760586917498586e-05 -15381857679.96421 +195.4999999999932 0 3.304136419046699e-05 -15413347823.26779 +195.5999999999932 0 -1.760586917498586e-05 -15444886318.15459 +195.6999999999932 0 -1.760586917498586e-05 -15476473214.09144 +195.7999999999932 0 -1.760586917498586e-05 -15508108560.57044 +195.8999999999932 0 3.304136419046699e-05 -15539792407.10903 +195.9999999999932 0 3.304136419046699e-05 -15571524803.25003 +196.0999999999931 0 2.16262068041817e-05 -15603305798.56148 +196.1999999999931 0 -1.760586917498586e-05 -15635135442.63679 +196.2999999999931 0 -2.82113932428274e-05 -15667013785.09469 +196.3999999999931 0 0 -15698940875.57918 +196.4999999999931 0 3.304136419046699e-05 -15730916763.75962 +196.5999999999931 0 3.304136419046699e-05 -15762941499.33066 +196.6999999999931 0 0 -15795015132.01229 +196.7999999999931 0 3.304136419046699e-05 -15827137711.5498 +196.8999999999931 0 -1.760586917498586e-05 -15859309287.71377 +196.9999999999931 0 0 -15891529910.30014 +197.0999999999931 0 3.304136419046699e-05 -15923799629.13014 +197.1999999999931 0 0 -15956118494.05033 +197.2999999999931 0 3.304136419046699e-05 -15988486554.93255 +197.3999999999931 0 3.304136419046699e-05 -16020903861.67401 +197.4999999999931 0 -2.82113932428274e-05 -16053370464.19717 +197.5999999999931 0 0 -16085886412.44985 +197.6999999999931 0 0 -16118451756.40516 +197.799999999993 0 -1.760586917498586e-05 -16151066546.06156 +197.899999999993 0 0 -16183730831.44278 +197.999999999993 0 0 -16216444662.59787 +198.099999999993 0 0 -16249208089.60124 +198.199999999993 0 0 -16282021162.55256 +198.299999999993 0 3.304136419046699e-05 -16314883931.57683 +198.399999999993 0 0 -16347796446.82438 +198.499999999993 0 3.304136419046699e-05 -16380758758.47084 +198.599999999993 0 0 -16413770916.71715 +198.699999999993 0 -1.760586917498586e-05 -16446832971.78957 +198.799999999993 0 0 -16479944973.93965 +198.899999999993 0 -1.760586917498586e-05 -16513106973.44432 +198.999999999993 0 3.304136419046699e-05 -16546319020.60573 +199.099999999993 0 0 -16579581165.75142 +199.199999999993 0 0 -16612893459.23421 +199.299999999993 0 -1.760586917498586e-05 -16646255951.43222 +199.399999999993 0 3.304136419046699e-05 -16679668692.74891 +199.499999999993 0 0 -16713131733.61304 +199.5999999999929 0 0 -16746645124.47867 +199.6999999999929 0 0 -16780208915.82522 +199.7999999999929 0 -1.760586917498586e-05 -16813823158.15736 +199.8999999999929 0 -1.760586917498586e-05 -16847487902.00512 +199.9999999999929 0 3.304136419046699e-05 -16881203197.9238 +200.0999999999929 0 3.304136419046699e-05 -16914969096.49406 +200.1999999999929 0 3.304136419046699e-05 -16948785648.32184 +200.2999999999929 0 0 -16982652904.03838 +200.3999999999929 0 0 -17016570914.30028 +200.4999999999929 0 -1.760586917498586e-05 -17050539729.78941 +200.5999999999929 0 -1.760586917498586e-05 -17084559401.21297 +200.6999999999929 0 -1.760586917498586e-05 -17118629979.30346 +200.7999999999929 0 -2.82113932428274e-05 -17152751514.8187 +200.8999999999929 0 0 -17186924058.54183 +200.9999999999929 0 0 -17221147661.2813 +201.0999999999929 0 0 -17255422373.87083 +201.1999999999929 0 2.16262068041817e-05 -17289748247.1695 +201.2999999999928 0 0 -17324125332.0617 +201.3999999999928 0 2.120790310624482e-05 -17358553679.45711 +201.4999999999928 0 -3.602311323697149e-05 -17393033340.29073 +201.5999999999928 0 0 -17427564365.52287 +201.6999999999928 0 2.120790310624482e-05 -17462146806.13912 +201.7999999999928 0 2.120790310624482e-05 -17496780713.15045 +201.8999999999928 0 -2.82113932428274e-05 -17531466137.5931 +201.9999999999928 0 2.16262068041817e-05 -17566203130.5286 +202.0999999999928 0 2.120790310624482e-05 -17600991743.04385 +202.1999999999928 0 0 -17635832026.25098 +202.2999999999928 0 0 -17670724031.28749 +202.3999999999928 0 2.16262068041817e-05 -17705667809.31621 +202.4999999999928 0 -2.82113932428274e-05 -17740663411.52522 +202.5999999999928 0 0 -17775710889.12792 +202.6999999999928 0 0 -17810810293.36306 +202.7999999999928 0 0 -17845961675.49467 +202.8999999999928 0 0 -17881165086.8121 +202.9999999999928 0 -2.82113932428274e-05 -17916420578.63001 +203.0999999999927 0 0 -17951728202.28836 +203.1999999999927 0 -2.422934555066855e-05 -17987088009.15245 +203.2999999999927 0 0 -18022500050.61283 +203.3999999999927 0 0 -18057964378.08543 +203.4999999999927 0 0 -18093481043.01145 +203.5999999999927 0 -3.726453792296525e-05 -18129050096.8574 +203.6999999999927 0 -3.089946568471369e-05 -18164671591.11512 +203.7999999999927 0 0 -18200345577.30173 +203.8999999999927 0 2.120790310624482e-05 -18236072106.95969 +203.9999999999927 0 0 -18271851231.65675 +204.0999999999927 0 -2.82113932428274e-05 -18307683002.98598 +204.1999999999927 0 0 -18343567472.56577 +204.2999999999927 0 0 -18379504692.03977 +204.3999999999927 0 -2.82113932428274e-05 -18415494713.07699 +204.4999999999927 0 0 -18451537587.37175 +204.5999999999927 0 2.16262068041817e-05 -18487633366.64365 +204.6999999999927 0 -2.879255448617196e-05 -18523782102.63758 +204.7999999999927 0 0 -18559983847.12383 +204.8999999999926 0 -2.82113932428274e-05 -18596238651.8979 +204.9999999999926 0 -3.726453792296525e-05 -18632546568.78065 +205.0999999999926 0 -3.726453792296525e-05 -18668907649.61824 +205.1999999999926 0 -2.82113932428274e-05 -18705321946.28212 +205.2999999999926 0 2.16262068041817e-05 -18741789510.66909 +205.3999999999926 0 2.120790310624482e-05 -18778310394.70122 +205.4999999999926 0 2.16262068041817e-05 -18814884650.3259 +205.5999999999926 0 -3.602311323697149e-05 -18851512329.51584 +205.6999999999926 0 -8.371939429707709e-06 -18888193484.26906 +205.7999999999926 0 0 -18924928166.60885 +205.8999999999926 0 0 -18961716428.58385 +205.9999999999926 0 -6.350740884939615e-05 -18998558322.26802 +206.0999999999926 0 -3.726453792296525e-05 -19035453899.76056 +206.1999999999926 0 2.16262068041817e-05 -19072403213.18608 +206.2999999999926 0 -3.726453792296525e-05 -19109406314.69437 +206.3999999999926 0 -3.726453792296525e-05 -19146463256.46064 +206.4999999999926 0 -2.422934555066855e-05 -19183574090.68538 +206.5999999999925 0 0 -19220738869.59434 +206.6999999999925 0 2.16262068041817e-05 -19257957645.43864 +206.7999999999925 0 0 -19295230470.49467 +206.8999999999925 0 0 -19332557397.06415 +206.9999999999925 0 0 -19369938477.47408 +207.0999999999925 0 -3.726453792296525e-05 -19407373764.07681 +207.1999999999925 0 -2.879255448617196e-05 -19444863309.24994 +207.2999999999925 0 -3.726453792296525e-05 -19482407165.39645 +207.3999999999925 0 0 -19520005384.94454 +207.4999999999925 0 -2.82113932428274e-05 -19557658020.34781 +207.5999999999925 0 0 -19595365124.08513 +207.6999999999925 0 2.120790310624482e-05 -19633126748.66063 +207.7999999999925 0 0 -19670942946.6038 +207.8999999999925 0 0 -19708813770.46945 +207.9999999999925 0 -2.82113932428274e-05 -19746739272.83767 +208.0999999999925 0 -2.82113932428274e-05 -19784719506.31382 +208.1999999999925 0 -3.602311323697149e-05 -19822754523.5287 +208.2999999999925 0 0 -19860844377.13823 +208.3999999999924 0 0 -19898989119.82377 +208.4999999999924 0 -3.726453792296525e-05 -19937188804.29196 +208.5999999999924 0 2.16262068041817e-05 -19975443483.27475 +208.6999999999924 0 2.16262068041817e-05 -20013753209.52936 +208.7999999999924 0 -3.602311323697149e-05 -20052118035.83833 +208.8999999999924 0 3.304136419046699e-05 -20090538015.00956 +208.9999999999924 0 0 -20129013199.87621 +209.0999999999924 0 -3.602311323697149e-05 -20167543643.29671 +209.1999999999924 0 0 -20206129398.15488 +209.2999999999924 0 2.16262068041817e-05 -20244770517.35982 +209.3999999999924 0 0 -20283467053.84589 +209.4999999999924 0 2.120790310624482e-05 -20322219060.57282 +209.5999999999924 0 -3.726453792296525e-05 -20361026590.52558 +209.6999999999924 0 -2.82113932428274e-05 -20399889696.71451 +209.7999999999924 0 0 -20438808432.17527 +209.8999999999924 0 0 -20477782849.96869 +209.9999999999924 0 -2.82113932428274e-05 -20516813003.18111 +210.0999999999923 0 -2.82113932428274e-05 -20555898944.92402 +210.1999999999923 0 2.16262068041817e-05 -20595040728.33424 +210.2999999999923 0 0 -20634238406.57399 +210.3999999999923 0 2.120790310624482e-05 -20673492032.83066 +210.4999999999923 0 0 -20712801660.3171 +210.5999999999923 0 0 -20752167342.27133 +210.6999999999923 0 -2.82113932428274e-05 -20791589131.95672 +210.7999999999923 0 0 -20831067082.66198 +210.8999999999923 0 0 -20870601247.70111 +210.9999999999923 0 -2.82113932428274e-05 -20910191680.41338 +211.0999999999923 0 -2.82113932428274e-05 -20949838434.16343 +211.1999999999923 0 0 -20989541562.34115 +211.2999999999923 0 0 -21029301118.36176 +211.3999999999923 0 0 -21069117155.66576 +211.4999999999923 0 0 -21108989727.71904 +211.5999999999923 0 0 -21148918888.0127 +211.6999999999923 0 -2.82113932428274e-05 -21188904690.06316 +211.7999999999923 0 0 -21228947187.41219 +211.8999999999922 0 0 -21269046433.62687 +211.9999999999922 0 0 -21309202482.2995 +212.0999999999922 0 -2.82113932428274e-05 -21349415387.04778 +212.1999999999922 0 2.120790310624482e-05 -21389685201.51467 +212.2999999999922 0 -2.82113932428274e-05 -21430011979.36847 +212.3999999999922 0 0 -21470395774.30274 +212.4999999999922 0 -3.602311323697149e-05 -21510836640.03635 +212.5999999999922 0 2.120790310624482e-05 -21551334630.31355 +212.6999999999922 0 -3.602311323697149e-05 -21591889798.9038 +212.7999999999922 0 2.16262068041817e-05 -21632502199.60189 +212.8999999999922 0 2.120790310624482e-05 -21673171886.22797 +212.9999999999922 0 2.120790310624482e-05 -21713898912.62742 +213.0999999999922 0 2.16262068041817e-05 -21754683332.671 +213.1999999999922 0 0 -21795525200.25471 +213.2999999999922 0 0 -21836424569.29987 +213.3999999999922 0 2.16262068041817e-05 -21877381493.75316 +213.4999999999922 0 0 -21918396027.58646 +213.5999999999921 0 2.120790310624482e-05 -21959468224.79709 +213.6999999999921 0 0 -22000598139.40756 +213.7999999999921 0 0 -22041785825.46571 +213.8999999999921 0 -3.602311323697149e-05 -22083031337.04475 +213.9999999999921 0 2.16262068041817e-05 -22124334728.24314 +214.0999999999921 0 0 -22165696053.18464 +214.1999999999921 0 0 -22207115366.01835 +214.2999999999921 0 -3.602311323697149e-05 -22248592720.91862 +214.3999999999921 0 -4.860028911934933e-05 -22290128172.08513 +214.4999999999921 0 -2.82113932428274e-05 -22331721773.74295 +214.5999999999921 0 0 -22373373580.14229 +214.6999999999921 0 -3.726453792296525e-05 -22415083645.55884 +214.7999999999921 0 0 -22456852024.29345 +214.8999999999921 0 2.16262068041817e-05 -22498678770.67233 +214.9999999999921 0 0 -22540563939.04702 +215.0999999999921 0 2.120790310624482e-05 -22582507583.79436 +215.1999999999921 0 2.120790310624482e-05 -22624509759.31647 +215.2999999999921 0 0 -22666570520.04075 +215.399999999992 0 -2.82113932428274e-05 -22708689920.41999 +215.499999999992 0 -8.371939429707709e-06 -22750868014.93218 +215.599999999992 0 0 -22793104858.08071 +215.699999999992 0 0 -22835400504.39419 +215.799999999992 0 2.16262068041817e-05 -22877755008.42663 +215.899999999992 0 0 -22920168424.75729 +215.999999999992 0 0 -22962640807.99066 +216.099999999992 0 2.16262068041817e-05 -23005172212.75671 +216.199999999992 0 -3.602311323697149e-05 -23047762693.71055 +216.299999999992 0 0 -23090412305.53267 +216.399999999992 0 -3.602311323697149e-05 -23133121102.92885 +216.499999999992 0 -3.726453792296525e-05 -23175889140.63021 +216.599999999992 0 0 -23218716473.39312 +216.699999999992 0 -2.82113932428274e-05 -23261603155.99928 +216.799999999992 0 0 -23304549243.25567 +216.899999999992 0 0 -23347554789.99465 +216.999999999992 0 3.304136419046699e-05 -23390619851.07378 +217.099999999992 0 -2.82113932428274e-05 -23433744481.37603 +217.1999999999919 0 -3.602311323697149e-05 -23476928735.80953 +217.2999999999919 0 -2.82113932428274e-05 -23520172669.3079 +217.3999999999919 0 -3.602311323697149e-05 -23563476336.82991 +217.4999999999919 0 -2.82113932428274e-05 -23606839793.3597 +217.5999999999919 0 2.120790310624482e-05 -23650263093.90671 +217.6999999999919 0 0 -23693746293.50567 +217.7999999999919 0 3.304136419046699e-05 -23737289447.21664 +217.8999999999919 0 2.120790310624482e-05 -23780892610.12497 +217.9999999999919 0 2.120790310624482e-05 -23824555837.34133 +218.0999999999919 0 -2.82113932428274e-05 -23868279184.00161 +218.1999999999919 0 -2.82113932428274e-05 -23912062705.26712 +218.2999999999919 0 0 -23955906456.32441 +218.3999999999919 0 -2.82113932428274e-05 -23999810492.38537 +218.4999999999919 0 -2.82113932428274e-05 -24043774868.68715 +218.5999999999919 0 -2.82113932428274e-05 -24087799640.49223 +218.6999999999919 0 2.120790310624482e-05 -24131884863.08836 +218.7999999999919 0 2.16262068041817e-05 -24176030591.78869 +218.8999999999918 0 0 -24220236881.93155 +218.9999999999918 0 -2.82113932428274e-05 -24264503788.88066 +219.0999999999918 0 -2.82113932428274e-05 -24308831368.02497 +219.1999999999918 0 2.120790310624482e-05 -24353219674.77886 +219.2999999999918 0 0 -24397668764.58186 +219.3999999999918 0 2.16262068041817e-05 -24442178692.89893 +219.4999999999918 0 -2.82113932428274e-05 -24486749515.22021 +219.5999999999918 0 -2.82113932428274e-05 -24531381287.06128 +219.6999999999918 0 0 -24576074063.96292 +219.7999999999918 0 2.120790310624482e-05 -24620827901.49129 +219.8999999999918 0 2.120790310624482e-05 -24665642855.23774 +219.9999999999918 0 -2.422934555066855e-05 -24710518980.81909 +220.0999999999918 0 2.16262068041817e-05 -24755456333.8773 +220.1999999999918 0 2.16262068041817e-05 -24800454970.0797 +220.2999999999918 0 2.16262068041817e-05 -24845514945.11899 +220.3999999999918 0 2.120790310624482e-05 -24890636314.7131 +220.4999999999918 0 0 -24935819134.6052 +220.5999999999918 0 -3.602311323697149e-05 -24981063460.56391 +220.6999999999917 0 2.120790310624482e-05 -25026369348.38308 +220.7999999999917 0 2.16262068041817e-05 -25071736853.88184 +220.8999999999917 0 -3.602311323697149e-05 -25117166032.90465 +220.9999999999917 0 2.16262068041817e-05 -25162656941.32129 +221.0999999999917 0 2.120790310624482e-05 -25208209635.02682 +221.1999999999917 0 -3.602311323697149e-05 -25253824169.94157 +221.2999999999917 0 -2.82113932428274e-05 -25299500602.01125 +221.3999999999917 0 0 -25345238987.20686 +221.4999999999917 0 2.16262068041817e-05 -25391039381.5246 +221.5999999999917 0 0 -25436901840.98613 +221.6999999999917 0 -2.82113932428274e-05 -25482826421.63831 +221.7999999999917 0 -3.602311323697149e-05 -25528813179.5533 +221.8999999999917 0 -2.82113932428274e-05 -25574862170.82861 +221.9999999999917 0 0 -25620973451.58703 +222.0999999999917 0 -2.82113932428274e-05 -25667147077.97669 +222.1999999999917 0 -2.82113932428274e-05 -25713383106.17095 +222.2999999999917 0 0 -25759681592.3685 +222.3999999999916 0 0 -25806042592.79338 +222.4999999999916 0 -2.82113932428274e-05 -25852466163.69492 +222.5999999999916 0 -2.82113932428274e-05 -25898952361.34767 +222.6999999999916 0 -2.82113932428274e-05 -25945501242.05161 +222.7999999999916 0 0 -25992112862.13189 +222.8999999999916 0 1.164981699730561e-05 -26038787277.93909 +222.9999999999916 0 0 -26085524545.849 +223.0999999999916 0 -2.82113932428274e-05 -26132324722.26273 +223.1999999999916 0 0 -26179187863.60678 +223.2999999999916 0 -2.82113932428274e-05 -26226114026.33281 +223.3999999999916 0 0 -26273103266.9179 +223.4999999999916 0 -2.82113932428274e-05 -26320155641.86438 +223.5999999999916 0 -2.82113932428274e-05 -26367271207.69987 +223.6999999999916 0 2.16262068041817e-05 -26414450020.97735 +223.7999999999916 0 2.16262068041817e-05 -26461692138.27501 +223.8999999999916 0 0 -26508997616.19646 +223.9999999999916 0 0 -26556366511.37053 +224.0999999999916 0 0 -26603798880.45134 +224.1999999999915 0 0 -26651294780.11841 +224.2999999999915 0 0 -26698854267.07647 +224.3999999999915 0 0 -26746477398.05556 +224.4999999999915 0 2.16262068041817e-05 -26794164229.81105 +224.5999999999915 0 -3.602311323697149e-05 -26841914819.12368 +224.6999999999915 0 0 -26889729222.7993 +224.7999999999915 0 1.164981699730561e-05 -26937607497.66932 +224.8999999999915 0 -3.602311323697149e-05 -26985549700.59019 +224.9999999999915 0 3.304136419046699e-05 -27033555888.44387 +225.0999999999915 0 2.120790310624482e-05 -27081626118.13749 +225.1999999999915 0 2.120790310624482e-05 -27129760446.60357 +225.2999999999915 0 2.120790310624482e-05 -27177958930.7999 +225.3999999999915 0 0 -27226221627.70952 +225.4999999999915 0 0 -27274548594.34085 +225.5999999999915 0 0 -27322939887.72758 +225.6999999999915 0 2.16262068041817e-05 -27371395564.92876 +225.7999999999915 0 2.120790310624482e-05 -27419915683.0286 +225.8999999999915 0 -8.371939429707709e-06 -27468500299.13673 +225.9999999999914 0 -2.82113932428274e-05 -27517149470.38809 +226.0999999999914 0 0 -27565863253.94283 +226.1999999999914 0 -2.82113932428274e-05 -27614641706.98651 +226.2999999999914 0 0 -27663484886.7299 +226.3999999999914 0 0 -27712392850.40912 +226.4999999999914 0 0 -27761365655.28558 +226.5999999999914 0 -3.602311323697149e-05 -27810403358.64604 +226.6999999999914 0 -2.422934555066855e-05 -27859506017.80247 +226.7999999999914 0 2.120790310624482e-05 -27908673690.09223 +226.8999999999914 0 0 -27957906432.87789 +226.9999999999914 0 2.120790310624482e-05 -28007204303.5474 +227.0999999999914 0 0 -28056567359.514 +227.1999999999914 0 2.16262068041817e-05 -28105995658.21624 +227.2999999999914 0 2.16262068041817e-05 -28155489257.11792 +227.3999999999914 0 3.304136419046699e-05 -28205048213.70815 +227.4999999999914 0 2.120790310624482e-05 -28254672585.50143 +227.5999999999914 0 -2.82113932428274e-05 -28304362430.03744 +227.6999999999913 0 0 -28354117804.88126 +227.7999999999913 0 2.120790310624482e-05 -28403938767.62321 +227.8999999999913 0 3.618893908969092e-05 -28453825375.87895 +227.9999999999913 0 0 -28503777687.28942 +228.0999999999913 0 2.120790310624482e-05 -28553795759.52087 +228.1999999999913 0 0 -28603879650.26487 +228.2999999999913 0 2.16262068041817e-05 -28654029417.2382 +228.3999999999913 0 0 -28704245118.18312 +228.4999999999913 0 2.120790310624482e-05 -28754526810.86703 +228.5999999999913 0 0 -28804874553.08266 +228.6999999999913 0 2.16262068041817e-05 -28855288402.64814 +228.7999999999913 0 0 -28905768417.40676 +228.8999999999913 0 0 -28956314655.22726 +228.9999999999913 0 0 -29006927174.00354 +229.0999999999913 0 -2.82113932428274e-05 -29057606031.65491 +229.1999999999913 0 -2.82113932428274e-05 -29108351286.12591 +229.2999999999913 0 0 -29159162995.38646 +229.3999999999913 0 2.120790310624482e-05 -29210041217.43167 +229.4999999999912 0 2.120790310624482e-05 -29260986010.28205 +229.5999999999912 0 -1.760586917498586e-05 -29311997431.98342 +229.6999999999912 0 -3.089946568471369e-05 -29363075540.6068 +229.7999999999912 0 0 -29414220394.24855 +229.8999999999912 0 -2.82113932428274e-05 -29465432051.03041 +229.9999999999912 0 0 -29516710569.09938 +230.0999999999912 0 0 -29568056006.62767 +230.1999999999912 0 0 -29619468421.81293 +230.2999999999912 0 2.16262068041817e-05 -29670947872.87803 +230.3999999999912 0 -2.82113932428274e-05 -29722494418.07114 +230.4999999999912 0 0 -29774108115.6658 +230.5999999999912 0 0 -29825789023.96077 +230.6999999999912 0 0 -29877537201.28017 +230.7999999999912 0 -2.82113932428274e-05 -29929352705.97337 +230.8999999999912 0 2.16262068041817e-05 -29981235596.41507 +230.9999999999912 0 -3.726453792296525e-05 -30033185931.00531 +231.0999999999912 0 0 -30085203768.16939 +231.1999999999911 0 2.16262068041817e-05 -30137289166.35783 +231.2999999999911 0 -3.089946568471369e-05 -30189442184.04669 +231.3999999999911 0 2.120790310624482e-05 -30241662879.73703 +231.4999999999911 0 0 -30293951311.95544 +231.5999999999911 0 -2.879255448617196e-05 -30346307539.25372 +231.6999999999911 0 -2.82113932428274e-05 -30398731620.20895 +231.7999999999911 0 0 -30451223613.42356 +231.8999999999911 0 2.16262068041817e-05 -30503783577.52531 +231.9999999999911 0 0 -30556411571.16717 +232.0999999999911 0 0 -30609107653.02745 +232.1999999999911 0 0 -30661871881.80979 +232.2999999999911 0 0 -30714704316.24313 +232.3999999999911 0 0 -30767605015.08167 +232.4999999999911 0 0 -30820574037.10495 +232.5999999999911 0 -3.726453792296525e-05 -30873611441.11779 +232.6999999999911 0 0 -30926717285.95029 +232.7999999999911 0 0 -30979891630.45789 +232.8999999999911 0 2.120790310624482e-05 -31033134533.52137 +232.999999999991 0 -2.82113932428274e-05 -31086446054.04672 +233.099999999991 0 0 -31139826250.96525 +233.199999999991 0 0 -31193275183.23365 +233.299999999991 0 2.16262068041817e-05 -31246792909.83382 +233.399999999991 0 -3.602311323697149e-05 -31300379489.77299 +233.499999999991 0 0 -31354034982.08373 +233.599999999991 0 2.120790310624482e-05 -31407759445.82384 +233.699999999991 0 2.120790310624482e-05 -31461552940.07649 +233.799999999991 0 2.120790310624482e-05 -31515415523.95015 +233.899999999991 0 0 -31569347256.57849 +233.999999999991 0 3.304136419046699e-05 -31623348197.12059 +234.099999999991 0 -2.82113932428274e-05 -31677418404.76081 +234.199999999991 0 0 -31731557938.70879 +234.299999999991 0 0 -31785766858.19947 +234.399999999991 0 2.16262068041817e-05 -31840045222.49311 +234.499999999991 0 2.16262068041817e-05 -31894393090.87528 +234.599999999991 0 2.120790310624482e-05 -31948810522.65678 +234.699999999991 0 -2.82113932428274e-05 -32003297577.17378 +234.7999999999909 0 0 -32057854313.78777 +234.8999999999909 0 0 -32112480791.88549 +234.9999999999909 0 2.120790310624482e-05 -32167177070.87894 +235.0999999999909 0 2.16262068041817e-05 -32221943210.20559 +235.1999999999909 0 2.120790310624482e-05 -32276779269.328 +235.2999999999909 0 0 -32331685307.73416 +235.3999999999909 0 -2.82113932428274e-05 -32386661384.93736 +235.4999999999909 0 2.120790310624482e-05 -32441707560.4761 +235.5999999999909 0 2.16262068041817e-05 -32496823893.91432 +235.6999999999909 0 2.120790310624482e-05 -32552010444.84115 +235.7999999999909 0 2.16262068041817e-05 -32607267272.87104 +235.8999999999909 0 2.16262068041817e-05 -32662594437.64374 +235.9999999999909 0 0 -32717991998.82439 +236.0999999999909 0 2.120790310624482e-05 -32773460016.10329 +236.1999999999909 0 0 -32828998549.19614 +236.2999999999909 0 2.120790310624482e-05 -32884607657.84393 +236.3999999999909 0 0 -32940287401.8129 +236.4999999999908 0 -3.726453792296525e-05 -32996037840.89463 +236.5999999999908 0 0 -33051859034.90598 +236.6999999999908 0 0 -33107751043.68915 +236.7999999999908 0 0 -33163713927.11159 +236.8999999999908 0 2.120790310624482e-05 -33219747745.06611 +236.9999999999908 0 2.16262068041817e-05 -33275852557.47076 +237.0999999999908 0 0 -33332028424.26894 +237.1999999999908 0 -2.82113932428274e-05 -33388275405.42933 +237.2999999999908 0 2.16262068041817e-05 -33444593560.94587 +237.3999999999908 0 0 -33500982950.83788 +237.4999999999908 0 3.618893908969092e-05 -33557443635.14993 +237.5999999999908 0 2.120790310624482e-05 -33613975673.95192 +237.6999999999908 0 2.120790310624482e-05 -33670579127.33901 +237.7999999999908 0 0 -33727254055.43168 +237.8999999999908 0 2.16262068041817e-05 -33784000518.37574 +237.9999999999908 0 2.16262068041817e-05 -33840818576.34227 +238.0999999999908 0 0 -33897708289.52766 +238.1999999999908 0 0 -33954669718.15357 +238.2999999999907 0 3.304136419046699e-05 -34011702922.46702 +238.3999999999907 0 0 -34068807962.74029 +238.4999999999907 0 -1.760586917498586e-05 -34125984899.271 +238.5999999999907 0 2.16262068041817e-05 -34183233792.38197 +238.6999999999907 0 0 -34240554702.42146 +238.7999999999907 0 2.16262068041817e-05 -34297947689.76291 +238.8999999999907 0 0 -34355412814.80515 +238.9999999999907 0 0 -34412950137.97229 +239.0999999999907 0 3.304136419046699e-05 -34470559719.71368 +239.1999999999907 0 0 -34528241620.50406 +239.2999999999907 0 0 -34585995900.84339 +239.3999999999907 0 0 -34643822621.25697 +239.4999999999907 0 0 -34701721842.29542 +239.5999999999907 0 3.304136419046699e-05 -34759693624.53461 +239.6999999999907 0 0 -34817738028.57579 +239.7999999999907 0 0 -34875855115.0454 +239.8999999999907 0 3.304136419046699e-05 -34934044944.59528 +239.9999999999906 0 -3.089946568471369e-05 -34992307577.90255 +240.0999999999906 0 0 -35050643075.66953 +240.1999999999906 0 -3.089946568471369e-05 -35109051498.624 +240.2999999999906 0 -3.577881284400064e-05 -35167532907.51894 +240.3999999999906 0 -4.337890641974151e-05 -35226087363.13265 +240.4999999999906 0 0 -35284714926.26875 +240.5999999999906 0 0 -35343415657.75613 +240.6999999999906 0 0 -35402189618.449 +240.7999999999906 0 0 -35461036869.22684 +240.8999999999906 0 0 -35519957470.99451 +240.9999999999906 0 0 -35578951484.68209 +241.0999999999906 0 -1.760586917498586e-05 -35638018971.24499 +241.1999999999906 0 0 -35697159991.6639 +241.2999999999906 0 3.304136419046699e-05 -35756374606.94485 +241.3999999999906 0 3.304136419046699e-05 -35815662878.11917 +241.4999999999906 0 0 -35875024866.24342 +241.5999999999906 0 0 -35934460632.39957 +241.6999999999906 0 0 -35993970237.69478 +241.7999999999905 0 3.304136419046699e-05 -36053553743.26158 +241.8999999999905 0 0 -36113211210.25782 +241.9999999999905 0 0 -36172942699.86653 +242.0999999999905 0 -1.760586917498586e-05 -36232748273.29621 +242.1999999999905 0 0 -36292627991.78051 +242.2999999999905 0 3.304136419046699e-05 -36352581916.57848 +242.3999999999905 0 -3.089946568471369e-05 -36412610108.97443 +242.4999999999905 0 -3.089946568471369e-05 -36472712630.27798 +242.5999999999905 0 3.304136419046699e-05 -36532889541.82401 +242.6999999999905 0 0 -36593140904.9728 +242.7999999999905 0 0 -36653466781.10979 +242.8999999999905 0 0 -36713867231.64589 +242.9999999999905 0 3.304136419046699e-05 -36774342318.01712 +243.0999999999905 0 0 -36834892101.68495 +243.1999999999905 0 0 -36895516644.13611 +243.2999999999905 0 0 -36956216006.88259 +243.3999999999905 0 0 -37016990251.46174 +243.4999999999905 0 0 -37077839439.43614 +243.5999999999904 0 0 -37138763632.39375 +243.6999999999904 0 3.304136419046699e-05 -37199762891.94775 +243.7999999999904 0 3.304136419046699e-05 -37260837279.73669 +243.8999999999904 0 0 -37321986857.42439 +243.9999999999904 0 -3.089946568471369e-05 -37383211686.69995 +244.0999999999904 0 1.164981699730561e-05 -37444511829.27785 +244.1999999999904 0 0 -37505887346.8977 +244.2999999999904 0 -3.089946568471369e-05 -37567338301.32465 +244.3999999999904 0 0 -37628864754.34895 +244.4999999999904 0 0 -37690466767.78622 +244.5999999999904 0 0 -37752144403.47739 +244.6999999999904 0 -3.089946568471369e-05 -37813897723.28871 +244.7999999999904 0 -1.760586917498586e-05 -37875726789.11172 +244.8999999999904 0 0 -37937631662.86317 +244.9999999999904 0 3.304136419046699e-05 -37999612406.48525 +245.0999999999904 0 0 -38061669081.94534 +245.1999999999904 0 -3.089946568471369e-05 -38123801751.23624 +245.2999999999903 0 0 -38186010476.37585 +245.3999999999903 0 0 -38248295319.40764 +245.4999999999903 0 3.304136419046699e-05 -38310656342.40013 +245.5999999999903 0 0 -38373093607.44728 +245.6999999999903 0 0 -38435607176.66831 +245.7999999999903 0 0 -38498197112.20779 +245.8999999999903 0 0 -38560863476.23547 +245.9999999999903 0 0 -38623606330.94653 +246.0999999999903 0 -3.089946568471369e-05 -38686425738.56139 +246.1999999999903 0 0 -38749321761.32578 +246.2999999999903 0 3.304136419046699e-05 -38812294461.51071 +246.3999999999903 0 0 -38875343901.41251 +246.4999999999903 0 0 -38938470143.35282 +246.5999999999903 0 -3.089946568471369e-05 -39001673249.67859 +246.6999999999903 0 0 -39064953282.76202 +246.7999999999903 0 3.304136419046699e-05 -39128310305.0006 +246.8999999999903 0 0 -39191744378.81722 +246.9999999999903 0 3.304136419046699e-05 -39255255566.66001 +247.0999999999902 0 0 -39318843931.00234 +247.1999999999902 0 0 -39382509534.34303 +247.2999999999902 0 3.304136419046699e-05 -39446252439.20601 +247.3999999999902 0 0 -39510072708.14069 +247.4999999999902 0 0 -39573970403.72163 +247.5999999999902 0 0 -39637945588.54882 +247.6999999999902 0 0 -39701998325.24746 +247.7999999999902 0 -1.760586917498586e-05 -39766128676.46803 +247.8999999999902 0 0 -39830336704.88648 +247.9999999999902 0 0 -39894622473.20387 +248.0999999999902 0 0 -39958986044.14662 +248.1999999999902 0 0 -40023427480.46642 +248.2999999999902 0 0 -40087946844.94041 +248.3999999999902 0 -3.089946568471369e-05 -40152544200.37087 +248.4999999999902 0 0 -40217219609.5854 +248.5999999999902 0 0 -40281973135.43697 +248.6999999999902 0 0 -40346804840.80378 +248.7999999999901 0 0 -40411714788.58937 +248.8999999999901 0 0 -40476703041.72257 +248.9999999999901 0 -3.370423928572563e-05 -40541769663.15757 +249.0999999999901 0 -3.089946568471369e-05 -40606914715.87371 +249.1999999999901 0 0 -40672138262.87573 +249.2999999999901 0 0 -40737440367.19372 +249.3999999999901 0 -3.577881284400064e-05 -40802821091.88294 +249.4999999999901 0 0 -40868280500.02406 +249.5999999999901 0 0 -40933818654.72305 +249.6999999999901 0 0 -40999435619.11107 +249.7999999999901 0 0 -41065131456.34469 +249.8999999999901 0 0 -41130906229.60576 +249.9999999999901 0 -3.726453792296525e-05 -41196760002.10133 +250.0999999999901 0 0 -41262692837.06386 +250.1999999999901 0 0 -41328704797.75112 +250.2999999999901 0 -3.370423928572563e-05 -41394795947.44617 +250.3999999999901 0 -3.089946568471369e-05 -41460966349.45724 +250.4999999999901 0 3.304136419046699e-05 -41527216067.11796 +250.59999999999 0 0 -41593545163.78738 +250.69999999999 0 0 -41659953702.84968 +250.79999999999 0 3.304136419046699e-05 -41726441747.71432 +250.89999999999 0 3.304136419046699e-05 -41793009361.81618 +250.99999999999 0 3.304136419046699e-05 -41859656608.6154 +251.09999999999 0 0 -41926383551.59739 +251.19999999999 0 0 -41993190254.27292 +251.29999999999 0 0 -42060076780.17797 +251.39999999999 0 3.304136419046699e-05 -42127043192.87384 +251.49999999999 0 -3.726453792296525e-05 -42194089555.94726 +251.59999999999 0 0 -42261215933.01009 +251.69999999999 0 0 -42328422387.69953 +251.79999999999 0 0 -42395708983.67821 +251.89999999999 0 0 -42463075784.63388 +251.99999999999 0 0 -42530522854.2797 +252.09999999999 0 0 -42598050256.35407 +252.19999999999 0 0 -42665658054.62074 +252.29999999999 0 0 -42733346312.86871 +252.3999999999899 0 3.304136419046699e-05 -42801115094.91241 +252.4999999999899 0 -4.337890641974151e-05 -42868964464.59126 +252.5999999999899 0 3.304136419046699e-05 -42936894485.7704 +252.6999999999899 0 0 -43004905222.33997 +252.7999999999899 0 0 -43072996738.21546 +252.8999999999899 0 0 -43141169097.33781 +252.9999999999899 0 0 -43209422363.67297 +253.0999999999899 0 -3.726453792296525e-05 -43277756601.21257 +253.1999999999899 0 0 -43346171873.97318 +253.2999999999899 0 -1.760586917498586e-05 -43414668245.99686 +253.3999999999899 0 0 -43483245781.35097 +253.4999999999899 0 -2.879255448617196e-05 -43551904544.12817 +253.5999999999899 0 3.304136419046699e-05 -43620644598.44631 +253.6999999999899 0 0 -43689466008.44864 +253.7999999999899 0 0 -43758368838.30373 +253.8999999999899 0 -3.089946568471369e-05 -43827353152.20531 +253.9999999999899 0 3.304136419046699e-05 -43896419014.37253 +254.0999999999898 0 3.304136419046699e-05 -43965566489.04993 +254.1999999999898 0 0 -44034795640.50707 +254.2999999999898 0 3.304136419046699e-05 -44104106533.03907 +254.3999999999898 0 0 -44173499230.96627 +254.4999999999898 0 3.304136419046699e-05 -44242973798.63421 +254.5999999999898 0 3.304136419046699e-05 -44312530300.41387 +254.6999999999898 0 0 -44382168800.70152 +254.7999999999898 0 0 -44451889363.91856 +254.8999999999898 0 3.304136419046699e-05 -44521692054.5119 +254.9999999999898 0 0 -44591576936.95361 +255.0999999999898 0 -3.089946568471369e-05 -44661544075.74113 +255.1999999999898 0 0 -44731593535.39724 +255.2999999999898 0 0 -44801725380.46992 +255.3999999999898 0 0 -44871939675.53242 +255.4999999999898 0 0 -44942236485.18343 +255.5999999999898 0 0 -45012615874.04689 +255.6999999999898 0 3.304136419046699e-05 -45083077906.77202 +255.7999999999898 0 0 -45153622648.03328 +255.8999999999897 0 0 -45224250162.53049 +255.9999999999897 0 -4.337890641974151e-05 -45294960514.98882 +256.0999999999897 0 0 -45365753770.15869 +256.1999999999898 0 0 -45436629992.8158 +256.2999999999898 0 0 -45507589247.76115 +256.3999999999898 0 0 -45578631599.82107 +256.4999999999898 0 0 -45649757113.84717 +256.5999999999898 0 0 -45720965854.71637 +256.6999999999899 0 0 -45792257887.33091 +256.7999999999899 0 0 -45863633276.61827 +256.8999999999899 0 -3.089946568471369e-05 -45935092087.53128 +256.9999999999899 0 -2.82113932428274e-05 -46006634385.0481 +257.09999999999 0 -3.089946568471369e-05 -46078260234.17204 +257.19999999999 0 0 -46149969699.93186 +257.29999999999 0 0 -46221762847.38165 +257.39999999999 0 3.304136419046699e-05 -46293639741.60065 +257.4999999999901 0 0 -46365600447.69347 +257.5999999999901 0 0 -46437645030.79 +257.6999999999901 0 -3.577881284400064e-05 -46509773556.04552 +257.7999999999901 0 0 -46581986088.64046 +257.8999999999901 0 0 -46654282693.78074 +257.9999999999902 0 0 -46726663436.69741 +258.0999999999902 0 0 -46799128382.64689 +258.1999999999902 0 3.304136419046699e-05 -46871677596.91083 +258.2999999999902 0 3.304136419046699e-05 -46944311144.79633 +258.3999999999903 0 3.304136419046699e-05 -47017029091.6357 +258.4999999999903 0 3.304136419046699e-05 -47089831502.78649 +258.5999999999903 0 2.16262068041817e-05 -47162718443.63158 +258.6999999999903 0 0 -47235689979.57922 +258.7999999999903 0 0 -47308746176.06297 +258.8999999999904 0 0 -47381887098.54162 +258.9999999999904 0 0 -47455112812.49915 +259.0999999999904 0 -3.089946568471369e-05 -47528423383.44512 +259.1999999999904 0 0 -47601818876.91422 +259.2999999999905 0 -3.089946568471369e-05 -47675299358.46633 +259.3999999999905 0 0 -47748864893.68688 +259.4999999999905 0 3.304136419046699e-05 -47822515548.18648 +259.5999999999905 0 0 -47896251387.60091 +259.6999999999906 0 0 -47970072477.59148 +259.7999999999906 0 0 -48043978883.84465 +259.8999999999906 0 2.120790310624482e-05 -48117970672.07224 +259.9999999999906 0 3.304136419046699e-05 -48192047908.01137 +260.0999999999906 0 0 -48266210657.42435 +260.1999999999907 0 0 -48340458986.099 +260.2999999999907 0 -3.089946568471369e-05 -48414792959.84827 +260.3999999999907 0 0 -48489212644.51041 +260.4999999999907 0 3.304136419046699e-05 -48563718105.94916 +260.5999999999908 0 0 -48638309410.05322 +260.6999999999908 0 -3.370423928572563e-05 -48712986622.73698 +260.7999999999908 0 -2.82113932428274e-05 -48787749809.93974 +260.8999999999908 0 0 -48862599037.6265 +260.9999999999908 0 -3.089946568471369e-05 -48937534371.78722 +261.0999999999909 0 -3.089946568471369e-05 -49012555878.4374 +261.1999999999909 0 0 -49087663623.61761 +261.2999999999909 0 0 -49162857673.39393 +261.3999999999909 0 0 -49238138093.85763 +261.499999999991 0 0 -49313504951.1253 +261.599999999991 0 0 -49388958311.33885 +261.699999999991 0 0 -49464498240.66547 +261.799999999991 0 0 -49540124805.29763 +261.8999999999911 0 0 -49615838071.45316 +261.9999999999911 0 0 -49691638105.37514 +262.0999999999911 0 3.304136419046699e-05 -49767524973.33189 +262.1999999999911 0 -3.370423928572563e-05 -49843498741.6172 +262.2999999999911 0 3.304136419046699e-05 -49919559476.55003 +262.3999999999912 0 0 -49995707244.47457 +262.4999999999912 0 0 -50071942111.76058 +262.5999999999912 0 0 -50148264144.8028 +262.6999999999912 0 0 -50224673410.02151 +262.7999999999913 0 3.304136419046699e-05 -50301169973.86214 +262.8999999999913 0 0 -50377753902.79555 +262.9999999999913 0 0 -50454425263.31773 +263.0999999999913 0 0 -50531184121.9501 +263.1999999999913 0 0 -50608030545.23936 +263.2999999999914 0 0 -50684964599.75748 +263.3999999999914 0 3.304136419046699e-05 -50761986352.10176 +263.4999999999914 0 0 -50839095868.8948 +263.5999999999914 0 0 -50916293216.78441 +263.6999999999915 0 0 -50993578462.44382 +263.7999999999915 0 3.304136419046699e-05 -51070951672.57145 +263.8999999999915 0 0 -51148412913.89114 +263.9999999999915 0 3.304136419046699e-05 -51225962253.15204 +264.0999999999916 0 0 -51303599757.12837 +264.1999999999916 0 3.304136419046699e-05 -51381325492.61988 +264.2999999999916 0 3.304136419046699e-05 -51459139526.45158 +264.3999999999916 0 0 -51537041925.47367 +264.4999999999916 0 0 -51615032756.56186 +264.5999999999917 0 3.304136419046699e-05 -51693112086.61684 +264.6999999999917 0 -3.089946568471369e-05 -51771279982.56492 +264.7999999999917 0 0 -51849536511.35754 +264.8999999999917 0 0 -51927881739.97142 +264.9999999999918 0 0 -52006315735.40878 +265.0999999999918 0 0 -52084838564.69682 +265.1999999999918 0 0 -52163450294.88826 +265.2999999999918 0 3.304136419046699e-05 -52242150993.0611 +265.3999999999918 0 0 -52320940726.31861 +265.4999999999919 0 0 -52399819561.78931 +265.5999999999919 0 0 -52478787566.62716 +265.6999999999919 0 0 -52557844808.01125 +265.7999999999919 0 0 -52636991353.14606 +265.899999999992 0 0 -52716227269.26132 +265.999999999992 0 -1.760586917498586e-05 -52795552623.61221 +266.099999999992 0 0 -52874967483.47903 +266.199999999992 0 0 -52954471916.1674 +266.2999999999921 0 0 -53034065989.00831 +266.3999999999921 0 0 -53113749769.35805 +266.4999999999921 0 -3.370423928572563e-05 -53193523324.59815 +266.5999999999921 0 0 -53273386722.13547 +266.6999999999921 0 -1.760586917498586e-05 -53353340029.40221 +266.7999999999922 0 3.304136419046699e-05 -53433383313.8558 +266.8999999999922 0 0 -53513516642.979 +266.9999999999922 0 0 -53593740084.27988 +267.0999999999922 0 0 -53674053705.29175 +267.1999999999923 0 3.304136419046699e-05 -53754457573.57339 +267.2999999999923 0 0 -53834951756.70861 +267.3999999999923 0 3.304136419046699e-05 -53915536322.30669 +267.4999999999923 0 0 -53996211338.00229 +267.5999999999923 0 3.304136419046699e-05 -54076976871.45509 +267.6999999999924 0 3.304136419046699e-05 -54157832990.35043 +267.7999999999924 0 0 -54238779762.39864 +267.8999999999924 0 3.304136419046699e-05 -54319817255.33552 +267.9999999999924 0 -2.82113932428274e-05 -54400945536.92213 +268.0999999999925 0 0 -54482164674.94477 +268.1999999999925 0 0 -54563474737.21508 +268.2999999999925 0 0 -54644875791.57014 +268.3999999999925 0 -3.089946568471369e-05 -54726367905.87197 +268.4999999999926 0 -3.089946568471369e-05 -54807951148.00832 +268.5999999999926 0 0 -54889625585.89201 +268.6999999999926 0 0 -54971391287.46104 +268.7999999999926 0 -1.760586917498586e-05 -55053248320.679 +268.8999999999926 0 0 -55135196753.53456 +268.9999999999927 0 -2.428729716004441e-05 -55217236654.04181 +269.0999999999927 0 0 -55299368090.24004 +269.1999999999927 0 0 -55381591130.19397 +269.2999999999927 0 -2.879255448617196e-05 -55463905841.99345 +269.3999999999928 0 0 -55546312293.75379 +269.4999999999928 0 0 -55628810553.61549 +269.5999999999928 0 0 -55711400689.74438 +269.6999999999928 0 0 -55794082770.33162 +269.7999999999928 0 0 -55876856863.59357 +269.8999999999929 0 0 -55959723037.77213 +269.9999999999929 0 3.304136419046699e-05 -56042681361.1342 +270.0999999999929 0 0 -56125731901.97218 +270.1999999999929 0 0 -56208874728.60361 +270.299999999993 0 0 -56292109909.37154 +270.399999999993 0 0 -56375437512.64409 +270.499999999993 0 0 -56458857606.81493 +270.599999999993 0 -1.760586917498586e-05 -56542370260.30273 +270.6999999999931 0 0 -56625975541.55176 +270.7999999999931 0 0 -56709673519.03132 +270.8999999999931 0 0 -56793464261.23628 +270.9999999999931 0 0 -56877347836.6865 +271.0999999999931 0 3.304136419046699e-05 -56961324313.92741 +271.1999999999932 0 3.304136419046699e-05 -57045393761.52966 +271.2999999999932 0 0 -57129556248.08904 +271.3999999999932 0 0 -57213811842.22696 +271.4999999999932 0 3.304136419046699e-05 -57298160612.58978 +271.5999999999933 0 0 -57382602627.84945 +271.6999999999933 0 0 -57467137956.70296 +271.7999999999933 0 -3.089946568471369e-05 -57551766667.87281 +271.8999999999933 0 0 -57636488830.10675 +271.9999999999933 0 -1.760586917498586e-05 -57721304512.1777 +272.0999999999934 0 3.304136419046699e-05 -57806213782.884 +272.1999999999934 0 0 -57891216711.04932 +272.2999999999934 0 3.304136419046699e-05 -57976313365.52259 +272.3999999999934 0 0 -58061503815.17793 +272.4999999999935 0 0 -58146788128.91492 +272.5999999999935 0 0 -58232166375.65837 +272.6999999999935 0 0 -58317638624.35834 +272.7999999999935 0 0 -58403204943.9903 +272.8999999999936 0 0 -58488865403.55493 +272.9999999999936 0 3.304136419046699e-05 -58574620072.07824 +273.0999999999936 0 0 -58660469018.61158 +273.1999999999936 0 0 -58746412312.23145 +273.2999999999936 0 3.304136419046699e-05 -58832450022.03989 +273.3999999999937 0 3.304136419046699e-05 -58918582217.16401 +273.4999999999937 0 0 -59004808966.75638 +273.5999999999937 0 0 -59091130339.99474 +273.6999999999937 0 0 -59177546406.08218 +273.7999999999938 0 0 -59264057234.24723 +273.8999999999938 0 0 -59350662893.74348 +273.9999999999938 0 3.304136419046699e-05 -59437363453.84991 +274.0999999999938 0 0 -59524158983.87083 +274.1999999999938 0 0 -59611049553.13595 +274.2999999999939 0 0 -59698035231.00002 +274.3999999999939 0 -3.577881284400064e-05 -59785116086.84336 +274.4999999999939 0 3.304136419046699e-05 -59872292190.07137 +274.5999999999939 0 0 -59959563610.11488 +274.699999999994 0 0 -60046930416.42999 +274.799999999994 0 3.304136419046699e-05 -60134392678.4981 +274.899999999994 0 0 -60221950465.82587 +274.999999999994 0 0 -60309603847.9453 +275.0999999999941 0 0 -60397352894.41373 +275.1999999999941 0 -3.089946568471369e-05 -60485197674.81368 +275.2999999999941 0 4.558919598218227e-05 -60573138258.75305 +275.3999999999941 0 0 -60661174715.86504 +275.4999999999941 0 0 -60749307115.80813 +275.5999999999942 0 0 -60837535528.26612 +275.6999999999942 0 -1.760586917498586e-05 -60925860022.94807 +275.7999999999942 0 3.304136419046699e-05 -61014280669.58837 +275.8999999999942 0 0 -61102797537.94672 +275.9999999999943 0 0 -61191410697.80805 +276.0999999999943 0 0 -61280120218.98276 +276.1999999999943 0 -1.760586917498586e-05 -61368926171.30628 +276.2999999999943 0 0 -61457828624.6395 +276.3999999999943 0 3.304136419046699e-05 -61546827648.86874 +276.4999999999944 0 -8.371939429707709e-06 -61635923313.90538 +276.5999999999944 0 0 -61725115689.68614 +276.6999999999944 0 0 -61814404846.17323 +276.7999999999944 0 0 -61903790853.35392 +276.8999999999945 0 0 -61993273781.24089 +276.9999999999945 0 0 -62082853699.87212 +277.0999999999945 0 0 -62172530679.31089 +277.1999999999945 0 3.304136419046699e-05 -62262304789.64581 +277.2999999999946 0 0 -62352176100.9907 +277.3999999999946 0 0 -62442144683.4847 +277.4999999999946 0 0 -62532210607.29234 +277.5999999999946 0 0 -62622373942.60337 +277.6999999999946 0 0 -62712634759.63283 +277.7999999999947 0 0 -62802993128.62104 +277.8999999999947 0 3.304136419046699e-05 -62893449119.83374 +277.9999999999947 0 0 -62984002803.56192 +278.0999999999947 0 3.304136419046699e-05 -63074654250.12173 +278.1999999999948 0 -1.760586917498586e-05 -63165403529.85476 +278.2999999999948 0 -3.089946568471369e-05 -63256250713.12791 +278.3999999999948 0 0 -63347195870.33334 +278.4999999999948 0 0 -63438239071.88853 +278.5999999999948 0 0 -63529380388.23615 +278.6999999999949 0 2.120790310624482e-05 -63620619889.8443 +278.7999999999949 0 0 -63711957647.2063 +278.8999999999949 0 0 -63803393730.84079 +278.9999999999949 0 0 -63894928211.29183 +279.099999999995 0 0 -63986561159.12859 +279.199999999995 0 3.304136419046699e-05 -64078292644.94563 +279.299999999995 0 -3.089946568471369e-05 -64170122739.3628 +279.399999999995 0 0 -64262051513.02523 +279.4999999999951 0 0 -64354079036.60339 +279.5999999999951 0 -3.089946568471369e-05 -64446205380.79298 +279.6999999999951 0 0 -64538430616.31509 +279.7999999999951 0 -4.337890641974151e-05 -64630754813.91603 +279.8999999999951 0 0 -64723178044.36754 +279.9999999999952 0 3.304136419046699e-05 -64815700378.46643 +280.0999999999952 0 0 -64908321887.03499 +280.1999999999952 0 3.304136419046699e-05 -65001042640.92071 +280.2999999999952 0 0 -65093862710.99657 +280.3999999999953 0 0 -65186782168.16054 +280.4999999999953 0 0 -65279801083.33616 +280.5999999999953 0 0 -65372919527.47211 +280.6999999999953 0 0 -65466137571.54248 +280.7999999999954 0 0 -65559455286.54657 +280.8999999999954 0 3.304136419046699e-05 -65652872743.50896 +280.9999999999954 0 0 -65746390013.47968 +281.0999999999954 0 3.304136419046699e-05 -65840007167.53389 +281.1999999999954 0 2.16262068041817e-05 -65933724276.77212 +281.2999999999955 0 0 -66027541412.32026 +281.3999999999955 0 0 -66121458645.32939 +281.4999999999955 0 0 -66215476046.97584 +281.5999999999955 0 0 -66309593688.46149 +281.6999999999956 0 -2.82113932428274e-05 -66403811641.01328 +281.7999999999956 0 0 -66498129975.88364 +281.8999999999956 0 0 -66592548764.35002 +281.9999999999956 0 0 -66687068077.71536 +282.0999999999956 0 0 -66781687987.30807 +282.1999999999957 0 0 -66876408564.48144 +282.2999999999957 0 0 -66971229880.61444 +282.3999999999957 0 0 -67066152007.11104 +282.4999999999957 0 0 -67161175015.40083 +282.5999999999958 0 0 -67256298976.93842 +282.6999999999958 0 0 -67351523963.2038 +282.7999999999958 0 0 -67446850045.70236 +282.8999999999958 0 0 -67542277295.96461 +282.9999999999959 0 0 -67637805785.54657 +283.0999999999959 0 3.304136419046699e-05 -67733435586.02935 +283.1999999999959 0 3.304136419046699e-05 -67829166769.01946 +283.2999999999959 0 0 -67924999406.1488 +283.3999999999959 0 0 -68020933569.07447 +283.499999999996 0 0 -68116969329.47873 +283.599999999996 0 0 -68213106759.06936 +283.699999999996 0 0 -68309345929.57944 +283.799999999996 0 3.304136419046699e-05 -68405686912.76717 +283.8999999999961 0 0 -68502129780.4162 +283.9999999999961 0 0 -68598674604.33533 +284.0999999999961 0 0 -68695321456.35891 +284.1999999999961 0 0 -68792070408.3463 +284.2999999999961 0 0 -68888921532.18237 +284.3999999999962 0 0 -68985874899.77725 +284.4999999999962 0 0 -69082930583.06625 +284.5999999999962 0 0 -69180088654.01006 +284.6999999999962 0 0 -69277349184.59471 +284.7999999999963 0 0 -69374712246.83147 +284.8999999999963 0 0 -69472177912.75693 +284.9999999999963 0 0 -69569746254.43298 +285.0999999999963 0 0 -69667417343.94681 +285.1999999999964 0 0 -69765191253.41092 +285.2999999999964 0 0 -69863068054.96306 +285.3999999999964 0 0 -69961047820.76631 +285.4999999999964 0 0 -70059130623.00903 +285.5999999999964 0 0 -70157316533.905 +285.6999999999965 0 0 -70255605625.69308 +285.7999999999965 0 0 -70353997970.63756 +285.8999999999965 0 0 -70452493641.02815 +285.9999999999965 0 -1.760586917498586e-05 -70551092709.17958 +286.0999999999966 0 -4.337890641974151e-05 -70649795247.43207 +286.1999999999966 0 -2.82113932428274e-05 -70748601328.15109 +286.2999999999966 0 -4.337890641974151e-05 -70847511023.72742 +286.3999999999966 0 0 -70946524406.57709 +286.4999999999966 0 -3.577881284400064e-05 -71045641549.14153 +286.5999999999967 0 0 -71144862523.88741 +286.6999999999967 0 0 -71244187403.30661 +286.7999999999967 0 0 -71343616259.9165 +286.8999999999967 0 0 -71443149166.25958 +286.9999999999968 0 0 -71542786194.90373 +287.0999999999968 0 0 -71642527418.44211 +287.1999999999968 0 -4.337890641974151e-05 -71742372909.49323 +287.2999999999968 0 0 -71842322740.70079 +287.3999999999969 0 0 -71942376984.73383 +287.4999999999969 0 0 -72042535714.28671 +287.5999999999969 0 0 -72142799002.07919 +287.6999999999969 0 0 -72243166920.85616 +287.7999999999969 0 -4.337890641974151e-05 -72343639543.38779 +287.899999999997 0 0 -72444216942.46974 +287.999999999997 0 0 -72544899190.92285 +288.099999999997 0 0 -72645686361.59322 +288.199999999997 0 0 -72746578527.35236 +288.2999999999971 0 0 -72847575761.09698 +288.3999999999971 0 0 -72948678135.74908 +288.4999999999971 0 0 -73049885724.25613 +288.5999999999971 0 0 -73151198599.59065 +288.6999999999971 0 0 -73252616834.75072 +288.7999999999972 0 3.304136419046699e-05 -73354140502.75945 +288.8999999999972 0 0 -73455769676.66542 +288.9999999999972 0 0 -73557504429.54245 +289.0999999999972 0 0 -73659344834.48978 +289.1999999999973 0 0 -73761290964.63174 +289.2999999999973 0 -1.760586917498586e-05 -73863342893.11807 +289.3999999999973 0 0 -73965500693.12389 +289.4999999999973 0 0 -74067764437.84947 +289.5999999999974 0 -2.82113932428274e-05 -74170134200.52042 +289.6999999999974 0 -4.337890641974151e-05 -74272610054.38776 +289.7999999999974 0 0 -74375192072.72763 +289.8999999999974 0 0 -74477880328.8416 +289.9999999999974 0 0 -74580674896.05647 +290.0999999999975 0 0 -74683575847.72443 +290.1999999999975 0 0 -74786583257.22281 +290.2999999999975 0 -2.82113932428274e-05 -74889697197.95447 +290.3999999999975 0 0 -74992917743.34727 +290.4999999999976 0 0 -75096244966.85468 +290.5999999999976 0 4.558919598218227e-05 -75199678941.95517 +290.6999999999976 0 0 -75303219742.15283 +290.7999999999976 0 0 -75406867440.97678 +290.8999999999976 0 0 -75510622111.98149 +290.9999999999977 0 0 -75614483828.74687 +291.0999999999977 0 0 -75718452664.87799 +291.1999999999977 0 0 -75822528694.00525 +291.2999999999977 0 -4.337890641974151e-05 -75926711989.78442 +291.3999999999978 0 0 -76031002625.89644 +291.4999999999978 0 0 -76135400676.04768 +291.5999999999978 0 0 -76239906213.9697 +291.6999999999978 0 0 -76344519313.4194 +291.7999999999979 0 1.164981699730561e-05 -76449240048.17914 +291.8999999999979 0 0 -76554068492.05614 +291.9999999999979 0 0 -76659004718.88347 +292.0999999999979 0 0 -76764048802.51906 +292.1999999999979 0 0 -76869200816.84639 +292.299999999998 0 0 -76974460835.77422 +292.399999999998 0 -4.860028911934933e-05 -77079828933.23637 +292.499999999998 0 0 -77185305183.19234 +292.599999999998 0 0 -77290889659.62654 +292.6999999999981 0 0 -77396582436.54898 +292.7999999999981 0 0 -77502383587.99481 +292.8999999999981 0 0 -77608293188.0246 +292.9999999999981 0 0 -77714311310.72406 +293.0999999999981 0 0 -77820438030.20428 +293.1999999999982 0 0 -77926673420.60159 +293.2999999999982 0 0 -78033017556.07784 +293.3999999999982 0 0 -78139470510.81995 +293.4999999999982 0 0 -78246032359.04018 +293.5999999999983 0 0 -78352703174.97604 +293.6999999999983 0 0 -78459483032.89066 +293.7999999999983 0 -4.337890641974151e-05 -78566372007.0719 +293.8999999999983 0 -2.82113932428274e-05 -78673370171.8334 +293.9999999999984 0 -4.337890641974151e-05 -78780477601.51399 +294.0999999999984 0 0 -78887694370.47766 +294.1999999999984 0 0 -78995020553.11388 +294.2999999999984 0 0 -79102456223.83716 +294.3999999999984 0 0 -79210001457.08768 +294.4999999999985 0 0 -79317656327.33051 +294.5999999999985 0 0 -79425420909.05638 +294.6999999999985 0 0 -79533295276.78096 +294.7999999999985 0 0 -79641279505.04573 +294.8999999999986 0 0 -79749373668.41687 +294.9999999999986 0 -4.337890641974151e-05 -79857577841.48631 +295.0999999999986 0 -4.337890641974151e-05 -79965892098.87105 +295.1999999999986 0 -4.337890641974151e-05 -80074316515.21353 +295.2999999999986 0 -4.337890641974151e-05 -80182851165.18124 +295.3999999999987 0 0 -80291496123.46739 +295.4999999999987 0 -4.337890641974151e-05 -80400251464.78993 +295.5999999999987 0 0 -80509117263.8927 +295.6999999999987 0 0 -80618093595.54439 +295.7999999999988 0 0 -80727180534.53926 +295.8999999999988 0 0 -80836378155.69667 +295.9999999999988 0 0 -80945686533.86151 +296.0999999999988 0 0 -81055105743.90369 +296.1999999999989 0 0 -81164635860.71851 +296.2999999999989 0 0 -81274276959.22684 +296.3999999999989 0 -1.760586917498586e-05 -81384029114.37447 +296.4999999999989 0 0 -81493892401.13269 +296.5999999999989 0 0 -81603866894.49811 +296.699999999999 0 0 -81713952669.49246 +296.799999999999 0 -8.371939429707709e-06 -81824149801.16283 +296.899999999999 0 0 -81934458364.58188 +296.999999999999 0 -4.337890641974151e-05 -82044878434.8472 +297.0999999999991 0 0 -82155410087.08188 +297.1999999999991 0 0 -82266053396.4342 +297.2999999999991 0 0 -82376808438.0779 +297.3999999999991 0 -4.337890641974151e-05 -82487675287.21172 +297.4999999999991 0 0 -82598654019.06007 +297.5999999999992 0 -4.337890641974151e-05 -82709744708.87259 +297.6999999999992 0 0 -82820947431.92381 +297.7999999999992 0 -4.337890641974151e-05 -82932262263.51408 +297.8999999999992 0 0 -83043689278.96867 +297.9999999999993 0 0 -83155228553.63847 +298.0999999999993 0 0 -83266880162.89934 +298.1999999999993 0 0 -83378644182.15285 +298.2999999999993 0 0 -83490520686.82544 +298.3999999999994 0 0 -83602509752.36902 +298.4999999999994 0 -4.337890641974151e-05 -83714611454.26079 +298.5999999999994 0 0 -83826825868.00339 +298.6999999999994 0 0 -83939153069.12454 +298.7999999999994 0 0 -84051593133.17747 +298.8999999999995 0 0 -84164146135.74054 +298.9999999999995 0 0 -84276812152.41745 +299.0999999999995 0 0 -84389591258.83713 +299.1999999999995 0 0 -84502483530.65393 +299.2999999999996 0 0 -84615489043.5477 +299.3999999999996 0 -2.82113932428274e-05 -84728607873.22296 +299.4999999999996 0 0 -84841840095.41029 +299.5999999999996 0 -4.337890641974151e-05 -84955185785.86487 +299.6999999999996 0 -2.82113932428274e-05 -85068645020.36777 +299.7999999999997 0 0 -85182217874.72488 +299.8999999999997 0 0 -85295904424.76776 +299.9999999999997 0 0 -85409704746.35304 diff --git a/example/example_v3_BP1.tsv b/example/example_v3_BP1.tsv new file mode 100644 index 00000000..001f9530 --- /dev/null +++ b/example/example_v3_BP1.tsv @@ -0,0 +1,2 @@ +yuktype L1 L2 L3 L4 L5 m12sq tbeta +1 6.9309437685026E+00 2.6305141403286E-01 1.2865950045595E+00 4.7721306931875E+00 4.7275722046239E+00 1.8933440789694E+04 1.6577896825228E+01 \ No newline at end of file diff --git a/example/example_v3_BP2.tsv b/example/example_v3_BP2.tsv new file mode 100644 index 00000000..8ba2304a --- /dev/null +++ b/example/example_v3_BP2.tsv @@ -0,0 +1,2 @@ +yuktype L1 L2 L3 L4 L5 m12sq tbeta +1 6.8467197321289E+00 2.5889890874393E-01 1.4661775278406E+00 4.4975594646126E+00 4.4503516057570E+00 6.6299728323804E+03 4.5319927369308E+01 \ No newline at end of file diff --git a/example/example_v3_BP3.tsv b/example/example_v3_BP3.tsv new file mode 100644 index 00000000..058cb01c --- /dev/null +++ b/example/example_v3_BP3.tsv @@ -0,0 +1,2 @@ +v vs va msq lambda delta2 b2 d2 Reb1 Imb1 Rea1 Ima1 +246.21965079413738 0 0 -15650 0.52 0.55 -8859 0.5 0 0 0 0 \ No newline at end of file diff --git a/include/BSMPT/Kfactors/KfactorsinterpolatedGSL.h b/include/BSMPT/Kfactors/KfactorsinterpolatedGSL.h index f0d7a2a7..c802dfdb 100644 --- a/include/BSMPT/Kfactors/KfactorsinterpolatedGSL.h +++ b/include/BSMPT/Kfactors/KfactorsinterpolatedGSL.h @@ -1,5 +1,6 @@ // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -26,6 +27,12 @@ namespace BSMPT namespace Kfactors { +/** + * @brief GSLAcclType Type used by the interpolations of the Kfunctions + */ +using GSLAcclType = + std::unique_ptr; + /** * Calculates the norm for < > Integrals * @param T temperature at which the normalisation should be evaluated diff --git a/include/BSMPT/ThermalFunctions/NegativeBosonSpline.h b/include/BSMPT/ThermalFunctions/NegativeBosonSpline.h index 19c0f18f..98c75061 100644 --- a/include/BSMPT/ThermalFunctions/NegativeBosonSpline.h +++ b/include/BSMPT/ThermalFunctions/NegativeBosonSpline.h @@ -1,5 +1,6 @@ // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -7,6 +8,8 @@ * @file */ +#include + #ifndef INCLUDE_BSMPT_THERMALFUNCTIONS_NEGATIVEBOSONSPLINE_H_ #define INCLUDE_BSMPT_THERMALFUNCTIONS_NEGATIVEBOSONSPLINE_H_ @@ -14,1012 +17,696 @@ * @brief C_NegLine Number of data points used for the interpolation of J_(m^2 < * 0) */ -const int C_NegLine = 3001; +extern const int C_NegLine; /** * @brief NegLinearInt 2D Array containing the pairs (m^2 , J_(m^2)) for m^2 < 0 */ -const double NegLinearInt[3001][2] = { - {-0, -2.164646465}, {-1, -2.818445251}, {-2, -3.222851734}, - {-3, -3.428922383}, {-4, -3.46485227}, {-5, -3.351032801}, - {-6, -3.103759168}, {-7, -2.736807005}, {-8, -2.262259033}, - {-9, -1.690996032}, {-10, -1.03301549}, {-11, -0.2976508055}, - {-12, 0.5062681395}, {-13, 1.370293416}, {-14, 2.286262618}, - {-15, 3.246217947}, {-16, 4.242340858}, {-17, 5.266889167}, - {-18, 6.312140833}, {-19, 7.370343407}, {-20, 8.433656113}, - {-21, 9.494099961}, {-22, 10.54349464}, {-23, 11.57339606}, - {-24, 12.57502367}, {-25, 13.53917411}, {-26, 14.4561211}, - {-27, 15.31549117}, {-28, 16.10611023}, {-29, 16.81580557}, - {-30, 17.43114564}, {-31, 17.93709101}, {-32, 18.3165027}, - {-33, 18.5494288}, {-34, 18.6120242}, {-35, 18.47477715}, - {-36, 18.09940905}, {-37, 17.43269548}, {-38, 16.39161386}, - {-39, 14.81074106}, {-40, 12.16616547}, {-41, 9.29873028}, - {-42, 6.552973907}, {-43, 3.92693942}, {-44, 1.418700787}, - {-45, -0.9736390888}, {-46, -3.25194955}, {-47, -5.418073643}, - {-48, -7.473830411}, {-49, -9.42101465}, {-50, -11.26140026}, - {-51, -12.99673894}, {-52, -14.62876466}, {-53, -16.15919077}, - {-54, -17.58971417}, {-55, -18.92201431}, {-56, -20.15775866}, - {-57, -21.2985937}, {-58, -22.34615666}, {-59, -23.30207115}, - {-60, -24.16794711}, {-61, -24.9453849}, {-62, -25.63597245}, - {-63, -26.24129017}, {-64, -26.7629061}, {-65, -27.20238238}, - {-66, -27.5612719}, {-67, -27.84112113}, {-68, -28.04346941}, - {-69, -28.16989666}, {-70, -28.22179307}, {-71, -28.20082067}, - {-72, -28.1084539}, {-73, -27.94620547}, {-74, -27.71559252}, - {-75, -27.4181245}, {-76, -27.05531078}, {-77, -26.6286592}, - {-78, -26.13967889}, {-79, -25.58987345}, {-80, -24.98075542}, - {-81, -24.31383211}, {-82, -23.59061264}, {-83, -22.812622}, - {-84, -21.98136023}, {-85, -21.09835882}, {-86, -20.1651382}, - {-87, -19.18322992}, {-88, -18.15416871}, {-89, -17.0794957}, - {-90, -15.96076011}, {-91, -14.79951789}, {-92, -13.59733502}, - {-93, -12.35577969}, {-94, -11.07644226}, {-95, -9.760914889}, - {-96, -8.410803442}, {-97, -7.027727211}, {-98, -5.613318217}, - {-99, -4.169222819}, {-100, -2.6971031}, {-101, -1.198637426}, - {-102, 0.3244783383}, {-103, 1.87052959}, {-104, 3.437781698}, - {-105, 5.024479158}, {-106, 6.628843696}, {-107, 8.249072607}, - {-108, 9.883338728}, {-109, 11.52978642}, {-110, 13.18653279}, - {-111, 14.85166411}, {-112, 16.52322793}, {-113, 18.19924795}, - {-114, 19.87770308}, {-115, 21.55654538}, {-116, 23.23364258}, - {-117, 24.9068802}, {-118, 26.57405565}, {-119, 28.23292158}, - {-120, 29.88117974}, {-121, 31.51647083}, {-122, 33.13637388}, - {-123, 34.73839708}, {-124, 36.31997987}, {-125, 37.87848087}, - {-126, 39.41117353}, {-127, 40.91524037}, {-128, 42.38776345}, - {-129, 43.82571787}, {-130, 45.22596257}, {-131, 46.5852188}, - {-132, 47.90008464}, {-133, 49.16698761}, {-134, 50.38219239}, - {-135, 51.54177463}, {-136, 52.64160307}, {-137, 53.67730717}, - {-138, 54.64426543}, {-139, 55.53755859}, {-140, 56.35193276}, - {-141, 57.08175867}, {-142, 57.72097689}, {-143, 58.26301396}, - {-144, 58.70074843}, {-145, 59.02631403}, {-146, 59.2310679}, - {-147, 59.30536241}, {-148, 59.23834431}, {-149, 59.01761897}, - {-150, 58.62890624}, {-151, 58.0553658}, {-152, 57.27674355}, - {-153, 56.26795292}, {-154, 54.99667402}, {-155, 53.41886624}, - {-156, 51.4689278}, {-157, 49.03154963}, {-158, 45.74131965}, - {-159, 41.62616097}, {-160, 37.60001753}, {-161, 33.66226904}, - {-162, 29.81229849}, {-163, 26.04948949}, {-164, 22.37322596}, - {-165, 18.78289423}, {-166, 15.2778806}, {-167, 11.85757254}, - {-168, 8.521358646}, {-169, 5.268628677}, {-170, 2.098771025}, - {-171, -0.9888217056}, {-172, -3.994758482}, {-173, -6.919647137}, - {-174, -9.764094799}, {-175, -12.52870753}, {-176, -15.21409204}, - {-177, -17.8208529}, {-178, -20.34959584}, {-179, -22.80092429}, - {-180, -25.17544509}, {-181, -27.47375948}, {-182, -29.69647001}, - {-183, -31.84418444}, {-184, -33.91750228}, {-185, -35.91702705}, - {-186, -37.84336232}, {-187, -39.69710967}, {-188, -41.4788742}, - {-189, -43.18925487}, {-190, -44.82885751}, {-191, -46.39828413}, - {-192, -47.89813907}, {-193, -49.32902096}, {-194, -50.69153769}, - {-195, -51.98629208}, {-196, -53.21388814}, {-197, -54.37493393}, - {-198, -55.47001943}, {-199, -56.49976731}, {-200, -57.46477608}, - {-201, -58.36565331}, {-202, -59.20300416}, {-203, -59.97743774}, - {-204, -60.68956245}, {-205, -61.33998741}, {-206, -61.92932148}, - {-207, -62.45817595}, {-208, -62.92716413}, {-209, -63.33689482}, - {-210, -63.68798276}, {-211, -63.98104441}, {-212, -64.21669495}, - {-213, -64.39555103}, {-214, -64.51822951}, {-215, -64.58535298}, - {-216, -64.59753934}, {-217, -64.5554102}, {-218, -64.45959239}, - {-219, -64.31071468}, {-220, -64.1093833}, {-221, -63.85627508}, - {-222, -63.55194348}, {-223, -63.1970829}, {-224, -62.7923069}, - {-225, -62.33825326}, {-226, -61.83555593}, {-227, -61.28486033}, - {-228, -60.68681572}, {-229, -60.04202895}, {-230, -59.351185}, - {-231, -58.61491945}, {-232, -57.83387908}, {-233, -57.00872637}, - {-234, -56.1401122}, {-235, -55.22869589}, {-236, -54.27513512}, - {-237, -53.28010662}, {-238, -52.24425275}, {-239, -51.16826426}, - {-240, -50.05280898}, {-241, -48.898567}, {-242, -47.7062091}, - {-243, -46.47642733}, {-244, -45.20990438}, {-245, -43.90733204}, - {-246, -42.56939876}, {-247, -41.19680664}, {-248, -39.79025838}, - {-249, -38.35045814}, {-250, -36.87811613}, {-251, -35.37394688}, - {-252, -33.83866427}, {-253, -32.27300534}, {-254, -30.6776846}, - {-255, -29.0534395}, {-256, -27.40100765}, {-257, -25.72113079}, - {-258, -24.0145619}, {-259, -22.28205072}, {-260, -20.52435702}, - {-261, -18.74224739}, {-262, -16.93649271}, {-263, -15.10787022}, - {-264, -13.257165}, {-265, -11.38516615}, {-266, -9.492672108}, - {-267, -7.580486533}, {-268, -5.649421074}, {-269, -3.700294873}, - {-270, -1.733934573}, {-271, 0.2488251854}, {-272, 2.247141615}, - {-273, 4.26016393}, {-274, 6.287029442}, {-275, 8.326871819}, - {-276, 10.37881165}, {-277, 12.44196055}, {-278, 14.51542024}, - {-279, 16.59827995}, {-280, 18.68962724}, {-281, 20.78853171}, - {-282, 22.89403273}, {-283, 25.00519758}, {-284, 27.12105303}, - {-285, 29.24061844}, {-286, 31.36290686}, {-287, 33.48690659}, - {-288, 35.61160032}, {-289, 37.73594961}, {-290, 39.85890681}, - {-291, 41.97940466}, {-292, 44.09635948}, {-293, 46.20867043}, - {-294, 48.3152183}, {-295, 50.41486595}, {-296, 52.50645607}, - {-297, 54.58881045}, {-298, 56.66072952}, {-299, 58.72099241}, - {-300, 60.76835132}, {-301, 62.80154239}, {-302, 64.81926703}, - {-303, 66.82020342}, {-304, 68.80300087}, {-305, 70.76628208}, - {-306, 72.70863559}, {-307, 74.62861802}, {-308, 76.52475273}, - {-309, 78.3955293}, {-310, 80.23938945}, {-311, 82.05474806}, - {-312, 83.83997123}, {-313, 85.5933769}, {-314, 87.3132406}, - {-315, 88.99778645}, {-316, 90.64534213}, {-317, 92.25354556}, - {-318, 93.82092148}, {-319, 95.34530355}, {-320, 96.82460761}, - {-321, 98.25668011}, {-322, 99.63928571}, {-323, 100.9700982}, - {-324, 102.2467108}, {-325, 103.4666138}, {-326, 104.6271835}, - {-327, 105.7256861}, {-328, 106.7592593}, {-329, 107.7249074}, - {-330, 108.6194617}, {-331, 109.4396211}, {-332, 110.1818781}, - {-333, 110.8425301}, {-334, 111.4176566}, {-335, 111.9030464}, - {-336, 112.2942704}, {-337, 112.5865307}, {-338, 112.7746988}, - {-339, 112.8532075}, {-340, 112.8160325}, {-341, 112.6566117}, - {-342, 112.3676606}, {-343, 111.941254}, {-344, 111.3684424}, - {-345, 110.6391971}, {-346, 109.742102}, {-347, 108.6639828}, - {-348, 107.3894029}, {-349, 105.899891}, {-350, 104.1727853}, - {-351, 102.1792932}, {-352, 99.88103654}, {-353, 97.22297728}, - {-354, 94.11563604}, {-355, 90.36386136}, {-356, 85.47741876}, - {-357, 80.48735678}, {-358, 75.57040959}, {-359, 70.72625364}, - {-360, 65.95456698}, {-361, 61.25504332}, {-362, 56.62734703}, - {-363, 52.07116171}, {-364, 47.58616915}, {-365, 43.17204856}, - {-366, 38.82848554}, {-367, 34.55514173}, {-368, 30.35171395}, - {-369, 26.21787572}, {-370, 22.1533058}, {-371, 18.15768323}, - {-372, 14.23068726}, {-373, 10.3719955}, {-374, 6.581286496}, - {-375, 2.858238737}, {-376, -0.7974700683}, {-377, -4.386162258}, - {-378, -7.908159706}, {-379, -11.36378471}, {-380, -14.75336302}, - {-381, -18.07721479}, {-382, -21.33566515}, {-383, -24.52903606}, - {-384, -27.65765178}, {-385, -30.72183874}, {-386, -33.72191926}, - {-387, -36.65821805}, {-388, -39.53106185}, {-389, -42.34077452}, - {-390, -45.08768278}, {-391, -47.77211105}, {-392, -50.39438818}, - {-393, -52.95483855}, {-394, -55.45379058}, {-395, -57.89157119}, - {-396, -60.26765199}, {-397, -62.58492887}, {-398, -64.84116398}, - {-399, -67.03754064}, {-400, -69.17438956}, {-401, -71.25203951}, - {-402, -73.27082244}, {-403, -75.23106426}, {-404, -77.13310394}, - {-405, -78.97726612}, {-406, -80.76388468}, {-407, -82.49329352}, - {-408, -84.16582446}, {-409, -85.78181453}, {-410, -87.34159197}, - {-411, -88.84549657}, {-412, -90.29385613}, {-413, -91.68701673}, - {-414, -93.02531129}, {-415, -94.30906853}, {-416, -95.53868142}, - {-417, -96.71434184}, {-418, -97.8365373}, {-419, -98.90555203}, - {-420, -99.92172895}, {-421, -100.8854059}, {-422, -101.796931}, - {-423, -102.6566422}, {-424, -103.4648752}, {-425, -104.2219825}, - {-426, -104.9283048}, {-427, -105.5841881}, {-428, -106.1899418}, - {-429, -106.7459687}, {-430, -107.2526463}, {-431, -107.7102377}, - {-432, -108.1191074}, {-433, -108.4796273}, {-434, -108.7921358}, - {-435, -109.0569967}, {-436, -109.2745546}, {-437, -109.4451574}, - {-438, -109.5691641}, {-439, -109.6469286}, {-440, -109.6788053}, - {-441, -109.6651497}, {-442, -109.6063213}, {-443, -109.5026803}, - {-444, -109.3545778}, {-445, -109.1623807}, {-446, -108.9264507}, - {-447, -108.6471437}, {-448, -108.3248336}, {-449, -107.9598773}, - {-450, -107.55264}, {-451, -107.1034909}, {-452, -106.6128004}, - {-453, -106.0809281}, {-454, -105.508239}, {-455, -104.8951326}, - {-456, -104.2419729}, {-457, -103.549115}, {-458, -102.8169437}, - {-459, -102.0458362}, {-460, -101.236169}, {-461, -100.3883224}, - {-462, -99.50267596}, {-463, -98.57961179}, {-464, -97.61951334}, - {-465, -96.62276523}, {-466, -95.58975369}, {-467, -94.52086526}, - {-468, -93.41648822}, {-469, -92.27701535}, {-470, -91.10283866}, - {-471, -89.89435118}, {-472, -88.65194415}, {-473, -87.37602319}, - {-474, -86.0669806}, {-475, -84.72521753}, {-476, -83.35113758}, - {-477, -81.94512955}, {-478, -80.50764168}, {-479, -79.03903968}, - {-480, -77.53974585}, {-481, -76.01017362}, {-482, -74.45073634}, - {-483, -72.86184691}, {-484, -71.24392366}, {-485, -69.59738667}, - {-486, -67.92265761}, {-487, -66.22015714}, {-488, -64.49031423}, - {-489, -62.73355567}, {-490, -60.95031191}, {-491, -59.14101082}, - {-492, -57.30610122}, {-493, -55.44600607}, {-494, -53.56117126}, - {-495, -51.6520359}, {-496, -49.71904761}, {-497, -47.76264925}, - {-498, -45.78329084}, {-499, -43.78144253}, {-500, -41.75754567}, - {-501, -39.71205121}, {-502, -37.64542848}, {-503, -35.55814339}, - {-504, -33.45065782}, {-505, -31.32344348}, {-506, -29.17697623}, - {-507, -27.01173066}, {-508, -24.82818564}, {-509, -22.62682504}, - {-510, -20.40813455}, {-511, -18.17260264}, {-512, -15.92072743}, - {-513, -13.65300059}, {-514, -11.36992453}, {-515, -9.072003103}, - {-516, -6.759744925}, {-517, -4.433661503}, {-518, -2.094269927}, - {-519, 0.2579106075}, {-520, 2.622355361}, {-521, 4.998535467}, - {-522, 7.385918103}, {-523, 9.783965912}, {-524, 12.19213543}, - {-525, 14.60988118}, {-526, 17.03665028}, {-527, 19.47188671}, - {-528, 21.91502796}, {-529, 24.36550783}, {-530, 26.82275312}, - {-531, 29.28618665}, {-532, 31.75522419}, {-533, 34.22927696}, - {-534, 36.70774991}, {-535, 39.19004315}, {-536, 41.6755473}, - {-537, 44.16369492}, {-538, 46.65372975}, {-539, 49.14515663}, - {-540, 51.63730833}, {-541, 54.12953323}, {-542, 56.62118465}, - {-543, 59.11160617}, {-544, 61.60013897}, {-545, 64.08610865}, - {-546, 66.56883634}, {-547, 69.04763149}, {-548, 71.52179836}, - {-549, 73.990633}, {-550, 76.45340531}, {-551, 78.90944296}, - {-552, 81.3579494}, {-553, 83.79821789}, {-554, 86.22947574}, - {-555, 88.65096563}, {-556, 91.06190888}, {-557, 93.46152193}, - {-558, 95.8490015}, {-559, 98.22354329}, {-560, 100.5843038}, - {-561, 102.9304637}, {-562, 105.2611678}, {-563, 107.5755478}, - {-564, 109.8727307}, {-565, 112.1518916}, {-566, 114.4118903}, - {-567, 116.6520352}, {-568, 118.871304}, {-569, 121.0687322}, - {-570, 123.2433433}, {-571, 125.3941369}, {-572, 127.5201043}, - {-573, 129.6201948}, {-574, 131.6933617}, {-575, 133.7384991}, - {-576, 135.7545229}, {-577, 137.7402916}, {-578, 139.6946626}, - {-579, 141.6164409}, {-580, 143.5044193}, {-581, 145.3573626}, - {-582, 147.1739878}, {-583, 148.953004}, {-584, 150.6930752}, - {-585, 152.3928165}, {-586, 154.0508404}, {-587, 155.6656613}, - {-588, 157.2358277}, {-589, 158.759763}, {-590, 160.2359156}, - {-591, 161.6626392}, {-592, 163.0382577}, {-593, 164.3610258}, - {-594, 165.6291329}, {-595, 166.8407206}, {-596, 167.9938579}, - {-597, 169.0865474}, {-598, 170.1167062}, {-599, 171.0821453}, - {-600, 171.9806158}, {-601, 172.8097578}, {-602, 173.5671934}, - {-603, 174.2502585}, {-604, 174.8562788}, {-605, 175.3824448}, - {-606, 175.8257666}, {-607, 176.1831092}, {-608, 176.4511691}, - {-609, 176.6264267}, {-610, 176.7051677}, {-611, 176.683375}, - {-612, 176.5569003}, {-613, 176.3211269}, {-614, 175.9711899}, - {-615, 175.5018004}, {-616, 174.9072308}, {-617, 174.1812105}, - {-618, 173.3168793}, {-619, 172.3066038}, {-620, 171.1420583}, - {-621, 169.813606}, {-622, 168.3105246}, {-623, 166.6204181}, - {-624, 164.7288269}, {-625, 162.6185667}, {-626, 160.2687256}, - {-627, 157.6530621}, {-628, 154.7372046}, {-629, 151.4732557}, - {-630, 147.7873085}, {-631, 143.5393762}, {-632, 138.2360408}, - {-633, 132.441885}, {-634, 126.7114289}, {-635, 121.0444717}, - {-636, 115.4408115}, {-637, 109.9002462}, {-638, 104.4225777}, - {-639, 99.00759058}, {-640, 93.65509865}, {-641, 88.36488441}, - {-642, 83.1367588}, {-643, 77.97050915}, {-644, 72.86593439}, - {-645, 67.82283565}, {-646, 62.84100438}, {-647, 57.92023578}, - {-648, 53.06033077}, {-649, 48.26108296}, {-650, 43.5222796}, - {-651, 38.8437392}, {-652, 34.22523699}, {-653, 29.66657102}, - {-654, 25.16754033}, {-655, 20.72793868}, {-656, 16.3475599}, - {-657, 12.02619906}, {-658, 7.763650659}, {-659, 3.559706711}, - {-660, -0.5858369661}, {-661, -4.673187266}, {-662, -8.702551622}, - {-663, -12.67413585}, {-664, -16.58814766}, {-665, -20.44479467}, - {-666, -24.2442843}, {-667, -27.98682429}, {-668, -31.6726214}, - {-669, -35.3018861}, {-670, -38.8748253}, {-671, -42.39164845}, - {-672, -45.8525651}, {-673, -49.25778122}, {-674, -52.607515}, - {-675, -55.90196413}, {-676, -59.14134737}, {-677, -62.32587076}, - {-678, -65.45574748}, {-679, -68.53118615}, {-680, -71.55240405}, - {-681, -74.51960166}, {-682, -77.43299141}, {-683, -80.29280457}, - {-684, -83.09922926}, {-685, -85.85248932}, {-686, -88.55279751}, - {-687, -91.2003627}, {-688, -93.79540693}, {-689, -96.338133}, - {-690, -98.82875998}, {-691, -101.2675031}, {-692, -103.6545818}, - {-693, -105.9901948}, {-694, -108.2745737}, {-695, -110.5079253}, - {-696, -112.6904724}, {-697, -114.8224226}, {-698, -116.904006}, - {-699, -118.9354227}, {-700, -120.9169049}, {-701, -122.8486601}, - {-702, -124.7309094}, {-703, -126.5638725}, {-704, -128.3477664}, - {-705, -130.0827969}, {-706, -131.7692313}, {-707, -133.4072368}, - {-708, -134.9970533}, {-709, -136.5388804}, {-710, -138.0330027}, - {-711, -139.4795765}, {-712, -140.8788462}, {-713, -142.2310333}, - {-714, -143.5363531}, {-715, -144.795054}, {-716, -146.0073585}, - {-717, -147.1734232}, {-718, -148.2935481}, {-719, -149.3679333}, - {-720, -150.3968089}, {-721, -151.3803812}, {-722, -152.3189025}, - {-723, -153.2125849}, {-724, -154.0616596}, {-725, -154.8663502}, - {-726, -155.6268844}, {-727, -156.343496}, {-728, -157.0164138}, - {-729, -157.6458578}, {-730, -158.2320695}, {-731, -158.7752809}, - {-732, -159.2757013}, {-733, -159.7335856}, {-734, -160.1491574}, - {-735, -160.5225928}, {-736, -160.8542925}, {-737, -161.1443172}, - {-738, -161.392977}, {-739, -161.6004808}, {-740, -161.767081}, - {-741, -161.8930099}, {-742, -161.9784945}, {-743, -162.0238088}, - {-744, -162.0291096}, {-745, -161.9947094}, {-746, -161.9208223}, - {-747, -161.8076858}, {-748, -161.655544}, {-749, -161.4646406}, - {-750, -161.2352}, {-751, -160.9674922}, {-752, -160.661736}, - {-753, -160.318182}, {-754, -159.9370729}, {-755, -159.518656}, - {-756, -159.0631717}, {-757, -158.5708695}, {-758, -158.041995}, - {-759, -157.4767954}, {-760, -156.875518}, {-761, -156.238413}, - {-762, -155.5657275}, {-763, -154.8576883}, {-764, -154.1146146}, - {-765, -153.336698}, {-766, -152.5241939}, {-767, -151.67738}, - {-768, -150.7964936}, {-769, -149.8817944}, {-770, -148.9335339}, - {-771, -147.9519748}, {-772, -146.9373688}, {-773, -145.8899792}, - {-774, -144.8100612}, {-775, -143.6978692}, {-776, -142.5536754}, - {-777, -141.3777291}, {-778, -140.1703002}, {-779, -138.9316525}, - {-780, -137.6620416}, {-781, -136.3617455}, {-782, -135.0310177}, - {-783, -133.6701303}, {-784, -132.2793521}, {-785, -130.8589499}, - {-786, -129.4091947}, {-787, -127.9303533}, {-788, -126.422706}, - {-789, -124.886512}, {-790, -123.3220654}, {-791, -121.7296275}, - {-792, -120.1094645}, {-793, -118.4618712}, {-794, -116.7871174}, - {-795, -115.0854845}, {-796, -113.3572517}, {-797, -111.6027009}, - {-798, -109.8221157}, {-799, -108.0157785}, {-800, -106.1839739}, - {-801, -104.3269442}, {-802, -102.445109}, {-803, -100.5386221}, - {-804, -98.60782736}, {-805, -96.65300338}, {-806, -94.67445177}, - {-807, -92.67246114}, {-808, -90.64732994}, {-809, -88.59934272}, - {-810, -86.52881868}, {-811, -84.43604242}, {-812, -82.32131631}, - {-813, -80.18494279}, {-814, -78.02722712}, {-815, -75.84847195}, - {-816, -73.64898439}, {-817, -71.42907469}, {-818, -69.18904919}, - {-819, -66.92921994}, {-820, -64.64989833}, {-821, -62.35140076}, - {-822, -60.03405448}, {-823, -57.69813983}, {-824, -55.34401429}, - {-825, -52.9719887}, {-826, -50.58237424}, {-827, -48.17550758}, - {-828, -45.75170905}, {-829, -43.31130923}, {-830, -40.85465578}, - {-831, -38.3820222}, {-832, -35.89380027}, {-833, -33.39030718}, - {-834, -30.87188113}, {-835, -28.33885989}, {-836, -25.791586}, - {-837, -23.23040251}, {-838, -20.65565546}, {-839, -18.06769347}, - {-840, -15.46686596}, {-841, -12.85352529}, {-842, -10.22802618}, - {-843, -7.59072556}, {-844, -4.941982726}, {-845, -2.282159}, - {-846, 0.3883812354}, {-847, 3.069271665}, {-848, 5.760141876}, - {-849, 8.460624391}, {-850, 11.17034134}, {-851, 13.8889164}, - {-852, 16.61597088}, {-853, 19.35112082}, {-854, 22.0939838}, - {-855, 24.84417126}, {-856, 27.6012906}, {-857, 30.36494688}, - {-858, 33.13475264}, {-859, 35.91029577}, {-860, 38.69117916}, - {-861, 41.47699621}, {-862, 44.26733722}, {-863, 47.06178917}, - {-864, 49.85993667}, {-865, 52.66135818}, {-866, 55.46563175}, - {-867, 58.2723309}, {-868, 61.08102427}, {-869, 63.8912789}, - {-870, 66.70265436}, {-871, 69.51471154}, {-872, 72.32700257}, - {-873, 75.1390826}, {-874, 77.95048204}, {-875, 80.7607584}, - {-876, 83.56944147}, {-877, 86.3760675}, {-878, 89.18017567}, - {-879, 91.98126002}, {-880, 94.77884082}, {-881, 97.57246115}, - {-882, 100.3616172}, {-883, 103.1458032}, {-884, 105.9245336}, - {-885, 108.6972495}, {-886, 111.4635541}, {-887, 114.2228084}, - {-888, 116.9745432}, {-889, 119.7182234}, {-890, 122.4533029}, - {-891, 125.1792501}, {-892, 127.8955124}, {-893, 130.6015331}, - {-894, 133.2967482}, {-895, 135.9806029}, {-896, 138.6525019}, - {-897, 141.3118561}, {-898, 143.95814}, {-899, 146.5906486}, - {-900, 149.208845}, {-901, 151.8121024}, {-902, 154.3997994}, - {-903, 156.9712964}, {-904, 159.5259653}, {-905, 162.0631293}, - {-906, 164.5821626}, {-907, 167.0823615}, {-908, 169.5630728}, - {-909, 172.0236076}, {-910, 174.4632534}, {-911, 176.8813043}, - {-912, 179.2770371}, {-913, 181.649717}, {-914, 183.998597}, - {-915, 186.32292}, {-916, 188.6219234}, {-917, 190.8947924}, - {-918, 193.1407544}, {-919, 195.359018}, {-920, 197.5486647}, - {-921, 199.7089361}, {-922, 201.838948}, {-923, 203.9378159}, - {-924, 206.0046461}, {-925, 208.0385334}, {-926, 210.0385395}, - {-927, 212.0037157}, {-928, 213.9330909}, {-929, 215.8256767}, - {-930, 217.680437}, {-931, 219.4963597}, {-932, 221.2723751}, - {-933, 223.0073833}, {-934, 224.7002898}, {-935, 226.3499379}, - {-936, 227.955181}, {-937, 229.5147707}, {-938, 231.0275034}, - {-939, 232.4921406}, {-940, 233.9073486}, {-941, 235.2718051}, - {-942, 236.5840914}, {-943, 237.8428376}, {-944, 239.0465633}, - {-945, 240.1937945}, {-946, 241.2828728}, {-947, 242.3122776}, - {-948, 243.280354}, {-949, 244.1853667}, {-950, 245.0254509}, - {-951, 245.7988519}, {-952, 246.5036069}, {-953, 247.1377368}, - {-954, 247.6991856}, {-955, 248.1856749}, {-956, 248.5950514}, - {-957, 248.9249178}, {-958, 249.1728039}, {-959, 249.3360923}, - {-960, 249.4120835}, {-961, 249.3978903}, {-962, 249.2904901}, - {-963, 249.0866837}, {-964, 248.7831043}, {-965, 248.3761291}, - {-966, 247.8619404}, {-967, 247.2364286}, {-968, 246.4952529}, - {-969, 245.6335903}, {-970, 244.6464415}, {-971, 243.5282542}, - {-972, 242.2729229}, {-973, 240.8740198}, {-974, 239.3240711}, - {-975, 237.6150244}, {-976, 235.7377827}, {-977, 233.6820431}, - {-978, 231.4360144}, {-979, 228.9860151}, {-980, 226.3157532}, - {-981, 223.4057407}, {-982, 220.2316214}, {-983, 216.7619707}, - {-984, 212.9539453}, {-985, 208.7438151}, {-986, 204.0204357}, - {-987, 198.4513863}, {-988, 191.9539737}, {-989, 185.5137361}, - {-990, 179.1305231}, {-991, 172.8042021}, {-992, 166.5346253}, - {-993, 160.3216539}, {-994, 154.1651419}, {-995, 148.0649452}, - {-996, 142.0209294}, {-997, 136.0329471}, {-998, 130.1008566}, - {-999, 124.2245131}, {-1000, 118.4037775}, {-1001, 112.6384919}, - {-1002, 106.9285437}, {-1003, 101.2737464}, {-1004, 95.6740208}, - {-1005, 90.12915306}, {-1006, 84.63903621}, {-1007, 79.20352156}, - {-1008, 73.82246536}, {-1009, 68.49571524}, {-1010, 63.22313572}, - {-1011, 58.00458209}, {-1012, 52.83990248}, {-1013, 47.72895845}, - {-1014, 42.67160661}, {-1015, 37.6676933}, {-1016, 32.71707993}, - {-1017, 27.81962091}, {-1018, 22.9751687}, {-1019, 18.183578}, - {-1020, 13.44470329}, {-1021, 8.758398453}, {-1022, 4.124517212}, - {-1023, -0.4570867577}, {-1024, -4.98655971}, {-1025, -9.464049237}, - {-1026, -13.88970118}, {-1027, -18.26366921}, {-1028, -22.58608181}, - {-1029, -26.85710322}, {-1030, -31.07687981}, {-1031, -35.24555423}, - {-1032, -39.36327722}, {-1033, -43.43019288}, {-1034, -47.44645359}, - {-1035, -51.41220714}, {-1036, -55.32760085}, {-1037, -59.19278346}, - {-1038, -63.00790389}, {-1039, -66.77311384}, {-1040, -70.4885606}, - {-1041, -74.15438858}, {-1042, -77.77075557}, {-1043, -81.3378101}, - {-1044, -84.85569342}, {-1045, -88.32456929}, {-1046, -91.74457185}, - {-1047, -95.11587655}, {-1048, -98.43861292}, {-1049, -101.7129364}, - {-1050, -104.9389982}, {-1051, -108.116953}, {-1052, -111.2469519}, - {-1053, -114.3291443}, {-1054, -117.3636835}, {-1055, -120.350731}, - {-1056, -123.2904136}, {-1057, -126.1829069}, {-1058, -129.0283102}, - {-1059, -131.8269205}, {-1060, -134.5787455}, {-1061, -137.2839921}, - {-1062, -139.9428011}, {-1063, -142.5553393}, {-1064, -145.1217586}, - {-1065, -147.6422077}, {-1066, -150.1168478}, {-1067, -152.5458297}, - {-1068, -154.929308}, {-1069, -157.2674421}, {-1070, -159.560384}, - {-1071, -161.8082911}, {-1072, -164.0113173}, {-1073, -166.1696455}, - {-1074, -168.2833633}, {-1075, -170.3526893}, {-1076, -172.3777703}, - {-1077, -174.3587452}, {-1078, -176.2957964}, {-1079, -178.1890627}, - {-1080, -180.0387032}, {-1081, -181.8448841}, {-1082, -183.6077636}, - {-1083, -185.3274889}, {-1084, -187.0042315}, {-1085, -188.6381461}, - {-1086, -190.2293938}, {-1087, -191.7781326}, {-1088, -193.2845233}, - {-1089, -194.7487256}, {-1090, -196.1709107}, {-1091, -197.5512218}, - {-1092, -198.8898335}, {-1093, -200.1869004}, {-1094, -201.4425888}, - {-1095, -202.6570529}, {-1096, -203.830468}, {-1097, -204.9629868}, - {-1098, -206.0547771}, {-1099, -207.1060004}, {-1100, -208.1168254}, - {-1101, -209.0874043}, {-1102, -210.0179099}, {-1103, -210.9084808}, - {-1104, -211.7593594}, {-1105, -212.57063}, {-1106, -213.342491}, - {-1107, -214.0750995}, {-1108, -214.7686313}, {-1109, -215.4232422}, - {-1110, -216.0391073}, {-1111, -216.6163907}, {-1112, -217.1552598}, - {-1113, -217.6558809}, {-1114, -218.1184298}, {-1115, -218.5430666}, - {-1116, -218.9299641}, {-1117, -219.2792899}, {-1118, -219.5912079}, - {-1119, -219.8659034}, {-1120, -220.1035431}, {-1121, -220.3042752}, - {-1122, -220.4683124}, {-1123, -220.595789}, {-1124, -220.6868907}, - {-1125, -220.7417845}, {-1126, -220.7606608}, {-1127, -220.7436669}, - {-1128, -220.6909955}, {-1129, -220.6028094}, {-1130, -220.4792882}, - {-1131, -220.3206066}, {-1132, -220.1269434}, {-1133, -219.8984306}, - {-1134, -219.6353491}, {-1135, -219.3377772}, {-1136, -219.0058966}, - {-1137, -218.639961}, {-1138, -218.2400614}, {-1139, -217.806434}, - {-1140, -217.3392209}, {-1141, -216.8386174}, {-1142, -216.304802}, - {-1143, -215.7379313}, {-1144, -215.1382507}, {-1145, -214.5058689}, - {-1146, -213.8410006}, {-1147, -213.1436722}, {-1148, -212.4144}, - {-1149, -211.6532648}, {-1150, -210.8602496}, {-1151, -210.0356182}, - {-1152, -209.1796635}, {-1153, -208.292457}, {-1154, -207.3742317}, - {-1155, -206.4251592}, {-1156, -205.4454419}, {-1157, -204.4352509}, - {-1158, -203.3947787}, {-1159, -202.3242138}, {-1160, -201.2237403}, - {-1161, -200.0935529}, {-1162, -198.9338327}, {-1163, -197.7447794}, - {-1164, -196.5265719}, {-1165, -195.2794152}, {-1166, -194.0034846}, - {-1167, -192.6989822}, {-1168, -191.3660931}, {-1169, -190.0050278}, - {-1170, -188.615956}, {-1171, -187.1990636}, {-1172, -185.7546078}, - {-1173, -184.2827155}, {-1174, -182.7836134}, {-1175, -181.2574946}, - {-1176, -179.7045563}, {-1177, -178.1249913}, {-1178, -176.5190014}, - {-1179, -174.8867817}, {-1180, -173.2285388}, {-1181, -171.5444753}, - {-1182, -169.834783}, {-1183, -168.0996691}, {-1184, -166.3393323}, - {-1185, -164.5539775}, {-1186, -162.7438117}, {-1187, -160.9090393}, - {-1188, -159.0498584}, {-1189, -157.1664862}, {-1190, -155.2591188}, - {-1191, -153.3279647}, {-1192, -151.3732357}, {-1193, -149.3951405}, - {-1194, -147.3938888}, {-1195, -145.3696861}, {-1196, -143.3227491}, - {-1197, -141.2532956}, {-1198, -139.1615686}, {-1199, -137.0476573}, - {-1200, -134.911905}, {-1201, -132.7544817}, {-1202, -130.575612}, - {-1203, -128.3755012}, {-1204, -126.1543736}, {-1205, -123.9124458}, - {-1206, -121.6499375}, {-1207, -119.3670684}, {-1208, -117.0640612}, - {-1209, -114.7411352}, {-1210, -112.3985149}, {-1211, -110.0364226}, - {-1212, -107.6550862}, {-1213, -105.2547282}, {-1214, -102.8355752}, - {-1215, -100.3978558}, {-1216, -97.94192805}, {-1217, -95.46763412}, - {-1218, -92.97559043}, {-1219, -90.46589772}, {-1220, -87.93879494}, - {-1221, -85.39450874}, {-1222, -82.83327678}, {-1223, -80.25533676}, - {-1224, -77.66091937}, {-1225, -75.05026788}, {-1226, -72.42361434}, - {-1227, -69.7812126}, {-1228, -67.12328759}, {-1229, -64.45009061}, - {-1230, -61.76186322}, {-1231, -59.05884859}, {-1232, -56.34129582}, - {-1233, -53.60944689}, {-1234, -50.86355525}, {-1235, -48.10386549}, - {-1236, -45.33063332}, {-1237, -42.54410702}, {-1238, -39.74453989}, - {-1239, -36.93218801}, {-1240, -34.10730552}, {-1241, -31.2701509}, - {-1242, -28.42098258}, {-1243, -25.56005939}, {-1244, -22.68764573}, - {-1245, -19.80399739}, {-1246, -16.90938536}, {-1247, -14.00407248}, - {-1248, -11.08832635}, {-1249, -8.162415023}, {-1250, -5.226609065}, - {-1251, -2.281179596}, {-1252, 0.6736000031}, {-1253, 3.637455053}, - {-1254, 6.610109242}, {-1255, 9.591284352}, {-1256, 12.5807009}, - {-1257, 15.578078}, {-1258, 18.58313209}, {-1259, 21.59557822}, - {-1260, 24.61513064}, {-1261, 27.64150032}, {-1262, 30.67448551}, - {-1263, 33.71353351}, {-1264, 36.75860495}, {-1265, 39.80932656}, - {-1266, 42.86539566}, {-1267, 45.9265127}, {-1268, 48.9923769}, - {-1269, 52.06268497}, {-1270, 55.1371306}, {-1271, 58.21540675}, - {-1272, 61.29720377}, {-1273, 64.38220765}, {-1274, 67.47010622}, - {-1275, 70.5605817}, {-1276, 73.65331522}, {-1277, 76.74798611}, - {-1278, 79.84428086}, {-1279, 82.94184609}, {-1280, 86.04038238}, - {-1281, 89.13954176}, {-1282, 92.23900341}, {-1283, 95.33842467}, - {-1284, 98.43746276}, {-1285, 101.5357879}, {-1286, 104.6330432}, - {-1287, 107.7288929}, {-1288, 110.8229826}, {-1289, 113.914946}, - {-1290, 117.0044776}, {-1291, 120.0911648}, {-1292, 123.1746671}, - {-1293, 126.254623}, {-1294, 129.3306622}, {-1295, 132.4024085}, - {-1296, 135.4694961}, {-1297, 138.5315459}, {-1298, 141.5881778}, - {-1299, 144.6390067}, {-1300, 147.6836428}, {-1301, 150.7216996}, - {-1302, 153.7527804}, {-1303, 156.7764848}, {-1304, 159.7924102}, - {-1305, 162.8001549}, {-1306, 165.7993073}, {-1307, 168.7894507}, - {-1308, 171.7701636}, {-1309, 174.7410292}, {-1310, 177.7016188}, - {-1311, 180.6514932}, {-1312, 183.590232}, {-1313, 186.5173807}, - {-1314, 189.4324993}, {-1315, 192.335137}, {-1316, 195.2248335}, - {-1317, 198.1011329}, {-1318, 200.9635721}, {-1319, 203.8116777}, - {-1320, 206.6449645}, {-1321, 209.4629834}, {-1322, 212.2651708}, - {-1323, 215.051117}, {-1324, 217.8202696}, {-1325, 220.5721457}, - {-1326, 223.3062348}, {-1327, 226.0219976}, {-1328, 228.7189248}, - {-1329, 231.3964819}, {-1330, 234.0541244}, {-1331, 236.6913037}, - {-1332, 239.307474}, {-1333, 241.9020644}, {-1334, 244.4745609}, - {-1335, 247.0242272}, {-1336, 249.5506309}, {-1337, 252.053134}, - {-1338, 254.531117}, {-1339, 256.9839895}, {-1340, 259.4111072}, - {-1341, 261.8118884}, {-1342, 264.1855677}, {-1343, 266.5316171}, - {-1344, 268.8493247}, {-1345, 271.1380253}, {-1346, 273.3970279}, - {-1347, 275.625645}, {-1348, 277.8231589}, {-1349, 279.9888462}, - {-1350, 282.1219906}, {-1351, 284.2218105}, {-1352, 286.2875575}, - {-1353, 288.3184944}, {-1354, 290.3137841}, {-1355, 292.2726388}, - {-1356, 294.1942255}, {-1357, 296.0777138}, {-1358, 297.9222555}, - {-1359, 299.726963}, {-1360, 301.4909509}, {-1361, 303.2133144}, - {-1362, 304.8930971}, {-1363, 306.5293722}, {-1364, 308.1211544}, - {-1365, 309.6674458}, {-1366, 311.1672389}, {-1367, 312.6194607}, - {-1368, 314.0230537}, {-1369, 315.37693}, {-1370, 316.6799452}, - {-1371, 317.9309397}, {-1372, 319.1287312}, {-1373, 320.2720696}, - {-1374, 321.3597792}, {-1375, 322.3904816}, {-1376, 323.3628738}, - {-1377, 324.2755782}, {-1378, 325.1271858}, {-1379, 325.9162269}, - {-1380, 326.641201}, {-1381, 327.3005381}, {-1382, 327.8926356}, - {-1383, 328.4158062}, {-1384, 328.8683354}, {-1385, 329.2483977}, - {-1386, 329.5541484}, {-1387, 329.7836205}, {-1388, 329.934821}, - {-1389, 330.0056401}, {-1390, 329.9938465}, {-1391, 329.8971536}, - {-1392, 329.7131475}, {-1393, 329.4393186}, {-1394, 329.0729496}, - {-1395, 328.6114015}, {-1396, 328.0514185}, {-1397, 327.3901659}, - {-1398, 326.6243236}, {-1399, 325.7502231}, {-1400, 324.7642665}, - {-1401, 323.6624161}, {-1402, 322.4404172}, {-1403, 321.0936525}, - {-1404, 319.6171893}, {-1405, 318.0056403}, {-1406, 316.2531436}, - {-1407, 314.3532958}, {-1408, 312.2990162}, {-1409, 310.0824576}, - {-1410, 307.6948371}, {-1411, 305.1262384}, {-1412, 302.36531}, - {-1413, 299.3989435}, {-1414, 296.2116922}, {-1415, 292.7850052}, - {-1416, 289.0960336}, {-1417, 285.1155148}, {-1418, 280.8042868}, - {-1419, 276.1056003}, {-1420, 270.9256839}, {-1421, 265.0498316}, - {-1422, 258.0305961}, {-1423, 250.9533622}, {-1424, 243.9283235}, - {-1425, 236.9553812}, {-1426, 230.0344125}, {-1427, 223.1653202}, - {-1428, 216.348016}, {-1429, 209.5823497}, {-1430, 202.8682465}, - {-1431, 196.2056074}, {-1432, 189.5942927}, {-1433, 183.0342138}, - {-1434, 176.5252728}, {-1435, 170.0673494}, {-1436, 163.660332}, - {-1437, 157.304118}, {-1438, 150.998396}, {-1439, 144.7436831}, - {-1440, 138.5393463}, {-1441, 132.3851596}, {-1442, 126.2813523}, - {-1443, 120.2277003}, {-1444, 114.2240948}, {-1445, 108.2704306}, - {-1446, 102.3665932}, {-1447, 96.51247854}, {-1448, 90.7079781}, - {-1449, 84.95297989}, {-1450, 79.24737737}, {-1451, 73.59106103}, - {-1452, 67.98392275}, {-1453, 62.4258486}, {-1454, 56.9167324}, - {-1455, 51.45647351}, {-1456, 46.04493615}, {-1457, 40.68203531}, - {-1458, 35.3676543}, {-1459, 30.10167972}, {-1460, 24.88400482}, - {-1461, 19.71451894}, {-1462, 14.59310863}, {-1463, 9.51966659}, - {-1464, 4.494081216}, {-1465, -0.4837582643}, {-1466, -5.413962806}, - {-1467, -10.2966427}, {-1468, -15.13191051}, {-1469, -19.91987594}, - {-1470, -24.66065154}, {-1471, -29.35434819}, {-1472, -34.00107675}, - {-1473, -38.60095195}, {-1474, -43.15407953}, {-1475, -47.6605766}, - {-1476, -52.12055709}, {-1477, -56.53412597}, {-1478, -60.90139933}, - {-1479, -65.22249186}, {-1480, -69.49751358}, {-1481, -73.72657766}, - {-1482, -77.90978796}, {-1483, -82.04728595}, {-1484, -86.13915926}, - {-1485, -90.18552139}, {-1486, -94.18649236}, {-1487, -98.14218701}, - {-1488, -102.0527166}, {-1489, -105.9182019}, {-1490, -109.738738}, - {-1491, -113.5144567}, {-1492, -117.2454677}, {-1493, -120.9318844}, - {-1494, -124.5738204}, {-1495, -128.1713919}, {-1496, -131.7247093}, - {-1497, -135.2338968}, {-1498, -138.6985832}, {-1499, -142.1203184}, - {-1500, -145.4977801}, {-1501, -148.8315869}, {-1502, -152.1218236}, - {-1503, -155.368617}, {-1504, -158.5720837}, {-1505, -161.7323404}, - {-1506, -164.8495028}, {-1507, -167.9236845}, {-1508, -170.9550084}, - {-1509, -173.9435859}, {-1510, -176.8895472}, {-1511, -179.7929786}, - {-1512, -182.6540205}, {-1513, -185.4727875}, {-1514, -188.2493946}, - {-1515, -190.9839652}, {-1516, -193.6766361}, {-1517, -196.327446}, - {-1518, -198.9366067}, {-1519, -201.5041901}, {-1520, -204.0303235}, - {-1521, -206.5151327}, {-1522, -208.9587251}, {-1523, -211.3612174}, - {-1524, -213.7227424}, {-1525, -216.0434048}, {-1526, -218.3233361}, - {-1527, -220.562651}, {-1528, -222.7614698}, {-1529, -224.9199123}, - {-1530, -227.0380859}, {-1531, -229.1161603}, {-1532, -231.1541895}, - {-1533, -233.1523338}, {-1534, -235.1107066}, {-1535, -237.0294274}, - {-1536, -238.9086548}, {-1537, -240.7483935}, {-1538, -242.5488926}, - {-1539, -244.3101745}, {-1540, -246.0324995}, {-1541, -247.7158654}, - {-1542, -249.360428}, {-1543, -250.9663196}, {-1544, -252.5336417}, - {-1545, -254.0625606}, {-1546, -255.5531396}, {-1547, -257.0055772}, - {-1548, -258.4199372}, {-1549, -259.7963526}, {-1550, -261.1349554}, - {-1551, -262.4358946}, {-1552, -263.6992507}, {-1553, -264.9251738}, - {-1554, -266.1137724}, {-1555, -267.2652048}, {-1556, -268.3795628}, - {-1557, -269.4569849}, {-1558, -270.4975974}, {-1559, -271.5015178}, - {-1560, -272.468886}, {-1561, -273.3998118}, {-1562, -274.2944668}, - {-1563, -275.1528889}, {-1564, -275.9752887}, {-1565, -276.7617535}, - {-1566, -277.5124308}, {-1567, -278.227434}, {-1568, -278.9068944}, - {-1569, -279.5509436}, {-1570, -280.1597069}, {-1571, -280.7333171}, - {-1572, -281.271896}, {-1573, -281.775573}, {-1574, -282.244486}, - {-1575, -282.678714}, {-1576, -283.0785305}, {-1577, -283.4439176}, - {-1578, -283.7750604}, {-1579, -284.0721417}, {-1580, -284.3351069}, - {-1581, -284.5642847}, {-1582, -284.7597417}, {-1583, -284.9215918}, - {-1584, -285.0499971}, {-1585, -285.1450516}, {-1586, -285.2065376}, - {-1587, -285.2357563}, {-1588, -285.2316342}, {-1589, -285.1947207}, - {-1590, -285.1251531}, {-1591, -285.0230331}, {-1592, -284.8885283}, - {-1593, -284.7217583}, {-1594, -284.5228688}, {-1595, -284.2919871}, - {-1596, -284.0292445}, {-1597, -283.7347788}, {-1598, -283.4087333}, - {-1599, -283.0512383}, {-1600, -282.6624229}, {-1601, -282.2424309}, - {-1602, -281.7914131}, {-1603, -281.3094869}, {-1604, -280.7967943}, - {-1605, -280.2534728}, {-1606, -279.67967}, {-1607, -279.0748296}, - {-1608, -278.4411441}, {-1609, -277.7766831}, {-1610, -277.0823332}, - {-1611, -276.3581653}, {-1612, -275.6043525}, {-1613, -274.8210143}, - {-1614, -274.008313}, {-1615, -273.1663679}, {-1616, -272.2953518}, - {-1617, -271.3953801}, {-1618, -270.4666038}, {-1619, -269.5091071}, - {-1620, -268.5231996}, {-1621, -267.5087519}, {-1622, -266.4662878}, - {-1623, -265.3956226}, {-1624, -264.2970108}, {-1625, -263.1705953}, - {-1626, -262.0165313}, {-1627, -260.8349371}, {-1628, -259.6259964}, - {-1629, -258.3898231}, {-1630, -257.1265868}, {-1631, -255.8364102}, - {-1632, -254.5194552}, {-1633, -253.1758803}, {-1634, -251.8058002}, - {-1635, -250.409391}, {-1636, -248.9867889}, {-1637, -247.5381318}, - {-1638, -246.0636286}, {-1639, -244.563364}, {-1640, -243.0374811}, - {-1641, -241.4861976}, {-1642, -239.9096107}, {-1643, -238.3078871}, - {-1644, -236.681172}, {-1645, -235.0296459}, {-1646, -233.3534053}, - {-1647, -231.6526321}, {-1648, -229.9274588}, {-1649, -228.1781623}, - {-1650, -226.4047428}, {-1651, -224.6074133}, {-1652, -222.7863451}, - {-1653, -220.9416398}, {-1654, -219.0735116}, {-1655, -217.1820907}, - {-1656, -215.2675444}, {-1657, -213.3300244}, {-1658, -211.369683}, - {-1659, -209.3866897}, {-1660, -207.3811902}, {-1661, -205.3533675}, - {-1662, -203.30336}, {-1663, -201.2313343}, {-1664, -199.1374481}, - {-1665, -197.0218662}, {-1666, -194.8847674}, {-1667, -192.7262711}, - {-1668, -190.5465757}, {-1669, -188.3458384}, {-1670, -186.1242187}, - {-1671, -183.8818843}, {-1672, -181.6189972}, {-1673, -179.335729}, - {-1674, -177.0322328}, {-1675, -174.7086864}, {-1676, -172.3652596}, - {-1677, -170.0021082}, {-1678, -167.6194134}, {-1679, -165.2173133}, - {-1680, -162.7960445}, {-1681, -160.3557143}, {-1682, -157.8965125}, - {-1683, -155.4186138}, {-1684, -152.9221898}, {-1685, -150.4074007}, - {-1686, -147.8744358}, {-1687, -145.3234508}, {-1688, -142.7546716}, - {-1689, -140.1682121}, {-1690, -137.5642571}, {-1691, -134.9430084}, - {-1692, -132.3046349}, {-1693, -129.6492983}, {-1694, -126.9771944}, - {-1695, -124.2884938}, {-1696, -121.583375}, {-1697, -118.8620233}, - {-1698, -116.1246178}, {-1699, -113.3713391}, {-1700, -110.6023692}, - {-1701, -107.8178928}, {-1702, -105.0180958}, {-1703, -102.2031563}, - {-1704, -99.37326821}, {-1705, -96.52858191}, {-1706, -93.66936695}, - {-1707, -90.79573097}, {-1708, -87.90789445}, {-1709, -85.00603934}, - {-1710, -82.09036096}, {-1711, -79.16102098}, {-1712, -76.21827778}, - {-1713, -73.26227099}, {-1714, -70.29315038}, {-1715, -67.31126389}, - {-1716, -64.31665711}, {-1717, -61.30957719}, {-1718, -58.29021672}, - {-1719, -55.25877431}, {-1720, -52.21545294}, {-1721, -49.16044728}, - {-1722, -46.09395655}, {-1723, -43.01618348}, {-1724, -39.92732826}, - {-1725, -36.82759564}, {-1726, -33.71718872}, {-1727, -30.59631219}, - {-1728, -27.4651689}, {-1729, -24.32396923}, {-1730, -21.17291826}, - {-1731, -18.01222638}, {-1732, -14.84210144}, {-1733, -11.66275519}, - {-1734, -8.474398089}, {-1735, -5.277243744}, {-1736, -2.071505147}, - {-1737, 1.142601817}, {-1738, 4.364862316}, {-1739, 7.595059073}, - {-1740, 10.83297395}, {-1741, 14.07838791}, {-1742, 17.33108012}, - {-1743, 20.59082944}, {-1744, 23.85741345}, {-1745, 27.130606}, - {-1746, 30.41018709}, {-1747, 33.69592687}, {-1748, 36.98759685}, - {-1749, 40.28497006}, {-1750, 43.58781629}, {-1751, 46.89590316}, - {-1752, 50.209002}, {-1753, 53.52687116}, {-1754, 56.84928153}, - {-1755, 60.17599514}, {-1756, 63.50677295}, {-1757, 66.84137666}, - {-1758, 70.17956563}, {-1759, 73.52109515}, {-1760, 76.86572436}, - {-1761, 80.21320719}, {-1762, 83.56329692}, {-1763, 86.91575236}, - {-1764, 90.27030066}, {-1765, 93.62671326}, {-1766, 96.98473215}, - {-1767, 100.3441002}, {-1768, 103.7045628}, {-1769, 107.0658466}, - {-1770, 110.427736}, {-1771, 113.7899279}, {-1772, 117.1521691}, - {-1773, 120.5142362}, {-1774, 123.8757527}, {-1775, 127.236559}, - {-1776, 130.5963477}, {-1777, 133.9548462}, {-1778, 137.3117864}, - {-1779, 140.6668935}, {-1780, 144.019869}, {-1781, 147.3704582}, - {-1782, 150.7183775}, {-1783, 154.0633144}, {-1784, 157.4050184}, - {-1785, 160.7431864}, {-1786, 164.077527}, {-1787, 167.4077511}, - {-1788, 170.7335631}, {-1789, 174.0546652}, {-1790, 177.3707551}, - {-1791, 180.6815471}, {-1792, 183.9867331}, {-1793, 187.2859685}, - {-1794, 190.5789949}, {-1795, 193.8654854}, {-1796, 197.1451059}, - {-1797, 200.4175632}, {-1798, 203.6825367}, {-1799, 206.9396968}, - {-1800, 210.1887216}, {-1801, 213.4292851}, {-1802, 216.661056}, - {-1803, 219.8837061}, {-1804, 223.0968824}, {-1805, 226.3002654}, - {-1806, 229.493504}, {-1807, 232.6762727}, {-1808, 235.8481706}, - {-1809, 239.0088965}, {-1810, 242.1580657}, {-1811, 245.2953655}, - {-1812, 248.4204047}, {-1813, 251.532773}, {-1814, 254.6321658}, - {-1815, 257.7181886}, {-1816, 260.7904663}, {-1817, 263.848621}, - {-1818, 266.892258}, {-1819, 269.9209918}, {-1820, 272.9344548}, - {-1821, 275.932219}, {-1822, 278.9138957}, {-1823, 281.8790852}, - {-1824, 284.8273764}, {-1825, 287.7583441}, {-1826, 290.6715817}, - {-1827, 293.5666663}, {-1828, 296.4431622}, {-1829, 299.3006457}, - {-1830, 302.1386696}, {-1831, 304.9568206}, {-1832, 307.754573}, - {-1833, 310.5315524}, {-1834, 313.2872937}, {-1835, 316.0212653}, - {-1836, 318.7330565}, {-1837, 321.4221836}, {-1838, 324.0881604}, - {-1839, 326.7304987}, {-1840, 329.3486326}, {-1841, 331.9421603}, - {-1842, 334.5105311}, {-1843, 337.0532316}, {-1844, 339.5697272}, - {-1845, 342.0594964}, {-1846, 344.5220039}, {-1847, 346.9567043}, - {-1848, 349.3630138}, {-1849, 351.7404044}, {-1850, 354.0882918}, - {-1851, 356.4061032}, {-1852, 358.6932203}, {-1853, 360.9490705}, - {-1854, 363.1730489}, {-1855, 365.3656041}, {-1856, 367.5228721}, - {-1857, 369.6474506}, {-1858, 371.7376163}, {-1859, 373.7927355}, - {-1860, 375.812037}, {-1861, 377.7949387}, {-1862, 379.7407076}, - {-1863, 381.6486335}, {-1864, 383.5180106}, {-1865, 385.3480624}, - {-1866, 387.1380641}, {-1867, 388.8872593}, {-1868, 390.5948317}, - {-1869, 392.2600545}, {-1870, 393.8820359}, {-1871, 395.459983}, - {-1872, 396.9930631}, {-1873, 398.4803572}, {-1874, 399.9210344}, - {-1875, 401.3141151}, {-1876, 402.6588113}, {-1877, 403.9540475}, - {-1878, 405.1988957}, {-1879, 406.3923656}, {-1880, 407.5334268}, - {-1881, 408.6210283}, {-1882, 409.6541294}, {-1883, 410.6316101}, - {-1884, 411.5523425}, {-1885, 412.4151488}, {-1886, 413.2188772}, - {-1887, 413.9622628}, {-1888, 414.6440533}, {-1889, 415.2629519}, - {-1890, 415.8176095}, {-1891, 416.3066548}, {-1892, 416.728632}, - {-1893, 417.0821132}, {-1894, 417.3654971}, {-1895, 417.5772473}, - {-1896, 417.7157386}, {-1897, 417.7792498}, {-1898, 417.7660382}, - {-1899, 417.6742585}, {-1900, 417.5020087}, {-1901, 417.2473105}, - {-1902, 416.9080878}, {-1903, 416.4821984}, {-1904, 415.9673674}, - {-1905, 415.3612177}, {-1906, 414.6613001}, {-1907, 413.865}, - {-1908, 412.9695616}, {-1909, 411.9721071}, {-1910, 410.8695776}, - {-1911, 409.6587338}, {-1912, 408.3361432}, {-1913, 406.8981203}, - {-1914, 405.3408246}, {-1915, 403.6600082}, {-1916, 401.8511918}, - {-1917, 399.9095439}, {-1918, 397.8297696}, {-1919, 395.6061773}, - {-1920, 393.2325758}, {-1921, 390.7018165}, {-1922, 388.0065344}, - {-1923, 385.1656683}, {-1924, 382.0867723}, {-1925, 378.841722}, - {-1926, 375.3902268}, {-1927, 371.7174307}, {-1928, 367.8055737}, - {-1929, 363.6329048}, {-1930, 359.1718349}, {-1931, 354.3858715}, - {-1932, 349.2231247}, {-1933, 343.6010933}, {-1934, 337.3504745}, - {-1935, 329.950698}, {-1936, 322.2912062}, {-1937, 314.6801463}, - {-1938, 307.1171549}, {-1939, 299.60287}, {-1940, 292.1365344}, - {-1941, 284.7182428}, {-1942, 277.3479559}, {-1943, 270.0255803}, - {-1944, 262.7510235}, {-1945, 255.5242057}, {-1946, 248.3450413}, - {-1947, 241.2134537}, {-1948, 234.129339}, {-1949, 227.0926324}, - {-1950, 220.1032292}, {-1951, 213.1610783}, {-1952, 206.2660762}, - {-1953, 199.418106}, {-1954, 192.6171278}, {-1955, 185.8630543}, - {-1956, 179.155766}, {-1957, 172.4952102}, {-1958, 165.8812805}, - {-1959, 159.313922}, {-1960, 152.7930067}, {-1961, 146.3184739}, - {-1962, 139.8902485}, {-1963, 133.508222}, {-1964, 127.1723164}, - {-1965, 120.8824627}, {-1966, 114.6385511}, {-1967, 108.4405069}, - {-1968, 102.2882401}, {-1969, 96.1816731}, {-1970, 90.12070067}, - {-1971, 84.10525847}, {-1972, 78.13524813}, {-1973, 72.21058682}, - {-1974, 66.33118658}, {-1975, 60.4969655}, {-1976, 54.70782541}, - {-1977, 48.96368942}, {-1978, 43.26447169}, {-1979, 37.61006021}, - {-1980, 32.0004247}, {-1981, 26.43542669}, {-1982, 20.91499515}, - {-1983, 15.43904262}, {-1984, 10.00748211}, {-1985, 4.620225938}, - {-1986, -0.7228133783}, {-1987, -6.021723494}, {-1988, -11.27658947}, - {-1989, -16.48750685}, {-1990, -21.65455571}, {-1991, -26.77782749}, - {-1992, -31.85740919}, {-1993, -36.89339081}, {-1994, -41.88585437}, - {-1995, -46.83489874}, {-1996, -51.74060567}, {-1997, -56.60306145}, - {-1998, -61.42235931}, {-1999, -66.19858681}, {-2000, -70.9318329}, - {-2001, -75.62218716}, {-2002, -80.26973548}, {-2003, -84.87457124}, - {-2004, -89.43677976}, {-2005, -93.95645317}, {-2006, -98.43367886}, - {-2007, -102.8685462}, {-2008, -107.2611502}, {-2009, -111.6115737}, - {-2010, -115.9199079}, {-2011, -120.1862458}, {-2012, -124.4106739}, - {-2013, -128.5932831}, {-2014, -132.7341875}, {-2015, -136.8334131}, - {-2016, -140.8911158}, {-2017, -144.9073395}, {-2018, -148.8822277}, - {-2019, -152.8158291}, {-2020, -156.708243}, {-2021, -160.5595635}, - {-2022, -164.3698865}, {-2023, -168.1392891}, {-2024, -171.8678771}, - {-2025, -175.5557625}, {-2026, -179.2029529}, {-2027, -182.8096307}, - {-2028, -186.3758531}, {-2029, -189.9017115}, {-2030, -193.387299}, - {-2031, -196.832711}, {-2032, -200.2380349}, {-2033, -203.6033646}, - {-2034, -206.9287938}, {-2035, -210.2144102}, {-2036, -213.4603115}, - {-2037, -216.6665934}, {-2038, -219.8333269}, {-2039, -222.960647}, - {-2040, -226.0486273}, {-2041, -229.0973213}, {-2042, -232.1068739}, - {-2043, -235.0772483}, {-2044, -238.0088781}, {-2045, -240.9015156}, - {-2046, -243.7553686}, {-2047, -246.5705384}, {-2048, -249.3470947}, - {-2049, -252.0851617}, {-2050, -254.7847815}, {-2051, -257.446159}, - {-2052, -260.0692812}, {-2053, -262.6542796}, {-2054, -265.2012469}, - {-2055, -267.7102679}, {-2056, -270.1814773}, {-2057, -272.6149185}, - {-2058, -275.0107179}, {-2059, -277.3689585}, {-2060, -279.6897437}, - {-2061, -281.9731652}, {-2062, -284.2192924}, {-2063, -286.4283015}, - {-2064, -288.6002083}, {-2065, -290.7351299}, {-2066, -292.8331807}, - {-2067, -294.8944379}, {-2068, -296.9190066}, {-2069, -298.9069792}, - {-2070, -300.8584588}, {-2071, -302.773538}, {-2072, -304.6523068}, - {-2073, -306.4948842}, {-2074, -308.3013433}, {-2075, -310.0718028}, - {-2076, -311.8063438}, {-2077, -313.5050721}, {-2078, -315.1680698}, - {-2079, -316.7954664}, {-2080, -318.3873474}, {-2081, -319.9437928}, - {-2082, -321.4649154}, {-2083, -322.9508231}, {-2084, -324.4015927}, - {-2085, -325.8173421}, {-2086, -327.1981457}, {-2087, -328.5441633}, - {-2088, -329.855426}, {-2089, -331.1320587}, {-2090, -332.3741665}, - {-2091, -333.5818414}, {-2092, -334.7551931}, {-2093, -335.8943053}, - {-2094, -336.9992937}, {-2095, -338.0702459}, {-2096, -339.1073014}, - {-2097, -340.1104863}, {-2098, -341.0799584}, {-2099, -342.015825}, - {-2100, -342.9181658}, {-2101, -343.7870749}, {-2102, -344.6226615}, - {-2103, -345.4250384}, {-2104, -346.194308}, {-2105, -346.9305378}, - {-2106, -347.6338704}, {-2107, -348.304392}, {-2108, -348.9422119}, - {-2109, -349.5474149}, {-2110, -350.1201358}, {-2111, -350.6604463}, - {-2112, -351.1684701}, {-2113, -351.6442856}, {-2114, -352.0880972}, - {-2115, -352.499796}, {-2116, -352.8796774}, {-2117, -353.2277905}, - {-2118, -353.5442363}, {-2119, -353.8291059}, {-2120, -354.0825163}, - {-2121, -354.3045796}, {-2122, -354.4953995}, {-2123, -354.6550344}, - {-2124, -354.7836683}, {-2125, -354.8813658}, {-2126, -354.9482168}, - {-2127, -354.9843609}, {-2128, -354.9898995}, {-2129, -354.9649747}, - {-2130, -354.9095195}, {-2131, -354.823835}, {-2132, -354.7079703}, - {-2133, -354.5620166}, {-2134, -354.3860746}, {-2135, -354.1803085}, - {-2136, -353.9447693}, {-2137, -353.6795756}, {-2138, -353.3848379}, - {-2139, -353.0606775}, {-2140, -352.7071811}, {-2141, -352.3244769}, - {-2142, -351.912662}, {-2143, -351.471863}, {-2144, -351.0021736}, - {-2145, -350.5037011}, {-2146, -349.9765579}, {-2147, -349.4208634}, - {-2148, -348.8367303}, {-2149, -348.2242421}, {-2150, -347.5835569}, - {-2151, -346.9147442}, {-2152, -346.2179301}, {-2153, -345.4932213}, - {-2154, -344.7407432}, {-2155, -343.9605941}, {-2156, -343.1528785}, - {-2157, -342.3177459}, {-2158, -341.4552718}, {-2159, -340.5655715}, - {-2160, -339.6487849}, {-2161, -338.7050057}, {-2162, -337.7343412}, - {-2163, -336.7369161}, {-2164, -335.7128505}, {-2165, -334.662227}, - {-2166, -333.5852284}, {-2167, -332.4818964}, {-2168, -331.3523944}, - {-2169, -330.196809}, {-2170, -329.0152665}, {-2171, -327.8078824}, - {-2172, -326.5747753}, {-2173, -325.3160546}, {-2174, -324.0318305}, - {-2175, -322.7222628}, {-2176, -321.3874142}, {-2177, -320.0274377}, - {-2178, -318.6424205}, {-2179, -317.2324728}, {-2180, -315.7978146}, - {-2181, -314.3384489}, {-2182, -312.8545312}, {-2183, -311.3461843}, - {-2184, -309.8135015}, {-2185, -308.2566863}, {-2186, -306.6757613}, - {-2187, -305.0709113}, {-2188, -303.4422126}, {-2189, -301.789807}, - {-2190, -300.1138112}, {-2191, -298.4143537}, {-2192, -296.6915478}, - {-2193, -294.9455222}, {-2194, -293.1763954}, {-2195, -291.3843497}, - {-2196, -289.5693315}, {-2197, -287.7316381}, {-2198, -285.8713262}, - {-2199, -283.9885534}, {-2200, -282.0834107}, {-2201, -280.1560426}, - {-2202, -278.2065489}, {-2203, -276.2350741}, {-2204, -274.2417379}, - {-2205, -272.2266737}, {-2206, -270.1899978}, {-2207, -268.1318423}, - {-2208, -266.0523289}, {-2209, -263.9515906}, {-2210, -261.8297485}, - {-2211, -259.6869414}, {-2212, -257.5232824}, {-2213, -255.3388932}, - {-2214, -253.1339501}, {-2215, -250.9085367}, {-2216, -248.6627959}, - {-2217, -246.3968522}, {-2218, -244.1108406}, {-2219, -241.804899}, - {-2220, -239.4791373}, {-2221, -237.1337037}, {-2222, -234.768745}, - {-2223, -232.3843565}, {-2224, -229.9807064}, {-2225, -227.557898}, - {-2226, -225.1160867}, {-2227, -222.6553908}, {-2228, -220.1759508}, - {-2229, -217.677904}, {-2230, -215.1613805}, {-2231, -212.6265203}, - {-2232, -210.0734562}, {-2233, -207.5023218}, {-2234, -204.9132451}, - {-2235, -202.3063923}, {-2236, -199.6818639}, {-2237, -197.03983}, - {-2238, -194.380415}, {-2239, -191.7037474}, {-2240, -189.0099853}, - {-2241, -186.2992551}, {-2242, -183.5717066}, {-2243, -180.8274679}, - {-2244, -178.0666762}, {-2245, -175.2895042}, {-2246, -172.4960631}, - {-2247, -169.6865042}, {-2248, -166.8609664}, {-2249, -164.0195998}, - {-2250, -161.1625442}, {-2251, -158.289947}, {-2252, -155.4019448}, - {-2253, -152.498694}, {-2254, -149.5803236}, {-2255, -146.6469962}, - {-2256, -143.6988504}, {-2257, -140.7360367}, {-2258, -137.7586994}, - {-2259, -134.7669883}, {-2260, -131.7610455}, {-2261, -128.7410366}, - {-2262, -125.7070907}, {-2263, -122.6593776}, {-2264, -119.5980339}, - {-2265, -116.5232134}, {-2266, -113.4350715}, {-2267, -110.3337476}, - {-2268, -107.2194106}, {-2269, -104.0920936}, {-2270, -100.9523156}, - {-2271, -97.79985445}, {-2272, -94.6349785}, {-2273, -91.45787948}, - {-2274, -88.26867852}, {-2275, -85.06754785}, {-2276, -81.85464089}, - {-2277, -78.63011638}, {-2278, -75.39413565}, {-2279, -72.1468558}, - {-2280, -68.88843666}, {-2281, -65.61904004}, {-2282, -62.33882793}, - {-2283, -59.04795767}, {-2284, -55.74659691}, {-2285, -52.43490637}, - {-2286, -49.1130512}, {-2287, -45.78119593}, {-2288, -42.43950444}, - {-2289, -39.08814207}, {-2290, -35.72727733}, {-2291, -32.35707085}, - {-2292, -28.9777075}, {-2293, -25.58933942}, {-2294, -22.19214184}, - {-2295, -18.78628354}, {-2296, -15.37193688}, {-2297, -11.94927261}, - {-2298, -8.518463601}, {-2299, -5.079682548}, {-2300, -1.633103747}, - {-2301, 1.821098413}, {-2302, 5.282748524}, {-2303, 8.751670197}, - {-2304, 12.22768648}, {-2305, 15.71061966}, {-2306, 19.20029397}, - {-2307, 22.69651984}, {-2308, 26.19912825}, {-2309, 29.70793306}, - {-2310, 33.22275341}, {-2311, 36.74341042}, {-2312, 40.26970642}, - {-2313, 43.80147036}, {-2314, 47.33851291}, {-2315, 50.88064578}, - {-2316, 54.42768675}, {-2317, 57.97943984}, {-2318, 61.53572256}, - {-2319, 65.09633804}, {-2320, 68.6611025}, {-2321, 72.22981743}, - {-2322, 75.80229463}, {-2323, 79.3783372}, {-2324, 82.95775036}, - {-2325, 86.54033883}, {-2326, 90.12590068}, {-2327, 93.71425003}, - {-2328, 97.30517596}, {-2329, 100.8984795}, {-2330, 104.4939651}, - {-2331, 108.091423}, {-2332, 111.6906555}, {-2333, 115.291453}, - {-2334, 118.893614}, {-2335, 122.4969296}, {-2336, 126.1011879}, - {-2337, 129.7061875}, {-2338, 133.3117114}, {-2339, 136.9175495}, - {-2340, 140.5234891}, {-2341, 144.129315}, {-2342, 147.7348154}, - {-2343, 151.3397674}, {-2344, 154.9439585}, {-2345, 158.5471624}, - {-2346, 162.1491674}, {-2347, 165.7497448}, {-2348, 169.3486707}, - {-2349, 172.9457248}, {-2350, 176.5406855}, {-2351, 180.1333077}, - {-2352, 183.723366}, {-2353, 187.3106448}, {-2354, 190.8949073}, - {-2355, 194.4759291}, {-2356, 198.0534221}, {-2357, 201.6272097}, - {-2358, 205.1969846}, {-2359, 208.762651}, {-2360, 212.3238241}, - {-2361, 215.8803108}, {-2362, 219.4318606}, {-2363, 222.9782309}, - {-2364, 226.5191699}, {-2365, 230.0544352}, {-2366, 233.5837716}, - {-2367, 237.1069139}, {-2368, 240.6236258}, {-2369, 244.1336406}, - {-2370, 247.6383991}, {-2371, 251.1325303}, {-2372, 254.6208938}, - {-2373, 258.1015027}, {-2374, 261.5741058}, {-2375, 265.0384209}, - {-2376, 268.4941917}, {-2377, 271.941132}, {-2378, 275.3789734}, - {-2379, 278.8074262}, {-2380, 282.2262386}, {-2381, 285.6351}, - {-2382, 289.0337321}, {-2383, 292.4218602}, {-2384, 295.7991856}, - {-2385, 299.1654198}, {-2386, 302.5202605}, {-2387, 305.8634252}, - {-2388, 309.1946062}, {-2389, 312.5135048}, {-2390, 315.8198165}, - {-2391, 319.113236}, {-2392, 322.3934033}, {-2393, 325.66015}, - {-2394, 328.9130104}, {-2395, 332.1517166}, {-2396, 335.3759845}, - {-2397, 338.5854103}, {-2398, 341.7797321}, {-2399, 344.9586149}, - {-2400, 348.1217023}, {-2401, 351.2686662}, {-2402, 354.3991717}, - {-2403, 357.5128706}, {-2404, 360.6094332}, {-2405, 363.6884632}, - {-2406, 366.7496497}, {-2407, 369.7926254}, {-2408, 372.8170254}, - {-2409, 375.8224899}, {-2410, 378.8086383}, {-2411, 381.7751082}, - {-2412, 384.7215191}, {-2413, 387.6474977}, {-2414, 390.5526423}, - {-2415, 393.4365774}, {-2416, 396.2989036}, {-2417, 399.1392244}, - {-2418, 401.9571151}, {-2419, 404.7522327}, {-2420, 407.5240922}, - {-2421, 410.272313}, {-2422, 412.9964593}, {-2423, 415.6960891}, - {-2424, 418.3708254}, {-2425, 421.0201754}, {-2426, 423.643725}, - {-2427, 426.240987}, {-2428, 428.8115477}, {-2429, 431.3549225}, - {-2430, 433.8706653}, {-2431, 436.3582581}, {-2432, 438.8172568}, - {-2433, 441.247178}, {-2434, 443.6475395}, {-2435, 446.0177607}, - {-2436, 448.3574199}, {-2437, 450.6659619}, {-2438, 452.9429115}, - {-2439, 455.1876351}, {-2440, 457.3997077}, {-2441, 459.5785156}, - {-2442, 461.7235283}, {-2443, 463.8341753}, {-2444, 465.9098741}, - {-2445, 467.9500617}, {-2446, 469.9541217}, {-2447, 471.9214823}, - {-2448, 473.8514962}, {-2449, 475.7435692}, {-2450, 477.5970594}, - {-2451, 479.4113195}, {-2452, 481.1856945}, {-2453, 482.9194772}, - {-2454, 484.6121218}, {-2455, 486.2627967}, {-2456, 487.8708666}, - {-2457, 489.4355502}, {-2458, 490.9561368}, {-2459, 492.4319211}, - {-2460, 493.8621066}, {-2461, 495.2459111}, {-2462, 496.5825668}, - {-2463, 497.8712169}, {-2464, 499.1110738}, {-2465, 500.3012703}, - {-2466, 501.4409179}, {-2467, 502.5291726}, {-2468, 503.5651018}, - {-2469, 504.5496464}, {-2470, 505.4762591}, {-2471, 506.3495478}, - {-2472, 507.1666798}, {-2473, 507.9265974}, {-2474, 508.6282626}, - {-2475, 509.2706183}, {-2476, 509.8524857}, {-2477, 510.3728067}, - {-2478, 510.8303492}, {-2479, 511.2239517}, {-2480, 511.5523527}, - {-2481, 511.8142359}, {-2482, 512.0083321}, {-2483, 512.1332609}, - {-2484, 512.1876494}, {-2485, 512.1699389}, {-2486, 512.0787598}, - {-2487, 511.9124796}, {-2488, 511.6695054}, {-2489, 511.3481601}, - {-2490, 510.9467169}, {-2491, 510.4633625}, {-2492, 509.8962183}, - {-2493, 509.243379}, {-2494, 508.5027255}, {-2495, 507.6721727}, - {-2496, 506.7495012}, {-2497, 505.7323738}, {-2498, 504.6183546}, - {-2499, 503.4048642}, {-2500, 502.0891692}, {-2501, 500.6685314}, - {-2502, 499.1398264}, {-2503, 497.4999126}, {-2504, 495.7453965}, - {-2505, 493.8728667}, {-2506, 491.8779939}, {-2507, 489.7569877}, - {-2508, 487.5054439}, {-2509, 485.1185603}, {-2510, 482.5911479}, - {-2511, 479.9176074}, {-2512, 477.0917364}, {-2513, 474.1068292}, - {-2514, 470.9554055}, {-2515, 467.6290435}, {-2516, 464.118404}, - {-2517, 460.4127475}, {-2518, 456.4998509}, {-2519, 452.365065}, - {-2520, 447.991528}, {-2521, 443.3580292}, {-2522, 438.438392}, - {-2523, 433.1979703}, {-2524, 427.5884027}, {-2525, 421.5343929}, - {-2526, 414.8919142}, {-2527, 407.1575495}, {-2528, 398.9589393}, - {-2529, 390.8056713}, {-2530, 382.6976782}, {-2531, 374.6348759}, - {-2532, 366.6172204}, {-2533, 358.6446286}, {-2534, 350.717138}, - {-2535, 342.8343774}, {-2536, 334.9966128}, {-2537, 327.2035838}, - {-2538, 319.4553132}, {-2539, 311.7516789}, {-2540, 304.0926436}, - {-2541, 296.478137}, {-2542, 288.9080242}, {-2543, 281.3823933}, - {-2544, 273.9010287}, {-2545, 266.4639084}, {-2546, 259.0709605}, - {-2547, 251.7221247}, {-2548, 244.417387}, {-2549, 237.1564913}, - {-2550, 229.9395698}, {-2551, 222.7664542}, {-2552, 215.637115}, - {-2553, 208.5514592}, {-2554, 201.5094486}, {-2555, 194.510955}, - {-2556, 187.5559601}, {-2557, 180.644378}, {-2558, 173.7761414}, - {-2559, 166.951178}, {-2560, 160.1694545}, {-2561, 153.4307895}, - {-2562, 146.7352321}, {-2563, 140.082664}, {-2564, 133.4730194}, - {-2565, 126.9062307}, {-2566, 120.3822261}, {-2567, 113.9009356}, - {-2568, 107.4622856}, {-2569, 101.0662139}, {-2570, 94.71264255}, - {-2571, 88.40150333}, {-2572, 82.13272692}, {-2573, 75.90623975}, - {-2574, 69.72197655}, {-2575, 63.57985833}, {-2576, 57.47982248}, - {-2577, 51.42179276}, {-2578, 45.40570429}, {-2579, 39.43147622}, - {-2580, 33.49904632}, {-2581, 27.60834016}, {-2582, 21.75928681}, - {-2583, 15.95181538}, {-2584, 10.18585427}, {-2585, 4.4613317}, - {-2586, -1.221823264}, {-2587, -6.863682244}, {-2588, -12.46431711}, - {-2589, -18.02379881}, {-2590, -23.54220032}, {-2591, -29.01959173}, - {-2592, -34.45604716}, {-2593, -39.85163591}, {-2594, -45.20643153}, - {-2595, -50.52050558}, {-2596, -55.79393134}, {-2597, -61.02677981}, - {-2598, -66.21912335}, {-2599, -71.37103561}, {-2600, -76.48258755}, - {-2601, -81.55385237}, {-2602, -86.58490467}, {-2603, -91.57580819}, - {-2604, -96.52662878}, {-2605, -101.4374872}, {-2606, -106.3084075}, - {-2607, -111.1394718}, {-2608, -115.9307636}, {-2609, -120.6823469}, - {-2610, -125.3943008}, {-2611, -130.0666951}, {-2612, -134.6996035}, - {-2613, -139.2926982}, {-2614, -143.8472845}, {-2615, -148.3621251}, - {-2616, -152.8378634}, {-2617, -157.2744514}, {-2618, -161.6719856}, - {-2619, -166.0305687}, {-2620, -170.3502425}, {-2621, -174.6311046}, - {-2622, -178.8732158}, {-2623, -183.0766462}, {-2624, -187.2414872}, - {-2625, -191.3678067}, {-2626, -195.4556602}, {-2627, -199.5051449}, - {-2628, -203.5163556}, {-2629, -207.4892838}, {-2630, -211.4240905}, - {-2631, -215.3208074}, {-2632, -219.179545}, {-2633, -223.000344}, - {-2634, -226.7832883}, {-2635, -230.5284632}, {-2636, -234.2359251}, - {-2637, -237.9057799}, {-2638, -241.5380558}, {-2639, -245.1328705}, - {-2640, -248.6903057}, {-2641, -252.2103734}, {-2642, -255.6932106}, - {-2643, -259.1388831}, {-2644, -262.5474507}, {-2645, -265.9189965}, - {-2646, -269.2536048}, {-2647, -272.5513386}, {-2648, -275.8122855}, - {-2649, -279.0365115}, {-2650, -282.2240579}, {-2651, -285.3751227}, - {-2652, -288.4896622}, {-2653, -291.5677959}, {-2654, -294.6095802}, - {-2655, -297.6151472}, {-2656, -300.584486}, {-2657, -303.5177297}, - {-2658, -306.414873}, {-2659, -309.276272}, {-2660, -312.1016832}, - {-2661, -314.8913017}, {-2662, -317.6452094}, {-2663, -320.363471}, - {-2664, -323.0461886}, {-2665, -325.6934182}, {-2666, -328.3052418}, - {-2667, -330.8817427}, {-2668, -333.4229876}, {-2669, -335.9290716}, - {-2670, -338.4000315}, {-2671, -340.8360332}, {-2672, -343.2370808}, - {-2673, -345.6032636}, {-2674, -347.9346872}, {-2675, -350.2313994}, - {-2676, -352.4934683}, {-2677, -354.7210289}, {-2678, -356.9141233}, - {-2679, -359.0728291}, {-2680, -361.1972312}, {-2681, -363.2874191}, - {-2682, -365.34346}, {-2683, -367.3654373}, {-2684, -369.3534306}, - {-2685, -371.3075113}, {-2686, -373.2277708}, {-2687, -375.1142949}, - {-2688, -376.9671425}, {-2689, -378.7864087}, {-2690, -380.5721488}, - {-2691, -382.3245196}, {-2692, -384.0435213}, {-2693, -385.7292557}, - {-2694, -387.3818163}, {-2695, -389.0012733}, {-2696, -390.5877112}, - {-2697, -392.141186}, {-2698, -393.6618535}, {-2699, -395.1497277}, - {-2700, -396.5965999}, {-2701, -398.0274661}, {-2702, -399.417503}, - {-2703, -400.7750989}, {-2704, -402.1002937}, {-2705, -403.3932392}, - {-2706, -404.6539646}, {-2707, -405.8825768}, {-2708, -407.0791497}, - {-2709, -408.2437654}, {-2710, -409.376479}, {-2711, -410.4774696}, - {-2712, -411.546718}, {-2713, -412.5843448}, {-2714, -413.5904292}, - {-2715, -414.5650599}, {-2716, -415.5083121}, {-2717, -416.4202805}, - {-2718, -417.3010423}, {-2719, -418.1506732}, {-2720, -418.9692655}, - {-2721, -419.7569036}, {-2722, -420.513675}, {-2723, -421.239654}, - {-2724, -421.9349321}, {-2725, -422.5996082}, {-2726, -423.2337297}, - {-2727, -423.8373989}, {-2728, -424.4107227}, {-2729, -424.9537758}, - {-2730, -425.4666152}, {-2731, -425.9493702}, {-2732, -426.4020748}, - {-2733, -426.8248474}, {-2734, -427.217775}, {-2735, -427.5809368}, - {-2736, -427.9144198}, {-2737, -428.218309}, {-2738, -428.4926839}, - {-2739, -428.7376385}, {-2740, -428.9532818}, {-2741, -429.1396611}, - {-2742, -429.2967315}, {-2743, -429.4250281}, {-2744, -429.5241873}, - {-2745, -429.5944341}, {-2746, -429.6358952}, {-2747, -429.6486157}, - {-2748, -429.6327289}, {-2749, -429.5882461}, {-2750, -429.5153283}, - {-2751, -429.4140299}, {-2752, -429.284449}, {-2753, -429.1266726}, - {-2754, -428.9407894}, {-2755, -428.7268877}, {-2756, -428.485047}, - {-2757, -428.2153711}, {-2758, -427.9179581}, {-2759, -427.5928025}, - {-2760, -427.2402092}, {-2761, -426.8600634}, {-2762, -426.4525022}, - {-2763, -426.0176744}, {-2764, -425.5556313}, {-2765, -425.06645}, - {-2766, -424.5502499}, {-2767, -424.0070906}, {-2768, -423.4369804}, - {-2769, -422.8403237}, {-2770, -422.2168792}, {-2771, -421.5668712}, - {-2772, -420.8903714}, {-2773, -420.1874771}, {-2774, -419.4582879}, - {-2775, -418.7028715}, {-2776, -417.9213825}, {-2777, -417.1137861}, - {-2778, -416.2803019}, {-2779, -415.4209327}, {-2780, -414.5358943}, - {-2781, -413.6251312}, {-2782, -412.6888458}, {-2783, -411.7270655}, - {-2784, -410.7399148}, {-2785, -409.7274847}, {-2786, -408.6898657}, - {-2787, -407.6271404}, {-2788, -406.5394284}, {-2789, -405.4267938}, - {-2790, -404.2893696}, {-2791, -403.1272335}, {-2792, -401.9404474}, - {-2793, -400.7291418}, {-2794, -399.4934088}, {-2795, -398.2333711}, - {-2796, -396.9490299}, {-2797, -395.6405785}, {-2798, -394.308076}, - {-2799, -392.9516177}, {-2800, -391.5713067}, {-2801, -390.1672388}, - {-2802, -388.7395085}, {-2803, -387.2882153}, {-2804, -385.8134491}, - {-2805, -384.3153075}, {-2806, -382.7939005}, {-2807, -381.2493181}, - {-2808, -379.6816558}, {-2809, -378.0910249}, {-2810, -376.4774999}, - {-2811, -374.8412066}, {-2812, -373.1822196}, {-2813, -371.5006566}, - {-2814, -369.7966219}, {-2815, -368.0701723}, {-2816, -366.3214594}, - {-2817, -364.5452255}, {-2818, -362.7575606}, {-2819, -360.9426031}, - {-2820, -359.1057448}, {-2821, -357.2470893}, {-2822, -355.3667934}, - {-2823, -353.4648962}, {-2824, -351.5415439}, {-2825, -349.5967641}, - {-2826, -347.6307086}, {-2827, -345.6435516}, {-2828, -343.6352853}, - {-2829, -341.6060508}, {-2830, -339.5559549}, {-2831, -337.4850931}, - {-2832, -335.3936063}, {-2833, -333.2815078}, {-2834, -331.1489865}, - {-2835, -328.996123}, {-2836, -326.8230136}, {-2837, -324.6297733}, - {-2838, -322.4165006}, {-2839, -320.1832988}, {-2840, -317.9302898}, - {-2841, -315.6575283}, {-2842, -313.365187}, {-2843, -311.0533456}, - {-2844, -308.7221204}, {-2845, -306.3715636}, {-2846, -304.0018428}, - {-2847, -301.6130457}, {-2848, -299.2053149}, {-2849, -296.778661}, - {-2850, -294.3332804}, {-2851, -291.8692554}, {-2852, -289.3867056}, - {-2853, -286.8857231}, {-2854, -284.3664217}, {-2855, -281.8289128}, - {-2856, -279.2733058}, {-2857, -276.6997087}, {-2858, -274.1082124}, - {-2859, -271.4989838}, {-2860, -268.8720998}, {-2861, -266.2276524}, - {-2862, -263.5657728}, {-2863, -260.886575}, {-2864, -258.190162}, - {-2865, -255.4766579}, {-2866, -252.7461647}, {-2867, -249.9987893}, - {-2868, -247.2346697}, {-2869, -244.4539049}, {-2870, -241.6565952}, - {-2871, -238.8428795}, {-2872, -236.0128579}, {-2873, -233.1666485}, - {-2874, -230.3043697}, {-2875, -227.4261255}, {-2876, -224.532046}, - {-2877, -221.6222294}, {-2878, -218.6968306}, {-2879, -215.7559142}, - {-2880, -212.7996108}, {-2881, -209.8280943}, {-2882, -206.8414104}, - {-2883, -203.8397101}, {-2884, -200.8231036}, {-2885, -197.7917191}, - {-2886, -194.745683}, {-2887, -191.6850652}, {-2888, -188.6100502}, - {-2889, -185.5207141}, {-2890, -182.4171986}, {-2891, -179.2996279}, - {-2892, -176.1681099}, {-2893, -173.022772}, {-2894, -169.8637367}, - {-2895, -166.6911266}, {-2896, -163.5050648}, {-2897, -160.3056778}, - {-2898, -157.0930773}, {-2899, -153.8673994}, {-2900, -150.6287617}, - {-2901, -147.3772845}, {-2902, -144.1131245}, {-2903, -140.8363703}, - {-2904, -137.5471599}, {-2905, -134.245623}, {-2906, -130.9318931}, - {-2907, -127.6060709}, {-2908, -124.2683065}, {-2909, -120.9187348}, - {-2910, -117.5574669}, {-2911, -114.1846455}, {-2912, -110.8003821}, - {-2913, -107.4048223}, {-2914, -103.9980925}, {-2915, -100.5803218}, - {-2916, -97.15161443}, {-2917, -93.71218791}, {-2918, -90.26208616}, - {-2919, -86.80147629}, {-2920, -83.33048558}, {-2921, -79.84925152}, - {-2922, -76.35789883}, {-2923, -72.85658119}, {-2924, -69.34540752}, - {-2925, -65.82453605}, {-2926, -62.29409248}, {-2927, -58.75421594}, - {-2928, -55.2050424}, {-2929, -51.64670934}, {-2930, -48.07935375}, - {-2931, -44.50311696}, {-2932, -40.91813601}, {-2933, -37.32455181}, - {-2934, -33.72250329}, {-2935, -30.11213021}, {-2936, -26.49357551}, - {-2937, -22.86698026}, {-2938, -19.23248746}, {-2939, -15.59023879}, - {-2940, -11.94037722}, {-2941, -8.283049528}, {-2942, -4.61839757}, - {-2943, -0.9465667096}, {-2944, 2.732296904}, {-2945, 6.41804652}, - {-2946, 10.11053603}, {-2947, 13.80961679}, {-2948, 17.5151423}, - {-2949, 21.22696456}, {-2950, 24.94493179}, {-2951, 28.66889572}, - {-2952, 32.39870438}, {-2953, 36.13420824}, {-2954, 39.87525524}, - {-2955, 43.62169196}, {-2956, 47.37336545}, {-2957, 51.13012322}, - {-2958, 54.89180698}, {-2959, 58.65827089}, {-2960, 62.42934404}, - {-2961, 66.2048854}, {-2962, 69.98472912}, {-2963, 73.76871333}, - {-2964, 77.55669237}, {-2965, 81.34850243}, {-2966, 85.14397702}, - {-2967, 88.94296449}, {-2968, 92.74528758}, {-2969, 96.55080013}, - {-2970, 100.3593323}, {-2971, 104.170725}, {-2972, 107.9848083}, - {-2973, 111.801418}, {-2974, 115.6203874}, {-2975, 119.4415738}, - {-2976, 123.2647452}, {-2977, 127.0897954}, {-2978, 130.9165312}, - {-2979, 134.7447889}, {-2980, 138.5743905}, {-2981, 142.4051704}, - {-2982, 146.2369521}, {-2983, 150.0695593}, {-2984, 153.902823}, - {-2985, 157.7365695}, {-2986, 161.5706172}, {-2987, 165.404789}, - {-2988, 169.2389147}, {-2989, 173.0727962}, {-2990, 176.9062718}, - {-2991, 180.7391523}, {-2992, 184.5712622}, {-2993, 188.4024214}, - {-2994, 192.2324214}, {-2995, 196.0611014}, {-2996, 199.8882735}, - {-2997, 203.7137417}, {-2998, 207.5373262}, {-2999, 211.3588207}, - {-3000, 215.1780691}}; +extern const double NegLinearInt[3001][2]; + +/** + * @brief NegLinearInt Transpose of NegLinearInt + */ +const std::vector> NegLinearIntTransposed = { + {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, + 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, + 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, + 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, + 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, + 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, + 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, + 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, + 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, + 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, + 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, + 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, + 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, + 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, + 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, + 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, + 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, + 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, + 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, + 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, + 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, + 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, + 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, + 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, + 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, + 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, + 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, + 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, + 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, + 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, + 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, + 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, + 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, + 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, + 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, + 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, + 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, + 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, + 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, + 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, + 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, + 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, + 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, + 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, + 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, + 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, + 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, + 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, + 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, + 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, + 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, + 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, + 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, + 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, + 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, + 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, + 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, + 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, + 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, + 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, + 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, + 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, + 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, + 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, + 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, + 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, + 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, + 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, + 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, + 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, + 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, + 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, + 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, + 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, + 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, + 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, + 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, + 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, + 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, + 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, + 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, + 1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, + 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, + 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, + 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, + 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, + 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, + 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, + 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, + 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, + 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, + 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, + 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, + 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, + 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, + 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, + 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, + 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691, + 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, + 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, + 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, + 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, + 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, + 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, + 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, + 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, + 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, + 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, + 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, + 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, + 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, + 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, + 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, + 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, + 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, + 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, + 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, + 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, + 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, + 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, + 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, + 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, + 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, + 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, + 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, + 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, + 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, + 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, + 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, + 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, + 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, + 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, + 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, 2109, 2110, 2111, + 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, 2123, + 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, + 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, + 2148, 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, + 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, + 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, + 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, + 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2206, 2207, + 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, + 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, + 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, + 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, + 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, + 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, + 2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, + 2292, 2293, 2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, + 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, + 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, + 2328, 2329, 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, + 2340, 2341, 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, + 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, + 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, + 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, + 2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, + 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, + 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, + 2424, 2425, 2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, + 2436, 2437, 2438, 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 2447, + 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459, + 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, + 2472, 2473, 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, + 2484, 2485, 2486, 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 2495, + 2496, 2497, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505, 2506, 2507, + 2508, 2509, 2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, + 2520, 2521, 2522, 2523, 2524, 2525, 2526, 2527, 2528, 2529, 2530, 2531, + 2532, 2533, 2534, 2535, 2536, 2537, 2538, 2539, 2540, 2541, 2542, 2543, + 2544, 2545, 2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553, 2554, 2555, + 2556, 2557, 2558, 2559, 2560, 2561, 2562, 2563, 2564, 2565, 2566, 2567, + 2568, 2569, 2570, 2571, 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, + 2580, 2581, 2582, 2583, 2584, 2585, 2586, 2587, 2588, 2589, 2590, 2591, + 2592, 2593, 2594, 2595, 2596, 2597, 2598, 2599, 2600, 2601, 2602, 2603, + 2604, 2605, 2606, 2607, 2608, 2609, 2610, 2611, 2612, 2613, 2614, 2615, + 2616, 2617, 2618, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, + 2628, 2629, 2630, 2631, 2632, 2633, 2634, 2635, 2636, 2637, 2638, 2639, + 2640, 2641, 2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649, 2650, 2651, + 2652, 2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662, 2663, + 2664, 2665, 2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, + 2676, 2677, 2678, 2679, 2680, 2681, 2682, 2683, 2684, 2685, 2686, 2687, + 2688, 2689, 2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697, 2698, 2699, + 2700, 2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, + 2712, 2713, 2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, + 2724, 2725, 2726, 2727, 2728, 2729, 2730, 2731, 2732, 2733, 2734, 2735, + 2736, 2737, 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745, 2746, 2747, + 2748, 2749, 2750, 2751, 2752, 2753, 2754, 2755, 2756, 2757, 2758, 2759, + 2760, 2761, 2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, 2770, 2771, + 2772, 2773, 2774, 2775, 2776, 2777, 2778, 2779, 2780, 2781, 2782, 2783, + 2784, 2785, 2786, 2787, 2788, 2789, 2790, 2791, 2792, 2793, 2794, 2795, + 2796, 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, 2805, 2806, 2807, + 2808, 2809, 2810, 2811, 2812, 2813, 2814, 2815, 2816, 2817, 2818, 2819, + 2820, 2821, 2822, 2823, 2824, 2825, 2826, 2827, 2828, 2829, 2830, 2831, + 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841, 2842, 2843, + 2844, 2845, 2846, 2847, 2848, 2849, 2850, 2851, 2852, 2853, 2854, 2855, + 2856, 2857, 2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, 2866, 2867, + 2868, 2869, 2870, 2871, 2872, 2873, 2874, 2875, 2876, 2877, 2878, 2879, + 2880, 2881, 2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889, 2890, 2891, + 2892, 2893, 2894, 2895, 2896, 2897, 2898, 2899, 2900, 2901, 2902, 2903, + 2904, 2905, 2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, + 2916, 2917, 2918, 2919, 2920, 2921, 2922, 2923, 2924, 2925, 2926, 2927, + 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2939, + 2940, 2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, + 2952, 2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, + 2964, 2965, 2966, 2967, 2968, 2969, 2970, 2971, 2972, 2973, 2974, 2975, + 2976, 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985, 2986, 2987, + 2988, 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, + 3000}, + {-2.16465, -2.81845, -3.22285, -3.42892, -3.46485, -3.35103, -3.10376, + -2.73681, -2.26226, -1.691, -1.03302, -0.297651, 0.506268, 1.37029, + 2.28626, 3.24622, 4.24234, 5.26689, 6.31214, 7.37034, 8.43366, + 9.4941, 10.5435, 11.5734, 12.575, 13.5392, 14.4561, 15.3155, + 16.1061, 16.8158, 17.4311, 17.9371, 18.3165, 18.5494, 18.612, + 18.4748, 18.0994, 17.4327, 16.3916, 14.8107, 12.1662, 9.29873, + 6.55297, 3.92694, 1.4187, -0.973639, -3.25195, -5.41807, -7.47383, + -9.42101, -11.2614, -12.9967, -14.6288, -16.1592, -17.5897, -18.922, + -20.1578, -21.2986, -22.3462, -23.3021, -24.1679, -24.9454, -25.636, + -26.2413, -26.7629, -27.2024, -27.5613, -27.8411, -28.0435, -28.1699, + -28.2218, -28.2008, -28.1085, -27.9462, -27.7156, -27.4181, -27.0553, + -26.6287, -26.1397, -25.5899, -24.9808, -24.3138, -23.5906, -22.8126, + -21.9814, -21.0984, -20.1651, -19.1832, -18.1542, -17.0795, -15.9608, + -14.7995, -13.5973, -12.3558, -11.0764, -9.76091, -8.4108, -7.02773, + -5.61332, -4.16922, -2.6971, -1.19864, 0.324478, 1.87053, 3.43778, + 5.02448, 6.62884, 8.24907, 9.88334, 11.5298, 13.1865, 14.8517, + 16.5232, 18.1992, 19.8777, 21.5565, 23.2336, 24.9069, 26.5741, + 28.2329, 29.8812, 31.5165, 33.1364, 34.7384, 36.32, 37.8785, + 39.4112, 40.9152, 42.3878, 43.8257, 45.226, 46.5852, 47.9001, + 49.167, 50.3822, 51.5418, 52.6416, 53.6773, 54.6443, 55.5376, + 56.3519, 57.0818, 57.721, 58.263, 58.7007, 59.0263, 59.2311, + 59.3054, 59.2383, 59.0176, 58.6289, 58.0554, 57.2767, 56.268, + 54.9967, 53.4189, 51.4689, 49.0315, 45.7413, 41.6262, 37.6, + 33.6623, 29.8123, 26.0495, 22.3732, 18.7829, 15.2779, 11.8576, + 8.52136, 5.26863, 2.09877, -0.988822, -3.99476, -6.91965, -9.76409, + -12.5287, -15.2141, -17.8209, -20.3496, -22.8009, -25.1754, -27.4738, + -29.6965, -31.8442, -33.9175, -35.917, -37.8434, -39.6971, -41.4789, + -43.1893, -44.8289, -46.3983, -47.8981, -49.329, -50.6915, -51.9863, + -53.2139, -54.3749, -55.47, -56.4998, -57.4648, -58.3657, -59.203, + -59.9774, -60.6896, -61.34, -61.9293, -62.4582, -62.9272, -63.3369, + -63.688, -63.981, -64.2167, -64.3956, -64.5182, -64.5854, -64.5975, + -64.5554, -64.4596, -64.3107, -64.1094, -63.8563, -63.5519, -63.1971, + -62.7923, -62.3383, -61.8356, -61.2849, -60.6868, -60.042, -59.3512, + -58.6149, -57.8339, -57.0087, -56.1401, -55.2287, -54.2751, -53.2801, + -52.2443, -51.1683, -50.0528, -48.8986, -47.7062, -46.4764, -45.2099, + -43.9073, -42.5694, -41.1968, -39.7903, -38.3505, -36.8781, -35.3739, + -33.8387, -32.273, -30.6777, -29.0534, -27.401, -25.7211, -24.0146, + -22.2821, -20.5244, -18.7422, -16.9365, -15.1079, -13.2572, -11.3852, + -9.49267, -7.58049, -5.64942, -3.70029, -1.73393, 0.248825, 2.24714, + 4.26016, 6.28703, 8.32687, 10.3788, 12.442, 14.5154, 16.5983, + 18.6896, 20.7885, 22.894, 25.0052, 27.1211, 29.2406, 31.3629, + 33.4869, 35.6116, 37.7359, 39.8589, 41.9794, 44.0964, 46.2087, + 48.3152, 50.4149, 52.5065, 54.5888, 56.6607, 58.721, 60.7684, + 62.8015, 64.8193, 66.8202, 68.803, 70.7663, 72.7086, 74.6286, + 76.5248, 78.3955, 80.2394, 82.0547, 83.84, 85.5934, 87.3132, + 88.9978, 90.6453, 92.2535, 93.8209, 95.3453, 96.8246, 98.2567, + 99.6393, 100.97, 102.247, 103.467, 104.627, 105.726, 106.759, + 107.725, 108.619, 109.44, 110.182, 110.843, 111.418, 111.903, + 112.294, 112.587, 112.775, 112.853, 112.816, 112.657, 112.368, + 111.941, 111.368, 110.639, 109.742, 108.664, 107.389, 105.9, + 104.173, 102.179, 99.881, 97.223, 94.1156, 90.3639, 85.4774, + 80.4874, 75.5704, 70.7263, 65.9546, 61.255, 56.6273, 52.0712, + 47.5862, 43.172, 38.8285, 34.5551, 30.3517, 26.2179, 22.1533, + 18.1577, 14.2307, 10.372, 6.58129, 2.85824, -0.79747, -4.38616, + -7.90816, -11.3638, -14.7534, -18.0772, -21.3357, -24.529, -27.6577, + -30.7218, -33.7219, -36.6582, -39.5311, -42.3408, -45.0877, -47.7721, + -50.3944, -52.9548, -55.4538, -57.8916, -60.2677, -62.5849, -64.8412, + -67.0375, -69.1744, -71.252, -73.2708, -75.2311, -77.1331, -78.9773, + -80.7639, -82.4933, -84.1658, -85.7818, -87.3416, -88.8455, -90.2939, + -91.687, -93.0253, -94.3091, -95.5387, -96.7143, -97.8365, -98.9056, + -99.9217, -100.885, -101.797, -102.657, -103.465, -104.222, -104.928, + -105.584, -106.19, -106.746, -107.253, -107.71, -108.119, -108.48, + -108.792, -109.057, -109.275, -109.445, -109.569, -109.647, -109.679, + -109.665, -109.606, -109.503, -109.355, -109.162, -108.926, -108.647, + -108.325, -107.96, -107.553, -107.103, -106.613, -106.081, -105.508, + -104.895, -104.242, -103.549, -102.817, -102.046, -101.236, -100.388, + -99.5027, -98.5796, -97.6195, -96.6228, -95.5898, -94.5209, -93.4165, + -92.277, -91.1028, -89.8944, -88.6519, -87.376, -86.067, -84.7252, + -83.3511, -81.9451, -80.5076, -79.039, -77.5397, -76.0102, -74.4507, + -72.8618, -71.2439, -69.5974, -67.9227, -66.2202, -64.4903, -62.7336, + -60.9503, -59.141, -57.3061, -55.446, -53.5612, -51.652, -49.719, + -47.7626, -45.7833, -43.7814, -41.7575, -39.7121, -37.6454, -35.5581, + -33.4507, -31.3234, -29.177, -27.0117, -24.8282, -22.6268, -20.4081, + -18.1726, -15.9207, -13.653, -11.3699, -9.072, -6.75974, -4.43366, + -2.09427, 0.257911, 2.62236, 4.99854, 7.38592, 9.78397, 12.1921, + 14.6099, 17.0367, 19.4719, 21.915, 24.3655, 26.8228, 29.2862, + 31.7552, 34.2293, 36.7077, 39.19, 41.6755, 44.1637, 46.6537, + 49.1452, 51.6373, 54.1295, 56.6212, 59.1116, 61.6001, 64.0861, + 66.5688, 69.0476, 71.5218, 73.9906, 76.4534, 78.9094, 81.3579, + 83.7982, 86.2295, 88.651, 91.0619, 93.4615, 95.849, 98.2235, + 100.584, 102.93, 105.261, 107.576, 109.873, 112.152, 114.412, + 116.652, 118.871, 121.069, 123.243, 125.394, 127.52, 129.62, + 131.693, 133.738, 135.755, 137.74, 139.695, 141.616, 143.504, + 145.357, 147.174, 148.953, 150.693, 152.393, 154.051, 155.666, + 157.236, 158.76, 160.236, 161.663, 163.038, 164.361, 165.629, + 166.841, 167.994, 169.087, 170.117, 171.082, 171.981, 172.81, + 173.567, 174.25, 174.856, 175.382, 175.826, 176.183, 176.451, + 176.626, 176.705, 176.683, 176.557, 176.321, 175.971, 175.502, + 174.907, 174.181, 173.317, 172.307, 171.142, 169.814, 168.311, + 166.62, 164.729, 162.619, 160.269, 157.653, 154.737, 151.473, + 147.787, 143.539, 138.236, 132.442, 126.711, 121.044, 115.441, + 109.9, 104.423, 99.0076, 93.6551, 88.3649, 83.1368, 77.9705, + 72.8659, 67.8228, 62.841, 57.9202, 53.0603, 48.2611, 43.5223, + 38.8437, 34.2252, 29.6666, 25.1675, 20.7279, 16.3476, 12.0262, + 7.76365, 3.55971, -0.585837, -4.67319, -8.70255, -12.6741, -16.5881, + -20.4448, -24.2443, -27.9868, -31.6726, -35.3019, -38.8748, -42.3916, + -45.8526, -49.2578, -52.6075, -55.902, -59.1413, -62.3259, -65.4557, + -68.5312, -71.5524, -74.5196, -77.433, -80.2928, -83.0992, -85.8525, + -88.5528, -91.2004, -93.7954, -96.3381, -98.8288, -101.268, -103.655, + -105.99, -108.275, -110.508, -112.69, -114.822, -116.904, -118.935, + -120.917, -122.849, -124.731, -126.564, -128.348, -130.083, -131.769, + -133.407, -134.997, -136.539, -138.033, -139.48, -140.879, -142.231, + -143.536, -144.795, -146.007, -147.173, -148.294, -149.368, -150.397, + -151.38, -152.319, -153.213, -154.062, -154.866, -155.627, -156.343, + -157.016, -157.646, -158.232, -158.775, -159.276, -159.734, -160.149, + -160.523, -160.854, -161.144, -161.393, -161.6, -161.767, -161.893, + -161.978, -162.024, -162.029, -161.995, -161.921, -161.808, -161.656, + -161.465, -161.235, -160.967, -160.662, -160.318, -159.937, -159.519, + -159.063, -158.571, -158.042, -157.477, -156.876, -156.238, -155.566, + -154.858, -154.115, -153.337, -152.524, -151.677, -150.796, -149.882, + -148.934, -147.952, -146.937, -145.89, -144.81, -143.698, -142.554, + -141.378, -140.17, -138.932, -137.662, -136.362, -135.031, -133.67, + -132.279, -130.859, -129.409, -127.93, -126.423, -124.887, -123.322, + -121.73, -120.109, -118.462, -116.787, -115.085, -113.357, -111.603, + -109.822, -108.016, -106.184, -104.327, -102.445, -100.539, -98.6078, + -96.653, -94.6745, -92.6725, -90.6473, -88.5993, -86.5288, -84.436, + -82.3213, -80.1849, -78.0272, -75.8485, -73.649, -71.4291, -69.189, + -66.9292, -64.6499, -62.3514, -60.0341, -57.6981, -55.344, -52.972, + -50.5824, -48.1755, -45.7517, -43.3113, -40.8547, -38.382, -35.8938, + -33.3903, -30.8719, -28.3389, -25.7916, -23.2304, -20.6557, -18.0677, + -15.4669, -12.8535, -10.228, -7.59073, -4.94198, -2.28216, 0.388381, + 3.06927, 5.76014, 8.46062, 11.1703, 13.8889, 16.616, 19.3511, + 22.094, 24.8442, 27.6013, 30.3649, 33.1348, 35.9103, 38.6912, + 41.477, 44.2673, 47.0618, 49.8599, 52.6614, 55.4656, 58.2723, + 61.081, 63.8913, 66.7027, 69.5147, 72.327, 75.1391, 77.9505, + 80.7608, 83.5694, 86.3761, 89.1802, 91.9813, 94.7788, 97.5725, + 100.362, 103.146, 105.925, 108.697, 111.464, 114.223, 116.975, + 119.718, 122.453, 125.179, 127.896, 130.602, 133.297, 135.981, + 138.653, 141.312, 143.958, 146.591, 149.209, 151.812, 154.4, + 156.971, 159.526, 162.063, 164.582, 167.082, 169.563, 172.024, + 174.463, 176.881, 179.277, 181.65, 183.999, 186.323, 188.622, + 190.895, 193.141, 195.359, 197.549, 199.709, 201.839, 203.938, + 206.005, 208.039, 210.039, 212.004, 213.933, 215.826, 217.68, + 219.496, 221.272, 223.007, 224.7, 226.35, 227.955, 229.515, + 231.028, 232.492, 233.907, 235.272, 236.584, 237.843, 239.047, + 240.194, 241.283, 242.312, 243.28, 244.185, 245.025, 245.799, + 246.504, 247.138, 247.699, 248.186, 248.595, 248.925, 249.173, + 249.336, 249.412, 249.398, 249.29, 249.087, 248.783, 248.376, + 247.862, 247.236, 246.495, 245.634, 244.646, 243.528, 242.273, + 240.874, 239.324, 237.615, 235.738, 233.682, 231.436, 228.986, + 226.316, 223.406, 220.232, 216.762, 212.954, 208.744, 204.02, + 198.451, 191.954, 185.514, 179.131, 172.804, 166.535, 160.322, + 154.165, 148.065, 142.021, 136.033, 130.101, 124.225, 118.404, + 112.638, 106.929, 101.274, 95.674, 90.1292, 84.639, 79.2035, + 73.8225, 68.4957, 63.2231, 58.0046, 52.8399, 47.729, 42.6716, + 37.6677, 32.7171, 27.8196, 22.9752, 18.1836, 13.4447, 8.7584, + 4.12452, -0.457087, -4.98656, -9.46405, -13.8897, -18.2637, -22.5861, + -26.8571, -31.0769, -35.2456, -39.3633, -43.4302, -47.4465, -51.4122, + -55.3276, -59.1928, -63.0079, -66.7731, -70.4886, -74.1544, -77.7708, + -81.3378, -84.8557, -88.3246, -91.7446, -95.1159, -98.4386, -101.713, + -104.939, -108.117, -111.247, -114.329, -117.364, -120.351, -123.29, + -126.183, -129.028, -131.827, -134.579, -137.284, -139.943, -142.555, + -145.122, -147.642, -150.117, -152.546, -154.929, -157.267, -159.56, + -161.808, -164.011, -166.17, -168.283, -170.353, -172.378, -174.359, + -176.296, -178.189, -180.039, -181.845, -183.608, -185.327, -187.004, + -188.638, -190.229, -191.778, -193.285, -194.749, -196.171, -197.551, + -198.89, -200.187, -201.443, -202.657, -203.83, -204.963, -206.055, + -207.106, -208.117, -209.087, -210.018, -210.908, -211.759, -212.571, + -213.342, -214.075, -214.769, -215.423, -216.039, -216.616, -217.155, + -217.656, -218.118, -218.543, -218.93, -219.279, -219.591, -219.866, + -220.104, -220.304, -220.468, -220.596, -220.687, -220.742, -220.761, + -220.744, -220.691, -220.603, -220.479, -220.321, -220.127, -219.898, + -219.635, -219.338, -219.006, -218.64, -218.24, -217.806, -217.339, + -216.839, -216.305, -215.738, -215.138, -214.506, -213.841, -213.144, + -212.414, -211.653, -210.86, -210.036, -209.18, -208.292, -207.374, + -206.425, -205.445, -204.435, -203.395, -202.324, -201.224, -200.094, + -198.934, -197.745, -196.527, -195.279, -194.003, -192.699, -191.366, + -190.005, -188.616, -187.199, -185.755, -184.283, -182.784, -181.257, + -179.705, -178.125, -176.519, -174.887, -173.229, -171.544, -169.835, + -168.1, -166.339, -164.554, -162.744, -160.909, -159.05, -157.166, + -155.259, -153.328, -151.373, -149.395, -147.394, -145.37, -143.323, + -141.253, -139.162, -137.048, -134.912, -132.754, -130.576, -128.376, + -126.154, -123.912, -121.65, -119.367, -117.064, -114.741, -112.399, + -110.036, -107.655, -105.255, -102.836, -100.398, -97.9419, -95.4676, + -92.9756, -90.4659, -87.9388, -85.3945, -82.8333, -80.2553, -77.6609, + -75.0503, -72.4236, -69.7812, -67.1233, -64.4501, -61.7619, -59.0588, + -56.3413, -53.6094, -50.8636, -48.1039, -45.3306, -42.5441, -39.7445, + -36.9322, -34.1073, -31.2702, -28.421, -25.5601, -22.6876, -19.804, + -16.9094, -14.0041, -11.0883, -8.16242, -5.22661, -2.28118, 0.6736, + 3.63746, 6.61011, 9.59128, 12.5807, 15.5781, 18.5831, 21.5956, + 24.6151, 27.6415, 30.6745, 33.7135, 36.7586, 39.8093, 42.8654, + 45.9265, 48.9924, 52.0627, 55.1371, 58.2154, 61.2972, 64.3822, + 67.4701, 70.5606, 73.6533, 76.748, 79.8443, 82.9418, 86.0404, + 89.1395, 92.239, 95.3384, 98.4375, 101.536, 104.633, 107.729, + 110.823, 113.915, 117.004, 120.091, 123.175, 126.255, 129.331, + 132.402, 135.469, 138.532, 141.588, 144.639, 147.684, 150.722, + 153.753, 156.776, 159.792, 162.8, 165.799, 168.789, 171.77, + 174.741, 177.702, 180.651, 183.59, 186.517, 189.432, 192.335, + 195.225, 198.101, 200.964, 203.812, 206.645, 209.463, 212.265, + 215.051, 217.82, 220.572, 223.306, 226.022, 228.719, 231.396, + 234.054, 236.691, 239.307, 241.902, 244.475, 247.024, 249.551, + 252.053, 254.531, 256.984, 259.411, 261.812, 264.186, 266.532, + 268.849, 271.138, 273.397, 275.626, 277.823, 279.989, 282.122, + 284.222, 286.288, 288.318, 290.314, 292.273, 294.194, 296.078, + 297.922, 299.727, 301.491, 303.213, 304.893, 306.529, 308.121, + 309.667, 311.167, 312.619, 314.023, 315.377, 316.68, 317.931, + 319.129, 320.272, 321.36, 322.39, 323.363, 324.276, 325.127, + 325.916, 326.641, 327.301, 327.893, 328.416, 328.868, 329.248, + 329.554, 329.784, 329.935, 330.006, 329.994, 329.897, 329.713, + 329.439, 329.073, 328.611, 328.051, 327.39, 326.624, 325.75, + 324.764, 323.662, 322.44, 321.094, 319.617, 318.006, 316.253, + 314.353, 312.299, 310.082, 307.695, 305.126, 302.365, 299.399, + 296.212, 292.785, 289.096, 285.116, 280.804, 276.106, 270.926, + 265.05, 258.031, 250.953, 243.928, 236.955, 230.034, 223.165, + 216.348, 209.582, 202.868, 196.206, 189.594, 183.034, 176.525, + 170.067, 163.66, 157.304, 150.998, 144.744, 138.539, 132.385, + 126.281, 120.228, 114.224, 108.27, 102.367, 96.5125, 90.708, + 84.953, 79.2474, 73.5911, 67.9839, 62.4258, 56.9167, 51.4565, + 46.0449, 40.682, 35.3677, 30.1017, 24.884, 19.7145, 14.5931, + 9.51967, 4.49408, -0.483758, -5.41396, -10.2966, -15.1319, -19.9199, + -24.6607, -29.3543, -34.0011, -38.601, -43.1541, -47.6606, -52.1206, + -56.5341, -60.9014, -65.2225, -69.4975, -73.7266, -77.9098, -82.0473, + -86.1392, -90.1855, -94.1865, -98.1422, -102.053, -105.918, -109.739, + -113.514, -117.245, -120.932, -124.574, -128.171, -131.725, -135.234, + -138.699, -142.12, -145.498, -148.832, -152.122, -155.369, -158.572, + -161.732, -164.85, -167.924, -170.955, -173.944, -176.89, -179.793, + -182.654, -185.473, -188.249, -190.984, -193.677, -196.327, -198.937, + -201.504, -204.03, -206.515, -208.959, -211.361, -213.723, -216.043, + -218.323, -220.563, -222.761, -224.92, -227.038, -229.116, -231.154, + -233.152, -235.111, -237.029, -238.909, -240.748, -242.549, -244.31, + -246.032, -247.716, -249.36, -250.966, -252.534, -254.063, -255.553, + -257.006, -258.42, -259.796, -261.135, -262.436, -263.699, -264.925, + -266.114, -267.265, -268.38, -269.457, -270.498, -271.502, -272.469, + -273.4, -274.294, -275.153, -275.975, -276.762, -277.512, -278.227, + -278.907, -279.551, -280.16, -280.733, -281.272, -281.776, -282.244, + -282.679, -283.079, -283.444, -283.775, -284.072, -284.335, -284.564, + -284.76, -284.922, -285.05, -285.145, -285.207, -285.236, -285.232, + -285.195, -285.125, -285.023, -284.889, -284.722, -284.523, -284.292, + -284.029, -283.735, -283.409, -283.051, -282.662, -282.242, -281.791, + -281.309, -280.797, -280.253, -279.68, -279.075, -278.441, -277.777, + -277.082, -276.358, -275.604, -274.821, -274.008, -273.166, -272.295, + -271.395, -270.467, -269.509, -268.523, -267.509, -266.466, -265.396, + -264.297, -263.171, -262.017, -260.835, -259.626, -258.39, -257.127, + -255.836, -254.519, -253.176, -251.806, -250.409, -248.987, -247.538, + -246.064, -244.563, -243.037, -241.486, -239.91, -238.308, -236.681, + -235.03, -233.353, -231.653, -229.927, -228.178, -226.405, -224.607, + -222.786, -220.942, -219.074, -217.182, -215.268, -213.33, -211.37, + -209.387, -207.381, -205.353, -203.303, -201.231, -199.137, -197.022, + -194.885, -192.726, -190.547, -188.346, -186.124, -183.882, -181.619, + -179.336, -177.032, -174.709, -172.365, -170.002, -167.619, -165.217, + -162.796, -160.356, -157.897, -155.419, -152.922, -150.407, -147.874, + -145.323, -142.755, -140.168, -137.564, -134.943, -132.305, -129.649, + -126.977, -124.288, -121.583, -118.862, -116.125, -113.371, -110.602, + -107.818, -105.018, -102.203, -99.3733, -96.5286, -93.6694, -90.7957, + -87.9079, -85.006, -82.0904, -79.161, -76.2183, -73.2623, -70.2932, + -67.3113, -64.3167, -61.3096, -58.2902, -55.2588, -52.2155, -49.1604, + -46.094, -43.0162, -39.9273, -36.8276, -33.7172, -30.5963, -27.4652, + -24.324, -21.1729, -18.0122, -14.8421, -11.6628, -8.4744, -5.27724, + -2.07151, 1.1426, 4.36486, 7.59506, 10.833, 14.0784, 17.3311, + 20.5908, 23.8574, 27.1306, 30.4102, 33.6959, 36.9876, 40.285, + 43.5878, 46.8959, 50.209, 53.5269, 56.8493, 60.176, 63.5068, + 66.8414, 70.1796, 73.5211, 76.8657, 80.2132, 83.5633, 86.9158, + 90.2703, 93.6267, 96.9847, 100.344, 103.705, 107.066, 110.428, + 113.79, 117.152, 120.514, 123.876, 127.237, 130.596, 133.955, + 137.312, 140.667, 144.02, 147.37, 150.718, 154.063, 157.405, + 160.743, 164.078, 167.408, 170.734, 174.055, 177.371, 180.682, + 183.987, 187.286, 190.579, 193.865, 197.145, 200.418, 203.683, + 206.94, 210.189, 213.429, 216.661, 219.884, 223.097, 226.3, + 229.494, 232.676, 235.848, 239.009, 242.158, 245.295, 248.42, + 251.533, 254.632, 257.718, 260.79, 263.849, 266.892, 269.921, + 272.934, 275.932, 278.914, 281.879, 284.827, 287.758, 290.672, + 293.567, 296.443, 299.301, 302.139, 304.957, 307.755, 310.532, + 313.287, 316.021, 318.733, 321.422, 324.088, 326.73, 329.349, + 331.942, 334.511, 337.053, 339.57, 342.059, 344.522, 346.957, + 349.363, 351.74, 354.088, 356.406, 358.693, 360.949, 363.173, + 365.366, 367.523, 369.647, 371.738, 373.793, 375.812, 377.795, + 379.741, 381.649, 383.518, 385.348, 387.138, 388.887, 390.595, + 392.26, 393.882, 395.46, 396.993, 398.48, 399.921, 401.314, + 402.659, 403.954, 405.199, 406.392, 407.533, 408.621, 409.654, + 410.632, 411.552, 412.415, 413.219, 413.962, 414.644, 415.263, + 415.818, 416.307, 416.729, 417.082, 417.365, 417.577, 417.716, + 417.779, 417.766, 417.674, 417.502, 417.247, 416.908, 416.482, + 415.967, 415.361, 414.661, 413.865, 412.97, 411.972, 410.87, + 409.659, 408.336, 406.898, 405.341, 403.66, 401.851, 399.91, + 397.83, 395.606, 393.233, 390.702, 388.007, 385.166, 382.087, + 378.842, 375.39, 371.717, 367.806, 363.633, 359.172, 354.386, + 349.223, 343.601, 337.35, 329.951, 322.291, 314.68, 307.117, + 299.603, 292.137, 284.718, 277.348, 270.026, 262.751, 255.524, + 248.345, 241.213, 234.129, 227.093, 220.103, 213.161, 206.266, + 199.418, 192.617, 185.863, 179.156, 172.495, 165.881, 159.314, + 152.793, 146.318, 139.89, 133.508, 127.172, 120.882, 114.639, + 108.441, 102.288, 96.1817, 90.1207, 84.1053, 78.1352, 72.2106, + 66.3312, 60.497, 54.7078, 48.9637, 43.2645, 37.6101, 32.0004, + 26.4354, 20.915, 15.439, 10.0075, 4.62023, -0.722813, -6.02172, + -11.2766, -16.4875, -21.6546, -26.7778, -31.8574, -36.8934, -41.8859, + -46.8349, -51.7406, -56.6031, -61.4224, -66.1986, -70.9318, -75.6222, + -80.2697, -84.8746, -89.4368, -93.9565, -98.4337, -102.869, -107.261, + -111.612, -115.92, -120.186, -124.411, -128.593, -132.734, -136.833, + -140.891, -144.907, -148.882, -152.816, -156.708, -160.56, -164.37, + -168.139, -171.868, -175.556, -179.203, -182.81, -186.376, -189.902, + -193.387, -196.833, -200.238, -203.603, -206.929, -210.214, -213.46, + -216.667, -219.833, -222.961, -226.049, -229.097, -232.107, -235.077, + -238.009, -240.902, -243.755, -246.571, -249.347, -252.085, -254.785, + -257.446, -260.069, -262.654, -265.201, -267.71, -270.181, -272.615, + -275.011, -277.369, -279.69, -281.973, -284.219, -286.428, -288.6, + -290.735, -292.833, -294.894, -296.919, -298.907, -300.858, -302.774, + -304.652, -306.495, -308.301, -310.072, -311.806, -313.505, -315.168, + -316.795, -318.387, -319.944, -321.465, -322.951, -324.402, -325.817, + -327.198, -328.544, -329.855, -331.132, -332.374, -333.582, -334.755, + -335.894, -336.999, -338.07, -339.107, -340.11, -341.08, -342.016, + -342.918, -343.787, -344.623, -345.425, -346.194, -346.931, -347.634, + -348.304, -348.942, -349.547, -350.12, -350.66, -351.168, -351.644, + -352.088, -352.5, -352.88, -353.228, -353.544, -353.829, -354.083, + -354.305, -354.495, -354.655, -354.784, -354.881, -354.948, -354.984, + -354.99, -354.965, -354.91, -354.824, -354.708, -354.562, -354.386, + -354.18, -353.945, -353.68, -353.385, -353.061, -352.707, -352.324, + -351.913, -351.472, -351.002, -350.504, -349.977, -349.421, -348.837, + -348.224, -347.584, -346.915, -346.218, -345.493, -344.741, -343.961, + -343.153, -342.318, -341.455, -340.566, -339.649, -338.705, -337.734, + -336.737, -335.713, -334.662, -333.585, -332.482, -331.352, -330.197, + -329.015, -327.808, -326.575, -325.316, -324.032, -322.722, -321.387, + -320.027, -318.642, -317.232, -315.798, -314.338, -312.855, -311.346, + -309.814, -308.257, -306.676, -305.071, -303.442, -301.79, -300.114, + -298.414, -296.692, -294.946, -293.176, -291.384, -289.569, -287.732, + -285.871, -283.989, -282.083, -280.156, -278.207, -276.235, -274.242, + -272.227, -270.19, -268.132, -266.052, -263.952, -261.83, -259.687, + -257.523, -255.339, -253.134, -250.909, -248.663, -246.397, -244.111, + -241.805, -239.479, -237.134, -234.769, -232.384, -229.981, -227.558, + -225.116, -222.655, -220.176, -217.678, -215.161, -212.627, -210.073, + -207.502, -204.913, -202.306, -199.682, -197.04, -194.38, -191.704, + -189.01, -186.299, -183.572, -180.827, -178.067, -175.29, -172.496, + -169.687, -166.861, -164.02, -161.163, -158.29, -155.402, -152.499, + -149.58, -146.647, -143.699, -140.736, -137.759, -134.767, -131.761, + -128.741, -125.707, -122.659, -119.598, -116.523, -113.435, -110.334, + -107.219, -104.092, -100.952, -97.7999, -94.635, -91.4579, -88.2687, + -85.0675, -81.8546, -78.6301, -75.3941, -72.1469, -68.8884, -65.619, + -62.3388, -59.048, -55.7466, -52.4349, -49.1131, -45.7812, -42.4395, + -39.0881, -35.7273, -32.3571, -28.9777, -25.5893, -22.1921, -18.7863, + -15.3719, -11.9493, -8.51846, -5.07968, -1.6331, 1.8211, 5.28275, + 8.75167, 12.2277, 15.7106, 19.2003, 22.6965, 26.1991, 29.7079, + 33.2228, 36.7434, 40.2697, 43.8015, 47.3385, 50.8806, 54.4277, + 57.9794, 61.5357, 65.0963, 68.6611, 72.2298, 75.8023, 79.3783, + 82.9578, 86.5403, 90.1259, 93.7143, 97.3052, 100.898, 104.494, + 108.091, 111.691, 115.291, 118.894, 122.497, 126.101, 129.706, + 133.312, 136.918, 140.523, 144.129, 147.735, 151.34, 154.944, + 158.547, 162.149, 165.75, 169.349, 172.946, 176.541, 180.133, + 183.723, 187.311, 190.895, 194.476, 198.053, 201.627, 205.197, + 208.763, 212.324, 215.88, 219.432, 222.978, 226.519, 230.054, + 233.584, 237.107, 240.624, 244.134, 247.638, 251.133, 254.621, + 258.102, 261.574, 265.038, 268.494, 271.941, 275.379, 278.807, + 282.226, 285.635, 289.034, 292.422, 295.799, 299.165, 302.52, + 305.863, 309.195, 312.514, 315.82, 319.113, 322.393, 325.66, + 328.913, 332.152, 335.376, 338.585, 341.78, 344.959, 348.122, + 351.269, 354.399, 357.513, 360.609, 363.688, 366.75, 369.793, + 372.817, 375.822, 378.809, 381.775, 384.722, 387.647, 390.553, + 393.437, 396.299, 399.139, 401.957, 404.752, 407.524, 410.272, + 412.996, 415.696, 418.371, 421.02, 423.644, 426.241, 428.812, + 431.355, 433.871, 436.358, 438.817, 441.247, 443.648, 446.018, + 448.357, 450.666, 452.943, 455.188, 457.4, 459.579, 461.724, + 463.834, 465.91, 467.95, 469.954, 471.921, 473.851, 475.744, + 477.597, 479.411, 481.186, 482.919, 484.612, 486.263, 487.871, + 489.436, 490.956, 492.432, 493.862, 495.246, 496.583, 497.871, + 499.111, 500.301, 501.441, 502.529, 503.565, 504.55, 505.476, + 506.35, 507.167, 507.927, 508.628, 509.271, 509.852, 510.373, + 510.83, 511.224, 511.552, 511.814, 512.008, 512.133, 512.188, + 512.17, 512.079, 511.912, 511.67, 511.348, 510.947, 510.463, + 509.896, 509.243, 508.503, 507.672, 506.75, 505.732, 504.618, + 503.405, 502.089, 500.669, 499.14, 497.5, 495.745, 493.873, + 491.878, 489.757, 487.505, 485.119, 482.591, 479.918, 477.092, + 474.107, 470.955, 467.629, 464.118, 460.413, 456.5, 452.365, + 447.992, 443.358, 438.438, 433.198, 427.588, 421.534, 414.892, + 407.158, 398.959, 390.806, 382.698, 374.635, 366.617, 358.645, + 350.717, 342.834, 334.997, 327.204, 319.455, 311.752, 304.093, + 296.478, 288.908, 281.382, 273.901, 266.464, 259.071, 251.722, + 244.417, 237.156, 229.94, 222.766, 215.637, 208.551, 201.509, + 194.511, 187.556, 180.644, 173.776, 166.951, 160.169, 153.431, + 146.735, 140.083, 133.473, 126.906, 120.382, 113.901, 107.462, + 101.066, 94.7126, 88.4015, 82.1327, 75.9062, 69.722, 63.5799, + 57.4798, 51.4218, 45.4057, 39.4315, 33.499, 27.6083, 21.7593, + 15.9518, 10.1859, 4.46133, -1.22182, -6.86368, -12.4643, -18.0238, + -23.5422, -29.0196, -34.456, -39.8516, -45.2064, -50.5205, -55.7939, + -61.0268, -66.2191, -71.371, -76.4826, -81.5539, -86.5849, -91.5758, + -96.5266, -101.437, -106.308, -111.139, -115.931, -120.682, -125.394, + -130.067, -134.7, -139.293, -143.847, -148.362, -152.838, -157.274, + -161.672, -166.031, -170.35, -174.631, -178.873, -183.077, -187.241, + -191.368, -195.456, -199.505, -203.516, -207.489, -211.424, -215.321, + -219.18, -223., -226.783, -230.528, -234.236, -237.906, -241.538, + -245.133, -248.69, -252.21, -255.693, -259.139, -262.547, -265.919, + -269.254, -272.551, -275.812, -279.037, -282.224, -285.375, -288.49, + -291.568, -294.61, -297.615, -300.584, -303.518, -306.415, -309.276, + -312.102, -314.891, -317.645, -320.363, -323.046, -325.693, -328.305, + -330.882, -333.423, -335.929, -338.4, -340.836, -343.237, -345.603, + -347.935, -350.231, -352.493, -354.721, -356.914, -359.073, -361.197, + -363.287, -365.343, -367.365, -369.353, -371.308, -373.228, -375.114, + -376.967, -378.786, -380.572, -382.325, -384.044, -385.729, -387.382, + -389.001, -390.588, -392.141, -393.662, -395.15, -396.597, -398.027, + -399.418, -400.775, -402.1, -403.393, -404.654, -405.883, -407.079, + -408.244, -409.376, -410.477, -411.547, -412.584, -413.59, -414.565, + -415.508, -416.42, -417.301, -418.151, -418.969, -419.757, -420.514, + -421.24, -421.935, -422.6, -423.234, -423.837, -424.411, -424.954, + -425.467, -425.949, -426.402, -426.825, -427.218, -427.581, -427.914, + -428.218, -428.493, -428.738, -428.953, -429.14, -429.297, -429.425, + -429.524, -429.594, -429.636, -429.649, -429.633, -429.588, -429.515, + -429.414, -429.284, -429.127, -428.941, -428.727, -428.485, -428.215, + -427.918, -427.593, -427.24, -426.86, -426.453, -426.018, -425.556, + -425.066, -424.55, -424.007, -423.437, -422.84, -422.217, -421.567, + -420.89, -420.187, -419.458, -418.703, -417.921, -417.114, -416.28, + -415.421, -414.536, -413.625, -412.689, -411.727, -410.74, -409.727, + -408.69, -407.627, -406.539, -405.427, -404.289, -403.127, -401.94, + -400.729, -399.493, -398.233, -396.949, -395.641, -394.308, -392.952, + -391.571, -390.167, -388.74, -387.288, -385.813, -384.315, -382.794, + -381.249, -379.682, -378.091, -376.477, -374.841, -373.182, -371.501, + -369.797, -368.07, -366.321, -364.545, -362.758, -360.943, -359.106, + -357.247, -355.367, -353.465, -351.542, -349.597, -347.631, -345.644, + -343.635, -341.606, -339.556, -337.485, -335.394, -333.282, -331.149, + -328.996, -326.823, -324.63, -322.417, -320.183, -317.93, -315.658, + -313.365, -311.053, -308.722, -306.372, -304.002, -301.613, -299.205, + -296.779, -294.333, -291.869, -289.387, -286.886, -284.366, -281.829, + -279.273, -276.7, -274.108, -271.499, -268.872, -266.228, -263.566, + -260.887, -258.19, -255.477, -252.746, -249.999, -247.235, -244.454, + -241.657, -238.843, -236.013, -233.167, -230.304, -227.426, -224.532, + -221.622, -218.697, -215.756, -212.8, -209.828, -206.841, -203.84, + -200.823, -197.792, -194.746, -191.685, -188.61, -185.521, -182.417, + -179.3, -176.168, -173.023, -169.864, -166.691, -163.505, -160.306, + -157.093, -153.867, -150.629, -147.377, -144.113, -140.836, -137.547, + -134.246, -130.932, -127.606, -124.268, -120.919, -117.557, -114.185, + -110.8, -107.405, -103.998, -100.58, -97.1516, -93.7122, -90.2621, + -86.8015, -83.3305, -79.8493, -76.3579, -72.8566, -69.3454, -65.8245, + -62.2941, -58.7542, -55.205, -51.6467, -48.0794, -44.5031, -40.9181, + -37.3246, -33.7225, -30.1121, -26.4936, -22.867, -19.2325, -15.5902, + -11.9404, -8.28305, -4.6184, -0.946567, 2.7323, 6.41805, 10.1105, + 13.8096, 17.5151, 21.227, 24.9449, 28.6689, 32.3987, 36.1342, + 39.8753, 43.6217, 47.3734, 51.1301, 54.8918, 58.6583, 62.4293, + 66.2049, 69.9847, 73.7687, 77.5567, 81.3485, 85.144, 88.943, + 92.7453, 96.5508, 100.359, 104.171, 107.985, 111.801, 115.62, + 119.442, 123.265, 127.09, 130.917, 134.745, 138.574, 142.405, + 146.237, 150.07, 153.903, 157.737, 161.571, 165.405, 169.239, + 173.073, 176.906, 180.739, 184.571, 188.402, 192.232, 196.061, + 199.888, 203.714, 207.537, 211.359, 215.178}}; #endif /* INCLUDE_BSMPT_THERMALFUNCTIONS_NEGATIVEBOSONSPLINE_H_ */ diff --git a/include/BSMPT/ThermalFunctions/ThermalFunctions.h b/include/BSMPT/ThermalFunctions/ThermalFunctions.h index acd9e891..e345c810 100644 --- a/include/BSMPT/ThermalFunctions/ThermalFunctions.h +++ b/include/BSMPT/ThermalFunctions/ThermalFunctions.h @@ -1,5 +1,6 @@ // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -9,6 +10,8 @@ #ifndef INCLUDE_BSMPT_THERMALFUNCTIONS_THERMALFUNCTIONS_H_ #define INCLUDE_BSMPT_THERMALFUNCTIONS_THERMALFUNCTIONS_H_ + +#include namespace BSMPT { namespace ThermalFunctions @@ -76,8 +79,11 @@ double JbosonInterpolatedLow(const double &x, const int &n, int diff = 0); * Using linear interpolation with data points to interpolate the thermal * integral for bosons for x=m^2/T^2 < 0 * @param x The ratio m^2/T^2 + * @param diff Returns the interpolation of J_- for diff = 0 and for dJ_-/dx for + * diff = 1 */ -double JbosonInterpolatedNegative(const double &x); +double JbosonInterpolatedNegative(const double &x, int diff = 0); + /** * Puts together the separate interpolations for J_- * @param x The ratio m^2/T^2 diff --git a/include/BSMPT/ThermalFunctions/thermalcoefficientcalculator.h b/include/BSMPT/ThermalFunctions/thermalcoefficientcalculator.h index bb52a3bc..2c8e5164 100644 --- a/include/BSMPT/ThermalFunctions/thermalcoefficientcalculator.h +++ b/include/BSMPT/ThermalFunctions/thermalcoefficientcalculator.h @@ -8,6 +8,7 @@ #include #include + namespace BSMPT { namespace ThermalFunctions diff --git a/include/BSMPT/baryo_calculation/CalculateEtaInterface.h b/include/BSMPT/baryo_calculation/CalculateEtaInterface.h index bad96001..333ba405 100644 --- a/include/BSMPT/baryo_calculation/CalculateEtaInterface.h +++ b/include/BSMPT/baryo_calculation/CalculateEtaInterface.h @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -105,13 +106,33 @@ class CalculateEtaInterface */ GSL_integration_mubl GSL_integration_mubl_container; + /** + * @brief SMConstants The SM Constants used during the EWBG calculation + */ + const ISMConstants SMConstants; + public: /** * @brief CalculateEtaInterface Initialises the class with a config pair * @param config config.first sets the CalculateEtaInterface::method_transport * and second CalculateEtaInterface::bot_mass_flag */ - CalculateEtaInterface(const std::pair, int> &config); + [[deprecated( + "Will call CalculateEtaInterface with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] CalculateEtaInterface(const std::pair, + int> &config); + + /** + * @brief CalculateEtaInterface Initialises the class with a config pair + * @param config config.first sets the CalculateEtaInterface::method_transport + * and second CalculateEtaInterface::bot_mass_flag + * @param smConstants The SM Constants. This should be the same as used by the + * parameter point used to calculate the SFOEWPT + */ + CalculateEtaInterface(const std::pair, int> &config, + const ISMConstants &smConstants); /** * Initialises the class member and sets the @@ -121,16 +142,50 @@ class CalculateEtaInterface * @param bot_mass_flag_in Sets the CalculateEtaInterface::bot_mass_flag * member */ + [[deprecated( + "Will call CalculateEtaInterface with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] CalculateEtaInterface(const std::vector + &method_input, + const int &bot_mass_flag_in); + + /** + * Initialises the class member and sets the + * CalculateEtaInterface::method_transport and + * CalculateEtaInterface::bot_mass_flag + * @param method_input Sets the CalculateEtaInterface::method_transport member + * @param bot_mass_flag_in Sets the CalculateEtaInterface::bot_mass_flag + * member + * @param smConstants The SM Constants. This should be the same as used by the + * parameter point used to calculate the SFOEWPT + */ CalculateEtaInterface(const std::vector &method_input, - const int &bot_mass_flag_in); + const int &bot_mass_flag_in, + const ISMConstants &smConstants); + + /** + * Initialises the class member and sets the + * CalculateEtaInterface::method_transport and + * CalculateEtaInterface::bot_mass_flag with the input given in the input file + * @param file input file to get the settings + */ + [[deprecated( + "Will call CalculateEtaInterface with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] CalculateEtaInterface(const std::string &file); /** * Initialises the class member and sets the * CalculateEtaInterface::method_transport and * CalculateEtaInterface::bot_mass_flag with the input given in the input file * @param file input file to get the settings + * @param smConstants The SM Constants. This should be the same as used by the + * parameter point used to calculate the SFOEWPT */ - CalculateEtaInterface(const std::string &file); + CalculateEtaInterface(const std::string &file, + const ISMConstants &smConstants); virtual ~CalculateEtaInterface(); diff --git a/include/BSMPT/baryo_calculation/Fluid_Type/bot_source.h b/include/BSMPT/baryo_calculation/Fluid_Type/bot_source.h index 3001f46e..8a721ee2 100644 --- a/include/BSMPT/baryo_calculation/Fluid_Type/bot_source.h +++ b/include/BSMPT/baryo_calculation/Fluid_Type/bot_source.h @@ -1,5 +1,6 @@ // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -37,6 +38,12 @@ class bot_source : public gen_fluid { private: public: + [[deprecated("Will call bot_source with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] bot_source(); + + bot_source(const ISMConstants &smConstants); /** * @brief operator () Needed for the numerical solution via boost. * @param omega Vector of all included (rescaled) chemical potentials diff --git a/include/BSMPT/baryo_calculation/Fluid_Type/gen_func_fluid.h b/include/BSMPT/baryo_calculation/Fluid_Type/gen_func_fluid.h index 6069fdf1..00f17861 100644 --- a/include/BSMPT/baryo_calculation/Fluid_Type/gen_func_fluid.h +++ b/include/BSMPT/baryo_calculation/Fluid_Type/gen_func_fluid.h @@ -28,6 +28,15 @@ typedef std::vector state_type; */ const double C_smallcut = 1e-20; +/** + * @brief C_AbsErr Absolute tolerance for boost::integrate_adaptive + */ +const double C_AbsErr = 1e-6; +/** + * @brief C_RelErr Relative tolerance for boost::integrate_adaptive + */ +const double C_RelErr = 1e-9; + /** * @brief The Calc_Gam_M class Class instance for the numerical evaluation of * the relaxation rate at given temperature and quark mass. @@ -237,6 +246,7 @@ double NIntegrate_kappa(const Calc_kappa_t &C_kap); class Calc_eta { private: + ISMConstants SMConstants; /** * @brief Temp Temperature */ @@ -255,6 +265,11 @@ class Calc_eta public: double prefactor; + [[deprecated("Will call Calc_eta with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] Calc_eta(); + Calc_eta(const ISMConstants &smConstants); void set_class(std::vector array_z, std::vector array_nL, double Temp, @@ -297,7 +312,14 @@ double Nintegrate_eta(const Calc_eta &C_eta, class gen_fluid { private: + const ISMConstants SMConstants; + public: + [[deprecated("Will call gen_fluid with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] gen_fluid(); + gen_fluid(const ISMConstants &smConstants); int bot_mass_flag; int tau_mass_flag = 1; // Changing to zero for massless tau leptons --> might cause problems! @@ -394,9 +416,9 @@ class gen_fluid double gprime = 0.36; double alphaS = 1. / 7; double alphaW = 1. / 30; - double mtop_0 = C_MassTop; - double mbot_0 = C_MassBottom; - double mtau_0 = C_MassTau; + double mtop_0{0}; + double mbot_0{0}; + double mtau_0{0}; /** * @brief Dq Diffusion constant of quarks. diff --git a/include/BSMPT/baryo_calculation/Fluid_Type/tau_source.h b/include/BSMPT/baryo_calculation/Fluid_Type/tau_source.h index 2167f08b..75eeff0b 100644 --- a/include/BSMPT/baryo_calculation/Fluid_Type/tau_source.h +++ b/include/BSMPT/baryo_calculation/Fluid_Type/tau_source.h @@ -2,7 +2,8 @@ #define TAU_SOURCE_H // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -32,6 +33,12 @@ class tau_source : public gen_fluid { private: public: + [[deprecated("Will call tau_source with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] tau_source(); + + tau_source(const ISMConstants &smConstants); /** * @brief operator () Needed for the numerical solution via boost. * @param omega Vector of all included (rescaled) chemical potentials diff --git a/include/BSMPT/baryo_calculation/Fluid_Type/top_source.h b/include/BSMPT/baryo_calculation/Fluid_Type/top_source.h index 1f28b485..8a3ad2ce 100644 --- a/include/BSMPT/baryo_calculation/Fluid_Type/top_source.h +++ b/include/BSMPT/baryo_calculation/Fluid_Type/top_source.h @@ -2,7 +2,8 @@ #define TOP_SOURCE_H // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -32,6 +33,11 @@ class top_source : public gen_fluid { private: public: + [[deprecated("Will call top_source with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] top_source(); + top_source(const ISMConstants &smConstants); /** * @brief operator () Needed for the numerical solution via boost. * @param omega Vector of all included (rescaled) chemical potentials diff --git a/include/BSMPT/bounce_solution/action_calculation.h b/include/BSMPT/bounce_solution/action_calculation.h new file mode 100644 index 00000000..3972f94a --- /dev/null +++ b/include/BSMPT/bounce_solution/action_calculation.h @@ -0,0 +1,745 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana +// +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +/** + * @file + */ + +#include +#include +#include +#include +#include +#include // std::optional +#include +#include + +using Eigen::MatrixXd; +using Eigen::VectorXd; + +/** + * @brief This classes calculates the Bounce action of the potential with a set + * temperature + */ + +namespace BSMPT +{ + +class BounceActionInt +{ +private: + // These two variables check if the method undershot and overshot at least + // once. If only one type of convergence was achieved it is an indication that + // no solution has been found. + /** + * @brief Records if overshoot/undershoot method undershots at least once + */ + bool UndershotOnce = false; + /** + * @brief Records if overshoot/undershoot method overshots at least once + */ + bool OvershotOnce = false; + + /** + * @brief Value of d2Vdl^2 near the true vacuum + * + */ + double TrueVacuumHessian; + + /** + * @brief Store the value of backwards propagation + * + */ + double Initial_lmin; + + /** + * @brief Potential at the false vacuum in the unshifted potential (in the + * shifted Vfalse = 0) + * + */ + double Vfalse; + + /** + * @brief l0 - Initial_lmin for solutions starting very near the true vacuum + * + */ + double l0_minus_lmin; + + /** + * @brief True if path deformation reached the desired results without solving + * the 1D equation one more time. + * + */ + bool PathDeformationConvergedWithout1D = false; + + /** + * @brief Lmin - L0 that splits between the two branches of the H > 0 + * analytical solution. If unset, we only use the linear approximation + * + */ + std::optional ExactSolutionThreshold; + + /** + * @brief First guess of l(rho) - l0 used to to integrate in the analytical + * solution. Can be decreased if the error is too high. + * + */ + double FractionOfThePathExact = 1e-4; + +public: + /** + * @brief Dimension of the VEV space + * + */ + int dim = -1; + + /** + * @brief Possible status of the Action calculation + * + */ + enum class ActionStatus + { + Success, + NotCalculated, + Integration1DFailed, + PathDeformationNotConverged, + PathDeformationCrashed, + FalseVacuumNotMinimum, + BackwardsPropagationFailed, + NeverUndershootOvershoot, + UndershootOvershootNegativeGrad, + NotEnoughPointsForSpline + }; + + /** + * @brief Possible results of the undershoot/overshoot algorithm + * + */ + enum class UndershootOvershootStatus + { + Converged, + Undershoot, + Overshoot + }; + + /** + * @brief Possible status of the 1D bounce solver + * + */ + enum class Integration1DStatus + { + Converged, + NotConverged, + }; + + /** + * @brief Possible status of the path deformation algorithm + * + */ + enum class PathDeformationStatus + { + Converged, + NotConverged, + }; + + /** + * @brief either returns a -1 (if failed) or the value of the action + * + */ + double Action = -1; + + /** + * @brief Status of the Action calculation + * + */ + ActionStatus StateOfBounceActionInt = ActionStatus::NotCalculated; + + /** + * @brief Status of the 1D bounce solver + * + */ + Integration1DStatus StateOf1DIntegration = Integration1DStatus::NotConverged; + + /** + * @brief Status of the path deformation algorithm + * + */ + PathDeformationStatus StateOfPathDeformation = + PathDeformationStatus::NotConverged; + + /** + * @brief Factor produced by the spherical symmetry of the potential. + * * = 2 if \f$ T > 0\f$ (\f$O(3)\f$ symmetry). + * * = 3 if \f$ T = 0\f$ (\f$O(4)\f$ symmetry). + * + * Default value is \f$ 2 \f$ since most of our calculation are done at finite + * temperature. + */ + double Alpha = 2; // alpha = 2 if T > 0 | alpha = 3 if T = 0 + + /** + * @brief Temperature of the potential. Irrelevant but helpful + * + */ + double T = -1; + + /** + * @brief Number of integration of the bounce + * + */ + int MaxPathIntegrations; + + /** + * @brief Number of path deformations before integrating again + * + */ + int MaxSinglePathDeformations = 200; + + /** + * @brief list of \f$ \rho \f$ of the solution + */ + std::vector rho_sol; + + /** + * @brief list of \f$ l(\rho) \f$ of the solution + * + */ + std::vector l_sol; + + /** + * @brief list of \f$ \frac{l}{\rho} \f$ of the solution + * + */ + std::vector dldrho_sol; + + /** + * @brief Step for the numerical derivative + * + */ + double eps = 0.01; + + /** + * @brief Number of basis function that are used + 1 + * + */ + int BernsteinDegree = 10; + + /** + * @brief // Number of knots in the new path + * + */ + double NumberPathKnots = 50; + /** + * @brief True vacuum candidate + * + */ + std::vector TrueVacuum; + /** + * @brief False vacuum. Should be the same as the last path knot + * + */ + std::vector FalseVacuum; + /** + * @brief Potential of the class + * + */ + + std::function)> V; // Potential + /** + * @brief Potential gradient of the class, can be either numerical or + * analytical + * + */ + std::function(std::vector)> + dV; // Potential gradient + /** + * @brief Potential hessian of the class, completly numerical + * + * TODO: Calculate hessian from analytical gradient + */ + std::function>(std::vector)> Hessian; + /** + * @brief First path given to class + * + */ + std::vector> InitPath; // Initial path given to class + /** + * @brief Current class path, can be changed by @ref PathDeformation + * + */ + std::vector> Path; // Initial path given to class + /** + * @brief We describe the tunneling path using a cubid spline. + * The parameterization is the length along the spline. + * + */ + cvspline Spline; // Constant velocity spline object + /** + * @brief Spline used to save \f$ \frac{dV}{dl} \f$ + * + */ + tk::spline RasterizeddVdl; // RasterizeddVdl + + /** + * @brief Default constructor (unit tests) + * + */ + BounceActionInt(); + + /** + * @brief Construct a new Bounce Action Int object + * + * @param init_path is the initial path guess + * @param TrueVacuumIn is the true vacuum candidate of the potential + * @param FalseVacuumIn is the false vacuum + * @param V is the class potential + * @param dV is the class gradient + */ + BounceActionInt( + std::vector> InitPath_In, + std::vector TrueVacuum_In, + std::vector FalseVacuum_In, + std::function)> &V_In, + std::function(std::vector)> &dV_In, + double T_In, + int MaxPathIntegrations_in); + + /** + * @brief Construct a new Bounce Action Int object + * + * @param init_path is the initial path guess + * @param TrueVacuumIn is the true vacuum candidate of the potential + * @param FalseVacuumIn is the false vacuum + * @param V is the class potential + */ + BounceActionInt(std::vector> InitPath_In, + std::vector TrueVacuum_In, + std::vector FalseVacuum_In, + std::function)> &V_In, + double T_In, + int MaxPathIntegrations_in); + + /** + * @brief Used set the path of the class. + * + * @param init_path Knots that are used to describe the path + */ + void SetPath(std::vector> InitPath_In); + + /** + * @brief Precalculates dVdl and creates a spline with the result. + * This is done to increase the runtime in large dimensional models + * + * * @param l_start is the starting position produced in the + * backwardspropagation part + */ + void RasterizedVdl(double l_start = 0); + + /** + * @brief Prints a vector + * + * @param vec Vector to be printed + */ + void PrintVector(std::vector vec); + + /** + * @brief Calculates \f$ \frac{dV}{dl} \f$ using the spline and potential + * derivatives + * + * \f$ \frac{dV}{dl} = \frac{\partial V}{\partial \vec{\phi}} \cdot \frac{d + * \vec{\phi}}{dl} = \nabla V(\vec{\phi}) \cdot \frac{d + * \vec{\phi}}{dl} \f$ + * + * @param l Spline parameterization point where \f$ \frac{dV}{dl} \f$ is + * calculated + * @return double Returns \f$ \frac{dV}{dl} \f$ + */ + double Calc_dVdl(double l); + + /** + * @brief Calculates \f$ \frac{d^2V}{dl^2} \f$ using the spline and potential + * derivatives + * + * \f$ \frac{d^2V}{dl^2} = \nabla V(\vec{\phi}) \cdot \frac{d^2 + * \vec{\phi}}{dl^2} + \left(\frac{d\vec{\phi}}{dl}\right)^T H(\vec{\phi}) + * \frac{d\vec{\phi}}{dl} \f$ + * + * @return double Returns \f$ \frac{d^2V}{dl^2} \f$ + */ + double Calc_d2Vdl2(double l); + + /** + * @brief Calculated the normal force \f$ \vec{N} \f$ on a @ref spline point. + * + * @param l is the @ref spline parameter where the force is calculated. + * @param dldrho is \f$ \frac{dl}{d\rho}\f$. + * @param gradient is the gradient evaluated at spline parameter l. + * @return std::vector is the \f$ \vec{N} \f$ at spline parameter l. + */ + std::vector NormalForce(const double &l, + const double &dldrho, + const std::vector &gradient); + + /** + * @brief Auxiliary function used in the Runge-Kutta 5th order + * adaptative step @ref RK5_step. + * + * @param rho is the integration variable \f$ \rho \f$. + * @param dvs are the functions values. + * @param aks are used to return the function derivatives. + */ + void AuxFunctionDev(const double &rho, + const std::vector &dvs, + std::vector &aks); + + /** + * @brief Runge-Kutta 5th order step. + * + * Although the Runge-Kutta methods are valid for \f$ y' = + * f(t,y) \f$ integration one can generalize the method for higher order ODE + * using auxiliary functions. One can write \f$ y'' = f(t,y, y') \f$ as + * + * * \f$ y' = m \f$ + * * \f$ m' = f(t, y, m) \f$ + * + * linearizing the ODE system allowing the application of Runge-Kutta method + * to each one. + * + * This method takes a 5th order Runge-Kutta step that can be embedded into a + * 4th order Runge-Kutta step. By comparing the result of the 4th and 5th + * order we can control the error within our calculation by adjusting the step + * size accordingly. + * + * @param y function values \f$ \{y(\rho_i), m(\rho_i) \} \f$. + * @param dydx function derivatives \f$ \{y'(\rho_i), m'(\rho_i) \} \f$. + * @param n is the number of linearizations, i.e. 2. + * @param rho is the integration variable \f$ \rho \f$. + * @param h is the step size. + * @param yout is the 5th order Runge-Kutta integration result. + * @param yerr is the difference between the 4th order and 5th order + * Runge-Kutta result. + */ + void RK5_step(const std::vector &y, + const std::vector &dydx, + int n, + float rho, + float h, + std::vector &yout, + std::vector &yerr); + + /** + * @brief Modified Bessel function \f$I_\alpha (x) \f$ of the first kind + * + * \f$I_\alpha (x) = \sum_{m=0}^\infty \frac{1}{m! \Gamma(m + \alpha + 1)} + * \left(\frac{x}{2}\right)^{2m + \alpha} \f$ + * + * The convergence should be quite fast. We use as many terms to get the last + * term to impact the result in \f$ 10^{-15}\f$ (relatively). The default + * maximum number of terms is 50. + * + * @param alpha is an complex number. + * @param x where to calculate the Bessel function. + * @param terms are the maximum number of terms allowed in the calculation. + * @return double returns \f$I_\alpha (x) \f$ + */ + double BesselI(double alpha, double x, int terms = 100); + + /** + * @brief Modified Bessel function i \f$J_1 (i x) \f$ of the first kind + * + * \f$i J_1 (i x) = i \sum_{m=0}^\infty (-1)^{m + 1} \frac{1}{m! \Gamma(m + + * \alpha + 1)} \left(\frac{x}{2}\right)^{2m + \alpha} \f$ + * + * The convergence should be quite fast. We use as many terms to get the last + * term to impact the result in \f$ 10^{-15}\f$ (relatively). The default + * maximum number of terms is 50. + * + * @param alpha is an complex number. + * @param x where to calculate the Bessel function. + * @param terms are the maximum number of terms allowed in the calculation. + * @return double returns \f$I_\alpha (x) \f$ + */ + double BesselJ(double x, int terms = 100); + + /** + * @brief Integrates the 1D profile assuming \f$ \frac{dV}{dl} \f$ is a + * linear in l, i.e. \f$ \frac{dV}{dl} \approx dV + H (l - l_0) \f$. The + * solution is for \f$ \alpha = 2 \f$ is + * + * \f$ l(\rho) = l_0 - \frac{dV}{H} + + * \frac{dV}{H^{3/2}}\frac{\sinh(\rho\sqrt{H})}{\rho} \f$ + * + * and the solution for \f$ \alpha = 3 \f$ is + * + * \f$ l(\rho) = l_0 - \frac{dV}{H} + \frac{2 dV}{H^{3/2}} \frac{I_\alpha(\rho + * \sqrt{H})}{\rho}\f$ + * + * where \f$ I_\alpha(\rho) \f$ is the modified Bessel function of the first + * kind. + * + * @param l0 is the integration starting point. + * @param l is the integration final point. + * @param dVdl \f$ \frac{dV}{dl} \f$ at \f$ l_0 \f$. + * @param d2Vdl2 \f$ \frac{d^2V}{dl^2} \f$ at \f$ l_0 \f$. + * @param maxiter Maximum iteration when calculating \f$ \rho(l) \f$. + * @return std::vector + */ + std::vector + ExactSolutionLin(double l0, double l, double dVdl, double d2Vdl2); + + /** + * @brief Integrates the 1D profile assuming \f$ \frac{dV}{dl} \f$ is a + * linear in l, i.e. \f$ \frac{dV}{dl} \approx H (l - l_{min}) \f$. This + * correspondes to a purely qudratic potential. + * + * @param l is the integration final point. + * @return std::vector + */ + std::vector ExactSolutionFromMinimum(double l); + + /** + * @brief Logistic function with patched edges to account for numerical + * instability/nans + * + * \f$ \text{LogisticFunction}(x)=\begin{cases}1,\quad x\ge10\\0,\quad x\le + * -10\\\frac{1}{1+e^{-x}},\quad\text{otherwise}\end{cases} \f$ + * + * @param x independent variable + * @return double logistic function at at x + */ + double LogisticFunction(const double &x); + + /** + * @brief Calculate \f$l_\text{threshold}\f$ that splits the two branches of + * analytical integration. This function works recursively until the error + * **MinError** is small enough or the integration step is too small to be + * numerically stable. + * + * @param MinError Lowest error found + */ + void CalculateExactSolutionThreshold(double MinError = 1e100); + + /** + * @brief Calculates the 1D solution by comparing the @ref + * ExactSolutionCons and @ref ExactSolutionLin so that the analytical step is + * appropriate. + * + * @param l0 starting point + * @return std::vector + */ + std::vector ExactSolution(double l0); + + /** + * @brief This is done to make sure that we can still find solution after path + * deformation. This propagates the spline into negative values (by + * extrapolating). + * + * @return double negative or zero value. + */ + void BackwardsPropagation(); + + /** + * @brief Integrates 1D bounce equation once + * + * @param l0 is the starting value. + * @param conv checks type of convergence. Converged. Undershoot. Overshoot. + * @param rho vector of integration variable \f$ \rho \f$ steps. + * @param l vector of variable \f$ l \f$ steps. + * @param dl_drho vector of variable \f$ \frac{dl}{d\rho} \f$ steps. + * @param d2l_drho2 vector of variable \f$ \frac{d^2l}{d\rho^2} \f$ steps. + * @param maxiter is the maximum integration steps. + * @param error is the acceptance of undershoot/overshoot. + * @param eps_abs is used to control the step size error (RK4 vs RK5). + * @param max_step in the case you want to set a maximum step size in \f$ \rho + * \f$. + */ + void IntegrateBounce(double l0, + UndershootOvershootStatus &conv, + std::vector &rho, + std::vector &l, + std::vector &dl_drho, + std::vector &d2l_drho2, + int maxiter, + double error, + double eps_abs, + double max_step = 0); + /** + * @brief Performs a binary search using the overshooting/undershooting method + * to find the solution to the 1D bounce equation + * + * @param rho is the vector of \f$ \rho \f$ values from the solution + * @param l is the vector of \f$ l \f$ values from the solution + * @param dl_drho is the vector of \f$ \frac{dl}{d\rho} \f$ values from the + * solution + * @param d2l_drho2is the vector of \f$ \frac{d^2l}{d\rho^2} \f$ values from + * the solution + * @param error is the @ref IntegrateBounce error (acceptance of + * undershoot/overshoot) + * @param maxiter is the maximum number of binary searches + */ + void Solve1DBounce(std::vector &rho, + std::vector &l, + std::vector &dl_drho, + std::vector &d2l_drho2, + double error = 1e-7, + int maxiter = 100); + + /** + * @brief Calculates the normalization of the force \f$ \vec{\phi} \rightarrow + * \vec{\phi} + \vec{N}/reductor \f$. We have that \f$ reductor = \varepsilon + * \max{\nabla V}/L \f$, where \f$ 10^{-4} \le \varepsilon \le 10^{-1} \f$ is + * a small parameter + * + * @param MaximumGradient + * @return double + */ + double ReductorCalculator(const double &MaximumGradient); + + /** + * @brief Check if the force in each point is sufficient small compared to the + * gradient in each point + * + * @param l list of spline parameter \f$ l \f$ of the knots + * @param rho_l_spl list of \f$ \frac{dl}{d\rho}\f$ of the knots + * @return true if converged + * @return false if not converged + */ + bool PathDeformationCheck(std::vector &l, tk::spline &rho_l_spl); + + /** + * @brief Takes a single path deformation step + * + * @param stepsize \f$ \varepsilon \f$ + * @param reductor is the reductor + * @param l list of \f$ l \f$ at the knots of the old solution + * @param rho_l_spl list of \f$ \frac{dl}{d\rho} \f$ at the knots of the old + * solution + * @param l_fornextpath list of new \f$ l \f$ at the new path iteration + * @param best_path save the best path + * @param saves the current iteration on the fly + * @param MaximumGradient maximum \f$ \nabla V \f$ + * @param MaximumForce maximum \f$ \vec{N} \f$ + * @param MaximumRelativeError maximum \f$ \frac{|\vec{N}|}{|\nabla V|} \f$ + * @param Maximum_dldrho maximum \f$ \frac{dl}{d\rho} \f$ + * @param PerpendicularGradient maximum \f$ \nabla_\perp V \f$ + * @param inverseK inverse of the kernel matrix + * @param forces list of forces to check if path is converging or not + */ + void SinglePathDeformation(double &stepsize, + double &reductor, + std::vector &l, + tk::spline &rho_l_spl, + std::vector &l_fornextpath, + std::vector> &best_path, + std::vector> &next_path, + double &MaximumGradient, + double &MaximumForce, + double &MaximumRelativeError, + double &Maximum_dldrho, + double &PerpendicularGradient, + MatrixXd &inverseK, + std::vector> &forces); + + /** + * @brief Deforms the path minimizing the force \f$ \vec{N} \f$ without + * solving + * + * @param l is the vector of \f$ \rho \f$ values from the solution + * @param rho_l_spl tk::spline of \f$ \rho(l) \f$ + */ + void PathDeformation(std::vector &l, tk::spline &rho_l_spl); + /** + * @brief Number of combinations of chosing k in n + * + * \f$ {n \choose k} = \frac{n!}{k!(n-k)!}\f$ + * + * @param n + * @param k + * @return unsigned + */ + unsigned nChoosek(unsigned n, unsigned k); + + /** + * @brief Calculates the \f$ k^{th}\f$ Bernstein polynomial of degree \f$ n + * \f$ at \f$ x \f$. + * + * \f$ B_{\nu,n}(x) = {n \choose \nu} x^\nu (1-x)^{n-\nu} \f$ + * + * @param n Bernstein degree. + * @param nu Bernstein basis function, \f$ 0 \leq \nu \leq n \f$. + * @param x is the independent parameter. + * @return double \f$ B_{\nu,n}(x) \f$. + */ + double Bernstein(int n, int nu, double x); + + /** + * @brief Calculates the force vector \f$ \vec{N} \f$ of multiple path knots + * at the same time. Use in the path deformation algorithm. + * + * @param dldrho is the vector of \f$ \frac{dl}{d\rho} \f$ values from the + * solution. + * @param gradient is the vector of \f$ \nabla(\vec{\phi}(l)) \f$ values from + * the solution. + * @param dphidl is the vector of \f$ \frac{d\vec{\phi}}{dl} \f$ values from + * the solution. + * @param d2phidl2 is the vector of \f$ \frac{d^2\vec{\phi}}{dl^2} \f$ values + * from the solution. + * @return std::vector list of force vectors \f$ \vec{N} \f$ applied + * to each path knot. + */ + std::vector NormalForceBernstein(const double &dldrho, + const std::vector &gradient, + const std::vector &dphidl, + const std::vector &d2phidl2); + + /** + * @brief Calculates \f$ \frac{d^2l}{d\rho^2} \f$ + * + * \f$ \frac{d^2l}{d\rho^2} = \frac{dV}{dl} - + * \frac{\alpha}{\rho}\frac{dl}{d\rho}\f$ + * + * @param l \f$ = l(\rho) \f$ + * @param rho where we want to calculate. + * @param dldrho \f$ = \frac{dl(\rho)}{d\rho} \f$ + * @return double \f$ \frac{d^2l}{d\rho^2} \f$ at \f$ \rho \f$ + */ + double d2ldrho2(double l, double rho, double dldrho); + + /** + * @brief Calculate kinect term of the action + * + * @param rho list of rho coming from the integration + * @param dl_drho_spl Spline of \f$\frac{dl(\rho)}{d\rho}\f$ + * @return double kinetic part of the action + */ + double CalculateKineticTermAction(const std::vector &rho, + const tk::spline &dl_drho_spl); + + /** + * @brief Calculate potential term of the action + * + * @param rho list of rho coming from the integration + * @param l_rho_spl Spline of \f$l(\rho)\f$ + * @return double potential part of the action + */ + double CalculatePotentialTermAction(const std::vector &rho, + const tk::spline &l_rho_spl); + + /** + * @brief Calculates the action of the bounce equation by deforming the + * given + * @ref path and minimizing the normal force \f$ \vec{N} \f$ until it gets + * sufficiently small. + * + * @param error is the acceptance of undershoot/overshoot method. + */ + void CalculateAction(double error = 1e-6); +}; +} // namespace BSMPT \ No newline at end of file diff --git a/include/BSMPT/bounce_solution/bounce_solution.h b/include/BSMPT/bounce_solution/bounce_solution.h new file mode 100644 index 00000000..96c18131 --- /dev/null +++ b/include/BSMPT/bounce_solution/bounce_solution.h @@ -0,0 +1,569 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana +// +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +/** + * @file bounce solution calculation + */ + +#include +#include // MinimumTracer +#include +#include +#include +#include // std::max +#include // numerical derivative +#include // numerical integration + +namespace BSMPT +{ + +/** + * struct to store result and error + */ +struct resultErrorPair +{ + double result; + double error; +}; + +/** + * @brief BounceSolution class that handles the calculation of the bounce + * solution as well as the calculation of the charateristic temperature scales + */ +class BounceSolution +{ +public: + /** + * @brief modelPointer for the used parameter point + */ + std::shared_ptr modelPointer; + + /** + * @brief MinTracer object + */ + std::shared_ptr MinTracer; + + /** + * @brief epsilon of turbulence efficiency factor + */ + double epsturb = 0.1; + + /** + * @brief wall velocity + */ + double vwall = 0.95; + + /** + * @brief number of temperature steps in the initial scan of the bounce solver + * + */ + size_t NumberOfInitialScanTemperatures; + + /** + * @brief set to true if nucleation temperature is set + */ + bool nucleation_temp_set = false; + + /** + * @brief set to true if percolation temperature is set + */ + bool percolation_temp_set = false; + + /** + * @brief set to true if completion temperature is set + */ + bool completion_temp_set = false; + + /** + * @brief critical temperature/highest temperature when transition can occur + */ + double Tc = -1; + + /** + * @brief lowest temperature when a transition can occur + */ + double Tm = -1; + + /** + * @brief nucleation temperature + */ + double Tnucl = -1; + + /** + * @brief approximate nucleation temperature + */ + double Tnucl_approx = -1; + + /** + * @brief percolation temperature + */ + double Tperc = -1; + + /** + * @brief completion temperature + */ + double Tcompl = -1; + + /** + * @brief stored temperature + */ + double store_Temp; + + /** + * @brief PT strength + */ + double alpha = -1; + + /** + * @brief Inverse time scale \f$ \frac{\beta}{H} \f$ + * + */ + double betaH = -1; + + /** + * @brief number of effective degrees of freedom + */ + double gstar; + + /** + * @brief index of the true vacuum phase candidate in the coex list + * + */ + int indexTrueCandidatePhase; + + /** + * @brief spline used to interpolate the action as a function of the + * temperature + * + */ + tk::spline S3ofT_spline; + + /** + * @brief Set of BounceActionInt objects with valid solutions. + * + */ + std::vector SolutionList; + + /** + * @brief List of group elements allowed by the potential + * + */ + std::vector GroupElements; + + /** + * @brief Store symmetry that produces the best tunneling rate + * + */ + Eigen::MatrixXd OptimalDiscreteSymmetry; + + /** + * @brief Transforms the vev to the optimal vev. + * + * @param vev to be converted + * @return std::vector transformed vev + */ + std::vector + TransformIntoOptimalDiscreteSymmetry(const std::vector &vev); + + /** + * @brief Calculates which is the optimal symmetry from the group of + * symmetries + * + */ + void CalculateOptimalDiscreteSymmetry(); + + /** + * @brief Storage of the tunneling rate per volume of the transition from + * false to true vacuum + * @param Temp temperature + */ + double TunnelingRate(const double &Temp); + /** + * @brief Storage of the temperature-dependent Hubble rate + * @param Temp temperature + */ + double HubbleRate(const double &Temp); + + /** + * @brief inner_integrand friend to define inner integrand of percolation + * temperature integral + */ + friend double inner_integrand(double var, void *params); + + /** + * @brief outer_integrand friend to define outer integrand of percolation + * temperature integral + */ + friend double outer_integrand(double var, void *params); + + /** + * @brief Calculate euclidian action at temperature T + */ + double GetBounceSol(const double &Temp) const; + + /** + * @brief action_ratio friend to define input of numerical derivative in + * calculation of inverse time scale + */ + friend double action_ratio(double var, void *params); + +public: + /** + * @brief AbsErr absolute error for numerical integration + */ + const double AbsErr = 0; + + /** + * @brief RelErr relative error for numerical integration + */ + const double RelErr = 1e-6; + + /** + * @brief Maximum relative difference in temperature on the fraction of false + * vacuum to be accepted. + * + */ + const double RelativeTemperatureInCalcTempAtFalseVacFraction = 1e-8; + + /** + * @brief Maximum relative error on the fraction of vacuum tunneled to be + * accepted. + */ + const double RelativeErrorInCalcTempAtFalseVacFraction = 1e-3; + + /** + * @brief Additional margin of error in the while loop without admitting + * failure. + */ + const double MarginOfCalcTempAtFalseVacFractionBeforeFailure = 1e-4; + + /** + * @brief pair of coexisiting phases + */ + CoexPhases phase_pair; + + /** + * @brief status of bounce solver + * + */ + StatusGW status_bounce_sol = StatusGW::NotSet; + + /** + * @brief status of approximate nucleation temperature calculation + * + */ + BSMPT::StatusTemperature status_nucl_approx = + BSMPT::StatusTemperature::NotSet; + + /** + * @brief status of nucleation temperature calculation + * + */ + BSMPT::StatusTemperature status_nucl = BSMPT::StatusTemperature::NotSet; + + /** + * @brief status of percolation temperature calculation + * + */ + BSMPT::StatusTemperature status_perc = BSMPT::StatusTemperature::NotSet; + + /** + * @brief status of completion temperature calculation + * + */ + BSMPT::StatusTemperature status_compl = BSMPT::StatusTemperature::NotSet; + + /** + * @brief \f$ v_{\text{wall}}\f$ defined by the user as an input parameter. + * If \f$ v_{\text{wall}}\f = -1$ then we use the approximation coming from + * https://arxiv.org/abs/2210.16305 + * If \f$ v_{\text{wall}}\f = -2$ then we use the upper bound from + * https://arxiv.org/abs/2305.02357 + * + */ + double UserDefined_vwall = 0.95; + + /** + * @brief Number of integration of the bounce + * + */ + int MaxPathIntegrations = 7; + + /** + * @brief Construct a new Bounce Sol Calc object. Used for testing + * @param pointer_in model pointer + */ + BounceSolution(const std::shared_ptr &pointer_in); + + /** + * @brief Construct a new Bounce Sol Calc object. This class takes as input a + * pair of coexisting phases and delegates to constructor with provided + * symmetry group. + * + * @param pointer_in model pointer + * @param MinTracerIn minimum tracer pointer + * @param phase_pair_in pair of coexisting phases + * @param UserDefined_vwall_in is the input value for v_wall. If = -1$ then we + * use the approximation coming from https://arxiv.org/abs/2210.16305. If = + * -2$ then we use the upper bound from https://arxiv.org/abs/2305.02357 + * @param UserDefined_epsturb_in is the input value for epsturb. If [0..1] set + * to value, for -1 we use the upper bound from + * https://arxiv.org/abs/1704.05871 + * @param MaxPathIntegrations_in max number of path integrations + * @param NumberOfInitialScanTemperatures_in number of temperature steps in + * the initial scan of the bounce solver + */ + BounceSolution(const std::shared_ptr &pointer_in, + const std::shared_ptr &MinTracer_in, + const CoexPhases &phase_pair_in, + const double &UserDefined_vwall_in, + const double &UserDefined_epsturb_in, + const int &MaxPathIntegrations_in, + const size_t &NumberOfInitialScanTemperatures_in); + + /** + * @brief Construct a new Bounce Sol Calc object. This class takes as input a + * pair of coexisting phases. + * + * @param pointer_in model pointer + * @param MinTracerIn minimum tracer pointer + * @param phase_pair_in pair of coexisting phases + * @param UserDefined_vwall_in is the input value for v_wall. If = -1$ then we + * use the approximation coming from https://arxiv.org/abs/2210.16305. If = + * -2$ then we use the upper bound from https://arxiv.org/abs/2305.02357 + * @param UserDefined_epsturb_in is the input value for epsturb. If [0..1] set + * to value, for -1 we use the upper bound from + * https://arxiv.org/abs/1704.05871 + * @param MaxPathIntegrations_in max number of path integrations + * @param GroupElements_In List of allowed potential symmetries + * @param NumberOfInitialScanTemperatures_in number of temperature steps in + * the initial scan of the bounce solver + */ + BounceSolution(const std::shared_ptr &pointer_in, + const std::shared_ptr &MinTracer_in, + const CoexPhases &phase_pair_in, + const double &UserDefined_vwall_in, + const double &UserDefined_epsturb_in, + const int &MaxPathIntegrations_in, + const size_t &NumberOfInitialScanTemperatures_in, + std::vector GroupElements_in); + + /** + * @brief Initially we have no idea where the transition can occur, therefore + * we scan the complete temperature range + */ + void GWInitialScan(); + + /** + * @brief Calculate the euclidian action of the transition from false to true + * phase of phase pair. + * + * @param T temperature + * @param smart + */ + + void CalculateActionAt(double T, bool smart = true); + + /** + * @brief If solution were found by the GWInitialScan() then we scan + * temperature range in the vicinity such that we are get a enough sample to + * then do the extrapolation. + * + */ + void GWSecondaryScan(); + + /** + * @brief Do linear extrapolations to calculate action at higher temperatures + * + */ + void GWScanTowardsHighAction(); + + /** + * @brief Do linear extrapolations to calculate action at lower temperatures + * + */ + void GWScanTowardsLowAction(); + + /** + * @brief Set the Bounce Sol object + * + */ + void SetBounceSol(); + + /** + * @brief Get the bubble wall velocity + * @return vb + */ + double GetWallVelocity() const; + + /** + * @brief Get epsturb + * @return epsturb + */ + double GetEpsTurb() const; + + /** + * @brief SetGstar Set gstar + */ + void SetGstar(const double &gstar_in); + + /** + * @brief GetGstar Get gstar + */ + double GetGstar() const; + + /** + * @brief SetCriticalTemp Set critical temperature + */ + void SetCriticalTemp(const double &T_in); + + /** + * @brief GetCriticalTemp Get critical temperature + */ + double GetCriticalTemp() const; + + /** + * @brief SetStoredTemp Set stored temperature + */ + void SetStoredTemp(const double &T_in); + /** + * @brief GetStoredTemp Get stored temperature + */ + double GetStoredTemp() const; + + /** + * @brief GetNucleationTemp Get nucleation temperature via exact method + */ + double GetNucleationTemp() const; + + /** + * @brief GetNucleationTempApprox Get nucleation temperature via approximate + * method + */ + double GetNucleationTempApprox() const; + + /** + * @brief GetPercolationTemp Get percolation temperature + */ + double GetPercolationTemp() const; + + /** + * @brief GetCompletionTemp Get percolation temperature + */ + double GetCompletionTemp() const; + + /** + * @brief CalcTransitionTemp Get transition temperature from int + */ + double CalcTransitionTemp(const int &which_transition_temp); + + /** + * @brief GetPTStrength Get PT strength alpha + */ + double GetPTStrength() const; + + /** + * @brief CalcGstarPureRad Calculate the number of effective degrees of + * freedom assuming a purely radiative universe + */ + void CalcGstarPureRad(); + + /** + * @brief Calculation of nucleation temperature + */ + void CalculateNucleationTemp(); + + /** + * @brief Approximate calculation of nucleation temperature + */ + void CalculateNucleationTempApprox(); + + /** + * @brief CalcTempAtFalseVacFraction calculates the temperature at which the + * false vacuum fraction drops below val + * @param false_vac_frac desired false vacuum fraction value + * @return temperature at which false vacuum fraction drops below val + */ + double CalcTempAtFalseVacFraction(const double &false_vac_frac); + + /** + * @brief CalcFalseVacFraction calculates false vacuum fraction as function of + * temperature + * @param temp temperature + * @return false vacuum fraction + */ + double CalcFalseVacFraction(const double &temp); + + /** + * @brief CalculatePercolationTemp calculation of the temperature when the + * false vacuum fraction drops below 71 % (default) + * @param false_vac_frac false vacuum fraction at percolation temperature, by + * default set to 71 % + */ + void CalculatePercolationTemp(const double &false_vac_frac = 0.71); + + /** + * @brief CalculateCompletionTemp calculation of the temperature when the + * false vacuum fraction drops below 1 % (default) + * @param false_vac_frac false vacuum fraction at completion temperature, by + * default set to 1 % + */ + void CalculateCompletionTemp(const double &false_vac_frac = 0.01); + + /** + * @brief Calculate phase transition strength alpha at percolation temperature + */ + void CalculatePTStrength(); + + /** + * @brief Calculate wall velocity + * @param false_min initial, false minimum + * @param true_min final, true minimum + */ + void CalculateWallVelocity(const Minimum &false_min, const Minimum &true_min); + + /** + * @brief Calculate inverse time scale of phase transition + */ + void CalculateInvTimeScale(); + + /** + * @brief Get inverse time scale of phase transition + */ + double GetInvTimeScale(); +}; + +/** + * @brief Nintegrate_Inner Numerical integration of inner integral over inverse + * Hubble rate for the percolation temperature calculation + * @param obj Class reference to pass all needed parameters + * @param T upper integration boundary + * @return Numerical value of integral and absolute error + */ +struct resultErrorPair Nintegrate_Inner(BounceSolution &obj, + const double &Tprime); + +/** + * @brief Nintegrate_Outer Numerical integration of outer integral for the + * percolation temperature calculation + * @param obj Class reference to pass all needed parameters + * @return Numerical value of integral and absolute error + */ +struct resultErrorPair Nintegrate_Outer(BounceSolution &obj); + +/** + * @brief Nderive_BounceRatio Numerical derivative for the inverse time scale + * calculation + * @param obj Class reference to pass all needed parameters + * @return Numerical value of derivative and absolute error + */ +struct resultErrorPair Nderive_BounceRatio(BounceSolution &obj); + +} // namespace BSMPT diff --git a/include/BSMPT/config.h.in b/include/BSMPT/config.h.in index 835d7552..71fd83d2 100644 --- a/include/BSMPT/config.h.in +++ b/include/BSMPT/config.h.in @@ -3,3 +3,4 @@ #cmakedefine libcmaes_FOUND #cmakedefine NLopt_FOUND #cmakedefine Boost_FOUND +#cmakedefine nlohmann_json_FOUND diff --git a/include/BSMPT/gravitational_waves/gw.h b/include/BSMPT/gravitational_waves/gw.h new file mode 100644 index 00000000..e0686155 --- /dev/null +++ b/include/BSMPT/gravitational_waves/gw.h @@ -0,0 +1,223 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana +// +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +/** + * @file gravitational wave calculation + */ + +#include // BounceSolution +#include +#include +#include + +namespace BSMPT +{ + +/** + * @brief struct to store all calculated GW data + */ +struct GravitationalWaveData +{ + bool swON = true; // enable sound wave contribution by default + bool turbON = true; // enable turbulence contribution by default + double transitionTemp = false; // transition temperature + double PTStrength = false; // strength of EW phase transition + double InvTimeScale = false; // inverse time scale beta/H + double vb = false; // bubble wall velocity + + double kappa_sw = false; // efficiency factor for sound waves + double K_sw = false; // kinetic energy fraction in fluid of total bubble + // energy for sound waves + double HR = false; // time scale times max. velocity for sound waves + double kappa_turb = false; // efficiency factor for turbulence + double K_turb = false; // kinetic energy fraction in fluid of total bubble + // energy for turbulence + double gstar = false; // number of eff. d.o.f. + double Hstar = false; // Hubble rate at percolation temperature + + double fPeakSoundWave = false; // peak frequency for sound wave + double h2OmegaPeakSoundWave = false; // peak amplitude for sound wave + double fPeakTurbulence = false; // peak frequency for turbulence + double h2OmegaPeakTurbulence = false; // peak amplitude for turbulence + + StatusGW status = StatusGW::NotSet; // gw calculation status +}; + +class GravitationalWave +{ +private: +public: + GravitationalWaveData data; + GravitationalWave(BounceSolution &BACalc, + const int &which_transition_temp = 3); + ~GravitationalWave(); + + /** + * @brief CalcEpsTurb calculate epsilon for turbulence contribution + * @param epsturb_in is the input value for epsturb. If [0..1] set + * to value, for -1 we use the upper bound from + * https://arxiv.org/abs/1704.05871 + * @return value for epsturb + */ + double CalcEpsTurb(double epsturb_in); + + /** + * @brief AbsErr absolute error for numerical integration + */ + const double AbsErr = 0; + + /** + * @brief RelErr relative error for numerical integration + */ + const double RelErr = 1e-6; + + /** + * @brief reduced Hubble constant + * + */ + double h = 0.674; + + /** + * @brief Calculate peak frequency of GW signal for sound waves + */ + void CalcPeakFrequencySoundWave(); + + /** + * @brief Calculate peak amplitude of GW signal for sound waves + */ + void CalcPeakAmplitudeSoundWave(); + + /** + * @brief Calculate peak frequency of GW signal from turbulence + */ + void CalcPeakFrequencyTurbulence(); + + /** + * @brief Calculate peak amplitude of GW signal from turbulence + */ + void CalcPeakAmplitudeTurbulence(); + + /** + * @brief Amplitude of GW signal as a function of + * @param f frequency + * @param swON true = contribution from sound waves switched on, + * false = switched off + * @param turbON true = contribution from turbulence switched on, + * false = switched off + * @return h2OmegaGW + */ + double CalcGWAmplitude(double f, bool swON, bool turbON); + + /** + * @brief GetSNR + * @param fmin minimal frequency + * @param fmax maximal frequency + * @param T duration of exp. data acquisition, default value: 3 years + * @return signal-to-noise (SNR) ratio at LISA + */ + double GetSNR(const double fmin, const double fmax, const double T = 3); + + /** + * @brief snr_integrand friend to define inner integrand of SNR integral + */ + friend double snr_integrand(double freq, void *params); +}; + +/** + * @brief SIfunc + * @param f frequency + * @return value of SI-function from LISA mission performance requirement for + * power spectral density + */ +double SIfunc(const double f); + +/** + * @brief Rfunc + * @param f frequency + * @return value of R-function from LISA mission performance requirement for + * power spectral density + */ +double Rfunc(const double f); + +/** + * @brief powspec_density + * @param f frequency + * @return value of power spectral density-function from LISA mission + * performance requirement + */ +double powspec_density(const double f); + +/** + * @brief return the value of LISA mission nominal sensitivity + * + * @param f frequency + * @return value of LISA's nominal sensitivity for a given frequency + */ +double h2OmSens(const double f); + +/** + * @brief Nintegrate_SNR Numerical integration of SNR integral + * @param obj Class reference to pass all needed parameters + * @return Numerical value of integral and absolute error + */ +struct resultErrorPair +Nintegrate_SNR(GravitationalWave &obj, const double fmin, const double fmax); + +/** + * @brief Get efficiency factor kappa_sw for sound waves + * + * @param alpha strength of the phase transition + * @param vwall bubble wall velocity + * @param Csound speed of sound + * @return double + */ +double +Getkappa_sw(const double &alpha, const double &vwall, const double &Csound); + +/** + * @brief Get K for sound waves + * + * @param alpha strength of the phase transition + * @param vwall bubble wall velocity + * @param Csound speed of sound + * @return double + */ +double GetK_sw(const double &alpha, const double &vwall, const double &Csound); + +/** + * @brief Get HR for sound waves + * + * @param invTimeScale beta/H, inverse time scale + * @param vwall bubble wall velocity + * @param Csound speed of sound + * @return double + */ +double +GetHR(const double &invTimeScale, const double &vwall, const double &Csound); + +/** + * @brief Get K for turbulence + * + * @param alpha strength of the phase transition + * @param kappa turbulence efficiency factor + * @return double + */ +double GetK_turb(const double &alpha, const double &kappa); + +/** + * @brief Determine fluid turnover time regime + * + * @param HR mean bubble separation + * @param K fraction of the kinetic energy in the fluid + * @return true if H*tauSH approx. 1, false if smaller than 1 + */ +bool IsFluidTurnoverApproxOne(const double &HR, const double &K); + +} // namespace BSMPT \ No newline at end of file diff --git a/include/BSMPT/minimizer/MinimizePlane.h b/include/BSMPT/minimizer/MinimizePlane.h index 56c514b5..43f2c30c 100644 --- a/include/BSMPT/minimizer/MinimizePlane.h +++ b/include/BSMPT/minimizer/MinimizePlane.h @@ -1,4 +1,5 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -123,6 +124,36 @@ struct PointerContainerMinPlane * @return MinimizePlaneReturn struct which has the minimum and the value of the * potential */ +[[deprecated("Will call MinimizePlane with GetSMConstants(). Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] MinimizePlaneReturn +MinimizePlane(const std::vector &basepoint, + const std::vector &VEVSymmetric, + const std::vector &VEVBroken, + const ModelID::ModelIDs &Model, + const std::vector &par, + const std::vector &parCT, + const double &Temp, + const int &WhichMinimizer = WhichMinimizerDefault); + +/** + * Calculates the minimum of a potential on a plane. For this the normal vector + * of the plane is calculated as the connection vector between the symmetric and + * the broken phase. At a given point the plane normal to the connection vector + * is then calculated and the potential is minimised along this plane. + * @param basepoint Parameter point at which the plane and the connection + * between the symmetric and the broken minimum should be calculated + * @param VEVSymmetric Symmetric minimum + * @param VEVBroken Broken minimum + * @param Model Decides which model should be used through FChoose + * @param par Inputparameters for the parameterpoint + * @param parCT Counterterm parameters for the parameterpoint + * @param SMConstant The SM constants used by the parameter point + * @param Temp Temperature at which the minimum should be calculated + * @return MinimizePlaneReturn struct which has the minimum and the value of the + * potential + */ MinimizePlaneReturn MinimizePlane(const std::vector &basepoint, const std::vector &VEVSymmetric, @@ -130,6 +161,7 @@ MinimizePlane(const std::vector &basepoint, const ModelID::ModelIDs &Model, const std::vector &par, const std::vector &parCT, + const ISMConstants &SMConstant, const double &Temp, const int &WhichMinimizer = WhichMinimizerDefault); /** diff --git a/include/BSMPT/minimizer/Minimizer.h b/include/BSMPT/minimizer/Minimizer.h index 366df523..a9c1dbec 100644 --- a/include/BSMPT/minimizer/Minimizer.h +++ b/include/BSMPT/minimizer/Minimizer.h @@ -95,7 +95,13 @@ MinimizersToUse GetMinimizers(int WhichMinimizer); */ constexpr int WhichMinimizerDefault = CalcWhichMinimizer(); -// Minimizer.cpp +/** + * @brief Minimization of the Model + * Minimizes the given Potential with parameters par and CT-parameters parCT at + * a given Temperature Temp and writes the solution in the std::vector sol. The + * Minimization Debugging Options are written in the std::vector Check. The + * std::vector Start gives the start value for the CMA-ES Minimization. + */ std::vector Minimize_gen_all(const std::shared_ptr &modelPointer, const double &Temp, @@ -174,10 +180,36 @@ PTFinder_gen_all(const std::shared_ptr &modelPointer, * = NLOPT, to use multiple add the numbers * @return the global minimum */ +[[deprecated("Will call Minimize_gen_all_tree_level with GetSMConstants(). " + "Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] std::vector +Minimize_gen_all_tree_level(const ModelID::ModelIDs &Model, + const std::vector &par, + const std::vector &parCT, + std::vector &Check, + const std::vector &start, + int WhichMinimizer = WhichMinimizerDefault, + bool UseMultithreading = true); + +/** + * @brief Minimize_gen_all_tree_level Minimizes the tree-level potential + * @param Model Which Model to minimize + * @param par parameters of the point + * @param parCT counterterm parameters + * @param SMConstants The SM Constants used for the minimisation + * @param Check Vector to safe the error flags during the minimization + * @param start Starting point for the minimization + * @param WhichMinimizer Which minimizers should be taken? 1 = CMAES, 2 = GSL, 4 + * = NLOPT, to use multiple add the numbers + * @return the global minimum + */ std::vector Minimize_gen_all_tree_level(const ModelID::ModelIDs &Model, const std::vector &par, const std::vector &parCT, + const ISMConstants &SMConstants, std::vector &Check, const std::vector &start, int WhichMinimizer = WhichMinimizerDefault, diff --git a/include/BSMPT/minimum_tracer/minimum_tracer.h b/include/BSMPT/minimum_tracer/minimum_tracer.h new file mode 100644 index 00000000..eafb84ce --- /dev/null +++ b/include/BSMPT/minimum_tracer/minimum_tracer.h @@ -0,0 +1,953 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana +// +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +/** + * @file minimum tracer class + */ +#include "Eigen/Eigenvalues" // Eigenvalues utility +#include // for Minimizer +#include // for Class_Potential_Origin +#include // for Logger Class +#include +#include +#include // Eigenvalues matrix +#include +#include // std::pow +#include // for shared_ptr +#include // std::optional +#include // std::strtol + +namespace BSMPT +{ + +/** + * @brief Value to be store in the columns without any values + * + */ +const double EmptyValue = NAN; +/** + * @brief Possible NLO stability status + * + */ +enum class StatusNLOStability +{ + NotSet, + Off, + Success, + NoNLOStability +}; +/** + * @brief Map to convert StatusNLOStability to strins + * + */ +const std::unordered_map + StatusNLOStabilityToString{ + {StatusNLOStability::NotSet, "not_set"}, + {StatusNLOStability::Off, "off"}, + {StatusNLOStability::Success, "success"}, + {StatusNLOStability::NoNLOStability, "no_nlo_stability"}}; +/** + * @brief Possible electroweak symmetry restoration status + * + */ +enum class StatusEWSR +{ + NotSet, + Off, + Failure, + NotBFB, + FlatRegion, + EWSymNonRes, + EWSymRes +}; +/** + * @brief Map to convert StatusEWSRToString to strins + * + */ +const std::unordered_map StatusEWSRToString{ + {StatusEWSR::NotSet, "not_set"}, + {StatusEWSR::Off, "off"}, + {StatusEWSR::Failure, "failure"}, + {StatusEWSR::NotBFB, "non_bfb"}, + {StatusEWSR::FlatRegion, "flat_region"}, + {StatusEWSR::EWSymNonRes, "ew_syum_non_res"}, + {StatusEWSR::EWSymRes, "ew_sym_res"}}; +/** + * @brief Possible tracing results + * + */ +enum class StatusTracing +{ + NotSet, + Success, + NoCoverage, + NoMinsAtBoundaries, + NoGlobMinCoverage, + Failure +}; +/** + * @brief Map to convert StatusTracingToString to strins + * + */ +const std::unordered_map StatusTracingToString{ + {StatusTracing::NotSet, "not_set"}, + {StatusTracing::Success, "success"}, + {StatusTracing::NoCoverage, "no_coverage"}, + {StatusTracing::NoMinsAtBoundaries, "no_mins_at_boundaries"}, + {StatusTracing::NoGlobMinCoverage, "no_glob_min_coverage"}, + {StatusTracing::Failure, "failure"}}; +/** + * @brief Possible status for the coex phase + * + */ +enum class StatusCoexPair +{ + NotSet, + Success, + NoCoexPairs +}; +/** + * @brief Map to convert StatusCoexPairToString to strins + * + */ +const std::unordered_map StatusCoexPairToString{ + {StatusCoexPair::NotSet, "not_set"}, + {StatusCoexPair::Success, "success"}, + {StatusCoexPair::NoCoexPairs, "no_coex_pair"}}; +/** + * @brief Possible status for the critical temperature + * + */ +enum class StatusCrit +{ + NotSet, + Success, + FalseLower, + TrueLower, + Failure +}; +/** + * @brief Map to convert StatusCritToString to strins + * + */ +const std::unordered_map StatusCritToString{ + {StatusCrit::NotSet, "not_set"}, + {StatusCrit::Success, "success"}, + {StatusCrit::FalseLower, "false_lower"}, + {StatusCrit::TrueLower, "true_lower"}, + {StatusCrit::Failure, "failure"}}; +/** + * @brief Possible status for the approximated nucleation, exact nucleation, + * percolation and completion temperature + * + */ +enum class StatusTemperature +{ + NotSet, + Success, + NotMet, + NaN +}; +/** + * @brief Map to convert StatusTemperature to strins + * + */ +const std::unordered_map + StatusTemperatureToString{{StatusTemperature::NotSet, "not_set"}, + {StatusTemperature::Success, "success"}, + {StatusTemperature::NotMet, "not_met"}, + {StatusTemperature::NaN, "nan"}}; +/** + * @brief Possible results for the GW and bounce_sol class. + * + */ +enum class StatusGW +{ + NotSet, + Success, + Failure +}; +/** + * @brief Map to convert StatusGWToString to strins + * + */ +const std::unordered_map StatusGWToString{ + {StatusGW::NotSet, "not_set"}, + {StatusGW::Success, "success"}, + {StatusGW::Failure, "failure"}}; + +/** + * @brief Override << operator to handle StatusNLOStability + * + * @param os ostream buffer + * @param status status to be printed + * @return std::ostream& buffer + */ +std::ostream &operator<<(std::ostream &os, const StatusNLOStability &status); +/** + * @brief Override << operator to handle StatusEWSR + * + * @param os ostream buffer + * @param status status to be printed + * @return std::ostream& buffer + */ +std::ostream &operator<<(std::ostream &os, const StatusEWSR &status); +/** + * @brief Override << operator to handle StatusTracing + * + * @param os ostream buffer + * @param status status to be printed + * @return std::ostream& buffer + */ +std::ostream &operator<<(std::ostream &os, const StatusTracing &status); +/** + * @brief Override << operator to handle StatusCoexPair + * + * @param os ostream buffer + * @param status status to be printed + * @return std::ostream& buffer + */ +std::ostream &operator<<(std::ostream &os, const StatusCoexPair &status); +/** + * @brief Override << operator to handle StatusCrit + * + * @param os ostream buffer + * @param status status to be printed + * @return std::ostream& buffer + */ +std::ostream &operator<<(std::ostream &os, const StatusCrit &status); +/** + * @brief Override << operator to handle StatusGW + * + * @param os ostream buffer + * @param status status to be printed + * @return std::ostream& buffer + */ +std::ostream &operator<<(std::ostream &os, const StatusGW &status); +/** + * @brief Override << operator to handle StatusTemperature + * + * @param os ostream buffer + * @param status status to be printed + * @return std::ostream& buffer + */ +std::ostream &operator<<(std::ostream &os, const StatusTemperature &status); + +/** + * @brief struct to store minimum and temperature + * @param point coordinates in field space + * @param temp temperature + * @param potential value of the potential + * @param is_glob_min true if minimum is global minimum + * @param EdgeOfPhase 1 = starting minimum | 0 = Middle minimum | -1 = Ending + * minimum (sum of EdgeOfPhase is the number of coexisting phases) + */ +struct Minimum +{ + std::vector point; + double temp; + double potential; + bool is_glob_min = false; + int EdgeOfPhase = 0; + + bool operator<(const Minimum &a) const { return temp < a.temp; } +}; + +class MinimumTracer +{ +private: + int WhichMinimizer; + bool UseMultithreading; + +protected: + /** + * @brief modelPointer for the used parameter point + */ + std::shared_ptr modelPointer; + +public: + /** + * @brief Threshold for the acceptable gradient + * + */ + double GradientThreshold = 1e-3; + + /** + * @brief Add a constant to the diagonals of the hessian matrix in the + * LocateMinimum function. Helps with convergence. + * + */ + double HessianDiagonalShift = 1e-3; + + /** + * @brief Minimum found in IsThereEWSymmetryRestoration() + * + */ + std::vector HighTemperatureVEV; + + /** + * @brief Vector to store minima that appeared from VEV splittings + * + */ + std::vector SavedMinimaFromVEVSplitting; + + /** + * @brief default constructor + */ + MinimumTracer(); + + /** + * @brief constructor + * @param pointer_in this->modelPointer for used parameter point + * @param WhichMinimizer_in which minimizers are used + * @param UseMultithreading_in whether or not multithreading is used + */ + MinimumTracer(const std::shared_ptr &pointer_in, + const int &WhichMinimizer_in, + const bool &UseMultithreading_in); + + /** + * @brief Calculates flat field directions + */ + void FindFlatDirections(); + + /** + * @brief Convert point into minimal non-flat space, reduces dimension in case + * of flat directions, point has to have VEV dimension + */ + void ConvertToNonFlatDirections(std::vector &point); + + /** + * @brief Calculates the list of symmetries that leave V unchanged + * + */ + void FindDiscreteSymmetries(); + + /** + * @brief ConvertToVEVDim converts point from full to reduced (VEV) dimension + * @param point point in full field dimension + * @return point in reduced VEV dimension + */ + std::vector ConvertToVEVDim(const std::vector &point); + + /** + * @brief get global minimum of effective potential + * @param Temp temperature + * @param check storage for minimization debugging options + * @param start start value for CMA-ES minimization + * @return global minimum at temperature Temp + */ + std::vector GetGlobalMinimum(const double &Temp, + std::vector &check, + const std::vector &start); + + /** + * @brief get global minimum of effective potential + * @param Temp temperature + * @param start start value for CMA-ES minimization + * @return global minimum at temperature Temp + */ + std::vector GetGlobalMinimum(const double &Temp, + const std::vector &start); + + /** + * @brief get global minimum of effective potential + * @param Temp temperature + * @return global minimum at temperature Temp + */ + std::vector GetGlobalMinimum(const double &Temp); + + /** + * @brief IsGlobMin checks whether current minimum is the global minimum + * @param min Minimum to check, sets is_glob_min to true if min is global + * minimum + */ + void IsGlobMin(Minimum &min); + + /** + * @brief GetStatusNLOVEV convert bool output of CheckNLOVEV to + * status string + * @param out bool output of CheckNLOVEV + * @return status string for output + */ + StatusNLOStability GetStatusNLOVEV(const bool &out); + + /** + * @brief GetStatusEWSR convert double output of IsThereEWSymmetryRestoration + * to status string + * @param out int output of IsThereEWSymmetryRestoration + * @return status string for output + */ + StatusEWSR GetStatusEWSR(const int &out); + + /** + * @brief IsThereEWSymmetryRestoration checks if there is EW symmetry + * restoration at high temperatures + * @return status; if status < -1: no minimum if status = 0: calculation + * failed, if status = 1: flat region with minimum, if status = 2: there is a + * minimum but no symmetry restoration, if status = 3: symmetry restoration + */ + int IsThereEWSymmetryRestoration(); + + /** + * @brief SmallestEigenvalue calculate Eigenvalues of Hessian and returns + * smallest + * @param point point where to evaluate the Hessian + * @param Hessian Hessian function + * @return smallest Eigenvalue of Hessian + */ + double SmallestEigenvalue( + const std::vector &point, + const std::function>(std::vector)> + &Hessian); + + /** + * @brief FindZeroSmallestEigenvalue + * @param point_1 first point + * @param T_1 temperature of first point + * @param point_2 second point + * @param T_2 temperature of second point + * @return stationary point found in between point_1 and point_2 + */ + std::vector FindZeroSmallestEigenvalue(std::vector point_1, + double T_1, + std::vector point_2, + double T_2); + + /** + * @brief TrackPhase with enforced global minimum tracing (= phase is checked + * if it is still the global minimum until it is no longer, then the current + * temperature is stored in globMinEndT) + * @param globMinEndT temperature at which phase is no longer global minimum + * @param point_In start point for tracking + * @param currentT_In start point temperature for phase tracking + * @param finalT end point temperature + * @param dT_In initial temperature step size + * @param output if true tracking output is printed on the screen + * @param unprotected if true we dont check the hessian + */ + std::vector TrackPhase(double &globMinEndT, + const std::vector &point_In, + const double ¤tT_In, + const double &finalT, + const double &dT_In = 1, + const bool &output = true, + const bool &unprotected = false); + + /** + * @brief TrackPhase + * @param point_In start point for tracking + * @param currentT_In start point temperature for phase tracking + * @param finalT end point temperature + * @param dT_In initial temperature step size + * @param output if true tracking output is printed on the screen + * @param unprotected if true we dont check the hessian + */ + std::vector TrackPhase(const std::vector &point_In, + const double ¤tT_In, + const double &finalT, + const double &dT_In = 1, + const bool &output = true, + const bool &unprotected = false); + + /** + * @brief bool to store whether flat directions are found + */ + bool flat_dirs_found = false; + + /** + * @brief storage of all non-flat VEV-directions + */ + std::vector NonFlatDirections; + + /** + * @brief storage of indices of flat 1D directions in VEV basis + */ + std::vector flat_1D_dirs; + + /** + * @brief storage of indices of flat 2D directions in VEV basis + */ + std::vector> flat_2D_dirs; + + /** + * @brief storage of indices of flat 3D directions in VEV basis + */ + std::vector> flat_3D_dirs; + + /** + * @brief List of group elements allowed by the potential + * + */ + std::vector GroupElements; + + /** + * @brief Reduce the VEV into the same principal quadrant. + * + * @param point to be rotated + */ + void ReduceVEV(std::vector &vev); + + /** + * @brief Reduce the VEV of the minimum into the same principal quadrant. + * + * @param min to be rotated + */ + void ReduceVEV(Minimum &min); + + /** + * @brief WarpPath + * @param path + * @param T1 + * @param F1 + * @param T2 + * @param F2 + * @return wraped path + */ + const std::vector> + WarpPath(const std::vector> &path, + const std::vector &T1, + const std::vector &F1, + const std::vector &T2, + const std::vector &F2); + + /** + * @brief Finds stationary points of a function (not only minimas). + * + * @param guess_In is the initial guess for the minimum + * @param df gradient of the function to be minimized + * @param Hessian hessian of the function + * @param error Maximum size of \f$ | \vec{df} | \f$ that is considered a + * minimum + * @param const_multiplier If \f$ \det{Hessian} = 0\f$ this method does not + * work. In that case we move the guess as \f$ \vec{p} \rightarrow \vec{p} - + * const\_multiplier * \vec{df}\f$ + * @param maxiter Maximum iteration exiting function + * @return std::vector + */ + std::vector LocateMinimum( + const std::vector &guess_In, + std::function(std::vector)> &df, + std::function>(std::vector)> + &Hessian, + const double &error = 1e-4, + const double &const_multiplier = 1e-2, + const int &maxiter = 100); + + /** + * @brief GetLegend derive legend + * @param num_coex_phases number of coexisting phase regions + * @param do_gw_calc bool that determines whether gw calculation is performed + * @return vector of column label strings + */ + std::vector GetLegend(const int &num_coex_phases, + const bool &do_gw_calc); +}; + +/** + * @brief Create1DimGrid creates a 1-dim grid of given size in index-direction + * @param point + * @param k index direction in which to create grid + * @param low_value + * @param high_value + * @param nsteps + * @return gridsize-dim vector of vectors + */ +std::vector> +Create1DimGrid(const std::vector &point, + const int k, + const double low_value, + const double high_value, + const int nsteps = 100); + +/** + * @brief Create1DimGrid creates a 1-dim grid of given size between two points + * @param min_start + * @param min_end + * @param npoints + * @return npoints long vector of steps on connecting line between min_start and + * min_end + */ +std::vector> +Create1DimGrid(const std::vector &min_start, + const std::vector &min_end, + const int npoints = 100); + +/** + * Returns true if two values are the same given some relative precision + */ +bool almost_the_same(const double &a, + const double &b, + const double &rel_precision = 0.01, + const double &num_zero = 1e-10); + +/** + * Returns true if two vectors are the element-wise the same given some relative + * precision + */ +bool almost_the_same(const std::vector &a, + const std::vector &b, + const bool &allow_for_sign_flip = false, + const double &rel_precision = 0.01, + const double &num_zero = 1e-10); + +/** + * @brief Phase object + * + */ +struct Phase +{ + /** + * @brief phase ID + */ + int id = 0; + + /** + * @brief Lowest temperature of the phase + */ + double T_low = 0; + + /** + * @brief Highest temperature of the phase + */ + double T_high = 0; + + /** + * @brief Set of Minimum that compose the phase + */ + std::vector MinimumPhaseVector; + + /** + * @brief MinTracer object + */ + std::shared_ptr MinTracer; + + /** + * @brief Function that adds min to MinimumPhaseVector + * + * @param min Minimum + */ + void Add(Minimum min); + + /** + * @brief Calculates the minimum of the phase at temperature T. This function + * assumes that T is inside the temperature range of the phase. + * + * @param T temperature + * @return Minimum at temperature T for the corresponding phase + */ + Minimum Get(double T); + + /** + * @brief empty constructor + */ + Phase(); + + /** + * @brief Construct a new Phase object with enforced global minimum tracing + * @param phase_start Initial starting point for the phase + * @param initialT Initial temperature + * @param finalT Final temperature + * @param globMinEndT Temperature where phase is first detected to no longer + * be global minimum + * @param MinTracerIn MinTracer pointer + */ + Phase(const std::vector &phase_start, + const double &initialT, + const double &finalT, + double &globMinEndT, + std::shared_ptr &MinTracerIn); + + /** + * @brief Construct a new Phase:: Phase object + * + * @param phase_start Initial starting point for the phase + * @param initialT Temperature of the phase given as input + * @param LowT Lowest temperature + * @param HighT Highest temperature + * @param globMinEndT Temperature where phase is first detected to no longer + * be global minimum + * @param MinTracerIn MinTracer pointer + */ + Phase(const double &initialT, + const std::vector &phase_start, + const double &LowT, + const double &HighT, + double &globMinEndT, + std::shared_ptr &MinTracerIn); + + /** + * @brief Construct a new Phase object + * + * @param phase_start Initial starting point for the phase + * @param initialT Initial temperature + * @param finalT Final temperature + * @param globMinEndT Temperature where phase is first detected to no longer + * be global minimum + * @param MinTracerIn MinTracer pointer + */ + Phase(const std::vector &phase_start, + const double &initialT, + const double &finalT, + std::shared_ptr &MinTracerIn); + + /** + * @brief Construct a new Phase:: Phase object + * + * @param phase_start Initial starting point for the phase + * @param initialT Temperature of the phase given as input + * @param LowT Lowest temperature + * @param HighT Highest temperature + * @param MinTracerIn MinTracer pointer + */ + Phase(const double &initialT, + const std::vector &phase_start, + const double &LowT, + const double &HighT, + std::shared_ptr &MinTracerIn); + + /** + * @brief Construct a new Phase:: Phase object + * + * @param initialT Temperature of the phase given as input + * @param LowT Lowest temperature + * @param HighT Highest temperature + * @param MinTracerIn MinTracer pointer + */ + Phase(const double &initialT, + const double &LowT, + const double &HighT, + std::shared_ptr &MinTracerIn); +}; + +/** + * @brief CoexPhases struct to save pair of coexisting phases (false and true + * phase) + */ +struct CoexPhases +{ + int coex_pair_id; + double T_high; + double T_low; + Phase false_phase; + Phase true_phase; + double crit_temp = -1; + StatusCrit crit_status = StatusCrit::NotSet; + + /** + * @brief empty constructor + */ + CoexPhases(); + + /** + * @brief constructor + */ + CoexPhases(const int &pair_id, + const Phase &false_phase, + const Phase &true_phase, + const double &Tlow_in, + const double &Thigh_in); + + /** + * @brief CalculateTc critical temperature for coexising phase pair + */ + void CalculateTc(); +}; + +/** + * @brief Complete vacuum structure of the theory for this parameter point + * + */ +struct Vacuum +{ + /** + * @brief Lowest temperature 0 GeV + * + */ + double T_low = 0; + + /** + * @brief Highest temperature, 300 GeV or set in input file + * + */ + double T_high = 300; + + /** + * @brief Lowest temperature at which high-temperature phase is found to + * exist + * + */ + double T_low_highTempPhase = -1; + + /** + * @brief Highest temperature at which low-temperature phase is found to + * exist + * + */ + double T_high_lowTempPhase = -1; + + /** + * @brief number of equally-spaced intermediate points to check for new + * phases + */ + int num_points = 0; + + /** + * @brief vacuum status code = success, no_coverage, no_glob_min_coverage + */ + StatusTracing status_vacuum = StatusTracing::NotSet; + + /** + * @brief coexisting phases status code = success, no_coex_pairs + */ + StatusCoexPair status_coex_pairs = StatusCoexPair::NotSet; + + /** + * @brief MinTracer object + * + */ + std::shared_ptr MinTracer; + + /** + * @brief Model pointer + * + */ + std::shared_ptr modelPointer; + + /** + * @brief List of different phases + * + */ + std::vector PhasesList; + + /** + * @brief List of different phase pairs + * + */ + std::vector CoexPhasesList; + + /** + * @brief Construct a new Vacuum object + * + * @param T_lowIn Lowest temperature, 0 GeV or set in input file + * @param T_highIn Highest temperature, 300 GeV or set in input file + * @param MinTracerIn MinTracer object + * @param modelPointerIn Model pointer + * @param UseMultiStepPTModeIn choose multi-step PT modes: default (= -1), + * 0, 1, 2, auto (= 3) + * @param num_pointsIn number of equally-spaced intermediate points to check + * for new phases + * @param do_only_tracing if true only tracing and no identification of all + * possible coexisting phase pairs and their critical temperatures is done, if + * false identification and calculation of Tc is done + */ + Vacuum(const double &T_lowIn, + const double &T_highIn, + std::shared_ptr &MinTracerIn, + std::shared_ptr &modelPointerIn, + const int &UseMultiStepPTModeIn, + const int &num_pointsIn = 10, + const bool &do_only_tracing = false); + + /** + * @brief MultiStepPTTracer traces all phases between T_high and T_low + * assuming that we start and end in a global minimum (absolute stability) + * @param Temp temperature at which to evaluate phase + * @param deltaT temperature step to take if already traced phase is found + * again + */ + void MultiStepPTTracer(const double &Temp, const double &deltaT = 0); + + /** + * @brief print info on phase + * @param phase Phase object + */ + void print(const Phase &phase); + + /** + * @brief setCoexPhases Calculates all coexisting phase pairs irrespective of + * borders of coexisiting phase regions, this way we take into account the + * full region of coexistance for coexisting phases and do not split at the + * border of coexisting regions which are split as soon as the number of + * coexisting phases changes which excludes transitions that have a critical + * temperature in the first region but only complete in the second region (in + * case the critical temperature is close to the region border or the + * temperature difference is large enough) + */ + void setCoexPhases(); + + /** + * @brief setCoexRegion Calculates all coexisting phase regions with phase + * pairs included from the phase vector + * @param UseMultiStepPTMode int to distinguish multistep PT mode, for all + * modes except mode 0 we try to patch up holes in tracing + */ + void setCoexRegion(const int &UseMultiStepPTMode); + + /** + * @brief Adds a phase to the phase list + * + * @param phase + */ + void addPhase(Phase &phase); + + /** + * @brief This function checks if the minimum already exists in one of the + * phases in the phase list + * @param minimum to be checked + * @return int = -1 if minimum is not in phase. Otherwise returns index of + * phase. + */ + int MinimumFoundAlready(const Minimum &minimum); + + /** + * @brief MultiStepPTMode0 single-step PT mode + * @param LowTempPoint tracing starting point at T_low + * @param HighTempPoint tracing starting point at T_high + */ + void MultiStepPTMode0(const std::vector &LowTempPoint, + const std::vector &HighTempPoint); + + /** + * @brief MultiStepPTMode1 multi-step coverage PT mode + * @param LowTempPoint tracing starting point at T_low + * @param HighTempPoint tracing starting point at T_high + */ + void MultiStepPTMode1(const std::vector &LowTempPoint, + const std::vector &HighTempPoint); + + /** + * @brief DoPhasesOverlap checks if two phases overlap + */ + bool DoPhasesOverlap(Phase &new_phase, Phase &old_phase); + + /** + * @brief DoGlobMinOverlap check for global minimum at left-/rightmost + * overlap and choose endpoint of previous phase if new phase does not overlap + */ + bool DoGlobMinOverlap(const Phase &new_phase, const Phase &old_phase); + + /** + * @brief MultiStepPTMode2 multi-step global minimum coverage PT mode + * @param LowTempPoint tracing starting point at T_low + * @param HighTempPoint tracing starting point at T_high + */ + void MultiStepPTMode2(const std::vector &LowTempPoint, + const std::vector &HighTempPoint); + + /** + * @brief prints the phases from T_low up to T_high on the terminal + * + * @param size of diagram in terminal + */ + void PrintPhasesDiagram(int size = 100); +}; + +} // namespace BSMPT \ No newline at end of file diff --git a/include/BSMPT/models/ClassPotentialC2HDM.h b/include/BSMPT/models/ClassPotentialC2HDM.h index 4c7b01fe..d2b50763 100644 --- a/include/BSMPT/models/ClassPotentialC2HDM.h +++ b/include/BSMPT/models/ClassPotentialC2HDM.h @@ -1,5 +1,6 @@ // Copyright (C) 2018 Philipp Basler and Margarete Mühlleitner -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -77,7 +78,7 @@ namespace Models class Class_Potential_C2HDM : public Class_Potential_Origin { public: - Class_Potential_C2HDM(); + Class_Potential_C2HDM(const ISMConstants &smConstants); virtual ~Class_Potential_C2HDM() override; bool UseHsmNotationInTripleHiggs = false; @@ -88,7 +89,7 @@ class Class_Potential_C2HDM : public Class_Potential_Origin Du1CT = 0, DRu3CT = 0; double DIL5CT = 0, DIu3CT = 0; double DT1 = 0, DT2 = 0, DT3 = 0, DTCharged = 0; - double DIL6CT=0; + double DIL6CT = 0; double TanBeta = 0, C_CosBeta = 0, C_SinBeta = 0, C_CosBetaSquared = 0, C_SinBetaSquared = 0; double beta = 0; @@ -97,7 +98,6 @@ class Class_Potential_C2HDM : public Class_Potential_Origin double CTempC1 = 0, CTempC2 = 0, CTempCS = 0; double R_Hh_1 = 0, R_Hh_2 = 0, R_Hh_3 = 0, R_Hl_1 = 0, R_Hl_2 = 0, R_Hl_3 = 0, R_Hsm_1 = 0, R_Hsm_2 = 0, R_Hsm_3 = 0; - void ReadAndSet(const std::string &linestr, std::vector &par) override; std::vector addLegendCT() const override; diff --git a/include/BSMPT/models/ClassPotentialCPintheDark.h b/include/BSMPT/models/ClassPotentialCPintheDark.h index 788782a1..dc9aff64 100644 --- a/include/BSMPT/models/ClassPotentialCPintheDark.h +++ b/include/BSMPT/models/ClassPotentialCPintheDark.h @@ -83,7 +83,7 @@ namespace Models class Class_Potential_CPintheDark : public Class_Potential_Origin { public: - Class_Potential_CPintheDark(); + Class_Potential_CPintheDark(const ISMConstants &smConstants); virtual ~Class_Potential_CPintheDark(); // parameters of scalar potential diff --git a/include/BSMPT/models/ClassPotentialCxSM.h b/include/BSMPT/models/ClassPotentialCxSM.h index 86e1c59e..80fa16b3 100644 --- a/include/BSMPT/models/ClassPotentialCxSM.h +++ b/include/BSMPT/models/ClassPotentialCxSM.h @@ -1,5 +1,6 @@ // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -65,7 +66,7 @@ namespace Models class Class_CxSM : public Class_Potential_Origin { public: - Class_CxSM(); + Class_CxSM(const ISMConstants &smConstants); virtual ~Class_CxSM(); // Add here your parameters for the Lagrangian as well as for the counterterm @@ -77,8 +78,8 @@ class Class_CxSM : public Class_Potential_Origin double dmsq, dlambda, ddelta2, db2, dd2, dReb1, dImb1, dRea1, dIma1, dT1, dT2, dT3, dT4, dT5, dT6; - double g1 = C_gs; - double g2 = C_g; + double g1 = SMConstants.C_gs; + double g2 = SMConstants.C_g; double vh, vs, va; diff --git a/include/BSMPT/models/ClassPotentialRN2HDM.h b/include/BSMPT/models/ClassPotentialN2HDM.h similarity index 94% rename from include/BSMPT/models/ClassPotentialRN2HDM.h rename to include/BSMPT/models/ClassPotentialN2HDM.h index d58d366c..80da9df5 100644 --- a/include/BSMPT/models/ClassPotentialRN2HDM.h +++ b/include/BSMPT/models/ClassPotentialN2HDM.h @@ -1,10 +1,11 @@ // Copyright (C) 2018 Philipp Basler and Margarete Mühlleitner -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later -#ifndef SRC_CLASSPOTENTIALRN2HDM_H_ -#define SRC_CLASSPOTENTIALRN2HDM_H_ +#ifndef SRC_CLASSPOTENTIALN2HDM_H_ +#define SRC_CLASSPOTENTIALN2HDM_H_ #include @@ -18,7 +19,7 @@ namespace Models { /** - * @brief The Class_Potential_RN2HDM class + * @brief The Class_Potential_N2HDM class * Implementation of the real N2HDM, as shown in the manual * * * \f$ -L_S = u1 \Phi_1^\dagger \Phi_1 + u2 \Phi_2^\dagger \Phi_2 + @@ -76,11 +77,11 @@ namespace Models * * Type FL(=4): \f$ \Phi_d = \Phi_1 \,,\Phi_l = \Phi_2 \f$ * */ -class Class_Potential_RN2HDM : public Class_Potential_Origin +class Class_Potential_N2HDM : public Class_Potential_Origin { public: - Class_Potential_RN2HDM(); - virtual ~Class_Potential_RN2HDM(); + Class_Potential_N2HDM(const ISMConstants &smConstants); + virtual ~Class_Potential_N2HDM(); double L1 = 0, L2 = 0, L3 = 0, L4 = 0, RL5 = 0, RealMMix = 0, u1 = 0, u2 = 0; double DL1CT = 0, DL2CT = 0, DL3CT = 0, DL4CT = 0, DRL5CT = 0, Du2CT = 0, @@ -138,4 +139,4 @@ class Class_Potential_RN2HDM : public Class_Potential_Origin } // namespace Models } // namespace BSMPT -#endif /* SRC_CLASSPOTENTIALRN2HDM_H_ */ +#endif /* SRC_CLASSPOTENTIALN2HDM_H_ */ diff --git a/include/BSMPT/models/ClassPotentialOrigin.h b/include/BSMPT/models/ClassPotentialOrigin.h index 0a389dde..4c791f3f 100644 --- a/include/BSMPT/models/ClassPotentialOrigin.h +++ b/include/BSMPT/models/ClassPotentialOrigin.h @@ -55,6 +55,12 @@ const double C_CWcbHiggs = 1.5; */ class Class_Potential_Origin { +public: + /** + * @brief SMConstants The SM constants used by the model + */ + const ISMConstants SMConstants; + protected: /** * @brief UseTreeLevel Enforces VEff to only use the tree-level potential @@ -64,7 +70,7 @@ class Class_Potential_Origin /** * MSBar renormalization scale */ - double scale = C_vev0; + double scale; /** * Number of Lagrange parameters in the Higgs Tree-Level potential @@ -383,7 +389,13 @@ class Class_Potential_Origin std::vector VevOrder; public: - Class_Potential_Origin(); + [[deprecated("Will call Class_Potential_Origin with GetSMConstants(). " + "Please use the " + "detailed overload " + "to ensure consistent SM constants through all " + "routines.")]] Class_Potential_Origin(); + + Class_Potential_Origin(const ISMConstants &smConstants); virtual ~Class_Potential_Origin(); /** @@ -445,6 +457,12 @@ class Class_Potential_Origin */ const auto &Get_Curvature_Quark_F2() const { return Curvature_Quark_F2; } + /** + * @brief Get_VevOrder allows const ref access to the VevOrder vector + * @return + */ + const std::vector &Get_VevOrder() const { return VevOrder; } + /** * @brief get_scale * @return the MSBar renormalisation scale @@ -507,6 +525,16 @@ class Class_Potential_Origin * @return NHiggs */ std::size_t get_NHiggs() const { return NHiggs; } + /** + * @brief get_NChargedHiggs + * @return NChargedHiggs + */ + std::size_t get_NChargedHiggs() const { return NChargedHiggs; } + /** + * @brief get_NNeutralHiggs + * @return NNeutralHiggs + */ + std::size_t get_NNeutralHiggs() const { return NNeutralHiggs; } /** * @brief get_NLepton * @return NLepton @@ -517,6 +545,16 @@ class Class_Potential_Origin * @return ModelID of the Model */ ModelID::ModelIDs get_Model() const { return Model; } + + /** + * @brief get_DebyeHiggs get the Debye corrections to the Higgs mass matrix + * @return + */ + const std::vector> &get_DebyeHiggs() const + { + return DebyeHiggs; + } + /** * @brief set_InputLineNumber * @param InputLineNumber_in value to set InputLineNumber @@ -571,9 +609,31 @@ class Class_Potential_Origin void setUseIndexCol(std::string legend); /** - * Initializes all vectors needed for the calculations. + * get UseIndexCol var */ - void initVectors(); + bool getUseIndexCol(); + + /** + * @brief sym2Dim Symmetrize scalar 2-dim tensor + * @param Tensor2Dim 2-dim scalar tensor + * @param Nk1 number of first indices + * @param Nk2 number of second indices + */ + void sym2Dim(std::vector> &Tensor2Dim, + std::size_t Nk1, + std::size_t Nk2); + + /** + * @brief sym3Dim Symmetrize scalar 3-dim tensor + * @param Tensor3Dim 4-dim scalar tensor + * @param Nk1 number of first indices + * @param Nk2 number of second indices + * @param Nk3 number of third indices + */ + void sym3Dim(std::vector>> &Tensor3Dim, + std::size_t Nk1, + std::size_t Nk2, + std::size_t Nk3); /** * @brief sym4Dim Symmetrize scalar 4-dim tensor @@ -590,6 +650,11 @@ class Class_Potential_Origin std::size_t Nk3, std::size_t Nk4); + /** + * Initializes all vectors needed for the calculations. + */ + void initVectors(); + /** * Calculates the effective potential and its derivatives. * @param v vev configuration at which the potential should be evaluated @@ -599,10 +664,10 @@ class Class_Potential_Origin * @param Order 0 returns the tree level potential and 1 the NLO potential. * Default value is the NLO potential */ - double VEff(const std::vector &v, - double Temp = 0, - int diff = 0, - int Order = 1) const; + virtual double VEff(const std::vector &v, + double Temp = 0, + int diff = 0, + int Order = 1) const; /** * Calculates the tree-level potential and its derivatives. * @param v the configuration of all VEVs at which the potential should be @@ -638,11 +703,20 @@ class Class_Potential_Origin * @return the value of the one-loop part of the effective potential */ double V1Loop(const std::vector &v, double Temp, int diff) const; + /** * This function calculates the EW breaking VEV from all contributing field * configurations. */ - double EWSBVEV(const std::vector &v) const; + virtual double EWSBVEV(const std::vector &v) const; + + /** + * @brief SetEWVEVZero Set all VEV directions in sol-vector to zero that + * contibute to EW VEV + * @param sol solution in nVEV-space + * @return sol with EWVEV dirs set to zero + */ + virtual void SetEWVEVZero(std::vector &sol) const; /** * Reads the string linestr and sets the parameter point @@ -728,12 +802,17 @@ class Class_Potential_Origin * tree-level minimum. */ std::vector WeinbergForthDerivative() const; + /** * Calculates the Debye corrections to the Higgs mass matrix. * If you can provide CalculateDebyeSimplified() with the Matrix as this will * reduce the runtime. + * @param forceCalculation Forces the caclulation, even if the model + * implements a simplified version. The simplified calculation will be + * skipped. */ - void CalculateDebye(); + void CalculateDebye(bool forceCalculation = false); + /** * Calculates the Debye corrections to the gauge sector. By using * CalculateDebyeGaugeSimplified() the runtime can be reduced. diff --git a/include/BSMPT/models/ClassPotentialR2HDM.h b/include/BSMPT/models/ClassPotentialR2HDM.h index 3d987ca4..9f8bf3ca 100644 --- a/include/BSMPT/models/ClassPotentialR2HDM.h +++ b/include/BSMPT/models/ClassPotentialR2HDM.h @@ -1,5 +1,6 @@ // Copyright (C) 2018 Philipp Basler and Margarete Mühlleitner -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -75,7 +76,7 @@ namespace Models class Class_Potential_R2HDM : public Class_Potential_Origin { public: - Class_Potential_R2HDM(); + Class_Potential_R2HDM(const ISMConstants &smConstants); virtual ~Class_Potential_R2HDM(); double L1 = 0, L2 = 0, L3 = 0, L4 = 0, RL5 = 0, RealMMix = 0, u1 = 0, u2 = 0; diff --git a/include/BSMPT/models/ClassPotentialSM.h b/include/BSMPT/models/ClassPotentialSM.h new file mode 100644 index 00000000..c657e8c2 --- /dev/null +++ b/include/BSMPT/models/ClassPotentialSM.h @@ -0,0 +1,99 @@ +// Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file + * Model file for the SM + */ + +#pragma once + +#include + +namespace BSMPT +{ +namespace Models +{ + +/** + * @brief The Class_SM class + * Implementation of the Standard Model + * + * + * * \f$ -L_S = muSq \Phi^\dagger \Phi + lambda (\Phi^\dagger \Phi)^2 \f$ + * * \f$ -L_Y = \overline{U}_L V \text{diag}(y_d,y_s,y_b) D_R \Phi^+ + + * \overline{D}_L \text{diag}(y_d,y_s,y_b) D_R \Phi^0 + \overline{U}_L + * \text{diag}(y_u, y_c, y_t) U_R (\Phi^0)^\ast - \overline{D}_L V^\dagger + * \text{diag}(y_u, y_c, y_t) U_R \Phi^- + \overline{E}_L \text{diag}(y_e, + * y_\mu, y_\tau) E_R \Phi^0 +\overline{\nu}_L \text{diag}(y_e, y_\mu, y_\tau) + * E_R \Phi^+ + c.c. \f$ + * * \f$ L_G = (D_\mu \Phi)^\dagger (D^\mu \Phi) \f$ + * + * with + * + * * \f$ \Phi = \begin{pmatrix} \Phi^+ \\ \Phi^0 \end{pmatrix} = + * 1/\sqrt{2} \begin{pmatrix} higgsbase[0] + I*higgsbase[1] \\ higgsbase[2] + I + * *higgsbase[3] \end{pmatrix}\,, \f$ + * * \f$ D_\mu = -I C\_{}g/2 * W_\mu^a \sigma^a -I C\_{}gs/2 B_\mu = + * -\frac{I}{2} \begin{pmatrix} C\_{}gs B + C\_{}g W3 & C\_{}g (W1 -I W2) \\ + * C\_{}g (W1 +I W2) & C\_{}gs B - C\_{}g W3 \end{pmatrix} \f$ with the gauge + * base = [W1,W2,W3,B] + * + * * \f$ \overline{U}_L = \begin{pmatrix} \overline{u}_L & \overline{c}_L & + * \overline{t}_L \end{pmatrix}\,, \f$ + * * \f$ U_R = \begin{pmatrix} u_R \\ c_R \\ t_R \end{pmatrix}\,, \f$ + * * \f$ \overline{D}_L = \begin{pmatrix} \overline{d}_L & \overline{s}_L & + * \overline{b}_L \end{pmatrix}\,, \f$ + * * \f$ D_R = \begin{pmatrix} d_R \\ s_R \\ b_R \end{pmatrix}\,, \f$ + * * \f$ \overline{E}_L = \begin{pmatrix} \overline{e}_L & \overline{\mu}_L & + * \overline{\tau}_L \end{pmatrix}\,, \f$ + * * \f$ E_R = \begin{pmatrix} e_R \\ \mu_R \\ \tau_R \end{pmatrix}\,, \f$ + * * \f$ \overline{\nu}_L = \begin{pmatrix} \overline{\nu}_{e,L} & + * \overline{\nu}_{\mu,L} & \overline{\nu}_{\tau,L} \end{pmatrix} \f$ + * + * The basis of the quarks given by \f$ [u_R, c_R, t_R, d_R, s_R, b_R, + * \overline{u}_L, \overline{c}_L, \overline{t}_L, \overline{d}_L, + * \overline{s}_L, \overline{b}_L ] \f$ and for the leptons \f$ [\overline{e}_L, + * e_R, \overline{\mu}_L , \mu_R, \overline{\tau}_L, \tau_R, + * \overline{\nu}_{e,L}, \overline{\nu}_{\mu,L}, \overline{\nu}_{\tau,L} ] \f$ + */ +class Class_SM : public Class_Potential_Origin +{ +public: + Class_SM(const ISMConstants &smConstants); + virtual ~Class_SM(); + + double muSq, lambda; + + double dmuSq, dlambda, dT1, dT2, dT3, dT4; + + double v0; + + void ReadAndSet(const std::string &linestr, + std::vector &par) override; + std::vector addLegendCT() const override; + std::vector addLegendTemp() const override; + std::vector addLegendTripleCouplings() const override; + std::vector addLegendVEV() const override; + + void set_gen(const std::vector &par) override; + void set_CT_Pot_Par(const std::vector &par) override; + void write() const override; + + void TripleHiggsCouplings() override; + std::vector calc_CT() const override; + + void SetCurvatureArrays() override; + bool CalculateDebyeSimplified() override; + bool CalculateDebyeGaugeSimplified() override; + double VTreeSimplified(const std::vector &v) const override; + double VCounterSimplified(const std::vector &v) const override; + void Debugging(const std::vector &input, + std::vector &output) const override; +}; + +} // namespace Models +} // namespace BSMPT diff --git a/include/BSMPT/models/ClassTemplate.h b/include/BSMPT/models/ClassTemplate.h index 997cf78b..d596eca3 100644 --- a/include/BSMPT/models/ClassTemplate.h +++ b/include/BSMPT/models/ClassTemplate.h @@ -1,5 +1,6 @@ // Copyright (C) 2018 Philipp Basler and Margarete Mühlleitner -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -25,7 +26,7 @@ namespace Models class Class_Template : public Class_Potential_Origin { public: - Class_Template(); + Class_Template(const ISMConstants &smConstants); virtual ~Class_Template(); // Add here your parameters for the Lagrangian as well as for the counterterm diff --git a/include/BSMPT/models/IncludeAllModels.h b/include/BSMPT/models/IncludeAllModels.h index bbd4e02f..3b72adf1 100644 --- a/include/BSMPT/models/IncludeAllModels.h +++ b/include/BSMPT/models/IncludeAllModels.h @@ -4,8 +4,8 @@ // // SPDX-License-Identifier: GPL-3.0-or-later -//#ifndef INCLUDEALLMODELS_H_ -//#define INCLUDEALLMODELS_H_ +// #ifndef INCLUDEALLMODELS_H_ +// #define INCLUDEALLMODELS_H_ #pragma once @@ -20,6 +20,7 @@ */ namespace BSMPT { +struct ISMConstants; class Class_Potential_Origin; namespace ModelID { @@ -32,9 +33,10 @@ enum class ModelIDs NotSet, C2HDM, R2HDM, - RN2HDM, + N2HDM, CXSM, CPINTHEDARK, + SM, // Here you start adding your models TEMPLATE, @@ -50,8 +52,9 @@ enum class ModelIDs const std::unordered_map ModelNames{ {"c2hdm", ModelIDs::C2HDM}, {"r2hdm", ModelIDs::R2HDM}, - {"n2hdm", ModelIDs::RN2HDM}, + {"n2hdm", ModelIDs::N2HDM}, {"cxsm", ModelIDs::CXSM}, + {"sm", ModelIDs::SM}, {"cpinthedark", ModelIDs::CPINTHEDARK}, {"template", ModelIDs::TEMPLATE}, }; @@ -68,8 +71,22 @@ std::unordered_map InvertModelNames(); * choice. If choice == NotSet the function throws an runtime error * @throw Runtime error if an invalid model was given into choice */ +[[deprecated( + "Will call FChoose with GetSMConstants(). Please use the detailed overload " + "to ensure consistent SM constants through all routines.")]] std:: + unique_ptr + FChoose(ModelIDs choice); -std::unique_ptr FChoose(ModelIDs choice); +/** + * @param choice ModelIDs for the Model under investigation + * @return smart pointer to the instance of the class matching the ModelIDs + * choice. If choice == NotSet the function throws an runtime error + * @param smConstants The SM Constants to use for the parameter + * @throw Runtime error if an invalid model was given into choice + */ + +std::unique_ptr +FChoose(ModelIDs choice, const ISMConstants &smConstants); /** * @@ -88,4 +105,4 @@ void ShowInputError(); } // namespace BSMPT -//#endif /* INCLUDEALLMODELS_H_ */ +// #endif /* INCLUDEALLMODELS_H_ */ diff --git a/include/BSMPT/models/ModelTestfunctions.h b/include/BSMPT/models/ModelTestfunctions.h index afa13c26..2efb4fd6 100644 --- a/include/BSMPT/models/ModelTestfunctions.h +++ b/include/BSMPT/models/ModelTestfunctions.h @@ -8,6 +8,8 @@ #include #include +#include + namespace BSMPT { class Class_Potential_Origin; @@ -43,7 +45,7 @@ CheckCTConditionsSecondDerivative(const Class_Potential_Origin &point); TestResults CheckCTIdentities(const Class_Potential_Origin &point); TestResults CheckCTNumber(const Class_Potential_Origin &point); -TestResults CheckCKMUnitarity(); +TestResults CheckCKMUnitarity(const ISMConstants &SMConstants); TestResults CheckSymmetricTensorScalarSecond( const std::vector> &Tensor); TestResults CheckSymmetricTensorScalarThird( diff --git a/include/BSMPT/models/SMparam.h b/include/BSMPT/models/SMparam.h index 59942a07..48c3fe71 100644 --- a/include/BSMPT/models/SMparam.h +++ b/include/BSMPT/models/SMparam.h @@ -1,5 +1,6 @@ // Copyright (C) 2018 Philipp Basler and Margarete Mühlleitner -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -17,245 +18,224 @@ namespace BSMPT { /** - * @brief imaginary number i - */ -const std::complex II(0, 1); - -// CKM Matrix - -// const double C_Vts = 0.0404; -// const double C_Vtd = 0.00867; -// const double C_Vtb = std::sqrt(1-C_Vts*C_Vts - C_Vtd*C_Vtd); //0.9991; -// const double C_Vcb = 0.0412; -// const double C_Vcd = 0.22520; -// const double C_Vcs = std::sqrt(1-C_Vcb*C_Vcb-C_Vcd*C_Vcd);//0.97344; -// const double C_Vub = 0.00351; -// const double C_Vus = 0.22534; -// const double C_Vud = std::sqrt(1-C_Vub*C_Vub-C_Vus*C_Vus);//0.97427; - -// CKM Matrix as unitary - -// const std::complex C_Vts=0; -// const std::complex C_Vtd = 0; -// const std::complex C_Vtb = 1; //0.9991; -// const std::complex C_Vcb = 0; -// const std::complex C_Vcd = 0; -// const std::complex C_Vcs = 1;//0.97344; -// const std::complex C_Vub = 0; -// const std::complex C_Vus = 0; -// const std::complex C_Vud = 1; //0.97427; - -/* Here is an example of the CKM Matrix given by the standard parameters. The - * elements V11, V23 and V33 are real in this parametrisation and are calculated - * by the other elements and the unitarity conditions. If the unitarity at - * numerical precision is not given you will end up with massive charged - * Goldstone bosons - */ - -/** - * @brief The lambda parameter in the Wolfenstein parametrisation of the - * CKM-Matrix LHCHXSWG-INT-2015-006 - */ -const double C_Wolfenstein_lambda = 0.22537; -/** - * @brief The A parameter in the Wolfenstein parametrisation of the CKM-Matrix - * LHCHXSWG-INT-2015-006 - */ -const double C_Wolfenstein_A = 0.814; -/** - * @brief The rho parameter in the Wolfenstein parametrisation of the CKM-Matrix - * LHCHXSWG-INT-2015-006 - */ -const double C_Wolfenstein_rho = 0.117; -/** - * @brief The eta parameter in the Wolfenstein parametrisation of the CKM-Matrix - * LHCHXSWG-INT-2015-006 - */ -const double C_Wolfenstein_eta = 0.353; - -/** - * @brief The theta_12 mixing angle in the CKM matrix calculated by the - * Wolfenstein parameters - */ -const double theta12 = std::asin(C_Wolfenstein_lambda); -/** - * @brief The theta_23 mixing angle in the CKM matrix calculated by the - * Wolfenstein parameters - */ -const double theta23 = - std::asin(C_Wolfenstein_A * std::pow(C_Wolfenstein_lambda, 2)); -/** - * @brief The CP-violating angle in the CKM matrix calculated by the Wolfenstein - * parameters - */ -const double delta = - std::arg(C_Wolfenstein_A * std::pow(C_Wolfenstein_lambda, 3) * - (C_Wolfenstein_rho + II * C_Wolfenstein_eta)); -/** - * @brief The theta_13 mixing angle in the CKM matrix calculated by the - * Wolfenstein parameters - */ -const double theta13 = - std::asin(std::abs(C_Wolfenstein_A * std::pow(C_Wolfenstein_lambda, 3) * - (C_Wolfenstein_rho + II * C_Wolfenstein_eta))); - -/** - * @brief ud element of the CKM matrix - */ -const std::complex C_Vud = std::cos(theta12) * std::cos(theta13); -/** - * @brief us element of the CKM matrix - */ -const std::complex C_Vus = std::sin(theta12) * std::cos(theta13); -/** - * @brief ub element of the CKM matrix - */ -const std::complex C_Vub = std::sin(theta13) * std::exp(-delta * II); - -/** - * @brief cd element of the CKM matrix - */ -const std::complex C_Vcd = -std::sin(theta12) * std::cos(theta23) - - std::cos(theta12) * std::sin(theta23) * - std::sin(theta13) * std::exp(II * delta); -/** - * @brief cs element of the CKM matrix - */ -const std::complex C_Vcs = std::cos(theta12) * std::cos(theta23) - - std::sin(theta12) * std::sin(theta23) * - std::sin(theta13) * std::exp(II * delta); -/** - * @brief cb element of the CKM matrix - */ -const std::complex C_Vcb = std::sin(theta23) * std::cos(theta13); - -/** - * @brief td element of the CKM matrix - */ -const std::complex C_Vtd = std::sin(theta12) * std::sin(theta23) - - std::cos(theta12) * std::cos(theta23) * - std::sin(theta13) * std::exp(II * delta); -/** - * @brief ts element of the CKM matrix - */ -const std::complex C_Vts = -std::cos(theta12) * std::sin(theta23) - - std::sin(theta12) * std::cos(theta23) * - std::sin(theta13) * std::exp(II * delta); -/** - * @brief tb element of the CKM matrix - */ -const std::complex C_Vtb = std::cos(theta23) * std::cos(theta13); - -/** - * @brief Mass of the W-Boson - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassW = 80.385; -/** - * @brief Mass of the Z-Boson - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassZ = 91.1876; -/** - * @brief Mass of the Higgs Boson - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassSMHiggs = 125.09; - -/** - * @brief Mass of the up quark - * Unit: GeV - * https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG - */ -const double C_MassUp = 0.1; -/** - * @brief Mass of the down quark - * Unit: GeV - * https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG - */ -const double C_MassDown = 0.1; -/** - * @brief Mass of the strange quark - * Unit: GeV - * https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG - */ -const double C_MassStrange = 0.1; -/** - * @brief Mass of the top quark in the OS Scheme - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassTop = 172.5; -/** - * @brief Mass of the charm quark in the OS Scheme - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassCharm = 1.51; -/** - * @brief Mass of the bottom quark in the OS Scheme - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassBottom = 4.92; - -/** - * @brief Mass of the tau lepton - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassTau = 1.77682; -/** - * @brief Mass of the muon - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassMu = 0.1056583715; -/** - * @brief Mass of the electron - * Unit: GeV - * LHCHXSWG-INT-2015-006 - */ -const double C_MassElectron = 0.510998928 * std::pow(10.0, -3.0); - -/** - * @brief Fermi constant - * Unit: GeV^{-2} - * LHCHXSWG-INT-2015-006 + * @brief The ISMConstants struct containing all necessary SM constants. */ -const double C_GF = 1.1663787 * 1e-5; - -/** - * @brief sin^2(theta_Weinberg) derived from the W- and Z-Boson masses - */ -const double C_sinsquaredWeinberg = - 1 - (C_MassW * C_MassW) / (C_MassZ * C_MassZ); +struct ISMConstants +{ + /** + * @brief The lambda parameter in the Wolfenstein parametrisation of the + * CKM-Matrix LHCHXSWG-INT-2015-006 + */ + double C_Wolfenstein_lambda{0}; + + /** + * @brief The A parameter in the Wolfenstein parametrisation of the CKM-Matrix + * LHCHXSWG-INT-2015-006 + */ + double C_Wolfenstein_A{0}; + + /** + * @brief The rho parameter in the Wolfenstein parametrisation of the + * CKM-Matrix LHCHXSWG-INT-2015-006 + */ + double C_Wolfenstein_rho{0}; + /** + * @brief The eta parameter in the Wolfenstein parametrisation of the + * CKM-Matrix LHCHXSWG-INT-2015-006 + */ + double C_Wolfenstein_eta{0}; + + /** + * @brief The theta_12 mixing angle in the CKM matrix calculated by the + * Wolfenstein parameters + */ + double theta12{0}; + /** + * @brief The theta_23 mixing angle in the CKM matrix calculated by the + * Wolfenstein parameters + */ + double theta23{0}; + /** + * @brief The CP-violating angle in the CKM matrix calculated by the + * Wolfenstein parameters + */ + double delta{0}; + /** + * @brief The theta_13 mixing angle in the CKM matrix calculated by the + * Wolfenstein parameters + */ + double theta13{0}; + + /** + * @brief ud element of the CKM matrix + */ + std::complex C_Vud{0, 0}; + /** + * @brief us element of the CKM matrix + */ + std::complex C_Vus{0, 0}; + /** + * @brief ub element of the CKM matrix + */ + std::complex C_Vub{0, 0}; + + /** + * @brief cd element of the CKM matrix + */ + std::complex C_Vcd{0, 0}; + /** + * @brief cs element of the CKM matrix + */ + std::complex C_Vcs{0, 0}; + /** + * @brief cb element of the CKM matrix + */ + std::complex C_Vcb{0, 0}; + + /** + * @brief td element of the CKM matrix + */ + std::complex C_Vtd{0, 0}; + /** + * @brief ts element of the CKM matrix + */ + std::complex C_Vts{0, 0}; + /** + * @brief tb element of the CKM matrix + */ + std::complex C_Vtb{0, 0}; + + /** + * @brief Mass of the W-Boson + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassW{0}; + /** + * @brief Mass of the Z-Boson + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassZ{0}; + /** + * @brief Mass of the Higgs Boson + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassSMHiggs{0}; + + /** + * @brief Mass of the up quark + * Unit: GeV + * https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG + */ + double C_MassUp{0}; + /** + * @brief Mass of the down quark + * Unit: GeV + * https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG + */ + double C_MassDown{0}; + /** + * @brief Mass of the strange quark + * Unit: GeV + * https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG + */ + double C_MassStrange{0}; + /** + * @brief Mass of the top quark in the OS Scheme + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassTop{0}; + /** + * @brief Mass of the charm quark in the OS Scheme + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassCharm{0}; + /** + * @brief Mass of the bottom quark in the OS Scheme + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassBottom{0}; + + /** + * @brief Mass of the tau lepton + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassTau{0}; + /** + * @brief Mass of the muon + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassMu{0}; + /** + * @brief Mass of the electron + * Unit: GeV + * LHCHXSWG-INT-2015-006 + */ + double C_MassElectron{0}; + + /** + * @brief Fermi constant + * Unit: GeV^{-2} + * LHCHXSWG-INT-2015-006 + */ + double C_GF{0}; + + /** + * @brief sin^2(theta_Weinberg) derived from the W- and Z-Boson masses + */ + double C_sinsquaredWeinberg{0}; + + /** + * @brief Vacuum expectation value of the SM derived through the Fermi + * constant + */ + double C_vev0{0}; + /** + * @brief gauge coupling of the U(2)_L with the SM Higgs doublett, derived + * through the W-Boson mass and the SM VEV Unit: GeV + */ + double C_g{0}; + /** + * @brief gauge coupling of the U(1) with the SM Higgs doublett, derived + * through the W- and Z-Boson masses and the SM VEV + */ + double C_gs{0}; + + /** + * @brief Trilinear coupling between three SM Higgs Boson, calculated as the + * third derivative of the SM Higgs Potential Unit: GeV + */ + double C_SMTriHiggs{0}; + + /** + * @brief speed of sound + */ + const double Csound = 0.5773502691896258; // 1/sqrt(3) + + /** + * @brief reduced Planck mass = MPl / (8 Pi) + */ + const double MPl = 2.4e18; +}; /** - * @brief Vacuum expectation value of the SM derived through the Fermi constant - */ -const double C_vev0 = std::sqrt(1 / std::sqrt(2) * 1 / C_GF); -/** - * @brief gauge coupling of the U(2)_L with the SM Higgs doublett, derived - * through the W-Boson mass and the SM VEV Unit: GeV - */ -const double C_g = 2 * C_MassW / C_vev0; -/** - * @brief gauge coupling of the U(1) with the SM Higgs doublett, derived through - * the W- and Z-Boson masses and the SM VEV + * @brief imaginary number i */ -const double C_gs = - 2 * std::sqrt(std::pow(C_MassZ, 2) - std::pow(C_MassW, 2)) / C_vev0; +const std::complex II(0, 1); /** - * @brief Trilinear coupling between three SM Higgs Boson, calculated as the - * third derivative of the SM Higgs Potential Unit: GeV + * @brief GetSMConstants returns a set of SM contants as indicated by the + * sources described for each parameter. + * @return The SM Constants used by default in BSMPT */ -const double C_SMTriHiggs = 3 * C_MassSMHiggs * C_MassSMHiggs / (C_vev0); - +const ISMConstants GetSMConstants(); } // namespace BSMPT #endif /* SMPARAM_H_ */ diff --git a/include/BSMPT/transition_tracer/transition_tracer.h b/include/BSMPT/transition_tracer/transition_tracer.h new file mode 100644 index 00000000..8ca1690a --- /dev/null +++ b/include/BSMPT/transition_tracer/transition_tracer.h @@ -0,0 +1,194 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana +// +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +/** + * @file transition history evaluator + */ + +#include "BSMPT/bounce_solution/bounce_solution.h" // BounceSolution +#include "BSMPT/gravitational_waves/gw.h" // GravitationalWaves +#include "BSMPT/minimum_tracer/minimum_tracer.h" // MinimumTracer + +namespace BSMPT +{ + +/** + * @brief user_input struct to store user input and distribute to the classes + * @param modelPointer model pointer + * @param T_low lowest temperature, default: 0 GeV + * @param T_high highest temperature, default: 300 GeV + * @param vwall wall velocity, default: 0.95 + * @param perc_prbl false vacuum fraction at percolation temperature, default: + * 71% + * @param compl_prbl false vacuum fraction at completion temperature, default: + * 1% + * @param epsturb epsilon value of turbulence contribution, default: 0.1 + * @param maxpathintegrations maximal number of path integrations, default: 7 + * @param multistepmode choose multi-step PT modes: default (= -1), 0, 1, 2, + * auto (= 3) + * @param num_points number of equally-spaced intermediate points to check, + * default: 10 + * @param ewsr_check check of electroweak symmetry restoration, default: off (= + * 0) + * @param nlo_check check of nlo stability, default: on (= 1) + * @param use_gsl whether GSL minimizer is used + * @param use_cmaes whether CMAES minimizer is used + * @param use_nlopt whether NLopt minimizer is used + * @param which_minimizer which minimizers are used + * @param use_multithreading whether multi-threading is used + * @param gw_calculation bool to turn GW parameter calculation on/off + * @param which_transition_temp which transition temperature is chosen: 1 = + * nucl_approx, 2 = nucl, 3 = perc (default), 4 = compl + * @param number_of_initial_scan_temperatures number of temperature steps in the + * initial scan of the bounce solver + */ +struct user_input +{ + std::shared_ptr modelPointer; + double T_low = 0; + double T_high = 300; + double vwall = 0.95; + double perc_prbl = 0.71; + double compl_prbl = 0.01; + double epsturb = 0.1; + int maxpathintegrations = 7; + int multistepmode = -1; + int num_points = 10; + int ewsr_check = 0; + int nlo_check = 1; + + int which_minimizer = Minimizer::WhichMinimizerDefault; + bool use_multithreading = false; + + bool gw_calculation = false; + int which_transition_temp = 3; + size_t number_of_initial_scan_temperatures = 25; +}; + +/** + * @brief status codes struct + */ +struct status_codes +{ + StatusNLOStability status_nlo_stability = StatusNLOStability::NotSet; + StatusEWSR status_ewsr = StatusEWSR::NotSet; + StatusTracing status_tracing = StatusTracing::NotSet; + StatusCoexPair status_coex_pairs = StatusCoexPair::NotSet; + // index of vectors is coex_phase_id + std::vector status_crit; + std::vector status_bounce_sol; + std::vector status_nucl_approx; + std::vector status_nucl; + std::vector status_perc; + std::vector status_compl; +}; + +/** + * @brief transition data struct + */ +struct transition_data +{ + std::optional crit_temp; + std::optional nucl_approx_temp; + std::optional nucl_temp; + std::optional perc_temp; + std::optional compl_temp; + + std::vector crit_true_vev; + std::vector crit_false_vev; + std::vector nucl_approx_true_vev; + std::vector nucl_approx_false_vev; + std::vector nucl_true_vev; + std::vector nucl_false_vev; + std::vector perc_true_vev; + std::vector perc_false_vev; + std::vector compl_true_vev; + std::vector compl_false_vev; +}; + +/** + * @brief gravitational wave data struct + */ +struct gw_data +{ + std::optional vwall; + + std::optional alpha; + std::optional beta_over_H; + + std::optional K_sw; + std::optional K_turb; + + std::optional fpeak_sw; + std::optional fpeak_turb; + std::optional h2Omega_sw; + std::optional h2Omega_turb; + + std::optional SNR_sw; + std::optional SNR_turb; + std::optional SNR; + + StatusGW status_gw = StatusGW::NotSet; + std::optional trans_temp; +}; + +struct output +{ + std::vector legend; + status_codes status; + std::vector vec_trans_data; + std::vector vec_gw_data; + std::size_t num_coex_phase_pairs = 0; + + // stores string-identifier of phase id's throughout the transition history of + // the universe + std::string transition_history = "not_set"; +}; + +class TransitionTracer +{ +protected: + /** + * @brief modelPointer for the used parameter point + */ + std::shared_ptr modelPointer; + +private: + /** + * @brief number of VEVs of model + */ + std::size_t num_vev; + +public: + /** + * @brief vector of all found coexisting phase regions + */ + std::vector vec_coex; + + /** + * @brief TransitionTracer constructor + * @param input user input + */ + TransitionTracer(user_input &input); + ~TransitionTracer(); + + /** + * @brief Store the list of bounce solutions + * + */ + std::vector ListBounceSolution; + + /** + * @brief output data storage + */ + output output_store; +}; + +} // namespace BSMPT \ No newline at end of file diff --git a/include/BSMPT/utility/Logger.h b/include/BSMPT/utility/Logger.h index 95a93873..cdb4cfc1 100644 --- a/include/BSMPT/utility/Logger.h +++ b/include/BSMPT/utility/Logger.h @@ -18,8 +18,10 @@ namespace BSMPT { class Logger; +class parser; void ShowLoggerHelp(); +void SetLogger(const parser &argparser); void SetLogger(const std::vector &args); enum class LoggingLevel @@ -27,23 +29,39 @@ enum class LoggingLevel None, Default, MinimizerDetailed, + MinTracerDetailed, + TransitionDetailed, + GWDetailed, + BounceDetailed, ProgDetailed, EWBGDetailed, - Debug + Debug, + Complete }; +/** + * @brief The BSMPTLogger class + */ class BSMPTLogger { public: friend Logger; BSMPTLogger(std::ostream &os) : mOstream{os.rdbuf()} {} - BSMPTLogger(const BSMPTLogger &) = delete; - BSMPTLogger(BSMPTLogger &&) = delete; + BSMPTLogger(const BSMPTLogger &) = delete; + BSMPTLogger(BSMPTLogger &&) = delete; BSMPTLogger &operator=(const BSMPTLogger &) = delete; - BSMPTLogger &operator=(BSMPTLogger &&) = delete; + BSMPTLogger &operator=(BSMPTLogger &&) = delete; private: + /** + * @brief SetOStream sets the output of the logger to a certain ostream + * @param Ostream + */ void SetOStream(std::ostream &Ostream); + /** + * @brief SetOStream writes the output of the logger to a file + * @param file + */ void SetOStream(const std::string &file); template void @@ -75,16 +93,20 @@ class BSMPTLogger {LoggingLevel::EWBGDetailed, false}, {LoggingLevel::ProgDetailed, false}, {LoggingLevel::MinimizerDetailed, false}, + {LoggingLevel::MinTracerDetailed, false}, + {LoggingLevel::TransitionDetailed, false}, + {LoggingLevel::BounceDetailed, false}, + {LoggingLevel::GWDetailed, false}, {LoggingLevel::Debug, false}}; }; class Logger { public: - Logger(const Logger &) = delete; - Logger(Logger &&) = delete; + Logger(const Logger &) = delete; + Logger(Logger &&) = delete; Logger &operator=(const Logger &) = delete; - Logger &operator=(Logger &&) = delete; + Logger &operator=(Logger &&) = delete; static void SetLevel(const std::map &Setup) { @@ -112,6 +134,11 @@ class Logger Instance().Write(level, toWrite, file, line); } + static bool GetLoggingLevelStatus(LoggingLevel level) + { + return Instance().mCurrentSetup[level]; + } + static void Disable() { Instance().Disable(); } private: diff --git a/include/BSMPT/utility/NumericalDerivatives.h b/include/BSMPT/utility/NumericalDerivatives.h new file mode 100644 index 00000000..c3edf1f9 --- /dev/null +++ b/include/BSMPT/utility/NumericalDerivatives.h @@ -0,0 +1,56 @@ +#pragma once +#include +#include + +namespace BSMPT +{ +/** + * @brief Numerical method to calculate the + * gradient of a function f using finite differences method. + * + * This method is used while BSMPT is not able to + * calculate the potential derivative analytically. We used the 4th order + * method + * + * \f$\frac{\partial f}{\partial \phi_i} = \frac{1}{12 + * \epsilon}\left(-f(\dots ,\vec{\phi}_i + 2 \epsilon ) + 8 f(\dots + * ,\vec{\phi}_i + \epsilon )- 8 f(\dots ,\vec{\phi}_i - \epsilon ) + + * f(\dots ,\vec{\phi}_i - 2 \epsilon )\right)\f$ + * + * where \f$ \epsilon \f$ is a small step. + * + * @param phi Where we want to calculate the gradient + * @param f function + * @param eps Size of finite differences step + * @return std::vector The \f$ dim \times 1 \f$ gradient of V taken at + * phi + */ +std::vector +NablaNumerical(const std::vector &phi, + const std::function)> &f, + const double &eps); + +/** + * @brief Numerical method to calculate the potential's (or other functions's) + * hessian matrix using finite differences method. + * + * \f$\frac{\partial^2 V}{\partial \phi_i \phi_j} = \frac{1}{4 + * \epsilon^2}\left(V(\dots, \vec{\phi}_i + \epsilon , \vec{\phi}_j + + * \epsilon) - V(\dots, \vec{\phi}_i - \epsilon , \vec{\phi}_j + + * \epsilon) - V(\dots, \vec{\phi}_i + \epsilon , \vec{\phi}_j - + * \epsilon) + V(\dots, \vec{\phi}_i - \epsilon , \vec{\phi}_j - + * \epsilon) \right)\f$ + * + * where \f$ \epsilon \f$ is a small step. + * + * @param phi Where we want to calculate the Hessian matrix + * @param V Potential (or other function) + * @param eps Size of finite differences step + * @return std::vector> The \f$ dim \times \dim \f$ + * hessian matrix of V taken at phi + */ +std::vector> +HessianNumerical(const std::vector &phi, + const std::function)> &V, + double eps); +} // namespace BSMPT \ No newline at end of file diff --git a/include/BSMPT/utility/asciiplotter/asciiplotter.h b/include/BSMPT/utility/asciiplotter/asciiplotter.h new file mode 100644 index 00000000..6e9205f0 --- /dev/null +++ b/include/BSMPT/utility/asciiplotter/asciiplotter.h @@ -0,0 +1,69 @@ +/* +MIT License + +Copyright (c) 2017 Joe Hood + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#pragma once + +#include +#include +#include +#include +#include + +#define MAX_CURVES 10 + +using namespace std; + +class AsciiPlotter +{ +private: + static const char _default_markers[10]; + int _width; + int _height; + int _curves; + string _title; + string _xlabel; + string _ylabel; + bool _legend = false; + vector _xdata[MAX_CURVES]; + vector _ydata[MAX_CURVES]; + string _labels[MAX_CURVES]; + char _markers[MAX_CURVES]; + +public: + AsciiPlotter(); + AsciiPlotter(string title); + AsciiPlotter(string title, int width, int height); + ~AsciiPlotter(); + void plot(const char *plotfile, const char *datafile); + void addPlot(vector xdata, + vector ydata, + string label, + char marker); + void show(); + void show(std::stringstream &ss); + void xlabel(string label); + void ylabel(string label); + void legend(); + void example(); +}; diff --git a/include/BSMPT/utility/const_velocity_spline.h b/include/BSMPT/utility/const_velocity_spline.h new file mode 100644 index 00000000..2f4429f8 --- /dev/null +++ b/include/BSMPT/utility/const_velocity_spline.h @@ -0,0 +1,205 @@ +/* + * vev_spline.cpp + * + * cubic spline interpolation for path in VEV space using constant speed (in + * particular = 1) + * + * We use the lib spline.h to make a spline in each direction, the parameter is + * the linear length between the points (not important as long as it + * monotonically increasing) Then we make a thoroughly integration (Simpson 3/8 + * rule) to convert from linear length to spline length, and vice-versa. + * Interpolate using a spline + * + */ + +#pragma once + +#include // for Logger Class +#include +#include +#include +#include +#include +#include + +/** + * @brief Constructs a spline \f$ s(l) \f$ with constant velocity, i.e. \f$ + * \frac{ds(l)}{dl} \equiv 1\f$. \f$ l \f$ acts as the length alongisde the + * spline. It works by using tk::spline to construct a cubic spline which + * depends on another arbitrary parameter \f$ x \f$ and then construct an + * additional spline to convert from \f$ x \to l \equiv l(x) \f$ + * + */ +class cvspline +{ +private: + /** + * @brief List of x for linear lengths division + * + */ + std::vector list_x; + /** + * @brief // List of l for spline lengths division + * + */ + std::vector list_l; + + /** + * @brief derivative in \f$ x \f$ + * + * @param x + * @return double + */ + double lin_abs_deriv(double x); + + /** + * @brief Integrates from \f$ t_0 \f$ to \f$ t_1 \f$ using a single Simposons' + * 3/8 integration step. + * + * @param t0 lower limit + * @param t1 upper limit + * @return double value of the integral + */ + double Simpson_step(double t0, double t1); + +public: + /** + * @brief Dimension of the VEV space + * + */ + int dim; + /** + * @brief Number of points in the path (knots) + * + */ + int num_points; + /** + * @brief Number of point from x to l (and viceversa) + * + */ + int num_inter; + /** + * @brief Spline to convert from linear length to spline length + * + */ + tk::spline x_to_l; + /** + * @brief Spline to convert from spline length to linear length + * + */ + tk::spline l_to_x; + /** + * @brief Linear length of the (spline) path + * + */ + float linL; + /** + * @brief True length of the (spline) path + * + */ + float L; + /** + * @brief We need a parameter, so I used the linear lengths (not the path + * spline length) as parameter, this is not optimal as the velocity will not + * be 1. + * + */ + std::vector lin_lengths; + /** + * @brief Position of the VEV list "lin_lengths" using spline length + * + */ + std::vector vev_position; + /** + * @brief Vector of each 2D splines (x = linear length (not important, + * must be increasing), y = vev_i) + * + */ + std::vector splines; + /** + * @brief Transpose of the path given, easier for calculations + * + */ + std::vector> transposed_phi; + /** + * @brief // List of VEVs paths + * + */ + std::vector> phipath; + /** + * @brief Default constructor + * + */ + cvspline(); + /** + * @brief Construct a new cvspline object + * + * @param phipath_in knots of the path + */ + cvspline(const std::vector> &phipath_in); + /** + * @brief Construct a new cvspline object + * + * @param phipath_in knots of the path + * @param input_num_inter number of interpolations between \f$ x \f$ and \f$ l + * \f$ + */ + cvspline(const std::vector> &phipath_in, + int input_num_inter); + /** + * @brief initialize the constant velocity spline using the given path + * + */ + void initialize(); + /** + * @brief introduce a new point on the knot list + * + * @param p parameter of the point + * @param new_vev value of the knot + * @param compile initialize after point is added? + */ + void add_point(const double &p, + const std::vector &new_vev, + const bool &compile = true); + /** + * @brief derivative of the constant velocity spline in \f$ x \f$ + * + * @param order order of the derivative + * @param x where to calculate the derivative + * @return std::vector result + */ + std::vector deriv(int order, double x); + /** + * @brief first derivative of the constant velocity spline in \f$ l \f$ + * + * @param l where to calculate the derivative + * @return std::vector result + */ + std::vector dl(double l); + /** + * @brief second derivative of the constant velocity spline in \f$ l \f$ + * + * @param l where to calculate the derivative + * @return std::vector result + */ + std::vector d2l(double l); + /** + * @brief value of the constant velocity spline at \f$ l \f$ + * + * @param l + * @return std::vector + */ + std::vector operator()(double l) const; + /** + * @brief print the current knots of the spline + * + */ + void print_path() const; + /** + * @brief save the knots of the splien into a file + * + * @param file_name name of the file + * @param header print the names of the VEVs in the first column? + */ + void save_path(const std::string &file_name, const bool &header = true); +}; \ No newline at end of file diff --git a/include/BSMPT/utility/parser.h b/include/BSMPT/utility/parser.h new file mode 100644 index 00000000..8f11d1b8 --- /dev/null +++ b/include/BSMPT/utility/parser.h @@ -0,0 +1,216 @@ +// Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#ifndef PARSER_H +#define PARSER_H + +#include +#include +#include +#include +#include + +namespace BSMPT +{ + +class parserException : public std::exception +{ +public: + virtual const char *what() const noexcept; + parserException(const std::string &msg); + +private: + std::string message; +}; + +/** + * @brief The parser class provides the argument parser for the CLI and JSON + * methods. This is case insensitive. + */ +class parser +{ +public: + parser(); + parser(const bool &enable_column_output); + /** + * @brief enable_minimizer_options Enables the options regarding the + * minimizer. + */ + void enable_minimizer_options(); + /** + * @brief add_argument Silently adds a new argument for the parser options. + * @param argument The parameter name for the CLI or JSON key. This will be + * treated case insensitive. + * @param description The description for the parameter shown in help. + * @param default_val The default value for optional parameters. + */ + void add_argument_only_display(const std::string &argument, + const std::string &description, + const std::string &default_val); + /** + * @brief add_argument Silently adds a new argument for the parser options. + * @param argument The parameter name for the CLI or JSON key. This will be + * treated case insensitive. + * @param required Decide if it is a required parameter or not. + */ + void add_argument(const std::string &argument, bool required); + /** + * @brief add_argument Adds a new argument for the parser options. + * @param argument The parameter name for the CLI or JSON key. This will be + * treated case insensitive. + * @param description The description for the parameter shown in help. + * @param required Decide if it is a required parameter or not. + */ + void add_argument(const std::string &argument, + const std::string &description, + bool required); + /** + * @brief add_argument Adds a new argument for the parser options. + * @param argument The parameter name for the CLI or JSON key. This will be + * treated case insensitive. + * @param description The description for the parameter shown in help. + * @param default_val The default value for optional parameters. + * @param required Decide if it is a required parameter or not. + */ + void add_argument(const std::string &argument, + const std::string &description, + const std::string &default_val, + bool required); + /** + * @brief add_subtext add subtext to description column + * @param subtext string to print in description column + */ + void add_subtext(const std::string &subtext); + /** + * @brief add_input Add the vector with each input as it is given in the CLI + * in the form "--argument=value". + * @param input The vector containing the CLI inputs. + * @throws parserException if the argument was not expected by the parser. + */ + void add_input(const std::vector &input); + /** + * @brief print_help Prints the header and the arguments with their + * description. + */ + void print_help() const; + /** + * @brief get_value Get the value for the required parameter. + * @param argument The required CLI name or JSON key. + * @return The value if the parameter was set. + * @throws parserException if the argument was not set or if the value can not + * be casted from a string to the type. + */ + template + T get_value(const std::string &argument) const + { + auto value = get_value_as_string(argument); + if constexpr (std::is_same::value) + { + return value; + } + else if constexpr (std::is_same::value) + { + return std::stoi(value); + } + else if constexpr (std::is_same::value) + { + return std::stoul(value); + } + else if constexpr (std::is_same::value) + { + return std::stod(value); + } + else if constexpr (std::is_same::value) + { + auto lower = to_lower(value); + return lower == "true"; + } + else + { + return static_cast(value); + } + } + + /** + * @brief all_required_set Check ifs all required parameter are set. + * @return true/false if all required parameters are set. + */ + bool all_required_set() const; + /** + * @brief check_required_parameters Calls all_required_set() and throws a + * parserException if not all required parameters are set. + * @throws parserException if not all required parameter are set. + */ + void check_required_parameters() const; + /** + * @brief set_help_header Sets the header which is printed in print_help() + * @param header The header to print. + */ + void set_help_header(const std::string &header); + +private: + struct Options + { + std::string argument; + std::string description; + std::optional value; + std::string default_val = ""; + }; + struct KeyValue + { + std::string key; + std::string value; + KeyValue() = default; + KeyValue(const std::string &Key, const std::string &Value) + : key{Key} + , value{Value} + { + } + }; + + std::vector> mOrderedArguments; + std::unordered_map mRequiredArguments; + std::unordered_map mOptionalArguments; + + bool extra_column_output = false; + + /** + * @brief get_value Get the value for the required parameter. + * @param argument The required CLI name or JSON key. + * @return The value if the parameter was set. + * @throws parserException if the argument was not set or if the value can not + * be casted from a string to the type. + */ + std::string get_value_as_string(const std::string &argument) const; + /** + * @brief add_json_input Add the input parameters with a json file. + * @param filename The file containing the json. + */ + void add_json_input(const std::string &filename); + /** + * @brief add_input Set the key value pairs. + * @param input The vector containing all key value pairs. + */ + void add_input(const std::vector &input); + /** + * @brief get_key_value Converts the CLI input in the form "--argName=value" + * into a key value pair. + * @param input The CLI option in the form of "--argName=foo". + * @return Returns the matching KeyValue. + */ + + std::string to_lower(const std::string &input) const; + + KeyValue get_key_value(const std::string &input); + std::string mHeader; + + /** + * @brief Helper to avoid multiple prints of the help output + */ + mutable bool mHelpAlreadyPrinted{false}; +}; +} // namespace BSMPT +#endif // PARSER_H diff --git a/include/BSMPT/utility/spline/spline.h b/include/BSMPT/utility/spline/spline.h new file mode 100644 index 00000000..3062747a --- /dev/null +++ b/include/BSMPT/utility/spline/spline.h @@ -0,0 +1,196 @@ +/* + * spline.h + * + * simple cubic spline interpolation library without external + * dependencies + * + * --------------------------------------------------------------------- + * Copyright (C) 2011, 2014, 2016, 2021 Tino Kluge (ttk448 at gmail.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * --------------------------------------------------------------------- + * + */ + +#ifndef TK_SPLINE_H +#define TK_SPLINE_H + +#include +#include +#include +#include +#include + +namespace tk +{ + +// spline interpolation +class spline +{ +public: + // spline types + enum spline_type + { + linear = 10, // linear interpolation + cspline = 30, // cubic splines (classical C^2) + cspline_hermite = 31 // cubic hermite splines (local, only C^1) + }; + + // boundary condition type for the spline end-points + enum bd_type + { + first_deriv = 1, + second_deriv = 2, + not_a_knot = 3 + }; + +protected: + std::vector m_x, m_y; // x,y coordinates of points + // interpolation parameters + // f(x) = a_i + b_i*(x-x_i) + c_i*(x-x_i)^2 + d_i*(x-x_i)^3 + // where a_i = y_i, or else it won't go through grid points + std::vector m_b, m_c, m_d; // spline coefficients + double m_c0; // for left extrapolation + spline_type m_type; + bd_type m_left, m_right; + double m_left_value, m_right_value; + bool m_made_monotonic; + void set_coeffs_from_b(); // calculate c_i, d_i from b_i + size_t find_closest(double x) const; // closest idx so that m_x[idx]<=x + +public: + // default constructor: set boundary condition to be zero curvature + // at both ends, i.e. natural splines + spline() + : m_type(cspline) + , m_left(second_deriv) + , m_right(second_deriv) + , m_left_value(0.0) + , m_right_value(0.0) + , m_made_monotonic(false) + { + ; + } + spline(const std::vector &X, + const std::vector &Y, + spline_type type = cspline, + bool make_monotonic = false, + bd_type left = second_deriv, + double left_value = 0.0, + bd_type right = second_deriv, + double right_value = 0.0) + : m_type(type) + , m_left(left) + , m_right(right) + , m_left_value(left_value) + , m_right_value(right_value) + , m_made_monotonic(false) // false correct here: make_monotonic() sets it + { + this->set_points(X, Y, m_type); + if (make_monotonic) + { + this->make_monotonic(); + } + } + + // modify boundary conditions: if called it must be before set_points() + void set_boundary(bd_type left, + double left_value, + bd_type right, + double right_value); + + // set all data points (cubic_spline=false means linear interpolation) + void set_points(const std::vector &x, + const std::vector &y, + spline_type type = cspline); + + // adjust coefficients so that the spline becomes piecewise monotonic + // where possible + // this is done by adjusting slopes at grid points by a non-negative + // factor and this will break C^2 + // this can also break boundary conditions if adjustments need to + // be made at the boundary points + // returns false if no adjustments have been made, true otherwise + bool make_monotonic(); + + // evaluates the spline at point x + double operator()(double x) const; + double deriv(int order, double x) const; + + // solves for all x so that: spline(x) = y + std::vector solve(double y, bool ignore_extrapolation = true) const; + + // returns the input data points + std::vector get_x() const { return m_x; } + std::vector get_y() const { return m_y; } + double get_x_min() const + { + assert(!m_x.empty()); + return m_x.front(); + } + double get_x_max() const + { + assert(!m_x.empty()); + return m_x.back(); + } +}; + +namespace internal +{ + +// band matrix solver +class band_matrix +{ +private: + std::vector> m_upper; // upper band + std::vector> m_lower; // lower band +public: + band_matrix(){}; // constructor + band_matrix(int dim, int n_u, int n_l); // constructor + ~band_matrix(){}; // destructor + void resize(int dim, int n_u, int n_l); // init with dim,n_u,n_l + int dim() const; // matrix dimension + int num_upper() const { return (int)m_upper.size() - 1; } + int num_lower() const { return (int)m_lower.size() - 1; } + // access operator + double &operator()(int i, int j); // write + double operator()(int i, int j) const; // read + // we can store an additional diagonal (in m_lower) + double &saved_diag(int i); + double saved_diag(int i) const; + void lu_decompose(); + std::vector r_solve(const std::vector &b) const; + std::vector l_solve(const std::vector &b) const; + std::vector lu_solve(const std::vector &b, + bool is_lu_decomposed = false); +}; + +double get_eps(); + +// solutions for a + b*x = 0 +std::vector solve_linear(double a, double b); + +// solutions for a + b*x + c*x^2 = 0 +std::vector +solve_quadratic(double a, double b, double c, int newton_iter = 0); + +// solutions for the cubic equation: a + b*x +c*x^2 + d*x^3 = 0= +std::vector +solve_cubic(double a, double b, double c, double d, int newton_iter = 0); + +} // namespace internal + +} // namespace tk + +#endif /* TK_SPLINE_H */ \ No newline at end of file diff --git a/include/BSMPT/utility/utility.h b/include/BSMPT/utility/utility.h index 95e2affa..8d06ce5b 100644 --- a/include/BSMPT/utility/utility.h +++ b/include/BSMPT/utility/utility.h @@ -7,7 +7,11 @@ #pragma once #include +#include +#include +#include #include +#include #include #include #include @@ -32,13 +36,62 @@ namespace BSMPT */ bool StringStartsWith(const std::string &str, const std::string &prefix); +/** + * @brief StringEndsWith tests if str ends with suffix + * @param str + * @param suffix + * @return + */ +bool StringEndsWith(const std::string &str, const std::string &suffix); + /** * @brief seperator used to write into output files */ const std::string sep = "\t"; /** - * Overload to print out vectors with the << operator + * @brief factorial function + */ +int factorial(const int &a); + +/** + * @brief push back vector into vector + */ +template +std::vector push_back(std::vector &a, const std::vector &b) +{ + return a.insert(a.end(), b.begin(), b.end()); +} + +/** + * @brief vector to_string + */ +template std::string vec_to_string(const std::vector &vec) +{ + std::string res; + bool first = true; + for (const auto &el : vec) + { + if (not first) + { + res += sep + std::to_string(el); + } + else + { + res = std::to_string(el); + first = false; + } + } + return res; +} + +/** + * @brief split string separated by delimiter into substrings + */ +std::vector split(const std::string &str, char delimiter); + +/** + * @brief Overload to print out vectors with the << operator */ template std::ostream &operator<<(std::ostream &os, const std::vector &vec) @@ -59,6 +112,178 @@ std::ostream &operator<<(std::ostream &os, const std::vector &vec) return os; } +/** + * @brief vector addition + */ +template +std::vector operator+(const std::vector &a, const std::vector &b) +{ + if (a.size() != b.size()) + throw std::runtime_error( + "Vector cannot be added. Must have the same size."); + std::vector result; + result.reserve(a.size()); + + std::transform(a.begin(), + a.end(), + b.begin(), + std::back_inserter(result), + std::plus()); + return result; +} + +/** + * @brief vector subtraction + */ +template +std::vector operator-(const std::vector &a, const std::vector &b) +{ + if (a.size() != b.size()) + throw("Vector cannot be subtracted. Must have the same size."); + + std::vector result; + result.reserve(a.size()); + + std::transform(a.begin(), + a.end(), + b.begin(), + std::back_inserter(result), + std::minus()); + return result; +} + +/** + * @brief multiplication of vector with scalar + */ +template +std::vector operator*(const T2 &a, const std::vector &b) +{ + std::vector result; + result.reserve(b.size()); + + std::transform(b.begin(), + b.end(), + std::back_inserter(result), + [&a](T i) { return a * i; }); + return result; +} + +/** + * @brief division of vector by scalar + */ +template +std::vector operator/(const std::vector &a, const T2 &b) +{ + std::vector result; + result.reserve(a.size()); + + std::transform(a.begin(), + a.end(), + std::back_inserter(result), + [&b](T i) { return i / b; }); + return result; +} + +/** + * @brief dot product of two vectors + */ +template +T operator*(const std::vector &a, const std::vector &b) +{ + if (a.size() != b.size()) + throw( + "Dot product between vectors cannot be done. Must have the same size."); + + std::vector result; + result.reserve(a.size()); + + std::transform(a.begin(), + a.end(), + b.begin(), + std::back_inserter(result), + [](T i, T j) { return (i * j); }); + + T result1 = std::accumulate(result.begin(), result.end(), 0.0); + + return result1; +} + +/** + * @brief multiplication of matrix with vector + */ +template +std::vector operator*(const std::vector> &a, + const std::vector &b) +{ + if (a.size() != b.size()) + throw("Multiplication of matrix with vector cannot be done. Must have the " + "same size."); + + std::vector result; + result.reserve(a.size()); + + std::transform(a.begin(), + a.end(), + std::back_inserter(result), + [&](std::vector i) { return (i * b); }); + + return result; +} + +/** + * @brief flatten matrix + */ +template +std::vector flatten(std::vector> const &vec) +{ + std::vector flattened; + for (auto const &v : vec) + { + flattened.insert(flattened.end(), v.begin(), v.end()); + } + return flattened; +} + +/** + * @brief L2NormVector + * @param vec vector + * @return L2 norm of vector + */ +double L2NormVector(const std::vector &vec); + +/** + * @brief Calculates the tranpose of a matrix + * @param A matrix to be transposed + * @return std::vector> transposed matrix + */ +std::vector> +Transpose(const std::vector> &A); + +/** + * @brief Dilogarithm of x + * + * https://en.wikipedia.org/wiki/Dilogarithm + * + * @param x real argument of from \f$ (-\infty, 1)\f$ + * @return double + */ +double Li2(const double &x); + +/** + * @brief Incomplete elliptic integral of the second kind of x with a different + * parameterization and k^2 = -2 + * + * \f$ \text{EllipIntSecond}(x) = -i E(i \phi, 2) = \int_0^\phi + * \sqrt{1+2\sinh^2{\theta}}\,d\theta \f$ + * + * https://en.wikipedia.org/wiki; - double CalculateNorm1(const double &T) { return -std::pow(M_PI, 3) * std::pow(T, 2) * 2.0 / 3.0; diff --git a/src/ThermalFunctions/CMakeLists.txt b/src/ThermalFunctions/CMakeLists.txt index f1bd6779..20022f62 100644 --- a/src/ThermalFunctions/CMakeLists.txt +++ b/src/ThermalFunctions/CMakeLists.txt @@ -1,21 +1,17 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/ThermalFunctions") set(header - ${header_path}/ThermalFunctions.h - ${header_path}/NegativeBosonSpline.h - ${header_path}/thermalcoefficientcalculator.h -) -set(src - ThermalFunctions.cpp - thermalcoefficientcalculator.cpp -) + ${header_path}/ThermalFunctions.h ${header_path}/NegativeBosonSpline.h + ${header_path}/thermalcoefficientcalculator.h) +set(src thermalcoefficientcalculator.cpp ThermalFunctions.cpp + NegativeBosonSpline.cpp) add_library(ThermalFunctions ${header} ${src}) -target_link_libraries(ThermalFunctions PUBLIC GSL::gsl) +target_link_libraries(ThermalFunctions PUBLIC GSL::gsl Utility) target_include_directories(ThermalFunctions PUBLIC ${BSMPT_SOURCE_DIR}/include) -target_compile_features(ThermalFunctions PUBLIC cxx_std_14) - +target_compile_features(ThermalFunctions PUBLIC cxx_std_17) diff --git a/src/ThermalFunctions/NegativeBosonSpline.cpp b/src/ThermalFunctions/NegativeBosonSpline.cpp new file mode 100644 index 00000000..6d867756 --- /dev/null +++ b/src/ThermalFunctions/NegativeBosonSpline.cpp @@ -0,0 +1,1017 @@ +// Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file + */ + +#include +#include + +const int C_NegLine = 3001; + +const double NegLinearInt[3001][2] = { + {-0, -2.164646465}, {-1, -2.818445251}, {-2, -3.222851734}, + {-3, -3.428922383}, {-4, -3.46485227}, {-5, -3.351032801}, + {-6, -3.103759168}, {-7, -2.736807005}, {-8, -2.262259033}, + {-9, -1.690996032}, {-10, -1.03301549}, {-11, -0.2976508055}, + {-12, 0.5062681395}, {-13, 1.370293416}, {-14, 2.286262618}, + {-15, 3.246217947}, {-16, 4.242340858}, {-17, 5.266889167}, + {-18, 6.312140833}, {-19, 7.370343407}, {-20, 8.433656113}, + {-21, 9.494099961}, {-22, 10.54349464}, {-23, 11.57339606}, + {-24, 12.57502367}, {-25, 13.53917411}, {-26, 14.4561211}, + {-27, 15.31549117}, {-28, 16.10611023}, {-29, 16.81580557}, + {-30, 17.43114564}, {-31, 17.93709101}, {-32, 18.3165027}, + {-33, 18.5494288}, {-34, 18.6120242}, {-35, 18.47477715}, + {-36, 18.09940905}, {-37, 17.43269548}, {-38, 16.39161386}, + {-39, 14.81074106}, {-40, 12.16616547}, {-41, 9.29873028}, + {-42, 6.552973907}, {-43, 3.92693942}, {-44, 1.418700787}, + {-45, -0.9736390888}, {-46, -3.25194955}, {-47, -5.418073643}, + {-48, -7.473830411}, {-49, -9.42101465}, {-50, -11.26140026}, + {-51, -12.99673894}, {-52, -14.62876466}, {-53, -16.15919077}, + {-54, -17.58971417}, {-55, -18.92201431}, {-56, -20.15775866}, + {-57, -21.2985937}, {-58, -22.34615666}, {-59, -23.30207115}, + {-60, -24.16794711}, {-61, -24.9453849}, {-62, -25.63597245}, + {-63, -26.24129017}, {-64, -26.7629061}, {-65, -27.20238238}, + {-66, -27.5612719}, {-67, -27.84112113}, {-68, -28.04346941}, + {-69, -28.16989666}, {-70, -28.22179307}, {-71, -28.20082067}, + {-72, -28.1084539}, {-73, -27.94620547}, {-74, -27.71559252}, + {-75, -27.4181245}, {-76, -27.05531078}, {-77, -26.6286592}, + {-78, -26.13967889}, {-79, -25.58987345}, {-80, -24.98075542}, + {-81, -24.31383211}, {-82, -23.59061264}, {-83, -22.812622}, + {-84, -21.98136023}, {-85, -21.09835882}, {-86, -20.1651382}, + {-87, -19.18322992}, {-88, -18.15416871}, {-89, -17.0794957}, + {-90, -15.96076011}, {-91, -14.79951789}, {-92, -13.59733502}, + {-93, -12.35577969}, {-94, -11.07644226}, {-95, -9.760914889}, + {-96, -8.410803442}, {-97, -7.027727211}, {-98, -5.613318217}, + {-99, -4.169222819}, {-100, -2.6971031}, {-101, -1.198637426}, + {-102, 0.3244783383}, {-103, 1.87052959}, {-104, 3.437781698}, + {-105, 5.024479158}, {-106, 6.628843696}, {-107, 8.249072607}, + {-108, 9.883338728}, {-109, 11.52978642}, {-110, 13.18653279}, + {-111, 14.85166411}, {-112, 16.52322793}, {-113, 18.19924795}, + {-114, 19.87770308}, {-115, 21.55654538}, {-116, 23.23364258}, + {-117, 24.9068802}, {-118, 26.57405565}, {-119, 28.23292158}, + {-120, 29.88117974}, {-121, 31.51647083}, {-122, 33.13637388}, + {-123, 34.73839708}, {-124, 36.31997987}, {-125, 37.87848087}, + {-126, 39.41117353}, {-127, 40.91524037}, {-128, 42.38776345}, + {-129, 43.82571787}, {-130, 45.22596257}, {-131, 46.5852188}, + {-132, 47.90008464}, {-133, 49.16698761}, {-134, 50.38219239}, + {-135, 51.54177463}, {-136, 52.64160307}, {-137, 53.67730717}, + {-138, 54.64426543}, {-139, 55.53755859}, {-140, 56.35193276}, + {-141, 57.08175867}, {-142, 57.72097689}, {-143, 58.26301396}, + {-144, 58.70074843}, {-145, 59.02631403}, {-146, 59.2310679}, + {-147, 59.30536241}, {-148, 59.23834431}, {-149, 59.01761897}, + {-150, 58.62890624}, {-151, 58.0553658}, {-152, 57.27674355}, + {-153, 56.26795292}, {-154, 54.99667402}, {-155, 53.41886624}, + {-156, 51.4689278}, {-157, 49.03154963}, {-158, 45.74131965}, + {-159, 41.62616097}, {-160, 37.60001753}, {-161, 33.66226904}, + {-162, 29.81229849}, {-163, 26.04948949}, {-164, 22.37322596}, + {-165, 18.78289423}, {-166, 15.2778806}, {-167, 11.85757254}, + {-168, 8.521358646}, {-169, 5.268628677}, {-170, 2.098771025}, + {-171, -0.9888217056}, {-172, -3.994758482}, {-173, -6.919647137}, + {-174, -9.764094799}, {-175, -12.52870753}, {-176, -15.21409204}, + {-177, -17.8208529}, {-178, -20.34959584}, {-179, -22.80092429}, + {-180, -25.17544509}, {-181, -27.47375948}, {-182, -29.69647001}, + {-183, -31.84418444}, {-184, -33.91750228}, {-185, -35.91702705}, + {-186, -37.84336232}, {-187, -39.69710967}, {-188, -41.4788742}, + {-189, -43.18925487}, {-190, -44.82885751}, {-191, -46.39828413}, + {-192, -47.89813907}, {-193, -49.32902096}, {-194, -50.69153769}, + {-195, -51.98629208}, {-196, -53.21388814}, {-197, -54.37493393}, + {-198, -55.47001943}, {-199, -56.49976731}, {-200, -57.46477608}, + {-201, -58.36565331}, {-202, -59.20300416}, {-203, -59.97743774}, + {-204, -60.68956245}, {-205, -61.33998741}, {-206, -61.92932148}, + {-207, -62.45817595}, {-208, -62.92716413}, {-209, -63.33689482}, + {-210, -63.68798276}, {-211, -63.98104441}, {-212, -64.21669495}, + {-213, -64.39555103}, {-214, -64.51822951}, {-215, -64.58535298}, + {-216, -64.59753934}, {-217, -64.5554102}, {-218, -64.45959239}, + {-219, -64.31071468}, {-220, -64.1093833}, {-221, -63.85627508}, + {-222, -63.55194348}, {-223, -63.1970829}, {-224, -62.7923069}, + {-225, -62.33825326}, {-226, -61.83555593}, {-227, -61.28486033}, + {-228, -60.68681572}, {-229, -60.04202895}, {-230, -59.351185}, + {-231, -58.61491945}, {-232, -57.83387908}, {-233, -57.00872637}, + {-234, -56.1401122}, {-235, -55.22869589}, {-236, -54.27513512}, + {-237, -53.28010662}, {-238, -52.24425275}, {-239, -51.16826426}, + {-240, -50.05280898}, {-241, -48.898567}, {-242, -47.7062091}, + {-243, -46.47642733}, {-244, -45.20990438}, {-245, -43.90733204}, + {-246, -42.56939876}, {-247, -41.19680664}, {-248, -39.79025838}, + {-249, -38.35045814}, {-250, -36.87811613}, {-251, -35.37394688}, + {-252, -33.83866427}, {-253, -32.27300534}, {-254, -30.6776846}, + {-255, -29.0534395}, {-256, -27.40100765}, {-257, -25.72113079}, + {-258, -24.0145619}, {-259, -22.28205072}, {-260, -20.52435702}, + {-261, -18.74224739}, {-262, -16.93649271}, {-263, -15.10787022}, + {-264, -13.257165}, {-265, -11.38516615}, {-266, -9.492672108}, + {-267, -7.580486533}, {-268, -5.649421074}, {-269, -3.700294873}, + {-270, -1.733934573}, {-271, 0.2488251854}, {-272, 2.247141615}, + {-273, 4.26016393}, {-274, 6.287029442}, {-275, 8.326871819}, + {-276, 10.37881165}, {-277, 12.44196055}, {-278, 14.51542024}, + {-279, 16.59827995}, {-280, 18.68962724}, {-281, 20.78853171}, + {-282, 22.89403273}, {-283, 25.00519758}, {-284, 27.12105303}, + {-285, 29.24061844}, {-286, 31.36290686}, {-287, 33.48690659}, + {-288, 35.61160032}, {-289, 37.73594961}, {-290, 39.85890681}, + {-291, 41.97940466}, {-292, 44.09635948}, {-293, 46.20867043}, + {-294, 48.3152183}, {-295, 50.41486595}, {-296, 52.50645607}, + {-297, 54.58881045}, {-298, 56.66072952}, {-299, 58.72099241}, + {-300, 60.76835132}, {-301, 62.80154239}, {-302, 64.81926703}, + {-303, 66.82020342}, {-304, 68.80300087}, {-305, 70.76628208}, + {-306, 72.70863559}, {-307, 74.62861802}, {-308, 76.52475273}, + {-309, 78.3955293}, {-310, 80.23938945}, {-311, 82.05474806}, + {-312, 83.83997123}, {-313, 85.5933769}, {-314, 87.3132406}, + {-315, 88.99778645}, {-316, 90.64534213}, {-317, 92.25354556}, + {-318, 93.82092148}, {-319, 95.34530355}, {-320, 96.82460761}, + {-321, 98.25668011}, {-322, 99.63928571}, {-323, 100.9700982}, + {-324, 102.2467108}, {-325, 103.4666138}, {-326, 104.6271835}, + {-327, 105.7256861}, {-328, 106.7592593}, {-329, 107.7249074}, + {-330, 108.6194617}, {-331, 109.4396211}, {-332, 110.1818781}, + {-333, 110.8425301}, {-334, 111.4176566}, {-335, 111.9030464}, + {-336, 112.2942704}, {-337, 112.5865307}, {-338, 112.7746988}, + {-339, 112.8532075}, {-340, 112.8160325}, {-341, 112.6566117}, + {-342, 112.3676606}, {-343, 111.941254}, {-344, 111.3684424}, + {-345, 110.6391971}, {-346, 109.742102}, {-347, 108.6639828}, + {-348, 107.3894029}, {-349, 105.899891}, {-350, 104.1727853}, + {-351, 102.1792932}, {-352, 99.88103654}, {-353, 97.22297728}, + {-354, 94.11563604}, {-355, 90.36386136}, {-356, 85.47741876}, + {-357, 80.48735678}, {-358, 75.57040959}, {-359, 70.72625364}, + {-360, 65.95456698}, {-361, 61.25504332}, {-362, 56.62734703}, + {-363, 52.07116171}, {-364, 47.58616915}, {-365, 43.17204856}, + {-366, 38.82848554}, {-367, 34.55514173}, {-368, 30.35171395}, + {-369, 26.21787572}, {-370, 22.1533058}, {-371, 18.15768323}, + {-372, 14.23068726}, {-373, 10.3719955}, {-374, 6.581286496}, + {-375, 2.858238737}, {-376, -0.7974700683}, {-377, -4.386162258}, + {-378, -7.908159706}, {-379, -11.36378471}, {-380, -14.75336302}, + {-381, -18.07721479}, {-382, -21.33566515}, {-383, -24.52903606}, + {-384, -27.65765178}, {-385, -30.72183874}, {-386, -33.72191926}, + {-387, -36.65821805}, {-388, -39.53106185}, {-389, -42.34077452}, + {-390, -45.08768278}, {-391, -47.77211105}, {-392, -50.39438818}, + {-393, -52.95483855}, {-394, -55.45379058}, {-395, -57.89157119}, + {-396, -60.26765199}, {-397, -62.58492887}, {-398, -64.84116398}, + {-399, -67.03754064}, {-400, -69.17438956}, {-401, -71.25203951}, + {-402, -73.27082244}, {-403, -75.23106426}, {-404, -77.13310394}, + {-405, -78.97726612}, {-406, -80.76388468}, {-407, -82.49329352}, + {-408, -84.16582446}, {-409, -85.78181453}, {-410, -87.34159197}, + {-411, -88.84549657}, {-412, -90.29385613}, {-413, -91.68701673}, + {-414, -93.02531129}, {-415, -94.30906853}, {-416, -95.53868142}, + {-417, -96.71434184}, {-418, -97.8365373}, {-419, -98.90555203}, + {-420, -99.92172895}, {-421, -100.8854059}, {-422, -101.796931}, + {-423, -102.6566422}, {-424, -103.4648752}, {-425, -104.2219825}, + {-426, -104.9283048}, {-427, -105.5841881}, {-428, -106.1899418}, + {-429, -106.7459687}, {-430, -107.2526463}, {-431, -107.7102377}, + {-432, -108.1191074}, {-433, -108.4796273}, {-434, -108.7921358}, + {-435, -109.0569967}, {-436, -109.2745546}, {-437, -109.4451574}, + {-438, -109.5691641}, {-439, -109.6469286}, {-440, -109.6788053}, + {-441, -109.6651497}, {-442, -109.6063213}, {-443, -109.5026803}, + {-444, -109.3545778}, {-445, -109.1623807}, {-446, -108.9264507}, + {-447, -108.6471437}, {-448, -108.3248336}, {-449, -107.9598773}, + {-450, -107.55264}, {-451, -107.1034909}, {-452, -106.6128004}, + {-453, -106.0809281}, {-454, -105.508239}, {-455, -104.8951326}, + {-456, -104.2419729}, {-457, -103.549115}, {-458, -102.8169437}, + {-459, -102.0458362}, {-460, -101.236169}, {-461, -100.3883224}, + {-462, -99.50267596}, {-463, -98.57961179}, {-464, -97.61951334}, + {-465, -96.62276523}, {-466, -95.58975369}, {-467, -94.52086526}, + {-468, -93.41648822}, {-469, -92.27701535}, {-470, -91.10283866}, + {-471, -89.89435118}, {-472, -88.65194415}, {-473, -87.37602319}, + {-474, -86.0669806}, {-475, -84.72521753}, {-476, -83.35113758}, + {-477, -81.94512955}, {-478, -80.50764168}, {-479, -79.03903968}, + {-480, -77.53974585}, {-481, -76.01017362}, {-482, -74.45073634}, + {-483, -72.86184691}, {-484, -71.24392366}, {-485, -69.59738667}, + {-486, -67.92265761}, {-487, -66.22015714}, {-488, -64.49031423}, + {-489, -62.73355567}, {-490, -60.95031191}, {-491, -59.14101082}, + {-492, -57.30610122}, {-493, -55.44600607}, {-494, -53.56117126}, + {-495, -51.6520359}, {-496, -49.71904761}, {-497, -47.76264925}, + {-498, -45.78329084}, {-499, -43.78144253}, {-500, -41.75754567}, + {-501, -39.71205121}, {-502, -37.64542848}, {-503, -35.55814339}, + {-504, -33.45065782}, {-505, -31.32344348}, {-506, -29.17697623}, + {-507, -27.01173066}, {-508, -24.82818564}, {-509, -22.62682504}, + {-510, -20.40813455}, {-511, -18.17260264}, {-512, -15.92072743}, + {-513, -13.65300059}, {-514, -11.36992453}, {-515, -9.072003103}, + {-516, -6.759744925}, {-517, -4.433661503}, {-518, -2.094269927}, + {-519, 0.2579106075}, {-520, 2.622355361}, {-521, 4.998535467}, + {-522, 7.385918103}, {-523, 9.783965912}, {-524, 12.19213543}, + {-525, 14.60988118}, {-526, 17.03665028}, {-527, 19.47188671}, + {-528, 21.91502796}, {-529, 24.36550783}, {-530, 26.82275312}, + {-531, 29.28618665}, {-532, 31.75522419}, {-533, 34.22927696}, + {-534, 36.70774991}, {-535, 39.19004315}, {-536, 41.6755473}, + {-537, 44.16369492}, {-538, 46.65372975}, {-539, 49.14515663}, + {-540, 51.63730833}, {-541, 54.12953323}, {-542, 56.62118465}, + {-543, 59.11160617}, {-544, 61.60013897}, {-545, 64.08610865}, + {-546, 66.56883634}, {-547, 69.04763149}, {-548, 71.52179836}, + {-549, 73.990633}, {-550, 76.45340531}, {-551, 78.90944296}, + {-552, 81.3579494}, {-553, 83.79821789}, {-554, 86.22947574}, + {-555, 88.65096563}, {-556, 91.06190888}, {-557, 93.46152193}, + {-558, 95.8490015}, {-559, 98.22354329}, {-560, 100.5843038}, + {-561, 102.9304637}, {-562, 105.2611678}, {-563, 107.5755478}, + {-564, 109.8727307}, {-565, 112.1518916}, {-566, 114.4118903}, + {-567, 116.6520352}, {-568, 118.871304}, {-569, 121.0687322}, + {-570, 123.2433433}, {-571, 125.3941369}, {-572, 127.5201043}, + {-573, 129.6201948}, {-574, 131.6933617}, {-575, 133.7384991}, + {-576, 135.7545229}, {-577, 137.7402916}, {-578, 139.6946626}, + {-579, 141.6164409}, {-580, 143.5044193}, {-581, 145.3573626}, + {-582, 147.1739878}, {-583, 148.953004}, {-584, 150.6930752}, + {-585, 152.3928165}, {-586, 154.0508404}, {-587, 155.6656613}, + {-588, 157.2358277}, {-589, 158.759763}, {-590, 160.2359156}, + {-591, 161.6626392}, {-592, 163.0382577}, {-593, 164.3610258}, + {-594, 165.6291329}, {-595, 166.8407206}, {-596, 167.9938579}, + {-597, 169.0865474}, {-598, 170.1167062}, {-599, 171.0821453}, + {-600, 171.9806158}, {-601, 172.8097578}, {-602, 173.5671934}, + {-603, 174.2502585}, {-604, 174.8562788}, {-605, 175.3824448}, + {-606, 175.8257666}, {-607, 176.1831092}, {-608, 176.4511691}, + {-609, 176.6264267}, {-610, 176.7051677}, {-611, 176.683375}, + {-612, 176.5569003}, {-613, 176.3211269}, {-614, 175.9711899}, + {-615, 175.5018004}, {-616, 174.9072308}, {-617, 174.1812105}, + {-618, 173.3168793}, {-619, 172.3066038}, {-620, 171.1420583}, + {-621, 169.813606}, {-622, 168.3105246}, {-623, 166.6204181}, + {-624, 164.7288269}, {-625, 162.6185667}, {-626, 160.2687256}, + {-627, 157.6530621}, {-628, 154.7372046}, {-629, 151.4732557}, + {-630, 147.7873085}, {-631, 143.5393762}, {-632, 138.2360408}, + {-633, 132.441885}, {-634, 126.7114289}, {-635, 121.0444717}, + {-636, 115.4408115}, {-637, 109.9002462}, {-638, 104.4225777}, + {-639, 99.00759058}, {-640, 93.65509865}, {-641, 88.36488441}, + {-642, 83.1367588}, {-643, 77.97050915}, {-644, 72.86593439}, + {-645, 67.82283565}, {-646, 62.84100438}, {-647, 57.92023578}, + {-648, 53.06033077}, {-649, 48.26108296}, {-650, 43.5222796}, + {-651, 38.8437392}, {-652, 34.22523699}, {-653, 29.66657102}, + {-654, 25.16754033}, {-655, 20.72793868}, {-656, 16.3475599}, + {-657, 12.02619906}, {-658, 7.763650659}, {-659, 3.559706711}, + {-660, -0.5858369661}, {-661, -4.673187266}, {-662, -8.702551622}, + {-663, -12.67413585}, {-664, -16.58814766}, {-665, -20.44479467}, + {-666, -24.2442843}, {-667, -27.98682429}, {-668, -31.6726214}, + {-669, -35.3018861}, {-670, -38.8748253}, {-671, -42.39164845}, + {-672, -45.8525651}, {-673, -49.25778122}, {-674, -52.607515}, + {-675, -55.90196413}, {-676, -59.14134737}, {-677, -62.32587076}, + {-678, -65.45574748}, {-679, -68.53118615}, {-680, -71.55240405}, + {-681, -74.51960166}, {-682, -77.43299141}, {-683, -80.29280457}, + {-684, -83.09922926}, {-685, -85.85248932}, {-686, -88.55279751}, + {-687, -91.2003627}, {-688, -93.79540693}, {-689, -96.338133}, + {-690, -98.82875998}, {-691, -101.2675031}, {-692, -103.6545818}, + {-693, -105.9901948}, {-694, -108.2745737}, {-695, -110.5079253}, + {-696, -112.6904724}, {-697, -114.8224226}, {-698, -116.904006}, + {-699, -118.9354227}, {-700, -120.9169049}, {-701, -122.8486601}, + {-702, -124.7309094}, {-703, -126.5638725}, {-704, -128.3477664}, + {-705, -130.0827969}, {-706, -131.7692313}, {-707, -133.4072368}, + {-708, -134.9970533}, {-709, -136.5388804}, {-710, -138.0330027}, + {-711, -139.4795765}, {-712, -140.8788462}, {-713, -142.2310333}, + {-714, -143.5363531}, {-715, -144.795054}, {-716, -146.0073585}, + {-717, -147.1734232}, {-718, -148.2935481}, {-719, -149.3679333}, + {-720, -150.3968089}, {-721, -151.3803812}, {-722, -152.3189025}, + {-723, -153.2125849}, {-724, -154.0616596}, {-725, -154.8663502}, + {-726, -155.6268844}, {-727, -156.343496}, {-728, -157.0164138}, + {-729, -157.6458578}, {-730, -158.2320695}, {-731, -158.7752809}, + {-732, -159.2757013}, {-733, -159.7335856}, {-734, -160.1491574}, + {-735, -160.5225928}, {-736, -160.8542925}, {-737, -161.1443172}, + {-738, -161.392977}, {-739, -161.6004808}, {-740, -161.767081}, + {-741, -161.8930099}, {-742, -161.9784945}, {-743, -162.0238088}, + {-744, -162.0291096}, {-745, -161.9947094}, {-746, -161.9208223}, + {-747, -161.8076858}, {-748, -161.655544}, {-749, -161.4646406}, + {-750, -161.2352}, {-751, -160.9674922}, {-752, -160.661736}, + {-753, -160.318182}, {-754, -159.9370729}, {-755, -159.518656}, + {-756, -159.0631717}, {-757, -158.5708695}, {-758, -158.041995}, + {-759, -157.4767954}, {-760, -156.875518}, {-761, -156.238413}, + {-762, -155.5657275}, {-763, -154.8576883}, {-764, -154.1146146}, + {-765, -153.336698}, {-766, -152.5241939}, {-767, -151.67738}, + {-768, -150.7964936}, {-769, -149.8817944}, {-770, -148.9335339}, + {-771, -147.9519748}, {-772, -146.9373688}, {-773, -145.8899792}, + {-774, -144.8100612}, {-775, -143.6978692}, {-776, -142.5536754}, + {-777, -141.3777291}, {-778, -140.1703002}, {-779, -138.9316525}, + {-780, -137.6620416}, {-781, -136.3617455}, {-782, -135.0310177}, + {-783, -133.6701303}, {-784, -132.2793521}, {-785, -130.8589499}, + {-786, -129.4091947}, {-787, -127.9303533}, {-788, -126.422706}, + {-789, -124.886512}, {-790, -123.3220654}, {-791, -121.7296275}, + {-792, -120.1094645}, {-793, -118.4618712}, {-794, -116.7871174}, + {-795, -115.0854845}, {-796, -113.3572517}, {-797, -111.6027009}, + {-798, -109.8221157}, {-799, -108.0157785}, {-800, -106.1839739}, + {-801, -104.3269442}, {-802, -102.445109}, {-803, -100.5386221}, + {-804, -98.60782736}, {-805, -96.65300338}, {-806, -94.67445177}, + {-807, -92.67246114}, {-808, -90.64732994}, {-809, -88.59934272}, + {-810, -86.52881868}, {-811, -84.43604242}, {-812, -82.32131631}, + {-813, -80.18494279}, {-814, -78.02722712}, {-815, -75.84847195}, + {-816, -73.64898439}, {-817, -71.42907469}, {-818, -69.18904919}, + {-819, -66.92921994}, {-820, -64.64989833}, {-821, -62.35140076}, + {-822, -60.03405448}, {-823, -57.69813983}, {-824, -55.34401429}, + {-825, -52.9719887}, {-826, -50.58237424}, {-827, -48.17550758}, + {-828, -45.75170905}, {-829, -43.31130923}, {-830, -40.85465578}, + {-831, -38.3820222}, {-832, -35.89380027}, {-833, -33.39030718}, + {-834, -30.87188113}, {-835, -28.33885989}, {-836, -25.791586}, + {-837, -23.23040251}, {-838, -20.65565546}, {-839, -18.06769347}, + {-840, -15.46686596}, {-841, -12.85352529}, {-842, -10.22802618}, + {-843, -7.59072556}, {-844, -4.941982726}, {-845, -2.282159}, + {-846, 0.3883812354}, {-847, 3.069271665}, {-848, 5.760141876}, + {-849, 8.460624391}, {-850, 11.17034134}, {-851, 13.8889164}, + {-852, 16.61597088}, {-853, 19.35112082}, {-854, 22.0939838}, + {-855, 24.84417126}, {-856, 27.6012906}, {-857, 30.36494688}, + {-858, 33.13475264}, {-859, 35.91029577}, {-860, 38.69117916}, + {-861, 41.47699621}, {-862, 44.26733722}, {-863, 47.06178917}, + {-864, 49.85993667}, {-865, 52.66135818}, {-866, 55.46563175}, + {-867, 58.2723309}, {-868, 61.08102427}, {-869, 63.8912789}, + {-870, 66.70265436}, {-871, 69.51471154}, {-872, 72.32700257}, + {-873, 75.1390826}, {-874, 77.95048204}, {-875, 80.7607584}, + {-876, 83.56944147}, {-877, 86.3760675}, {-878, 89.18017567}, + {-879, 91.98126002}, {-880, 94.77884082}, {-881, 97.57246115}, + {-882, 100.3616172}, {-883, 103.1458032}, {-884, 105.9245336}, + {-885, 108.6972495}, {-886, 111.4635541}, {-887, 114.2228084}, + {-888, 116.9745432}, {-889, 119.7182234}, {-890, 122.4533029}, + {-891, 125.1792501}, {-892, 127.8955124}, {-893, 130.6015331}, + {-894, 133.2967482}, {-895, 135.9806029}, {-896, 138.6525019}, + {-897, 141.3118561}, {-898, 143.95814}, {-899, 146.5906486}, + {-900, 149.208845}, {-901, 151.8121024}, {-902, 154.3997994}, + {-903, 156.9712964}, {-904, 159.5259653}, {-905, 162.0631293}, + {-906, 164.5821626}, {-907, 167.0823615}, {-908, 169.5630728}, + {-909, 172.0236076}, {-910, 174.4632534}, {-911, 176.8813043}, + {-912, 179.2770371}, {-913, 181.649717}, {-914, 183.998597}, + {-915, 186.32292}, {-916, 188.6219234}, {-917, 190.8947924}, + {-918, 193.1407544}, {-919, 195.359018}, {-920, 197.5486647}, + {-921, 199.7089361}, {-922, 201.838948}, {-923, 203.9378159}, + {-924, 206.0046461}, {-925, 208.0385334}, {-926, 210.0385395}, + {-927, 212.0037157}, {-928, 213.9330909}, {-929, 215.8256767}, + {-930, 217.680437}, {-931, 219.4963597}, {-932, 221.2723751}, + {-933, 223.0073833}, {-934, 224.7002898}, {-935, 226.3499379}, + {-936, 227.955181}, {-937, 229.5147707}, {-938, 231.0275034}, + {-939, 232.4921406}, {-940, 233.9073486}, {-941, 235.2718051}, + {-942, 236.5840914}, {-943, 237.8428376}, {-944, 239.0465633}, + {-945, 240.1937945}, {-946, 241.2828728}, {-947, 242.3122776}, + {-948, 243.280354}, {-949, 244.1853667}, {-950, 245.0254509}, + {-951, 245.7988519}, {-952, 246.5036069}, {-953, 247.1377368}, + {-954, 247.6991856}, {-955, 248.1856749}, {-956, 248.5950514}, + {-957, 248.9249178}, {-958, 249.1728039}, {-959, 249.3360923}, + {-960, 249.4120835}, {-961, 249.3978903}, {-962, 249.2904901}, + {-963, 249.0866837}, {-964, 248.7831043}, {-965, 248.3761291}, + {-966, 247.8619404}, {-967, 247.2364286}, {-968, 246.4952529}, + {-969, 245.6335903}, {-970, 244.6464415}, {-971, 243.5282542}, + {-972, 242.2729229}, {-973, 240.8740198}, {-974, 239.3240711}, + {-975, 237.6150244}, {-976, 235.7377827}, {-977, 233.6820431}, + {-978, 231.4360144}, {-979, 228.9860151}, {-980, 226.3157532}, + {-981, 223.4057407}, {-982, 220.2316214}, {-983, 216.7619707}, + {-984, 212.9539453}, {-985, 208.7438151}, {-986, 204.0204357}, + {-987, 198.4513863}, {-988, 191.9539737}, {-989, 185.5137361}, + {-990, 179.1305231}, {-991, 172.8042021}, {-992, 166.5346253}, + {-993, 160.3216539}, {-994, 154.1651419}, {-995, 148.0649452}, + {-996, 142.0209294}, {-997, 136.0329471}, {-998, 130.1008566}, + {-999, 124.2245131}, {-1000, 118.4037775}, {-1001, 112.6384919}, + {-1002, 106.9285437}, {-1003, 101.2737464}, {-1004, 95.6740208}, + {-1005, 90.12915306}, {-1006, 84.63903621}, {-1007, 79.20352156}, + {-1008, 73.82246536}, {-1009, 68.49571524}, {-1010, 63.22313572}, + {-1011, 58.00458209}, {-1012, 52.83990248}, {-1013, 47.72895845}, + {-1014, 42.67160661}, {-1015, 37.6676933}, {-1016, 32.71707993}, + {-1017, 27.81962091}, {-1018, 22.9751687}, {-1019, 18.183578}, + {-1020, 13.44470329}, {-1021, 8.758398453}, {-1022, 4.124517212}, + {-1023, -0.4570867577}, {-1024, -4.98655971}, {-1025, -9.464049237}, + {-1026, -13.88970118}, {-1027, -18.26366921}, {-1028, -22.58608181}, + {-1029, -26.85710322}, {-1030, -31.07687981}, {-1031, -35.24555423}, + {-1032, -39.36327722}, {-1033, -43.43019288}, {-1034, -47.44645359}, + {-1035, -51.41220714}, {-1036, -55.32760085}, {-1037, -59.19278346}, + {-1038, -63.00790389}, {-1039, -66.77311384}, {-1040, -70.4885606}, + {-1041, -74.15438858}, {-1042, -77.77075557}, {-1043, -81.3378101}, + {-1044, -84.85569342}, {-1045, -88.32456929}, {-1046, -91.74457185}, + {-1047, -95.11587655}, {-1048, -98.43861292}, {-1049, -101.7129364}, + {-1050, -104.9389982}, {-1051, -108.116953}, {-1052, -111.2469519}, + {-1053, -114.3291443}, {-1054, -117.3636835}, {-1055, -120.350731}, + {-1056, -123.2904136}, {-1057, -126.1829069}, {-1058, -129.0283102}, + {-1059, -131.8269205}, {-1060, -134.5787455}, {-1061, -137.2839921}, + {-1062, -139.9428011}, {-1063, -142.5553393}, {-1064, -145.1217586}, + {-1065, -147.6422077}, {-1066, -150.1168478}, {-1067, -152.5458297}, + {-1068, -154.929308}, {-1069, -157.2674421}, {-1070, -159.560384}, + {-1071, -161.8082911}, {-1072, -164.0113173}, {-1073, -166.1696455}, + {-1074, -168.2833633}, {-1075, -170.3526893}, {-1076, -172.3777703}, + {-1077, -174.3587452}, {-1078, -176.2957964}, {-1079, -178.1890627}, + {-1080, -180.0387032}, {-1081, -181.8448841}, {-1082, -183.6077636}, + {-1083, -185.3274889}, {-1084, -187.0042315}, {-1085, -188.6381461}, + {-1086, -190.2293938}, {-1087, -191.7781326}, {-1088, -193.2845233}, + {-1089, -194.7487256}, {-1090, -196.1709107}, {-1091, -197.5512218}, + {-1092, -198.8898335}, {-1093, -200.1869004}, {-1094, -201.4425888}, + {-1095, -202.6570529}, {-1096, -203.830468}, {-1097, -204.9629868}, + {-1098, -206.0547771}, {-1099, -207.1060004}, {-1100, -208.1168254}, + {-1101, -209.0874043}, {-1102, -210.0179099}, {-1103, -210.9084808}, + {-1104, -211.7593594}, {-1105, -212.57063}, {-1106, -213.342491}, + {-1107, -214.0750995}, {-1108, -214.7686313}, {-1109, -215.4232422}, + {-1110, -216.0391073}, {-1111, -216.6163907}, {-1112, -217.1552598}, + {-1113, -217.6558809}, {-1114, -218.1184298}, {-1115, -218.5430666}, + {-1116, -218.9299641}, {-1117, -219.2792899}, {-1118, -219.5912079}, + {-1119, -219.8659034}, {-1120, -220.1035431}, {-1121, -220.3042752}, + {-1122, -220.4683124}, {-1123, -220.595789}, {-1124, -220.6868907}, + {-1125, -220.7417845}, {-1126, -220.7606608}, {-1127, -220.7436669}, + {-1128, -220.6909955}, {-1129, -220.6028094}, {-1130, -220.4792882}, + {-1131, -220.3206066}, {-1132, -220.1269434}, {-1133, -219.8984306}, + {-1134, -219.6353491}, {-1135, -219.3377772}, {-1136, -219.0058966}, + {-1137, -218.639961}, {-1138, -218.2400614}, {-1139, -217.806434}, + {-1140, -217.3392209}, {-1141, -216.8386174}, {-1142, -216.304802}, + {-1143, -215.7379313}, {-1144, -215.1382507}, {-1145, -214.5058689}, + {-1146, -213.8410006}, {-1147, -213.1436722}, {-1148, -212.4144}, + {-1149, -211.6532648}, {-1150, -210.8602496}, {-1151, -210.0356182}, + {-1152, -209.1796635}, {-1153, -208.292457}, {-1154, -207.3742317}, + {-1155, -206.4251592}, {-1156, -205.4454419}, {-1157, -204.4352509}, + {-1158, -203.3947787}, {-1159, -202.3242138}, {-1160, -201.2237403}, + {-1161, -200.0935529}, {-1162, -198.9338327}, {-1163, -197.7447794}, + {-1164, -196.5265719}, {-1165, -195.2794152}, {-1166, -194.0034846}, + {-1167, -192.6989822}, {-1168, -191.3660931}, {-1169, -190.0050278}, + {-1170, -188.615956}, {-1171, -187.1990636}, {-1172, -185.7546078}, + {-1173, -184.2827155}, {-1174, -182.7836134}, {-1175, -181.2574946}, + {-1176, -179.7045563}, {-1177, -178.1249913}, {-1178, -176.5190014}, + {-1179, -174.8867817}, {-1180, -173.2285388}, {-1181, -171.5444753}, + {-1182, -169.834783}, {-1183, -168.0996691}, {-1184, -166.3393323}, + {-1185, -164.5539775}, {-1186, -162.7438117}, {-1187, -160.9090393}, + {-1188, -159.0498584}, {-1189, -157.1664862}, {-1190, -155.2591188}, + {-1191, -153.3279647}, {-1192, -151.3732357}, {-1193, -149.3951405}, + {-1194, -147.3938888}, {-1195, -145.3696861}, {-1196, -143.3227491}, + {-1197, -141.2532956}, {-1198, -139.1615686}, {-1199, -137.0476573}, + {-1200, -134.911905}, {-1201, -132.7544817}, {-1202, -130.575612}, + {-1203, -128.3755012}, {-1204, -126.1543736}, {-1205, -123.9124458}, + {-1206, -121.6499375}, {-1207, -119.3670684}, {-1208, -117.0640612}, + {-1209, -114.7411352}, {-1210, -112.3985149}, {-1211, -110.0364226}, + {-1212, -107.6550862}, {-1213, -105.2547282}, {-1214, -102.8355752}, + {-1215, -100.3978558}, {-1216, -97.94192805}, {-1217, -95.46763412}, + {-1218, -92.97559043}, {-1219, -90.46589772}, {-1220, -87.93879494}, + {-1221, -85.39450874}, {-1222, -82.83327678}, {-1223, -80.25533676}, + {-1224, -77.66091937}, {-1225, -75.05026788}, {-1226, -72.42361434}, + {-1227, -69.7812126}, {-1228, -67.12328759}, {-1229, -64.45009061}, + {-1230, -61.76186322}, {-1231, -59.05884859}, {-1232, -56.34129582}, + {-1233, -53.60944689}, {-1234, -50.86355525}, {-1235, -48.10386549}, + {-1236, -45.33063332}, {-1237, -42.54410702}, {-1238, -39.74453989}, + {-1239, -36.93218801}, {-1240, -34.10730552}, {-1241, -31.2701509}, + {-1242, -28.42098258}, {-1243, -25.56005939}, {-1244, -22.68764573}, + {-1245, -19.80399739}, {-1246, -16.90938536}, {-1247, -14.00407248}, + {-1248, -11.08832635}, {-1249, -8.162415023}, {-1250, -5.226609065}, + {-1251, -2.281179596}, {-1252, 0.6736000031}, {-1253, 3.637455053}, + {-1254, 6.610109242}, {-1255, 9.591284352}, {-1256, 12.5807009}, + {-1257, 15.578078}, {-1258, 18.58313209}, {-1259, 21.59557822}, + {-1260, 24.61513064}, {-1261, 27.64150032}, {-1262, 30.67448551}, + {-1263, 33.71353351}, {-1264, 36.75860495}, {-1265, 39.80932656}, + {-1266, 42.86539566}, {-1267, 45.9265127}, {-1268, 48.9923769}, + {-1269, 52.06268497}, {-1270, 55.1371306}, {-1271, 58.21540675}, + {-1272, 61.29720377}, {-1273, 64.38220765}, {-1274, 67.47010622}, + {-1275, 70.5605817}, {-1276, 73.65331522}, {-1277, 76.74798611}, + {-1278, 79.84428086}, {-1279, 82.94184609}, {-1280, 86.04038238}, + {-1281, 89.13954176}, {-1282, 92.23900341}, {-1283, 95.33842467}, + {-1284, 98.43746276}, {-1285, 101.5357879}, {-1286, 104.6330432}, + {-1287, 107.7288929}, {-1288, 110.8229826}, {-1289, 113.914946}, + {-1290, 117.0044776}, {-1291, 120.0911648}, {-1292, 123.1746671}, + {-1293, 126.254623}, {-1294, 129.3306622}, {-1295, 132.4024085}, + {-1296, 135.4694961}, {-1297, 138.5315459}, {-1298, 141.5881778}, + {-1299, 144.6390067}, {-1300, 147.6836428}, {-1301, 150.7216996}, + {-1302, 153.7527804}, {-1303, 156.7764848}, {-1304, 159.7924102}, + {-1305, 162.8001549}, {-1306, 165.7993073}, {-1307, 168.7894507}, + {-1308, 171.7701636}, {-1309, 174.7410292}, {-1310, 177.7016188}, + {-1311, 180.6514932}, {-1312, 183.590232}, {-1313, 186.5173807}, + {-1314, 189.4324993}, {-1315, 192.335137}, {-1316, 195.2248335}, + {-1317, 198.1011329}, {-1318, 200.9635721}, {-1319, 203.8116777}, + {-1320, 206.6449645}, {-1321, 209.4629834}, {-1322, 212.2651708}, + {-1323, 215.051117}, {-1324, 217.8202696}, {-1325, 220.5721457}, + {-1326, 223.3062348}, {-1327, 226.0219976}, {-1328, 228.7189248}, + {-1329, 231.3964819}, {-1330, 234.0541244}, {-1331, 236.6913037}, + {-1332, 239.307474}, {-1333, 241.9020644}, {-1334, 244.4745609}, + {-1335, 247.0242272}, {-1336, 249.5506309}, {-1337, 252.053134}, + {-1338, 254.531117}, {-1339, 256.9839895}, {-1340, 259.4111072}, + {-1341, 261.8118884}, {-1342, 264.1855677}, {-1343, 266.5316171}, + {-1344, 268.8493247}, {-1345, 271.1380253}, {-1346, 273.3970279}, + {-1347, 275.625645}, {-1348, 277.8231589}, {-1349, 279.9888462}, + {-1350, 282.1219906}, {-1351, 284.2218105}, {-1352, 286.2875575}, + {-1353, 288.3184944}, {-1354, 290.3137841}, {-1355, 292.2726388}, + {-1356, 294.1942255}, {-1357, 296.0777138}, {-1358, 297.9222555}, + {-1359, 299.726963}, {-1360, 301.4909509}, {-1361, 303.2133144}, + {-1362, 304.8930971}, {-1363, 306.5293722}, {-1364, 308.1211544}, + {-1365, 309.6674458}, {-1366, 311.1672389}, {-1367, 312.6194607}, + {-1368, 314.0230537}, {-1369, 315.37693}, {-1370, 316.6799452}, + {-1371, 317.9309397}, {-1372, 319.1287312}, {-1373, 320.2720696}, + {-1374, 321.3597792}, {-1375, 322.3904816}, {-1376, 323.3628738}, + {-1377, 324.2755782}, {-1378, 325.1271858}, {-1379, 325.9162269}, + {-1380, 326.641201}, {-1381, 327.3005381}, {-1382, 327.8926356}, + {-1383, 328.4158062}, {-1384, 328.8683354}, {-1385, 329.2483977}, + {-1386, 329.5541484}, {-1387, 329.7836205}, {-1388, 329.934821}, + {-1389, 330.0056401}, {-1390, 329.9938465}, {-1391, 329.8971536}, + {-1392, 329.7131475}, {-1393, 329.4393186}, {-1394, 329.0729496}, + {-1395, 328.6114015}, {-1396, 328.0514185}, {-1397, 327.3901659}, + {-1398, 326.6243236}, {-1399, 325.7502231}, {-1400, 324.7642665}, + {-1401, 323.6624161}, {-1402, 322.4404172}, {-1403, 321.0936525}, + {-1404, 319.6171893}, {-1405, 318.0056403}, {-1406, 316.2531436}, + {-1407, 314.3532958}, {-1408, 312.2990162}, {-1409, 310.0824576}, + {-1410, 307.6948371}, {-1411, 305.1262384}, {-1412, 302.36531}, + {-1413, 299.3989435}, {-1414, 296.2116922}, {-1415, 292.7850052}, + {-1416, 289.0960336}, {-1417, 285.1155148}, {-1418, 280.8042868}, + {-1419, 276.1056003}, {-1420, 270.9256839}, {-1421, 265.0498316}, + {-1422, 258.0305961}, {-1423, 250.9533622}, {-1424, 243.9283235}, + {-1425, 236.9553812}, {-1426, 230.0344125}, {-1427, 223.1653202}, + {-1428, 216.348016}, {-1429, 209.5823497}, {-1430, 202.8682465}, + {-1431, 196.2056074}, {-1432, 189.5942927}, {-1433, 183.0342138}, + {-1434, 176.5252728}, {-1435, 170.0673494}, {-1436, 163.660332}, + {-1437, 157.304118}, {-1438, 150.998396}, {-1439, 144.7436831}, + {-1440, 138.5393463}, {-1441, 132.3851596}, {-1442, 126.2813523}, + {-1443, 120.2277003}, {-1444, 114.2240948}, {-1445, 108.2704306}, + {-1446, 102.3665932}, {-1447, 96.51247854}, {-1448, 90.7079781}, + {-1449, 84.95297989}, {-1450, 79.24737737}, {-1451, 73.59106103}, + {-1452, 67.98392275}, {-1453, 62.4258486}, {-1454, 56.9167324}, + {-1455, 51.45647351}, {-1456, 46.04493615}, {-1457, 40.68203531}, + {-1458, 35.3676543}, {-1459, 30.10167972}, {-1460, 24.88400482}, + {-1461, 19.71451894}, {-1462, 14.59310863}, {-1463, 9.51966659}, + {-1464, 4.494081216}, {-1465, -0.4837582643}, {-1466, -5.413962806}, + {-1467, -10.2966427}, {-1468, -15.13191051}, {-1469, -19.91987594}, + {-1470, -24.66065154}, {-1471, -29.35434819}, {-1472, -34.00107675}, + {-1473, -38.60095195}, {-1474, -43.15407953}, {-1475, -47.6605766}, + {-1476, -52.12055709}, {-1477, -56.53412597}, {-1478, -60.90139933}, + {-1479, -65.22249186}, {-1480, -69.49751358}, {-1481, -73.72657766}, + {-1482, -77.90978796}, {-1483, -82.04728595}, {-1484, -86.13915926}, + {-1485, -90.18552139}, {-1486, -94.18649236}, {-1487, -98.14218701}, + {-1488, -102.0527166}, {-1489, -105.9182019}, {-1490, -109.738738}, + {-1491, -113.5144567}, {-1492, -117.2454677}, {-1493, -120.9318844}, + {-1494, -124.5738204}, {-1495, -128.1713919}, {-1496, -131.7247093}, + {-1497, -135.2338968}, {-1498, -138.6985832}, {-1499, -142.1203184}, + {-1500, -145.4977801}, {-1501, -148.8315869}, {-1502, -152.1218236}, + {-1503, -155.368617}, {-1504, -158.5720837}, {-1505, -161.7323404}, + {-1506, -164.8495028}, {-1507, -167.9236845}, {-1508, -170.9550084}, + {-1509, -173.9435859}, {-1510, -176.8895472}, {-1511, -179.7929786}, + {-1512, -182.6540205}, {-1513, -185.4727875}, {-1514, -188.2493946}, + {-1515, -190.9839652}, {-1516, -193.6766361}, {-1517, -196.327446}, + {-1518, -198.9366067}, {-1519, -201.5041901}, {-1520, -204.0303235}, + {-1521, -206.5151327}, {-1522, -208.9587251}, {-1523, -211.3612174}, + {-1524, -213.7227424}, {-1525, -216.0434048}, {-1526, -218.3233361}, + {-1527, -220.562651}, {-1528, -222.7614698}, {-1529, -224.9199123}, + {-1530, -227.0380859}, {-1531, -229.1161603}, {-1532, -231.1541895}, + {-1533, -233.1523338}, {-1534, -235.1107066}, {-1535, -237.0294274}, + {-1536, -238.9086548}, {-1537, -240.7483935}, {-1538, -242.5488926}, + {-1539, -244.3101745}, {-1540, -246.0324995}, {-1541, -247.7158654}, + {-1542, -249.360428}, {-1543, -250.9663196}, {-1544, -252.5336417}, + {-1545, -254.0625606}, {-1546, -255.5531396}, {-1547, -257.0055772}, + {-1548, -258.4199372}, {-1549, -259.7963526}, {-1550, -261.1349554}, + {-1551, -262.4358946}, {-1552, -263.6992507}, {-1553, -264.9251738}, + {-1554, -266.1137724}, {-1555, -267.2652048}, {-1556, -268.3795628}, + {-1557, -269.4569849}, {-1558, -270.4975974}, {-1559, -271.5015178}, + {-1560, -272.468886}, {-1561, -273.3998118}, {-1562, -274.2944668}, + {-1563, -275.1528889}, {-1564, -275.9752887}, {-1565, -276.7617535}, + {-1566, -277.5124308}, {-1567, -278.227434}, {-1568, -278.9068944}, + {-1569, -279.5509436}, {-1570, -280.1597069}, {-1571, -280.7333171}, + {-1572, -281.271896}, {-1573, -281.775573}, {-1574, -282.244486}, + {-1575, -282.678714}, {-1576, -283.0785305}, {-1577, -283.4439176}, + {-1578, -283.7750604}, {-1579, -284.0721417}, {-1580, -284.3351069}, + {-1581, -284.5642847}, {-1582, -284.7597417}, {-1583, -284.9215918}, + {-1584, -285.0499971}, {-1585, -285.1450516}, {-1586, -285.2065376}, + {-1587, -285.2357563}, {-1588, -285.2316342}, {-1589, -285.1947207}, + {-1590, -285.1251531}, {-1591, -285.0230331}, {-1592, -284.8885283}, + {-1593, -284.7217583}, {-1594, -284.5228688}, {-1595, -284.2919871}, + {-1596, -284.0292445}, {-1597, -283.7347788}, {-1598, -283.4087333}, + {-1599, -283.0512383}, {-1600, -282.6624229}, {-1601, -282.2424309}, + {-1602, -281.7914131}, {-1603, -281.3094869}, {-1604, -280.7967943}, + {-1605, -280.2534728}, {-1606, -279.67967}, {-1607, -279.0748296}, + {-1608, -278.4411441}, {-1609, -277.7766831}, {-1610, -277.0823332}, + {-1611, -276.3581653}, {-1612, -275.6043525}, {-1613, -274.8210143}, + {-1614, -274.008313}, {-1615, -273.1663679}, {-1616, -272.2953518}, + {-1617, -271.3953801}, {-1618, -270.4666038}, {-1619, -269.5091071}, + {-1620, -268.5231996}, {-1621, -267.5087519}, {-1622, -266.4662878}, + {-1623, -265.3956226}, {-1624, -264.2970108}, {-1625, -263.1705953}, + {-1626, -262.0165313}, {-1627, -260.8349371}, {-1628, -259.6259964}, + {-1629, -258.3898231}, {-1630, -257.1265868}, {-1631, -255.8364102}, + {-1632, -254.5194552}, {-1633, -253.1758803}, {-1634, -251.8058002}, + {-1635, -250.409391}, {-1636, -248.9867889}, {-1637, -247.5381318}, + {-1638, -246.0636286}, {-1639, -244.563364}, {-1640, -243.0374811}, + {-1641, -241.4861976}, {-1642, -239.9096107}, {-1643, -238.3078871}, + {-1644, -236.681172}, {-1645, -235.0296459}, {-1646, -233.3534053}, + {-1647, -231.6526321}, {-1648, -229.9274588}, {-1649, -228.1781623}, + {-1650, -226.4047428}, {-1651, -224.6074133}, {-1652, -222.7863451}, + {-1653, -220.9416398}, {-1654, -219.0735116}, {-1655, -217.1820907}, + {-1656, -215.2675444}, {-1657, -213.3300244}, {-1658, -211.369683}, + {-1659, -209.3866897}, {-1660, -207.3811902}, {-1661, -205.3533675}, + {-1662, -203.30336}, {-1663, -201.2313343}, {-1664, -199.1374481}, + {-1665, -197.0218662}, {-1666, -194.8847674}, {-1667, -192.7262711}, + {-1668, -190.5465757}, {-1669, -188.3458384}, {-1670, -186.1242187}, + {-1671, -183.8818843}, {-1672, -181.6189972}, {-1673, -179.335729}, + {-1674, -177.0322328}, {-1675, -174.7086864}, {-1676, -172.3652596}, + {-1677, -170.0021082}, {-1678, -167.6194134}, {-1679, -165.2173133}, + {-1680, -162.7960445}, {-1681, -160.3557143}, {-1682, -157.8965125}, + {-1683, -155.4186138}, {-1684, -152.9221898}, {-1685, -150.4074007}, + {-1686, -147.8744358}, {-1687, -145.3234508}, {-1688, -142.7546716}, + {-1689, -140.1682121}, {-1690, -137.5642571}, {-1691, -134.9430084}, + {-1692, -132.3046349}, {-1693, -129.6492983}, {-1694, -126.9771944}, + {-1695, -124.2884938}, {-1696, -121.583375}, {-1697, -118.8620233}, + {-1698, -116.1246178}, {-1699, -113.3713391}, {-1700, -110.6023692}, + {-1701, -107.8178928}, {-1702, -105.0180958}, {-1703, -102.2031563}, + {-1704, -99.37326821}, {-1705, -96.52858191}, {-1706, -93.66936695}, + {-1707, -90.79573097}, {-1708, -87.90789445}, {-1709, -85.00603934}, + {-1710, -82.09036096}, {-1711, -79.16102098}, {-1712, -76.21827778}, + {-1713, -73.26227099}, {-1714, -70.29315038}, {-1715, -67.31126389}, + {-1716, -64.31665711}, {-1717, -61.30957719}, {-1718, -58.29021672}, + {-1719, -55.25877431}, {-1720, -52.21545294}, {-1721, -49.16044728}, + {-1722, -46.09395655}, {-1723, -43.01618348}, {-1724, -39.92732826}, + {-1725, -36.82759564}, {-1726, -33.71718872}, {-1727, -30.59631219}, + {-1728, -27.4651689}, {-1729, -24.32396923}, {-1730, -21.17291826}, + {-1731, -18.01222638}, {-1732, -14.84210144}, {-1733, -11.66275519}, + {-1734, -8.474398089}, {-1735, -5.277243744}, {-1736, -2.071505147}, + {-1737, 1.142601817}, {-1738, 4.364862316}, {-1739, 7.595059073}, + {-1740, 10.83297395}, {-1741, 14.07838791}, {-1742, 17.33108012}, + {-1743, 20.59082944}, {-1744, 23.85741345}, {-1745, 27.130606}, + {-1746, 30.41018709}, {-1747, 33.69592687}, {-1748, 36.98759685}, + {-1749, 40.28497006}, {-1750, 43.58781629}, {-1751, 46.89590316}, + {-1752, 50.209002}, {-1753, 53.52687116}, {-1754, 56.84928153}, + {-1755, 60.17599514}, {-1756, 63.50677295}, {-1757, 66.84137666}, + {-1758, 70.17956563}, {-1759, 73.52109515}, {-1760, 76.86572436}, + {-1761, 80.21320719}, {-1762, 83.56329692}, {-1763, 86.91575236}, + {-1764, 90.27030066}, {-1765, 93.62671326}, {-1766, 96.98473215}, + {-1767, 100.3441002}, {-1768, 103.7045628}, {-1769, 107.0658466}, + {-1770, 110.427736}, {-1771, 113.7899279}, {-1772, 117.1521691}, + {-1773, 120.5142362}, {-1774, 123.8757527}, {-1775, 127.236559}, + {-1776, 130.5963477}, {-1777, 133.9548462}, {-1778, 137.3117864}, + {-1779, 140.6668935}, {-1780, 144.019869}, {-1781, 147.3704582}, + {-1782, 150.7183775}, {-1783, 154.0633144}, {-1784, 157.4050184}, + {-1785, 160.7431864}, {-1786, 164.077527}, {-1787, 167.4077511}, + {-1788, 170.7335631}, {-1789, 174.0546652}, {-1790, 177.3707551}, + {-1791, 180.6815471}, {-1792, 183.9867331}, {-1793, 187.2859685}, + {-1794, 190.5789949}, {-1795, 193.8654854}, {-1796, 197.1451059}, + {-1797, 200.4175632}, {-1798, 203.6825367}, {-1799, 206.9396968}, + {-1800, 210.1887216}, {-1801, 213.4292851}, {-1802, 216.661056}, + {-1803, 219.8837061}, {-1804, 223.0968824}, {-1805, 226.3002654}, + {-1806, 229.493504}, {-1807, 232.6762727}, {-1808, 235.8481706}, + {-1809, 239.0088965}, {-1810, 242.1580657}, {-1811, 245.2953655}, + {-1812, 248.4204047}, {-1813, 251.532773}, {-1814, 254.6321658}, + {-1815, 257.7181886}, {-1816, 260.7904663}, {-1817, 263.848621}, + {-1818, 266.892258}, {-1819, 269.9209918}, {-1820, 272.9344548}, + {-1821, 275.932219}, {-1822, 278.9138957}, {-1823, 281.8790852}, + {-1824, 284.8273764}, {-1825, 287.7583441}, {-1826, 290.6715817}, + {-1827, 293.5666663}, {-1828, 296.4431622}, {-1829, 299.3006457}, + {-1830, 302.1386696}, {-1831, 304.9568206}, {-1832, 307.754573}, + {-1833, 310.5315524}, {-1834, 313.2872937}, {-1835, 316.0212653}, + {-1836, 318.7330565}, {-1837, 321.4221836}, {-1838, 324.0881604}, + {-1839, 326.7304987}, {-1840, 329.3486326}, {-1841, 331.9421603}, + {-1842, 334.5105311}, {-1843, 337.0532316}, {-1844, 339.5697272}, + {-1845, 342.0594964}, {-1846, 344.5220039}, {-1847, 346.9567043}, + {-1848, 349.3630138}, {-1849, 351.7404044}, {-1850, 354.0882918}, + {-1851, 356.4061032}, {-1852, 358.6932203}, {-1853, 360.9490705}, + {-1854, 363.1730489}, {-1855, 365.3656041}, {-1856, 367.5228721}, + {-1857, 369.6474506}, {-1858, 371.7376163}, {-1859, 373.7927355}, + {-1860, 375.812037}, {-1861, 377.7949387}, {-1862, 379.7407076}, + {-1863, 381.6486335}, {-1864, 383.5180106}, {-1865, 385.3480624}, + {-1866, 387.1380641}, {-1867, 388.8872593}, {-1868, 390.5948317}, + {-1869, 392.2600545}, {-1870, 393.8820359}, {-1871, 395.459983}, + {-1872, 396.9930631}, {-1873, 398.4803572}, {-1874, 399.9210344}, + {-1875, 401.3141151}, {-1876, 402.6588113}, {-1877, 403.9540475}, + {-1878, 405.1988957}, {-1879, 406.3923656}, {-1880, 407.5334268}, + {-1881, 408.6210283}, {-1882, 409.6541294}, {-1883, 410.6316101}, + {-1884, 411.5523425}, {-1885, 412.4151488}, {-1886, 413.2188772}, + {-1887, 413.9622628}, {-1888, 414.6440533}, {-1889, 415.2629519}, + {-1890, 415.8176095}, {-1891, 416.3066548}, {-1892, 416.728632}, + {-1893, 417.0821132}, {-1894, 417.3654971}, {-1895, 417.5772473}, + {-1896, 417.7157386}, {-1897, 417.7792498}, {-1898, 417.7660382}, + {-1899, 417.6742585}, {-1900, 417.5020087}, {-1901, 417.2473105}, + {-1902, 416.9080878}, {-1903, 416.4821984}, {-1904, 415.9673674}, + {-1905, 415.3612177}, {-1906, 414.6613001}, {-1907, 413.865}, + {-1908, 412.9695616}, {-1909, 411.9721071}, {-1910, 410.8695776}, + {-1911, 409.6587338}, {-1912, 408.3361432}, {-1913, 406.8981203}, + {-1914, 405.3408246}, {-1915, 403.6600082}, {-1916, 401.8511918}, + {-1917, 399.9095439}, {-1918, 397.8297696}, {-1919, 395.6061773}, + {-1920, 393.2325758}, {-1921, 390.7018165}, {-1922, 388.0065344}, + {-1923, 385.1656683}, {-1924, 382.0867723}, {-1925, 378.841722}, + {-1926, 375.3902268}, {-1927, 371.7174307}, {-1928, 367.8055737}, + {-1929, 363.6329048}, {-1930, 359.1718349}, {-1931, 354.3858715}, + {-1932, 349.2231247}, {-1933, 343.6010933}, {-1934, 337.3504745}, + {-1935, 329.950698}, {-1936, 322.2912062}, {-1937, 314.6801463}, + {-1938, 307.1171549}, {-1939, 299.60287}, {-1940, 292.1365344}, + {-1941, 284.7182428}, {-1942, 277.3479559}, {-1943, 270.0255803}, + {-1944, 262.7510235}, {-1945, 255.5242057}, {-1946, 248.3450413}, + {-1947, 241.2134537}, {-1948, 234.129339}, {-1949, 227.0926324}, + {-1950, 220.1032292}, {-1951, 213.1610783}, {-1952, 206.2660762}, + {-1953, 199.418106}, {-1954, 192.6171278}, {-1955, 185.8630543}, + {-1956, 179.155766}, {-1957, 172.4952102}, {-1958, 165.8812805}, + {-1959, 159.313922}, {-1960, 152.7930067}, {-1961, 146.3184739}, + {-1962, 139.8902485}, {-1963, 133.508222}, {-1964, 127.1723164}, + {-1965, 120.8824627}, {-1966, 114.6385511}, {-1967, 108.4405069}, + {-1968, 102.2882401}, {-1969, 96.1816731}, {-1970, 90.12070067}, + {-1971, 84.10525847}, {-1972, 78.13524813}, {-1973, 72.21058682}, + {-1974, 66.33118658}, {-1975, 60.4969655}, {-1976, 54.70782541}, + {-1977, 48.96368942}, {-1978, 43.26447169}, {-1979, 37.61006021}, + {-1980, 32.0004247}, {-1981, 26.43542669}, {-1982, 20.91499515}, + {-1983, 15.43904262}, {-1984, 10.00748211}, {-1985, 4.620225938}, + {-1986, -0.7228133783}, {-1987, -6.021723494}, {-1988, -11.27658947}, + {-1989, -16.48750685}, {-1990, -21.65455571}, {-1991, -26.77782749}, + {-1992, -31.85740919}, {-1993, -36.89339081}, {-1994, -41.88585437}, + {-1995, -46.83489874}, {-1996, -51.74060567}, {-1997, -56.60306145}, + {-1998, -61.42235931}, {-1999, -66.19858681}, {-2000, -70.9318329}, + {-2001, -75.62218716}, {-2002, -80.26973548}, {-2003, -84.87457124}, + {-2004, -89.43677976}, {-2005, -93.95645317}, {-2006, -98.43367886}, + {-2007, -102.8685462}, {-2008, -107.2611502}, {-2009, -111.6115737}, + {-2010, -115.9199079}, {-2011, -120.1862458}, {-2012, -124.4106739}, + {-2013, -128.5932831}, {-2014, -132.7341875}, {-2015, -136.8334131}, + {-2016, -140.8911158}, {-2017, -144.9073395}, {-2018, -148.8822277}, + {-2019, -152.8158291}, {-2020, -156.708243}, {-2021, -160.5595635}, + {-2022, -164.3698865}, {-2023, -168.1392891}, {-2024, -171.8678771}, + {-2025, -175.5557625}, {-2026, -179.2029529}, {-2027, -182.8096307}, + {-2028, -186.3758531}, {-2029, -189.9017115}, {-2030, -193.387299}, + {-2031, -196.832711}, {-2032, -200.2380349}, {-2033, -203.6033646}, + {-2034, -206.9287938}, {-2035, -210.2144102}, {-2036, -213.4603115}, + {-2037, -216.6665934}, {-2038, -219.8333269}, {-2039, -222.960647}, + {-2040, -226.0486273}, {-2041, -229.0973213}, {-2042, -232.1068739}, + {-2043, -235.0772483}, {-2044, -238.0088781}, {-2045, -240.9015156}, + {-2046, -243.7553686}, {-2047, -246.5705384}, {-2048, -249.3470947}, + {-2049, -252.0851617}, {-2050, -254.7847815}, {-2051, -257.446159}, + {-2052, -260.0692812}, {-2053, -262.6542796}, {-2054, -265.2012469}, + {-2055, -267.7102679}, {-2056, -270.1814773}, {-2057, -272.6149185}, + {-2058, -275.0107179}, {-2059, -277.3689585}, {-2060, -279.6897437}, + {-2061, -281.9731652}, {-2062, -284.2192924}, {-2063, -286.4283015}, + {-2064, -288.6002083}, {-2065, -290.7351299}, {-2066, -292.8331807}, + {-2067, -294.8944379}, {-2068, -296.9190066}, {-2069, -298.9069792}, + {-2070, -300.8584588}, {-2071, -302.773538}, {-2072, -304.6523068}, + {-2073, -306.4948842}, {-2074, -308.3013433}, {-2075, -310.0718028}, + {-2076, -311.8063438}, {-2077, -313.5050721}, {-2078, -315.1680698}, + {-2079, -316.7954664}, {-2080, -318.3873474}, {-2081, -319.9437928}, + {-2082, -321.4649154}, {-2083, -322.9508231}, {-2084, -324.4015927}, + {-2085, -325.8173421}, {-2086, -327.1981457}, {-2087, -328.5441633}, + {-2088, -329.855426}, {-2089, -331.1320587}, {-2090, -332.3741665}, + {-2091, -333.5818414}, {-2092, -334.7551931}, {-2093, -335.8943053}, + {-2094, -336.9992937}, {-2095, -338.0702459}, {-2096, -339.1073014}, + {-2097, -340.1104863}, {-2098, -341.0799584}, {-2099, -342.015825}, + {-2100, -342.9181658}, {-2101, -343.7870749}, {-2102, -344.6226615}, + {-2103, -345.4250384}, {-2104, -346.194308}, {-2105, -346.9305378}, + {-2106, -347.6338704}, {-2107, -348.304392}, {-2108, -348.9422119}, + {-2109, -349.5474149}, {-2110, -350.1201358}, {-2111, -350.6604463}, + {-2112, -351.1684701}, {-2113, -351.6442856}, {-2114, -352.0880972}, + {-2115, -352.499796}, {-2116, -352.8796774}, {-2117, -353.2277905}, + {-2118, -353.5442363}, {-2119, -353.8291059}, {-2120, -354.0825163}, + {-2121, -354.3045796}, {-2122, -354.4953995}, {-2123, -354.6550344}, + {-2124, -354.7836683}, {-2125, -354.8813658}, {-2126, -354.9482168}, + {-2127, -354.9843609}, {-2128, -354.9898995}, {-2129, -354.9649747}, + {-2130, -354.9095195}, {-2131, -354.823835}, {-2132, -354.7079703}, + {-2133, -354.5620166}, {-2134, -354.3860746}, {-2135, -354.1803085}, + {-2136, -353.9447693}, {-2137, -353.6795756}, {-2138, -353.3848379}, + {-2139, -353.0606775}, {-2140, -352.7071811}, {-2141, -352.3244769}, + {-2142, -351.912662}, {-2143, -351.471863}, {-2144, -351.0021736}, + {-2145, -350.5037011}, {-2146, -349.9765579}, {-2147, -349.4208634}, + {-2148, -348.8367303}, {-2149, -348.2242421}, {-2150, -347.5835569}, + {-2151, -346.9147442}, {-2152, -346.2179301}, {-2153, -345.4932213}, + {-2154, -344.7407432}, {-2155, -343.9605941}, {-2156, -343.1528785}, + {-2157, -342.3177459}, {-2158, -341.4552718}, {-2159, -340.5655715}, + {-2160, -339.6487849}, {-2161, -338.7050057}, {-2162, -337.7343412}, + {-2163, -336.7369161}, {-2164, -335.7128505}, {-2165, -334.662227}, + {-2166, -333.5852284}, {-2167, -332.4818964}, {-2168, -331.3523944}, + {-2169, -330.196809}, {-2170, -329.0152665}, {-2171, -327.8078824}, + {-2172, -326.5747753}, {-2173, -325.3160546}, {-2174, -324.0318305}, + {-2175, -322.7222628}, {-2176, -321.3874142}, {-2177, -320.0274377}, + {-2178, -318.6424205}, {-2179, -317.2324728}, {-2180, -315.7978146}, + {-2181, -314.3384489}, {-2182, -312.8545312}, {-2183, -311.3461843}, + {-2184, -309.8135015}, {-2185, -308.2566863}, {-2186, -306.6757613}, + {-2187, -305.0709113}, {-2188, -303.4422126}, {-2189, -301.789807}, + {-2190, -300.1138112}, {-2191, -298.4143537}, {-2192, -296.6915478}, + {-2193, -294.9455222}, {-2194, -293.1763954}, {-2195, -291.3843497}, + {-2196, -289.5693315}, {-2197, -287.7316381}, {-2198, -285.8713262}, + {-2199, -283.9885534}, {-2200, -282.0834107}, {-2201, -280.1560426}, + {-2202, -278.2065489}, {-2203, -276.2350741}, {-2204, -274.2417379}, + {-2205, -272.2266737}, {-2206, -270.1899978}, {-2207, -268.1318423}, + {-2208, -266.0523289}, {-2209, -263.9515906}, {-2210, -261.8297485}, + {-2211, -259.6869414}, {-2212, -257.5232824}, {-2213, -255.3388932}, + {-2214, -253.1339501}, {-2215, -250.9085367}, {-2216, -248.6627959}, + {-2217, -246.3968522}, {-2218, -244.1108406}, {-2219, -241.804899}, + {-2220, -239.4791373}, {-2221, -237.1337037}, {-2222, -234.768745}, + {-2223, -232.3843565}, {-2224, -229.9807064}, {-2225, -227.557898}, + {-2226, -225.1160867}, {-2227, -222.6553908}, {-2228, -220.1759508}, + {-2229, -217.677904}, {-2230, -215.1613805}, {-2231, -212.6265203}, + {-2232, -210.0734562}, {-2233, -207.5023218}, {-2234, -204.9132451}, + {-2235, -202.3063923}, {-2236, -199.6818639}, {-2237, -197.03983}, + {-2238, -194.380415}, {-2239, -191.7037474}, {-2240, -189.0099853}, + {-2241, -186.2992551}, {-2242, -183.5717066}, {-2243, -180.8274679}, + {-2244, -178.0666762}, {-2245, -175.2895042}, {-2246, -172.4960631}, + {-2247, -169.6865042}, {-2248, -166.8609664}, {-2249, -164.0195998}, + {-2250, -161.1625442}, {-2251, -158.289947}, {-2252, -155.4019448}, + {-2253, -152.498694}, {-2254, -149.5803236}, {-2255, -146.6469962}, + {-2256, -143.6988504}, {-2257, -140.7360367}, {-2258, -137.7586994}, + {-2259, -134.7669883}, {-2260, -131.7610455}, {-2261, -128.7410366}, + {-2262, -125.7070907}, {-2263, -122.6593776}, {-2264, -119.5980339}, + {-2265, -116.5232134}, {-2266, -113.4350715}, {-2267, -110.3337476}, + {-2268, -107.2194106}, {-2269, -104.0920936}, {-2270, -100.9523156}, + {-2271, -97.79985445}, {-2272, -94.6349785}, {-2273, -91.45787948}, + {-2274, -88.26867852}, {-2275, -85.06754785}, {-2276, -81.85464089}, + {-2277, -78.63011638}, {-2278, -75.39413565}, {-2279, -72.1468558}, + {-2280, -68.88843666}, {-2281, -65.61904004}, {-2282, -62.33882793}, + {-2283, -59.04795767}, {-2284, -55.74659691}, {-2285, -52.43490637}, + {-2286, -49.1130512}, {-2287, -45.78119593}, {-2288, -42.43950444}, + {-2289, -39.08814207}, {-2290, -35.72727733}, {-2291, -32.35707085}, + {-2292, -28.9777075}, {-2293, -25.58933942}, {-2294, -22.19214184}, + {-2295, -18.78628354}, {-2296, -15.37193688}, {-2297, -11.94927261}, + {-2298, -8.518463601}, {-2299, -5.079682548}, {-2300, -1.633103747}, + {-2301, 1.821098413}, {-2302, 5.282748524}, {-2303, 8.751670197}, + {-2304, 12.22768648}, {-2305, 15.71061966}, {-2306, 19.20029397}, + {-2307, 22.69651984}, {-2308, 26.19912825}, {-2309, 29.70793306}, + {-2310, 33.22275341}, {-2311, 36.74341042}, {-2312, 40.26970642}, + {-2313, 43.80147036}, {-2314, 47.33851291}, {-2315, 50.88064578}, + {-2316, 54.42768675}, {-2317, 57.97943984}, {-2318, 61.53572256}, + {-2319, 65.09633804}, {-2320, 68.6611025}, {-2321, 72.22981743}, + {-2322, 75.80229463}, {-2323, 79.3783372}, {-2324, 82.95775036}, + {-2325, 86.54033883}, {-2326, 90.12590068}, {-2327, 93.71425003}, + {-2328, 97.30517596}, {-2329, 100.8984795}, {-2330, 104.4939651}, + {-2331, 108.091423}, {-2332, 111.6906555}, {-2333, 115.291453}, + {-2334, 118.893614}, {-2335, 122.4969296}, {-2336, 126.1011879}, + {-2337, 129.7061875}, {-2338, 133.3117114}, {-2339, 136.9175495}, + {-2340, 140.5234891}, {-2341, 144.129315}, {-2342, 147.7348154}, + {-2343, 151.3397674}, {-2344, 154.9439585}, {-2345, 158.5471624}, + {-2346, 162.1491674}, {-2347, 165.7497448}, {-2348, 169.3486707}, + {-2349, 172.9457248}, {-2350, 176.5406855}, {-2351, 180.1333077}, + {-2352, 183.723366}, {-2353, 187.3106448}, {-2354, 190.8949073}, + {-2355, 194.4759291}, {-2356, 198.0534221}, {-2357, 201.6272097}, + {-2358, 205.1969846}, {-2359, 208.762651}, {-2360, 212.3238241}, + {-2361, 215.8803108}, {-2362, 219.4318606}, {-2363, 222.9782309}, + {-2364, 226.5191699}, {-2365, 230.0544352}, {-2366, 233.5837716}, + {-2367, 237.1069139}, {-2368, 240.6236258}, {-2369, 244.1336406}, + {-2370, 247.6383991}, {-2371, 251.1325303}, {-2372, 254.6208938}, + {-2373, 258.1015027}, {-2374, 261.5741058}, {-2375, 265.0384209}, + {-2376, 268.4941917}, {-2377, 271.941132}, {-2378, 275.3789734}, + {-2379, 278.8074262}, {-2380, 282.2262386}, {-2381, 285.6351}, + {-2382, 289.0337321}, {-2383, 292.4218602}, {-2384, 295.7991856}, + {-2385, 299.1654198}, {-2386, 302.5202605}, {-2387, 305.8634252}, + {-2388, 309.1946062}, {-2389, 312.5135048}, {-2390, 315.8198165}, + {-2391, 319.113236}, {-2392, 322.3934033}, {-2393, 325.66015}, + {-2394, 328.9130104}, {-2395, 332.1517166}, {-2396, 335.3759845}, + {-2397, 338.5854103}, {-2398, 341.7797321}, {-2399, 344.9586149}, + {-2400, 348.1217023}, {-2401, 351.2686662}, {-2402, 354.3991717}, + {-2403, 357.5128706}, {-2404, 360.6094332}, {-2405, 363.6884632}, + {-2406, 366.7496497}, {-2407, 369.7926254}, {-2408, 372.8170254}, + {-2409, 375.8224899}, {-2410, 378.8086383}, {-2411, 381.7751082}, + {-2412, 384.7215191}, {-2413, 387.6474977}, {-2414, 390.5526423}, + {-2415, 393.4365774}, {-2416, 396.2989036}, {-2417, 399.1392244}, + {-2418, 401.9571151}, {-2419, 404.7522327}, {-2420, 407.5240922}, + {-2421, 410.272313}, {-2422, 412.9964593}, {-2423, 415.6960891}, + {-2424, 418.3708254}, {-2425, 421.0201754}, {-2426, 423.643725}, + {-2427, 426.240987}, {-2428, 428.8115477}, {-2429, 431.3549225}, + {-2430, 433.8706653}, {-2431, 436.3582581}, {-2432, 438.8172568}, + {-2433, 441.247178}, {-2434, 443.6475395}, {-2435, 446.0177607}, + {-2436, 448.3574199}, {-2437, 450.6659619}, {-2438, 452.9429115}, + {-2439, 455.1876351}, {-2440, 457.3997077}, {-2441, 459.5785156}, + {-2442, 461.7235283}, {-2443, 463.8341753}, {-2444, 465.9098741}, + {-2445, 467.9500617}, {-2446, 469.9541217}, {-2447, 471.9214823}, + {-2448, 473.8514962}, {-2449, 475.7435692}, {-2450, 477.5970594}, + {-2451, 479.4113195}, {-2452, 481.1856945}, {-2453, 482.9194772}, + {-2454, 484.6121218}, {-2455, 486.2627967}, {-2456, 487.8708666}, + {-2457, 489.4355502}, {-2458, 490.9561368}, {-2459, 492.4319211}, + {-2460, 493.8621066}, {-2461, 495.2459111}, {-2462, 496.5825668}, + {-2463, 497.8712169}, {-2464, 499.1110738}, {-2465, 500.3012703}, + {-2466, 501.4409179}, {-2467, 502.5291726}, {-2468, 503.5651018}, + {-2469, 504.5496464}, {-2470, 505.4762591}, {-2471, 506.3495478}, + {-2472, 507.1666798}, {-2473, 507.9265974}, {-2474, 508.6282626}, + {-2475, 509.2706183}, {-2476, 509.8524857}, {-2477, 510.3728067}, + {-2478, 510.8303492}, {-2479, 511.2239517}, {-2480, 511.5523527}, + {-2481, 511.8142359}, {-2482, 512.0083321}, {-2483, 512.1332609}, + {-2484, 512.1876494}, {-2485, 512.1699389}, {-2486, 512.0787598}, + {-2487, 511.9124796}, {-2488, 511.6695054}, {-2489, 511.3481601}, + {-2490, 510.9467169}, {-2491, 510.4633625}, {-2492, 509.8962183}, + {-2493, 509.243379}, {-2494, 508.5027255}, {-2495, 507.6721727}, + {-2496, 506.7495012}, {-2497, 505.7323738}, {-2498, 504.6183546}, + {-2499, 503.4048642}, {-2500, 502.0891692}, {-2501, 500.6685314}, + {-2502, 499.1398264}, {-2503, 497.4999126}, {-2504, 495.7453965}, + {-2505, 493.8728667}, {-2506, 491.8779939}, {-2507, 489.7569877}, + {-2508, 487.5054439}, {-2509, 485.1185603}, {-2510, 482.5911479}, + {-2511, 479.9176074}, {-2512, 477.0917364}, {-2513, 474.1068292}, + {-2514, 470.9554055}, {-2515, 467.6290435}, {-2516, 464.118404}, + {-2517, 460.4127475}, {-2518, 456.4998509}, {-2519, 452.365065}, + {-2520, 447.991528}, {-2521, 443.3580292}, {-2522, 438.438392}, + {-2523, 433.1979703}, {-2524, 427.5884027}, {-2525, 421.5343929}, + {-2526, 414.8919142}, {-2527, 407.1575495}, {-2528, 398.9589393}, + {-2529, 390.8056713}, {-2530, 382.6976782}, {-2531, 374.6348759}, + {-2532, 366.6172204}, {-2533, 358.6446286}, {-2534, 350.717138}, + {-2535, 342.8343774}, {-2536, 334.9966128}, {-2537, 327.2035838}, + {-2538, 319.4553132}, {-2539, 311.7516789}, {-2540, 304.0926436}, + {-2541, 296.478137}, {-2542, 288.9080242}, {-2543, 281.3823933}, + {-2544, 273.9010287}, {-2545, 266.4639084}, {-2546, 259.0709605}, + {-2547, 251.7221247}, {-2548, 244.417387}, {-2549, 237.1564913}, + {-2550, 229.9395698}, {-2551, 222.7664542}, {-2552, 215.637115}, + {-2553, 208.5514592}, {-2554, 201.5094486}, {-2555, 194.510955}, + {-2556, 187.5559601}, {-2557, 180.644378}, {-2558, 173.7761414}, + {-2559, 166.951178}, {-2560, 160.1694545}, {-2561, 153.4307895}, + {-2562, 146.7352321}, {-2563, 140.082664}, {-2564, 133.4730194}, + {-2565, 126.9062307}, {-2566, 120.3822261}, {-2567, 113.9009356}, + {-2568, 107.4622856}, {-2569, 101.0662139}, {-2570, 94.71264255}, + {-2571, 88.40150333}, {-2572, 82.13272692}, {-2573, 75.90623975}, + {-2574, 69.72197655}, {-2575, 63.57985833}, {-2576, 57.47982248}, + {-2577, 51.42179276}, {-2578, 45.40570429}, {-2579, 39.43147622}, + {-2580, 33.49904632}, {-2581, 27.60834016}, {-2582, 21.75928681}, + {-2583, 15.95181538}, {-2584, 10.18585427}, {-2585, 4.4613317}, + {-2586, -1.221823264}, {-2587, -6.863682244}, {-2588, -12.46431711}, + {-2589, -18.02379881}, {-2590, -23.54220032}, {-2591, -29.01959173}, + {-2592, -34.45604716}, {-2593, -39.85163591}, {-2594, -45.20643153}, + {-2595, -50.52050558}, {-2596, -55.79393134}, {-2597, -61.02677981}, + {-2598, -66.21912335}, {-2599, -71.37103561}, {-2600, -76.48258755}, + {-2601, -81.55385237}, {-2602, -86.58490467}, {-2603, -91.57580819}, + {-2604, -96.52662878}, {-2605, -101.4374872}, {-2606, -106.3084075}, + {-2607, -111.1394718}, {-2608, -115.9307636}, {-2609, -120.6823469}, + {-2610, -125.3943008}, {-2611, -130.0666951}, {-2612, -134.6996035}, + {-2613, -139.2926982}, {-2614, -143.8472845}, {-2615, -148.3621251}, + {-2616, -152.8378634}, {-2617, -157.2744514}, {-2618, -161.6719856}, + {-2619, -166.0305687}, {-2620, -170.3502425}, {-2621, -174.6311046}, + {-2622, -178.8732158}, {-2623, -183.0766462}, {-2624, -187.2414872}, + {-2625, -191.3678067}, {-2626, -195.4556602}, {-2627, -199.5051449}, + {-2628, -203.5163556}, {-2629, -207.4892838}, {-2630, -211.4240905}, + {-2631, -215.3208074}, {-2632, -219.179545}, {-2633, -223.000344}, + {-2634, -226.7832883}, {-2635, -230.5284632}, {-2636, -234.2359251}, + {-2637, -237.9057799}, {-2638, -241.5380558}, {-2639, -245.1328705}, + {-2640, -248.6903057}, {-2641, -252.2103734}, {-2642, -255.6932106}, + {-2643, -259.1388831}, {-2644, -262.5474507}, {-2645, -265.9189965}, + {-2646, -269.2536048}, {-2647, -272.5513386}, {-2648, -275.8122855}, + {-2649, -279.0365115}, {-2650, -282.2240579}, {-2651, -285.3751227}, + {-2652, -288.4896622}, {-2653, -291.5677959}, {-2654, -294.6095802}, + {-2655, -297.6151472}, {-2656, -300.584486}, {-2657, -303.5177297}, + {-2658, -306.414873}, {-2659, -309.276272}, {-2660, -312.1016832}, + {-2661, -314.8913017}, {-2662, -317.6452094}, {-2663, -320.363471}, + {-2664, -323.0461886}, {-2665, -325.6934182}, {-2666, -328.3052418}, + {-2667, -330.8817427}, {-2668, -333.4229876}, {-2669, -335.9290716}, + {-2670, -338.4000315}, {-2671, -340.8360332}, {-2672, -343.2370808}, + {-2673, -345.6032636}, {-2674, -347.9346872}, {-2675, -350.2313994}, + {-2676, -352.4934683}, {-2677, -354.7210289}, {-2678, -356.9141233}, + {-2679, -359.0728291}, {-2680, -361.1972312}, {-2681, -363.2874191}, + {-2682, -365.34346}, {-2683, -367.3654373}, {-2684, -369.3534306}, + {-2685, -371.3075113}, {-2686, -373.2277708}, {-2687, -375.1142949}, + {-2688, -376.9671425}, {-2689, -378.7864087}, {-2690, -380.5721488}, + {-2691, -382.3245196}, {-2692, -384.0435213}, {-2693, -385.7292557}, + {-2694, -387.3818163}, {-2695, -389.0012733}, {-2696, -390.5877112}, + {-2697, -392.141186}, {-2698, -393.6618535}, {-2699, -395.1497277}, + {-2700, -396.5965999}, {-2701, -398.0274661}, {-2702, -399.417503}, + {-2703, -400.7750989}, {-2704, -402.1002937}, {-2705, -403.3932392}, + {-2706, -404.6539646}, {-2707, -405.8825768}, {-2708, -407.0791497}, + {-2709, -408.2437654}, {-2710, -409.376479}, {-2711, -410.4774696}, + {-2712, -411.546718}, {-2713, -412.5843448}, {-2714, -413.5904292}, + {-2715, -414.5650599}, {-2716, -415.5083121}, {-2717, -416.4202805}, + {-2718, -417.3010423}, {-2719, -418.1506732}, {-2720, -418.9692655}, + {-2721, -419.7569036}, {-2722, -420.513675}, {-2723, -421.239654}, + {-2724, -421.9349321}, {-2725, -422.5996082}, {-2726, -423.2337297}, + {-2727, -423.8373989}, {-2728, -424.4107227}, {-2729, -424.9537758}, + {-2730, -425.4666152}, {-2731, -425.9493702}, {-2732, -426.4020748}, + {-2733, -426.8248474}, {-2734, -427.217775}, {-2735, -427.5809368}, + {-2736, -427.9144198}, {-2737, -428.218309}, {-2738, -428.4926839}, + {-2739, -428.7376385}, {-2740, -428.9532818}, {-2741, -429.1396611}, + {-2742, -429.2967315}, {-2743, -429.4250281}, {-2744, -429.5241873}, + {-2745, -429.5944341}, {-2746, -429.6358952}, {-2747, -429.6486157}, + {-2748, -429.6327289}, {-2749, -429.5882461}, {-2750, -429.5153283}, + {-2751, -429.4140299}, {-2752, -429.284449}, {-2753, -429.1266726}, + {-2754, -428.9407894}, {-2755, -428.7268877}, {-2756, -428.485047}, + {-2757, -428.2153711}, {-2758, -427.9179581}, {-2759, -427.5928025}, + {-2760, -427.2402092}, {-2761, -426.8600634}, {-2762, -426.4525022}, + {-2763, -426.0176744}, {-2764, -425.5556313}, {-2765, -425.06645}, + {-2766, -424.5502499}, {-2767, -424.0070906}, {-2768, -423.4369804}, + {-2769, -422.8403237}, {-2770, -422.2168792}, {-2771, -421.5668712}, + {-2772, -420.8903714}, {-2773, -420.1874771}, {-2774, -419.4582879}, + {-2775, -418.7028715}, {-2776, -417.9213825}, {-2777, -417.1137861}, + {-2778, -416.2803019}, {-2779, -415.4209327}, {-2780, -414.5358943}, + {-2781, -413.6251312}, {-2782, -412.6888458}, {-2783, -411.7270655}, + {-2784, -410.7399148}, {-2785, -409.7274847}, {-2786, -408.6898657}, + {-2787, -407.6271404}, {-2788, -406.5394284}, {-2789, -405.4267938}, + {-2790, -404.2893696}, {-2791, -403.1272335}, {-2792, -401.9404474}, + {-2793, -400.7291418}, {-2794, -399.4934088}, {-2795, -398.2333711}, + {-2796, -396.9490299}, {-2797, -395.6405785}, {-2798, -394.308076}, + {-2799, -392.9516177}, {-2800, -391.5713067}, {-2801, -390.1672388}, + {-2802, -388.7395085}, {-2803, -387.2882153}, {-2804, -385.8134491}, + {-2805, -384.3153075}, {-2806, -382.7939005}, {-2807, -381.2493181}, + {-2808, -379.6816558}, {-2809, -378.0910249}, {-2810, -376.4774999}, + {-2811, -374.8412066}, {-2812, -373.1822196}, {-2813, -371.5006566}, + {-2814, -369.7966219}, {-2815, -368.0701723}, {-2816, -366.3214594}, + {-2817, -364.5452255}, {-2818, -362.7575606}, {-2819, -360.9426031}, + {-2820, -359.1057448}, {-2821, -357.2470893}, {-2822, -355.3667934}, + {-2823, -353.4648962}, {-2824, -351.5415439}, {-2825, -349.5967641}, + {-2826, -347.6307086}, {-2827, -345.6435516}, {-2828, -343.6352853}, + {-2829, -341.6060508}, {-2830, -339.5559549}, {-2831, -337.4850931}, + {-2832, -335.3936063}, {-2833, -333.2815078}, {-2834, -331.1489865}, + {-2835, -328.996123}, {-2836, -326.8230136}, {-2837, -324.6297733}, + {-2838, -322.4165006}, {-2839, -320.1832988}, {-2840, -317.9302898}, + {-2841, -315.6575283}, {-2842, -313.365187}, {-2843, -311.0533456}, + {-2844, -308.7221204}, {-2845, -306.3715636}, {-2846, -304.0018428}, + {-2847, -301.6130457}, {-2848, -299.2053149}, {-2849, -296.778661}, + {-2850, -294.3332804}, {-2851, -291.8692554}, {-2852, -289.3867056}, + {-2853, -286.8857231}, {-2854, -284.3664217}, {-2855, -281.8289128}, + {-2856, -279.2733058}, {-2857, -276.6997087}, {-2858, -274.1082124}, + {-2859, -271.4989838}, {-2860, -268.8720998}, {-2861, -266.2276524}, + {-2862, -263.5657728}, {-2863, -260.886575}, {-2864, -258.190162}, + {-2865, -255.4766579}, {-2866, -252.7461647}, {-2867, -249.9987893}, + {-2868, -247.2346697}, {-2869, -244.4539049}, {-2870, -241.6565952}, + {-2871, -238.8428795}, {-2872, -236.0128579}, {-2873, -233.1666485}, + {-2874, -230.3043697}, {-2875, -227.4261255}, {-2876, -224.532046}, + {-2877, -221.6222294}, {-2878, -218.6968306}, {-2879, -215.7559142}, + {-2880, -212.7996108}, {-2881, -209.8280943}, {-2882, -206.8414104}, + {-2883, -203.8397101}, {-2884, -200.8231036}, {-2885, -197.7917191}, + {-2886, -194.745683}, {-2887, -191.6850652}, {-2888, -188.6100502}, + {-2889, -185.5207141}, {-2890, -182.4171986}, {-2891, -179.2996279}, + {-2892, -176.1681099}, {-2893, -173.022772}, {-2894, -169.8637367}, + {-2895, -166.6911266}, {-2896, -163.5050648}, {-2897, -160.3056778}, + {-2898, -157.0930773}, {-2899, -153.8673994}, {-2900, -150.6287617}, + {-2901, -147.3772845}, {-2902, -144.1131245}, {-2903, -140.8363703}, + {-2904, -137.5471599}, {-2905, -134.245623}, {-2906, -130.9318931}, + {-2907, -127.6060709}, {-2908, -124.2683065}, {-2909, -120.9187348}, + {-2910, -117.5574669}, {-2911, -114.1846455}, {-2912, -110.8003821}, + {-2913, -107.4048223}, {-2914, -103.9980925}, {-2915, -100.5803218}, + {-2916, -97.15161443}, {-2917, -93.71218791}, {-2918, -90.26208616}, + {-2919, -86.80147629}, {-2920, -83.33048558}, {-2921, -79.84925152}, + {-2922, -76.35789883}, {-2923, -72.85658119}, {-2924, -69.34540752}, + {-2925, -65.82453605}, {-2926, -62.29409248}, {-2927, -58.75421594}, + {-2928, -55.2050424}, {-2929, -51.64670934}, {-2930, -48.07935375}, + {-2931, -44.50311696}, {-2932, -40.91813601}, {-2933, -37.32455181}, + {-2934, -33.72250329}, {-2935, -30.11213021}, {-2936, -26.49357551}, + {-2937, -22.86698026}, {-2938, -19.23248746}, {-2939, -15.59023879}, + {-2940, -11.94037722}, {-2941, -8.283049528}, {-2942, -4.61839757}, + {-2943, -0.9465667096}, {-2944, 2.732296904}, {-2945, 6.41804652}, + {-2946, 10.11053603}, {-2947, 13.80961679}, {-2948, 17.5151423}, + {-2949, 21.22696456}, {-2950, 24.94493179}, {-2951, 28.66889572}, + {-2952, 32.39870438}, {-2953, 36.13420824}, {-2954, 39.87525524}, + {-2955, 43.62169196}, {-2956, 47.37336545}, {-2957, 51.13012322}, + {-2958, 54.89180698}, {-2959, 58.65827089}, {-2960, 62.42934404}, + {-2961, 66.2048854}, {-2962, 69.98472912}, {-2963, 73.76871333}, + {-2964, 77.55669237}, {-2965, 81.34850243}, {-2966, 85.14397702}, + {-2967, 88.94296449}, {-2968, 92.74528758}, {-2969, 96.55080013}, + {-2970, 100.3593323}, {-2971, 104.170725}, {-2972, 107.9848083}, + {-2973, 111.801418}, {-2974, 115.6203874}, {-2975, 119.4415738}, + {-2976, 123.2647452}, {-2977, 127.0897954}, {-2978, 130.9165312}, + {-2979, 134.7447889}, {-2980, 138.5743905}, {-2981, 142.4051704}, + {-2982, 146.2369521}, {-2983, 150.0695593}, {-2984, 153.902823}, + {-2985, 157.7365695}, {-2986, 161.5706172}, {-2987, 165.404789}, + {-2988, 169.2389147}, {-2989, 173.0727962}, {-2990, 176.9062718}, + {-2991, 180.7391523}, {-2992, 184.5712622}, {-2993, 188.4024214}, + {-2994, 192.2324214}, {-2995, 196.0611014}, {-2996, 199.8882735}, + {-2997, 203.7137417}, {-2998, 207.5373262}, {-2999, 211.3588207}, + {-3000, 215.1780691}}; \ No newline at end of file diff --git a/src/ThermalFunctions/ThermalFunctions.cpp b/src/ThermalFunctions/ThermalFunctions.cpp index 049d5d4b..2f67693f 100644 --- a/src/ThermalFunctions/ThermalFunctions.cpp +++ b/src/ThermalFunctions/ThermalFunctions.cpp @@ -256,7 +256,7 @@ double JbosonInterpolatedLow(const double &x, const int &n, int diff) } else if (diff == 1) { - res = pow(M_PI, 2); + res = pow(M_PI, 2) / 12.0; res += x * (6 * cb - 3) / 96.0; res += -x * log(x) / 16.0; res += -M_PI * sqrt(x) / 4.0; @@ -325,42 +325,42 @@ double JbosonInterpolated(const double &x, int diff) if (x >= C_BosonTheta) { res = JInterpolatedHigh(x, 3, diff); + if (diff == 0) res -= C_BosonShift; } else if (x >= 0) { res = JbosonInterpolatedLow(x, 3, diff); - if (diff == 0) res += C_BosonShift; } - else if (x < 0 and diff == 0) + else if (x < 0) { - res = JbosonInterpolatedNegative(x); + res = JbosonInterpolatedNegative(x, diff); } return res; } -double JbosonInterpolatedNegative(const double &x) +tk::spline JbosonNegativeSpline(NegLinearIntTransposed[0], + NegLinearIntTransposed[1], + tk::spline::cspline, + false, + tk::spline::first_deriv, + -pow(M_PI, 2) / 12, + tk::spline::first_deriv, + 3.816357189); + +double JbosonInterpolatedNegative(const double &x, int diff) { if (x >= 0) return 0; double PotVal = 0; - double xprev, fprev, xnext, fnext; - if (-x >= C_NegLine - 2) + + if (diff == 0) { - xprev = NegLinearInt[C_NegLine - 2][0]; - xnext = NegLinearInt[C_NegLine - 1][0]; - fprev = NegLinearInt[C_NegLine - 2][1]; - fnext = NegLinearInt[C_NegLine - 1][1]; + PotVal = JbosonNegativeSpline(-x) + 3.533375127e-06; } - else + else if (diff == 1) { - std::size_t pos = (std::size_t(-x)); - xprev = NegLinearInt[pos][0]; - fprev = NegLinearInt[pos][1]; - xnext = NegLinearInt[pos + 1][0]; - fnext = NegLinearInt[pos + 1][1]; + PotVal = -JbosonNegativeSpline.deriv(1, -x); } - PotVal = (fnext - fprev) / (xnext - xprev) * (x - xprev) + fprev; - PotVal += C_BosonShift; return PotVal; } diff --git a/src/ThermalFunctions/thermalcoefficientcalculator.cpp b/src/ThermalFunctions/thermalcoefficientcalculator.cpp index 1bebbc70..aa26059a 100644 --- a/src/ThermalFunctions/thermalcoefficientcalculator.cpp +++ b/src/ThermalFunctions/thermalcoefficientcalculator.cpp @@ -1,4 +1,15 @@ +// Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file + */ + #include + namespace BSMPT { namespace ThermalFunctions diff --git a/src/WallThickness/CMakeLists.txt b/src/WallThickness/CMakeLists.txt index 5428b322..a7f7c330 100644 --- a/src/WallThickness/CMakeLists.txt +++ b/src/WallThickness/CMakeLists.txt @@ -1,19 +1,16 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/WallThickness") -set(header - ${header_path}/WallThicknessLib.h - ${header_path}/WallThicknessCommon.h -) -set(src - WallThicknessLib.cpp - WallThickness1D.cpp -) +set(header ${header_path}/WallThicknessLib.h + ${header_path}/WallThicknessCommon.h) +set(src WallThicknessLib.cpp WallThickness1D.cpp) add_library(LibWallThickness ${header} ${src}) -target_link_libraries(LibWallThickness PUBLIC Eigen3::Eigen GSL::gsl Minimizer Utility Boost::boost Threads::Threads) +target_link_libraries( + LibWallThickness PUBLIC Eigen3::Eigen GSL::gsl Minimizer Utility Boost::boost + Threads::Threads) target_include_directories(LibWallThickness PUBLIC ${BSMPT_SOURCE_DIR}/include) -target_compile_features(LibWallThickness PUBLIC cxx_std_14) - +target_compile_features(LibWallThickness PUBLIC cxx_std_17) diff --git a/src/WallThickness/WallThicknessLib.cpp b/src/WallThickness/WallThicknessLib.cpp index 119f07d6..e4fd55aa 100644 --- a/src/WallThickness/WallThicknessLib.cpp +++ b/src/WallThickness/WallThicknessLib.cpp @@ -78,36 +78,39 @@ double calculate_wall_thickness_plane( const std::vector &a_vcritical, std::shared_ptr a_modelPointer, const double &a_Temp, - const int &a_WhichMinimizer) { - while (mDataIndex < a_BasePoints.size()) - { - const auto data = a_BasePoints.at(mDataIndex++); - auto MinimumPlaneResult = Minimizer::MinimizePlane(data.second, - a_vevsymmetric, - a_vcritical, - a_modelPointer, - a_Temp, - a_WhichMinimizer); - { - std::unique_lock lock(mWriteResultLock); - Data_min.at(data.first) = -MinimumPlaneResult.PotVal; - } - } - }; + const int &a_WhichMinimizer) + { + while (mDataIndex < a_BasePoints.size()) + { + const auto data = a_BasePoints.at(mDataIndex++); + auto MinimumPlaneResult = Minimizer::MinimizePlane(data.second, + a_vevsymmetric, + a_vcritical, + a_modelPointer, + a_Temp, + a_WhichMinimizer); + { + std::unique_lock lock(mWriteResultLock); + Data_min.at(data.first) = -MinimumPlaneResult.PotVal; + } + } + }; for (auto &thr : Data_min_threads) { - thr = std::thread([&]() { - thread_Job(DataIndex, - BasePoints, - Data_min_negative, - WriteLock, - vevsymmetric, - vcritical, - modelPointer, - Temp, - WhichMinimizer); - }); + thr = std::thread( + [&]() + { + thread_Job(DataIndex, + BasePoints, + Data_min_negative, + WriteLock, + vevsymmetric, + vcritical, + modelPointer, + Temp, + WhichMinimizer); + }); } for (auto &thr : Data_min_threads) diff --git a/src/baryo_calculation/CMakeLists.txt b/src/baryo_calculation/CMakeLists.txt index 5b7825cf..083a6bb6 100644 --- a/src/baryo_calculation/CMakeLists.txt +++ b/src/baryo_calculation/CMakeLists.txt @@ -1,30 +1,37 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/baryo_calculation") set(header - ${header_path}/transport_equations.h - ${header_path}/Fluid_Type/gen_calc.h - ${header_path}/Fluid_Type/gen_func_fluid.h - ${header_path}/Fluid_Type/top_source.h - ${header_path}/Fluid_Type/bot_source.h - ${header_path}/Fluid_Type/tau_source.h - ${header_path}/CalculateEtaInterface.h -) + ${header_path}/transport_equations.h + ${header_path}/Fluid_Type/gen_calc.h + ${header_path}/Fluid_Type/gen_func_fluid.h + ${header_path}/Fluid_Type/top_source.h + ${header_path}/Fluid_Type/bot_source.h + ${header_path}/Fluid_Type/tau_source.h + ${header_path}/CalculateEtaInterface.h) set(src - transport_equations.cpp - Fluid_Type/gen_calc.cpp - Fluid_Type/gen_func_fluid.cpp - Fluid_Type/top_source.cpp - Fluid_Type/bot_source.cpp - Fluid_Type/tau_source.cpp - CalculateEtaInterface.cpp -) + transport_equations.cpp + Fluid_Type/gen_calc.cpp + Fluid_Type/gen_func_fluid.cpp + Fluid_Type/top_source.cpp + Fluid_Type/bot_source.cpp + Fluid_Type/tau_source.cpp + CalculateEtaInterface.cpp) add_library(Baryo ${header} ${src}) -target_link_libraries(Baryo PUBLIC Eigen3::Eigen GSL::gsl Minimizer Kfactors LibWallThickness Utility Boost::boost) -#target_compile_options(Baryo PUBLIC ${OpenMP_CXX_FLAGS}) +target_link_libraries( + Baryo + PUBLIC Eigen3::Eigen + GSL::gsl + Minimizer + Kfactors + LibWallThickness + Utility + Boost::boost) +# target_compile_options(Baryo PUBLIC ${OpenMP_CXX_FLAGS}) target_include_directories(Baryo PUBLIC ${BSMPT_SOURCE_DIR}/include) -target_compile_features(Baryo PUBLIC cxx_std_14) +target_compile_features(Baryo PUBLIC cxx_std_17) diff --git a/src/baryo_calculation/CalculateEtaInterface.cpp b/src/baryo_calculation/CalculateEtaInterface.cpp index e85e2265..b2b7b073 100644 --- a/src/baryo_calculation/CalculateEtaInterface.cpp +++ b/src/baryo_calculation/CalculateEtaInterface.cpp @@ -96,8 +96,18 @@ CalculateEtaInterface::ReadConfigFile(const std::string &file) const CalculateEtaInterface::CalculateEtaInterface( const std::pair, int> &config) + : CalculateEtaInterface(config, GetSMConstants()) +{ +} + +CalculateEtaInterface::CalculateEtaInterface( + const std::pair, int> &config, + const ISMConstants &smConstants) : method_transport{config.first} + , C_eta(smConstants) , bot_mass_flag{config.second} + , SMConstants{smConstants} + { if (config.first.size() != 5) { @@ -111,14 +121,29 @@ CalculateEtaInterface::CalculateEtaInterface( } CalculateEtaInterface::CalculateEtaInterface(const std::string &file) - : CalculateEtaInterface(ReadConfigFile(file)) + : CalculateEtaInterface(file, GetSMConstants()) +{ +} + +CalculateEtaInterface::CalculateEtaInterface(const std::string &file, + const ISMConstants &smConstants) + : CalculateEtaInterface(ReadConfigFile(file), smConstants) { } CalculateEtaInterface::CalculateEtaInterface( const std::vector &method_input, const int &bot_mass_flag_in) - : CalculateEtaInterface(std::make_pair(method_input, bot_mass_flag_in)) + : CalculateEtaInterface(method_input, bot_mass_flag_in, GetSMConstants()) +{ +} + +CalculateEtaInterface::CalculateEtaInterface( + const std::vector &method_input, + const int &bot_mass_flag_in, + const ISMConstants &smConstants) + : CalculateEtaInterface(std::make_pair(method_input, bot_mass_flag_in), + smConstants) { } @@ -235,7 +260,7 @@ std::vector CalculateEtaInterface::CalcEta() if (method_transport.at(0)) { GSL_integration_mubl_container.set_transport_method(TransportMethod::top); - top_source C_top; + top_source C_top(SMConstants); C_top.set_class(bot_mass_flag, GSL_integration_mubl_container, Calc_Gam_inp, @@ -250,7 +275,7 @@ std::vector CalculateEtaInterface::CalcEta() { GSL_integration_mubl_container.set_transport_method( TransportMethod::bottom); - bot_source C_bot; + bot_source C_bot(SMConstants); C_bot.set_class(bot_mass_flag, GSL_integration_mubl_container, Calc_Gam_inp, @@ -264,7 +289,7 @@ std::vector CalculateEtaInterface::CalcEta() if (method_transport.at(2)) { GSL_integration_mubl_container.set_transport_method(TransportMethod::tau); - tau_source C_tau; + tau_source C_tau(SMConstants); C_tau.set_class(bot_mass_flag, GSL_integration_mubl_container, Calc_Gam_inp, diff --git a/src/baryo_calculation/Fluid_Type/bot_source.cpp b/src/baryo_calculation/Fluid_Type/bot_source.cpp index 350e07a2..6523a822 100644 --- a/src/baryo_calculation/Fluid_Type/bot_source.cpp +++ b/src/baryo_calculation/Fluid_Type/bot_source.cpp @@ -19,6 +19,14 @@ namespace Baryo typedef runge_kutta_cash_karp54 error_stepper_type; typedef controlled_runge_kutta controlled_stepper_type; +bot_source::bot_source() : bot_source(GetSMConstants()) +{ +} + +bot_source::bot_source(const ISMConstants &smConstants) : gen_fluid(smConstants) +{ +} + void bot_source::operator()(const state_type &omega, state_type &domega, const double z) @@ -46,11 +54,13 @@ void bot_source::operator()(const state_type &omega, // TOP and BOT quark mass calculation top_func(z, quark_mass, quark_mass_prime); double mt = quark_mass[0]; - double mb; + double mb{0}; // BOTTOM quark mass can be set to zero to have a crosscheck - if (bot_mass_flag == 1) mb = quark_mass[1]; - if (bot_mass_flag == 2) mb = 0; - if ((bot_mass_flag != 1) and (bot_mass_flag != 2)) + if (bot_mass_flag == 1) + mb = quark_mass[1]; + else if (bot_mass_flag == 2) + mb = 0; + else throw std::runtime_error("No valid option for the bottom mass @ ()"); // Phase Calculation @@ -165,7 +175,7 @@ double bot_source::Calc_nL(double z_start, double z_end) const mu = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; const double C_AbsErr = 1e-9; const double C_RelErr = 1e-5; - double stepsize_initial; + double stepsize_initial{0}; if (z_start < z_end) stepsize_initial = 1e-8; if (z_start > z_end) stepsize_initial = -1e-8; double abs_err = C_AbsErr; diff --git a/src/baryo_calculation/Fluid_Type/gen_calc.cpp b/src/baryo_calculation/Fluid_Type/gen_calc.cpp index 2f5af99a..bcad60e0 100644 --- a/src/baryo_calculation/Fluid_Type/gen_calc.cpp +++ b/src/baryo_calculation/Fluid_Type/gen_calc.cpp @@ -1,5 +1,6 @@ // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later diff --git a/src/baryo_calculation/Fluid_Type/gen_func_fluid.cpp b/src/baryo_calculation/Fluid_Type/gen_func_fluid.cpp index d1cb35d1..7dd427db 100644 --- a/src/baryo_calculation/Fluid_Type/gen_func_fluid.cpp +++ b/src/baryo_calculation/Fluid_Type/gen_func_fluid.cpp @@ -17,14 +17,6 @@ namespace BSMPT { namespace Baryo { -/** - * @brief C_AbsErr Absolute tolerance for boost::integrate_adaptive - */ -const double C_AbsErr = 1e-6; -/** - * @brief C_RelErr Relative tolerance for boost::integrate_adaptive - */ -const double C_RelErr = 1e-9; void Calc_Gam_M::operator()(const state_type &Gam, state_type &dGam, @@ -281,6 +273,15 @@ void Calc_eta::operator()(const state_type &eta, std::exp(exponent_prefactor * z); // prefactor is not used here for numerical stability } + +Calc_eta::Calc_eta() : Calc_eta(GetSMConstants()) +{ +} + +Calc_eta::Calc_eta(const ISMConstants &smConstants) : SMConstants{smConstants} +{ +} + void Calc_eta::set_class(std::vector array_z_in, std::vector array_nL_in, double Temp_in, @@ -309,13 +310,13 @@ void Calc_eta::set_class(std::vector array_z_in, // SIMPLIFIED EXPRESSION // prefactor = -3*GamWS/(2*vw*s_entr); // exponent_prefactor = -R*GamWS/vw; - double t0, h; + double t0{0}, h{0}; if (array_z.at(0) < array_z.at(array_z.size() - 1)) { t0 = array_z.at(0); h = array_z.at(1) - array_z.at(0); } - if (array_z.at(0) > array_z.at(array_z.size() - 1)) + else if (array_z.at(0) > array_z.at(array_z.size() - 1)) { t0 = array_z.at(array_z.size() - 1); h = array_z.at(0) - array_z.at(1); @@ -351,13 +352,13 @@ void Calc_eta::set_class( // SIMPLIFIED EXPRESSION // prefactor = -3*GamWS/(2*vw*s_entr); // exponent_prefactor = -R*GamWS/vw; - double t0, h; + double t0{0}, h{0}; if (array_z.at(0) < array_z.at(array_z.size() - 1)) { t0 = array_z.at(0); h = array_z.at(1) - array_z.at(0); } - if (array_z.at(0) > array_z.at(array_z.size() - 1)) + else if (array_z.at(0) > array_z.at(array_z.size() - 1)) { t0 = array_z.at(array_z.size() - 1); h = array_z.at(0) - array_z.at(1); @@ -385,6 +386,18 @@ double Nintegrate_eta(const Calc_eta &C_eta, return C_eta.prefactor * eta[0]; } +gen_fluid::gen_fluid() : gen_fluid(GetSMConstants()) +{ +} + +gen_fluid::gen_fluid(const ISMConstants &smConstants) + : SMConstants{smConstants} + , mtop_0{smConstants.C_MassTop} + , mbot_0{smConstants.C_MassBottom} + , mtau_0{smConstants.C_MassTau} +{ +} + void gen_fluid::top_func(double z, std::vector &m_quark, std::vector &m_quark_prime) @@ -588,12 +601,12 @@ void gen_fluid::set_class(const int bottom_mass_inp, gen_fluid::Dtau = 100. / Temp; double sinbeta = std::sin(std::atan(tanbeta)); double cosbeta = std::cos(std::atan(tanbeta)); - gen_fluid::yuk_q = std::sqrt(2) * mtop_0 / (C_vev0 * sinbeta); + gen_fluid::yuk_q = std::sqrt(2) * mtop_0 / (SMConstants.C_vev0 * sinbeta); gen_fluid::Gam_SS = 14 * std::pow(alphaS, 4) * Temp; double yuk_t = 0, yuk_b = 0, yuk_tau = 0; // top thermal mass - yuk_t = std::sqrt(2) * mtop_0 / (C_vev0 * sinbeta); + yuk_t = std::sqrt(2) * mtop_0 / (SMConstants.C_vev0 * sinbeta); auto top_thermal = Calc_ThermalMass_q(yuk_t, Temp); msqrt_thermal_top = top_thermal.first; dmsqrt_thermal_top = top_thermal.second; @@ -601,24 +614,24 @@ void gen_fluid::set_class(const int bottom_mass_inp, if (Yuk_Type == 1) { // bot&tau thermal mass - yuk_b = std::sqrt(2) * mbot_0 / (C_vev0 * sinbeta); + yuk_b = std::sqrt(2) * mbot_0 / (SMConstants.C_vev0 * sinbeta); auto bot_thermal = Calc_ThermalMass_q(yuk_b, Temp); msqrt_thermal_bot = bot_thermal.first; dmsqrt_thermal_bot = bot_thermal.second; - yuk_tau = std::sqrt(2) * mtau_0 / (C_vev0 * sinbeta); + yuk_tau = std::sqrt(2) * mtau_0 / (SMConstants.C_vev0 * sinbeta); auto tau_thermal = Calc_ThermalMass_l(yuk_tau, Temp); msqrt_thermal_tau = tau_thermal.first; dmsqrt_thermal_tau = tau_thermal.second; } if (Yuk_Type == 2) { - yuk_b = std::sqrt(2) * mbot_0 / (C_vev0 * cosbeta); + yuk_b = std::sqrt(2) * mbot_0 / (SMConstants.C_vev0 * cosbeta); auto bot_thermal = Calc_ThermalMass_q(yuk_b, Temp); msqrt_thermal_bot = bot_thermal.first; dmsqrt_thermal_bot = bot_thermal.second; - yuk_tau = std::sqrt(2) * mtau_0 / (C_vev0 * cosbeta); + yuk_tau = std::sqrt(2) * mtau_0 / (SMConstants.C_vev0 * cosbeta); auto tau_thermal = Calc_ThermalMass_l(yuk_tau, Temp); msqrt_thermal_tau = tau_thermal.first; dmsqrt_thermal_tau = tau_thermal.second; diff --git a/src/baryo_calculation/Fluid_Type/tau_source.cpp b/src/baryo_calculation/Fluid_Type/tau_source.cpp index 60cb6d22..07ef059a 100644 --- a/src/baryo_calculation/Fluid_Type/tau_source.cpp +++ b/src/baryo_calculation/Fluid_Type/tau_source.cpp @@ -19,6 +19,14 @@ namespace Baryo typedef runge_kutta_cash_karp54 error_stepper_type; typedef controlled_runge_kutta controlled_stepper_type; +tau_source::tau_source() : tau_source(GetSMConstants()) +{ +} + +tau_source::tau_source(const ISMConstants &smConstants) : gen_fluid(smConstants) +{ +} + void tau_source::operator()(const state_type &omega, state_type &domega, const double z) @@ -52,19 +60,23 @@ void tau_source::operator()(const state_type &omega, // TOP and BOT quark mass calculation top_func(z, quark_mass, quark_mass_prime); double mt = quark_mass[0]; - double mb; - if (bot_mass_flag == 1) mb = quark_mass[1]; - if (bot_mass_flag == 2) mb = 0; - if ((bot_mass_flag != 1) and (bot_mass_flag != 2)) + double mb{0}; + if (bot_mass_flag == 1) + mb = quark_mass[1]; + else if (bot_mass_flag == 2) + mb = 0; + else throw std::runtime_error("No valid mbot mass flag is chosen. Please make " "sure to chose a proper value"); // TAU mass calculation std::vector tau_mass, tau_mass_prime; tau_func(z, tau_mass, tau_mass_prime); - double mtau; - if (tau_mass_flag == 1) mtau = tau_mass[0]; - if (tau_mass_flag == 2) mtau = 0; - if ((tau_mass_flag != 1) and (tau_mass_flag != 2)) + double mtau{0}; + if (tau_mass_flag == 1) + mtau = tau_mass[0]; + else if (tau_mass_flag == 2) + mtau = 0; + else throw std::runtime_error("No valid mtau mass flag is chosen. Please make " "sure to chose a proper value"); @@ -222,9 +234,11 @@ double tau_source::Calc_nL(double z_start, double z_end) const mu = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; const double C_AbsErr = 1e-9; const double C_RelErr = 1e-5; - double stepsize_initial; - if (z_start < z_end) stepsize_initial = 1e-8; - if (z_start > z_end) stepsize_initial = -1e-8; + double stepsize_initial{0}; + if (z_start < z_end) + stepsize_initial = 1e-8; + else + stepsize_initial = -1e-8; double abs_err = C_AbsErr; double rel_err = C_RelErr; integrate_adaptive(make_controlled(abs_err, rel_err, error_stepper_type()), diff --git a/src/baryo_calculation/Fluid_Type/top_source.cpp b/src/baryo_calculation/Fluid_Type/top_source.cpp index 37c9ae21..edf9b324 100644 --- a/src/baryo_calculation/Fluid_Type/top_source.cpp +++ b/src/baryo_calculation/Fluid_Type/top_source.cpp @@ -1,5 +1,6 @@ // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -17,6 +18,14 @@ namespace Baryo typedef runge_kutta_cash_karp54 error_stepper_type; typedef controlled_runge_kutta controlled_stepper_type; +top_source::top_source() : top_source(GetSMConstants()) +{ +} + +top_source::top_source(const ISMConstants &smConstants) : gen_fluid(smConstants) +{ +} + double top_source::Calc_nL(double z_start, double z_end) const { /* @@ -33,9 +42,11 @@ double top_source::Calc_nL(double z_start, double z_end) const mu = {0, 0, 0, 0, 0, 0, 0, 0}; const double C_AbsErr = 1e-9; const double C_RelErr = 1e-5; - double stepsize_initial; - if (z_start < z_end) stepsize_initial = 1e-8; - if (z_start > z_end) stepsize_initial = -1e-8; + double stepsize_initial{0}; + if (z_start < z_end) + stepsize_initial = 1e-8; + else + stepsize_initial = -1e-8; double abs_err = C_AbsErr; double rel_err = C_RelErr; integrate_adaptive(make_controlled(abs_err, rel_err, error_stepper_type()), @@ -68,14 +79,14 @@ void top_source::operator()(const state_type &omega, theta_vec[1]; // derivative of the phase factor of the top quark // Calculation of kappa_t Calc_kappa_obj.set_class(Temp, mt); - double num_int = NIntegrate_kappa(Calc_kappa_obj); - double kappa_q = kappa_QL_0 * num_int; // left-handed kappa + double num_int = NIntegrate_kappa(Calc_kappa_obj); + double kappa_q = kappa_QL_0 * num_int; // left-handed kappa double kappa_tR = kappa_QR_0 * num_int; // right-handed kappa // Rescaled chemical potential like in 1811.11104 double mu_M = (omega[1] / kappa_tR - omega[0] / kappa_q); double bR = -(omega[1] + omega[0]); // local baryon conservation used to - // expresse the right-handed b density + // expresse the right-handed b density double mu_SS = 2 * omega[0] / kappa_q - omega[1] / kappa_tR - bR / kappa_QR_0; double mu_Y = omega[1] / kappa_tR - omega[0] / kappa_q - omega[2] / kappa_H_0 - omega[3] / kappa_H_0; diff --git a/src/bounce_solution/CMakeLists.txt b/src/bounce_solution/CMakeLists.txt new file mode 100644 index 00000000..ed43c8f0 --- /dev/null +++ b/src/bounce_solution/CMakeLists.txt @@ -0,0 +1,15 @@ +# SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, +# João Viana +# +# SPDX-License-Identifier: GPL-3.0-or-later + +set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/bounce_solution") +set(header ${header_path}/bounce_solution.h ${header_path}/action_calculation.h) + +set(src bounce_solution.cpp action_calculation.cpp) + +add_library(BounceSolution ${header} ${src}) +target_link_libraries(BounceSolution PUBLIC Eigen3::Eigen GSL::gsl Minimizer + Utility MinimumTracer) +target_include_directories(BounceSolution PUBLIC ${BSMPT_SOURCE_DIR}/include) +target_compile_features(BounceSolution PUBLIC cxx_std_14) diff --git a/src/bounce_solution/action_calculation.cpp b/src/bounce_solution/action_calculation.cpp new file mode 100644 index 00000000..b1fd1ebb --- /dev/null +++ b/src/bounce_solution/action_calculation.cpp @@ -0,0 +1,1797 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file + */ + +#include +#include + +namespace BSMPT +{ + +BounceActionInt::BounceActionInt() +{ +} + +BounceActionInt::BounceActionInt( + std::vector> InitPath_In, + std::vector TrueVacuum_In, + std::vector FalseVacuum_In, + std::function)> &V_In, + std::function(std::vector)> &dV_In, + double T_In, + int MaxPathIntegrations_In) +{ + // Initialization of the class when the derivative is provided + this->dim = InitPath_In.at(0).size(); + this->Vfalse = V_In(FalseVacuum_In); + this->V = [&](std::vector vev) { return V_In(vev) - this->Vfalse; }; + this->dV = dV_In; + this->Hessian = [=](auto const &arg) + { return HessianNumerical(arg, V_In, this->eps); }; + this->TrueVacuum = TrueVacuum_In; + this->FalseVacuum = FalseVacuum_In; + this->InitPath = InitPath_In; + this->T = T_In; + this->MaxPathIntegrations = MaxPathIntegrations_In; + // Set Spline path + SetPath(InitPath_In); +} + +BounceActionInt::BounceActionInt( + std::vector> InitPath_In, + std::vector TrueVacuum_In, + std::vector FalseVacuum_In, + std::function)> &V_In, + double T_In, + int MaxPathIntegrations_In) +{ + // Initialization of the class when the derivative is not provided + this->dim = InitPath_In.at(0).size(); + this->Vfalse = V_In(FalseVacuum_In); + this->V = [&](std::vector vev) { return V_In(vev) - this->Vfalse; }; + // Use numerical derivative + this->dV = [=](auto const &arg) + { return NablaNumerical(arg, this->V, this->eps); }; + this->Hessian = [=](auto const &arg) + { return HessianNumerical(arg, V_In, this->eps); }; + this->TrueVacuum = TrueVacuum_In; + this->FalseVacuum = FalseVacuum_In; + this->InitPath = InitPath_In; + this->T = T_In; + this->MaxPathIntegrations = MaxPathIntegrations_In; + // Set Spline path + SetPath(InitPath_In); +} + +void BounceActionInt::SetPath(std::vector> InitPath_In) +{ + // Method to be called when the path is changed manually + this->Path = InitPath_In; + // Find minimums near the initial and last position + + this->Spline = cvspline(this->Path); + this->Path = Spline.phipath; + + if (V(InitPath_In.front()) > V(InitPath_In.back())) + { + std::stringstream ss; + ss << "-----------------------------------------------\n"; + ss << "Error with new path with length\t" << Spline.L << "\n"; + ss << "V(TrueVacuum) = " << V(InitPath_In.front()) << "\n"; + ss << "V(FalseVacuum) = " << V(InitPath_In.back()) << "\n"; + ss << "V(TrueVacuum) > V(FalseVacuum) < ---- This cannot be! Path might " + "be backwards\n"; + ss << "-----------------------------------------------\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + } + + // Rasterize dVdl + RasterizedVdl(); +} + +void BounceActionInt::RasterizedVdl(double l_start) +{ + // This method is used to calculate all dVdl before hand. Otherwise the code + // will probably slow down + std::vector l_temp, dVdl_temp; + + for (int it = 0; it <= 1000; it++) + { + l_temp.push_back(l_start + it / 1000.0 * (Spline.L - l_start)); + dVdl_temp.push_back(Calc_dVdl(l_temp.back())); + } + // Set the not-a-knot boundary conditions + RasterizeddVdl.set_boundary( + tk::spline::not_a_knot, 0.0, tk::spline::not_a_knot, 0.0); + RasterizeddVdl.set_points(l_temp, dVdl_temp); +} + +void BounceActionInt::PrintVector(std::vector vec) +{ + std::stringstream ss; + ss << std::setprecision(15) << "["; + for (double i : vec) + ss << i << " "; + ss << "]"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); +} + +std::vector +BounceActionInt::NormalForce(const double &l, + const double &dldrho, + const std::vector &gradient) +{ + std::vector r; // Result + std::vector d2phidl2 = Spline.d2l(l); // d2Phi/dl2 + std::vector dphidl = + Spline.dl(l); // dPhi/dl which norm is 1 (needed to calculate the + // perpendicular component) + r = std::pow(dldrho, 2) * d2phidl2 - + (gradient - (gradient * dphidl) * dphidl); + + return r; +} + +std::vector +BounceActionInt::NormalForceBernstein(const double &dldrho, + const std::vector &gradient, + const std::vector &dphidl, + const std::vector &d2phidl2) +{ + std::vector r; // Result + r = std::pow(dldrho, 2) * d2phidl2 - + (gradient - (gradient * dphidl) * dphidl); + + return r; +} + +double BounceActionInt::d2ldrho2(double l, double rho, double dldrho) +{ + if (dldrho == 0) // This is stupid, we should take a manual Runge-Kutta step + { + return (RasterizeddVdl(l)); + } + return (RasterizeddVdl(l) - Alpha * dldrho / rho); +} + +void BounceActionInt::AuxFunctionDev(const double &rho, + const std::vector &dvs, + std::vector &aks) +{ + // Array of the derivatives + // Auxiliary function for the Runge Kutta 5 order method + aks = {dvs[1], d2ldrho2(dvs[0], rho, dvs[1])}; + return; +} + +void BounceActionInt::RK5_step(const std::vector &y, + const std::vector &dydx, + int n, + float rho, + float h, + std::vector &yout, + std::vector &yerr) +{ + int i; + + double a2 = 0.2, a3 = 0.3, a4 = 0.6, a5 = 1.0, a6 = 0.875, b21 = 0.2, + b31 = 3.0 / 40.0, b32 = 9.0 / 40.0, b41 = 0.3, b42 = -0.9, b43 = 1.2, + b51 = -11.0 / 54.0, b52 = 2.5, b53 = -70.0 / 27.0, b54 = 35.0 / 27.0, + b61 = 1631.0 / 55296.0, b62 = 175.0 / 512.0, b63 = 575.0 / 13824.0, + b64 = 44275.0 / 110592.0, b65 = 253.0 / 4096.0, c1 = 37.0 / 378.0, + c3 = 250.0 / 621.0, c4 = 125.0 / 594.0, c6 = 512.0 / 1771.0, + dc5 = -277.00 / 14336.0; + double dc1 = c1 - 2825.0 / 27648.0, dc3 = c3 - 18575.0 / 48384.0, + dc4 = c4 - 13525.0 / 55296.0, dc6 = c6 - 0.25; + + std::vector ak2(2); + std::vector ak3(2); + std::vector ak4(2); + std::vector ak5(2); + std::vector ak6(2); + std::vector ytemp(2); + ytemp = std::vector(2); + + // First step. + for (i = 0; i < n; i++) + ytemp[i] = y[i] + b21 * h * dydx[i]; + this->AuxFunctionDev(rho + a2 * h, ytemp, ak2); + // Second step. + for (i = 0; i < n; i++) + ytemp[i] = y[i] + h * (b31 * dydx[i] + b32 * ak2[i]); + this->AuxFunctionDev(rho + a3 * h, ytemp, ak3); + // Third step. + for (i = 0; i < n; i++) + ytemp[i] = y[i] + h * (b41 * dydx[i] + b42 * ak2[i] + b43 * ak3[i]); + this->AuxFunctionDev(rho + a4 * h, ytemp, ak4); + // Fourth step. + for (i = 0; i < n; i++) + ytemp[i] = + y[i] + h * (b51 * dydx[i] + b52 * ak2[i] + b53 * ak3[i] + b54 * ak4[i]); + this->AuxFunctionDev(rho + a5 * h, ytemp, ak5); + // Fifth step. + for (i = 0; i < n; i++) + ytemp[i] = y[i] + h * (b61 * dydx[i] + b62 * ak2[i] + b63 * ak3[i] + + b64 * ak4[i] + b65 * ak5[i]); + this->AuxFunctionDev(rho + a6 * h, ytemp, ak6); + // Sixth step. + for (i = 0; i < n; i++) // Accumulate increments with proper weights. + yout[i] = + y[i] + h * (c1 * dydx[i] + c3 * ak3[i] + c4 * ak4[i] + c6 * ak6[i]); + for (i = 0; i < n; i++) + yerr[i] = h * (dc1 * dydx[i] + dc3 * ak3[i] + dc4 * ak4[i] + dc5 * ak5[i] + + dc6 * ak6[i]); + return; +} + +double BounceActionInt::BesselI(double alpha, double x, int terms) +{ + // This implementation seems to converge quite quicly + // https://en.wikipedia.org/wiki/Bessel_function#:~:text=Modified%20Bessel%20functions%3A%20I%CE%B1%2C%20K%CE%B1%5B,first%20and%20second%20kind%20and%20are%20defined%20as%5B19%5D + double r0 = 1e100; + double r = 0; + int m = 0; + while ((m < terms) && (abs((r - r0) / r) > 1e-15)) + { + r0 = r; // Save step + r += 1 / (tgamma(m + alpha + 1) * tgamma(m + 1)) * + std::pow(x / 2.0, 2.0 * m + alpha); // One more term + m++; // Update later to not mess up summation + } + return r; +} + +double BounceActionInt::BesselJ(double x, int terms) +{ + // This implementation seems to converge quite quicly + // https://en.wikipedia.org/wiki/Bessel_function#:~:text=Modified%20Bessel%20functions%3A%20I%CE%B1%2C%20K%CE%B1%5B,first%20and%20second%20kind%20and%20are%20defined%20as%5B19%5D + double r0 = 1e100; + double r = 0; + int m = 0; + while ((m < terms) && (abs((r - r0) / r) > 1e-15)) + { + r0 = r; // Save step + r += 1 / (tgamma(m + 2.) * tgamma(m + 1)) * std::pow(-1, m) * + std::pow(x / 2.0, 2.0 * m + 1.); // One more term + m++; // Update later to not mess up summation + } + return r; +} + +std::vector BounceActionInt::ExactSolutionFromMinimum(double l) +{ + double rho_down = 1e-100; + double rho_up = 1; + double rho_middle = 0; + std::function LinearSolution, LinearSolutionDerivative; + + TrueVacuumHessian = Calc_d2Vdl2(Initial_lmin); // Sanity check + if (Alpha == 2) + { + LinearSolution = [=](const double rho_in) + { + return l - (Initial_lmin + l0_minus_lmin * + sinh(sqrt(TrueVacuumHessian) * rho_in) / + (sqrt(TrueVacuumHessian) * rho_in)); + }; + LinearSolutionDerivative = [=](const double rho_in) + { + return ((l0_minus_lmin * cosh(rho_in * std::sqrt(TrueVacuumHessian))) / + rho_in) - + (l0_minus_lmin * sinh(rho_in * std::sqrt(TrueVacuumHessian))) / + (pow(rho_in, 2) * std::sqrt(TrueVacuumHessian)); + }; + } + + // T = 0 + if (Alpha == 3) + { + LinearSolution = [=](const double rho_in) + { + return l - + (Initial_lmin + 2 * l0_minus_lmin * + BesselI(1, sqrt(TrueVacuumHessian) * rho_in) / + (sqrt(TrueVacuumHessian) * rho_in)); + }; + LinearSolutionDerivative = [=](const double rho_in) + { + return ( + (2 * l0_minus_lmin * BesselI(2, rho_in * sqrt(TrueVacuumHessian))) / + rho_in); + }; + } + + // Check if lower limit is viable + assert(LinearSolution(rho_down) > 0); + + // Check if upper limit is viable + while (LinearSolution(rho_up) > 0 and rho_up < 100) + { + // This is always possible + rho_up += 1; + } + + // Do binary search + int cc = 0; // For safety + while (rho_up - rho_down > 1e-10 and cc < 150) + { + rho_middle = (rho_up + rho_down) / 2; + if (LinearSolution(rho_middle) > 0) + { + rho_down = rho_middle; + } + else + { + rho_up = rho_middle; + } + cc++; + } + return {rho_middle, l, LinearSolutionDerivative(rho_middle)}; +} + +std::vector BounceActionInt::ExactSolutionLin(double l0, + double l, + double dVdl, + double d2Vdl2) +{ + // Numerical solution of equation of motion with V'(phi) = dVdl + (phi - + // phi0) * d2Vdl2 + std::stringstream ss; + double nu = (Alpha - 1.0) / 2.0; // To keep things tidy + double Abs_d2Vdl2 = abs(d2Vdl2); + double Sign_d2Vdl2 = (d2Vdl2 > 0) - (d2Vdl2 < 0); // Sign(d2Vdl2) + double rho_down = 1e-100; + double rho_middle = 0; + double rho_up = 1; + std::function LinearSolution, LinearSolutionDerivative; + + // Set maximum values that rho can have + if (Alpha == 2 and d2Vdl2 > 0) + { + rho_up = 1; + } + else if (Alpha == 2 and d2Vdl2 < 0) + { + // Maximum value in oscillatory behaviour 4.493409457909 is the solution of + // tan(x) = x + rho_up = 4.493409457909 / std::sqrt(Abs_d2Vdl2); + } + else if (Alpha == 3 and d2Vdl2 > 0) + { + rho_up = 1; + } + else if (Alpha == 3 and d2Vdl2 < 0) + { + // Maximum value in oscillatory behaviour 5.13562230184068 is the solution + // for BesselJ[0, x] - (2 BesselJ[1, x])/x - BesselJ[2, x] + rho_up = 5.13562230184068 / std::sqrt(Abs_d2Vdl2); + } + // Write difference of l(rho) - l0 + // Goal is to find zero of this function + if (Alpha == 2 and d2Vdl2 > 0) + { + LinearSolution = [=](const double rho_in) + { + return l - (l0 - dVdl / d2Vdl2 + + Sign_d2Vdl2 * dVdl * sinh(sqrt(Abs_d2Vdl2) * rho_in) / + (pow(Abs_d2Vdl2, 1.5) * rho_in)); + }; + LinearSolutionDerivative = [=](const double rho_in) + { + return (dVdl * cosh(sqrt(d2Vdl2) * rho_in)) / (d2Vdl2 * rho_in) - + (dVdl * sinh(sqrt(d2Vdl2) * rho_in)) / + (pow(d2Vdl2, 1.5) * std::pow(rho_in, 2)); + }; + } + else if (Alpha == 2 and d2Vdl2 < 0) + { + LinearSolution = [=](const double rho_in) + { + return l - (l0 - dVdl / d2Vdl2 + + Sign_d2Vdl2 * dVdl * sin(sqrt(Abs_d2Vdl2) * rho_in) / + (pow(Abs_d2Vdl2, 1.5) * rho_in)); + }; + + LinearSolutionDerivative = [=](const double rho_in) + { + return -((dVdl * cos(sqrt(Abs_d2Vdl2) * rho_in)) / + (Abs_d2Vdl2 * rho_in)) + + (dVdl * sin(sqrt(Abs_d2Vdl2) * rho_in)) / + (pow(Abs_d2Vdl2, 1.5) * std::pow(rho_in, 2)); + }; + } + else if (Alpha == 3 and d2Vdl2 > 0) + { + LinearSolution = [=](const double rho_in) + { + return l - (l0 - dVdl / d2Vdl2 + + 2 * dVdl * BesselI(nu, std::sqrt(d2Vdl2) * rho_in) / + (pow(d2Vdl2, 1.5) * rho_in)); + }; + LinearSolutionDerivative = [=](const double rho_in) + { + return (-2 * dVdl * BesselI(1, std::sqrt(d2Vdl2) * rho_in)) / + (pow(d2Vdl2, 1.5) * std::pow(rho_in, 2)) + + (dVdl * (BesselI(0, std::sqrt(d2Vdl2) * rho_in) + + BesselI(2, std::sqrt(d2Vdl2) * rho_in))) / + (d2Vdl2 * rho_in); + }; + } + else if (Alpha == 3 and d2Vdl2 < 0) + { + LinearSolution = [=](const double rho_in) + { + return l - (l0 - dVdl / d2Vdl2 - + 2 * dVdl * BesselJ(sqrt(Abs_d2Vdl2) * rho_in) / + (pow(Abs_d2Vdl2, 1.5) * rho_in)); + }; + LinearSolutionDerivative = [=](const double rho_in) + { + // We used numerical derivative here because Bessel function J are not + // completely implemented + return ( + -(LinearSolution(rho_in + 0.001) - LinearSolution(rho_in - 0.001)) / + (0.002)); + }; + } + else + { + ss << "An error occured, Alpha must be 2 or 3 (Alpha = D - 1), instead " + "Alpha is \t" + << Alpha << "\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + double small_step = 1e-5; + return { + small_step, l0 + small_step * small_step * dVdl / 2, small_step * dVdl}; + } + + // Check if lower limit is viable + if (LinearSolution(rho_down) < 0) + { + ss << "Error in\t(LinearSolution(rho_down) < 0)\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + double small_step = 1e-5; + return { + small_step, l0 + small_step * small_step * dVdl / 2, small_step * dVdl}; + } + + // Check if upper limit is viable + // If d2Vdl2 then there is a possibility that there is no solution + if (d2Vdl2 < 0) + { + if (LinearSolution(rho_up) > 0) + { + // TODO + ss << "Error in\t(LinearSolution(rho_up) < 0). Call function again with " + "smaller argument\n"; + ss << rho_up << "\t" << l << "\t" << dVdl << "\t" << d2Vdl2 << "\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + if (abs((l - l0) / Spline.L) < 1e-10) + { + // Maximum numerical precision reached. + StateOfBounceActionInt = ActionStatus::Integration1DFailed; + // Abort calculation + return {0, 0, 0}; + } + return (ExactSolutionLin(l0, l0 + (l - l0) / 10., dVdl, d2Vdl2)); + } + } + else + { + // In this case we can solve the problem of the limit + int counter = 0; + while (LinearSolution(rho_up) > 0 and counter < 100) + { + counter++; + // This is always possible + rho_up += 1; + } + } + // Do binary search + int cc = 0; // For safety + while (rho_up - rho_down > 1e-10 and cc < 150) + { + rho_middle = (rho_up + rho_down) / 2; + if (LinearSolution(rho_middle) > 0) + { + rho_down = rho_middle; + } + else + { + rho_up = rho_middle; + } + cc++; + } + return {rho_middle, l, LinearSolutionDerivative(rho_middle)}; +} + +double BounceActionInt::Calc_dVdl(double l) +{ + // Function to calculate dV/dl + return dV(Spline(l)) * Spline.dl(l); +} + +double BounceActionInt::Calc_d2Vdl2(double l) +{ + // Function to calculate d2V/dl2 + return (dV(Spline(l)) * Spline.d2l(l)) + + ((Hessian(Spline(l)) * Spline.dl(l)) * Spline.dl(l)); +} + +double BounceActionInt::LogisticFunction(const double &x) +{ + if (x >= 10) return 1; + if (x <= -10) return 0; + return 1 / (1 + exp(-x)); +} + +void BounceActionInt::CalculateExactSolutionThreshold(double MinError) +{ + double NumberOfSteps = 1000; + double Error, l0, l, inital_exponent, final_exponent; + + std::vector MinSol, LinSol; + inital_exponent = log((Spline.L - Initial_lmin) / 100.) - + 10; // Search from 4e-7% spline path + final_exponent = + log((Spline.L - Initial_lmin) / 100.); // Search until 10% spline path + + for (double exponent = inital_exponent; exponent <= final_exponent; + exponent += (final_exponent - inital_exponent) / NumberOfSteps) + { + l0_minus_lmin = exp(exponent); + l0 = Initial_lmin + l0_minus_lmin; + l = l0 + Spline.L * FractionOfThePathExact; + MinSol = ExactSolutionFromMinimum(l); + LinSol = ExactSolutionLin(l0, l, Calc_dVdl(l0), Calc_d2Vdl2(l0)); + Error = 0.5 * + abs((LinSol.at(0) - MinSol.at(0)) / (LinSol.at(0) + MinSol.at(0))); + if (Error < MinError) + { + // Found a better ExactSolutionThreshold + MinError = Error; + ExactSolutionThreshold = l0_minus_lmin; + } + } + + if (MinError > 1e-2) // Error not small enough + { + if (FractionOfThePathExact <= 1e-4) return; + FractionOfThePathExact /= 10.; + CalculateExactSolutionThreshold(MinError); + } +} +std::vector BounceActionInt::ExactSolution(double l0) +{ + // FractionOfThePathExact = 1e-5; + // Solving FractionOfThePathExact of the path + double l = l0 + Spline.L * FractionOfThePathExact; + // Computing the second derivative of the potential beforehand + double d2Vdl2 = Calc_d2Vdl2(l0); + // dVdl + double dVdl = Calc_dVdl(l0); + + std::stringstream ss; + + // In the case Backwards propagation failed we use only the Linear Solution + if (not ExactSolutionThreshold.has_value()) + return ExactSolutionLin(l0, l, dVdl, d2Vdl2); + + if (dVdl <= 0) + { + // Assume negative grad is numerical error if close to the true minimum + if (l0_minus_lmin / Spline.L < 1e-2) return ExactSolutionFromMinimum(l); + // If we are not close to the minimum then probably l0 in not a solution as + // it will roll backwards + ss << " \n l = " << l0 << std::endl; + ss << " dVdl = " << dVdl << std::endl; + ss << " d2Vd2l = " << d2Vdl2 << std::endl; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + StateOfBounceActionInt = ActionStatus::UndershootOvershootNegativeGrad; + return {}; + } + + std::vector MinSol = ExactSolutionFromMinimum(l); + std::vector LinSol = ExactSolutionLin(l0, l, dVdl, d2Vdl2); + + // Calculate the LogisticExponent which indicates the contribution from both + // branches + double LogisticExponent = 100 * + (l0_minus_lmin - ExactSolutionThreshold.value()) / + (ExactSolutionThreshold.value() - Initial_lmin); + + // If the contribution is too close to 0 or 1 we assume only a single type of + // solution. The protects the code againts NANs from the LinSol when + // the gradient is negative due to numerical instabilities. + if (LogisticFunction(-LogisticExponent) == 1) return MinSol; + if (LogisticFunction(LogisticExponent) == 1) return LinSol; + + // Interpolate between both solution at ExactSolutionThreshold) + std::vector MinLinInterpolated = LinSol; + + MinLinInterpolated.at(0) = MinSol.at(0) * LogisticFunction(-LogisticExponent); + MinLinInterpolated.at(0) += LinSol.at(0) * LogisticFunction(LogisticExponent); + MinLinInterpolated.at(2) = MinSol.at(2) * LogisticFunction(-LogisticExponent); + MinLinInterpolated.at(2) += LinSol.at(2) * LogisticFunction(LogisticExponent); + + return MinLinInterpolated; +} + +void BounceActionInt::IntegrateBounce(double l0, + UndershootOvershootStatus &conv, + std::vector &rho, + std::vector &l, + std::vector &dl_drho, + std::vector &d2l_drho2, + int maxiter, + double error, + double eps_abs, + double max_step) +{ + std::stringstream ss; + // Integrate the bounce equation with x(rho) = "x0" until dx/drho < 0 + // (undershoot) or x(rho) > L (overshoot) or + // converges + double L = Spline.L; + double step; // Integration step + std::vector ExactSol = ExactSolution(l0); + + if (StateOfBounceActionInt != ActionStatus::NotCalculated) return; + + rho = {0, ExactSol.at(0)}; // Initial integration value for abcissas + l = {l0, ExactSol.at(1)}; // Guess for the bounce solution + dl_drho = {0, ExactSol.at(2)}; // Initial derivative = 0 + d2l_drho2 = {d2ldrho2(l0, 0, 0)}; + d2l_drho2.push_back(d2ldrho2(l.back(), rho.back(), dl_drho.back())); + step = rho.back() / 100; + + std::vector next_l_dldrho( + 2); // Save "l" and "dldrho" from the Runge-Kutta 5th order step. + std::vector err( + 2); // Save error from the "l" and "dldrho" Runge-Kutta 5th order + // step, used to upgrade the step size. + + double delta0; // Wanted precision + double delta1; // Step precision + int it; // Counter + + for (it = 0; + (it < maxiter) && + (((dl_drho.back() > error) && ((l.back() - L) / L < error)) || it < 5); + it++) // Take at least 3 steps (due to dldrho < 0 due to numerical + // errors) + { + RK5_step({l.back(), dl_drho.back()}, + {dl_drho.back(), d2l_drho2.back()}, + 2, + rho.back(), + step, + next_l_dldrho, + err); + + delta1 = std::max(abs(err[0]), abs(err[1])); + delta0 = eps_abs * std::max(abs(l.back() + next_l_dldrho[0]), + abs(dl_drho.back() + next_l_dldrho[1])); + + // Update step list + rho.push_back(rho.back() + step); + l.push_back(next_l_dldrho[0]); + dl_drho.push_back(next_l_dldrho[1]); + d2l_drho2.push_back(d2ldrho2(l.back(), rho.back(), dl_drho.back())); + + if (max_step > 0) + { + step = std::min((step * std::pow(delta0 / delta1, 0.2)), max_step); + } + else + { + step = step * std::pow(delta0 / delta1, 0.2) / 2; + } + } + if ((abs(dl_drho.back()) <= error) && (abs(l.back() - L) / L <= error)) + { + ss << "Converged\t" << it << "\t" << l0 << "\t" << rho.back() << "\t" + << l.back() << "\t" << dl_drho.back(); + conv = UndershootOvershootStatus::Converged; + } + else if (dl_drho.back() <= error) + { + ss << "Undershoot\t" << it << "\t" << l0 << "\t" << rho.back() << "\t" + << l.back() << "\t" << dl_drho.back(); + rho.pop_back(); + l.pop_back(); + dl_drho.pop_back(); + d2l_drho2.pop_back(); + conv = UndershootOvershootStatus::Undershoot; + UndershotOnce = true; + } + else if ((l.back() - L) / L >= error) + { + ss << "Overshoot\t" << it << "\t" << l0 << "\t" << rho.back() << "\t" + << l.back() << "\t" << dl_drho.back(); + conv = UndershootOvershootStatus::Overshoot; + OvershotOnce = true; + } + else + { + // This shouldnt happen + conv = UndershootOvershootStatus::Overshoot; + } + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); +} + +void BounceActionInt::BackwardsPropagation() +{ + std::stringstream ss; + // Backwards propagation starting point finder + double l0 = 0; + double l00 = 1e100; + for (int i = 0; i < 100; i++) + { + l00 = l0; + l0 -= Calc_dVdl(l0) / Calc_d2Vdl2(l0); + if (abs((l0 - l00) / Spline.L) < 1e-8 and Calc_d2Vdl2(l0) > 0 and + l0 <= Spline.L / 100) + { + // Calculate the threshold between linear solution and solution from + // minimum + CalculateExactSolutionThreshold(); + Initial_lmin = l0; + return; + } + } + ss << "Backwards propagation did not work...\t" << l0 + << "\t using minus gradient method instead\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + + // Restart the loop without the second derivative. + l0 = 0; + for (int i = 0; i < 1000; i++) + { + l00 = l0; + l0 -= Calc_dVdl(l0) / 100; + if (abs((l0 - l00) / Spline.L) < 1e-8 and Calc_d2Vdl2(l0) > 0 and + l0 <= Spline.L / 100) + { + // Calculate the threshold between linear solution and solution from + // minimum + CalculateExactSolutionThreshold(); + Initial_lmin = l0; + return; + } + } + ss << "Backwards propagation not converging\t" << l0 + << "\t using minus 0.1% Spline length as backwards propagation\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ExactSolutionThreshold + .reset(); // Use always the linear solution in exact solution + Initial_lmin = -1 * Spline.L / 1000.0; + return; +} + +void BounceActionInt::Solve1DBounce( + std::vector &rho, + std::vector &l, + std::vector &dl_drho, + std::vector &d2l_drho2, + double error, + int maxiter) // Alpha = 2 at T > 0 and Alpha = 3 at T = 0 +{ + + std::stringstream ss; + // Method to solve the bounce ODE + double lmin, l0, lmax, L; + UndershootOvershootStatus conv; // Converged? + L = Spline.L; + + BackwardsPropagation(); + RasterizedVdl(Initial_lmin); // Update rasterized dVdl + lmin = this->Initial_lmin; // Lower interval + lmax = L; // Uppter interval + ss << "Backwards propagation : \t" << lmin << "\t" << Calc_dVdl(lmin) << "\t" + << Calc_d2Vdl2(lmin) << "\n"; + if (ExactSolutionThreshold.has_value()) + { + ss << "l_threshold =\t" << ExactSolutionThreshold.value() << "\n"; + } + else + { + ss << "l_threshold was not been calculated\n"; + } + + if (V(Spline(lmin)) > V(Spline(lmax))) + { + ss << "Backwards propagation produced V(lmin) > V(L). Abort."; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + StateOfBounceActionInt = ActionStatus::BackwardsPropagationFailed; + return; + } + TrueVacuumHessian = Calc_d2Vdl2(lmin); + int j = 0; + int resolution = 1000; + while (j < resolution) + { + // This procedure is done such that the allowed search intervals goes + // from true VEV up to the point where potential becomes lower than + // Vfalse. This method does not focus on speed. This method allows for + // only one solution to the bounce equation in this interval. + j++; + if (V(Spline(lmin + (L - lmin) * double(j) / double(resolution))) > 0) + { + lmax = lmin + (L - lmin) * double(j) / double(resolution); + break; + } + if (Calc_dVdl((L - lmin) * double(j) / double(resolution)) < 0) + { + lmax = lmin + (L - lmin) * double(j) / double(resolution); + break; + } + } + + ss << "Upper limit : l = \t" << lmax + << "\t | V(l = 0) - V(TrueVacuum) = " << V(Spline(lmax)) - V(TrueVacuum) + << "\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + + StateOf1DIntegration = Integration1DStatus::NotConverged; + + UndershotOnce = false; + OvershotOnce = false; + + l0 = (lmax + lmin) / 2.0; // Perform binary search + + // mu ~= log(l0 - lmin) + double mu_min = -200; + double mu_max = log(lmax - lmin); + double mu_middle = (mu_min + mu_max) / 2; + + int mode = 0; // Binary search. 0 = linear, 1 = log + for (int i = 0; i < maxiter; i++) + { + if (mode == 0) + { + l0 = (lmax + lmin) / 2.0; // Perform binary search + l0_minus_lmin = l0 - Initial_lmin; + IntegrateBounce( + l0, conv, rho, l, dl_drho, d2l_drho2, 100000, error, error * 0.0015); + if (StateOfBounceActionInt != ActionStatus::NotCalculated) return; + if (rho.size() <= 7) + { + ss << "rho\t = "; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + PrintVector(rho); + ss << "l\t = "; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + PrintVector(l); + ss << "dl_drho\t = "; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + PrintVector(dl_drho); + ss << "d2l_drho2\t = "; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + PrintVector(d2l_drho2); + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "dVdl\t = " + std::to_string(Calc_dVdl(l0))); + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "d2Vdl2\t = " + std::to_string(Calc_d2Vdl2(l0))); + ss << "\n Overshoot/Undershoot method failed!\t"; + StateOf1DIntegration = Integration1DStatus::NotConverged; + StateOfBounceActionInt = ActionStatus::Integration1DFailed; + break; + } + if (conv == UndershootOvershootStatus::Converged) // Solved! + { + ss << "\nFound Solution!\t" << l0 << " in\t" << i << "\titerations."; + StateOf1DIntegration = Integration1DStatus::Converged; + break; + } + if ((lmax - lmin) / L < error * 0.0000001) + { + // A solution was found + if (OvershotOnce == true) + { + ss << "\nConverged due to proximity!\t" << l0 << "\t" + << " in\t" << i << "\titerations.\t" + << "\t" << (abs(dl_drho.back())) << "\t" + << "\t" << (abs(l.back() - L) / L); + StateOf1DIntegration = Integration1DStatus::Converged; + break; + } + // Method never overshot. Switch to log scale + mode = 1; + mu_max = log(lmax - lmin) + 2; // Give some margin for the binary search + } + if (conv == UndershootOvershootStatus::Undershoot) // Undershoot! + { + lmax = double(l0); + } + if (conv == UndershootOvershootStatus::Overshoot) // Overshoot! + { + lmin = double(l0); + } + } + if (mode == 1) + { + mu_middle = (mu_min + mu_max) / 2; + l0_minus_lmin = exp(mu_middle); + l0 = Initial_lmin + l0_minus_lmin; // Perform binary search in log space + + IntegrateBounce( + l0, conv, rho, l, dl_drho, d2l_drho2, 100000, error, error * 0.0015); + if (StateOfBounceActionInt != ActionStatus::NotCalculated) return; + if (rho.size() <= 7) + { + ss << "rho\t = "; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + PrintVector(rho); + ss << "l\t = "; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + PrintVector(l); + ss << "dl_drho\t = "; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + PrintVector(dl_drho); + ss << "d2l_drho2\t = "; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + PrintVector(d2l_drho2); + ss << "\n Overshoot/Undershoot method failed!\t"; + + StateOf1DIntegration = Integration1DStatus::NotConverged; + StateOfBounceActionInt = ActionStatus::Integration1DFailed; + break; + } + if (conv == UndershootOvershootStatus::Converged) // Solved! + { + ss << "\nFound Solution!\t" << l0 << " in\t" << i << "\titerations."; + StateOf1DIntegration = Integration1DStatus::Converged; + break; + } + if (abs(mu_max - mu_min) < 0.0000001) + { + ss << "\nConverged due to proximity!\t" << l0 << "\t" + << " in\t" << i << "\titerations.\t" + << "\t" << (abs(dl_drho.back())) << "\t" + << "\t" << (abs(l.back() - L) / L); + StateOf1DIntegration = Integration1DStatus::Converged; + break; + } + if (conv == UndershootOvershootStatus::Undershoot) // Undershoot! + { + mu_max = mu_middle; + } + if (conv == UndershootOvershootStatus::Overshoot) // Overshoot! + { + mu_min = mu_middle; + } + } + } + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); +} + +double BounceActionInt::Bernstein(int n, int nu, double x) +{ + std::stringstream ss; + // Implementation of Bernstein polynomials + // https://en.wikipedia.org/wiki/Bernstein_polynomial#:~:text=In%20the%20mathematical%20field%20of,named%20after%20Sergei%20Natanovich%20Bernstein. + if (nu < 0 || nu > n) + { + return 0; + } + if (x < 0 || x > 1.0001) + { + ss << "Incorrect argument in Bernstein polynomial ->\t" << x; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + } + return (nChoosek(n, nu) * pow(x, nu) * pow(1 - x, n - nu)); +} + +double BounceActionInt::ReductorCalculator(const double &MaximumGradient) +{ + { + return MaximumGradient / (Spline.L); + }; +} + +bool BounceActionInt::PathDeformationCheck(std::vector &l, + tk::spline &rho_l_spl) +{ + std::stringstream ss; + // First try at path deformation a + // Calculate the 1D bounce and then deform the knots until normal force + // vanishes Problems: + // -> Cubic splines are too unstable so some smoothing algorithm has to + // be used + + std::vector gradient(dim, 0); + std::vector force(dim, 0); + + double delta = (l.back() - l.front()) / + (10 * NumberPathKnots); // Difference between to knots + double np = l.front(); // Start of the new path + double MaximumForce = 0; // Save maximum force + double PerpendicularGradient = 0; // Save maximum perpendicular gradient + double MaximumGradient = 0; // Save maximum gradient + double MaximumRelativeError = 0; // Save maximum force relative to gradient + double Maximum_dldrho = 0; // Save maximum dl/drho + std::vector phi; // Temporary variables for calculating force + + // Creates new list of knots for the new Spline, that then are going to + // be moved with a force + for (np = l.front() + delta; np <= l.back() - delta / 10.0; np += delta) + { + phi = Spline(np); // New knot on the splind + gradient = dV(phi); // Grandient of knot + force = NormalForce(np, + 1 / rho_l_spl.deriv(1, np), + gradient); // Calculate force in the knot + + Maximum_dldrho = std::max(Maximum_dldrho, 1 / rho_l_spl.deriv(1, np)); + + PerpendicularGradient = std::max( + PerpendicularGradient, L2NormVector(NormalForce(np, 0, gradient))); + + MaximumGradient = + std::max(MaximumGradient, + L2NormVector(gradient)); // Calculate maximum gradient + MaximumForce = std::max(MaximumForce, + L2NormVector(force)); // Calculates maximum force + MaximumRelativeError = std::max( + MaximumRelativeError, + L2NormVector(force) / + L2NormVector(gradient)); // Calculate maximum force relative + // to gradient on that point + } + + ss << "----------------\t Path deformation check\t----------------\n"; + + double reductor = ReductorCalculator(MaximumGradient); + + ss << "\nMaximmum dl/drho\t" << Maximum_dldrho << "\n"; + ss << "Maximmum gradient\t" << MaximumGradient << "\n"; + ss << "Maximmum perpendicular gradient\t" << PerpendicularGradient << "\n"; + ss << "Maximmum force\t" << MaximumForce << "\n"; + ss << "Maximmum relative error\t" << MaximumRelativeError << "\n"; + ss << "Reductor is\t" << reductor << "\n"; + ss << "Spline length is\t" << Spline.L << "\n"; + // ss << "{" << Maximum_dldrho << ", " << PerpendicularGradient << ", " + // << MaximumGradient << ", " << Spline.L << ", " << reductor << "}\n"; + + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + + // Check for convergence! + + if (MaximumRelativeError < 0.05) + { + // It converged! + StateOfPathDeformation = PathDeformationStatus::Converged; + ss << "Everything went well. Path deformation converged!\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + return true; + } + return false; +} + +void BounceActionInt::SinglePathDeformation( + double &stepsize, + double &reductor, + std::vector &l, + tk::spline &rho_l_spl, + std::vector &l_fornextpath, + std::vector> &best_path, + std::vector> &next_path, + double &MaximumGradient, + double &MaximumForce, + double &MaximumRelativeError, + double &Maximum_dldrho, + double &PerpendicularGradient, + MatrixXd &inverseK, + std::vector> &forces) +{ + double stepIncrease = 1.5; + double stepDecrease = 5.; + double reverseCheck = .15; + double maxstep = .1; + double minstep = 1e-4; + + std::vector temp_phi(dim, 0); + std::vector temp_dphi(dim, 0); + std::vector temp_d2phi(dim, 0); + std::vector gradient(dim, 0); + std::vector force(dim, 0); + std::vector BernsteinCoefficients(dim); + + double l_to_Bernstein, np; + // Save initial and final parameterization + double l0 = l.front(); + double lf = l.back(); + // Difference between to knots to calculate Bernstein kernel + // Transposes the path of differences + double delta = (lf - l0) / 300; + std::vector> transposed_next_path = + BSMPT::Transpose(next_path); + std::vector> last_forces = forces; + + for (int d = 0; d < dim; d++) + { + // Calculation of the Bernstein Spline coefficient + tk::spline next_path_spline(l_fornextpath, transposed_next_path[d]); + std::vector IntegralVector(BernsteinDegree, 0); + for (int b_it = 0; b_it < BernsteinDegree; b_it++) + { + for (np = l0; np <= lf - delta / 10.0; np += delta) + { + IntegralVector[b_it] = + IntegralVector[b_it] + + Bernstein(BernsteinDegree, b_it, (np - l0) / (lf - l0)) * + next_path_spline(np); + IntegralVector[b_it] = + IntegralVector[b_it] + + 4 * + Bernstein( + BernsteinDegree, b_it, (np + delta / 2 - l0) / (lf - l0)) * + next_path_spline(np + delta / 2); + IntegralVector[b_it] = + IntegralVector[b_it] + + Bernstein(BernsteinDegree, b_it, (np + delta - l0) / (lf - l0)) * + next_path_spline(np + delta); + } + } + + // Normalization in Simpson Integration + IntegralVector = (delta / 6) * IntegralVector; + + // Converts into eigenvector + Eigen::VectorXd EigenIntegralVector = + Eigen::Map(IntegralVector.data(), + IntegralVector.size()); + + // Solves K s = b + BernsteinCoefficients[d] = inverseK * EigenIntegralVector; + + for (int it_path = 0; it_path < NumberPathKnots; it_path++) + { + double temp = 0; + for (int b_it = 0; b_it < BernsteinDegree; b_it++) + { + temp += Bernstein(BernsteinDegree, + b_it, + (l_fornextpath[it_path] - l0) / (lf - l0)) * + BernsteinCoefficients[d](b_it); + } + next_path[it_path][d] = temp; + } + } + + double oldMaximumGradient = MaximumGradient; + double oldMaximumForce = MaximumForce; + double oldMaximumRelativeError = MaximumRelativeError; + double oldMaximum_dldrho = Maximum_dldrho; + double oldPerpendicularGradient = PerpendicularGradient; + + MaximumGradient = 0; + MaximumForce = 0; + MaximumRelativeError = 0; + Maximum_dldrho = 0; + PerpendicularGradient = 0; + + forces.clear(); + + for (int it_path = 0; it_path < NumberPathKnots; it_path++) + { + l_to_Bernstein = (l_fornextpath[it_path] - l0) / (lf - l0); + + std::fill(temp_phi.begin(), temp_phi.end(), 0); + std::fill(temp_dphi.begin(), temp_dphi.end(), 0); + std::fill(temp_d2phi.begin(), temp_d2phi.end(), 0); + + for (int d = 0; d < dim; d++) + { + for (int b_it = 0; b_it < BernsteinDegree; b_it++) + { + temp_phi[d] += Bernstein(BernsteinDegree, b_it, l_to_Bernstein) * + BernsteinCoefficients[d](b_it); + temp_dphi[d] += + BernsteinDegree * + (Bernstein(BernsteinDegree - 1, b_it - 1, l_to_Bernstein) - + Bernstein(BernsteinDegree - 1, b_it, l_to_Bernstein)) * + BernsteinCoefficients[d](b_it) / (lf - l0); + temp_d2phi[d] += + BernsteinDegree * (BernsteinDegree - 1) * + (Bernstein(BernsteinDegree - 2, b_it - 2, l_to_Bernstein) - + 2 * Bernstein(BernsteinDegree - 2, b_it - 1, l_to_Bernstein) + + Bernstein(BernsteinDegree - 2, b_it, l_to_Bernstein)) * + BernsteinCoefficients[d](b_it) / std::pow(lf - l0, 2); + } + } + + gradient = dV(FalseVacuum + temp_phi); + force = NormalForceBernstein(1 / rho_l_spl.deriv(1, l_fornextpath[it_path]), + gradient, + temp_dphi, + temp_d2phi); + + forces.push_back(force); + + next_path[it_path] = next_path[it_path] + force / reductor; + + Maximum_dldrho = std::max(Maximum_dldrho, + 1 / rho_l_spl.deriv(1, l_fornextpath[it_path])); + + PerpendicularGradient = std::max( + PerpendicularGradient, + L2NormVector(NormalForceBernstein(0, gradient, temp_dphi, temp_d2phi))); + + MaximumGradient = + std::max(MaximumGradient, + L2NormVector(gradient)); // Calculate maximum gradient + MaximumForce = std::max(MaximumForce, + L2NormVector(force)); // Calculates maximum force + /*MaximumRelativeError = std::max( + MaximumRelativeError, + L2NormVector(force) / + L2NormVector(gradient)); // Calculate maximum force relative + // to gradient on that point*/ + MaximumRelativeError = MaximumForce / MaximumGradient; + } + + // Convergence check + + std::vector reverser(forces.size(), 0); + + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "Path deformation error (before " + "integrating): " + + std::to_string(MaximumRelativeError)); + + if (oldMaximumRelativeError > MaximumRelativeError) + { + best_path = next_path; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "Next best path found with error: " + + std::to_string(MaximumRelativeError)); + } + else + { + MaximumGradient = oldMaximumGradient; + MaximumForce = oldMaximumForce; + MaximumRelativeError = oldMaximumRelativeError; + Maximum_dldrho = oldMaximum_dldrho; + PerpendicularGradient = oldPerpendicularGradient; + } + + // Update stepsize + // Calculates fraction of forces that switches direction betweeen iteration + // It this fraction is too big, the stepsize gets reduced , otherwise it + // gets increased + if (last_forces.size() > 0) + { + std::transform(forces.begin(), + forces.end(), + last_forces.begin(), + reverser.begin(), + [](std::vector &a, std::vector &b) + { return a * b < 0; }); + if (std::accumulate(reverser.begin(), reverser.end(), 0.0) > + forces.size() * reverseCheck) + { + next_path = best_path; + stepsize /= stepDecrease; + } + else + { + stepsize *= stepIncrease; + } + stepsize = std::min(stepsize, maxstep); + stepsize = std::max(stepsize, minstep); + } + + last_forces = forces; +} + +void BounceActionInt::PathDeformation(std::vector &l, + tk::spline &rho_l_spl) +{ + // First try at path deformation a + // Calculate the 1D bounce and then deform the knots until normal force + // vanishes Problems: + // -> Cubic splines are too unstable so some smoothing algorithm has to + // be used + // -> Smoothing algorithm always spoils, in some way, the solution + + double reductor; // Computed factor to reduce the force + int NoBestPathCounter = 0; + + double stepsize = 2e-5; + double SatisfactoryError = 0.05; // Maximum relative error which we consider a + // success (we must still integrate again) + + double delta = + (l.back() - l.front()) / NumberPathKnots; // Difference between to knots + + double oldMaximumRelativeError; + double MaximumForce = 0; // Save maximum force + double MaximumGradient = 0; // Save maximum gradient + double PerpendicularGradient = 0; // Save maximum perpendicular gradient + double Maximum_dldrho = 0; // Save maximum dl/drho + double MaximumRelativeError = + 1e100; // Save maximum force relative to gradient + std::vector phi, l_fornextpath; + std::vector> next_path, old_path, transposed_next_path, + best_path, last_forces, forces; // Next iteration path + std::vector gradient(dim, 0); + std::vector force(dim, 0); + + // Converting into Berenstein Basis! + // Initialize K matrix + // K_ij = int_0^1 Bi(x)Bj(x) dx + MatrixXd K = MatrixXd::Zero(BernsteinDegree, BernsteinDegree); + for (int i = 0; i < BernsteinDegree; i++) + { + for (int j = 0; j < BernsteinDegree; j++) + { + K(i, j) = + (l.back() - l.front()) * double(nChoosek(BernsteinDegree, i)) * + nChoosek(BernsteinDegree, j) / + (nChoosek(2 * BernsteinDegree, i + j) * (2 * BernsteinDegree + 1)); + } + } + MatrixXd inverseK = K.inverse(); + + // Creates new list of knots for the new Spline, that then are going to + // be moved with a force + for (double np = l.front(); np <= l.back() - delta / 10.0; np += delta) + { + phi = Spline(np); // New knot on the splind + best_path.push_back(phi - FalseVacuum); // Add point to list + l_fornextpath.push_back(np); // Save the parameter for each point + gradient = dV(phi); // Grandient of knot + force = NormalForce(np, + 1 / rho_l_spl.deriv(1, np), + gradient); // Calculate force in the knot + + Maximum_dldrho = std::max(Maximum_dldrho, 1 / rho_l_spl.deriv(1, np)); + + PerpendicularGradient = std::max( + PerpendicularGradient, L2NormVector(NormalForce(np, 0, gradient))); + + MaximumGradient = + std::max(MaximumGradient, + L2NormVector(gradient)); // Calculate maximum gradient + MaximumForce = std::max(MaximumForce, + L2NormVector(force)); // Calculates maximum force + MaximumRelativeError = std::max( + MaximumRelativeError, + L2NormVector(force) / + L2NormVector(gradient)); // Calculate maximum force relative + // to gradient on that point + } + + phi = FalseVacuum; // Last point + best_path.push_back(phi - FalseVacuum); // Add last point to list + l_fornextpath.push_back(Spline.L); // Save the parameter for each point + old_path = best_path; // Save path in the case "oh no" happens + next_path = best_path; // Starting path if the last iteration + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "----------------\tPath deformation\t----------------"); + for (int it_maxpath = 0; it_maxpath < MaxSinglePathDeformations; it_maxpath++) + { + NoBestPathCounter++; + reductor = ReductorCalculator(MaximumGradient) / stepsize; + + oldMaximumRelativeError = MaximumRelativeError; + + SinglePathDeformation(stepsize, + reductor, + l, + rho_l_spl, + l_fornextpath, + best_path, + next_path, + MaximumGradient, + MaximumForce, + MaximumRelativeError, + Maximum_dldrho, + PerpendicularGradient, + inverseK, + forces); + + if (MaximumRelativeError != oldMaximumRelativeError) NoBestPathCounter = 0; + + if (MaximumRelativeError < SatisfactoryError) + { + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "Enough convergence!\t" + + std::to_string(MaximumRelativeError)); + + PathDeformationConvergedWithout1D = true; + break; + } + if (MaximumRelativeError > 5) break; // Things went very wrong + if (NoBestPathCounter > 20) + break; // Algorithm does not seem to find new best paths + } + + // Reshift all point to their correct locations + if (best_path.size() == 0) + { + StateOfBounceActionInt = ActionStatus::PathDeformationCrashed; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "Path deformation exploded"); + return; + } + else if (MaximumRelativeError > SatisfactoryError) + { + BSMPT::Logger::Write( + BSMPT::LoggingLevel::BounceDetailed, + "Maximum iterations reached without error increasing. Integrate " + "again!\n"); + } + + for (int it_path = 0; it_path <= NumberPathKnots; it_path++) + { + best_path[it_path] = FalseVacuum + best_path[it_path]; + } + // Change the class path into the new path + SetPath(best_path); + + return; +} + +unsigned BounceActionInt::nChoosek(unsigned n, unsigned k) +{ + // Auxiliary function to calculate n choose k combination + if (k > n) return 0; + if (k * 2 > n) k = n - k; + if (k == 0) return 1; + + int result = n; + for (std::size_t i = 2; i <= k; ++i) + { + result *= (n - i + 1); + result /= i; + } + return result; +} + +double +BounceActionInt::CalculateKineticTermAction(const std::vector &rho, + const tk::spline &dl_drho_spl) +{ + double integral = 0; + double int_delta = rho[rho.size() - 1] / 2000; + if (Alpha == 2) + { + for (double r = 0.0; r <= rho[rho.size() - 1]; r += int_delta) + { + // Simpson Integration (1 + 4 + 1)/ 6 * step + integral += r * r * (0.5 * std::pow(dl_drho_spl(r), 2)); + integral += + 4 * r * r * (0.5 * std::pow(dl_drho_spl(r + int_delta / 2.0), 2)); + integral += r * r * (0.5 * std::pow(dl_drho_spl(r + int_delta), 2)); + } + integral = integral * 4 * M_PI * int_delta / + 6.0; // Angular integration and Simpson step + return integral; + } + else if (Alpha == 3) + { + for (double r = 0.0; r <= rho[rho.size() - 1]; r += int_delta) + { + // Simpson Integration (1 + 4 + 1)/ 6 * step + integral += r * r * r * (0.5 * std::pow(dl_drho_spl(r), 2)); + integral += + 4 * r * r * r * (0.5 * std::pow(dl_drho_spl(r + int_delta / 2.0), 2)); + integral += r * r * r * (0.5 * std::pow(dl_drho_spl(r + int_delta), 2)); + } + integral = integral * 2 * M_PI * M_PI * int_delta / + 6.0; // Angular integration and Simpson step + return integral; + } + return -1; +} + +double +BounceActionInt::CalculatePotentialTermAction(const std::vector &rho, + const tk::spline &l_rho_spl) +{ + double integral = 0; + double int_delta = rho[rho.size() - 1] / 2000; + if (Alpha == 2) + { + for (double r = 0.0; r <= rho[rho.size() - 1]; r += int_delta) + { + // Simpson Integration (1 + 4 + 1)/ 6 * step + integral += r * r * (V(Spline(l_rho_spl(r)))); + integral += 4 * r * r * (V(Spline(l_rho_spl(r + int_delta / 2.0)))); + integral += r * r * (V(Spline(l_rho_spl(r + int_delta)))); + } + integral = integral * 4 * M_PI * int_delta / + 6.0; // Angular integration and Simpson step + return integral; + } + else if (Alpha == 3) + { + for (double r = 0.0; r <= rho[rho.size() - 1]; r += int_delta) + { + // Simpson Integration (1 + 4 + 1)/ 6 * step + integral += r * r * r * (V(Spline(l_rho_spl(r)))); + integral += 4 * r * r * r * (V(Spline(l_rho_spl(r + int_delta / 2.0)))); + integral += r * r * r * (V(Spline(l_rho_spl(r + int_delta)))); + } + integral = integral * 2 * M_PI * M_PI * int_delta / + 6.0; // Angular integration and Simpson step + return integral; + } + return -1; +} + +void BounceActionInt::CalculateAction( + double error) // Alpha = 2 at T > 0 and Alpha = 3 at T = 0 +{ + std::stringstream ss; + if (Calc_d2Vdl2(Spline.L) < 0) + { + StateOfBounceActionInt = ActionStatus::FalseVacuumNotMinimum; + ss << "False vacuum is not a minimum!\n"; + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + return; + } + + std::vector rho; // List of rho + std::vector l; // List of l(rho) + std::vector dl_drho; // List of d^x/drho(rho) + std::vector d2l_drho2; // List of d2^x/drho2(rho) + + tk::spline rho_l_spl; // Spline to find rho as a function of l + tk::spline l_rho_spl; // Spline to find l as a function of rho + tk::spline dl_drho_l_spl; // Spline to find dldrho as a function of l + tk::spline dl_drho_spl; // Spline to find dldrho as a function of rho + tk::spline d2l_drho2_spl; // Spline to find d2ldrho2 as a function of rho + + std::vector force, originalforce; + + StateOf1DIntegration = + Integration1DStatus ::NotConverged; // Know if a solution was found + StateOfPathDeformation = + PathDeformationStatus::NotConverged; // To record if path deformation + // converged or not + + if (dim > 1) // If dim = 0 then we only need the solution for the 1D + // bounce equation + { + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "--------------------------------\t1\t----------------" + "-----------------"); + // Solves 1D bounce equation + Solve1DBounce(rho, l, dl_drho, d2l_drho2, error); + + if (StateOfBounceActionInt != ActionStatus::NotCalculated) return; + + if (rho.size() < 4) + { + if (rho.size() < 4) + StateOfBounceActionInt = ActionStatus::NotEnoughPointsForSpline; + // actions is less than 1 in case of an error. Abort + // calculation + Spline.print_path(); + return; + } + // Checks if convergence was met + rho_l_spl.set_points(l, rho); + l_rho_spl.set_points(rho, l); + dl_drho_spl.set_points(rho, dl_drho); + PathDeformationCheck(l, rho_l_spl); + // Save solution + rho_sol = rho; + l_sol = l; + dldrho_sol = dl_drho; + // Checks if convergence was met + + for (int i = 2; + i <= MaxPathIntegrations and + StateOfPathDeformation == PathDeformationStatus::NotConverged; + i++) + { + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + ss.str(std::string()); + if (UndershotOnce == false and Action >= -1) + { + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "Method never undershot. Terrible news!"); + StateOfBounceActionInt = ActionStatus::NeverUndershootOvershoot; + } + if (OvershotOnce == false and Action >= -1) + { + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "Method never overshot. Terrible news!"); + StateOfBounceActionInt = ActionStatus::NeverUndershootOvershoot; + } + + if (StateOfBounceActionInt != ActionStatus::NotCalculated) + { + // actions is less than 1 in case of an error. Abort + // calculation + Spline.print_path(); + return; + } + + if (rho.size() < 4) + { + // Not enough point to populate the Spline + StateOfBounceActionInt = ActionStatus::NotEnoughPointsForSpline; + Spline.print_path(); + return; + } + rho_l_spl.set_points(l, rho); + l_rho_spl.set_points(rho, l); + dl_drho_spl.set_points(rho, dl_drho); + d2l_drho2_spl.set_points(rho, d2l_drho2); + dl_drho_l_spl.set_points(l, dl_drho); + + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "--------------------------------\t" + + std::to_string(i) + + "\t---------------------------------\n"); + // Deform path + PathDeformation(l, rho_l_spl); + + // Solves 1D bounce equation + Solve1DBounce(rho, + l, + dl_drho, + d2l_drho2, + error); // Solves bounce equation + + if (UndershotOnce == false and Action >= -1) + { + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "Method never undershot. Terrible news!"); + StateOfBounceActionInt = ActionStatus::NeverUndershootOvershoot; + } + if (OvershotOnce == false and Action >= -1) + { + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "Method never overshot. Terrible news!"); + StateOfBounceActionInt = ActionStatus::NeverUndershootOvershoot; + } + if (StateOfBounceActionInt != ActionStatus::NotCalculated) + { + // actions is less than 1 in case of an error. Abort + // calculation + Spline.print_path(); + return; + } + + // Path deformation converged + if (PathDeformationConvergedWithout1D) + { + // Save solution + StateOfPathDeformation = PathDeformationStatus::Converged; + rho_sol = rho; + l_sol = l; + dldrho_sol = dl_drho; + break; + } + + // Checks if convergence was met + if (PathDeformationCheck(l, rho_l_spl)) + { + // Save solution + rho_sol = rho; + l_sol = l; + dldrho_sol = dl_drho; + break; + } + + if (StateOfPathDeformation == PathDeformationStatus::Converged) + { + // PathDeformation Converged! + break; + } + + if (StateOf1DIntegration == Integration1DStatus ::NotConverged) + { + StateOfBounceActionInt = + ActionStatus::Integration1DFailed; // Undershoot/overshoot failed. + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + } + + if (StateOfBounceActionInt != ActionStatus::NotCalculated) + { + // actions is less than 1 in case of an error. Abort + // calculation + Spline.print_path(); + return; + } + } + if (StateOfPathDeformation == PathDeformationStatus::NotConverged) + { + StateOfBounceActionInt = + ActionStatus::PathDeformationNotConverged; // Path deformation did not + // converged in time. + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + return; + } + } + else + { + // Path deformation in not necessary + Solve1DBounce(rho, + l, + dl_drho, + d2l_drho2, + error); // Solves bounce equation once + } + + if (StateOf1DIntegration == Integration1DStatus::NotConverged) + { + StateOfBounceActionInt = + ActionStatus::Integration1DFailed; // No solution was found. + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + return; + } + + rho_l_spl.set_points(l, rho); + l_rho_spl.set_points(rho, l); + dl_drho_spl.set_points(rho, dl_drho); + + double KineticPart = CalculateKineticTermAction(rho, dl_drho_spl); + double KineticAction = + 2 * KineticPart / + (1 + + Alpha); // Calculate the Action using only the kinetical contributions + double PotentialPart = CalculatePotentialTermAction(rho, l_rho_spl); + double PotentialAction = + 2 * PotentialPart / + (1 - + Alpha); // Calculate the Action using only the potential contributions + + Action = KineticPart + PotentialPart; + + // Print warning the actions dffer by 10% + if (abs(Action / KineticAction - 1) > 0.1) + { + ss << "Warning! Mismatch between Action and Action calculated using " + "only kinetic term : " + << Action << " and " << KineticAction + << ". Relative error = " << abs(Action / KineticAction - 1) << "\n"; + } + // Print warning the actions dffer by 10% + if (abs(Action / PotentialAction - 1) > 0.1) + { + ss << "Warning! Mismatch between Action and Action calculated using " + "only potential term : " + << Action << " and " << PotentialAction + << ". Relative error = " << abs(Action / PotentialAction - 1) << "\n"; + } + + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); + BSMPT::Logger::Write( + BSMPT::LoggingLevel::BounceDetailed, + "Distance from true vacuum to spline(l0) = " + + std::to_string(L2NormVector(TrueVacuum - Spline(l.at(0))))); + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, + "\nAction =\t" + std::to_string(Action) + "\tat T =\t" + + std::to_string(T) + "\n"); + return; +} +} // namespace BSMPT \ No newline at end of file diff --git a/src/bounce_solution/bounce_solution.cpp b/src/bounce_solution/bounce_solution.cpp new file mode 100644 index 00000000..f40d1866 --- /dev/null +++ b/src/bounce_solution/bounce_solution.cpp @@ -0,0 +1,1101 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file bounce solution calculator class + */ + +#include + +namespace BSMPT +{ + +BounceSolution::BounceSolution( + const std::shared_ptr &pointer_in) +{ + modelPointer = pointer_in; +} + +BounceSolution::BounceSolution( + const std::shared_ptr &pointer_in, + const std::shared_ptr &MinTracer_in, + const CoexPhases &phase_pair_in, + const double &UserDefined_vwall_in, + const double &UserDefined_epsturb_in, + const int &MaxPathIntegrations_in, + const size_t &NumberOfInitialScanTemperatures_in, + std::vector GroupElements_in) +{ + modelPointer = pointer_in; + MinTracer = MinTracer_in; + + phase_pair = phase_pair_in; + Tc = phase_pair.crit_temp; + Tm = phase_pair.T_low; + + UserDefined_vwall = UserDefined_vwall_in; + epsturb = UserDefined_epsturb_in; + MaxPathIntegrations = MaxPathIntegrations_in; + NumberOfInitialScanTemperatures = NumberOfInitialScanTemperatures_in; + this->CalcGstarPureRad(); // initialize degrees of freedom for purely + // radiative universe + GroupElements = GroupElements_in; + + if (Tc > 0) + // Calculate which of the VEV has the best change of tunneling + { + CalculateOptimalDiscreteSymmetry(); + BounceSolution::GWInitialScan(); + } +} + +BounceSolution::BounceSolution( + const std::shared_ptr &pointer_in, + const std::shared_ptr &MinTracer_in, + const CoexPhases &phase_pair_in, + const double &UserDefined_vwall_in, + const double &UserDefined_epsturb_in, + const int &MaxPathIntegrations_in, + const size_t &NumberOfInitialScanTemperatures_in) + : BounceSolution(pointer_in, + MinTracer_in, + phase_pair_in, + UserDefined_vwall_in, + UserDefined_epsturb_in, + MaxPathIntegrations_in, + NumberOfInitialScanTemperatures_in, + {Eigen::MatrixXd::Identity(pointer_in->get_nVEV(), + pointer_in->get_nVEV())}) +{ +} + +void BounceSolution::CalculateOptimalDiscreteSymmetry() +{ + std::stringstream ss; + ss << "Calculating optimal symmetry\n"; + + Eigen::VectorXd TrueVacuum = Eigen::Map( + phase_pair.true_phase.Get(Tc).point.data(), + phase_pair.true_phase.Get(Tc).point.size()); + std::vector FalseVacuum = phase_pair.false_phase.Get(Tc).point; + + // Set the optimal discrete symmetro to the identity matrix + OptimalDiscreteSymmetry = + Eigen::MatrixXd::Identity(FalseVacuum.size(), FalseVacuum.size()); + + double MaximumDistance = 1e100; + for (auto GroupElement : GroupElements) + { + Eigen::VectorXd CandidateTrueVacuum = GroupElement * TrueVacuum; + std::vector DeltaVEV = FalseVacuum; + for (std::size_t el = 0; el < FalseVacuum.size(); el++) + DeltaVEV.push_back(FalseVacuum[el] - TrueVacuum[el]); + + if (L2NormVector(DeltaVEV) < MaximumDistance) + { + MaximumDistance = L2NormVector(DeltaVEV); + OptimalDiscreteSymmetry = GroupElement; + } + } + + ss << "Optimal symmetry is \n\n" << OptimalDiscreteSymmetry << "\n"; + Logger::Write(LoggingLevel::BounceDetailed, ss.str()); +} + +std::vector BounceSolution::TransformIntoOptimalDiscreteSymmetry( + const std::vector &vev) +{ + std::vector result(vev.size(), 0); + // Transform the vector + for (std::size_t i = 0; i < vev.size(); i++) + for (std::size_t j = 0; j < vev.size(); j++) + result[i] += OptimalDiscreteSymmetry(i, j) * vev[j]; + return result; +} + +void BounceSolution::GWInitialScan() +{ + if (Tc < 0) + { + // Transition is never viable + return; + } + + double last_action = -1; + double dT = (Tc - phase_pair.T_low) / NumberOfInitialScanTemperatures; + std::vector TrueVacuum, FalseVacuum, last_TrueVacuum, + last_FalseVacuum; + std::vector> last_path, path; + + for (double T = Tc - dT; T >= phase_pair.T_low + dT; T -= dT) + { + Logger::Write(LoggingLevel::BounceDetailed, "T = " + std::to_string(T)); + + // Check if transition is energetically viable + if (phase_pair.true_phase.Get(T).potential >= + phase_pair.false_phase.Get(T).potential) + continue; + + TrueVacuum = TransformIntoOptimalDiscreteSymmetry( + phase_pair.true_phase.Get(T).point); + FalseVacuum = phase_pair.false_phase.Get(T).point; + std::function)> V = [&](std::vector vev) + { + // Potential wrapper + return modelPointer->VEff(modelPointer->MinimizeOrderVEV(vev), T); + }; + if (last_action < 0) + { + path = {TrueVacuum, FalseVacuum}; + } + else + { + path = MinTracer->WarpPath(last_path, + last_TrueVacuum, + last_FalseVacuum, + TrueVacuum, + FalseVacuum); + } + BounceActionInt bc( + path, TrueVacuum, FalseVacuum, V, T, MaxPathIntegrations); + bc.CalculateAction(); + + last_path = bc.Path; + last_TrueVacuum = bc.TrueVacuum; + last_FalseVacuum = bc.FalseVacuum; + + // Comment this is you want dumb paths!! + last_action = bc.Action; + if (bc.Action / T > 0) + { + SolutionList.insert(std::upper_bound(SolutionList.begin(), + SolutionList.end(), + bc, + [](const BounceActionInt &a, + const BounceActionInt &b) + { return a.T < b.T; }), + bc); + } + + if (bc.Action / T < 40 and bc.Action > 0) break; + } + GWSecondaryScan(); +} + +void BounceSolution::CalculateActionAt(double T, bool smart) +{ + // Action outside allowed range + if (T < Tm or T > Tc) return; + Logger::Write(LoggingLevel::BounceDetailed, " T = " + std::to_string(T)); + // Find the closest solution to our goal temperature + if (SolutionList.size() > 0) + { + auto it = + std::min_element(SolutionList.begin(), + SolutionList.end(), + [T](const BounceActionInt &a, const BounceActionInt &b) + { return std::abs(T - a.T) < std::abs(T - b.T); }); + BounceActionInt Nearest_bc = *it; + + if (abs(Nearest_bc.T - T) < 0.001) return; + + // Check if transition is energetically viable + if (phase_pair.true_phase.Get(T).potential >= + phase_pair.false_phase.Get(T).potential) + return; + + std::vector TrueVacuum = TransformIntoOptimalDiscreteSymmetry( + phase_pair.true_phase.Get(T).point); + std::vector FalseVacuum = phase_pair.false_phase.Get(T).point; + std::function)> V = [&](std::vector vev) + { + // Potential wrapper + return modelPointer->VEff(modelPointer->MinimizeOrderVEV(vev), T); + }; + std::vector> path; + + if (smart) + path = MinTracer->WarpPath(Nearest_bc.Path, + Nearest_bc.TrueVacuum, + Nearest_bc.FalseVacuum, + TrueVacuum, + FalseVacuum); + else + path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc( + path, TrueVacuum, FalseVacuum, V, T, MaxPathIntegrations); + bc.CalculateAction(); + if (bc.Action / T > 0) + { + SolutionList.insert(std::upper_bound(SolutionList.begin(), + SolutionList.end(), + bc, + [](const BounceActionInt &a, + const BounceActionInt &b) + { return a.T < b.T; }), + bc); + } + } + else + { + std::vector TrueVacuum = TransformIntoOptimalDiscreteSymmetry( + phase_pair.true_phase.Get(T).point); + std::vector FalseVacuum = phase_pair.false_phase.Get(T).point; + std::function)> V = [&](std::vector vev) + { + // Potential wrapper + return modelPointer->VEff(modelPointer->MinimizeOrderVEV(vev), T); + }; + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc( + path, TrueVacuum, FalseVacuum, V, T, MaxPathIntegrations); + bc.CalculateAction(); + if (bc.Action / T > 0) + { + SolutionList.push_back(bc); + } + } +} + +void BounceSolution::GWSecondaryScan() +{ + if (SolutionList.size() == 0) + { + Logger::Write(LoggingLevel::BounceDetailed, + "No solution was found during the initial scan.\n Abort!\n"); + // Failed to find the solution + status_bounce_sol = StatusGW::Failure; + return; + } + else if (SolutionList.size() == 1) + { + Logger::Write( + LoggingLevel::BounceDetailed, + "Only one solution was found. Searching near what was found\n"); + CalculateActionAt(SolutionList[0].T - + (SolutionList[0].T - phase_pair.T_low) / 10.); + if (SolutionList.size() == 1) + { + // Failed to find the solution + SetBounceSol(); + return; + }; + } + + GWScanTowardsLowAction(); + GWScanTowardsHighAction(); + + std::size_t NumOfSol = SolutionList.size(); + + for (int i = 0; i < 2; i++) + { + std::vector nextTList; + + for (std::size_t sol = 0; sol < SolutionList.size() - 1; sol++) + { + double t1 = SolutionList[sol].T; + double t2 = SolutionList[sol + 1].T; + double s1 = SolutionList[sol].Action / SolutionList[sol].T; + double s2 = SolutionList[sol + 1].Action / SolutionList[sol + 1].T; + + // Outside our range + if (s1 > 200) continue; + if (s2 < 50) continue; + + double NumOfT = ceil((s2 - s1) / 20); + + double dT = (SolutionList[sol + 1].T - SolutionList[sol].T) / NumOfT; + + double newT; + double ActionProjection; + for (int it_T = 1; it_T < NumOfT; it_T++) + { + newT = SolutionList[sol].T + it_T * dT; + ActionProjection = (newT - t1) * (s2 - s1) / (t2 - t1) + s1; + // Action expected to fall within the wanted range + if (ActionProjection < 400 and ActionProjection > 0) + nextTList.push_back(newT); + } + } + + for (auto j : nextTList) + { + CalculateActionAt(j); + } + + if (NumOfSol == SolutionList.size()) break; + NumOfSol = SolutionList.size(); + } + GWScanTowardsLowAction(); + GWScanTowardsHighAction(); + SetBounceSol(); +} + +void BounceSolution::GWScanTowardsHighAction() +{ + for (int i = 0; + i <= + 1. + (200 - SolutionList.back().Action / SolutionList.back().T) / 10.; + i++) + { + if (SolutionList.back().Action / SolutionList.back().T > 200) break; + + // Try to calculate until s3/T = 200 + double t1 = SolutionList[SolutionList.size() - 2].T; + double t2 = SolutionList[SolutionList.size() - 1].T; + double s1 = SolutionList[SolutionList.size() - 2].Action / t1; + double s2 = SolutionList[SolutionList.size() - 1].Action / t2; + double goal = s2 + 10; + std::size_t NumOfSol = SolutionList.size(); + + double T = ((s1 - goal) * t2 - (s2 - goal) * t1) / (s1 - s2); + + // Action is not monotonic + if (T < t2) return; + + if (T > this->Tc) // Action is flat + { + if (t2 + (t2 - t1) > this->Tc) return; // Close already + CalculateActionAt(t2 + (t2 - t1)); + i--; + } + else + { + CalculateActionAt(T); + if (NumOfSol == SolutionList.size()) + CalculateActionAt( + T, false); // No solution was found. Calculate using dumb method + } + if (NumOfSol == SolutionList.size()) return; // No solution was found. Abort + } +} + +void BounceSolution::GWScanTowardsLowAction() +{ + for (int i = 0; + i <= + 1. + (SolutionList.front().Action / SolutionList.front().T - 50) / 10.; + i++) + { + if (SolutionList.front().Action / SolutionList.front().T < 50) break; + // Try to calculate it at s3/T = 300 + double t1 = SolutionList[0].T; + double t2 = SolutionList[1].T; + double s1 = SolutionList[0].Action / t1; + double s2 = SolutionList[1].Action / t2; + double goal = s1 - 10; + std::size_t NumOfSol = SolutionList.size(); + + double T = ((s1 - goal) * t2 - (s2 - goal) * t1) / (s1 - s2); + + // Action is not monotonic + if (T > t1) return; + + if (T < this->Tm) // Action is flat + { + if (t1 - (t2 - t1) < this->Tm) return; // Close already + CalculateActionAt(t1 - (t2 - t1)); + i--; + } + else + { + CalculateActionAt(T); + if (NumOfSol == SolutionList.size()) + CalculateActionAt( + T, false); // No solution was found. Calculate using dumb method + } + if (NumOfSol == SolutionList.size()) return; // No solution was found. Abort + } +} + +void BounceSolution::SetBounceSol() +{ + std::vector list_T, list_S3, list_S3_T, list_140; + std::stringstream ss; + ss << "------------ Solution list ------------\n"; + for (auto sol : SolutionList) + { + ss << std::setprecision(10) << "{" << sol.T << ",\t" << sol.Action << ",\t" + << sol.Action / sol.T << "},\n"; + list_T.push_back(sol.T); + list_S3.push_back(sol.Action); + list_S3_T.push_back(abs(log(sol.Action / sol.T))); + list_140.push_back(log(140)); + } + ss << "---------------------------------------\n"; + Logger::Write(LoggingLevel::BounceDetailed, ss.str()); + + if (SolutionList.size() > 1) + { + // Plot log of action/T as function of T + ss.clear(); + AsciiPlotter plotter("S_3/T", 100, 35); + plotter.addPlot(list_T, list_140, " ", '.'); + plotter.addPlot(list_T, list_S3_T, " ", '*'); + plotter.xlabel("T (GeV)"); + plotter.ylabel("log(S_3/T)"); + plotter.show(ss); + Logger::Write(LoggingLevel::BounceDetailed, ss.str()); + } + + if (SolutionList.size() < 4) + { + status_bounce_sol = StatusGW::Failure; + Logger::Write( + LoggingLevel::BounceDetailed, + "There are not enough points to calculate the path. Abort.\n"); + return; // Not enough points to calculate path + } + + S3ofT_spline.set_boundary( + tk::spline::not_a_knot, 0.0, tk::spline::not_a_knot, 0.0); + S3ofT_spline.set_points(list_T, list_S3); + status_bounce_sol = StatusGW::Success; +} + +double BounceSolution::GetWallVelocity() const +{ + return vwall; +} + +double BounceSolution::GetEpsTurb() const +{ + return epsturb; +} + +void BounceSolution::SetGstar(const double &gstar_in) +{ + gstar = gstar_in; +} + +double BounceSolution::GetGstar() const +{ + return gstar; +} + +void BounceSolution::SetCriticalTemp(const double &T_in) +{ + Tc = T_in; +} + +double BounceSolution::GetCriticalTemp() const +{ + return Tc; +} + +void BounceSolution::SetStoredTemp(const double &T_in) +{ + store_Temp = T_in; +} + +double BounceSolution::GetStoredTemp() const +{ + return store_Temp; +} + +double BounceSolution::GetNucleationTemp() const +{ + return Tnucl; +} + +double BounceSolution::GetNucleationTempApprox() const +{ + return Tnucl_approx; +} + +double BounceSolution::GetPercolationTemp() const +{ + return Tperc; +} + +double BounceSolution::GetCompletionTemp() const +{ + return Tcompl; +} + +double BounceSolution::CalcTransitionTemp(const int &which_transition_temp) +{ + double trans_temp = -1; + if (status_nucl_approx == BSMPT::StatusTemperature::Success and + which_transition_temp == 1) + { + trans_temp = GetNucleationTempApprox(); + Logger::Write( + LoggingLevel::TransitionDetailed, + "Approximate nucleation temperature T = " + std::to_string(trans_temp) + + " chosen as transition temperature."); + } + else if (status_nucl == BSMPT::StatusTemperature::Success and + which_transition_temp == 2) + { + trans_temp = GetNucleationTemp(); + Logger::Write(LoggingLevel::TransitionDetailed, + "Nucleation temperature T = " + std::to_string(trans_temp) + + " chosen as transition temperature."); + } + else if (status_perc == BSMPT::StatusTemperature::Success and + which_transition_temp == 3) + { + trans_temp = GetPercolationTemp(); + Logger::Write(LoggingLevel::TransitionDetailed, + "Percolation temperature T = " + std::to_string(trans_temp) + + " chosen as transition temperature."); + } + else if (status_compl == BSMPT::StatusTemperature::Success and + which_transition_temp == 4) + { + trans_temp = GetCompletionTemp(); + Logger::Write(LoggingLevel::TransitionDetailed, + "Completion temperature T = " + std::to_string(trans_temp) + + " chosen as transition temperature."); + } + return trans_temp; +} + +double BounceSolution::GetPTStrength() const +{ + return alpha; +} + +double BounceSolution::TunnelingRate(const double &Temp) +{ + if (Temp < SolutionList.front().T or Temp > SolutionList.back().T) + return 0; // Never extrapolate + double Shat3 = GetBounceSol(Temp); + if (Shat3 < 0) + { + Logger::Write(LoggingLevel::BounceDetailed, + "Action spline became negative somewhere. T = " + + std::to_string(Temp)); + return 1e100; // Spline is unstable or ridiculous action. Return values that + // kills the tunneling rate + } + + double amp = + std::pow(Temp, 4) * std::pow((Shat3 / (2 * M_PI * Temp)), 3. / 2); + return amp * std::exp(-Shat3 / Temp); +} + +double BounceSolution::HubbleRate(const double &Temp) +{ + return M_PI * std::sqrt(this->GetGstar()) / std::sqrt(90.) * + std::pow(Temp, 2) / + modelPointer->SMConstants.MPl; // radiation dominated universe +} + +void BounceSolution::CalcGstarPureRad() +{ + std::size_t NHiggs = this->modelPointer->get_NHiggs(); + + double gb = 8 * 2 + 3 * 3 + 2 + NHiggs; + double gf = 6 * 3 * 2 * 2 + 3 * 2 * 2 + 3 * 2; + double geff = gb + 7. / 8 * gf; + + this->SetGstar(geff); +} + +void BounceSolution::CalculateNucleationTemp() +{ + if (status_bounce_sol == StatusGW::Success) + { + double T_up = -1; + double T_down = -1; + double T_middle; + + for (auto sol = SolutionList.rbegin(); sol != SolutionList.rend(); sol++) + { + // Catches the first interval with the nucleation temperature + if (T_up == -1 and + TunnelingRate(sol->T) / std::pow(HubbleRate(sol->T), 4) < 1) + T_up = sol->T; + + if (T_down == -1 and + TunnelingRate(sol->T) / std::pow(HubbleRate(sol->T), 4) > 1) + T_down = sol->T; + + if (T_up > 0 and T_down > 0) break; + } + + if (T_up > 0 and T_down > 0) + { + // There is a Tn to be calculated! Use bisection method + for (int i = 0; i < 50; i++) + { + T_middle = (T_up + T_down) / 2; + + if (TunnelingRate(T_middle) / std::pow(HubbleRate(T_middle), 4) < 1) + { + T_up = T_middle; + } + else + { + T_down = T_middle; + } + if (std::abs(T_up / T_down - 1) < 1e-10) + { + Tnucl = T_middle; + nucleation_temp_set = true; + status_nucl = BSMPT::StatusTemperature::Success; + return; + } + } + } + std::stringstream ss; + ss << "Nucleation temperature calculation failed\n"; + + if (T_up < 0) ss << "Tunneling rate/H never is less than 1.\n"; + if (T_down < 0) ss << "Tunneling rate/H never is more than 1.\n"; + + Logger::Write(LoggingLevel::TransitionDetailed, ss.str()); + + status_nucl = BSMPT::StatusTemperature::NotMet; + return; + } + + return; +} + +void BounceSolution::CalculateNucleationTempApprox() +{ + if (status_bounce_sol == StatusGW::Success) + { + double T_up = -1; + double T_down = -1; + double T_middle; + + for (auto sol = SolutionList.rbegin(); sol != SolutionList.rend(); sol++) + { + // Catches the first interval with the nucleation temperature + if (T_up == -1 and GetBounceSol(sol->T) / sol->T < 140) T_up = sol->T; + + if (T_down == -1 and GetBounceSol(sol->T) / sol->T > 140) T_down = sol->T; + + if (T_up > 0 and T_down > 0) break; + } + + if (T_up > 0 and T_down > 0) + { + // There is a Tn to be calculated! Use bisection method + for (int i = 0; i < 50; i++) + { + T_middle = (T_up + T_down) / 2; + + if (GetBounceSol(T_middle) / T_middle < 140) + { + T_up = T_middle; + } + else + { + T_down = T_middle; + } + if (std::abs(T_up / T_down - 1) < 1e-10) + { + Tnucl_approx = T_middle; + status_nucl_approx = BSMPT::StatusTemperature::Success; + return; + } + } + } + std::stringstream ss; + ss << "Approximate nucleation temperature calculation failed\n"; + + if (T_up < 0) ss << "S3(T)/T never is less than 140.\n"; + if (T_down < 0) ss << "S3(T)/T never is more than 140.\n"; + + Logger::Write(LoggingLevel::TransitionDetailed, ss.str()); + + status_nucl_approx = BSMPT::StatusTemperature::NotMet; + return; + } + return; +} + +double BounceSolution::CalcFalseVacFraction(const double &temp) +{ + double prefac = 4. * M_PI / 3. * std::pow(vwall, 3); + this->SetStoredTemp(temp); + return std::exp(-prefac * Nintegrate_Outer(*this).result); +} + +double BounceSolution::CalcTempAtFalseVacFraction(const double &false_vac_frac) +{ + double res_Temp = -1; + + double int_at_false_vac_frac = -std::log(false_vac_frac); + + double T_up = -1; + double T_down = -1; + double prefac = 4. * M_PI / 3. * std::pow(vwall, 3); + double T_middle; + + for (auto sol = SolutionList.rbegin(); sol != SolutionList.rend(); sol++) + { + // catch the first interval containing res_Temp + this->SetStoredTemp(sol->T); + double IatT_solT = prefac * Nintegrate_Outer(*this).result; + + if (T_up == -1 and IatT_solT < int_at_false_vac_frac) T_up = sol->T; + if (T_down == -1 and IatT_solT > int_at_false_vac_frac) T_down = sol->T; + if (T_up > 0 and T_down > 0) break; + } + + Logger::Write(LoggingLevel::BounceDetailed, + "T ( Pf = " + std::to_string(std::exp(-int_at_false_vac_frac)) + + " ) is in interval [ " + std::to_string(T_down) + ", " + + std::to_string(T_up) + " ]"); + + if (T_up > 0 and T_down > 0) + { + T_middle = (T_up + T_down) / 2.; + this->SetStoredTemp(T_middle); // update temp storage for inner integral + double IatT = prefac * Nintegrate_Outer(*this).result; + + while ((std::abs(T_up / T_down - 1) > + RelativeTemperatureInCalcTempAtFalseVacFraction * + MarginOfCalcTempAtFalseVacFractionBeforeFailure) and + (not almost_the_same( + int_at_false_vac_frac, + IatT, + RelativeErrorInCalcTempAtFalseVacFraction * + MarginOfCalcTempAtFalseVacFractionBeforeFailure))) + { + T_middle = (T_up + T_down) / 2.; + this->SetStoredTemp(T_middle); // update temp storage for inner integral + IatT = prefac * Nintegrate_Outer(*this).result; + + Logger::Write(LoggingLevel::BounceDetailed, + "Pf ( T = " + std::to_string(T_middle) + + " ) = " + std::to_string(std::exp(-IatT))); + + if (IatT < int_at_false_vac_frac) + { + T_up = T_middle; + } + else + { + T_down = T_middle; + } + + // Condition for success + if (std::abs(T_up / T_down - 1) < + RelativeTemperatureInCalcTempAtFalseVacFraction and + almost_the_same(int_at_false_vac_frac, + IatT, + RelativeErrorInCalcTempAtFalseVacFraction)) + { + res_Temp = T_middle; + break; + } + } + } + // Not numerically stable + return res_Temp; +} + +void BounceSolution::CalculatePercolationTemp(const double &false_vac_frac) +{ + if (status_bounce_sol == StatusGW::Success) + { + Tperc = CalcTempAtFalseVacFraction(false_vac_frac); + + if (Tperc > 0 and percolation_temp_set == false) + { + // Try to calculate action at Tp + // CalculateActionAt(Tperc); + for (std::size_t i = 0; i < SolutionList.size() - 1; i++) + { + if (Tperc > SolutionList[i].T and Tperc < SolutionList[i + 1].T) + CalculateActionAt((SolutionList[i].T + SolutionList[i + 1].T) / 2.); + } + percolation_temp_set = true; + SetBounceSol(); + Tperc = CalcTempAtFalseVacFraction(false_vac_frac); + status_perc = BSMPT::StatusTemperature::Success; + } + else if (Tperc < 0) + { + Logger::Write(LoggingLevel::TransitionDetailed, + "Calculation of the percolation temperature failed."); + status_perc = BSMPT::StatusTemperature::NotMet; + } + return; + } + return; +} + +void BounceSolution::CalculateCompletionTemp(const double &false_vac_frac) +{ + if (status_bounce_sol == StatusGW::Success) + { + Tcompl = CalcTempAtFalseVacFraction(false_vac_frac); + + if (Tcompl > 0 and completion_temp_set == false) + { + for (std::size_t i = 0; i < SolutionList.size() - 1; i++) + { + if (Tcompl > SolutionList[i].T and Tcompl < SolutionList[i + 1].T) + CalculateActionAt((SolutionList[i].T + SolutionList[i + 1].T) / 2.); + } + completion_temp_set = true; + Tcompl = CalcTempAtFalseVacFraction(false_vac_frac); + status_compl = BSMPT::StatusTemperature::Success; + } + else if (Tcompl < 0) + { + Logger::Write(LoggingLevel::TransitionDetailed, + "Calculation of the completion temperature failed."); + status_compl = BSMPT::StatusTemperature::NotMet; + } + return; + } + return; +} + +double inner_integrand(double Temp, void *params) +{ + class BounceSolution &obj = *static_cast(params); + double func = 1. / obj.HubbleRate(Temp); + return func; +} + +double outer_integrand(double Temp, void *params) +{ + class BounceSolution &obj = *static_cast(params); + + double func = obj.TunnelingRate(Temp) / + (std::pow(Temp, 4) * obj.HubbleRate(Temp)) * + std::pow(Nintegrate_Inner(obj, Temp).result, 3); + return func; +} + +struct resultErrorPair Nintegrate_Inner(BounceSolution &obj, + const double &Tprime) +{ + double abs_err = obj.AbsErr; + double rel_err = obj.RelErr; + + std::size_t workspace_size = 1000; + gsl_integration_workspace *w = + gsl_integration_workspace_alloc(workspace_size); + gsl_function F; + F.function = &inner_integrand; + F.params = static_cast(&obj); + + struct resultErrorPair res; + + gsl_integration_qags(&F, + obj.GetStoredTemp(), + Tprime, + abs_err, + rel_err, + workspace_size, + w, + &res.result, + &res.error); + + gsl_integration_workspace_free(w); + + return res; +} + +struct resultErrorPair Nintegrate_Outer(BounceSolution &obj) +{ + double abs_err = obj.AbsErr; + double rel_err = obj.RelErr; + + std::size_t workspace_size = 1000; + gsl_integration_workspace *w = + gsl_integration_workspace_alloc(workspace_size); + gsl_function F; + F.function = &outer_integrand; + F.params = static_cast(&obj); + + struct resultErrorPair res; + + gsl_integration_qags(&F, + obj.GetStoredTemp(), + obj.GetCriticalTemp(), + abs_err, + rel_err, + workspace_size, + w, + &res.result, + &res.error); + + gsl_integration_workspace_free(w); + + return res; +} + +void BounceSolution::CalculatePTStrength() +{ + if (not percolation_temp_set) + { + throw std::runtime_error("Phase transition strength cannot be calculated " + "because percolation temperature is not yet set."); + } + + if (UserDefined_vwall >= 0) + vwall = UserDefined_vwall; + else + vwall = 0.95; // Initial guess + + double old_alpha; // To keep track of the convergence + + for (int c = 0; c < 20; c++) + { + // Use recurvie method to find solution of + // alpha = alpha(T_*) + // T_* = T_*(alpha, v_wall) + // v_wall = v_wall(alpha, T_*) + // Should converge quickly, if fails use default value of v_wall = 0.95 + old_alpha = alpha; + CalculatePercolationTemp(); + Minimum true_min = phase_pair.true_phase.Get(GetPercolationTemp()); + Minimum false_min = phase_pair.false_phase.Get(GetPercolationTemp()); + + double Vi = + false_min + .potential; // potential at false vacuum and percolation temperature + double Vf = + true_min + .potential; // potential at true vacuum and percolation temperature + double dTVi = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(false_min.point), + Tperc, + -1); // temperature-derivative at false vacuum + double dTVf = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(true_min.point), + Tperc, + -1); // temperature-derivative at true vacuum const + + double rho_gam = + this->GetGstar() * std::pow(M_PI, 2) / 30 * std::pow(Tperc, 4); + alpha = 1 / rho_gam * (Vi - Vf - Tperc / 4. * (dTVi - dTVf)); + CalculateWallVelocity(false_min, true_min); + if (abs(alpha / old_alpha - 1) < 1e-7) return; // Found a solution + } + // We could not find the solution for the system. use default value of .95 + // instead + Logger::Write(LoggingLevel::TransitionDetailed, + "v_wall could not be calculated. Using 0.95 for v_wall."); + UserDefined_vwall = 0.95; + // Call this function recursively + CalculatePTStrength(); + return; +} + +void BounceSolution::CalculateWallVelocity(const Minimum &false_min, + const Minimum &true_min) +{ + if (not percolation_temp_set) + { + throw std::runtime_error("Wall velocity cannot be calculated " + "because percolation temperature is not yet set."); + } + + // User defined + if (UserDefined_vwall >= 0) vwall = UserDefined_vwall; + if (UserDefined_vwall == -1) + { + // vwall https://arxiv.org/abs/2210.16305 + double Vi = + false_min + .potential; // potential at false vacuum and percolation temperature + double Vf = + true_min + .potential; // potential at true vacuum and percolation temperature + double rho_gam = + this->GetGstar() * std::pow(M_PI, 2) / 30 * std::pow(Tperc, 4); + + double v_ChapmanJouget = 1. / (1 + alpha) * + (modelPointer->SMConstants.Csound + + std::sqrt(std::pow(alpha, 2) + 2. / 3 * alpha)); + + // Candidate wall velocity + vwall = std::sqrt((Vi - Vf) / (alpha * rho_gam)); + // If cancidate is bigger than chapman jouget velocity, v = 1 + if (vwall > v_ChapmanJouget) vwall = 1; + } + if (UserDefined_vwall == -2) + { + // Upper bound implementation https://arxiv.org/abs/2305.02357 + double v_ChapmanJouget = 1. / (1 + alpha) * + (modelPointer->SMConstants.Csound + + std::sqrt(std::pow(alpha, 2) + 2. / 3 * alpha)); + + double dTVi = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(false_min.point), + Tperc, + -1); // temperature-derivative at false vacuum + double dTVf = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(true_min.point), + Tperc, + -1); // temperature-derivative at true vacuum const + + double psi = dTVf / dTVi; + double a = 0.2233; + double b = 1.704; + double p = -3.433; + + vwall = std::pow( + pow(abs((3 * alpha + psi - 1) / (2 * (2 - 3 * psi + std::pow(psi, 3)))), + p / 2) + + std::pow( + abs(v_ChapmanJouget * (1 - a * std::pow(1 - psi, b) / alpha)), + p / 2), + 1 / p); + } +} + +double BounceSolution::GetBounceSol(const double &Temp) const +{ + return S3ofT_spline(Temp); +} + +double action_ratio(double Temp, void *params) +{ + class BounceSolution &obj = *static_cast(params); + double func = obj.GetBounceSol(Temp) / Temp; + return func; +} + +struct resultErrorPair Nderive_BounceRatio(BounceSolution &obj) +{ + double step_size = 1e-8; + + gsl_function F; + F.function = &action_ratio; + F.params = static_cast(&obj); + + struct resultErrorPair res; + + gsl_deriv_central( + &F, obj.GetPercolationTemp(), step_size, &res.result, &res.error); + + return res; +} + +void BounceSolution::CalculateInvTimeScale() +{ + if (not percolation_temp_set) + { + throw std::runtime_error("Phase transition strength cannot be calculated " + "because percolation temperature is not yet set."); + } + + struct resultErrorPair res = Nderive_BounceRatio(*this); + this->betaH = this->GetPercolationTemp() * res.result; +} + +double BounceSolution::GetInvTimeScale() +{ + if (this->betaH == -1) CalculateInvTimeScale(); + return this->betaH; +} + +} // namespace BSMPT diff --git a/src/gravitational_waves/CMakeLists.txt b/src/gravitational_waves/CMakeLists.txt new file mode 100644 index 00000000..403b80a9 --- /dev/null +++ b/src/gravitational_waves/CMakeLists.txt @@ -0,0 +1,15 @@ +# SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, +# João Viana +# +# SPDX-License-Identifier: GPL-3.0-or-later + +set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/gravitational_waves") +set(header ${header_path}/gw.h) + +set(src gw.cpp) + +add_library(GW ${header} ${src}) +target_link_libraries(GW PUBLIC Eigen3::Eigen GSL::gsl Minimizer Utility + BounceSolution) +target_include_directories(GW PUBLIC ${BSMPT_SOURCE_DIR}/include) +target_compile_features(GW PUBLIC cxx_std_14) diff --git a/src/gravitational_waves/gw.cpp b/src/gravitational_waves/gw.cpp new file mode 100644 index 00000000..506ae1ec --- /dev/null +++ b/src/gravitational_waves/gw.cpp @@ -0,0 +1,280 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file gravitational wave class + */ + +#include + +namespace BSMPT +{ + +GravitationalWave::GravitationalWave(BounceSolution &BACalc, + const int &which_transition_temp) +{ + data.transitionTemp = BACalc.CalcTransitionTemp(which_transition_temp); + data.PTStrength = BACalc.GetPTStrength(); + data.InvTimeScale = BACalc.GetInvTimeScale(); + data.vb = BACalc.GetWallVelocity(); + data.kappa_sw = Getkappa_sw( + data.PTStrength, data.vb, BACalc.modelPointer->SMConstants.Csound); + data.K_sw = GetK_sw( + data.PTStrength, data.vb, BACalc.modelPointer->SMConstants.Csound); + data.HR = GetHR( + data.InvTimeScale, data.vb, BACalc.modelPointer->SMConstants.Csound); + data.kappa_turb = CalcEpsTurb(BACalc.GetEpsTurb()) * data.kappa_sw; + data.K_turb = GetK_turb(data.PTStrength, data.kappa_turb); + data.gstar = BACalc.GetGstar(); + data.Hstar = BACalc.HubbleRate(data.transitionTemp); + + if (data.InvTimeScale < 1) + { + data.status = StatusGW::Failure; + Logger::Write( + LoggingLevel::GWDetailed, + "beta/H < 1 detected, with beta/H = " + + std::to_string(data.InvTimeScale) + + ". Transition is assumed to happen, but no GWs calculated."); + } + else if (data.transitionTemp == -1) + { + data.status = StatusGW::Failure; + Logger::Write(LoggingLevel::GWDetailed, + "Requested transition temperature could not be calculated."); + } +} + +GravitationalWave::~GravitationalWave() +{ +} + +double GravitationalWave::CalcEpsTurb(double epsturb_in) +{ + if (epsturb_in == -1) + { + double HtauSW = 2. / std::sqrt(3) * data.HR / std::sqrt(data.K_sw); + return std::pow((1 - std::min(HtauSW, 1.)), 2. / 3.); + } + else + { + return epsturb_in; + } +} + +void GravitationalWave::CalcPeakFrequencySoundWave() +{ + double res = 26e-6 * (1. / this->data.HR) * + (this->data.transitionTemp / 100) * + std::pow(this->data.gstar / 100, 1. / 6); + this->data.fPeakSoundWave = res; +} + +void GravitationalWave::CalcPeakAmplitudeSoundWave() +{ + double ratio = 0; + if (IsFluidTurnoverApproxOne(this->data.HR, this->data.K_sw)) + { + ratio = this->data.HR * std::pow(this->data.K_sw, 2.); + } + else + { + ratio = 2. / std::sqrt(3) * std::pow(this->data.HR, 2) * + std::pow(this->data.K_sw, 3. / 2); + } + + // Taken from erratum of https://arxiv.org/pdf/1704.05871.pdf + this->data.h2OmegaPeakSoundWave = h * h * 2.061 * 1.2e-2 * 3.57e-5 * + std::pow(100. / this->data.gstar, 1. / 3.) * + ratio; +} + +void GravitationalWave::CalcPeakFrequencyTurbulence() +{ + double res = 7.909e-5 * (1. / this->data.HR) * + (this->data.transitionTemp / 100) * + std::pow(this->data.gstar / 100., 1. / 6.); + this->data.fPeakTurbulence = res; +} + +void GravitationalWave::CalcPeakAmplitudeTurbulence() +{ + double res = 1.144e-4 * std::pow(100. / this->data.gstar, 1. / 3.) * + this->data.HR * std::pow(this->data.K_turb, 3. / 2.); + this->data.h2OmegaPeakTurbulence = res; +} + +double GravitationalWave::CalcGWAmplitude(double f, bool swON, bool turbON) +{ + double res = 0; + if (swON) + { + if (!this->data.h2OmegaPeakSoundWave) + { + this->CalcPeakAmplitudeSoundWave(); + } + else if (!this->data.fPeakSoundWave) + { + this->CalcPeakFrequencySoundWave(); + } + + res += this->data.h2OmegaPeakSoundWave * std::pow(4. / 7, -7. / 2) * + std::pow(f / this->data.fPeakSoundWave, 3) * + std::pow((1 + 3. / 4 * std::pow(f / this->data.fPeakSoundWave, 2)), + -7. / 2); + } + if (turbON) + { + if (!this->data.h2OmegaPeakTurbulence) + { + this->CalcPeakAmplitudeTurbulence(); + } + else if (!this->data.fPeakTurbulence) + { + this->CalcPeakFrequencyTurbulence(); + } + + res += this->data.h2OmegaPeakTurbulence * + std::pow(f / this->data.fPeakTurbulence, 3) / + std::pow(1 + f / this->data.fPeakTurbulence, 11 / 3) / + (1 + 8 * M_PI * f / this->data.Hstar); + } + + return res; +} + +double +GravitationalWave::GetSNR(const double fmin, const double fmax, const double T) +{ + auto integral = Nintegrate_SNR(*this, fmin, fmax); + double res = std::sqrt(86400 * 365.25 * T * integral.result); + this->data.status = StatusGW::Success; + return res; +} + +double SIfunc(const double f) +{ + double f1 = 0.4e-3; + return 5.76e-48 * (1 + std::pow(f1 / f, 2)); +} + +double Rfunc(const double f) +{ + double f2 = 25e-3; + return 1. + std::pow(f / f2, 2); +} + +double powspec_density(const double f) +{ + double SIIfunc = 3.6e-41; + return 1. / 2 * 20. / 3 * (SIfunc(f) / std::pow(2 * M_PI * f, 4) + SIIfunc) * + Rfunc(f); +} + +double h2OmSens(const double f) +{ + double H0 = 100 / 3.09e19; + return (4 * std::pow(M_PI, 2)) / (3 * std::pow(H0, 2)) * std::pow(f, 3) * + powspec_density(f); +} + +double snr_integrand(double f, void *params) +{ + class GravitationalWave &obj = *static_cast(params); + + double func = std::pow( + obj.CalcGWAmplitude(f, obj.data.swON, obj.data.turbON) / (h2OmSens(f)), + 2); + return func; +} + +struct resultErrorPair +Nintegrate_SNR(GravitationalWave &obj, const double fmin, const double fmax) +{ + double abs_err = obj.AbsErr; + double rel_err = obj.RelErr; + + std::size_t workspace_size = 1000; + gsl_integration_workspace *w = + gsl_integration_workspace_alloc(workspace_size); + gsl_function F; + F.function = &snr_integrand; + F.params = static_cast(&obj); + + struct resultErrorPair res; + + gsl_integration_qags(&F, + fmin, + fmax, + abs_err, + rel_err, + workspace_size, + w, + &res.result, + &res.error); + + gsl_integration_workspace_free(w); + + return res; +} + +double +Getkappa_sw(const double &alpha, const double &vwall, const double &Csound) +{ + double kappa; + double kappaA = std::pow(vwall, 6.0 / 5.0) * 6.9 * alpha / + (1.36 - 0.037 * std::sqrt(alpha) + alpha); + double kappaB = + std::pow(alpha, 2.0 / 5.0) / (0.017 + std::pow(0.997 + alpha, 2.0 / 5.0)); + double kappaC = std::sqrt(alpha) / (0.135 + std::sqrt(0.98 + alpha)); + double kappaD = alpha / (0.73 + 0.083 * std::sqrt(alpha) + alpha); + double xiJ = + (sqrt((2.0 / 3.0) * alpha + alpha * alpha) + std::sqrt(1.0 / 3.0)) / + (1 + alpha); + double deltaK = -0.9 * log((sqrt(alpha) / (1 + std::sqrt(alpha)))); + + if (vwall < Csound) + kappa = std::pow(Csound, 11.0 / 5.0) * kappaA * kappaB / + ((pow(Csound, 11.0 / 5.0) - std::pow(vwall, 11.0 / 5.0)) * kappaB + + vwall * std::pow(Csound, 6.0 / 5.0) * kappaA); + else if (vwall > xiJ) + kappa = std::pow(xiJ - 1, 3.0) * std::pow(xiJ, 5.0 / 2.0) * + std::pow(vwall, -5.0 / 2.0) * kappaC * kappaD / + ((pow(xiJ - 1, 3.0) - std::pow(vwall - 1, 3.0)) * + std::pow(xiJ, 5.0 / 2.0) * kappaC + + std::pow(vwall - 1, 3.0) * kappaD); + else + kappa = kappaB + (vwall - Csound) * deltaK + + (pow(vwall - Csound, 3.0) / std::pow(xiJ - Csound, 3.0)) * + (kappaC - kappaB - (xiJ - Csound) * deltaK); + + return kappa; +} + +double GetK_sw(const double &alpha, const double &vwall, const double &Csound) +{ + double kappa = Getkappa_sw(alpha, vwall, Csound); + return kappa * alpha / (1. + alpha); +} + +double +GetHR(const double &invTimeScale, const double &vwall, const double &Csound) +{ + double max_velo = std::max(vwall, Csound); + return 1. / invTimeScale * std::pow(8 * M_PI, 1. / 3) * max_velo; +} + +double GetK_turb(const double &alpha, const double &kappa) +{ + return kappa * alpha / (1. + alpha); +} + +bool IsFluidTurnoverApproxOne(const double &HR, const double &K) +{ + double ratio = 2 * HR / std::sqrt(3 * K); + return (ratio < 1) ? false : true; +} + +} // namespace BSMPT \ No newline at end of file diff --git a/src/minimizer/CMakeLists.txt b/src/minimizer/CMakeLists.txt index de4500c3..2d3712b1 100644 --- a/src/minimizer/CMakeLists.txt +++ b/src/minimizer/CMakeLists.txt @@ -1,53 +1,35 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/minimizer") -set(header - ${header_path}/Minimizer.h - ${header_path}/MinimizePlane.h - ${header_path}/MinimizeGSL.h -) - -set(src - MinimizeGSL.cpp - Minimizer.cpp - MinimizePlane.cpp -) +set(header ${header_path}/Minimizer.h ${header_path}/MinimizePlane.h + ${header_path}/MinimizeGSL.h) +set(src MinimizeGSL.cpp Minimizer.cpp MinimizePlane.cpp) if(libcmaes_FOUND) - set(header - ${header} - ${header_path}/LibCMAES/MinimizeLibCMAES.h - ) - set(src - ${src} - LibCMAES/MinimizeLibCMAES.cpp - ) + set(header ${header} ${header_path}/LibCMAES/MinimizeLibCMAES.h) + set(src ${src} LibCMAES/MinimizeLibCMAES.cpp) endif() if(NLopt_FOUND) - set(header - ${header} - ${header_path}/LibNLOPT/MinimizeNLOPT.h - ) - set(src - ${src} - LibNLOPT/MinimizeNLOPT.cpp - ) + set(header ${header} ${header_path}/LibNLOPT/MinimizeNLOPT.h) + set(src ${src} LibNLOPT/MinimizeNLOPT.cpp) endif() - - add_library(Minimizer ${header} ${src}) -target_link_libraries(Minimizer PUBLIC Eigen3::Eigen GSL::gsl Threads::Threads Utility Models) +target_link_libraries(Minimizer PUBLIC Eigen3::Eigen GSL::gsl Threads::Threads + Utility Models) if(libcmaes_FOUND) - target_link_libraries(Minimizer PRIVATE libcmaes::cmaes OpenMP::OpenMP_CXX) + target_link_libraries(Minimizer PRIVATE libcmaes::cmaes) + if(OpenMP_FOUND) + target_link_libraries(Minimizer PRIVATE OpenMP::OpenMP_CXX) + endif() endif() - if(NLopt_FOUND) if(TARGET NLopt::nlopt) target_link_libraries(Minimizer PUBLIC NLopt::nlopt) @@ -57,7 +39,6 @@ if(NLopt_FOUND) endif() target_include_directories(Minimizer PUBLIC ${BSMPT_SOURCE_DIR}/include - ${BSMPT_BINARY_DIR}/include) + ${BSMPT_BINARY_DIR}/include) target_include_directories(Minimizer PUBLIC ${BSMPT_SOURCE_DIR}/include) -target_compile_features(Minimizer PUBLIC cxx_std_14) - +target_compile_features(Minimizer PUBLIC cxx_std_17) diff --git a/src/minimizer/LibCMAES/MinimizeLibCMAES.cpp b/src/minimizer/LibCMAES/MinimizeLibCMAES.cpp index 28926f08..cb525d96 100644 --- a/src/minimizer/LibCMAES/MinimizeLibCMAES.cpp +++ b/src/minimizer/LibCMAES/MinimizeLibCMAES.cpp @@ -54,7 +54,8 @@ LibCMAESReturn min_cmaes_gen_all(const Class_Potential_Origin &model, // cmaparams.set_noisy(); cmaparams.set_ftolerance(ftol); - FitFunc cmafunc = [&](const double *v, const int &N) { + FitFunc cmafunc = [&](const double *v, const int &N) + { (void)N; std::vector vev; for (std::size_t i{0}; i < dim; ++i) @@ -109,7 +110,8 @@ CMAES_Minimize_Plane_gen_all(const struct PointerContainerMinPlane ¶ms, cmaparams.set_algo(aCMAES); cmaparams.set_ftolerance(ftol); - FitFunc CMAES_VEFF_Minimize_Plane = [=](const double *v, const int &N) { + FitFunc CMAES_VEFF_Minimize_Plane = [=](const double *v, const int &N) + { (void)N; std::size_t nVEVs = params.modelPointer->get_nVEV(); diff --git a/src/minimizer/Minfunc_gen.cpp b/src/minimizer/Minfunc_gen.cpp index 903310b6..e95f3524 100644 --- a/src/minimizer/Minfunc_gen.cpp +++ b/src/minimizer/Minfunc_gen.cpp @@ -1,5 +1,6 @@ // Copyright (C) 2018 Philipp Basler and Margarete Mühlleitner -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later diff --git a/src/minimizer/MinimizeGSL.cpp b/src/minimizer/MinimizeGSL.cpp index 8a6be0ac..333de73b 100644 --- a/src/minimizer/MinimizeGSL.cpp +++ b/src/minimizer/MinimizeGSL.cpp @@ -200,7 +200,8 @@ GSL_Minimize_gen_all(const Class_Potential_Origin &model, GSL_params &mparams, std::mutex &mWriteResultLock, std::queue> &mResults, - bool UseLock = true) { + bool UseLock = true) + { while (mFoundSolutions < mMaxSol and not mStartingPoints.empty()) { std::vector start; @@ -234,14 +235,16 @@ GSL_Minimize_gen_all(const Class_Potential_Origin &model, for (std::size_t i = 0; i < Num_threads; ++i) { - MinThreads.push_back(std::thread([&]() { - thread_Job(FoundSolutions, - MaxSol, - StartingPoints, - params, - WriteResultLock, - Results); - })); + MinThreads.push_back(std::thread( + [&]() + { + thread_Job(FoundSolutions, + MaxSol, + StartingPoints, + params, + WriteResultLock, + Results); + })); } for (auto &thr : MinThreads) diff --git a/src/minimizer/MinimizePlane.cpp b/src/minimizer/MinimizePlane.cpp index fe1e012b..f0969ceb 100644 --- a/src/minimizer/MinimizePlane.cpp +++ b/src/minimizer/MinimizePlane.cpp @@ -87,9 +87,30 @@ MinimizePlaneReturn MinimizePlane(const std::vector &basepoint, const std::vector &parCT, const double &Temp, const int &WhichMinimizer) +{ + return MinimizePlane(basepoint, + VEVSymmetric, + VEVBroken, + Model, + par, + parCT, + GetSMConstants(), + Temp, + WhichMinimizer); +} + +MinimizePlaneReturn MinimizePlane(const std::vector &basepoint, + const std::vector &VEVSymmetric, + const std::vector &VEVBroken, + const ModelID::ModelIDs &Model, + const std::vector &par, + const std::vector &parCT, + const ISMConstants &SMConstant, + const double &Temp, + const int &WhichMinimizer) { std::shared_ptr modelPointer = - ModelID::FChoose(Model); + ModelID::FChoose(Model, SMConstant); modelPointer->set_All(par, parCT); return MinimizePlane( basepoint, VEVSymmetric, VEVBroken, modelPointer, Temp, WhichMinimizer); diff --git a/src/minimizer/Minimizer.cpp b/src/minimizer/Minimizer.cpp index 105ada94..09989da6 100644 --- a/src/minimizer/Minimizer.cpp +++ b/src/minimizer/Minimizer.cpp @@ -63,11 +63,11 @@ namespace Minimizer MinimizersToUse GetMinimizers(int WhichMinimizer) { - bool UseCMAES = (WhichMinimizer % 2 == 1); + bool UseCMAES = (WhichMinimizer % 2 != 0); WhichMinimizer /= 2; - bool UseGSL = (WhichMinimizer % 2 == 1); + bool UseGSL = (WhichMinimizer % 2 != 0); WhichMinimizer /= 2; - bool UseNLopt = (WhichMinimizer % 2 == 1); + bool UseNLopt = (WhichMinimizer % 2 != 0); #ifndef libcmaes_FOUND UseCMAES = false; @@ -80,13 +80,6 @@ MinimizersToUse GetMinimizers(int WhichMinimizer) return MinimizersToUse(UseCMAES, UseGSL, UseNLopt); } -/** - * @brief Minimization of the Model - * Minimizes the given Potential with parameters par and CT-parameters parCT at - * a given Temperature Temp and writes the solution in the std::vector sol. The - * Minimization Debugging Options are written in the std::vector Check. The - * std::vector Start gives the start value for the CMA-ES Minimization. - */ std::vector Minimize_gen_all(const std::shared_ptr &modelPointer, const double &Temp, @@ -125,8 +118,9 @@ Minimize_gen_all(const std::shared_ptr &modelPointer, { if (UseMultithreading) { - thread_GSL = - std::thread([&solGSLMin, &gslMinSuc, &modelPointer, &Temp]() { + thread_GSL = std::thread( + [&solGSLMin, &gslMinSuc, &modelPointer, &Temp]() + { std::tie(solGSLMin, gslMinSuc) = GSL_Minimize_gen_all( *modelPointer, Temp, @@ -146,7 +140,8 @@ Minimize_gen_all(const std::shared_ptr &modelPointer, if (UseMultithreading) { thread_GSL = std::thread( - [&solGSLMin, &gslMinSuc, &modelPointer, &Temp, &MaxSol]() { + [&solGSLMin, &gslMinSuc, &modelPointer, &Temp, &MaxSol]() + { std::tie(solGSLMin, gslMinSuc) = GSL_Minimize_gen_all(*modelPointer, Temp, 5, MaxSol); }); @@ -165,9 +160,10 @@ Minimize_gen_all(const std::shared_ptr &modelPointer, { if (UseMultithreading) { - thread_CMAES = std::thread([&modelPointer, &Temp, &start, &LibCMAES]() { - LibCMAES = LibCMAES::min_cmaes_gen_all(*modelPointer, Temp, start); - }); + thread_CMAES = std::thread( + [&modelPointer, &Temp, &start, &LibCMAES]() { + LibCMAES = LibCMAES::min_cmaes_gen_all(*modelPointer, Temp, start); + }); } else { @@ -185,9 +181,9 @@ Minimize_gen_all(const std::shared_ptr &modelPointer, { if (UseMultithreading) { - thread_NLopt = std::thread([&NLOPTResult, &modelPointer, &Temp]() { - NLOPTResult = LibNLOPT::MinimizeUsingNLOPT(*modelPointer, Temp); - }); + thread_NLopt = std::thread( + [&NLOPTResult, &modelPointer, &Temp]() + { NLOPTResult = LibNLOPT::MinimizeUsingNLOPT(*modelPointer, Temp); }); } else { @@ -261,7 +257,7 @@ Minimize_gen_all(const std::shared_ptr &modelPointer, auto sol = Minima.at(minIndex); auto EWVEV = modelPointer->EWSBVEV(modelPointer->MinimizeOrderVEV(sol)); - if (EWVEV <= 0.5) sol = std::vector(modelPointer->get_nVEV(), 0); + if (EWVEV <= 0.5) modelPointer->SetEWVEVZero(sol); solGSLMin.clear(); if (UseMinimizer.UseGSL and gslMinSuc) @@ -416,9 +412,29 @@ Minimize_gen_all_tree_level(const ModelID::ModelIDs &Model, const std::vector &start, int WhichMinimizer, bool UseMultithreading) +{ + return Minimize_gen_all_tree_level(Model, + par, + parCT, + GetSMConstants(), + Check, + start, + WhichMinimizer, + UseMultithreading); +} + +std::vector +Minimize_gen_all_tree_level(const ModelID::ModelIDs &Model, + const std::vector &par, + const std::vector &parCT, + const ISMConstants &SMConstants, + std::vector &Check, + const std::vector &start, + int WhichMinimizer, + bool UseMultithreading) { std::shared_ptr modelPointer = - ModelID::FChoose(Model); + ModelID::FChoose(Model, SMConstants); modelPointer->set_All(par, parCT); modelPointer->SetUseTreeLevel(true); auto sol = Minimize_gen_all( @@ -514,7 +530,8 @@ MinimaDevelopmentWithTemperature( } } - auto StoppingCriteria = [&](const double &Temp) { + auto StoppingCriteria = [&](const double &Temp) + { double epsilon = std::abs((FinalTemperature - StartingTemperature) / StepsizeTemperature) * 1e-2; // because 1+1 = 2.0000000000000001 diff --git a/src/minimum_tracer/CMakeLists.txt b/src/minimum_tracer/CMakeLists.txt new file mode 100644 index 00000000..fa45ce75 --- /dev/null +++ b/src/minimum_tracer/CMakeLists.txt @@ -0,0 +1,15 @@ +# SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, +# João Viana +# +# SPDX-License-Identifier: GPL-3.0-or-later + +set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/minimum_tracer") +set(header ${header_path}/minimum_tracer.h) + +set(src minimum_tracer.cpp) + +add_library(MinimumTracer ${header} ${src}) +target_link_libraries(MinimumTracer PUBLIC Eigen3::Eigen GSL::gsl Minimizer + Utility) +target_include_directories(MinimumTracer PUBLIC ${BSMPT_SOURCE_DIR}/include) +target_compile_features(MinimumTracer PUBLIC cxx_std_14) diff --git a/src/minimum_tracer/minimum_tracer.cpp b/src/minimum_tracer/minimum_tracer.cpp new file mode 100644 index 00000000..e806ad2f --- /dev/null +++ b/src/minimum_tracer/minimum_tracer.cpp @@ -0,0 +1,2898 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file minimum tracer class + */ + +#include +#include + +using namespace Eigen; + +namespace BSMPT +{ + +std::ostream &operator<<(std::ostream &os, const StatusNLOStability &status) +{ + os << StatusNLOStabilityToString.at(status); + return os; +} +std::ostream &operator<<(std::ostream &os, const StatusEWSR &status) +{ + os << StatusEWSRToString.at(status); + return os; +} +std::ostream &operator<<(std::ostream &os, const StatusTracing &status) +{ + os << StatusTracingToString.at(status); + return os; +} +std::ostream &operator<<(std::ostream &os, const StatusCoexPair &status) +{ + os << StatusCoexPairToString.at(status); + return os; +} +std::ostream &operator<<(std::ostream &os, const StatusCrit &status) +{ + os << StatusCritToString.at(status); + return os; +} +std::ostream &operator<<(std::ostream &os, const StatusGW &status) +{ + os << StatusGWToString.at(status); + return os; +} +std::ostream &operator<<(std::ostream &os, const StatusTemperature &status) +{ + os << StatusTemperatureToString.at(status); + return os; +} + +std::vector MinimumTracer::LocateMinimum( + const std::vector &guess_In, + std::function(std::vector)> &df, + std::function>(std::vector)> + &Hessian, + const double &error, + const double &const_multiplier, + const int &maxiter) +{ + // Save initial guess + std::vector guess = guess_In; + // Checks if guess is close enough + if (L2NormVector(df(guess)) < error) return guess; + + // If not, performs gradient descent until minima with a maximum of + // "maxiter" iterations + int dim = guess.size(); // Guess dimension + int i = 0; // Counter + std::vector new_guess = guess; // First guess + std::vector gradient; // Gradient + std::vector> Hess; // HessianNumerical gradient + + for (i = 0; (i < maxiter) && (L2NormVector(df(new_guess)) > error); i++) + { + // Update grad and HessianNumerical : + gradient = df(new_guess); + Hess = Hessian(new_guess); + + // Convert into a Eigen3 // Probably there is a better way + Eigen::MatrixXd HessMatrix(dim, dim); + for (int m = 0; m < dim; m++) + { + for (int n = 0; n < dim; n++) + { + HessMatrix(m, n) = Hess[m][n]; + } + // Add a small constant to protect us againt numerically unstable negative + // eigenvalues + HessMatrix(m, m) += HessianDiagonalShift; + } + + if (HessMatrix.determinant() != 0) // If HessianNumerical is + // invertible them do the gradient descent, if not use only the + // diagonal elements. + { + // Convert gradient into vector + Eigen::VectorXd EigenGradient = + Eigen::Map(gradient.data(), + gradient.size()); + + // Calculates the n - th step : x(n + 1) = x(n) + alpha(n) + Eigen::VectorXd delta = + HessMatrix.colPivHouseholderQr().solve(-1 * EigenGradient); + + for (int j = 0; j < dim; j++) + { + new_guess[j] += delta(j); // Updates guess + } + } + else // If is not invertible use just the gradient + { + for (int j = 0; j < dim; j++) + { + new_guess[j] -= const_multiplier * gradient[j]; // Updates guess + } + } + } + return (new_guess); +} + +double MinimumTracer::SmallestEigenvalue( + const std::vector &point, + const std::function>(std::vector)> + &Hessian) +{ + std::size_t dim = point.size(); + std::vector> current_hessian = Hessian(point); + + Eigen::MatrixXcd mat(dim, dim); + for (std::size_t i = 0; i < dim; i++) + { + mat.col(i) = Eigen::Map(current_hessian[i].data(), dim); + } + + // Calculate smallest eigenvalue + double current_min = 1e100; + for (auto element : mat.eigenvalues()) + current_min = std::min(element.real(), current_min); + // If the "SmallestEigenvalue" is zero, it can become negative due to + // numerical errors. To prevent unstable behaviour we add a small constant. + return current_min + 1e-7; +} + +std::vector +MinimumTracer::FindZeroSmallestEigenvalue(std::vector point_1, + double T_1, + std::vector point_2, + double T_2) +{ + double eps = 0.1; + double ev_1, ev_2, ev_m, T_m; // Eigenvalues of phases and middle temperature + int dim = this->modelPointer->get_nVEV(); + std::vector point_m; + std::function)> V_1, V_2, V_m; + std::function(std::vector)> dV_1, dV_2, dV_m; + std::function>(std::vector)> + Hessian_1, Hessian_2, Hessian_m; + + // Define potential 1 + V_1 = [&](std::vector vev) + { + // Potential wrapper + std::vector res = this->modelPointer->MinimizeOrderVEV(vev); + return this->modelPointer->VEff(res, T_1) / (1 + T_1 * T_1); + }; + dV_1 = [&](auto const &arg) { return NablaNumerical(arg, V_1, eps); }; + Hessian_1 = [&](auto const &arg) { return HessianNumerical(arg, V_1, eps); }; + + // Define potential 2 + V_2 = [&](std::vector vev) + { + // Potential wrapper + std::vector res = this->modelPointer->MinimizeOrderVEV(vev); + return this->modelPointer->VEff(res, T_2) / (1 + T_2 * T_2); + }; + dV_2 = [=](auto const &arg) { return NablaNumerical(arg, V_2, eps); }; + Hessian_2 = [=](auto const &arg) { return HessianNumerical(arg, V_2, eps); }; + + // Initial guess for middle point + point_m = point_1; + + // Calculate smallest EV + ev_1 = SmallestEigenvalue(point_1, Hessian_1); + ev_2 = SmallestEigenvalue(point_2, Hessian_2); + + if (ev_1 * ev_2 > 0) + { + // Safety check. We should never be here. + std::stringstream ss; + ss << "They have the same sign, no zero to be found!\t" << ev_1 << "\t" + << ev_2 << "\n"; + Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); + point_1.push_back(-1); + return point_1; + } + + // This is to provent instabilities and make sure we do not leave the + // phase + double AllowedMaxDistance = fmax(1, L2NormVector(point_1 - point_2) / dim); + std::vector CandidatePoint = point_1; + double CandidateTemperature = T_1; + + while (abs(T_1 / T_2 - 1) > 1e-8) + { + T_m = (T_1 + T_2) / 2.; + // Define potential in the middle + V_m = [&](std::vector vev) + { + // Potential wrapper + std::vector res = this->modelPointer->MinimizeOrderVEV(vev); + return this->modelPointer->VEff(res, T_m) / (1 + T_m * T_m); + }; + dV_m = [=](auto const &arg) { return NablaNumerical(arg, V_m, eps); }; + Hessian_m = [=](auto const &arg) + { return HessianNumerical(arg, V_m, eps); }; + point_m = + LocateMinimum(point_m, dV_m, Hessian_m, 1e-3 * dim / (1 + T_m * T_m)); + ev_m = SmallestEigenvalue(point_m, Hessian_m); + + // Check if there is numerical instabilities so reduce the searching area. + if (L2NormVector(point_m - point_2) / dim > AllowedMaxDistance or + L2NormVector(point_1 - point_m) / dim > AllowedMaxDistance) + { + T_2 = T_m; + } + else if (ev_1 * ev_m > 0) + { + // This point has the correct eigenvalue and is close. + CandidatePoint = point_m; + CandidateTemperature = T_m; + } + + if (ev_1 * ev_m > 0) + { + T_1 = T_m; + } + else if (ev_2 * ev_m > 0) + { + T_2 = T_m; + } + else + { + // Here ev_m == 0 + break; + } + } + CandidatePoint.push_back(CandidateTemperature); + return CandidatePoint; +} + +std::vector +MinimumTracer::TrackPhase(double &globMinEndT, + const std::vector &point_In, + const double ¤tT_In, + const double &finalT, + const double &dT_In, + const bool &output, + const bool &unprotected) +{ + // Test phase tracker + int dim = this->modelPointer->get_nVEV(); + int IsInMin = 0; + double initialT = currentT_In; + double currentT = currentT_In; + double dT = dT_In; + double initialdT; + double eps = 0.1; + double LengthGradient, PotentialDifference, Distance; + std::function(std::vector)> dV; + std::function>(std::vector)> Hessian; + std::vector point = point_In; + std::vector new_point = point_In; + std::vector zeroTemp; + std::stringstream ss; + std::vector MinimumList; + Minimum newMinimum; + + bool old_min_is_global = true; + + if ((finalT - currentT) / dT < 0) + { + // Step has the wrong sign + dT *= -1; + } + initialdT = dT; + + // Reduce the VEV into the same sector + ReduceVEV(point); + + // Remove flat directions + ConvertToNonFlatDirections(point); + + ss << "Tracking phase from T = " << currentT << " to T = " << finalT + << " | Starting minimum at = " << point << "\n"; + while ((finalT - currentT) / dT >= 0) + { + std::function)> V = [&](std::vector vev) + { + // Potential wrapper + std::vector res = this->modelPointer->MinimizeOrderVEV(vev); + return this->modelPointer->VEff(res, currentT) / + (1 + currentT * currentT); + }; + dV = [=](auto const &arg) { return NablaNumerical(arg, V, eps); }; + Hessian = [=](auto const &arg) { return HessianNumerical(arg, V, eps); }; + + // Locate the minimum + new_point = + LocateMinimum(point, dV, Hessian, 1e-4 * GradientThreshold * dim); + + // Reduce the VEV into the same sector + ReduceVEV(new_point); + + // Remove flat directions + ConvertToNonFlatDirections(new_point); + + // Calculate the length of the gradient in the normal potential divided + // by the dimension of the VEV space + LengthGradient = + L2NormVector(dV(new_point)) / dim; // (1 + currentT * currentT) * + // Compare minimum and previous iteration + Distance = L2NormVector(new_point - point); + // Compute difference in energy between both minimum + PotentialDifference = V(new_point) - V(point); + + // If the minimum it n GeV away then we consider it a new phase + double ThresholdDistance = (double)dim; + if (abs(dT) < 1e-5) + { + break; + } + else if (LengthGradient > GradientThreshold or + Distance > ThresholdDistance or + std::any_of(new_point.begin(), + new_point.end(), + [](double v) { return isnan(v); })) + { + // Algorithm flew away. Going back one iteration. + // Decrease temperature step size + // Not a stationary point anymore. Going back one iteration. + // Decrease temperature step size + + ss << "\n\033[1;95m.-> | T = " << currentT + << " |Grad|/dim = " << LengthGradient << " | Distance = " << Distance + << " | |dphi/dT| = " << abs(Distance / dT) + << " | deltaV = " << PotentialDifference + << " | SEV = " << SmallestEigenvalue(new_point, Hessian) + << " | <-\033[0m\n"; + + if (initialT == currentT) + { + ss << "Could not locate the starting minimum at T = " << initialT + << " GeV."; + ss << " |Grad|/dim = " << L2NormVector(dV(point)) / dim + << " | Distance = " << Distance + << " | |dphi/dT| = " << abs(Distance / dT) + << " | deltaV = " << PotentialDifference + << " | SEV = " << SmallestEigenvalue(point, Hessian); + if (output) Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); + return MinimumList; + } + + currentT -= dT; + dT /= 10.; + } + else if (unprotected) + { + newMinimum.point = new_point; + newMinimum.temp = currentT; + newMinimum.potential = V(new_point) * (1 + currentT * currentT); + MinimumList.push_back(newMinimum); + point = new_point; + // Sucess minimum! + ss << "\033[1;32m.\033[0m"; + dT *= + .5 * ThresholdDistance / Distance; // Try to predict the best stepsize + if (abs(initialdT) <= abs(dT)) dT = initialdT; + } + else + { + // It is a nearby stationary point! + if (SmallestEigenvalue(new_point, Hessian) < 0) + { + if (IsInMin == -1) + { + zeroTemp = FindZeroSmallestEigenvalue( + point, currentT - dT, new_point, currentT); + if (zeroTemp.back() > 0) + { + currentT = zeroTemp.back(); + zeroTemp.pop_back(); + // Reduce the VEV into the same sector + ReduceVEV(zeroTemp); + // Remove flat directions + ConvertToNonFlatDirections(zeroTemp); + newMinimum.point = zeroTemp; + newMinimum.temp = currentT; + newMinimum.potential = V(zeroTemp) * (1 + currentT * currentT); + + if (old_min_is_global) // check if newMinimum is + // still global minimum + { + IsGlobMin(newMinimum); + if (!newMinimum.is_glob_min) + { + if (output) + Logger::Write( + LoggingLevel::MinTracerDetailed, + "Phase no longer coincides with global minimum at " + + std::to_string(newMinimum.temp)); + globMinEndT = newMinimum.temp; + old_min_is_global = false; + } + } + + MinimumList.push_back(newMinimum); + } + // End tracking + break; + } + else + { + ss << "Calculation of phase tracker failed. T = " << currentT + << " GeV\t|\t Final T = " << finalT << " GeV\t|\t" + << LengthGradient << "\t|\t" + << SmallestEigenvalue(new_point, Hessian) << "\t"; + // Sucess saddle point! + ss << "\033[1;31m.\033[0m"; + if (output) Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); + ss.str(std::string()); + return MinimumList; // return if starts in a saddle point + } + IsInMin = 1; + } + else + { + if (IsInMin == 1) + { + // We should never be here. We only track minimum + break; + } + else + { + newMinimum.point = new_point; + newMinimum.temp = currentT; + newMinimum.potential = V(new_point) * (1 + currentT * currentT); + + if (old_min_is_global) // check if newMinimum is + // still global minimum + { + IsGlobMin(newMinimum); + if (!newMinimum.is_glob_min) + { + if (output) + Logger::Write( + LoggingLevel::MinTracerDetailed, + "Phase no longer coincides with global minimum at " + + std::to_string(newMinimum.temp)); + globMinEndT = newMinimum.temp; + old_min_is_global = false; + } + } + + MinimumList.push_back(newMinimum); + // Sucess minimum! + ss << "\033[1;32m.\033[0m"; + dT *= .5 * ThresholdDistance / + Distance; // Try to predict the best stepsize + if (abs(initialdT) <= abs(dT)) dT = initialdT; + } + IsInMin = -1; + } + point = new_point; + } + + // Make sure that or step is not bigger than it should be and we overshot + // the next minimum + if (currentT == finalT) break; + bool SafeStep = abs(finalT - currentT) > abs(dT); + if (SafeStep) + currentT += dT; + else + currentT = finalT; + } + if (output) Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); + if (output) + Logger::Write(LoggingLevel::MinTracerDetailed, + "T = " + std::to_string(currentT) + " GeV"); + if (old_min_is_global) globMinEndT = currentT; + return MinimumList; +} + +std::vector +MinimumTracer::TrackPhase(const std::vector &point_In, + const double ¤tT_In, + const double &finalT, + const double &dT_In, + const bool &output, + const bool &unprotected) +{ + // Test phase tracker + int dim = this->modelPointer->get_nVEV(); + int IsInMin = 0; + double initialT = currentT_In; + double currentT = currentT_In; + double dT = dT_In; + double initialdT; + double eps = 0.1; + double LengthGradient, PotentialDifference, Distance; + std::function(std::vector)> dV; + std::function>(std::vector)> Hessian; + std::vector point = point_In; + std::vector new_point = point; + std::vector zeroTemp; + std::stringstream ss; + std::vector MinimumList; + Minimum newMinimum; + + if ((finalT - currentT) / dT < 0) + { + // Step has the wrong sign + dT *= -1; + } + initialdT = dT; + + // Reduce the VEV into the same sector + ReduceVEV(point); + + // Remove flat directions + ConvertToNonFlatDirections(point); + + ss << "Tracking phase from T = " << currentT << " to T = " << finalT + << " | Starting minimum at = " << point << "\n"; + while ((finalT - currentT) / dT >= 0) + { + std::function)> V = [&](std::vector vev) + { + // Potential wrapper + std::vector res = this->modelPointer->MinimizeOrderVEV(vev); + return this->modelPointer->VEff(res, currentT) / + (1 + currentT * currentT); + }; + dV = [=](auto const &arg) { return NablaNumerical(arg, V, eps); }; + Hessian = [=](auto const &arg) { return HessianNumerical(arg, V, eps); }; + + // Locate the minimum + new_point = + LocateMinimum(point, dV, Hessian, 1e-4 * GradientThreshold * dim); + + // Reduce the VEV into the same sector + ReduceVEV(new_point); + + // Remove flat directions + ConvertToNonFlatDirections(new_point); + + // Calculate the length of the gradient in the normal potential divided + // by the dimension of the VEV space + LengthGradient = + L2NormVector(dV(new_point)) / dim; // (1 + currentT * currentT) * + // Compare minimum and previous iteration + Distance = L2NormVector(new_point - point); + // Compute difference in energy between both minimum + PotentialDifference = V(new_point) - V(point); + + // If the minimum it n GeV away then we consider it a new phase + double ThresholdDistance = (double)dim; + if (abs(dT) < 1e-5) + { + break; + } + else if (LengthGradient > GradientThreshold or + Distance > ThresholdDistance or + std::any_of(new_point.begin(), + new_point.end(), + [](double v) { return isnan(v); })) + { + // Algorithm flew away. Going back one iteration. + // Decrease temperature step size + // Not a stationary point anymore. Going back one iteration. + // Decrease temperature step size + + ss << "\n\033[1;95m.-> | T = " << currentT + << " |Grad|/dim = " << LengthGradient << " | Distance = " << Distance + << " | |dphi/dT| = " << abs(Distance / dT) + << " | deltaV = " << PotentialDifference + << " | SEV = " << SmallestEigenvalue(new_point, Hessian) + << " | <-\033[0m\n"; + + if (initialT == currentT) + { + ss << "Could not locate the starting minimum at T = " << initialT + << " GeV."; + ss << " |Grad|/dim = " << L2NormVector(dV(point)) / dim + << " | Distance = " << Distance + << " | |dphi/dT| = " << abs(Distance / dT) + << " | deltaV = " << PotentialDifference + << " | SEV = " << SmallestEigenvalue(point, Hessian); + if (output) Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); + return MinimumList; + } + + currentT -= dT; + dT /= 10.; + } + else if (unprotected) + { + newMinimum.point = new_point; + newMinimum.temp = currentT; + newMinimum.potential = V(new_point) * (1 + currentT * currentT); + MinimumList.push_back(newMinimum); + point = new_point; + // Sucess minimum! + ss << "\033[1;32m.\033[0m"; + dT *= + .5 * ThresholdDistance / Distance; // Try to predict the best stepsize + if (abs(initialdT) <= abs(dT)) dT = initialdT; + } + else + { + // It is a nearby stationary point! + if (SmallestEigenvalue(new_point, Hessian) < 0) + { + if (IsInMin == -1) + { + zeroTemp = FindZeroSmallestEigenvalue( + point, currentT - dT, new_point, currentT); + if (zeroTemp.back() > 0) + { + currentT = zeroTemp.back(); + zeroTemp.pop_back(); + // Reduce the VEV into the same sector + ReduceVEV(zeroTemp); + // Remove flat directions + ConvertToNonFlatDirections(zeroTemp); + newMinimum.point = zeroTemp; + newMinimum.temp = currentT; + newMinimum.potential = V(zeroTemp) * (1 + currentT * currentT); + MinimumList.push_back(newMinimum); + } + // End tracking + break; + } + else + { + ss << "Calculation of Tc or phase tracker failed. T = " << currentT + << " GeV\t|\t Final T = " << finalT << " GeV\t|\t" + << LengthGradient << "\t|\t" + << SmallestEigenvalue(new_point, Hessian) << "\t"; + // Sucess saddle point! + ss << "\033[1;31m.\033[0m"; + if (output) Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); + ss.str(std::string()); + return MinimumList; // return if starts in a saddle point + } + IsInMin = 1; + } + else + { + if (IsInMin == 1) + { + // We should never be here. We only track minimum + break; + } + else + { + newMinimum.point = new_point; + newMinimum.temp = currentT; + newMinimum.potential = V(new_point) * (1 + currentT * currentT); + MinimumList.push_back(newMinimum); + // Sucess minimum! + ss << "\033[1;32m.\033[0m"; + dT *= .5 * ThresholdDistance / + Distance; // Try to predict the best stepsize + if (abs(initialdT) <= abs(dT)) dT = initialdT; + } + IsInMin = -1; + } + point = new_point; + } + + // Make sure that or step is not bigger than it should be and we overshot + // the next minimum + if (currentT == finalT) break; + bool SafeStep = abs(finalT - currentT) > abs(dT); + if (SafeStep) + currentT += dT; + else + currentT = finalT; + } + if (output) Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); + if (output) + Logger::Write(LoggingLevel::MinTracerDetailed, + "T = " + std::to_string(currentT) + " GeV"); + return MinimumList; +} + +void MinimumTracer::ReduceVEV(std::vector &vev) +{ + // Saveguard if GroupElements is not populated + if (GroupElements.size() == 0) return; + int MaximumMeasure = -1; + char *ptr; + std::string BinaryNumber; + for (auto GroupElement : GroupElements) + { + // Clean buffer + BinaryNumber.clear(); + // Feed buffer + for (size_t i = 0; i < vev.size(); i++) + BinaryNumber.append(std::to_string(vev[i] * GroupElement(i, i) >= + 1e-5)); // Heaviside function + + // Converto to decimal and compare + if (std::strtol(BinaryNumber.c_str(), &ptr, 2) > MaximumMeasure) + { + MaximumMeasure = std::strtol(BinaryNumber.c_str(), &ptr, 2); + for (size_t i = 0; i < vev.size(); i++) + vev[i] *= GroupElement(i, i); // Transform vev + } + + // Reached maximum measure + if (MaximumMeasure == pow(2, vev.size()) - 1) return; + } +} + +void MinimumTracer::ReduceVEV(Minimum &min) +{ + ReduceVEV(min.point); +} + +const std::vector> +MinimumTracer::WarpPath(const std::vector> &path, + const std::vector &T1, + const std::vector &F1, + const std::vector &T2, + const std::vector &F2) +{ + std::vector> r; + + for (std::size_t i = 0; i < path.size(); i++) + { + std::vector temp = path[i]; + for (std::size_t d = 0; d < temp.size(); d++) + { + // warp the path + if ((F1[d] - T1[d]) == 0) + temp[d] = T2[d] + (temp[d] - T1[d]); + else + temp[d] = T2[d] + (F2[d] - T2[d]) * (temp[d] - T1[d]) / (F1[d] - T1[d]); + } + r.push_back(temp); + } + return r; +} + +MinimumTracer::MinimumTracer() +{ +} + +MinimumTracer::MinimumTracer( + const std::shared_ptr &pointer_in, + const int &WhichMinimizer_in, + const bool &UseMultithreading_in) +{ + modelPointer = pointer_in; + WhichMinimizer = WhichMinimizer_in; + UseMultithreading = UseMultithreading_in; + + FindDiscreteSymmetries(); + FindFlatDirections(); +} + +void MinimumTracer::FindFlatDirections() +{ + // The number 2, 100, 200 were choosen arbitrarily as an example of a S0(3) + // rotation + auto nvev = this->modelPointer->get_nVEV(); + auto vev_order = this->modelPointer->Get_VevOrder(); + + std::vector point = std::vector(nvev, 1); + + // initializsation of vector NonFlatDirections + NonFlatDirections = std::vector(nvev, 1); + + double res_1, res_2; + + // 3-dimensional flat directions (SO(3)) + for (std::size_t i = 0; i < nvev; i++) + { + for (std::size_t j = i + 1; j < nvev; j++) + { + for (std::size_t k = j; k < nvev; k++) + { + point.at(i) = 2; + point.at(j) = 100; + point.at(k) = 200; + res_1 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + point.at(i) = 2; + point.at(j) = 200; + point.at(k) = 100; + res_2 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + if (almost_the_same(res_1, res_2, 1e-8)) + { + point.at(i) = 100; + point.at(j) = 2; + point.at(k) = 200; + res_1 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + if (almost_the_same(res_1, res_2, 1e-8)) + { + point.at(i) = 100; + point.at(j) = 200; + point.at(k) = 2; + res_2 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + if (almost_the_same(res_1, res_2, 1e-8)) + { + point.at(i) = 200; + point.at(j) = 2; + point.at(k) = 100; + res_1 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + if (almost_the_same(res_1, res_2, 1e-8)) + { + point.at(i) = 200; + point.at(j) = 100; + point.at(k) = 2; + res_2 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + if (almost_the_same(res_1, res_2, 1e-8)) + { + NonFlatDirections.at(j) = 0; // choose one point in sphere + NonFlatDirections.at(k) = 0; // choose one point in sphere + flat_dirs_found = true; + flat_3D_dirs.push_back(std::vector({i, j, k})); + } + } + } + } + } + + point.at(i) = 1; + point.at(j) = 1; + point.at(k) = 1; + } + } + } + + // 2-dimensional flat directions (SO(2)) + // The number 2, 100 were choosen arbitrarily as an example of a S0(2) + // rotation + for (std::size_t i = 0; i < nvev; i++) + { + for (std::size_t j = i + 1; j < nvev; j++) + { + point.at(i) = 2; + point.at(j) = 100; + res_1 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + point.at(i) = 100; + point.at(j) = 2; + res_2 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + point.at(i) = 1; + point.at(j) = 1; + + if (almost_the_same(res_1, res_2, 1e-8)) + { + NonFlatDirections.at(j) = 0; // choose one point in circle + flat_dirs_found = true; + flat_2D_dirs.push_back(std::vector({i, j})); + } + } + } + + // 1-dimensional flat directions + for (std::size_t i = 0; i < nvev; i++) + { + point.at(i) = 2; + res_1 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + point.at(i) = 100; + res_2 = this->modelPointer->VEff( + this->modelPointer->MinimizeOrderVEV(point), 0, 0, 0); + point.at(i) = 1; + + if (almost_the_same(res_1, res_2, 1e-8)) + { + NonFlatDirections.at(i) = 0; // choose one field point in well + flat_dirs_found = true; + flat_1D_dirs.push_back(i); + } + } + + // todo: higher-dimensional flat directions + + if (flat_dirs_found) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Flat directions encountered!"); + if (flat_1D_dirs.size() > 0) + { + for (auto ind : flat_1D_dirs) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Field index " + std::to_string(ind) + + " identified as 1D flat direction."); + } + } + else if (flat_2D_dirs.size() > 0) + { + for (auto inds : flat_2D_dirs) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Field index (" + vec_to_string(inds) + + ") identified as 2D flat direction."); + } + } + else if (flat_3D_dirs.size() > 0) + { + for (auto inds : flat_3D_dirs) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Field index (" + vec_to_string(inds) + + ") identified as 3D flat direction."); + } + } + Logger::Write(LoggingLevel::MinTracerDetailed, + "Choosing minimal set of field " + "directions as: " + + vec_to_string(NonFlatDirections)); + } + // Remove duplicates + flat_1D_dirs.erase(unique(flat_1D_dirs.begin(), flat_1D_dirs.end()), + flat_1D_dirs.end()); + flat_2D_dirs.erase(unique(flat_2D_dirs.begin(), flat_2D_dirs.end()), + flat_2D_dirs.end()); + flat_3D_dirs.erase(unique(flat_3D_dirs.begin(), flat_3D_dirs.end()), + flat_3D_dirs.end()); + return; +} + +void MinimumTracer::ConvertToNonFlatDirections(std::vector &point) +{ + if (flat_dirs_found) // flat directions in point + { + for (const auto &pair : flat_2D_dirs) + { + auto a = point.at(pair.at(0)); + auto b = point.at(pair.at(1)); + auto c = std::sqrt(a * a + b * b); + point.at(pair.at(0)) = c; + point.at(pair.at(1)) = 0; + } + } + + return; +} + +void MinimumTracer::FindDiscreteSymmetries() +{ + const double GroupElementslMaximumRelativeError = + 1e-8; // Maximum value of |V/GroupElements(V)-1| + const size_t NumberOfGroupElementsChecks = + 10; // Number of times GroupElements is checked + const size_t dim = modelPointer->get_nVEV(); // Number of VEVs + + std::function V = [&](Eigen::VectorXd vev) + { + // Potential wrapper at T=0 for tree-level potential + std::vector res = this->modelPointer->MinimizeOrderVEV( + std::vector(vev.data(), vev.data() + vev.size())); + return this->modelPointer->VEff(res, 0, 0, 0); + }; + + // Generate random VEV + srand(time(NULL)); + const long max_rand = 1000000L; + std::function GenerateRandomVEV = [&]() + { + Eigen::VectorXd res(dim); + for (auto &m : res) + m = 1. + 299. * (rand() % max_rand) / max_rand; + return res; + }; + + // Check if potential is invariant under group element + std::function CheckGroupElement = + [&](Eigen::MatrixXd GroupElement) + { + int result = 1; + for (std::size_t it = 0; it < NumberOfGroupElementsChecks; it++) + { + auto RandomVEV = GenerateRandomVEV(); + result *= (abs(V(RandomVEV) / V(GroupElement * RandomVEV) - 1) < + GroupElementslMaximumRelativeError); + } + return result; + }; + + // Store available possible + std::vector C2GroupElements, SnGroupElements, + StoreGroupElements; + + // n-plet of C2 + for (std::size_t C2Nplet = 0; C2Nplet <= dim; C2Nplet++) + { + // Construct bitmask. bx11...000 + std::string bitmask(C2Nplet, 1); // C2Nplet leading 1's + bitmask.resize(dim, 0); // NVEV - C2Nplet trailing 0's + do // Permute bitmask + { + // Start with identity matrix + Eigen::MatrixXd C2_element = MatrixXd::Identity(dim, dim); + for (std::size_t i = 0; i < dim; ++i) // Flip i element + { + if (bitmask[i]) C2_element(i, i) = -1; + } + C2GroupElements.push_back(C2_element); + } while (std::prev_permutation(bitmask.begin(), bitmask.end())); + } + + /* + Currently permutations of VEV is not working + + Eigen::PermutationMatrix PermutationMatrix(dim); + PermutationMatrix.setIdentity(); + do + { + SnGroupElements.push_back(Eigen::MatrixXd(PermutationMatrix)); + } while (std::next_permutation(PermutationMatrix.indices().begin(), + PermutationMatrix.indices().end())); + */ + SnGroupElements.push_back(MatrixXd::Identity(dim, dim)); + + // Save all group elements that keep V invariant. + for (auto SnGroupElement : SnGroupElements) + for (auto C2GroupElement : C2GroupElements) + { + if (CheckGroupElement(SnGroupElement * C2GroupElement)) + StoreGroupElements.push_back(SnGroupElement * C2GroupElement); + } + + // Save all group elements + this->GroupElements = StoreGroupElements; +} + +std::vector +MinimumTracer::ConvertToVEVDim(const std::vector &point) +{ + std::vector point_out; + auto VevOrder = this->modelPointer->Get_VevOrder(); + + for (std::size_t i : VevOrder) + { + point_out.push_back(point.at(i)); + } + + return point_out; +} + +std::vector +MinimumTracer::GetGlobalMinimum(const double &Temp, + std::vector &check, + const std::vector &start) +{ + return this->modelPointer->MinimizeOrderVEV( + Minimizer::Minimize_gen_all(this->modelPointer, + Temp, + check, + start, + this->WhichMinimizer, + this->UseMultithreading)); +} + +std::vector +MinimumTracer::GetGlobalMinimum(const double &Temp, + const std::vector &start) +{ + std::vector check; + return this->GetGlobalMinimum(Temp, check, start); +} + +std::vector MinimumTracer::GetGlobalMinimum(const double &Temp) +{ + return this->GetGlobalMinimum( + Temp, std::vector(modelPointer->get_NHiggs(), 0)); +} + +void MinimumTracer::IsGlobMin(Minimum &min) +{ + double num_error = 1; + double diff = 0; + std::vector diff_vec; + + auto glob_min = + this->ConvertToVEVDim(this->GetGlobalMinimum(min.temp, min.point)); + + ReduceVEV(glob_min); + ConvertToNonFlatDirections(glob_min); + + auto test_min = min.point; + ReduceVEV(test_min); + ConvertToNonFlatDirections(test_min); + + for (std::size_t i = 0; i < glob_min.size(); i++) + { + diff_vec.push_back(glob_min.at(i) - test_min.at(i)); + } + diff = L2NormVector(diff_vec); + + if (diff < num_error) // min coincides with global minimum + { + min.is_glob_min = true; + } + else // min does not coincide with global minimum + { + min.is_glob_min = false; + } + + return; +} + +StatusNLOStability MinimumTracer::GetStatusNLOVEV(const bool &out) +{ + std::string status; + if (out) + { + return StatusNLOStability::Success; + }; + return StatusNLOStability::NoNLOStability; +} + +StatusEWSR MinimumTracer::GetStatusEWSR(const int &out) +{ + switch (out) + { + case 3: + Logger::Write(LoggingLevel::MinTracerDetailed, + "There is EW symmetry restoration."); + return StatusEWSR::EWSymRes; + break; + case 2: + Logger::Write(LoggingLevel::MinTracerDetailed, + "There is no EW symmetry restoration."); + return StatusEWSR::EWSymNonRes; + break; + case 1: + Logger::Write(LoggingLevel::MinTracerDetailed, + "There is a flat region at high temperature. More orders are " + "needed to lift degeneracy."); + return StatusEWSR::FlatRegion; + break; + case 0: + Logger::Write(LoggingLevel::MinTracerDetailed, + "High temperature symmetry restoration calculation not " + "found. Check is inconclusive."); + return StatusEWSR::Failure; + break; + case -1: + Logger::Write(LoggingLevel::MinTracerDetailed, + "Potential not bounded from below at high temperature."); + return StatusEWSR::NotBFB; + break; + } + return StatusEWSR::Failure; +} + +int MinimumTracer::IsThereEWSymmetryRestoration() +{ + double T; + double ActualSmallestEigenvalue = 0; + double OldSmallestEigenvalue = 1e100; + double EvenOlderSmallestEigenvalue = 1e200; + double eps = 0.1; + double treshold = 1e-6; + double Tmax = 1e10; + std::vector gradient, stationary_point; + size_t dim = this->modelPointer->get_nVEV(); + std::vector point(dim, 0); + + Eigen::VectorXd GradientEigen; + Eigen::MatrixXd HessianEigen(dim, dim); + + std::function(std::vector)> dV; + std::function)> V; + std::function>(std::vector)> Hessian; + + Logger::Write(LoggingLevel::MinTracerDetailed, + "Starting symmetry restoration check"); + + for (double exponentT = 0; exponentT <= log(Tmax); + exponentT += log(Tmax) / (20 * log(Tmax))) + { + T = exp(exponentT); + // wrappers for potential, first and second numerical derivative + V = [&](std::vector vev) + { + std::vector res = this->modelPointer->MinimizeOrderVEV(vev); + if (C_UseParwani) + return this->modelPointer->VEff(res, T) / (1 + T * T * log(T * T)); + return this->modelPointer->VEff(res, T) / (1 + T * T); + }; + dV = [=](auto const &arg) { return NablaNumerical(arg, V, eps); }; + Hessian = [=](auto const &arg) { return HessianNumerical(arg, V, eps); }; + + ActualSmallestEigenvalue = SmallestEigenvalue(point, Hessian); + + if (abs(ActualSmallestEigenvalue / OldSmallestEigenvalue - 1) < treshold and + abs(ActualSmallestEigenvalue / EvenOlderSmallestEigenvalue - 1) < + treshold) // V/T^2 constant enough in T + { + // Save into Eigen objects + gradient = dV(point); + GradientEigen = Eigen::Map( + gradient.data(), gradient.size()); + for (std::size_t i = 0; i < dim; i++) + { + HessianEigen.col(i) = + Eigen::Map(Hessian(point)[i].data(), dim); + } + break; + } + EvenOlderSmallestEigenvalue = OldSmallestEigenvalue; + OldSmallestEigenvalue = ActualSmallestEigenvalue; + } + + if (GradientEigen.size() == 0) return 0; // Convergence was never met + + if (ActualSmallestEigenvalue < 0) // Potential is not positively definite. + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Smallest eigenvalue at high temperature is\t" + + std::to_string(ActualSmallestEigenvalue)); + return -1; + } + + if (ActualSmallestEigenvalue == 0) // Potential is not positively definite. + return 1; + + Eigen::VectorXd StationaryPoint = + HessianEigen.colPivHouseholderQr().solve(GradientEigen); + + // Locate global stationary point + point = std::vector(StationaryPoint.data(), + StationaryPoint.data() + StationaryPoint.size()); + + // Check if point is reasonable. + for (const auto &vev : point) + if (isnan(vev)) return 0; + + // Save global minimum to use as seed point for the high temperature VEV + HighTemperatureVEV = point; + + auto glob_min_vev_dim = modelPointer->MinimizeOrderVEV(point); + auto EWVEV = this->modelPointer->EWSBVEV(glob_min_vev_dim); + if (EWVEV <= 0.5) // Symmetry restoration + { + return 3; // temperature for EW SR + } + else // (EWVEV > 0.5) EW is broken at high temperature + { + return 2; // SNR + } +} + +CoexPhases::CoexPhases() +{ +} + +CoexPhases::CoexPhases(const int &pair_id_in, + const Phase &false_phase_in, + const Phase &true_phase_in, + const double &Tlow_in, + const double &Thigh_in) +{ + coex_pair_id = pair_id_in; + false_phase = false_phase_in; + true_phase = true_phase_in; + T_high = Thigh_in; + T_low = Tlow_in; + + CalculateTc(); +} + +void CoexPhases::CalculateTc() +{ + Logger::Write(LoggingLevel::MinTracerDetailed, + "Calculating critical temperature between false phase " + + std::to_string(false_phase.id) + " and true phase " + + std::to_string(true_phase.id)); + + // deltaV has to be negative for the transition to occur + auto deltaV = [&](double T) + { return true_phase.Get(T).potential - false_phase.Get(T).potential; }; + + /// Ploting deltaV + std::stringstream ss; + AsciiPlotter plotter("dV(T) = V(True Vacuum) - V(False Vacuum) | Phase " + + std::to_string(false_phase.id) + " -> Phase " + + std::to_string(true_phase.id), + 100, + 35); + std::vector plotT, plotDeltaV, plot0; + for (double T = T_low; T <= T_high; T += (T_high - T_low) / 100) + { + plotT.push_back(T); + plotDeltaV.push_back(deltaV(T)); + plot0.push_back(0); + } + plotter.addPlot(plotT, plot0, "", '.'); + plotter.addPlot(plotT, plotDeltaV, "dV", '*'); + + plotter.xlabel("T (GeV)"); + plotter.ylabel("dV (GeV)"); + plotter.show(ss); + Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); + + if (deltaV(T_high) > 0 and deltaV(T_low) > 0) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "True vacuum candidate is never energetically viable."); + + crit_status = BSMPT::StatusCrit::FalseLower; + crit_temp = -1; + } + else if (deltaV(T_high) < 0 and deltaV(T_low) < 0) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "True vacuum candidate is always energetically " + "viable.\nCritical temperature identified at Tc = " + + std::to_string(T_high) + " GeV"); + + crit_status = BSMPT::StatusCrit::TrueLower; + crit_temp = T_high; + } + else if (deltaV(T_high) > 0 and deltaV(T_low) < 0) + { + // Binary search + double binaryLowT = T_low; + double binaryMiddleT = T_low; + double binaryHighT = T_high; + while (abs(binaryHighT / binaryLowT - 1) > 1e-10) + { + binaryMiddleT = (binaryHighT + binaryLowT) / 2; + + if (deltaV(binaryMiddleT) > 0) + { + binaryHighT = binaryMiddleT; + } + else + { + binaryLowT = binaryMiddleT; + } + } + Logger::Write(LoggingLevel::MinTracerDetailed, + "Critical temperature identified at Tc = " + + std::to_string(binaryMiddleT) + " GeV"); + + crit_status = BSMPT::StatusCrit::Success; + crit_temp = binaryMiddleT; + } + else + { + Logger::Write( + LoggingLevel::MinTracerDetailed, + "False vacuum phase ends as the global minimum. New phase scan is " + "needed!"); + crit_status = BSMPT::StatusCrit::Failure; + crit_temp = -2; + } + return; +} + +std::vector> +Create1DimGrid(const std::vector &point, + const int k, + const double low_value, + const double high_value, + const int nsteps) +{ + std::vector> res_vec; + std::vector res = point; + double distance = high_value - low_value; + + if (nsteps == 0) + { + res_vec.push_back(res); + return res_vec; + } + else + { + double stepsize = distance / nsteps; + + for (int i = 0; i <= nsteps; i++) + { + res.at(k) = low_value + i * stepsize; + res_vec.push_back(res); + } + return res_vec; + } +} + +std::vector> +Create1DimGrid(const std::vector &min_start, + const std::vector &min_end, + const int npoints) +{ + std::vector> res_vec; + res_vec.push_back(min_start); + auto diff_vec = min_end - min_start; + if (npoints > 0) + { + auto step_vec = 1. / npoints * diff_vec; + for (int i = 1; i <= npoints; i++) + { + res_vec.push_back(min_start + i * step_vec); + } + } + return res_vec; +} + +bool almost_the_same(const double &a, + const double &b, + const double &rel_precision, + const double &num_zero) +{ + if (std::abs(a) < num_zero and std::abs(b) < num_zero) + { + return true; + } + return std::abs(a - b) < std::abs(a + b) / 2 * rel_precision; +} + +bool almost_the_same(const std::vector &a, + const std::vector &b, + const bool &allow_for_sign_flip, + const double &rel_precision, + const double &num_zero) +{ + if (a.size() != b.size()) + { + throw std::runtime_error("Error. Vectors must have the same size."); + } + int count_true = 0; + for (std::size_t i = 0; i < a.size(); i++) + { + if (allow_for_sign_flip) + { + count_true += + int(almost_the_same(a.at(i), b.at(i), rel_precision, num_zero)); + } + else + { + count_true += int(almost_the_same( + std::abs(a.at(i)), std::abs(b.at(i)), rel_precision, num_zero)); + } + } + if (std::size_t(count_true) == a.size()) + { + return true; + } + else + { + return false; + } +} + +Phase::Phase() +{ +} + +Phase::Phase(const std::vector &phase_start, + const double &initialT, + const double &finalT, + double &globMinEndT, + std::shared_ptr &MinTracerIn) +{ + MinTracer = MinTracerIn; + // Save point + std::vector phase = phase_start; + // Reduce the VEV into the same sector + MinTracer->ReduceVEV(phase); + // Remove flat directions + MinTracer->ConvertToNonFlatDirections(phase); + std::vector MinimumList = + MinTracer->TrackPhase(globMinEndT, phase, initialT, finalT); + + if (MinimumList.size() == 0) return; // Minimum tracker failed + + for (auto Min : MinimumList) + { + Add(Min); + } + + T_low = MinimumPhaseVector.front().temp; + T_high = MinimumPhaseVector.back().temp; +} + +Phase::Phase(const double &initialT, + const std::vector &phase_start, + const double &LowT, + const double &HighT, + double &globMinEndT, + std::shared_ptr &MinTracerIn) +{ + MinTracer = MinTracerIn; + // Save point + std::vector phase = phase_start; + // Reduce the VEV into the same sector + MinTracer->ReduceVEV(phase); + // Remove flat directions + MinTracer->ConvertToNonFlatDirections(phase); + + std::vector MinimumListHigh = + MinTracer->TrackPhase(globMinEndT, phase, initialT, HighT); + std::vector MinimumListLow = + MinTracer->TrackPhase(globMinEndT, phase, initialT, LowT); + + for (auto Min : MinimumListHigh) + { + Add(Min); + } + for (auto Min : MinimumListLow) + { + Add(Min); + } + + if (MinimumPhaseVector.size() == 0) return; // Found no minimum + + T_low = MinimumPhaseVector.front().temp; + T_high = MinimumPhaseVector.back().temp; +} + +Phase::Phase(const std::vector &phase_start, + const double &initialT, + const double &finalT, + std::shared_ptr &MinTracerIn) +{ + MinTracer = MinTracerIn; + // Save point + std::vector phase = phase_start; + // Reduce the VEV into the same sector + MinTracer->ReduceVEV(phase); + // Remove flat directions + MinTracer->ConvertToNonFlatDirections(phase); + + std::vector MinimumList = + MinTracer->TrackPhase(phase, initialT, finalT); + + if (MinimumList.size() == 0) return; // Minimum tracker failed + + for (auto Min : MinimumList) + { + Add(Min); + } + + T_low = MinimumPhaseVector.front().temp; + T_high = MinimumPhaseVector.back().temp; +} + +Phase::Phase(const double &initialT, + const std::vector &phase_start, + const double &LowT, + const double &HighT, + std::shared_ptr &MinTracerIn) +{ + MinTracer = MinTracerIn; + // Save point + std::vector phase = phase_start; + // Reduce the VEV into the same sector + MinTracer->ReduceVEV(phase); + // Remove flat directions + MinTracer->ConvertToNonFlatDirections(phase); + + std::vector MinimumListHigh = + MinTracer->TrackPhase(phase, initialT, HighT); + std::vector MinimumListLow = + MinTracer->TrackPhase(phase, initialT, LowT); + + for (auto Min : MinimumListHigh) + { + Add(Min); + } + for (auto Min : MinimumListLow) + { + Add(Min); + } + + if (MinimumPhaseVector.size() == 0) return; // Found no minimum + + T_low = MinimumPhaseVector.front().temp; + T_high = MinimumPhaseVector.back().temp; +} + +Phase::Phase(const double &initialT, + const double &LowT, + const double &HighT, + std::shared_ptr &MinTracerIn) +{ + MinTracer = MinTracerIn; + std::vector phase_start = + MinTracer->ConvertToVEVDim(MinTracer->GetGlobalMinimum(initialT)); + + // Reduce the VEV into the same sector + MinTracer->ReduceVEV(phase_start); + // Remove flat directions + MinTracer->ConvertToNonFlatDirections(phase_start); + + if (initialT == LowT) + { + std::vector MinimumList = + MinTracer->TrackPhase(phase_start, initialT, HighT); + + if (MinimumList.size() == 0) return; // Minimum tracker failed + + for (auto Min : MinimumList) + { + Add(Min); + } + } + else if (initialT == HighT) + { + std::vector MinimumList = + MinTracer->TrackPhase(phase_start, initialT, LowT); + + if (MinimumList.size() == 0) return; // Minimum tracker failed + + for (auto Min : MinimumList) + { + Add(Min); + } + } + else if ((initialT < HighT and initialT > LowT) or + (initialT < LowT and initialT > HighT)) + { + std::vector MinimumListHigh = + MinTracer->TrackPhase(phase_start, initialT, HighT); + std::vector MinimumListLow = + MinTracer->TrackPhase(phase_start, initialT, LowT); + + for (auto Min : MinimumListHigh) + { + Add(Min); + } + for (auto Min : MinimumListLow) + { + Add(Min); + } + } + else + { + throw std::invalid_argument("Initial temperature out of bounds."); + } + + if (MinimumPhaseVector.size() == 0) return; // Found no minimum + + T_low = MinimumPhaseVector.front().temp; + T_high = MinimumPhaseVector.back().temp; +} + +Minimum Phase::Get(double T) +{ + if (T > T_high or T < T_low) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Tried to Get() the minimum outside temperature range of " + "the phase."); + } + + double error = 1e100; + Minimum bestGuess; + // Compute minimum closes to the desired temperature + for (auto min = MinimumPhaseVector.begin(); min < MinimumPhaseVector.end(); + ++min) + { + if (abs(T - min->temp) < error) + { + error = abs(T - min->temp); + bestGuess = *min; + } + } + if (error == 0) + { + // Minimum already in the list + return bestGuess; + } + std::vector MinimumList = MinTracer->TrackPhase( + bestGuess.point, bestGuess.temp, T, (T - bestGuess.temp), false, true); + // Check if the TrackPhase fails + if (MinimumList.size() > 0) + { + // Add new knots to the list so that Phase keeps track of the + // new minmum information + for (auto Min : MinimumList) + { + Add(Min); + } + // Check if last minimum found is what we wanted + if (MinimumList.back().temp != T) + BSMPT::Logger::Write( + BSMPT::LoggingLevel::MinTracerDetailed, + "Minimum tracker did not find the minimum at temperature " + + std::to_string(T) + + ", returning instead minimum at temperature " + + std::to_string(MinimumList.back().temp) + + " | dT = " + std::to_string(MinimumList.back().temp - T)); + // Return desired point + return MinimumList.back(); + } + return bestGuess; +} + +void Phase::Add(Minimum min) +{ + // Check if phase is already there + for (std::size_t i = 0; i < MinimumPhaseVector.size(); i++) + { + if (min.temp == MinimumPhaseVector[i].temp) + { + return; + } + } + // If the list is empty add that value in. + if (MinimumPhaseVector.size() == 0) + { + MinimumPhaseVector = {min}; + return; + } + // Temperature is the lowest yet. + if (min.temp < MinimumPhaseVector[0].temp) + { + // update EdgeOfPhase + MinimumPhaseVector.front().EdgeOfPhase = 0; + min.EdgeOfPhase = -1; + // insert min to begin of phase vector + MinimumPhaseVector.insert(MinimumPhaseVector.begin(), min); + T_low = min.temp; + return; + } + // Is the temperature in the middle of other temperatures? + for (std::size_t i = 0; i < MinimumPhaseVector.size() - 1; i++) + { + if (min.temp > MinimumPhaseVector[i].temp and + min.temp < MinimumPhaseVector[i + 1].temp) + { + MinimumPhaseVector.insert(MinimumPhaseVector.begin() + i + 1, min); + return; + } + } + // If not, it is the biggest temperature yet, add it to the end and update + // EdgeOfPhase + MinimumPhaseVector.back().EdgeOfPhase = 0; + min.EdgeOfPhase = 1; + + MinimumPhaseVector.push_back(min); + T_high = min.temp; + + return; +} + +void Vacuum::MultiStepPTMode0(const std::vector &LowTempPoint_in, + const std::vector &HighTempPoint_in) +{ + auto LowTempPoint = LowTempPoint_in; + auto HighTempPoint = HighTempPoint_in; + + Logger::Write(LoggingLevel::MinTracerDetailed, + "Low-temperature phase starts at " + + vec_to_string(LowTempPoint) + "\n"); + Phase LowTempPhase(LowTempPoint, T_low, T_high, MinTracer); + T_high_lowTempPhase = LowTempPhase.T_high; + Logger::Write(LoggingLevel::MinTracerDetailed, + "Low-temperature phase exists until T = " + + std::to_string(T_high_lowTempPhase) + " GeV"); + if (LowTempPhase.MinimumPhaseVector.size() > 1) addPhase(LowTempPhase); + + Logger::Write(LoggingLevel::MinTracerDetailed, + "High-temperature phase starts at T = " + + vec_to_string(HighTempPoint) + " GeV"); + Phase HighTempPhase(HighTempPoint, T_high, T_low, MinTracer); + T_low_highTempPhase = HighTempPhase.T_low; + Logger::Write(LoggingLevel::MinTracerDetailed, + "High-temperature phase exists until T = " + + std::to_string(T_low_highTempPhase) + " GeV"); + if (HighTempPhase.MinimumPhaseVector.size() > 1) addPhase(HighTempPhase); + + if (LowTempPhase.MinimumPhaseVector.size() > 1 and + HighTempPhase.MinimumPhaseVector.size() > 1) + { + bool whole_temp_region_traced = T_low_highTempPhase < T_high_lowTempPhase; + + if (whole_temp_region_traced) + { + bool glob_min_overlap = DoGlobMinOverlap(LowTempPhase, HighTempPhase); + + if (glob_min_overlap) + { + Logger::Write( + LoggingLevel::MinTracerDetailed, + "High- and low-temperature phase coexist in temperature range [" + + std::to_string(T_low_highTempPhase) + ", " + + std::to_string(T_high_lowTempPhase) + + "].\nand are " + "still global minimum outside overlap. One-step " + "PT identified. One-step PT mode 0 successful."); + } + else + { + Logger::Write( + LoggingLevel::MinTracerDetailed, + "High- and low-temperature phase coexist in temperature range [" + + std::to_string(T_low_highTempPhase) + ", " + + std::to_string(T_high_lowTempPhase) + + "].\nbut are " + "no longer global minimum outside overlap. " + "Tracing misses the global minimum in some areas " + "of temperature space. Try to re-run with " + "multi-step PT mode 2 enabled."); + status_vacuum = StatusTracing::NoGlobMinCoverage; + } + } + else + { + Logger::Write( + LoggingLevel::MinTracerDetailed, + "High- and low-temperature phase do not coexist in " + "temperature range. Possible multi-step PT detected. Try to re-run " + "with multi-step PT mode 1 enabled."); + status_vacuum = StatusTracing::NoCoverage; + } + } + else + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "No traceable global-minimum phases found at the outer " + "boundaries. Abort."); + status_vacuum = StatusTracing::NoMinsAtBoundaries; + } + return; +} + +bool Vacuum::DoPhasesOverlap(Phase &new_phase, Phase &old_phase) +{ + bool whole_region_covered = false; + + if (new_phase.T_high >= old_phase.T_low) + { + if (new_phase.T_low <= old_phase.T_high) + { + whole_region_covered = true; + } + } + + return whole_region_covered; +} + +bool Vacuum::DoGlobMinOverlap(const Phase &new_phase, const Phase &old_phase) +{ + bool global_minimum_overlap = false; + + if (new_phase.MinimumPhaseVector.size() > 1 and + old_phase.MinimumPhaseVector.size() > 1) + { + if (new_phase.T_high >= old_phase.T_low and + new_phase.T_low <= old_phase.T_high) // coverage check + { + Phase phase_low, phase_high; + if (new_phase.T_high >= old_phase.T_high) + { + phase_high = new_phase; + phase_low = old_phase; + } + else if (new_phase.T_low <= old_phase.T_low) + { + phase_high = old_phase; + phase_low = new_phase; + } + + // check for global minimum at innermost overlap + auto min_coex_high = phase_high.Get( + phase_low.T_high); // high-temperature phase minimum when + // low-temperature phase stops existing + auto min_coex_low = phase_low.Get( + phase_high.T_low); // low-temperature phase minimum when + // high-temperature phase stops existing + MinTracer->IsGlobMin(min_coex_high); + MinTracer->IsGlobMin(min_coex_low); + global_minimum_overlap = + min_coex_high.is_glob_min and min_coex_low.is_glob_min; + } + } + else + { + global_minimum_overlap = true; // phases have no length + } + + return global_minimum_overlap; +} + +void Vacuum::MultiStepPTMode1(const std::vector &LowTempPoint_in, + const std::vector &HighTempPoint_in) +{ + auto LowTempPoint = LowTempPoint_in; + auto HighTempPoint = HighTempPoint_in; + + Logger::Write(LoggingLevel::MinTracerDetailed, + "Low-temperature phase starts at T = " + + vec_to_string(LowTempPoint) + " GeV"); + Phase LowTempPhase(LowTempPoint, T_low, T_high, MinTracer); + T_high_lowTempPhase = LowTempPhase.T_high; + if (LowTempPhase.MinimumPhaseVector.size() > 1) + { + addPhase(LowTempPhase); + Logger::Write(LoggingLevel::MinTracerDetailed, + "Low-temperature phase exists until T = " + + std::to_string(T_high_lowTempPhase) + " GeV"); + } + + Logger::Write(LoggingLevel::MinTracerDetailed, + "High-temperature phase starts at " + + vec_to_string(HighTempPoint) + "\n"); + Phase HighTempPhase(HighTempPoint, T_high, T_low, MinTracer); + T_low_highTempPhase = HighTempPhase.T_low; + if (HighTempPhase.MinimumPhaseVector.size() > 1) + { + addPhase(HighTempPhase); + Logger::Write(LoggingLevel::MinTracerDetailed, + "High-temperature phase exists until T = " + + std::to_string(T_low_highTempPhase) + " GeV"); + } + + bool whole_temp_region_traced = DoPhasesOverlap(LowTempPhase, HighTempPhase); + bool sides_traced = whole_temp_region_traced; + + if (whole_temp_region_traced) + { + if (DoGlobMinOverlap(LowTempPhase, HighTempPhase)) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "High- and low-temperature phase coexist in " + "temperature range [" + + std::to_string(T_low_highTempPhase) + ", " + + std::to_string(T_high_lowTempPhase) + + "].\nand are " + "still global minimum outside overlap. One-step " + "PT identified. Multi-step PT mode 1 successful."); + } + else + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "High- and low-temperature phase overlap but are " + "no longer global minimum outside overlap. " + "Tracing misses the global minimum in some areas " + "of temperature space. Try to re-run with " + "multi-step PT mode 2 enabled."); + status_vacuum = StatusTracing::NoGlobMinCoverage; + } + } + else // check for phases in between + { + double tmp_low_highTempPhase = T_low_highTempPhase - 1, + tmp_high_lowTempPhase = T_high_lowTempPhase + 1; + + auto tmp_LowTempPhase = LowTempPhase; // previous low temperature phase + auto tmp_HighTempPhase = HighTempPhase; // previous high temperature phase + + bool global_minimum_overlap = true; + bool side_global_overlap = true; + bool error_detected = false; + + while (not whole_temp_region_traced and global_minimum_overlap and + not error_detected) + { + Phase LowTempPhaseMiddle(tmp_high_lowTempPhase, T_low, T_high, MinTracer); + Phase HighTempPhaseMiddle( + tmp_low_highTempPhase, T_low, T_high, MinTracer); + + if (LowTempPhaseMiddle.MinimumPhaseVector.size() > 1) + addPhase(LowTempPhaseMiddle); + if (HighTempPhaseMiddle.MinimumPhaseVector.size() > 1) + addPhase(HighTempPhaseMiddle); + + Logger::Write( + LoggingLevel::MinTracerDetailed, + "Intermediate phase at T = \t" + + std::to_string(tmp_high_lowTempPhase) + " GeV exists between [ " + + std::to_string(LowTempPhaseMiddle.T_low) + " , " + + std::to_string(LowTempPhaseMiddle.T_high) + + " ] GeV\nIntermediate phase at T = \t" + + std::to_string(tmp_low_highTempPhase) + " GeV exists between [ " + + std::to_string(HighTempPhaseMiddle.T_low) + " , " + + std::to_string(HighTempPhaseMiddle.T_high) + " ] Gev\n"); + + sides_traced = DoPhasesOverlap(tmp_LowTempPhase, LowTempPhaseMiddle) and + DoPhasesOverlap(tmp_HighTempPhase, + HighTempPhaseMiddle); // overlap at sides + + if (not sides_traced) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Numerical instability at phase overlap detected, no " + "coverage achieved."); + status_vacuum = StatusTracing::NoCoverage; + error_detected = true; + } + else + { + whole_temp_region_traced = + DoPhasesOverlap(LowTempPhaseMiddle, + HighTempPhaseMiddle); // innermost overlap + + if (whole_temp_region_traced) + { + side_global_overlap = + DoGlobMinOverlap(tmp_LowTempPhase, LowTempPhaseMiddle) and + DoGlobMinOverlap(tmp_HighTempPhase, HighTempPhaseMiddle); + + if (side_global_overlap) + { + // check for global minimum at innermost overlap + global_minimum_overlap = + DoGlobMinOverlap(LowTempPhaseMiddle, HighTempPhaseMiddle); + + if (global_minimum_overlap) // success + { + Logger::Write( + LoggingLevel::MinTracerDetailed, + "Innermost high- and low-temperature phase coexist in " + "temperature range " + "[" + + std::to_string(tmp_low_highTempPhase) + ", " + + std::to_string(tmp_high_lowTempPhase) + + "].\nand are " + "still global minimum outside overlap. Multi-step " + "PT identified. Multi-step PT overlap mode 1 " + "successful."); + } + else // no_glob_minimum_coverage + { + Logger::Write( + LoggingLevel::MinTracerDetailed, + "Innermost high- and low-temperature phase overlap but are " + "no longer global minimum outside overlap. " + "Tracing misses the global minimum in some areas " + "of temperature space. Try to re-run with " + "multi-step PT mode 2 enabled."); + status_vacuum = StatusTracing::NoGlobMinCoverage; + error_detected = true; + } + } + else // no_glob_minimum_coverage + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Tracing misses the global minimum in some areas " + "of temperature space. Try to re-run with " + "multi-step PT mode 2 enabled."); + status_vacuum = StatusTracing::NoGlobMinCoverage; + error_detected = true; + } + } + + tmp_low_highTempPhase = HighTempPhaseMiddle.T_low; + tmp_high_lowTempPhase = LowTempPhaseMiddle.T_high; + + tmp_LowTempPhase = LowTempPhaseMiddle; + tmp_HighTempPhase = HighTempPhaseMiddle; + } + } + } + + return; +} + +void Vacuum::MultiStepPTMode2(const std::vector &LowTempPoint_in, + const std::vector &HighTempPoint_in) +{ + auto LowTempPoint = LowTempPoint_in; + auto HighTempPoint = HighTempPoint_in; + + double T_low_newglob; + Phase LowTempPhase(LowTempPoint, T_low, T_high, T_low_newglob, MinTracer); + T_high_lowTempPhase = LowTempPhase.T_high; + Logger::Write(LoggingLevel::MinTracerDetailed, + "Low-temperature phase exists in T = [" + + std::to_string(LowTempPhase.T_low) + " , " + + std::to_string(LowTempPhase.T_high) + + "] GeV and is the global minimum in T = [" + + std::to_string(T_low) + " , " + + std::to_string(T_low_newglob) + "] GeV\n"); + if (LowTempPhase.MinimumPhaseVector.size() > 1) addPhase(LowTempPhase); + + double T_high_newglob; + Phase HighTempPhase(HighTempPoint, T_high, T_low, T_high_newglob, MinTracer); + T_low_highTempPhase = HighTempPhase.T_low; + Logger::Write(LoggingLevel::MinTracerDetailed, + "High-temperature phase exists until T = [" + + std::to_string(HighTempPhase.T_low) + " , " + + std::to_string(HighTempPhase.T_high) + + "] GeV and is the global minimum in T = [" + + std::to_string(T_high_newglob) + " , " + + std::to_string(T_high) + "] GeV\n"); + if (HighTempPhase.MinimumPhaseVector.size() > 1) addPhase(HighTempPhase); + + double deltaT = 1; + + double tmp_T_low_newglob = (LowTempPhase.T_high > T_low_newglob) + ? T_low_newglob + : T_low_newglob + deltaT; + double tmp_T_high_newglob = (HighTempPhase.T_low < T_high_newglob) + ? T_high_newglob + : T_high_newglob - deltaT; + double tmp_T_low_newglob_old, tmp_T_high_newglob_old; + + while (tmp_T_low_newglob < + tmp_T_high_newglob) // glob min not found in whole temp range + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Searching for phases in range T = [ " + + std::to_string(tmp_T_low_newglob) + ", " + + std::to_string(tmp_T_high_newglob) + " ] GeV\n"); + + // Low-temperature phase + LowTempPoint = MinTracer->ConvertToVEVDim( + MinTracer->GetGlobalMinimum(tmp_T_low_newglob)); + + Logger::Write( + LoggingLevel::MinTracerDetailed, + "Intermediate phase at T = " + std::to_string(tmp_T_low_newglob) + + " GeV with " + vec_to_string(LowTempPoint) + "\n"); + + tmp_T_low_newglob_old = tmp_T_low_newglob; + Phase LowTempPhaseMiddle(tmp_T_low_newglob_old, + LowTempPoint, + T_low, + T_high, + tmp_T_low_newglob, + MinTracer); + if (LowTempPhaseMiddle.T_low < LowTempPhaseMiddle.T_high) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Intermediate phase exists between T = [ " + + std::to_string(LowTempPhaseMiddle.T_low) + ", " + + std::to_string(LowTempPhaseMiddle.T_high) + " ] GeV\n"); + addPhase(LowTempPhaseMiddle); + } + else + { + if (tmp_T_low_newglob + 1 < T_high) + tmp_T_low_newglob += 1; // try to move out of problematic region + } + + // High-temperature phase + HighTempPoint = MinTracer->ConvertToVEVDim( + MinTracer->GetGlobalMinimum(tmp_T_high_newglob)); + + Logger::Write( + LoggingLevel::MinTracerDetailed, + "Intermediate phase at T = " + std::to_string(tmp_T_high_newglob) + + " GeV with " + vec_to_string(HighTempPoint) + "\n"); + + tmp_T_high_newglob_old = tmp_T_high_newglob; + Phase HighTempPhaseMiddle(tmp_T_high_newglob_old, + HighTempPoint, + T_low, + T_high, + tmp_T_high_newglob, + MinTracer); + if (HighTempPhaseMiddle.T_low < HighTempPhaseMiddle.T_high) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Intermediate phase exists between T = [ " + + std::to_string(HighTempPhaseMiddle.T_low) + ", " + + std::to_string(HighTempPhaseMiddle.T_high) + + " ] GeV\n"); + addPhase(HighTempPhaseMiddle); + } + else + { + if (tmp_T_high_newglob > T_low + 1) + tmp_T_high_newglob -= 1; // try to move out of problematic region + } + } + return; +} + +void Vacuum::PrintPhasesDiagram(int size) +{ + // If logger is disabled no need to calculate this + if (not Logger::GetLoggingLevelStatus(LoggingLevel::MinTracerDetailed)) + return; + + std::stringstream ss; + std::vector T_list; + std::vector> PhaseListPlot; + std::vector PlotList; + char markers[] = {".*ox-cs"}; + + for (std::size_t it = 0; it < modelPointer->get_nVEV(); it++) + PlotList.push_back( + AsciiPlotter(modelPointer->addLegendVEV()[it], size, ceil(size / 3.))); + + for (std::size_t it = 0; it < PhasesList.size(); it++) + { + int nBefore = + floor(size * (PhasesList[it].T_low - T_low) / (T_high - T_low)); + int nAfter = + floor(size * (T_high - PhasesList[it].T_high) / (T_high - T_low)); + int nPhase = size - nBefore - nAfter; + + // Calculate VEV positions + T_list.clear(); + PhaseListPlot.clear(); + for (int i = 0; i <= nPhase; i++) + { + T_list.push_back(PhasesList[it].T_low + + (i / double(nPhase)) * + (PhasesList[it].T_high - PhasesList[it].T_low)); + PhaseListPlot.push_back(PhasesList[it].Get(T_list.back()).point); + } + + // Calculate transpose + std::vector> PhaseListPlot_transpose( + PhaseListPlot[0].size(), std::vector(PhaseListPlot.size())); + for (size_t i = 0; i < PhaseListPlot.size(); ++i) + for (size_t j = 0; j < PhaseListPlot[0].size(); ++j) + PhaseListPlot_transpose[j][i] = PhaseListPlot[i][j]; + + // Do the plotting + for (size_t i = 0; i < modelPointer->get_nVEV(); i++) + PlotList[i].addPlot(T_list, + PhaseListPlot_transpose[i], + "Phase " + std::to_string(it), + markers[it % sizeof(markers)]); + + /*ss << "Phase " << std::setw(3) << it << " |" << std::string(nBefore, ' ') + << std::string(nPhase, '.') << std::string(nAfter, ' ') << "|" + << std::setw(7) << PhasesList[it].T_low << " - " << std::setw(7) + << PhasesList[it].T_high << "|\n";*/ + + // Print also starting and ending minima + ss << "Phase " << std::setw(3) << it << " |" << std::string(nBefore, ' ') + << std::string(nPhase, '.') << std::string(nAfter, ' ') << "|" + << std::setw(7) << PhasesList[it].T_low << " - " << std::setw(7) + << PhasesList[it].T_high << "|" + << std::setw(2 * modelPointer->get_nVEV()) << std::setprecision(3) + << PhasesList[it].MinimumPhaseVector.front().point << "|" + << std::setw(2 * modelPointer->get_nVEV()) + << PhasesList[it].MinimumPhaseVector.back().point << "\n"; + } + + for (std::size_t it = 0; it < modelPointer->get_nVEV(); it++) + { + PlotList[it].legend(); + PlotList[it].xlabel("T (GeV)"); + PlotList[it].ylabel("Phase"); + PlotList[it].show(ss); + } + + Logger::Write(LoggingLevel::MinTracerDetailed, ss.str()); +} + +Vacuum::Vacuum(const double &T_lowIn, + const double &T_highIn, + std::shared_ptr &MinTracerIn, + std::shared_ptr &modelPointerIn, + const int &UseMultiStepPTMode, + const int &num_pointsIn, + const bool &do_only_tracing) +{ + T_low = T_lowIn; + T_high = T_highIn; + MinTracer = MinTracerIn; + modelPointer = modelPointerIn; + num_points = num_pointsIn; + + status_vacuum = + StatusTracing::Success; // flipped to error code if error encountered + status_coex_pairs = StatusCoexPair::NoCoexPairs; // flipped to success if coex + // phase pairs found + + if (UseMultiStepPTMode == -1) // default + { + MultiStepPTTracer(T_high); + } + else if (UseMultiStepPTMode >= 0) + { + std::vector start_lowmin, start_highmin; + for (std::size_t k = 0; k < modelPointer->get_nVEV(); k++) + { + start_lowmin.push_back(modelPointer->get_vevTreeMin(k)); + start_highmin.push_back(0); + } + + std::vector LowTempPoint = MinTracer->ConvertToVEVDim( + MinTracer->GetGlobalMinimum(T_low, start_lowmin)); + + if (this->modelPointer->EWSBVEV( + this->modelPointer->MinimizeOrderVEV(LowTempPoint)) > 1e10) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Potential non-BFB at T = 0."); + status_vacuum = StatusTracing::Failure; + return; + } + + std::vector HighTempPoint; + if (MinTracer->HighTemperatureVEV.size() > 0) + { + HighTempPoint = MinTracer->HighTemperatureVEV; + } + else + { + HighTempPoint = MinTracer->ConvertToVEVDim( + MinTracer->GetGlobalMinimum(T_high, start_highmin)); + } + + if (UseMultiStepPTMode == 0) // single-step phase transition mode + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Running multi-step PT mode 0."); + MultiStepPTMode0(LowTempPoint, HighTempPoint); + } + else if (UseMultiStepPTMode == 1) // enforce tracing coverage + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Running multi-step PT mode 1."); + MultiStepPTMode1(LowTempPoint, HighTempPoint); + } + else if (UseMultiStepPTMode == 2) // enforce global minimum tracing coverage + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Running multi-step PT mode 2."); + MultiStepPTMode2(LowTempPoint, HighTempPoint); + } + else if (UseMultiStepPTMode == 3) // automatic mode + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Running multi-step PT mode auto."); + MultiStepPTMode1(LowTempPoint, HighTempPoint); + if (status_vacuum == StatusTracing::NoGlobMinCoverage) + { + status_vacuum = StatusTracing::Success; + MultiStepPTMode2(LowTempPoint, HighTempPoint); + } + } + } + + // trace EW minimum (still at least a local minimum) + Minimum EWMin; + EWMin.temp = 0; + EWMin.point = modelPointer->get_vevTreeMin(); + if (MinimumFoundAlready(EWMin) == -1) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Tracking the EW minimum at " + vec_to_string(EWMin.point)); + Phase EWphase(EWMin.point, T_low, T_high, MinTracer); + addPhase(EWphase); + print(EWphase); + } + else + Logger::Write(LoggingLevel::MinTracerDetailed, "EW minimum already found."); + + // VEVs found from minima splitting + std::vector SavedMinimaFromVEVSplitting_Copy = + MinTracer->SavedMinimaFromVEVSplitting; // Make a copy of the found phases + for (auto Min : SavedMinimaFromVEVSplitting_Copy) + { + if (MinimumFoundAlready(Min) > -1) continue; + Logger::Write(LoggingLevel::MinTracerDetailed, + "Found a new phase from VEV splitting at T = " + + std::to_string(Min.temp)); + Phase newPhase(Min.temp, Min.point, T_low, T_high, MinTracer); + addPhase(newPhase); + print(newPhase); + } + + if (PhasesList.size() == 0) // no phases could be found + { + status_vacuum = StatusTracing::Failure; + } + + if (status_vacuum == StatusTracing::Success or + (UseMultiStepPTMode != 0 and + status_vacuum == StatusTracing::NoCoverage)) // no_coverage can get fixed + // in setCoexRegion + { + // sort phases in decending T_high + std::sort(PhasesList.begin(), + PhasesList.end(), + [](auto a, auto b) { return a.T_high > b.T_high; }); + + // assign ids to phases + for (std::size_t i = 0; i < PhasesList.size(); i++) + { + PhasesList[i].id = i; + } + + // identify coexisiting phase regions + setCoexRegion(UseMultiStepPTMode); // can flip status_vacuum to error code + + if (PhasesList.size() > 0) + { + PrintPhasesDiagram(); + } + + if ((status_coex_pairs == StatusCoexPair::Success) and + (not do_only_tracing)) + { + // identify coexisting phase pairs + setCoexPhases(); + } + } + + return; +} + +void Vacuum::MultiStepPTTracer(const double &Temp, const double &deltaT) +{ + if (Temp <= T_low) + { + auto glob_min = MinTracer->GetGlobalMinimum(T_low); + if (this->modelPointer->EWSBVEV(glob_min) > 1e10) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Potential non-BFB at T = 0."); + status_vacuum = StatusTracing::Failure; + } + else + { + // low temperature phase + Phase phase(T_low, T_low, T_high, MinTracer); + addPhase(phase); + print(phase); + + // test equally-spaced point grid + for (int i = 1; i <= num_points; i++) + { + Minimum min; + min.temp = T_low + (T_high - T_low) / (num_points + 1) * i; + min.point = + MinTracer->ConvertToVEVDim(MinTracer->GetGlobalMinimum(min.temp)); + MinTracer->ReduceVEV(min.point); + MinTracer->ConvertToNonFlatDirections(min.point); + + if (MinimumFoundAlready(min) == -1) // found new phase + { + Logger::Write( + LoggingLevel::MinTracerDetailed, + "-------------------------------------------------------"); + Phase inter_phase(min.temp, T_high, T_low, MinTracer); + addPhase(inter_phase); + print(inter_phase); + } + else + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Point at T = " + std::to_string(min.temp) + + " GeV belongs to already traced phase."); + } + } + } + return; + } + else if ((Temp == T_high) and (MinTracer->HighTemperatureVEV.size() > 0)) + { + Minimum HTMin; + HTMin.temp = T_high; + HTMin.point = MinTracer->HighTemperatureVEV; + if (MinimumFoundAlready(HTMin) == -1) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Tracking the high-temperature minimum at " + + vec_to_string(HTMin.point)); + Phase HTphase(HTMin.point, T_high, T_low, MinTracer); + addPhase(HTphase); + print(HTphase); + MultiStepPTTracer(HTphase.T_low, -1); + return; + } + } + + Minimum min; + min.temp = Temp; + min.point = MinTracer->ConvertToVEVDim(MinTracer->GetGlobalMinimum(Temp)); + + // Reduce the VEV into the same sector + MinTracer->ReduceVEV(min.point); + // Remove flat directions + MinTracer->ConvertToNonFlatDirections(min.point); + + if (MinimumFoundAlready(min) == -1) // found new phase + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "-------------------------------------------------------"); + Phase phase(Temp, T_high, T_low, MinTracer); + addPhase(phase); + print(phase); + + MultiStepPTTracer(phase.T_low, -1); + } + else // found last traced phase again + { + // Signal of phase splitting + MultiStepPTTracer(Temp + deltaT); + } + + return; +} + +void Vacuum::print(const Phase &phase) +{ + if (phase.MinimumPhaseVector.size() > 1) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "New phase found between " + std::to_string(phase.T_low) + + " GeV and " + std::to_string(phase.T_high) + " GeV"); + } + return; +} + +void Vacuum::setCoexPhases() +{ + std::stringstream ss1, ss2; + int pair_id = 0; + + for (std::size_t i = 0; i < PhasesList.size(); i++) + { + auto false_phase = PhasesList.at(i); + ss1 << "Phase " << false_phase.id << " exists between T = [" + << false_phase.T_low << ", " << false_phase.T_high << "] GeV\n"; + for (std::size_t j = i + 1; j < PhasesList.size(); j++) + { + auto true_phase = PhasesList.at(j); + if (true_phase.T_high >= false_phase.T_low and + true_phase.T_low <= false_phase.T_high) + { + double T_low_overlap = max(false_phase.T_low, true_phase.T_low); + double T_high_overlap = min(false_phase.T_high, true_phase.T_high); + + CoexPhases phase_pair( + pair_id, false_phase, true_phase, T_low_overlap, T_high_overlap); + CoexPhasesList.push_back(phase_pair); + + ss2 << "Pair " << pair_id << " (" << false_phase.id << ", " + << true_phase.id << ") with T = [" << T_low_overlap << ", " + << T_high_overlap << "] GeV and Tc = " << phase_pair.crit_temp + << " (" << StatusCritToString.at(phase_pair.crit_status) << ")\n"; + + pair_id += 1; + } + } + } + + Logger::Write(LoggingLevel::MinTracerDetailed, ss1.str()); + Logger::Write(LoggingLevel::MinTracerDetailed, ss2.str()); +} + +void Vacuum::setCoexRegion(const int &UseMultiStepPTMode) +{ + std::vector edgesList, edgesListResult; + std::vector tempList; + Logger::Write(LoggingLevel::MinTracerDetailed, + "Total number of phases identified: " + + std::to_string(PhasesList.size())); + + if (PhasesList.size() > 0) + { + for (auto i : PhasesList) + { + edgesList.push_back(i.MinimumPhaseVector.front()); + edgesList.push_back(i.MinimumPhaseVector.back()); + } + + for (auto i : edgesList) + { + tempList.push_back(i.temp); + } + + std::sort( + tempList.begin(), tempList.end(), [](auto a, auto b) { return a > b; }); + tempList.erase(unique(tempList.begin(), tempList.end()), tempList.end()); + + int EdgeOfPhaseatTemp = 0; + for (auto temp : tempList) + { + for (auto edge : edgesList) + { + if (edge.temp == temp) + { + EdgeOfPhaseatTemp += edge.EdgeOfPhase; + } + } + Minimum min; + min.temp = temp; + min.EdgeOfPhase = EdgeOfPhaseatTemp; + edgesListResult.push_back(min); + } + + // order list decending in temperature + std::sort(edgesList.begin(), + edgesList.end(), + [](auto a, auto b) { return a.temp > b.temp; }); + std::sort(edgesListResult.begin(), + edgesListResult.end(), + [](auto a, auto b) { return a.temp > b.temp; }); + + int numPhases = 0; + + bool no_gap_found = true; + + for (std::size_t i = 0; i < edgesListResult.size() - 1; i++) + { + numPhases = edgesListResult[i].EdgeOfPhase; + if (numPhases > 1) + { + status_coex_pairs = StatusCoexPair::Success; + } + else if (numPhases <= 0) // found a non-traced gap in temperature + { + no_gap_found = false; + double T_low_hole = edgesListResult[i + 1].temp; + double T_high_hole = edgesListResult[i].temp; + + if (T_low_hole + 1e-6 < T_high_hole) // threshold set to 1e-6 GeV + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "\nThere are phases missing between " + + std::to_string(T_low_hole) + " GeV and " + + std::to_string(T_high_hole) + " GeV!"); + status_vacuum = StatusTracing::NoCoverage; + + if (not(UseMultiStepPTMode == 0)) + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "\nTry to patch up gap between " + + std::to_string(T_low_hole) + " GeV and " + + std::to_string(T_high_hole) + " GeV."); + + // try to patch up holes in tracing + Minimum min; + min.temp = (T_high_hole + T_low_hole) / 2; + min.point = MinTracer->ConvertToVEVDim( + MinTracer->GetGlobalMinimum(min.temp)); + MinTracer->ReduceVEV(min.point); + MinTracer->ConvertToNonFlatDirections(min.point); + Phase inter_phase(min.temp, T_high, T_low, MinTracer); + addPhase(inter_phase); + print(inter_phase); + // If we had sucess finding a new phase. + if (inter_phase.MinimumPhaseVector.size() > + 2) // more than just endpoints found + { + status_vacuum = StatusTracing::Success; + setCoexRegion(UseMultiStepPTMode); + } + } + } + else + { + status_vacuum = StatusTracing::NoCoverage; + } + } + } + + if (no_gap_found) // correct status code in case local EW minimum covers up + // range + { + if (status_vacuum == StatusTracing::NoCoverage) + { + status_vacuum = StatusTracing::NoGlobMinCoverage; + } + } + } + + return; +} + +void Vacuum::addPhase(Phase &phase) +{ + if (phase.MinimumPhaseVector.size() <= 1) + { + if (phase.MinimumPhaseVector.size() > 0) + Logger::Write(LoggingLevel::MinTracerDetailed, + vec_to_string(phase.MinimumPhaseVector.at(0).point)); + Logger::Write(LoggingLevel::MinTracerDetailed, + "Phase was empty. Nothing was added."); + return; + } + // If the step size is too high and the T_high and T_low are too close we + // might have a phase with only 2 minima. This is not ideal so we look for + // more in the middle. + if (phase.MinimumPhaseVector.size() == 2) + { + // If only two minima were found look for more. + std::vector MinimumList = MinTracer->TrackPhase( + phase.MinimumPhaseVector[0].point, + phase.MinimumPhaseVector[0].temp, + phase.MinimumPhaseVector[1].temp, + (phase.MinimumPhaseVector[1].temp - phase.MinimumPhaseVector[0].temp) / + 3, + false); + // Check if the TrackPhase fails + if (MinimumList.size() > 0) + { + // Add new knots to the list so that Phase keeps track of the + // new minumum information + for (auto Min : MinimumList) + { + phase.Add(Min); + } + } + else + { + Logger::Write(LoggingLevel::MinTracerDetailed, + "Phase is too unstable. Throwing it away."); + return; + } + } + for (auto &existingPhase : PhasesList) + { + // Calculate the maximum distance of phase to each other phases + double Temp_min = std::max(existingPhase.T_low, phase.T_low); + double Temp_max = std::min(existingPhase.T_high, phase.T_high); + + if (Temp_min >= Temp_max) + { + continue; // Phases never exist at the same time + } + else + { + double dT = (Temp_max - Temp_min); + double max_distance = 0; + double numSteps = 12; + for (double n = 1; n < numSteps; n++) + { + max_distance = std::max( + max_distance, + L2NormVector( + existingPhase.Get(Temp_min + (n / numSteps) * dT).point - + phase.Get(Temp_min + (n / numSteps) * dT).point)); + } + if (max_distance < 1) + { + Logger::Write( + LoggingLevel::MinTracerDetailed, + "The phase starting at T = " + std::to_string(phase.T_low) + + " GeV and ending at T = " + std::to_string(phase.T_high) + + " GeV could not be added because it coincides with an " + "already " + "existing phase that starts at T = " + + std::to_string(existingPhase.T_low) + " GeV and ends at T = " + + std::to_string(existingPhase.T_high) + " GeV."); + + // Add Minimum of other phase to the already existing phase. + for (auto min : phase.MinimumPhaseVector) + existingPhase.Add(min); + return; // The phases coincide. Abort! + } + } + } + + // Set starting of phase + phase.MinimumPhaseVector.front().EdgeOfPhase = -1; + // Set ending of phase + phase.MinimumPhaseVector.back().EdgeOfPhase = 1; + PhasesList.push_back(phase); + return; +} + +int Vacuum::MinimumFoundAlready(const Minimum &minimum) +{ + double MaximumAllowedError = 1; + for (std::size_t ind = 0; ind < PhasesList.size(); ind++) + { + // Check if it is outside temperature range + if (minimum.temp > PhasesList[ind].T_high or + minimum.temp < PhasesList[ind].T_low) + continue; + + std::vector Distance; + std::transform(minimum.point.begin(), + minimum.point.end(), + PhasesList[ind].Get(minimum.temp).point.begin(), + std::back_inserter(Distance), + std::minus()); + + if (L2NormVector(Distance) / this->modelPointer->get_nVEV() < + MaximumAllowedError) + return ind; + } + return -1; +} + +std::vector MinimumTracer::GetLegend(const int &num_coex_phases, + const bool &do_gw_calc) +{ + std::vector legend; + + legend.push_back("status_nlo_stability"); + legend.push_back("status_ewsr"); + legend.push_back("status_tracing"); + legend.push_back("status_coex_pairs"); + legend.push_back("runtime"); + + for (int i = 0; i < num_coex_phases; i++) + { + legend.push_back("status_crit_" + std::to_string(i)); + legend.push_back("T_crit_" + std::to_string(i)); + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_crit_false_" + std::to_string(i))); + } + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_crit_true_" + std::to_string(i))); + } + legend.push_back("status_bounce_sol_" + std::to_string(i)); + legend.push_back("status_nucl_approx_" + std::to_string(i)); + legend.push_back("T_nucl_approx_" + std::to_string(i)); + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_nucl_approx_false_" + std::to_string(i))); + } + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_nucl_approx_true_" + std::to_string(i))); + } + legend.push_back("status_nucl_" + std::to_string(i)); + legend.push_back("T_nucl_" + std::to_string(i)); + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_nucl_false_" + std::to_string(i))); + } + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_nucl_true_" + std::to_string(i))); + } + legend.push_back("status_perc_" + std::to_string(i)); + legend.push_back("T_perc_" + std::to_string(i)); + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_perc_false_" + std::to_string(i))); + } + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_perc_true_" + std::to_string(i))); + } + legend.push_back("status_compl_" + std::to_string(i)); + legend.push_back("T_compl_" + std::to_string(i)); + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_compl_false_" + std::to_string(i))); + } + for (std::size_t j = 0; j < this->modelPointer->addLegendVEV().size(); j++) + { + legend.push_back(this->modelPointer->addLegendVEV().at(j).append( + "_compl_true_" + std::to_string(i))); + } + if (do_gw_calc) + { + legend.push_back("status_gw_" + std::to_string(i)); + legend.push_back("trans_temp_" + std::to_string(i)); + legend.push_back("v_wall_" + std::to_string(i)); + legend.push_back("alpha_PT_" + std::to_string(i)); + legend.push_back("beta/H_" + std::to_string(i)); + legend.push_back("K_sw_" + std::to_string(i)); + legend.push_back("fpeak_sw_" + std::to_string(i)); + legend.push_back("h2OmegaPeak_sw_" + std::to_string(i)); + legend.push_back("SNR(LISA-3yrs)_sw_" + std::to_string(i)); + legend.push_back("K_turb_" + std::to_string(i)); + legend.push_back("fpeak_turb_" + std::to_string(i)); + legend.push_back("h2OmegaPeak_turb_" + std::to_string(i)); + legend.push_back("SNR(LISA-3yrs)_turb_" + std::to_string(i)); + legend.push_back("SNR(LISA-3yrs)_" + std::to_string(i)); + } + } + + legend.push_back("transition_history"); + + return legend; +} + +} // namespace BSMPT diff --git a/src/models/CMakeLists.txt b/src/models/CMakeLists.txt index eb7b1f40..26ab76f8 100644 --- a/src/models/CMakeLists.txt +++ b/src/models/CMakeLists.txt @@ -1,48 +1,43 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/models") set(header - - ${header_path}/SMparam.h - - ${header_path}/ModelTestfunctions.h - ${header_path}/IncludeAllModels.h - ${header_path}/ClassPotentialOrigin.h - ${header_path}/ClassPotentialC2HDM.h - ${header_path}/ClassPotentialR2HDM.h - ${header_path}/ClassPotentialRN2HDM.h - ${header_path}/ClassPotentialCxSM.h - ${header_path}/ClassPotentialCPintheDark.h - - # Here you can add your new model - ${header_path}/ClassTemplate.h -) + ${header_path}/SMparam.h + ${header_path}/ModelTestfunctions.h + ${header_path}/IncludeAllModels.h + ${header_path}/ClassPotentialOrigin.h + ${header_path}/ClassPotentialC2HDM.h + ${header_path}/ClassPotentialR2HDM.h + ${header_path}/ClassPotentialN2HDM.h + ${header_path}/ClassPotentialCxSM.h + ${header_path}/ClassPotentialSM.h + ${header_path}/ClassPotentialCPintheDark.h + # Here you can add your new model + ${header_path}/ClassTemplate.h) set(src - - ModelTestfunctions.cpp - - IncludeAllModels.cpp - ClassPotentialOrigin.cpp - ClassPotentialOrigin_deprecated.cpp - - ClassPotentialC2HDM.cpp - ClassPotentialR2HDM.cpp - ClassPotentialRN2HDM.cpp - ClassPotentialCxSM.cpp - ClassPotentialCPintheDark.cpp - - # Here you can add your new model - ClassTemplate.cpp -) + SMParam.cpp + ModelTestfunctions.cpp + IncludeAllModels.cpp + ClassPotentialOrigin.cpp + ClassPotentialOrigin_deprecated.cpp + ClassPotentialC2HDM.cpp + ClassPotentialR2HDM.cpp + ClassPotentialN2HDM.cpp + ClassPotentialCxSM.cpp + ClassPotentialSM.cpp + ClassPotentialCPintheDark.cpp + # Here you can add your new model + ClassTemplate.cpp) add_library(Models ${header} ${src}) -target_link_libraries( Models PUBLIC GSL::gsl Eigen3::Eigen Minimizer ThermalFunctions Utility) +target_link_libraries(Models PUBLIC GSL::gsl Eigen3::Eigen Minimizer + ThermalFunctions Utility) target_include_directories(Models PUBLIC ${BSMPT_SOURCE_DIR}/include) -target_compile_features(Models PUBLIC cxx_std_14) - -# Include code-coverage settings: -#target_link_libraries(Models PUBLIC coverage_config) +target_compile_features(Models PUBLIC cxx_std_17) +# Include code-coverage settings: target_link_libraries(Models PUBLIC +# coverage_config) diff --git a/src/models/ClassPotentialC2HDM.cpp b/src/models/ClassPotentialC2HDM.cpp index 627b6ee3..e1e9aac3 100644 --- a/src/models/ClassPotentialC2HDM.cpp +++ b/src/models/ClassPotentialC2HDM.cpp @@ -14,7 +14,8 @@ namespace BSMPT { namespace Models { -Class_Potential_C2HDM::Class_Potential_C2HDM() +Class_Potential_C2HDM::Class_Potential_C2HDM(const ISMConstants &smConstants) + : Class_Potential_Origin(smConstants) { // TODO Auto-generated constructor stub Model = ModelID::ModelIDs::C2HDM; @@ -218,7 +219,7 @@ void Class_Potential_C2HDM::set_gen(const std::vector &p) { // double *p = (double *)par; - scale = C_vev0; + scale = SMConstants.C_vev0; L1 = p[0]; L2 = p[1]; L3 = p[2]; @@ -235,28 +236,38 @@ void Class_Potential_C2HDM::set_gen(const std::vector &p) C_SinBeta = sqrt(C_SinBetaSquared); u1 = RealMMix * TanBeta - - C_vev0 * C_vev0 * C_SinBetaSquared * (L4 + RL5 + L3) / 0.2e1 - - C_vev0 * C_vev0 * C_CosBetaSquared * L1 / 0.2e1; + SMConstants.C_vev0 * SMConstants.C_vev0 * C_SinBetaSquared * + (L4 + RL5 + L3) / 0.2e1 - + SMConstants.C_vev0 * SMConstants.C_vev0 * C_CosBetaSquared * L1 / 0.2e1; u2 = RealMMix * 1.0 / TanBeta - - C_vev0 * C_vev0 * C_CosBetaSquared * (L4 + RL5 + L3) / 0.2e1 - - C_vev0 * C_vev0 * C_SinBetaSquared * L2 / 0.2e1; - Iu3 = C_vev0 * C_vev0 * TanBeta * C_CosBetaSquared * IL5 * 0.5; + SMConstants.C_vev0 * SMConstants.C_vev0 * C_CosBetaSquared * + (L4 + RL5 + L3) / 0.2e1 - + SMConstants.C_vev0 * SMConstants.C_vev0 * C_SinBetaSquared * L2 / 0.2e1; + Iu3 = SMConstants.C_vev0 * SMConstants.C_vev0 * TanBeta * C_CosBetaSquared * + IL5 * 0.5; double cb = 0; if (Type == 1 or Type == 3) // Type I 2HDM or Lepton Specific { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_SinBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_SinBeta); } if (Type == 2 or Type == 4) // Type II 2HDM or Flipped { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_CosBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_CosBeta); } CTempC1 = 1.0 / 48 * - (12 * L1 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs)); - double ct = std::sqrt(2) * C_MassTop / (C_vev0 * C_SinBeta); - CTempC2 = 1.0 / 48 * - (12 * L2 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs) + + (12 * L1 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs)); + double ct = + std::sqrt(2) * SMConstants.C_MassTop / (SMConstants.C_vev0 * C_SinBeta); + CTempC2 = 1.0 / 48 * + (12 * L2 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs) + 12 * ct * ct); if (Type == 1 or Type == 3) @@ -271,14 +282,14 @@ void Class_Potential_C2HDM::set_gen(const std::vector &p) if (IncludeChargeBreakingVEV) { vevTreeMin[0] = 0; - vevTreeMin[1] = C_vev0 * C_CosBeta; - vevTreeMin[2] = C_vev0 * C_SinBeta; + vevTreeMin[1] = SMConstants.C_vev0 * C_CosBeta; + vevTreeMin[2] = SMConstants.C_vev0 * C_SinBeta; vevTreeMin[3] = 0; } else { - vevTreeMin[0] = C_vev0 * C_CosBeta; - vevTreeMin[1] = C_vev0 * C_SinBeta; + vevTreeMin[0] = SMConstants.C_vev0 * C_CosBeta; + vevTreeMin[1] = SMConstants.C_vev0 * C_SinBeta; vevTreeMin[2] = 0; } vevTree.resize(NHiggs); @@ -2083,8 +2094,8 @@ void Class_Potential_C2HDM::write() const ss << "The parameters are : \n"; ss << "Model = " << Model << "\n"; - ss << "v1 = " << C_vev0 * C_CosBeta << "\n"; - ss << "v2 = " << C_vev0 * C_SinBeta << "\n"; + ss << "v1 = " << SMConstants.C_vev0 * C_CosBeta << "\n"; + ss << "v2 = " << SMConstants.C_vev0 * C_SinBeta << "\n"; ss << "Type = " << Type << "\n"; ss << "beta = " << beta << std::endl; @@ -2293,8 +2304,8 @@ std::vector Class_Potential_C2HDM::calc_CT() const WeinbergNabla = WeinbergFirstDerivative(); WeinbergHesse = WeinbergSecondDerivative(); - double v1 = C_vev0 * C_CosBeta; - double v2 = C_vev0 * C_SinBeta; + double v1 = SMConstants.C_vev0 * C_CosBeta; + double v2 = SMConstants.C_vev0 * C_SinBeta; VectorXd NablaWeinberg(8); MatrixXd HesseWeinberg(8, 8), HiggsRot(8, 8); @@ -2421,9 +2432,9 @@ void Class_Potential_C2HDM::TripleHiggsCouplings() } MatrixXd HiggsRotSort(NHiggs, NHiggs); int posMHCS1 = 0, posMHCS2 = 0; - int posN[3]; - int countposN = 0; - int posG1 = 0, posG2 = 0, posG0 = 0; + std::vector posN(3); + std::size_t countposN = 0; + std::size_t posG1 = 0, posG2 = 0, posG0 = 0; double testsum = 0; const double ZeroThreshold = 1e-5; for (int i = 0; i < 3; i++) @@ -2446,7 +2457,7 @@ void Class_Potential_C2HDM::TripleHiggsCouplings() testsum += std::abs(HiggsRot(i, k)); if (testsum > ZeroThreshold) { - posN[countposN] = i; + posN.at(countposN) = i; countposN++; } } @@ -2460,7 +2471,7 @@ void Class_Potential_C2HDM::TripleHiggsCouplings() double NeutralHiggs[3]; for (int i = 0; i < 3; i++) { - NeutralHiggs[i] = HiggsMasses[posN[i]]; + NeutralHiggs[i] = HiggsMasses[posN.at(i)]; } for (int i = 0; i < 3; i++) { @@ -2577,8 +2588,8 @@ void Class_Potential_C2HDM::SetCurvatureArrays() } } - HiggsVev[4] = C_vev0 * C_CosBeta; - HiggsVev[6] = C_vev0 * C_SinBeta; + HiggsVev[4] = SMConstants.C_vev0 * C_CosBeta; + HiggsVev[6] = SMConstants.C_vev0 * C_SinBeta; Curvature_Higgs_L2[0][0] = u1; Curvature_Higgs_L2[0][1] = 0; @@ -2779,103 +2790,127 @@ void Class_Potential_C2HDM::SetCurvatureArrays() } } - Curvature_Gauge_G2H2[0][0][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][7][7] = C_g * C_g / 0.2e1; - - Curvature_Gauge_G2H2[0][3][0][4] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][1][5] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][2][6] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][3][7] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][4][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][5][1] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][6][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][7][3] = C_g * C_gs / 0.2e1; - - Curvature_Gauge_G2H2[1][1][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][7][7] = C_g * C_g / 0.2e1; - - Curvature_Gauge_G2H2[1][3][0][5] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][1][4] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][2][7] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][3][6] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][4][1] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][5][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][6][3] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][7][2] = C_g * C_gs / 0.2e1; - - Curvature_Gauge_G2H2[2][2][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][7][7] = C_g * C_g / 0.2e1; - - Curvature_Gauge_G2H2[2][3][0][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][1][1] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][2][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][3][3] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][4][4] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][5][5] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][6][6] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][7][7] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][0][4] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][1][5] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][2][6] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][3][7] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][4][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][5][1] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][6][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][7][3] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][0][5] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][1][4] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][2][7] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][3][6] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][4][1] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][5][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][6][3] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][7][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][0][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][1][1] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][2][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][3][3] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][4][4] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][5][5] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][6][6] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][7][7] = -C_g * C_gs / 0.2e1; - - Curvature_Gauge_G2H2[3][3][0][0] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][1][1] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][2][2] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][3][3] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][4][4] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][5][5] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][6][6] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][7][7] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][0][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + + Curvature_Gauge_G2H2[0][3][0][4] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][1][5] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][2][6] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][3][7] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][4][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][5][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][6][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][7][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + + Curvature_Gauge_G2H2[1][1][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + + Curvature_Gauge_G2H2[1][3][0][5] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][1][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][2][7] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][3][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][4][1] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][5][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][6][3] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][7][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + + Curvature_Gauge_G2H2[2][2][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + + Curvature_Gauge_G2H2[2][3][0][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][1][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][2][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][3][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][4][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][5][5] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][6][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][7][7] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][0][4] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][1][5] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][2][6] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][3][7] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][4][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][5][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][6][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][7][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][0][5] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][1][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][2][7] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][3][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][4][1] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][5][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][6][3] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][7][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][0][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][1][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][2][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][3][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][4][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][5][5] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][6][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][7][7] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + + Curvature_Gauge_G2H2[3][3][0][0] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][1][1] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][2][2] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][3][3] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][4][4] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][5][5] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][6][6] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][7][7] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; std::complex V11, V12, V13, V21, V22, V23, V31, V32, V33; - V11 = C_Vud; - V12 = C_Vus; - V13 = C_Vub; - V21 = C_Vcd; - V22 = C_Vcs; - V23 = C_Vcb; - V31 = C_Vtd; - V32 = C_Vts; - V33 = C_Vtb; + V11 = SMConstants.C_Vud; + V12 = SMConstants.C_Vus; + V13 = SMConstants.C_Vub; + V21 = SMConstants.C_Vcd; + V22 = SMConstants.C_Vcs; + V23 = SMConstants.C_Vcb; + V31 = SMConstants.C_Vtd; + V32 = SMConstants.C_Vts; + V33 = SMConstants.C_Vtb; MatrixXcd YIJR2(NQuarks, NQuarks), YIJE2(NQuarks, NQuarks), YIJS2(NQuarks, NQuarks), YIJP2(NQuarks, NQuarks), YIJRD(NQuarks, NQuarks), @@ -2895,8 +2930,8 @@ void Class_Potential_C2HDM::SetCurvatureArrays() YIJSL = MatrixXcd::Zero(NLepton, NLepton); YIJPL = MatrixXcd::Zero(NLepton, NLepton); - double v1 = C_vev0 * C_CosBeta; - double v2 = C_vev0 * C_SinBeta; + double v1 = SMConstants.C_vev0 * C_CosBeta; + double v2 = SMConstants.C_vev0 * C_SinBeta; double vL = v2; double vD = v2; if (Type == 2) @@ -2909,43 +2944,43 @@ void Class_Potential_C2HDM::SetCurvatureArrays() else if (Type == 4) vD = v1; - YIJR2(0, 9) = -std::conj(V11) * C_MassUp / v2; - YIJR2(0, 10) = -std::conj(V12) * C_MassUp / v2; - YIJR2(0, 11) = -std::conj(V13) * C_MassUp / v2; + YIJR2(0, 9) = -std::conj(V11) * SMConstants.C_MassUp / v2; + YIJR2(0, 10) = -std::conj(V12) * SMConstants.C_MassUp / v2; + YIJR2(0, 11) = -std::conj(V13) * SMConstants.C_MassUp / v2; - YIJR2(1, 9) = -std::conj(V21) * C_MassCharm / v2; - YIJR2(1, 10) = -std::conj(V22) * C_MassCharm / v2; - YIJR2(1, 11) = -std::conj(V23) * C_MassCharm / v2; + YIJR2(1, 9) = -std::conj(V21) * SMConstants.C_MassCharm / v2; + YIJR2(1, 10) = -std::conj(V22) * SMConstants.C_MassCharm / v2; + YIJR2(1, 11) = -std::conj(V23) * SMConstants.C_MassCharm / v2; - YIJR2(2, 9) = -std::conj(V31) * C_MassTop / v2; - YIJR2(2, 10) = -std::conj(V32) * C_MassTop / v2; - YIJR2(2, 11) = -std::conj(V33) * C_MassTop / v2; + YIJR2(2, 9) = -std::conj(V31) * SMConstants.C_MassTop / v2; + YIJR2(2, 10) = -std::conj(V32) * SMConstants.C_MassTop / v2; + YIJR2(2, 11) = -std::conj(V33) * SMConstants.C_MassTop / v2; - YIJS2(0, 6) = C_MassUp / v2; - YIJS2(1, 7) = C_MassCharm / v2; - YIJS2(2, 8) = C_MassTop / v2; + YIJS2(0, 6) = SMConstants.C_MassUp / v2; + YIJS2(1, 7) = SMConstants.C_MassCharm / v2; + YIJS2(2, 8) = SMConstants.C_MassTop / v2; - YIJSD(3, 9) = C_MassDown / vD; - YIJSD(4, 10) = C_MassStrange / vD; - YIJSD(5, 11) = C_MassBottom / vD; + YIJSD(3, 9) = SMConstants.C_MassDown / vD; + YIJSD(4, 10) = SMConstants.C_MassStrange / vD; + YIJSD(5, 11) = SMConstants.C_MassBottom / vD; - YIJRD(3, 6) = V11 * C_MassDown / vD; - YIJRD(3, 7) = V21 * C_MassDown / vD; - YIJRD(3, 8) = V31 * C_MassDown / vD; - YIJRD(4, 6) = V12 * C_MassStrange / vD; - YIJRD(4, 7) = V22 * C_MassStrange / vD; - YIJRD(4, 8) = V32 * C_MassStrange / vD; - YIJRD(5, 6) = V13 * C_MassBottom / vD; - YIJRD(5, 7) = V23 * C_MassBottom / vD; - YIJRD(5, 8) = V33 * C_MassBottom / vD; + YIJRD(3, 6) = V11 * SMConstants.C_MassDown / vD; + YIJRD(3, 7) = V21 * SMConstants.C_MassDown / vD; + YIJRD(3, 8) = V31 * SMConstants.C_MassDown / vD; + YIJRD(4, 6) = V12 * SMConstants.C_MassStrange / vD; + YIJRD(4, 7) = V22 * SMConstants.C_MassStrange / vD; + YIJRD(4, 8) = V32 * SMConstants.C_MassStrange / vD; + YIJRD(5, 6) = V13 * SMConstants.C_MassBottom / vD; + YIJRD(5, 7) = V23 * SMConstants.C_MassBottom / vD; + YIJRD(5, 8) = V33 * SMConstants.C_MassBottom / vD; - YIJRL(1, 6) = C_MassElectron / vL; - YIJRL(3, 7) = C_MassMu / vL; - YIJRL(5, 8) = C_MassTau / vL; + YIJRL(1, 6) = SMConstants.C_MassElectron / vL; + YIJRL(3, 7) = SMConstants.C_MassMu / vL; + YIJRL(5, 8) = SMConstants.C_MassTau / vL; - YIJSL(0, 1) = C_MassElectron / vL; - YIJSL(2, 3) = C_MassMu / vL; - YIJSL(4, 5) = C_MassTau / vL; + YIJSL(0, 1) = SMConstants.C_MassElectron / vL; + YIJSL(2, 3) = SMConstants.C_MassMu / vL; + YIJSL(4, 5) = SMConstants.C_MassTau / vL; for (std::size_t i = 0; i < NQuarks; i++) { @@ -3043,17 +3078,24 @@ bool Class_Potential_C2HDM::CalculateDebyeSimplified() if (Type == 1 or Type == 3) // Type I 2HDM oder Lepton Specific { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_SinBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_SinBeta); } if (Type == 2 or Type == 4) // Type II 2HDM oder Flipped { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_CosBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_CosBeta); } CTempC1 = 1.0 / 48 * - (12 * L1 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs)); - double ct = std::sqrt(2) * C_MassTop / (C_vev0 * C_SinBeta); - CTempC2 = 1.0 / 48 * - (12 * L2 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs) + + (12 * L1 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs)); + double ct = + std::sqrt(2) * SMConstants.C_MassTop / (SMConstants.C_vev0 * C_SinBeta); + CTempC2 = 1.0 / 48 * + (12 * L2 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs) + 12 * ct * ct); if (Type == 1 or Type == 3) @@ -3079,10 +3121,10 @@ bool Class_Potential_C2HDM::CalculateDebyeSimplified() bool Class_Potential_C2HDM::CalculateDebyeGaugeSimplified() { - DebyeGauge[0][0] = 2 * C_g * C_g; - DebyeGauge[1][1] = 2 * C_g * C_g; - DebyeGauge[2][2] = 2 * C_g * C_g; - DebyeGauge[3][3] = 2 * C_gs * C_gs; + DebyeGauge[0][0] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[1][1] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[2][2] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[3][3] = 2 * SMConstants.C_gs * SMConstants.C_gs; return true; } diff --git a/src/models/ClassPotentialCPintheDark.cpp b/src/models/ClassPotentialCPintheDark.cpp index 836301f9..d13d99b4 100644 --- a/src/models/ClassPotentialCPintheDark.cpp +++ b/src/models/ClassPotentialCPintheDark.cpp @@ -10,8 +10,8 @@ #include "Eigen/Dense" #include "Eigen/Eigenvalues" #include "Eigen/IterativeLinearSolvers" -#include // for C_vev0, C_MassTop, C_g -#include // for max, copy +#include // for SMConstants.C_vev0, SMConstants.C_MassTop, SMConstants.C_g +#include // for max, copy #include #include // for operator<<, endl, basic_o... #include // for allocator_traits<>::value... @@ -28,7 +28,9 @@ namespace BSMPT namespace Models { -Class_Potential_CPintheDark::Class_Potential_CPintheDark() +Class_Potential_CPintheDark::Class_Potential_CPintheDark( + const ISMConstants &smConstants) + : Class_Potential_Origin(smConstants) { Model = ModelID::ModelIDs::CPINTHEDARK; NNeutralHiggs = 5; // number of neutral Higgs bosons at T = 0 @@ -257,9 +259,9 @@ void Class_Potential_CPintheDark::set_gen(const std::vector &par) L8 = par[12]; // set vev - v1 = C_vev0; + v1 = SMConstants.C_vev0; - scale = C_vev0; // renormalisation scale is set to the SM VEV + scale = SMConstants.C_vev0; // renormalisation scale is set to the SM VEV vevTreeMin.resize(nVEV); vevTree.resize(NHiggs); @@ -1989,220 +1991,279 @@ void Class_Potential_CPintheDark::SetCurvatureArrays() Curvature_Higgs_L4[8][8][7][7] = L8; Curvature_Higgs_L4[8][8][8][8] = 0.6e1 * L6; - Curvature_Gauge_G2H2[0][0][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][7][7] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][0][4] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][1][5] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][2][6] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][3][7] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][4][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][5][1] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][6][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][7][3] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][7][7] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][0][5] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][1][4] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][2][7] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][3][6] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][4][1] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][5][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][6][3] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][7][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][7][7] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][0][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][1][1] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][2][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][3][3] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][4][4] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][5][5] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][6][6] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][7][7] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][0][4] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][1][5] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][2][6] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][3][7] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][4][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][5][1] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][6][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][7][3] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][0][5] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][1][4] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][2][7] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][3][6] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][4][1] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][5][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][6][3] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][7][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][0][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][1][1] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][2][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][3][3] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][4][4] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][5][5] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][6][6] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][7][7] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][3][0][0] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][1][1] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][2][2] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][3][3] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][4][4] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][5][5] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][6][6] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][7][7] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][0][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][0][4] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][1][5] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][2][6] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][3][7] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][4][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][5][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][6][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][7][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][0][5] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][1][4] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][2][7] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][3][6] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][4][1] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][5][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][6][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][7][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][0][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][1][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][2][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][3][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][4][4] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][5][5] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][6][6] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][7][7] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][0][4] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][1][5] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][2][6] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][3][7] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][4][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][5][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][6][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][7][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][0][5] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][1][4] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][2][7] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][3][6] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][4][1] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][5][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][6][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][7][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][0][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][1][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][2][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][3][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][4][4] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][5][5] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][6][6] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][7][7] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][3][0][0] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][1][1] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][2][2] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][3][3] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][4][4] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][5][5] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][6][6] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][7][7] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; std::complex V11, V12, V13, V21, V22, V23, V31, V32, V33; - V11 = C_Vud; - V12 = C_Vus; - V13 = C_Vub; - V21 = C_Vcd; - V22 = C_Vcs; - V23 = C_Vcb; - V31 = C_Vtd; - V32 = C_Vts; - V33 = C_Vtb; - - - Curvature_Quark_F2H1[0][1][4] = 0.1e1 / v1 * C_MassUp; - Curvature_Quark_F2H1[0][1][5] = -II / v1 * C_MassUp; - Curvature_Quark_F2H1[0][3][0] = 0.1e1 / v1 * C_MassDown * V11; - Curvature_Quark_F2H1[0][3][1] = II / v1 * C_MassDown * V11; - Curvature_Quark_F2H1[0][7][0] = V12 / v1 * C_MassStrange; - Curvature_Quark_F2H1[0][7][1] = II * V12 / v1 * C_MassStrange; - Curvature_Quark_F2H1[0][11][0] = V13 / v1 * C_MassBottom; - Curvature_Quark_F2H1[0][11][1] = II * V13 / v1 * C_MassBottom; - Curvature_Quark_F2H1[1][0][4] = 0.1e1 / v1 * C_MassUp; - Curvature_Quark_F2H1[1][0][5] = -II / v1 * C_MassUp; - Curvature_Quark_F2H1[1][2][0] = -0.1e1 / v1 * C_MassUp * std::conj(V11); - Curvature_Quark_F2H1[1][2][1] = II / v1 * C_MassUp * std::conj(V11); - Curvature_Quark_F2H1[1][6][0] = -0.1e1 / v1 * C_MassUp * std::conj(V12); - Curvature_Quark_F2H1[1][6][1] = II / v1 * C_MassUp * std::conj(V12); - Curvature_Quark_F2H1[1][10][0] = -0.1e1 / v1 * C_MassUp * std::conj(V13); - Curvature_Quark_F2H1[1][10][1] = II / v1 * C_MassUp * std::conj(V13); - Curvature_Quark_F2H1[2][1][0] = -0.1e1 / v1 * C_MassUp * std::conj(V11); - Curvature_Quark_F2H1[2][1][1] = II / v1 * C_MassUp * std::conj(V11); - Curvature_Quark_F2H1[2][3][4] = 0.1e1 / v1 * C_MassDown; - Curvature_Quark_F2H1[2][3][5] = II / v1 * C_MassDown; - Curvature_Quark_F2H1[2][5][0] = -0.1e1 / v1 * C_MassCharm * std::conj(V21); - Curvature_Quark_F2H1[2][5][1] = II / v1 * C_MassCharm * std::conj(V21); - Curvature_Quark_F2H1[2][9][0] = -0.1e1 / v1 * C_MassTop * std::conj(V31); - Curvature_Quark_F2H1[2][9][1] = II / v1 * C_MassTop * std::conj(V31); - Curvature_Quark_F2H1[3][0][0] = 0.1e1 / v1 * C_MassDown * V11; - Curvature_Quark_F2H1[3][0][1] = II / v1 * C_MassDown * V11; - Curvature_Quark_F2H1[3][2][4] = 0.1e1 / v1 * C_MassDown; - Curvature_Quark_F2H1[3][2][5] = II / v1 * C_MassDown; - Curvature_Quark_F2H1[3][4][0] = V21 / v1 * C_MassDown; - Curvature_Quark_F2H1[3][4][1] = II * V21 / v1 * C_MassDown; - Curvature_Quark_F2H1[3][8][0] = 0.1e1 / v1 * C_MassDown * V31; - Curvature_Quark_F2H1[3][8][1] = II / v1 * C_MassDown * V31; - Curvature_Quark_F2H1[4][3][0] = V21 / v1 * C_MassDown; - Curvature_Quark_F2H1[4][3][1] = II * V21 / v1 * C_MassDown; - Curvature_Quark_F2H1[4][5][4] = 0.1e1 / v1 * C_MassCharm; - Curvature_Quark_F2H1[4][5][5] = -II / v1 * C_MassCharm; - Curvature_Quark_F2H1[4][7][0] = V22 / v1 * C_MassStrange; - Curvature_Quark_F2H1[4][7][1] = II * V22 / v1 * C_MassStrange; - Curvature_Quark_F2H1[4][11][0] = V23 / v1 * C_MassBottom; - Curvature_Quark_F2H1[4][11][1] = II * V23 / v1 * C_MassBottom; - Curvature_Quark_F2H1[5][2][0] = -0.1e1 / v1 * C_MassCharm * std::conj(V21); - Curvature_Quark_F2H1[5][2][1] = II / v1 * C_MassCharm * std::conj(V21); - Curvature_Quark_F2H1[5][4][4] = 0.1e1 / v1 * C_MassCharm; - Curvature_Quark_F2H1[5][4][5] = -II / v1 * C_MassCharm; - Curvature_Quark_F2H1[5][6][0] = -0.1e1 / v1 * C_MassCharm * std::conj(V22); - Curvature_Quark_F2H1[5][6][1] = II / v1 * C_MassCharm * std::conj(V22); - Curvature_Quark_F2H1[5][10][0] = -0.1e1 / v1 * C_MassCharm * std::conj(V23); - Curvature_Quark_F2H1[5][10][1] = II / v1 * C_MassCharm * std::conj(V23); - Curvature_Quark_F2H1[6][1][0] = -0.1e1 / v1 * C_MassUp * std::conj(V12); - Curvature_Quark_F2H1[6][1][1] = II / v1 * C_MassUp * std::conj(V12); - Curvature_Quark_F2H1[6][5][0] = -0.1e1 / v1 * C_MassCharm * std::conj(V22); - Curvature_Quark_F2H1[6][5][1] = II / v1 * C_MassCharm * std::conj(V22); - Curvature_Quark_F2H1[6][7][4] = 0.1e1 / v1 * C_MassStrange; - Curvature_Quark_F2H1[6][7][5] = II / v1 * C_MassStrange; - Curvature_Quark_F2H1[6][9][0] = -0.1e1 / v1 * C_MassTop * std::conj(V32); - Curvature_Quark_F2H1[6][9][1] = II / v1 * C_MassTop * std::conj(V32); - Curvature_Quark_F2H1[7][0][0] = V12 / v1 * C_MassStrange; - Curvature_Quark_F2H1[7][0][1] = II * V12 / v1 * C_MassStrange; - Curvature_Quark_F2H1[7][4][0] = V22 / v1 * C_MassStrange; - Curvature_Quark_F2H1[7][4][1] = II * V22 / v1 * C_MassStrange; - Curvature_Quark_F2H1[7][6][4] = 0.1e1 / v1 * C_MassStrange; - Curvature_Quark_F2H1[7][6][5] = II / v1 * C_MassStrange; - Curvature_Quark_F2H1[7][8][0] = V32 / v1 * C_MassStrange; - Curvature_Quark_F2H1[7][8][1] = II * V32 / v1 * C_MassStrange; - Curvature_Quark_F2H1[8][3][0] = 0.1e1 / v1 * C_MassDown * V31; - Curvature_Quark_F2H1[8][3][1] = II / v1 * C_MassDown * V31; - Curvature_Quark_F2H1[8][7][0] = V32 / v1 * C_MassStrange; - Curvature_Quark_F2H1[8][7][1] = II * V32 / v1 * C_MassStrange; - Curvature_Quark_F2H1[8][9][4] = 0.1e1 / v1 * C_MassTop; - Curvature_Quark_F2H1[8][9][5] = -II / v1 * C_MassTop; - Curvature_Quark_F2H1[8][11][0] = V33 / v1 * C_MassBottom; - Curvature_Quark_F2H1[8][11][1] = II * V33 / v1 * C_MassBottom; - Curvature_Quark_F2H1[9][2][0] = -0.1e1 / v1 * C_MassTop * std::conj(V31); - Curvature_Quark_F2H1[9][2][1] = II / v1 * C_MassTop * std::conj(V31); - Curvature_Quark_F2H1[9][6][0] = -0.1e1 / v1 * C_MassTop * std::conj(V32); - Curvature_Quark_F2H1[9][6][1] = II / v1 * C_MassTop * std::conj(V32); - Curvature_Quark_F2H1[9][8][4] = 0.1e1 / v1 * C_MassTop; - Curvature_Quark_F2H1[9][8][5] = -II / v1 * C_MassTop; - Curvature_Quark_F2H1[9][10][0] = -0.1e1 / v1 * C_MassTop * std::conj(V33); - Curvature_Quark_F2H1[9][10][1] = II / v1 * C_MassTop * std::conj(V33); - Curvature_Quark_F2H1[10][1][0] = -0.1e1 / v1 * C_MassUp * std::conj(V13); - Curvature_Quark_F2H1[10][1][1] = II / v1 * C_MassUp * std::conj(V13); - Curvature_Quark_F2H1[10][5][0] = -0.1e1 / v1 * C_MassCharm * std::conj(V23); - Curvature_Quark_F2H1[10][5][1] = II / v1 * C_MassCharm * std::conj(V23); - Curvature_Quark_F2H1[10][9][0] = -0.1e1 / v1 * C_MassTop * std::conj(V33); - Curvature_Quark_F2H1[10][9][1] = II / v1 * C_MassTop * std::conj(V33); - Curvature_Quark_F2H1[10][11][4] = 0.1e1 / v1 * C_MassBottom; - Curvature_Quark_F2H1[10][11][5] = II / v1 * C_MassBottom; - Curvature_Quark_F2H1[11][0][0] = V13 / v1 * C_MassBottom; - Curvature_Quark_F2H1[11][0][1] = II * V13 / v1 * C_MassBottom; - Curvature_Quark_F2H1[11][4][0] = V23 / v1 * C_MassBottom; - Curvature_Quark_F2H1[11][4][1] = II * V23 / v1 * C_MassBottom; - Curvature_Quark_F2H1[11][8][0] = V33 / v1 * C_MassBottom; - Curvature_Quark_F2H1[11][8][1] = II * V33 / v1 * C_MassBottom; - Curvature_Quark_F2H1[11][10][4] = 0.1e1 / v1 * C_MassBottom; - Curvature_Quark_F2H1[11][10][5] = II / v1 * C_MassBottom; - - Curvature_Lepton_F2H1[0][1][4] = 0.1e1 / v1 * C_MassElectron; - Curvature_Lepton_F2H1[0][1][5] = II / v1 * C_MassElectron; - Curvature_Lepton_F2H1[1][0][4] = 0.1e1 / v1 * C_MassElectron; - Curvature_Lepton_F2H1[1][0][5] = II / v1 * C_MassElectron; - Curvature_Lepton_F2H1[1][6][0] = 0.1e1 / v1 * C_MassElectron; - Curvature_Lepton_F2H1[1][6][1] = II / v1 * C_MassElectron; - Curvature_Lepton_F2H1[2][3][4] = 0.1e1 / v1 * C_MassMu; - Curvature_Lepton_F2H1[2][3][5] = II / v1 * C_MassMu; - Curvature_Lepton_F2H1[3][2][4] = 0.1e1 / v1 * C_MassMu; - Curvature_Lepton_F2H1[3][2][5] = II / v1 * C_MassMu; - Curvature_Lepton_F2H1[3][7][0] = 0.1e1 / v1 * C_MassMu; - Curvature_Lepton_F2H1[3][7][1] = II / v1 * C_MassMu; - Curvature_Lepton_F2H1[4][5][4] = 0.1e1 / v1 * C_MassTau; - Curvature_Lepton_F2H1[4][5][5] = II / v1 * C_MassTau; - Curvature_Lepton_F2H1[5][4][4] = 0.1e1 / v1 * C_MassTau; - Curvature_Lepton_F2H1[5][4][5] = II / v1 * C_MassTau; - Curvature_Lepton_F2H1[5][8][0] = 0.1e1 / v1 * C_MassTau; - Curvature_Lepton_F2H1[5][8][1] = II / v1 * C_MassTau; - Curvature_Lepton_F2H1[6][1][0] = 0.1e1 / v1 * C_MassElectron; - Curvature_Lepton_F2H1[6][1][1] = II / v1 * C_MassElectron; - Curvature_Lepton_F2H1[7][3][0] = 0.1e1 / v1 * C_MassMu; - Curvature_Lepton_F2H1[7][3][1] = II / v1 * C_MassMu; - Curvature_Lepton_F2H1[8][5][0] = 0.1e1 / v1 * C_MassTau; - Curvature_Lepton_F2H1[8][5][1] = II / v1 * C_MassTau; + V11 = SMConstants.C_Vud; + V12 = SMConstants.C_Vus; + V13 = SMConstants.C_Vub; + V21 = SMConstants.C_Vcd; + V22 = SMConstants.C_Vcs; + V23 = SMConstants.C_Vcb; + V31 = SMConstants.C_Vtd; + V32 = SMConstants.C_Vts; + V33 = SMConstants.C_Vtb; + + Curvature_Quark_F2H1[0][1][4] = 0.1e1 / v1 * SMConstants.C_MassUp; + Curvature_Quark_F2H1[0][1][5] = -II / v1 * SMConstants.C_MassUp; + Curvature_Quark_F2H1[0][3][0] = 0.1e1 / v1 * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[0][3][1] = II / v1 * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[0][7][0] = V12 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[0][7][1] = II * V12 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[0][11][0] = V13 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[0][11][1] = II * V13 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[1][0][4] = 0.1e1 / v1 * SMConstants.C_MassUp; + Curvature_Quark_F2H1[1][0][5] = -II / v1 * SMConstants.C_MassUp; + Curvature_Quark_F2H1[1][2][0] = + -0.1e1 / v1 * SMConstants.C_MassUp * std::conj(V11); + Curvature_Quark_F2H1[1][2][1] = + II / v1 * SMConstants.C_MassUp * std::conj(V11); + Curvature_Quark_F2H1[1][6][0] = + -0.1e1 / v1 * SMConstants.C_MassUp * std::conj(V12); + Curvature_Quark_F2H1[1][6][1] = + II / v1 * SMConstants.C_MassUp * std::conj(V12); + Curvature_Quark_F2H1[1][10][0] = + -0.1e1 / v1 * SMConstants.C_MassUp * std::conj(V13); + Curvature_Quark_F2H1[1][10][1] = + II / v1 * SMConstants.C_MassUp * std::conj(V13); + Curvature_Quark_F2H1[2][1][0] = + -0.1e1 / v1 * SMConstants.C_MassUp * std::conj(V11); + Curvature_Quark_F2H1[2][1][1] = + II / v1 * SMConstants.C_MassUp * std::conj(V11); + Curvature_Quark_F2H1[2][3][4] = 0.1e1 / v1 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[2][3][5] = II / v1 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[2][5][0] = + -0.1e1 / v1 * SMConstants.C_MassCharm * std::conj(V21); + Curvature_Quark_F2H1[2][5][1] = + II / v1 * SMConstants.C_MassCharm * std::conj(V21); + Curvature_Quark_F2H1[2][9][0] = + -0.1e1 / v1 * SMConstants.C_MassTop * std::conj(V31); + Curvature_Quark_F2H1[2][9][1] = + II / v1 * SMConstants.C_MassTop * std::conj(V31); + Curvature_Quark_F2H1[3][0][0] = 0.1e1 / v1 * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[3][0][1] = II / v1 * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[3][2][4] = 0.1e1 / v1 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][2][5] = II / v1 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][4][0] = V21 / v1 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][4][1] = II * V21 / v1 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][8][0] = 0.1e1 / v1 * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[3][8][1] = II / v1 * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[4][3][0] = V21 / v1 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[4][3][1] = II * V21 / v1 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[4][5][4] = 0.1e1 / v1 * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[4][5][5] = -II / v1 * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[4][7][0] = V22 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[4][7][1] = II * V22 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[4][11][0] = V23 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[4][11][1] = II * V23 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][2][0] = + -0.1e1 / v1 * SMConstants.C_MassCharm * std::conj(V21); + Curvature_Quark_F2H1[5][2][1] = + II / v1 * SMConstants.C_MassCharm * std::conj(V21); + Curvature_Quark_F2H1[5][4][4] = 0.1e1 / v1 * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[5][4][5] = -II / v1 * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[5][6][0] = + -0.1e1 / v1 * SMConstants.C_MassCharm * std::conj(V22); + Curvature_Quark_F2H1[5][6][1] = + II / v1 * SMConstants.C_MassCharm * std::conj(V22); + Curvature_Quark_F2H1[5][10][0] = + -0.1e1 / v1 * SMConstants.C_MassCharm * std::conj(V23); + Curvature_Quark_F2H1[5][10][1] = + II / v1 * SMConstants.C_MassCharm * std::conj(V23); + Curvature_Quark_F2H1[6][1][0] = + -0.1e1 / v1 * SMConstants.C_MassUp * std::conj(V12); + Curvature_Quark_F2H1[6][1][1] = + II / v1 * SMConstants.C_MassUp * std::conj(V12); + Curvature_Quark_F2H1[6][5][0] = + -0.1e1 / v1 * SMConstants.C_MassCharm * std::conj(V22); + Curvature_Quark_F2H1[6][5][1] = + II / v1 * SMConstants.C_MassCharm * std::conj(V22); + Curvature_Quark_F2H1[6][7][4] = 0.1e1 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[6][7][5] = II / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[6][9][0] = + -0.1e1 / v1 * SMConstants.C_MassTop * std::conj(V32); + Curvature_Quark_F2H1[6][9][1] = + II / v1 * SMConstants.C_MassTop * std::conj(V32); + Curvature_Quark_F2H1[7][0][0] = V12 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][0][1] = II * V12 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][4][0] = V22 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][4][1] = II * V22 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][6][4] = 0.1e1 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][6][5] = II / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][8][0] = V32 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][8][1] = II * V32 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[8][3][0] = 0.1e1 / v1 * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[8][3][1] = II / v1 * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[8][7][0] = V32 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[8][7][1] = II * V32 / v1 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[8][9][4] = 0.1e1 / v1 * SMConstants.C_MassTop; + Curvature_Quark_F2H1[8][9][5] = -II / v1 * SMConstants.C_MassTop; + Curvature_Quark_F2H1[8][11][0] = V33 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[8][11][1] = II * V33 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[9][2][0] = + -0.1e1 / v1 * SMConstants.C_MassTop * std::conj(V31); + Curvature_Quark_F2H1[9][2][1] = + II / v1 * SMConstants.C_MassTop * std::conj(V31); + Curvature_Quark_F2H1[9][6][0] = + -0.1e1 / v1 * SMConstants.C_MassTop * std::conj(V32); + Curvature_Quark_F2H1[9][6][1] = + II / v1 * SMConstants.C_MassTop * std::conj(V32); + Curvature_Quark_F2H1[9][8][4] = 0.1e1 / v1 * SMConstants.C_MassTop; + Curvature_Quark_F2H1[9][8][5] = -II / v1 * SMConstants.C_MassTop; + Curvature_Quark_F2H1[9][10][0] = + -0.1e1 / v1 * SMConstants.C_MassTop * std::conj(V33); + Curvature_Quark_F2H1[9][10][1] = + II / v1 * SMConstants.C_MassTop * std::conj(V33); + Curvature_Quark_F2H1[10][1][0] = + -0.1e1 / v1 * SMConstants.C_MassUp * std::conj(V13); + Curvature_Quark_F2H1[10][1][1] = + II / v1 * SMConstants.C_MassUp * std::conj(V13); + Curvature_Quark_F2H1[10][5][0] = + -0.1e1 / v1 * SMConstants.C_MassCharm * std::conj(V23); + Curvature_Quark_F2H1[10][5][1] = + II / v1 * SMConstants.C_MassCharm * std::conj(V23); + Curvature_Quark_F2H1[10][9][0] = + -0.1e1 / v1 * SMConstants.C_MassTop * std::conj(V33); + Curvature_Quark_F2H1[10][9][1] = + II / v1 * SMConstants.C_MassTop * std::conj(V33); + Curvature_Quark_F2H1[10][11][4] = 0.1e1 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[10][11][5] = II / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][0][0] = V13 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][0][1] = II * V13 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][4][0] = V23 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][4][1] = II * V23 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][8][0] = V33 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][8][1] = II * V33 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][10][4] = 0.1e1 / v1 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][10][5] = II / v1 * SMConstants.C_MassBottom; + + Curvature_Lepton_F2H1[0][1][4] = 0.1e1 / v1 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[0][1][5] = II / v1 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][0][4] = 0.1e1 / v1 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][0][5] = II / v1 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][6][0] = 0.1e1 / v1 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][6][1] = II / v1 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[2][3][4] = 0.1e1 / v1 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[2][3][5] = II / v1 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][2][4] = 0.1e1 / v1 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][2][5] = II / v1 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][7][0] = 0.1e1 / v1 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][7][1] = II / v1 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[4][5][4] = 0.1e1 / v1 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[4][5][5] = II / v1 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][4][4] = 0.1e1 / v1 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][4][5] = II / v1 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][8][0] = 0.1e1 / v1 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][8][1] = II / v1 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[6][1][0] = 0.1e1 / v1 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[6][1][1] = II / v1 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[7][3][0] = 0.1e1 / v1 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[7][3][1] = II / v1 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[8][5][0] = 0.1e1 / v1 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[8][5][1] = II / v1 * SMConstants.C_MassTau; } bool Class_Potential_CPintheDark::CalculateDebyeSimplified() diff --git a/src/models/ClassPotentialCxSM.cpp b/src/models/ClassPotentialCxSM.cpp index c97fbd63..c5f5baa4 100644 --- a/src/models/ClassPotentialCxSM.cpp +++ b/src/models/ClassPotentialCxSM.cpp @@ -25,7 +25,8 @@ namespace Models * Lagrangian parameters AFTER using the tadpole conditions), nParCT (number of * counterterms) as well as nVEV (number of VEVs for minimization) */ -Class_CxSM::Class_CxSM() +Class_CxSM::Class_CxSM(const ISMConstants &smConstants) + : Class_Potential_Origin(smConstants) { Model = ModelID::ModelIDs::CXSM; // global int constant which will be used to // tell the program which model is called @@ -1023,46 +1024,58 @@ void Class_CxSM::SetCurvatureArrays() Curvature_Higgs_L4[5][5][4][4] = d2 / 0.2e1; Curvature_Higgs_L4[5][5][5][5] = 0.3e1 / 0.2e1 * d2; - Curvature_Gauge_G2H2[0][0][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][0][3] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][1][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][2][1] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][3][3][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][0][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][1][3] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][2][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][3][3][1] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][0][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][1][1] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][2][2] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][3][3][3] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][0][3] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][1][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][2][1] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][0][3][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][0][2] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][1][3] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][2][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][1][3][1] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][0][0] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][1][1] = C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][2][2] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][2][3][3] = -C_gs * C_g / 0.2e1; - Curvature_Gauge_G2H2[3][3][0][0] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][1][1] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][2][2] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][3][3] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][0][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][0][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][1][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][2][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][3][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][0][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][1][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][2][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][3][1] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][0][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][1][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][2][2] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][3][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][0][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][1][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][2][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][3][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][0][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][1][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][2][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][3][1] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][0][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][1][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][2][2] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][3][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][3][0][0] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][1][1] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][2][2] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][3][3] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; MatrixXcd YIJQc1(NQuarks, NQuarks), YIJQc2(NQuarks, NQuarks), YIJQc2OI(NQuarks, NQuarks), YIJQg0(NQuarks, NQuarks), @@ -1070,149 +1083,170 @@ void Class_CxSM::SetCurvatureArrays() YIJQh2(NQuarks, NQuarks), YIJQh3(NQuarks, NQuarks); std::complex V11, V12, V13, V21, V22, V23, V31, V32, V33; - V11 = C_Vud; - V12 = C_Vus; - V13 = C_Vub; - V21 = C_Vcd; - V22 = C_Vcs; - V23 = C_Vcb; - V31 = C_Vtd; - V32 = C_Vts; - V33 = C_Vtb; + V11 = SMConstants.C_Vud; + V12 = SMConstants.C_Vus; + V13 = SMConstants.C_Vub; + V21 = SMConstants.C_Vcd; + V22 = SMConstants.C_Vcs; + V23 = SMConstants.C_Vcb; + V31 = SMConstants.C_Vtd; + V32 = SMConstants.C_Vts; + V33 = SMConstants.C_Vtb; std::complex VC11, VC12, VC13, VC21, VC22, VC23, VC31, VC32, VC33; - VC11 = std::conj(C_Vud); - VC12 = std::conj(C_Vus); - VC13 = std::conj(C_Vub); - VC21 = std::conj(C_Vcd); - VC22 = std::conj(C_Vcs); - VC23 = std::conj(C_Vcb); - VC31 = std::conj(C_Vtd); - VC32 = std::conj(C_Vts); - VC33 = std::conj(C_Vtb); - - - Curvature_Lepton_F2H1[0][1][2] = II / vh * C_MassElectron; - Curvature_Lepton_F2H1[0][1][3] = 0.1e1 / vh * C_MassElectron; - Curvature_Lepton_F2H1[1][0][2] = II / vh * C_MassElectron; - Curvature_Lepton_F2H1[1][0][3] = 0.1e1 / vh * C_MassElectron; - Curvature_Lepton_F2H1[1][6][0] = 0.1e1 / vh * C_MassElectron; - Curvature_Lepton_F2H1[1][6][1] = II / vh * C_MassElectron; - Curvature_Lepton_F2H1[2][3][2] = II / vh * C_MassMu; - Curvature_Lepton_F2H1[2][3][3] = 0.1e1 / vh * C_MassMu; - Curvature_Lepton_F2H1[3][2][2] = II / vh * C_MassMu; - Curvature_Lepton_F2H1[3][2][3] = 0.1e1 / vh * C_MassMu; - Curvature_Lepton_F2H1[3][7][0] = 0.1e1 / vh * C_MassMu; - Curvature_Lepton_F2H1[3][7][1] = II / vh * C_MassMu; - Curvature_Lepton_F2H1[4][5][2] = II / vh * C_MassTau; - Curvature_Lepton_F2H1[4][5][3] = 0.1e1 / vh * C_MassTau; - Curvature_Lepton_F2H1[5][4][2] = II / vh * C_MassTau; - Curvature_Lepton_F2H1[5][4][3] = 0.1e1 / vh * C_MassTau; - Curvature_Lepton_F2H1[5][8][0] = 0.1e1 / vh * C_MassTau; - Curvature_Lepton_F2H1[5][8][1] = II / vh * C_MassTau; - Curvature_Lepton_F2H1[6][1][0] = 0.1e1 / vh * C_MassElectron; - Curvature_Lepton_F2H1[6][1][1] = II / vh * C_MassElectron; - Curvature_Lepton_F2H1[7][3][0] = 0.1e1 / vh * C_MassMu; - Curvature_Lepton_F2H1[7][3][1] = II / vh * C_MassMu; - Curvature_Lepton_F2H1[8][5][0] = 0.1e1 / vh * C_MassTau; - Curvature_Lepton_F2H1[8][5][1] = II / vh * C_MassTau; - - Curvature_Quark_F2H1[0][6][2] = -II / vh * C_MassUp; - Curvature_Quark_F2H1[0][6][3] = 0.1e1 / vh * C_MassUp; - Curvature_Quark_F2H1[0][9][0] = -0.1e1 / vh * C_MassUp * conj(V11); - Curvature_Quark_F2H1[0][9][1] = II / vh * C_MassUp * conj(V11); - Curvature_Quark_F2H1[0][10][0] = -0.1e1 / vh * C_MassUp * conj(V12); - Curvature_Quark_F2H1[0][10][1] = II / vh * C_MassUp * conj(V12); - Curvature_Quark_F2H1[0][11][0] = -0.1e1 / vh * C_MassUp * conj(V13); - Curvature_Quark_F2H1[0][11][1] = II / vh * C_MassUp * conj(V13); - Curvature_Quark_F2H1[1][7][2] = -II / vh * C_MassCharm; - Curvature_Quark_F2H1[1][7][3] = 0.1e1 / vh * C_MassCharm; - Curvature_Quark_F2H1[1][9][0] = -0.1e1 / vh * C_MassCharm * conj(V21); - Curvature_Quark_F2H1[1][9][1] = II / vh * C_MassCharm * conj(V21); - Curvature_Quark_F2H1[1][10][0] = -0.1e1 / vh * C_MassCharm * conj(V22); - Curvature_Quark_F2H1[1][10][1] = II / vh * C_MassCharm * conj(V22); - Curvature_Quark_F2H1[1][11][0] = -0.1e1 / vh * C_MassCharm * conj(V23); - Curvature_Quark_F2H1[1][11][1] = II / vh * C_MassCharm * conj(V23); - Curvature_Quark_F2H1[2][8][2] = -II / vh * C_MassTop; - Curvature_Quark_F2H1[2][8][3] = 0.1e1 / vh * C_MassTop; - Curvature_Quark_F2H1[2][9][0] = -0.1e1 / vh * C_MassTop * conj(V31); - Curvature_Quark_F2H1[2][9][1] = II / vh * C_MassTop * conj(V31); - Curvature_Quark_F2H1[2][10][0] = -0.1e1 / vh * C_MassTop * conj(V32); - Curvature_Quark_F2H1[2][10][1] = II / vh * C_MassTop * conj(V32); - Curvature_Quark_F2H1[2][11][0] = -0.1e1 / vh * C_MassTop * conj(V33); - Curvature_Quark_F2H1[2][11][1] = II / vh * C_MassTop * conj(V33); - Curvature_Quark_F2H1[3][6][0] = 0.1e1 / vh * C_MassDown * V11; - Curvature_Quark_F2H1[3][6][1] = II / vh * C_MassDown * V11; - Curvature_Quark_F2H1[3][7][0] = V21 / vh * C_MassDown; - Curvature_Quark_F2H1[3][7][1] = II * V21 / vh * C_MassDown; - Curvature_Quark_F2H1[3][8][0] = 0.1e1 / vh * C_MassDown * V31; - Curvature_Quark_F2H1[3][8][1] = II / vh * C_MassDown * V31; - Curvature_Quark_F2H1[3][9][2] = II / vh * C_MassDown; - Curvature_Quark_F2H1[3][9][3] = 0.1e1 / vh * C_MassDown; - Curvature_Quark_F2H1[4][6][0] = 0.1e1 / vh * C_MassStrange * V12; - Curvature_Quark_F2H1[4][6][1] = II / vh * C_MassStrange * V12; - Curvature_Quark_F2H1[4][7][0] = V22 / vh * C_MassStrange; - Curvature_Quark_F2H1[4][7][1] = II * V22 / vh * C_MassStrange; - Curvature_Quark_F2H1[4][8][0] = 0.1e1 / vh * C_MassStrange * V32; - Curvature_Quark_F2H1[4][8][1] = II / vh * C_MassStrange * V32; - Curvature_Quark_F2H1[4][10][2] = II / vh * C_MassStrange; - Curvature_Quark_F2H1[4][10][3] = 0.1e1 / vh * C_MassStrange; - Curvature_Quark_F2H1[5][6][0] = V13 / vh * C_MassBottom; - Curvature_Quark_F2H1[5][6][1] = II / vh * C_MassBottom * V13; - Curvature_Quark_F2H1[5][7][0] = V23 / vh * C_MassBottom; - Curvature_Quark_F2H1[5][7][1] = II / vh * C_MassBottom * V23; - Curvature_Quark_F2H1[5][8][0] = V33 / vh * C_MassBottom; - Curvature_Quark_F2H1[5][8][1] = II / vh * C_MassBottom * V33; - Curvature_Quark_F2H1[5][11][2] = II / vh * C_MassBottom; - Curvature_Quark_F2H1[5][11][3] = 0.1e1 / vh * C_MassBottom; - Curvature_Quark_F2H1[6][0][2] = -II / vh * C_MassUp; - Curvature_Quark_F2H1[6][0][3] = 0.1e1 / vh * C_MassUp; - Curvature_Quark_F2H1[6][3][0] = 0.1e1 / vh * C_MassDown * V11; - Curvature_Quark_F2H1[6][3][1] = II / vh * C_MassDown * V11; - Curvature_Quark_F2H1[6][4][0] = 0.1e1 / vh * C_MassStrange * V12; - Curvature_Quark_F2H1[6][4][1] = II / vh * C_MassStrange * V12; - Curvature_Quark_F2H1[6][5][0] = V13 / vh * C_MassBottom; - Curvature_Quark_F2H1[6][5][1] = II / vh * C_MassBottom * V13; - Curvature_Quark_F2H1[7][1][2] = -II / vh * C_MassCharm; - Curvature_Quark_F2H1[7][1][3] = 0.1e1 / vh * C_MassCharm; - Curvature_Quark_F2H1[7][3][0] = V21 / vh * C_MassDown; - Curvature_Quark_F2H1[7][3][1] = II * V21 / vh * C_MassDown; - Curvature_Quark_F2H1[7][4][0] = V22 / vh * C_MassStrange; - Curvature_Quark_F2H1[7][4][1] = II * V22 / vh * C_MassStrange; - Curvature_Quark_F2H1[7][5][0] = V23 / vh * C_MassBottom; - Curvature_Quark_F2H1[7][5][1] = II / vh * C_MassBottom * V23; - Curvature_Quark_F2H1[8][2][2] = -II / vh * C_MassTop; - Curvature_Quark_F2H1[8][2][3] = 0.1e1 / vh * C_MassTop; - Curvature_Quark_F2H1[8][3][0] = 0.1e1 / vh * C_MassDown * V31; - Curvature_Quark_F2H1[8][3][1] = II / vh * C_MassDown * V31; - Curvature_Quark_F2H1[8][4][0] = 0.1e1 / vh * C_MassStrange * V32; - Curvature_Quark_F2H1[8][4][1] = II / vh * C_MassStrange * V32; - Curvature_Quark_F2H1[8][5][0] = V33 / vh * C_MassBottom; - Curvature_Quark_F2H1[8][5][1] = II / vh * C_MassBottom * V33; - Curvature_Quark_F2H1[9][0][0] = -0.1e1 / vh * C_MassUp * conj(V11); - Curvature_Quark_F2H1[9][0][1] = II / vh * C_MassUp * conj(V11); - Curvature_Quark_F2H1[9][1][0] = -0.1e1 / vh * C_MassCharm * conj(V21); - Curvature_Quark_F2H1[9][1][1] = II / vh * C_MassCharm * conj(V21); - Curvature_Quark_F2H1[9][2][0] = -0.1e1 / vh * C_MassTop * conj(V31); - Curvature_Quark_F2H1[9][2][1] = II / vh * C_MassTop * conj(V31); - Curvature_Quark_F2H1[9][3][2] = II / vh * C_MassDown; - Curvature_Quark_F2H1[9][3][3] = 0.1e1 / vh * C_MassDown; - Curvature_Quark_F2H1[10][0][0] = -0.1e1 / vh * C_MassUp * conj(V12); - Curvature_Quark_F2H1[10][0][1] = II / vh * C_MassUp * conj(V12); - Curvature_Quark_F2H1[10][1][0] = -0.1e1 / vh * C_MassCharm * conj(V22); - Curvature_Quark_F2H1[10][1][1] = II / vh * C_MassCharm * conj(V22); - Curvature_Quark_F2H1[10][2][0] = -0.1e1 / vh * C_MassTop * conj(V32); - Curvature_Quark_F2H1[10][2][1] = II / vh * C_MassTop * conj(V32); - Curvature_Quark_F2H1[10][4][2] = II / vh * C_MassStrange; - Curvature_Quark_F2H1[10][4][3] = 0.1e1 / vh * C_MassStrange; - Curvature_Quark_F2H1[11][0][0] = -0.1e1 / vh * C_MassUp * conj(V13); - Curvature_Quark_F2H1[11][0][1] = II / vh * C_MassUp * conj(V13); - Curvature_Quark_F2H1[11][1][0] = -0.1e1 / vh * C_MassCharm * conj(V23); - Curvature_Quark_F2H1[11][1][1] = II / vh * C_MassCharm * conj(V23); - Curvature_Quark_F2H1[11][2][0] = -0.1e1 / vh * C_MassTop * conj(V33); - Curvature_Quark_F2H1[11][2][1] = II / vh * C_MassTop * conj(V33); - Curvature_Quark_F2H1[11][5][2] = II / vh * C_MassBottom; - Curvature_Quark_F2H1[11][5][3] = 0.1e1 / vh * C_MassBottom; + VC11 = std::conj(SMConstants.C_Vud); + VC12 = std::conj(SMConstants.C_Vus); + VC13 = std::conj(SMConstants.C_Vub); + VC21 = std::conj(SMConstants.C_Vcd); + VC22 = std::conj(SMConstants.C_Vcs); + VC23 = std::conj(SMConstants.C_Vcb); + VC31 = std::conj(SMConstants.C_Vtd); + VC32 = std::conj(SMConstants.C_Vts); + VC33 = std::conj(SMConstants.C_Vtb); + + Curvature_Lepton_F2H1[0][1][2] = II / vh * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[0][1][3] = 0.1e1 / vh * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][0][2] = II / vh * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][0][3] = 0.1e1 / vh * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][6][0] = 0.1e1 / vh * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][6][1] = II / vh * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[2][3][2] = II / vh * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[2][3][3] = 0.1e1 / vh * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][2][2] = II / vh * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][2][3] = 0.1e1 / vh * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][7][0] = 0.1e1 / vh * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][7][1] = II / vh * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[4][5][2] = II / vh * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[4][5][3] = 0.1e1 / vh * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][4][2] = II / vh * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][4][3] = 0.1e1 / vh * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][8][0] = 0.1e1 / vh * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][8][1] = II / vh * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[6][1][0] = 0.1e1 / vh * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[6][1][1] = II / vh * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[7][3][0] = 0.1e1 / vh * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[7][3][1] = II / vh * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[8][5][0] = 0.1e1 / vh * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[8][5][1] = II / vh * SMConstants.C_MassTau; + + Curvature_Quark_F2H1[0][6][2] = -II / vh * SMConstants.C_MassUp; + Curvature_Quark_F2H1[0][6][3] = 0.1e1 / vh * SMConstants.C_MassUp; + Curvature_Quark_F2H1[0][9][0] = + -0.1e1 / vh * SMConstants.C_MassUp * conj(V11); + Curvature_Quark_F2H1[0][9][1] = II / vh * SMConstants.C_MassUp * conj(V11); + Curvature_Quark_F2H1[0][10][0] = + -0.1e1 / vh * SMConstants.C_MassUp * conj(V12); + Curvature_Quark_F2H1[0][10][1] = II / vh * SMConstants.C_MassUp * conj(V12); + Curvature_Quark_F2H1[0][11][0] = + -0.1e1 / vh * SMConstants.C_MassUp * conj(V13); + Curvature_Quark_F2H1[0][11][1] = II / vh * SMConstants.C_MassUp * conj(V13); + Curvature_Quark_F2H1[1][7][2] = -II / vh * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[1][7][3] = 0.1e1 / vh * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[1][9][0] = + -0.1e1 / vh * SMConstants.C_MassCharm * conj(V21); + Curvature_Quark_F2H1[1][9][1] = II / vh * SMConstants.C_MassCharm * conj(V21); + Curvature_Quark_F2H1[1][10][0] = + -0.1e1 / vh * SMConstants.C_MassCharm * conj(V22); + Curvature_Quark_F2H1[1][10][1] = + II / vh * SMConstants.C_MassCharm * conj(V22); + Curvature_Quark_F2H1[1][11][0] = + -0.1e1 / vh * SMConstants.C_MassCharm * conj(V23); + Curvature_Quark_F2H1[1][11][1] = + II / vh * SMConstants.C_MassCharm * conj(V23); + Curvature_Quark_F2H1[2][8][2] = -II / vh * SMConstants.C_MassTop; + Curvature_Quark_F2H1[2][8][3] = 0.1e1 / vh * SMConstants.C_MassTop; + Curvature_Quark_F2H1[2][9][0] = + -0.1e1 / vh * SMConstants.C_MassTop * conj(V31); + Curvature_Quark_F2H1[2][9][1] = II / vh * SMConstants.C_MassTop * conj(V31); + Curvature_Quark_F2H1[2][10][0] = + -0.1e1 / vh * SMConstants.C_MassTop * conj(V32); + Curvature_Quark_F2H1[2][10][1] = II / vh * SMConstants.C_MassTop * conj(V32); + Curvature_Quark_F2H1[2][11][0] = + -0.1e1 / vh * SMConstants.C_MassTop * conj(V33); + Curvature_Quark_F2H1[2][11][1] = II / vh * SMConstants.C_MassTop * conj(V33); + Curvature_Quark_F2H1[3][6][0] = 0.1e1 / vh * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[3][6][1] = II / vh * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[3][7][0] = V21 / vh * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][7][1] = II * V21 / vh * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][8][0] = 0.1e1 / vh * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[3][8][1] = II / vh * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[3][9][2] = II / vh * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][9][3] = 0.1e1 / vh * SMConstants.C_MassDown; + Curvature_Quark_F2H1[4][6][0] = 0.1e1 / vh * SMConstants.C_MassStrange * V12; + Curvature_Quark_F2H1[4][6][1] = II / vh * SMConstants.C_MassStrange * V12; + Curvature_Quark_F2H1[4][7][0] = V22 / vh * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[4][7][1] = II * V22 / vh * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[4][8][0] = 0.1e1 / vh * SMConstants.C_MassStrange * V32; + Curvature_Quark_F2H1[4][8][1] = II / vh * SMConstants.C_MassStrange * V32; + Curvature_Quark_F2H1[4][10][2] = II / vh * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[4][10][3] = 0.1e1 / vh * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[5][6][0] = V13 / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][6][1] = II / vh * SMConstants.C_MassBottom * V13; + Curvature_Quark_F2H1[5][7][0] = V23 / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][7][1] = II / vh * SMConstants.C_MassBottom * V23; + Curvature_Quark_F2H1[5][8][0] = V33 / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][8][1] = II / vh * SMConstants.C_MassBottom * V33; + Curvature_Quark_F2H1[5][11][2] = II / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][11][3] = 0.1e1 / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[6][0][2] = -II / vh * SMConstants.C_MassUp; + Curvature_Quark_F2H1[6][0][3] = 0.1e1 / vh * SMConstants.C_MassUp; + Curvature_Quark_F2H1[6][3][0] = 0.1e1 / vh * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[6][3][1] = II / vh * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[6][4][0] = 0.1e1 / vh * SMConstants.C_MassStrange * V12; + Curvature_Quark_F2H1[6][4][1] = II / vh * SMConstants.C_MassStrange * V12; + Curvature_Quark_F2H1[6][5][0] = V13 / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[6][5][1] = II / vh * SMConstants.C_MassBottom * V13; + Curvature_Quark_F2H1[7][1][2] = -II / vh * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[7][1][3] = 0.1e1 / vh * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[7][3][0] = V21 / vh * SMConstants.C_MassDown; + Curvature_Quark_F2H1[7][3][1] = II * V21 / vh * SMConstants.C_MassDown; + Curvature_Quark_F2H1[7][4][0] = V22 / vh * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][4][1] = II * V22 / vh * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][5][0] = V23 / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[7][5][1] = II / vh * SMConstants.C_MassBottom * V23; + Curvature_Quark_F2H1[8][2][2] = -II / vh * SMConstants.C_MassTop; + Curvature_Quark_F2H1[8][2][3] = 0.1e1 / vh * SMConstants.C_MassTop; + Curvature_Quark_F2H1[8][3][0] = 0.1e1 / vh * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[8][3][1] = II / vh * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[8][4][0] = 0.1e1 / vh * SMConstants.C_MassStrange * V32; + Curvature_Quark_F2H1[8][4][1] = II / vh * SMConstants.C_MassStrange * V32; + Curvature_Quark_F2H1[8][5][0] = V33 / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[8][5][1] = II / vh * SMConstants.C_MassBottom * V33; + Curvature_Quark_F2H1[9][0][0] = + -0.1e1 / vh * SMConstants.C_MassUp * conj(V11); + Curvature_Quark_F2H1[9][0][1] = II / vh * SMConstants.C_MassUp * conj(V11); + Curvature_Quark_F2H1[9][1][0] = + -0.1e1 / vh * SMConstants.C_MassCharm * conj(V21); + Curvature_Quark_F2H1[9][1][1] = II / vh * SMConstants.C_MassCharm * conj(V21); + Curvature_Quark_F2H1[9][2][0] = + -0.1e1 / vh * SMConstants.C_MassTop * conj(V31); + Curvature_Quark_F2H1[9][2][1] = II / vh * SMConstants.C_MassTop * conj(V31); + Curvature_Quark_F2H1[9][3][2] = II / vh * SMConstants.C_MassDown; + Curvature_Quark_F2H1[9][3][3] = 0.1e1 / vh * SMConstants.C_MassDown; + Curvature_Quark_F2H1[10][0][0] = + -0.1e1 / vh * SMConstants.C_MassUp * conj(V12); + Curvature_Quark_F2H1[10][0][1] = II / vh * SMConstants.C_MassUp * conj(V12); + Curvature_Quark_F2H1[10][1][0] = + -0.1e1 / vh * SMConstants.C_MassCharm * conj(V22); + Curvature_Quark_F2H1[10][1][1] = + II / vh * SMConstants.C_MassCharm * conj(V22); + Curvature_Quark_F2H1[10][2][0] = + -0.1e1 / vh * SMConstants.C_MassTop * conj(V32); + Curvature_Quark_F2H1[10][2][1] = II / vh * SMConstants.C_MassTop * conj(V32); + Curvature_Quark_F2H1[10][4][2] = II / vh * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[10][4][3] = 0.1e1 / vh * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[11][0][0] = + -0.1e1 / vh * SMConstants.C_MassUp * conj(V13); + Curvature_Quark_F2H1[11][0][1] = II / vh * SMConstants.C_MassUp * conj(V13); + Curvature_Quark_F2H1[11][1][0] = + -0.1e1 / vh * SMConstants.C_MassCharm * conj(V23); + Curvature_Quark_F2H1[11][1][1] = + II / vh * SMConstants.C_MassCharm * conj(V23); + Curvature_Quark_F2H1[11][2][0] = + -0.1e1 / vh * SMConstants.C_MassTop * conj(V33); + Curvature_Quark_F2H1[11][2][1] = II / vh * SMConstants.C_MassTop * conj(V33); + Curvature_Quark_F2H1[11][5][2] = II / vh * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][5][3] = 0.1e1 / vh * SMConstants.C_MassBottom; SetCurvatureDone = true; } @@ -1259,7 +1293,7 @@ void Class_CxSM::Debugging(const std::vector &input, (void)output; Logger::Write(LoggingLevel::Debug, std::string("Start ") + __func__); - bool Debug = true; + bool Debug = false; if (not Debug) return; diff --git a/src/models/ClassPotentialRN2HDM.cpp b/src/models/ClassPotentialN2HDM.cpp similarity index 90% rename from src/models/ClassPotentialRN2HDM.cpp rename to src/models/ClassPotentialN2HDM.cpp index 883cf0ea..2caed38e 100644 --- a/src/models/ClassPotentialRN2HDM.cpp +++ b/src/models/ClassPotentialN2HDM.cpp @@ -8,7 +8,7 @@ @file */ -#include +#include #include #include #include @@ -20,10 +20,11 @@ namespace BSMPT namespace Models { -Class_Potential_RN2HDM::Class_Potential_RN2HDM() +Class_Potential_N2HDM::Class_Potential_N2HDM(const ISMConstants &smConstants) + : Class_Potential_Origin(smConstants) { // TODO Auto-generated constructor stub - Model = ModelID::ModelIDs::RN2HDM; + Model = ModelID::ModelIDs::N2HDM; NNeutralHiggs = 5; NChargedHiggs = 4; @@ -53,7 +54,7 @@ Class_Potential_RN2HDM::Class_Potential_RN2HDM() UseVCounterSimplified = false; } -Class_Potential_RN2HDM::~Class_Potential_RN2HDM() +Class_Potential_N2HDM::~Class_Potential_N2HDM() { // TODO Auto-generated destructor stub } @@ -62,7 +63,7 @@ Class_Potential_RN2HDM::~Class_Potential_RN2HDM() * returns a string which tells the user the chronological order of the * counterterms. Use this to complement the legend of the given inputfile */ -std::vector Class_Potential_RN2HDM::addLegendCT() const +std::vector Class_Potential_N2HDM::addLegendCT() const { std::vector labels; labels.push_back("Du11sq"); @@ -88,7 +89,7 @@ std::vector Class_Potential_RN2HDM::addLegendCT() const * the critical temperature. Use this to complement the legend of the given * inputfile */ -std::vector Class_Potential_RN2HDM::addLegendTemp() const +std::vector Class_Potential_N2HDM::addLegendTemp() const { std::vector labels; labels.push_back("T_c"); @@ -109,8 +110,7 @@ std::vector Class_Potential_RN2HDM::addLegendTemp() const * * Beware, this is not implemented yet! */ -std::vector -Class_Potential_RN2HDM::addLegendTripleCouplings() const +std::vector Class_Potential_N2HDM::addLegendTripleCouplings() const { std::vector particles; std::vector labels; @@ -148,7 +148,7 @@ Class_Potential_RN2HDM::addLegendTripleCouplings() const * returns a string which tells the user the chronological order of the VEVs. * Use this to complement the legend of the given inputfile */ -std::vector Class_Potential_RN2HDM::addLegendVEV() const +std::vector Class_Potential_N2HDM::addLegendVEV() const { std::vector labels; labels.push_back("omega_{CB}"); @@ -159,8 +159,8 @@ std::vector Class_Potential_RN2HDM::addLegendVEV() const return labels; } -void Class_Potential_RN2HDM::ReadAndSet(const std::string &linestr, - std::vector &par) +void Class_Potential_N2HDM::ReadAndSet(const std::string &linestr, + std::vector &par) { std::stringstream ss(linestr); double tmp; @@ -218,7 +218,7 @@ void Class_Potential_RN2HDM::ReadAndSet(const std::string &linestr, return; } -void Class_Potential_RN2HDM::set_gen(const std::vector &p) +void Class_Potential_N2HDM::set_gen(const std::vector &p) { L1 = p[0]; @@ -232,7 +232,7 @@ void Class_Potential_RN2HDM::set_gen(const std::vector &p) TanBeta = p[8]; Nvs = p[9]; RealMMix = p[10]; - scale = C_vev0; + scale = SMConstants.C_vev0; Type = p[11]; C_CosBetaSquared = 1.0 / (1 + TanBeta * TanBeta); @@ -241,8 +241,8 @@ void Class_Potential_RN2HDM::set_gen(const std::vector &p) C_SinBeta = sqrt(C_SinBetaSquared); beta = std::atan(TanBeta); - double v1 = C_vev0 * C_CosBeta; - double v2 = C_vev0 * C_SinBeta; + double v1 = SMConstants.C_vev0 * C_CosBeta; + double v2 = SMConstants.C_vev0 * C_SinBeta; u1 = RealMMix * TanBeta - 0.5 * v1 * v1 * L1 - 0.5 * v2 * v2 * (L3 + L4 + RL5) - 0.5 * Nvs * Nvs * NL7; @@ -253,19 +253,14 @@ void Class_Potential_RN2HDM::set_gen(const std::vector &p) vevTreeMin.resize(nVEV); vevTreeMin[0] = 0; vevTreeMin[1] = 0; - vevTreeMin[2] = C_vev0 * C_CosBeta; - vevTreeMin[3] = C_vev0 * C_SinBeta; + vevTreeMin[2] = SMConstants.C_vev0 * C_CosBeta; + vevTreeMin[3] = SMConstants.C_vev0 * C_SinBeta; vevTreeMin[4] = Nvs; vevTree.resize(NHiggs); vevTree = MinimizeOrderVEV(vevTreeMin); } -/** - *@brief Set Counterterm-Parameters from Inputarray with 11 Arguments - * - * - */ -void Class_Potential_RN2HDM::set_CT_Pot_Par(const std::vector &p) +void Class_Potential_N2HDM::set_CT_Pot_Par(const std::vector &p) { // double *p = (double *)par; @@ -431,7 +426,7 @@ void Class_Potential_RN2HDM::set_CT_Pot_Par(const std::vector &p) /** * Console-Output of all Parameters */ -void Class_Potential_RN2HDM::write() const +void Class_Potential_N2HDM::write() const { std::stringstream ss; typedef std::numeric_limits dbl; @@ -443,8 +438,8 @@ void Class_Potential_RN2HDM::write() const ss << "The parameters are : \n"; ss << "Model = " << Model << "\n"; ss << "Renorm Scale = " << scale << "\n"; - ss << "v1 = " << C_vev0 * C_CosBeta << "\n"; - ss << "v2 = " << C_vev0 * C_SinBeta << "\n"; + ss << "v1 = " << SMConstants.C_vev0 * C_CosBeta << "\n"; + ss << "v2 = " << SMConstants.C_vev0 * C_SinBeta << "\n"; ss << "Type = " << Type << "\n"; ss << "beta = " << beta << std::endl; @@ -618,7 +613,7 @@ void Class_Potential_RN2HDM::write() const Logger::Write(LoggingLevel::Default, ss.str()); } -std::vector Class_Potential_RN2HDM::calc_CT() const +std::vector Class_Potential_N2HDM::calc_CT() const { std::vector parCT; @@ -638,8 +633,8 @@ std::vector Class_Potential_RN2HDM::calc_CT() const WeinbergNabla = WeinbergFirstDerivative(); WeinbergHesse = WeinbergSecondDerivative(); - double v1 = C_vev0 * C_CosBeta; - double v2 = C_vev0 * C_SinBeta; + double v1 = SMConstants.C_vev0 * C_CosBeta; + double v2 = SMConstants.C_vev0 * C_SinBeta; VectorXd NablaWeinberg(NHiggs); MatrixXd HesseWeinberg(NHiggs, NHiggs), HiggsRot(NHiggs, NHiggs); @@ -777,7 +772,7 @@ std::vector Class_Potential_RN2HDM::calc_CT() const return parCT; } -void Class_Potential_RN2HDM::TripleHiggsCouplings() +void Class_Potential_N2HDM::TripleHiggsCouplings() { if (!SetCurvatureDone) SetCurvatureArrays(); if (!CalcCouplingsdone) CalculatePhysicalCouplings(); @@ -811,9 +806,9 @@ void Class_Potential_RN2HDM::TripleHiggsCouplings() MatrixXd HiggsRotSort(NHiggs, NHiggs); int posMHCS1 = 0, posMHCS2 = 0; int posA = 0; - int posN[3]; - int countposN = 0; - int posG1 = 0, posG2 = 0, posG0 = 0; + std::vector posN(3); + std::size_t countposN = 0; + std::size_t posG1 = 0, posG2 = 0, posG0 = 0; double testsum = 0; const double ZeroThreshold = 1e-5; @@ -837,7 +832,7 @@ void Class_Potential_RN2HDM::TripleHiggsCouplings() std::abs(HiggsRot(i, 8)); if (testsum > ZeroThreshold) { - posN[countposN] = i; + posN.at(countposN) = i; countposN++; } testsum = std::abs(HiggsRot(i, 4)) + std::abs(HiggsRot(i, 5)); @@ -850,7 +845,7 @@ void Class_Potential_RN2HDM::TripleHiggsCouplings() double NeutralHiggs[3]; for (int i = 0; i < 3; i++) { - NeutralHiggs[i] = HiggsMasses[posN[i]]; + NeutralHiggs[i] = HiggsMasses[posN.at(i)]; } for (int i = 0; i < 3; i++) { @@ -944,7 +939,7 @@ void Class_Potential_RN2HDM::TripleHiggsCouplings() } } -void Class_Potential_RN2HDM::SetCurvatureArrays() +void Class_Potential_N2HDM::SetCurvatureArrays() { initVectors(); @@ -959,8 +954,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() } } - HiggsVev[6] = C_vev0 * C_CosBeta; - HiggsVev[7] = C_vev0 * C_SinBeta; + HiggsVev[6] = SMConstants.C_vev0 * C_CosBeta; + HiggsVev[7] = SMConstants.C_vev0 * C_SinBeta; HiggsVev[8] = Nvs; Curvature_Higgs_L2[0][0] = u1; Curvature_Higgs_L2[0][1] = -RealMMix; @@ -1611,7 +1606,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() } } - Curvature_Gauge_G2H2[0][0][0][0] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][0][0][1] = 0; Curvature_Gauge_G2H2[0][0][0][2] = 0; Curvature_Gauge_G2H2[0][0][0][3] = 0; @@ -1621,7 +1616,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][0][0][7] = 0; Curvature_Gauge_G2H2[0][0][0][8] = 0; Curvature_Gauge_G2H2[0][0][1][0] = 0; - Curvature_Gauge_G2H2[0][0][1][1] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][0][1][2] = 0; Curvature_Gauge_G2H2[0][0][1][3] = 0; Curvature_Gauge_G2H2[0][0][1][4] = 0; @@ -1631,7 +1626,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][0][1][8] = 0; Curvature_Gauge_G2H2[0][0][2][0] = 0; Curvature_Gauge_G2H2[0][0][2][1] = 0; - Curvature_Gauge_G2H2[0][0][2][2] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][0][2][3] = 0; Curvature_Gauge_G2H2[0][0][2][4] = 0; Curvature_Gauge_G2H2[0][0][2][5] = 0; @@ -1641,7 +1636,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][0][3][0] = 0; Curvature_Gauge_G2H2[0][0][3][1] = 0; Curvature_Gauge_G2H2[0][0][3][2] = 0; - Curvature_Gauge_G2H2[0][0][3][3] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][0][3][4] = 0; Curvature_Gauge_G2H2[0][0][3][5] = 0; Curvature_Gauge_G2H2[0][0][3][6] = 0; @@ -1651,7 +1646,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][0][4][1] = 0; Curvature_Gauge_G2H2[0][0][4][2] = 0; Curvature_Gauge_G2H2[0][0][4][3] = 0; - Curvature_Gauge_G2H2[0][0][4][4] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][0][4][5] = 0; Curvature_Gauge_G2H2[0][0][4][6] = 0; Curvature_Gauge_G2H2[0][0][4][7] = 0; @@ -1661,7 +1656,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][0][5][2] = 0; Curvature_Gauge_G2H2[0][0][5][3] = 0; Curvature_Gauge_G2H2[0][0][5][4] = 0; - Curvature_Gauge_G2H2[0][0][5][5] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][0][5][6] = 0; Curvature_Gauge_G2H2[0][0][5][7] = 0; Curvature_Gauge_G2H2[0][0][5][8] = 0; @@ -1671,7 +1666,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][0][6][3] = 0; Curvature_Gauge_G2H2[0][0][6][4] = 0; Curvature_Gauge_G2H2[0][0][6][5] = 0; - Curvature_Gauge_G2H2[0][0][6][6] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][0][6][7] = 0; Curvature_Gauge_G2H2[0][0][6][8] = 0; Curvature_Gauge_G2H2[0][0][7][0] = 0; @@ -1681,7 +1676,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][0][7][4] = 0; Curvature_Gauge_G2H2[0][0][7][5] = 0; Curvature_Gauge_G2H2[0][0][7][6] = 0; - Curvature_Gauge_G2H2[0][0][7][7] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][0][7][8] = 0; Curvature_Gauge_G2H2[0][0][8][0] = 0; Curvature_Gauge_G2H2[0][0][8][1] = 0; @@ -1860,7 +1855,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][3][0][3] = 0; Curvature_Gauge_G2H2[0][3][0][4] = 0; Curvature_Gauge_G2H2[0][3][0][5] = 0; - Curvature_Gauge_G2H2[0][3][0][6] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][0][6] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][3][0][7] = 0; Curvature_Gauge_G2H2[0][3][0][8] = 0; Curvature_Gauge_G2H2[0][3][1][0] = 0; @@ -1870,13 +1865,13 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][3][1][4] = 0; Curvature_Gauge_G2H2[0][3][1][5] = 0; Curvature_Gauge_G2H2[0][3][1][6] = 0; - Curvature_Gauge_G2H2[0][3][1][7] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][1][7] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][3][1][8] = 0; Curvature_Gauge_G2H2[0][3][2][0] = 0; Curvature_Gauge_G2H2[0][3][2][1] = 0; Curvature_Gauge_G2H2[0][3][2][2] = 0; Curvature_Gauge_G2H2[0][3][2][3] = 0; - Curvature_Gauge_G2H2[0][3][2][4] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][2][4] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][3][2][5] = 0; Curvature_Gauge_G2H2[0][3][2][6] = 0; Curvature_Gauge_G2H2[0][3][2][7] = 0; @@ -1886,13 +1881,13 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][3][3][2] = 0; Curvature_Gauge_G2H2[0][3][3][3] = 0; Curvature_Gauge_G2H2[0][3][3][4] = 0; - Curvature_Gauge_G2H2[0][3][3][5] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][3][5] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][3][3][6] = 0; Curvature_Gauge_G2H2[0][3][3][7] = 0; Curvature_Gauge_G2H2[0][3][3][8] = 0; Curvature_Gauge_G2H2[0][3][4][0] = 0; Curvature_Gauge_G2H2[0][3][4][1] = 0; - Curvature_Gauge_G2H2[0][3][4][2] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][4][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][3][4][3] = 0; Curvature_Gauge_G2H2[0][3][4][4] = 0; Curvature_Gauge_G2H2[0][3][4][5] = 0; @@ -1902,13 +1897,13 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][3][5][0] = 0; Curvature_Gauge_G2H2[0][3][5][1] = 0; Curvature_Gauge_G2H2[0][3][5][2] = 0; - Curvature_Gauge_G2H2[0][3][5][3] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][5][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][3][5][4] = 0; Curvature_Gauge_G2H2[0][3][5][5] = 0; Curvature_Gauge_G2H2[0][3][5][6] = 0; Curvature_Gauge_G2H2[0][3][5][7] = 0; Curvature_Gauge_G2H2[0][3][5][8] = 0; - Curvature_Gauge_G2H2[0][3][6][0] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][6][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][3][6][1] = 0; Curvature_Gauge_G2H2[0][3][6][2] = 0; Curvature_Gauge_G2H2[0][3][6][3] = 0; @@ -1918,7 +1913,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[0][3][6][7] = 0; Curvature_Gauge_G2H2[0][3][6][8] = 0; Curvature_Gauge_G2H2[0][3][7][0] = 0; - Curvature_Gauge_G2H2[0][3][7][1] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][7][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[0][3][7][2] = 0; Curvature_Gauge_G2H2[0][3][7][3] = 0; Curvature_Gauge_G2H2[0][3][7][4] = 0; @@ -2016,7 +2011,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][0][8][6] = 0; Curvature_Gauge_G2H2[1][0][8][7] = 0; Curvature_Gauge_G2H2[1][0][8][8] = 0; - Curvature_Gauge_G2H2[1][1][0][0] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][1][0][1] = 0; Curvature_Gauge_G2H2[1][1][0][2] = 0; Curvature_Gauge_G2H2[1][1][0][3] = 0; @@ -2026,7 +2021,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][1][0][7] = 0; Curvature_Gauge_G2H2[1][1][0][8] = 0; Curvature_Gauge_G2H2[1][1][1][0] = 0; - Curvature_Gauge_G2H2[1][1][1][1] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][1][1][2] = 0; Curvature_Gauge_G2H2[1][1][1][3] = 0; Curvature_Gauge_G2H2[1][1][1][4] = 0; @@ -2036,7 +2031,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][1][1][8] = 0; Curvature_Gauge_G2H2[1][1][2][0] = 0; Curvature_Gauge_G2H2[1][1][2][1] = 0; - Curvature_Gauge_G2H2[1][1][2][2] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][1][2][3] = 0; Curvature_Gauge_G2H2[1][1][2][4] = 0; Curvature_Gauge_G2H2[1][1][2][5] = 0; @@ -2046,7 +2041,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][1][3][0] = 0; Curvature_Gauge_G2H2[1][1][3][1] = 0; Curvature_Gauge_G2H2[1][1][3][2] = 0; - Curvature_Gauge_G2H2[1][1][3][3] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][1][3][4] = 0; Curvature_Gauge_G2H2[1][1][3][5] = 0; Curvature_Gauge_G2H2[1][1][3][6] = 0; @@ -2056,7 +2051,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][1][4][1] = 0; Curvature_Gauge_G2H2[1][1][4][2] = 0; Curvature_Gauge_G2H2[1][1][4][3] = 0; - Curvature_Gauge_G2H2[1][1][4][4] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][1][4][5] = 0; Curvature_Gauge_G2H2[1][1][4][6] = 0; Curvature_Gauge_G2H2[1][1][4][7] = 0; @@ -2066,7 +2061,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][1][5][2] = 0; Curvature_Gauge_G2H2[1][1][5][3] = 0; Curvature_Gauge_G2H2[1][1][5][4] = 0; - Curvature_Gauge_G2H2[1][1][5][5] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][1][5][6] = 0; Curvature_Gauge_G2H2[1][1][5][7] = 0; Curvature_Gauge_G2H2[1][1][5][8] = 0; @@ -2076,7 +2071,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][1][6][3] = 0; Curvature_Gauge_G2H2[1][1][6][4] = 0; Curvature_Gauge_G2H2[1][1][6][5] = 0; - Curvature_Gauge_G2H2[1][1][6][6] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][1][6][7] = 0; Curvature_Gauge_G2H2[1][1][6][8] = 0; Curvature_Gauge_G2H2[1][1][7][0] = 0; @@ -2086,7 +2081,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][1][7][4] = 0; Curvature_Gauge_G2H2[1][1][7][5] = 0; Curvature_Gauge_G2H2[1][1][7][6] = 0; - Curvature_Gauge_G2H2[1][1][7][7] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][1][7][8] = 0; Curvature_Gauge_G2H2[1][1][8][0] = 0; Curvature_Gauge_G2H2[1][1][8][1] = 0; @@ -2182,7 +2177,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][3][0][1] = 0; Curvature_Gauge_G2H2[1][3][0][2] = 0; Curvature_Gauge_G2H2[1][3][0][3] = 0; - Curvature_Gauge_G2H2[1][3][0][4] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][0][4] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][3][0][5] = 0; Curvature_Gauge_G2H2[1][3][0][6] = 0; Curvature_Gauge_G2H2[1][3][0][7] = 0; @@ -2192,7 +2187,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][3][1][2] = 0; Curvature_Gauge_G2H2[1][3][1][3] = 0; Curvature_Gauge_G2H2[1][3][1][4] = 0; - Curvature_Gauge_G2H2[1][3][1][5] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][1][5] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][3][1][6] = 0; Curvature_Gauge_G2H2[1][3][1][7] = 0; Curvature_Gauge_G2H2[1][3][1][8] = 0; @@ -2202,7 +2197,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][3][2][3] = 0; Curvature_Gauge_G2H2[1][3][2][4] = 0; Curvature_Gauge_G2H2[1][3][2][5] = 0; - Curvature_Gauge_G2H2[1][3][2][6] = -C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][2][6] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][3][2][7] = 0; Curvature_Gauge_G2H2[1][3][2][8] = 0; Curvature_Gauge_G2H2[1][3][3][0] = 0; @@ -2212,9 +2208,10 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][3][3][4] = 0; Curvature_Gauge_G2H2[1][3][3][5] = 0; Curvature_Gauge_G2H2[1][3][3][6] = 0; - Curvature_Gauge_G2H2[1][3][3][7] = -C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][3][7] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][3][3][8] = 0; - Curvature_Gauge_G2H2[1][3][4][0] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][4][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][3][4][1] = 0; Curvature_Gauge_G2H2[1][3][4][2] = 0; Curvature_Gauge_G2H2[1][3][4][3] = 0; @@ -2224,7 +2221,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][3][4][7] = 0; Curvature_Gauge_G2H2[1][3][4][8] = 0; Curvature_Gauge_G2H2[1][3][5][0] = 0; - Curvature_Gauge_G2H2[1][3][5][1] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][5][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][3][5][2] = 0; Curvature_Gauge_G2H2[1][3][5][3] = 0; Curvature_Gauge_G2H2[1][3][5][4] = 0; @@ -2234,7 +2231,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][3][5][8] = 0; Curvature_Gauge_G2H2[1][3][6][0] = 0; Curvature_Gauge_G2H2[1][3][6][1] = 0; - Curvature_Gauge_G2H2[1][3][6][2] = -C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][6][2] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][3][6][3] = 0; Curvature_Gauge_G2H2[1][3][6][4] = 0; Curvature_Gauge_G2H2[1][3][6][5] = 0; @@ -2244,7 +2242,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[1][3][7][0] = 0; Curvature_Gauge_G2H2[1][3][7][1] = 0; Curvature_Gauge_G2H2[1][3][7][2] = 0; - Curvature_Gauge_G2H2[1][3][7][3] = -C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][7][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[1][3][7][4] = 0; Curvature_Gauge_G2H2[1][3][7][5] = 0; Curvature_Gauge_G2H2[1][3][7][6] = 0; @@ -2421,7 +2420,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][1][8][6] = 0; Curvature_Gauge_G2H2[2][1][8][7] = 0; Curvature_Gauge_G2H2[2][1][8][8] = 0; - Curvature_Gauge_G2H2[2][2][0][0] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[2][2][0][1] = 0; Curvature_Gauge_G2H2[2][2][0][2] = 0; Curvature_Gauge_G2H2[2][2][0][3] = 0; @@ -2431,7 +2430,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][2][0][7] = 0; Curvature_Gauge_G2H2[2][2][0][8] = 0; Curvature_Gauge_G2H2[2][2][1][0] = 0; - Curvature_Gauge_G2H2[2][2][1][1] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[2][2][1][2] = 0; Curvature_Gauge_G2H2[2][2][1][3] = 0; Curvature_Gauge_G2H2[2][2][1][4] = 0; @@ -2441,7 +2440,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][2][1][8] = 0; Curvature_Gauge_G2H2[2][2][2][0] = 0; Curvature_Gauge_G2H2[2][2][2][1] = 0; - Curvature_Gauge_G2H2[2][2][2][2] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[2][2][2][3] = 0; Curvature_Gauge_G2H2[2][2][2][4] = 0; Curvature_Gauge_G2H2[2][2][2][5] = 0; @@ -2451,7 +2450,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][2][3][0] = 0; Curvature_Gauge_G2H2[2][2][3][1] = 0; Curvature_Gauge_G2H2[2][2][3][2] = 0; - Curvature_Gauge_G2H2[2][2][3][3] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[2][2][3][4] = 0; Curvature_Gauge_G2H2[2][2][3][5] = 0; Curvature_Gauge_G2H2[2][2][3][6] = 0; @@ -2461,7 +2460,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][2][4][1] = 0; Curvature_Gauge_G2H2[2][2][4][2] = 0; Curvature_Gauge_G2H2[2][2][4][3] = 0; - Curvature_Gauge_G2H2[2][2][4][4] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[2][2][4][5] = 0; Curvature_Gauge_G2H2[2][2][4][6] = 0; Curvature_Gauge_G2H2[2][2][4][7] = 0; @@ -2471,7 +2470,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][2][5][2] = 0; Curvature_Gauge_G2H2[2][2][5][3] = 0; Curvature_Gauge_G2H2[2][2][5][4] = 0; - Curvature_Gauge_G2H2[2][2][5][5] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[2][2][5][6] = 0; Curvature_Gauge_G2H2[2][2][5][7] = 0; Curvature_Gauge_G2H2[2][2][5][8] = 0; @@ -2481,7 +2480,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][2][6][3] = 0; Curvature_Gauge_G2H2[2][2][6][4] = 0; Curvature_Gauge_G2H2[2][2][6][5] = 0; - Curvature_Gauge_G2H2[2][2][6][6] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[2][2][6][7] = 0; Curvature_Gauge_G2H2[2][2][6][8] = 0; Curvature_Gauge_G2H2[2][2][7][0] = 0; @@ -2491,7 +2490,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][2][7][4] = 0; Curvature_Gauge_G2H2[2][2][7][5] = 0; Curvature_Gauge_G2H2[2][2][7][6] = 0; - Curvature_Gauge_G2H2[2][2][7][7] = C_g * C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[2][2][7][8] = 0; Curvature_Gauge_G2H2[2][2][8][0] = 0; Curvature_Gauge_G2H2[2][2][8][1] = 0; @@ -2502,7 +2501,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][2][8][6] = 0; Curvature_Gauge_G2H2[2][2][8][7] = 0; Curvature_Gauge_G2H2[2][2][8][8] = 0; - Curvature_Gauge_G2H2[2][3][0][0] = C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][0][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[2][3][0][1] = 0; Curvature_Gauge_G2H2[2][3][0][2] = 0; Curvature_Gauge_G2H2[2][3][0][3] = 0; @@ -2512,7 +2511,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][3][0][7] = 0; Curvature_Gauge_G2H2[2][3][0][8] = 0; Curvature_Gauge_G2H2[2][3][1][0] = 0; - Curvature_Gauge_G2H2[2][3][1][1] = C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][1][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[2][3][1][2] = 0; Curvature_Gauge_G2H2[2][3][1][3] = 0; Curvature_Gauge_G2H2[2][3][1][4] = 0; @@ -2522,7 +2521,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][3][1][8] = 0; Curvature_Gauge_G2H2[2][3][2][0] = 0; Curvature_Gauge_G2H2[2][3][2][1] = 0; - Curvature_Gauge_G2H2[2][3][2][2] = C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][2][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[2][3][2][3] = 0; Curvature_Gauge_G2H2[2][3][2][4] = 0; Curvature_Gauge_G2H2[2][3][2][5] = 0; @@ -2532,7 +2531,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][3][3][0] = 0; Curvature_Gauge_G2H2[2][3][3][1] = 0; Curvature_Gauge_G2H2[2][3][3][2] = 0; - Curvature_Gauge_G2H2[2][3][3][3] = C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][3][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[2][3][3][4] = 0; Curvature_Gauge_G2H2[2][3][3][5] = 0; Curvature_Gauge_G2H2[2][3][3][6] = 0; @@ -2542,7 +2541,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][3][4][1] = 0; Curvature_Gauge_G2H2[2][3][4][2] = 0; Curvature_Gauge_G2H2[2][3][4][3] = 0; - Curvature_Gauge_G2H2[2][3][4][4] = -C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][4][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[2][3][4][5] = 0; Curvature_Gauge_G2H2[2][3][4][6] = 0; Curvature_Gauge_G2H2[2][3][4][7] = 0; @@ -2552,7 +2552,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][3][5][2] = 0; Curvature_Gauge_G2H2[2][3][5][3] = 0; Curvature_Gauge_G2H2[2][3][5][4] = 0; - Curvature_Gauge_G2H2[2][3][5][5] = -C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][5][5] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[2][3][5][6] = 0; Curvature_Gauge_G2H2[2][3][5][7] = 0; Curvature_Gauge_G2H2[2][3][5][8] = 0; @@ -2562,7 +2563,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][3][6][3] = 0; Curvature_Gauge_G2H2[2][3][6][4] = 0; Curvature_Gauge_G2H2[2][3][6][5] = 0; - Curvature_Gauge_G2H2[2][3][6][6] = -C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][6][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[2][3][6][7] = 0; Curvature_Gauge_G2H2[2][3][6][8] = 0; Curvature_Gauge_G2H2[2][3][7][0] = 0; @@ -2572,7 +2574,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[2][3][7][4] = 0; Curvature_Gauge_G2H2[2][3][7][5] = 0; Curvature_Gauge_G2H2[2][3][7][6] = 0; - Curvature_Gauge_G2H2[2][3][7][7] = -C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][7][7] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[2][3][7][8] = 0; Curvature_Gauge_G2H2[2][3][8][0] = 0; Curvature_Gauge_G2H2[2][3][8][1] = 0; @@ -2589,7 +2592,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][0][0][3] = 0; Curvature_Gauge_G2H2[3][0][0][4] = 0; Curvature_Gauge_G2H2[3][0][0][5] = 0; - Curvature_Gauge_G2H2[3][0][0][6] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][0][6] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][0][0][7] = 0; Curvature_Gauge_G2H2[3][0][0][8] = 0; Curvature_Gauge_G2H2[3][0][1][0] = 0; @@ -2599,13 +2602,13 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][0][1][4] = 0; Curvature_Gauge_G2H2[3][0][1][5] = 0; Curvature_Gauge_G2H2[3][0][1][6] = 0; - Curvature_Gauge_G2H2[3][0][1][7] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][1][7] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][0][1][8] = 0; Curvature_Gauge_G2H2[3][0][2][0] = 0; Curvature_Gauge_G2H2[3][0][2][1] = 0; Curvature_Gauge_G2H2[3][0][2][2] = 0; Curvature_Gauge_G2H2[3][0][2][3] = 0; - Curvature_Gauge_G2H2[3][0][2][4] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][2][4] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][0][2][5] = 0; Curvature_Gauge_G2H2[3][0][2][6] = 0; Curvature_Gauge_G2H2[3][0][2][7] = 0; @@ -2615,13 +2618,13 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][0][3][2] = 0; Curvature_Gauge_G2H2[3][0][3][3] = 0; Curvature_Gauge_G2H2[3][0][3][4] = 0; - Curvature_Gauge_G2H2[3][0][3][5] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][3][5] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][0][3][6] = 0; Curvature_Gauge_G2H2[3][0][3][7] = 0; Curvature_Gauge_G2H2[3][0][3][8] = 0; Curvature_Gauge_G2H2[3][0][4][0] = 0; Curvature_Gauge_G2H2[3][0][4][1] = 0; - Curvature_Gauge_G2H2[3][0][4][2] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][4][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][0][4][3] = 0; Curvature_Gauge_G2H2[3][0][4][4] = 0; Curvature_Gauge_G2H2[3][0][4][5] = 0; @@ -2631,13 +2634,13 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][0][5][0] = 0; Curvature_Gauge_G2H2[3][0][5][1] = 0; Curvature_Gauge_G2H2[3][0][5][2] = 0; - Curvature_Gauge_G2H2[3][0][5][3] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][5][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][0][5][4] = 0; Curvature_Gauge_G2H2[3][0][5][5] = 0; Curvature_Gauge_G2H2[3][0][5][6] = 0; Curvature_Gauge_G2H2[3][0][5][7] = 0; Curvature_Gauge_G2H2[3][0][5][8] = 0; - Curvature_Gauge_G2H2[3][0][6][0] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][6][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][0][6][1] = 0; Curvature_Gauge_G2H2[3][0][6][2] = 0; Curvature_Gauge_G2H2[3][0][6][3] = 0; @@ -2647,7 +2650,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][0][6][7] = 0; Curvature_Gauge_G2H2[3][0][6][8] = 0; Curvature_Gauge_G2H2[3][0][7][0] = 0; - Curvature_Gauge_G2H2[3][0][7][1] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][7][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][0][7][2] = 0; Curvature_Gauge_G2H2[3][0][7][3] = 0; Curvature_Gauge_G2H2[3][0][7][4] = 0; @@ -2668,7 +2671,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][1][0][1] = 0; Curvature_Gauge_G2H2[3][1][0][2] = 0; Curvature_Gauge_G2H2[3][1][0][3] = 0; - Curvature_Gauge_G2H2[3][1][0][4] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][0][4] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][1][0][5] = 0; Curvature_Gauge_G2H2[3][1][0][6] = 0; Curvature_Gauge_G2H2[3][1][0][7] = 0; @@ -2678,7 +2681,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][1][1][2] = 0; Curvature_Gauge_G2H2[3][1][1][3] = 0; Curvature_Gauge_G2H2[3][1][1][4] = 0; - Curvature_Gauge_G2H2[3][1][1][5] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][1][5] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][1][1][6] = 0; Curvature_Gauge_G2H2[3][1][1][7] = 0; Curvature_Gauge_G2H2[3][1][1][8] = 0; @@ -2688,7 +2691,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][1][2][3] = 0; Curvature_Gauge_G2H2[3][1][2][4] = 0; Curvature_Gauge_G2H2[3][1][2][5] = 0; - Curvature_Gauge_G2H2[3][1][2][6] = -C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][2][6] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][1][2][7] = 0; Curvature_Gauge_G2H2[3][1][2][8] = 0; Curvature_Gauge_G2H2[3][1][3][0] = 0; @@ -2698,9 +2702,10 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][1][3][4] = 0; Curvature_Gauge_G2H2[3][1][3][5] = 0; Curvature_Gauge_G2H2[3][1][3][6] = 0; - Curvature_Gauge_G2H2[3][1][3][7] = -C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][3][7] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][1][3][8] = 0; - Curvature_Gauge_G2H2[3][1][4][0] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][4][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][1][4][1] = 0; Curvature_Gauge_G2H2[3][1][4][2] = 0; Curvature_Gauge_G2H2[3][1][4][3] = 0; @@ -2710,7 +2715,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][1][4][7] = 0; Curvature_Gauge_G2H2[3][1][4][8] = 0; Curvature_Gauge_G2H2[3][1][5][0] = 0; - Curvature_Gauge_G2H2[3][1][5][1] = C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][5][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][1][5][2] = 0; Curvature_Gauge_G2H2[3][1][5][3] = 0; Curvature_Gauge_G2H2[3][1][5][4] = 0; @@ -2720,7 +2725,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][1][5][8] = 0; Curvature_Gauge_G2H2[3][1][6][0] = 0; Curvature_Gauge_G2H2[3][1][6][1] = 0; - Curvature_Gauge_G2H2[3][1][6][2] = -C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][6][2] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][1][6][3] = 0; Curvature_Gauge_G2H2[3][1][6][4] = 0; Curvature_Gauge_G2H2[3][1][6][5] = 0; @@ -2730,7 +2736,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][1][7][0] = 0; Curvature_Gauge_G2H2[3][1][7][1] = 0; Curvature_Gauge_G2H2[3][1][7][2] = 0; - Curvature_Gauge_G2H2[3][1][7][3] = -C_gs * C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][7][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; Curvature_Gauge_G2H2[3][1][7][4] = 0; Curvature_Gauge_G2H2[3][1][7][5] = 0; Curvature_Gauge_G2H2[3][1][7][6] = 0; @@ -2745,7 +2752,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][1][8][6] = 0; Curvature_Gauge_G2H2[3][1][8][7] = 0; Curvature_Gauge_G2H2[3][1][8][8] = 0; - Curvature_Gauge_G2H2[3][2][0][0] = C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][0][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][2][0][1] = 0; Curvature_Gauge_G2H2[3][2][0][2] = 0; Curvature_Gauge_G2H2[3][2][0][3] = 0; @@ -2755,7 +2762,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][2][0][7] = 0; Curvature_Gauge_G2H2[3][2][0][8] = 0; Curvature_Gauge_G2H2[3][2][1][0] = 0; - Curvature_Gauge_G2H2[3][2][1][1] = C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][1][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][2][1][2] = 0; Curvature_Gauge_G2H2[3][2][1][3] = 0; Curvature_Gauge_G2H2[3][2][1][4] = 0; @@ -2765,7 +2772,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][2][1][8] = 0; Curvature_Gauge_G2H2[3][2][2][0] = 0; Curvature_Gauge_G2H2[3][2][2][1] = 0; - Curvature_Gauge_G2H2[3][2][2][2] = C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][2][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][2][2][3] = 0; Curvature_Gauge_G2H2[3][2][2][4] = 0; Curvature_Gauge_G2H2[3][2][2][5] = 0; @@ -2775,7 +2782,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][2][3][0] = 0; Curvature_Gauge_G2H2[3][2][3][1] = 0; Curvature_Gauge_G2H2[3][2][3][2] = 0; - Curvature_Gauge_G2H2[3][2][3][3] = C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][3][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][2][3][4] = 0; Curvature_Gauge_G2H2[3][2][3][5] = 0; Curvature_Gauge_G2H2[3][2][3][6] = 0; @@ -2785,7 +2792,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][2][4][1] = 0; Curvature_Gauge_G2H2[3][2][4][2] = 0; Curvature_Gauge_G2H2[3][2][4][3] = 0; - Curvature_Gauge_G2H2[3][2][4][4] = -C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][4][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][2][4][5] = 0; Curvature_Gauge_G2H2[3][2][4][6] = 0; Curvature_Gauge_G2H2[3][2][4][7] = 0; @@ -2795,7 +2803,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][2][5][2] = 0; Curvature_Gauge_G2H2[3][2][5][3] = 0; Curvature_Gauge_G2H2[3][2][5][4] = 0; - Curvature_Gauge_G2H2[3][2][5][5] = -C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][5][5] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][2][5][6] = 0; Curvature_Gauge_G2H2[3][2][5][7] = 0; Curvature_Gauge_G2H2[3][2][5][8] = 0; @@ -2805,7 +2814,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][2][6][3] = 0; Curvature_Gauge_G2H2[3][2][6][4] = 0; Curvature_Gauge_G2H2[3][2][6][5] = 0; - Curvature_Gauge_G2H2[3][2][6][6] = -C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][6][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][2][6][7] = 0; Curvature_Gauge_G2H2[3][2][6][8] = 0; Curvature_Gauge_G2H2[3][2][7][0] = 0; @@ -2815,7 +2825,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][2][7][4] = 0; Curvature_Gauge_G2H2[3][2][7][5] = 0; Curvature_Gauge_G2H2[3][2][7][6] = 0; - Curvature_Gauge_G2H2[3][2][7][7] = -C_g * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][7][7] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][2][7][8] = 0; Curvature_Gauge_G2H2[3][2][8][0] = 0; Curvature_Gauge_G2H2[3][2][8][1] = 0; @@ -2826,7 +2837,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][2][8][6] = 0; Curvature_Gauge_G2H2[3][2][8][7] = 0; Curvature_Gauge_G2H2[3][2][8][8] = 0; - Curvature_Gauge_G2H2[3][3][0][0] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][0][0] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][3][0][1] = 0; Curvature_Gauge_G2H2[3][3][0][2] = 0; Curvature_Gauge_G2H2[3][3][0][3] = 0; @@ -2836,7 +2848,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][3][0][7] = 0; Curvature_Gauge_G2H2[3][3][0][8] = 0; Curvature_Gauge_G2H2[3][3][1][0] = 0; - Curvature_Gauge_G2H2[3][3][1][1] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][1][1] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][3][1][2] = 0; Curvature_Gauge_G2H2[3][3][1][3] = 0; Curvature_Gauge_G2H2[3][3][1][4] = 0; @@ -2846,7 +2859,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][3][1][8] = 0; Curvature_Gauge_G2H2[3][3][2][0] = 0; Curvature_Gauge_G2H2[3][3][2][1] = 0; - Curvature_Gauge_G2H2[3][3][2][2] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][2][2] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][3][2][3] = 0; Curvature_Gauge_G2H2[3][3][2][4] = 0; Curvature_Gauge_G2H2[3][3][2][5] = 0; @@ -2856,7 +2870,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][3][3][0] = 0; Curvature_Gauge_G2H2[3][3][3][1] = 0; Curvature_Gauge_G2H2[3][3][3][2] = 0; - Curvature_Gauge_G2H2[3][3][3][3] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][3][3] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][3][3][4] = 0; Curvature_Gauge_G2H2[3][3][3][5] = 0; Curvature_Gauge_G2H2[3][3][3][6] = 0; @@ -2866,7 +2881,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][3][4][1] = 0; Curvature_Gauge_G2H2[3][3][4][2] = 0; Curvature_Gauge_G2H2[3][3][4][3] = 0; - Curvature_Gauge_G2H2[3][3][4][4] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][4][4] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][3][4][5] = 0; Curvature_Gauge_G2H2[3][3][4][6] = 0; Curvature_Gauge_G2H2[3][3][4][7] = 0; @@ -2876,7 +2892,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][3][5][2] = 0; Curvature_Gauge_G2H2[3][3][5][3] = 0; Curvature_Gauge_G2H2[3][3][5][4] = 0; - Curvature_Gauge_G2H2[3][3][5][5] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][5][5] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][3][5][6] = 0; Curvature_Gauge_G2H2[3][3][5][7] = 0; Curvature_Gauge_G2H2[3][3][5][8] = 0; @@ -2886,7 +2903,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][3][6][3] = 0; Curvature_Gauge_G2H2[3][3][6][4] = 0; Curvature_Gauge_G2H2[3][3][6][5] = 0; - Curvature_Gauge_G2H2[3][3][6][6] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][6][6] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][3][6][7] = 0; Curvature_Gauge_G2H2[3][3][6][8] = 0; Curvature_Gauge_G2H2[3][3][7][0] = 0; @@ -2896,7 +2914,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][3][7][4] = 0; Curvature_Gauge_G2H2[3][3][7][5] = 0; Curvature_Gauge_G2H2[3][3][7][6] = 0; - Curvature_Gauge_G2H2[3][3][7][7] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][7][7] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; Curvature_Gauge_G2H2[3][3][7][8] = 0; Curvature_Gauge_G2H2[3][3][8][0] = 0; Curvature_Gauge_G2H2[3][3][8][1] = 0; @@ -2909,15 +2928,15 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() Curvature_Gauge_G2H2[3][3][8][8] = 0; std::complex V11, V12, V13, V21, V22, V23, V31, V32, V33; - V11 = C_Vud; - V12 = C_Vus; - V13 = C_Vub; - V21 = C_Vcd; - V22 = C_Vcs; - V23 = C_Vcb; - V31 = C_Vtd; - V32 = C_Vts; - V33 = C_Vtb; + V11 = SMConstants.C_Vud; + V12 = SMConstants.C_Vus; + V13 = SMConstants.C_Vub; + V21 = SMConstants.C_Vcd; + V22 = SMConstants.C_Vcs; + V23 = SMConstants.C_Vcb; + V31 = SMConstants.C_Vtd; + V32 = SMConstants.C_Vts; + V33 = SMConstants.C_Vtb; MatrixXcd YIJR2(NQuarks, NQuarks), YIJE2(NQuarks, NQuarks), YIJS2(NQuarks, NQuarks), YIJP2(NQuarks, NQuarks), YIJRD(NQuarks, NQuarks), @@ -2937,9 +2956,8 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() YIJSL = MatrixXcd::Zero(NLepton, NLepton); YIJPL = MatrixXcd::Zero(NLepton, NLepton); - - double v1 = C_vev0 * C_CosBeta; - double v2 = C_vev0 * C_SinBeta; + double v1 = SMConstants.C_vev0 * C_CosBeta; + double v2 = SMConstants.C_vev0 * C_SinBeta; double vL = v2; double vD = v2; if (Type == 2) @@ -2952,45 +2970,45 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() else if (Type == 4) vD = v1; - YIJR2(0, 9) = -std::conj(V11) * C_MassUp / v2; - YIJR2(0, 10) = -std::conj(V12) * C_MassUp / v2; - YIJR2(0, 11) = -std::conj(V13) * C_MassUp / v2; + YIJR2(0, 9) = -std::conj(V11) * SMConstants.C_MassUp / v2; + YIJR2(0, 10) = -std::conj(V12) * SMConstants.C_MassUp / v2; + YIJR2(0, 11) = -std::conj(V13) * SMConstants.C_MassUp / v2; - YIJR2(1, 9) = -std::conj(V21) * C_MassCharm / v2; - YIJR2(1, 10) = -std::conj(V22) * C_MassCharm / v2; - YIJR2(1, 11) = -std::conj(V23) * C_MassCharm / v2; + YIJR2(1, 9) = -std::conj(V21) * SMConstants.C_MassCharm / v2; + YIJR2(1, 10) = -std::conj(V22) * SMConstants.C_MassCharm / v2; + YIJR2(1, 11) = -std::conj(V23) * SMConstants.C_MassCharm / v2; - YIJR2(2, 9) = -std::conj(V31) * C_MassTop / v2; - YIJR2(2, 10) = -std::conj(V32) * C_MassTop / v2; - YIJR2(2, 11) = -std::conj(V33) * C_MassTop / v2; + YIJR2(2, 9) = -std::conj(V31) * SMConstants.C_MassTop / v2; + YIJR2(2, 10) = -std::conj(V32) * SMConstants.C_MassTop / v2; + YIJR2(2, 11) = -std::conj(V33) * SMConstants.C_MassTop / v2; - YIJS2(0, 6) = C_MassUp / v2; - YIJS2(1, 7) = C_MassCharm / v2; - YIJS2(2, 8) = C_MassTop / v2; + YIJS2(0, 6) = SMConstants.C_MassUp / v2; + YIJS2(1, 7) = SMConstants.C_MassCharm / v2; + YIJS2(2, 8) = SMConstants.C_MassTop / v2; - YIJSD(3, 9) = C_MassDown / vD; - YIJSD(4, 10) = C_MassStrange / vD; - YIJSD(5, 11) = C_MassBottom / vD; + YIJSD(3, 9) = SMConstants.C_MassDown / vD; + YIJSD(4, 10) = SMConstants.C_MassStrange / vD; + YIJSD(5, 11) = SMConstants.C_MassBottom / vD; - YIJRD(3, 6) = V11 * C_MassDown / vD; - YIJRD(3, 7) = V21 * C_MassDown / vD; - YIJRD(3, 8) = V31 * C_MassDown / vD; + YIJRD(3, 6) = V11 * SMConstants.C_MassDown / vD; + YIJRD(3, 7) = V21 * SMConstants.C_MassDown / vD; + YIJRD(3, 8) = V31 * SMConstants.C_MassDown / vD; - YIJRD(4, 6) = V12 * C_MassStrange / vD; - YIJRD(4, 7) = V22 * C_MassStrange / vD; - YIJRD(4, 8) = V32 * C_MassStrange / vD; + YIJRD(4, 6) = V12 * SMConstants.C_MassStrange / vD; + YIJRD(4, 7) = V22 * SMConstants.C_MassStrange / vD; + YIJRD(4, 8) = V32 * SMConstants.C_MassStrange / vD; - YIJRD(5, 6) = V13 * C_MassBottom / vD; - YIJRD(5, 7) = V23 * C_MassBottom / vD; - YIJRD(5, 8) = V33 * C_MassBottom / vD; + YIJRD(5, 6) = V13 * SMConstants.C_MassBottom / vD; + YIJRD(5, 7) = V23 * SMConstants.C_MassBottom / vD; + YIJRD(5, 8) = V33 * SMConstants.C_MassBottom / vD; - YIJRL(1, 6) = C_MassElectron / vL; - YIJRL(3, 7) = C_MassMu / vL; - YIJRL(5, 8) = C_MassTau / vL; + YIJRL(1, 6) = SMConstants.C_MassElectron / vL; + YIJRL(3, 7) = SMConstants.C_MassMu / vL; + YIJRL(5, 8) = SMConstants.C_MassTau / vL; - YIJSL(0, 1) = C_MassElectron / vL; - YIJSL(2, 3) = C_MassMu / vL; - YIJSL(4, 5) = C_MassTau / vL; + YIJSL(0, 1) = SMConstants.C_MassElectron / vL; + YIJSL(2, 3) = SMConstants.C_MassMu / vL; + YIJSL(4, 5) = SMConstants.C_MassTau / vL; for (std::size_t i = 0; i < NQuarks; i++) { @@ -3084,23 +3102,30 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() SetCurvatureDone = true; } -bool Class_Potential_RN2HDM::CalculateDebyeSimplified() +bool Class_Potential_N2HDM::CalculateDebyeSimplified() { double cb = 0; if (Type == 1 or Type == 3) // Type I 2HDM oder Lepton Specific { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_SinBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_SinBeta); } if (Type == 2 or Type == 4) // Type II 2HDM oder Flipped { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_CosBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_CosBeta); } CTempC1 = 1.0 / 48 * - (12 * L1 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs)); - double ct = std::sqrt(2) * C_MassTop / (C_vev0 * C_SinBeta); - CTempC2 = 1.0 / 48 * - (12 * L2 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs) + + (12 * L1 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs)); + double ct = + std::sqrt(2) * SMConstants.C_MassTop / (SMConstants.C_vev0 * C_SinBeta); + CTempC2 = 1.0 / 48 * + (12 * L2 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs) + 12 * ct * ct); if (Type == 1 or Type == 3) @@ -3129,18 +3154,18 @@ bool Class_Potential_RN2HDM::CalculateDebyeSimplified() return true; } -bool Class_Potential_RN2HDM::CalculateDebyeGaugeSimplified() +bool Class_Potential_N2HDM::CalculateDebyeGaugeSimplified() { - DebyeGauge[0][0] = 2 * C_g * C_g; - DebyeGauge[1][1] = 2 * C_g * C_g; - DebyeGauge[2][2] = 2 * C_g * C_g; - DebyeGauge[3][3] = 2 * C_gs * C_gs; + DebyeGauge[0][0] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[1][1] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[2][2] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[3][3] = 2 * SMConstants.C_gs * SMConstants.C_gs; return true; } double -Class_Potential_RN2HDM::VTreeSimplified(const std::vector &v) const +Class_Potential_N2HDM::VTreeSimplified(const std::vector &v) const { (void)v; double res = 0; @@ -3149,7 +3174,7 @@ Class_Potential_RN2HDM::VTreeSimplified(const std::vector &v) const } double -Class_Potential_RN2HDM::VCounterSimplified(const std::vector &v) const +Class_Potential_N2HDM::VCounterSimplified(const std::vector &v) const { (void)v; if (not UseVCounterSimplified) return 0; @@ -3157,8 +3182,8 @@ Class_Potential_RN2HDM::VCounterSimplified(const std::vector &v) const return res; } -void Class_Potential_RN2HDM::Debugging(const std::vector &input, - std::vector &output) const +void Class_Potential_N2HDM::Debugging(const std::vector &input, + std::vector &output) const { (void)input; (void)output; diff --git a/src/models/ClassPotentialOrigin.cpp b/src/models/ClassPotentialOrigin.cpp index 3ff0d5fd..271e7d05 100644 --- a/src/models/ClassPotentialOrigin.cpp +++ b/src/models/ClassPotentialOrigin.cpp @@ -26,6 +26,14 @@ using namespace Eigen; namespace BSMPT { Class_Potential_Origin::Class_Potential_Origin() + : Class_Potential_Origin(GetSMConstants()) +{ +} + +Class_Potential_Origin::Class_Potential_Origin(const ISMConstants &smConstants) + : SMConstants{smConstants} + , scale{SMConstants.C_vev0} + { // TODO Auto-generated constructor stub } @@ -304,19 +312,16 @@ double Class_Potential_Origin::fbaseTri(double MassSquaredA, else if (mas != 0 and mbs == 0 and mcs == 0) { C = 2; - res = 1.0 / mas * (std::log(mas) - 1); res = 1.0 / mas * (LogA - 1); } else if (mas == 0 and mbs != 0 and mcs == 0) { C = 3; - res = 1.0 / mbs * (std::log(mbs) - 1); res = (LogB - 1) / mbs; } else if (mas == 0 and mbs == 0 and mcs != 0) { C = 4; - res = 1.0 / mcs * (std::log(mcs) - 1); res = (LogC - 1) / mcs; } else if (mas == mbs and mas != 0 and mas != mcs and mcs != 0) @@ -3038,22 +3043,22 @@ double Class_Potential_Origin::V1Loop(const std::vector &v, res += -2 * fermion(LeptonMassesVec[k], Temp, 0); } - double VDebay = 0; + double VDebye = 0; for (std::size_t k = 0; k < NHiggs; k++) { - if (HiggsMassesVec[k] > 0) VDebay += std::pow(HiggsMassesVec[k], 1.5); + if (HiggsMassesVec[k] > 0) VDebye += std::pow(HiggsMassesVec[k], 1.5); if (HiggsMassesZeroTempVec[k] > 0) - VDebay += -std::pow(HiggsMassesZeroTempVec[k], 1.5); + VDebye += -std::pow(HiggsMassesZeroTempVec[k], 1.5); } for (std::size_t k = 0; k < NGauge; k++) { - if (GaugeMassesVec[k] > 0) VDebay += std::pow(GaugeMassesVec[k], 1.5); + if (GaugeMassesVec[k] > 0) VDebye += std::pow(GaugeMassesVec[k], 1.5); if (GaugeMassesZeroTempVec[k] > 0) - VDebay += -std::pow(GaugeMassesZeroTempVec[k], 1.5); + VDebye += -std::pow(GaugeMassesZeroTempVec[k], 1.5); } - VDebay *= -Temp / (12 * M_PI); - res += VDebay; + VDebye *= -Temp / (12 * M_PI); + res += VDebye; } } else if (diff > 0 and static_cast(diff) <= NHiggs) @@ -3113,17 +3118,17 @@ double Class_Potential_Origin::V1Loop(const std::vector &v, fermion(LeptonMassesVec[k], Temp, diff); } - double VDebay = 0; + double VDebye = 0; for (std::size_t k = 0; k < NHiggs; k++) { if (HiggsMassesVec[k] > 0) { - VDebay += 1.5 * HiggsMassesVec.at(k + NHiggs) * + VDebye += 1.5 * HiggsMassesVec.at(k + NHiggs) * std::pow(HiggsMassesVec.at(k), 0.5); } if (HiggsMassesZeroTempVec[k] > 0) { - VDebay += -1.5 * HiggsMassesZeroTempVec.at(k + NHiggs) * + VDebye += -1.5 * HiggsMassesZeroTempVec.at(k + NHiggs) * std::pow(HiggsMassesZeroTempVec[k], 0.5); } } @@ -3131,18 +3136,18 @@ double Class_Potential_Origin::V1Loop(const std::vector &v, { if (GaugeMassesVec[k] > 0) { - VDebay += 1.5 * GaugeMassesVec.at(k + NGauge) * + VDebye += 1.5 * GaugeMassesVec.at(k + NGauge) * std::pow(GaugeMassesVec[k], 0.5); } if (GaugeMassesZeroTempVec[k] > 0) { - VDebay += -1.5 * GaugeMassesZeroTempVec.at(k + NGauge) * + VDebye += -1.5 * GaugeMassesZeroTempVec.at(k + NGauge) * std::pow(GaugeMassesZeroTempVec[k], 0.5); } } - VDebay *= -Temp / (12 * M_PI); - res += VDebay; + VDebye *= -Temp / (12 * M_PI); + res += VDebye; } } else if (diff == -1) @@ -3193,34 +3198,34 @@ double Class_Potential_Origin::V1Loop(const std::vector &v, for (std::size_t k = 0; k < NLepton; k++) res += -2 * fermion(LeptonMassesVec[k], Temp, -1); - double VDebay = 0; + double VDebye = 0; for (std::size_t k = 0; k < NHiggs; k++) { - if (HiggsMassesVec[k] > 0) VDebay += std::pow(HiggsMassesVec[k], 1.5); + if (HiggsMassesVec[k] > 0) VDebye += std::pow(HiggsMassesVec[k], 1.5); if (HiggsMassesZeroTempVec[k] > 0) - VDebay += -std::pow(HiggsMassesZeroTempVec[k], 1.5); + VDebye += -std::pow(HiggsMassesZeroTempVec[k], 1.5); } for (std::size_t k = 0; k < NGauge; k++) { - if (GaugeMassesVec[k] > 0) VDebay += std::pow(GaugeMassesVec[k], 1.5); + if (GaugeMassesVec[k] > 0) VDebye += std::pow(GaugeMassesVec[k], 1.5); if (GaugeMassesZeroTempVec[k] > 0) - VDebay += -std::pow(GaugeMassesZeroTempVec[k], 1.5); + VDebye += -std::pow(GaugeMassesZeroTempVec[k], 1.5); } - VDebay *= -1.0 / (12 * M_PI); - res += VDebay; + VDebye *= -1.0 / (12 * M_PI); + res += VDebye; } } return res; } -void Class_Potential_Origin::CalculateDebye() +void Class_Potential_Origin::CalculateDebye(bool forceCalculation) { if (!SetCurvatureDone) SetCurvatureArrays(); - bool Done = CalculateDebyeSimplified(); - if (!Done) + bool Calculate = forceCalculation or not CalculateDebyeSimplified(); + if (Calculate) { for (std::size_t i = 0; i < NHiggs; i++) { @@ -3282,12 +3287,6 @@ void Class_Potential_Origin::CalculateDebye() } } } - - std::size_t nHiggsGauge = 0; - for (std::size_t i = 0; i < NHiggs; i++) - { - if (Curvature_Gauge_G2H2[0][0][i][i] != 0) nHiggsGauge++; - } } void Class_Potential_Origin::CalculateDebyeGauge() @@ -3390,6 +3389,42 @@ void Class_Potential_Origin::initVectors() HiggsVev = std::vector(NHiggs, 0); } +void Class_Potential_Origin::sym2Dim( + std::vector> &Tensor2Dim, + std::size_t Nk1, + std::size_t Nk2) +{ + for (std::size_t k1 = 0; k1 < Nk1; k1++) + { + for (std::size_t k2 = k1; k2 < Nk2; k2++) + { + Tensor2Dim[k2][k1] = Tensor2Dim[k1][k2]; + } + } +} + +void Class_Potential_Origin::sym3Dim( + std::vector>> &Tensor3Dim, + std::size_t Nk1, + std::size_t Nk2, + std::size_t Nk3) +{ + for (std::size_t k1 = 0; k1 < Nk1; k1++) + { + for (std::size_t k2 = k1; k2 < Nk2; k2++) + { + for (std::size_t k3 = k2; k3 < Nk3; k3++) + { + Tensor3Dim[k1][k3][k2] = Tensor3Dim[k1][k2][k3]; + Tensor3Dim[k2][k1][k3] = Tensor3Dim[k1][k2][k3]; + Tensor3Dim[k2][k3][k1] = Tensor3Dim[k1][k2][k3]; + Tensor3Dim[k3][k1][k2] = Tensor3Dim[k1][k2][k3]; + Tensor3Dim[k3][k2][k1] = Tensor3Dim[k1][k2][k3]; + } + } + } +} + void Class_Potential_Origin::sym4Dim( std::vector>>> &Tensor4Dim, std::size_t Nk1, @@ -3478,11 +3513,34 @@ double Class_Potential_Origin::EWSBVEV(const std::vector &v) const return res; } +void Class_Potential_Origin::SetEWVEVZero(std::vector &sol) const +{ + int count = 0; + for (std::size_t i = 0; i < NHiggs; i++) + { + double checkgauge = 0; + for (std::size_t j = 0; j < NGauge; j++) + { + checkgauge += std::abs(Curvature_Gauge_G2H2[j][j][i][i]); + } + if (checkgauge > 1e-10 and i == VevOrder[count]) // true for doublet vevs + { + sol.at(count) = 0; + count += 1; + } + } +} + void Class_Potential_Origin::setUseIndexCol(std::string legend) { UseIndexCol = legend.rfind(sep, 0) == 0; } +bool Class_Potential_Origin::getUseIndexCol() +{ + return UseIndexCol; +} + void Class_Potential_Origin::CheckImplementation( const int &WhichMinimizer) const { @@ -3513,8 +3571,8 @@ void Class_Potential_Origin::CheckImplementation( ModelTests::CheckNumberOfTripleCouplings(*this))); TestNames.push_back("CKM matrix unitarity"); - TestResults.push_back( - ModelTests::TestResultsToString(ModelTests::CheckCKMUnitarity())); + TestResults.push_back(ModelTests::TestResultsToString( + ModelTests::CheckCKMUnitarity(SMConstants))); Logger::Write(LoggingLevel::Default, "This function calculates the masses of the gauge bosons, " @@ -3890,18 +3948,19 @@ double Class_Potential_Origin::CalculateRatioAlpha( const std::vector &vev_broken, const double &Temp) const { - double res = 0; - double PotentialSymmetricPhaseValue = VEff(vev_symmetric, Temp, 0); - double PotentialSymmetricPhaseDeriv = VEff(vev_symmetric, Temp, -1); - double PotentialBrokenPhaseValue = VEff(vev_broken, Temp, 0); - double PotentialBrokenPhaseDeriv = VEff(vev_broken, Temp, -1); - res = -(PotentialBrokenPhaseValue - PotentialSymmetricPhaseValue) + - Temp * (PotentialBrokenPhaseDeriv - PotentialSymmetricPhaseDeriv); + (void)vev_symmetric; + (void)vev_broken; + (void)Temp; + // double res = 0; + // double PotentialSymmetricPhaseValue = VEff(vev_symmetric, Temp, 0); + // double PotentialSymmetricPhaseDeriv = VEff(vev_symmetric, Temp, -1); + // double PotentialBrokenPhaseValue = VEff(vev_broken, Temp, 0); + // double PotentialBrokenPhaseDeriv = VEff(vev_broken, Temp, -1); + // res = -(PotentialBrokenPhaseValue - PotentialSymmetricPhaseValue) + + // Temp * (PotentialBrokenPhaseDeriv - PotentialSymmetricPhaseDeriv); // TODO:: Unfinished! throw std::runtime_error("The CalculateRatioAlpha function is not finished " "and you should not be using it!"); - - return res; } std::vector Class_Potential_Origin::MinimizeOrderVEV( diff --git a/src/models/ClassPotentialR2HDM.cpp b/src/models/ClassPotentialR2HDM.cpp index 427a34cc..12c40c4c 100644 --- a/src/models/ClassPotentialR2HDM.cpp +++ b/src/models/ClassPotentialR2HDM.cpp @@ -14,7 +14,8 @@ namespace BSMPT namespace Models { -Class_Potential_R2HDM::Class_Potential_R2HDM() +Class_Potential_R2HDM::Class_Potential_R2HDM(const ISMConstants &smConstants) + : Class_Potential_Origin(smConstants) { // TODO Auto-generated constructor stub Model = ModelID::ModelIDs::R2HDM; @@ -181,16 +182,19 @@ void Class_Potential_R2HDM::ReadAndSet(const std::string &linestr, C_CosBeta = sqrt(C_CosBetaSquared); C_SinBetaSquared = TanBeta * TanBeta * C_CosBetaSquared; C_SinBeta = sqrt(C_SinBetaSquared); - // L1 =1.0 / (C_vev0 * C_vev0 * C_CosBeta * C_CosBeta)* (ca * ca * MH * MH + - // sa * sa * Mh * Mh- RealMMix * C_SinBeta / C_CosBeta); L2 =1.0 / (C_vev0 * - // C_vev0 * C_SinBeta * C_SinBeta)* (sa * sa * MH * MH + ca * ca * Mh * Mh- - // RealMMix * C_CosBeta / C_SinBeta); L3 = 2 * MHP * MHP / (C_vev0 * - // C_vev0)+ sa * ca * (MH * MH - Mh * Mh)/ (C_vev0 * C_vev0 - // *C_CosBeta*C_SinBeta )- RealMMix / (C_vev0 * C_vev0 * C_SinBeta * - // C_CosBeta); L4 = (MA * MA - 2 * MHP * MHP) / (C_vev0 * C_vev0)+ RealMMix / - // (C_vev0 * C_vev0 * C_SinBeta * C_CosBeta); RL5 = RealMMix / (C_vev0 * - // C_vev0 * C_SinBeta * C_CosBeta) - MA - //* MA / (C_vev0 * C_vev0); + // L1 =1.0 / (SMConstants.C_vev0 * SMConstants.C_vev0 * C_CosBeta * + // C_CosBeta)* (ca * ca * MH * MH + + // sa * sa * Mh * Mh- RealMMix * C_SinBeta / C_CosBeta); L2 =1.0 / + // (SMConstants.C_vev0 * SMConstants.C_vev0 * C_SinBeta * C_SinBeta)* (sa * sa + // * MH * MH + ca * ca * Mh * Mh- RealMMix * C_CosBeta / C_SinBeta); L3 = 2 + // * MHP * MHP / (SMConstants.C_vev0 * SMConstants.C_vev0)+ sa * ca * (MH * MH + // - Mh * Mh)/ (SMConstants.C_vev0 * SMConstants.C_vev0 *C_CosBeta*C_SinBeta + // )- RealMMix / (SMConstants.C_vev0 * SMConstants.C_vev0 * C_SinBeta * + // C_CosBeta); L4 = (MA * MA - 2 * MHP * MHP) / (SMConstants.C_vev0 * + // SMConstants.C_vev0)+ RealMMix / (SMConstants.C_vev0 * SMConstants.C_vev0 * + // C_SinBeta * C_CosBeta); RL5 = RealMMix / (SMConstants.C_vev0 * + // SMConstants.C_vev0 * C_SinBeta * C_CosBeta) - MA + //* MA / (SMConstants.C_vev0 * SMConstants.C_vev0); par[6] = TanBeta; par[4] = RL5; @@ -212,7 +216,7 @@ void Class_Potential_R2HDM::set_gen(const std::vector &par) { // double *p = (double *)par; - scale = C_vev0; + scale = SMConstants.C_vev0; // scale=C_MassZ; L1 = par[0]; L2 = par[1]; @@ -228,33 +232,50 @@ void Class_Potential_R2HDM::set_gen(const std::vector &par) C_SinBetaSquared = TanBeta * TanBeta * C_CosBetaSquared; C_SinBeta = sqrt(C_SinBetaSquared); + if (TanBeta < 0) // for beta in 4th quadrant + { + C_SinBeta *= -1; + } + u1 = RealMMix * TanBeta - - C_vev0 * C_vev0 * C_SinBetaSquared * (L4 + RL5 + L3) / 0.2e1 - - C_vev0 * C_vev0 * C_CosBetaSquared * L1 / 0.2e1; + SMConstants.C_vev0 * SMConstants.C_vev0 * C_SinBetaSquared * + (L4 + RL5 + L3) / 0.2e1 - + SMConstants.C_vev0 * SMConstants.C_vev0 * C_CosBetaSquared * L1 / 0.2e1; u2 = RealMMix * 1.0 / TanBeta - - C_vev0 * C_vev0 * C_CosBetaSquared * (L4 + RL5 + L3) / 0.2e1 - - C_vev0 * C_vev0 * C_SinBetaSquared * L2 / 0.2e1; + SMConstants.C_vev0 * SMConstants.C_vev0 * C_CosBetaSquared * + (L4 + RL5 + L3) / 0.2e1 - + SMConstants.C_vev0 * SMConstants.C_vev0 * C_SinBetaSquared * L2 / 0.2e1; - // double ML5 = 2*RealMMix/(C_vev0*C_vev0*C_SinBeta*C_CosBeta); + // double ML5 = + // 2*RealMMix/(SMConstants.C_vev0*SMConstants.C_vev0*C_SinBeta*C_CosBeta); // double TripleHiggs = - //-3.0/(C_vev0*std::sin(2*beta))*(Mh*Mh*(2*std::cos(alpha+beta)+std::sin(2*alpha)*std::sin(beta-alpha)) - //- std::cos(alpha+beta)*std::pow(std::cos(beta-alpha),2)*C_vev0*C_vev0*ML5 ); + //-3.0/(SMConstants.C_vev0*std::sin(2*beta))*(Mh*Mh*(2*std::cos(alpha+beta)+std::sin(2*alpha)*std::sin(beta-alpha)) + //- + // std::cos(alpha+beta)*std::pow(std::cos(beta-alpha),2)*SMConstants.C_vev0*SMConstants.C_vev0*ML5 + //); double cb = 0; if (Type == 1 or Type == 3) // Type I 2HDM oder Lepton Specific { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_SinBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_SinBeta); } if (Type == 2 or Type == 4) // Type II 2HDM oder Flipped { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_CosBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_CosBeta); } CTempC1 = 1.0 / 48 * - (12 * L1 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs)); - double ct = std::sqrt(2) * C_MassTop / (C_vev0 * C_SinBeta); - CTempC2 = 1.0 / 48 * - (12 * L2 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs) + + (12 * L1 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs)); + double ct = + std::sqrt(2) * SMConstants.C_MassTop / (SMConstants.C_vev0 * C_SinBeta); + CTempC2 = 1.0 / 48 * + (12 * L2 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs) + 12 * ct * ct); if (Type == 1 or Type == 3) @@ -268,8 +289,8 @@ void Class_Potential_R2HDM::set_gen(const std::vector &par) vevTreeMin.resize(nVEV); vevTreeMin[0] = 0; - vevTreeMin[1] = C_vev0 * C_CosBeta; - vevTreeMin[2] = C_vev0 * C_SinBeta; + vevTreeMin[1] = SMConstants.C_vev0 * C_CosBeta; + vevTreeMin[2] = SMConstants.C_vev0 * C_SinBeta; vevTreeMin[3] = 0; vevTree.resize(NHiggs); vevTree = MinimizeOrderVEV(vevTreeMin); @@ -507,8 +528,8 @@ void Class_Potential_R2HDM::write() const ss << "The parameters are : \n"; ss << "Model = " << Model << "\n"; - ss << "v1 = " << C_vev0 * C_CosBeta << "\n"; - ss << "v2 = " << C_vev0 * C_SinBeta << "\n"; + ss << "v1 = " << SMConstants.C_vev0 * C_CosBeta << "\n"; + ss << "v2 = " << SMConstants.C_vev0 * C_SinBeta << "\n"; ss << "Type = " << Type << "\n"; ss << "beta = " << beta << std::endl; @@ -632,8 +653,8 @@ std::vector Class_Potential_R2HDM::calc_CT() const WeinbergNabla = WeinbergFirstDerivative(); WeinbergHesse = WeinbergSecondDerivative(); - double v1 = C_vev0 * C_CosBeta; - double v2 = C_vev0 * C_SinBeta; + double v1 = SMConstants.C_vev0 * C_CosBeta; + double v2 = SMConstants.C_vev0 * C_SinBeta; VectorXd NablaWeinberg(8); MatrixXd HesseWeinberg(8, 8), HiggsRot(8, 8); @@ -783,7 +804,6 @@ void Class_Potential_R2HDM::TripleHiggsCouplings() if (testsum > ZeroThreshold) posMHCS2 = i; testsum = std::abs(HiggsRot(i, 5)) + std::abs(HiggsRot(i, 7)); if (testsum > ZeroThreshold) posA = i; - testsum = 0; testsum = std::abs(HiggsRot(i, 4)) + std::abs(HiggsRot(i, 6)); if (testsum > ZeroThreshold) { @@ -874,8 +894,8 @@ void Class_Potential_R2HDM::SetCurvatureArrays() } } - HiggsVev[4] = C_vev0 * C_CosBeta; - HiggsVev[6] = C_vev0 * C_SinBeta; + HiggsVev[4] = SMConstants.C_vev0 * C_CosBeta; + HiggsVev[6] = SMConstants.C_vev0 * C_SinBeta; Curvature_Higgs_L2[0][0] = u1; Curvature_Higgs_L2[0][1] = 0; @@ -1076,102 +1096,126 @@ void Class_Potential_R2HDM::SetCurvatureArrays() } } - Curvature_Gauge_G2H2[0][0][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[0][0][7][7] = C_g * C_g / 0.2e1; - - Curvature_Gauge_G2H2[0][3][0][4] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][1][5] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][2][6] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][3][7] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][4][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][5][1] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][6][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[0][3][7][3] = C_g * C_gs / 0.2e1; - - Curvature_Gauge_G2H2[1][1][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[1][1][7][7] = C_g * C_g / 0.2e1; - - Curvature_Gauge_G2H2[1][3][0][5] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][1][4] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][2][7] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][3][6] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][4][1] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][5][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][6][3] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[1][3][7][2] = C_g * C_gs / 0.2e1; - - Curvature_Gauge_G2H2[2][2][0][0] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][1][1] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][2][2] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][3][3] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][4][4] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][5][5] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][6][6] = C_g * C_g / 0.2e1; - Curvature_Gauge_G2H2[2][2][7][7] = C_g * C_g / 0.2e1; - - Curvature_Gauge_G2H2[2][3][0][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][1][1] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][2][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][3][3] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][4][4] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][5][5] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][6][6] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[2][3][7][7] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][0][4] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][1][5] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][2][6] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][3][7] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][4][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][5][1] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][6][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][0][7][3] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][0][5] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][1][4] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][2][7] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][3][6] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][4][1] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][5][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][6][3] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][1][7][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][0][0] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][1][1] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][2][2] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][3][3] = C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][4][4] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][5][5] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][6][6] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][2][7][7] = -C_g * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][0][0] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][1][1] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][2][2] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][3][3] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][4][4] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][5][5] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][6][6] = C_gs * C_gs / 0.2e1; - Curvature_Gauge_G2H2[3][3][7][7] = C_gs * C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][0][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + + Curvature_Gauge_G2H2[0][3][0][4] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][1][5] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][2][6] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][3][7] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][4][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][5][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][6][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[0][3][7][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + + Curvature_Gauge_G2H2[1][1][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + + Curvature_Gauge_G2H2[1][3][0][5] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][1][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][2][7] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][3][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][4][1] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][5][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][6][3] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[1][3][7][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + + Curvature_Gauge_G2H2[2][2][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][4][4] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][5][5] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][6][6] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][7][7] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + + Curvature_Gauge_G2H2[2][3][0][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][1][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][2][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][3][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][4][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][5][5] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][6][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[2][3][7][7] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][0][4] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][1][5] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][2][6] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][3][7] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][4][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][5][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][6][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][0][7][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][0][5] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][1][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][2][7] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][3][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][4][1] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][5][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][6][3] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][1][7][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][0][0] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][1][1] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][2][2] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][3][3] = SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][4][4] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][5][5] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][6][6] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][2][7][7] = + -SMConstants.C_g * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][0][0] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][1][1] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][2][2] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][3][3] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][4][4] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][5][5] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][6][6] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][7][7] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; std::complex V11, V12, V13, V21, V22, V23, V31, V32, V33; - V11 = C_Vud; - V12 = C_Vus; - V13 = C_Vub; - V21 = C_Vcd; - V22 = C_Vcs; - V23 = C_Vcb; - V31 = C_Vtd; - V32 = C_Vts; - V33 = C_Vtb; + V11 = SMConstants.C_Vud; + V12 = SMConstants.C_Vus; + V13 = SMConstants.C_Vub; + V21 = SMConstants.C_Vcd; + V22 = SMConstants.C_Vcs; + V23 = SMConstants.C_Vcb; + V31 = SMConstants.C_Vtd; + V32 = SMConstants.C_Vts; + V33 = SMConstants.C_Vtb; MatrixXcd YIJR2(NQuarks, NQuarks), YIJE2(NQuarks, NQuarks), YIJS2(NQuarks, NQuarks), YIJP2(NQuarks, NQuarks), YIJRD(NQuarks, NQuarks), @@ -1191,8 +1235,8 @@ void Class_Potential_R2HDM::SetCurvatureArrays() YIJSL = MatrixXcd::Zero(NLepton, NLepton); YIJPL = MatrixXcd::Zero(NLepton, NLepton); - double v1 = C_vev0 * C_CosBeta; - double v2 = C_vev0 * C_SinBeta; + double v1 = SMConstants.C_vev0 * C_CosBeta; + double v2 = SMConstants.C_vev0 * C_SinBeta; double vL = v2; double vD = v2; if (Type == 2) @@ -1205,43 +1249,43 @@ void Class_Potential_R2HDM::SetCurvatureArrays() else if (Type == 4) vD = v1; - YIJR2(0, 9) = -std::conj(V11) * C_MassUp / v2; - YIJR2(0, 10) = -std::conj(V12) * C_MassUp / v2; - YIJR2(0, 11) = -std::conj(V13) * C_MassUp / v2; + YIJR2(0, 9) = -std::conj(V11) * SMConstants.C_MassUp / v2; + YIJR2(0, 10) = -std::conj(V12) * SMConstants.C_MassUp / v2; + YIJR2(0, 11) = -std::conj(V13) * SMConstants.C_MassUp / v2; - YIJR2(1, 9) = -std::conj(V21) * C_MassCharm / v2; - YIJR2(1, 10) = -std::conj(V22) * C_MassCharm / v2; - YIJR2(1, 11) = -std::conj(V23) * C_MassCharm / v2; + YIJR2(1, 9) = -std::conj(V21) * SMConstants.C_MassCharm / v2; + YIJR2(1, 10) = -std::conj(V22) * SMConstants.C_MassCharm / v2; + YIJR2(1, 11) = -std::conj(V23) * SMConstants.C_MassCharm / v2; - YIJR2(2, 9) = -std::conj(V31) * C_MassTop / v2; - YIJR2(2, 10) = -std::conj(V32) * C_MassTop / v2; - YIJR2(2, 11) = -std::conj(V33) * C_MassTop / v2; + YIJR2(2, 9) = -std::conj(V31) * SMConstants.C_MassTop / v2; + YIJR2(2, 10) = -std::conj(V32) * SMConstants.C_MassTop / v2; + YIJR2(2, 11) = -std::conj(V33) * SMConstants.C_MassTop / v2; - YIJS2(0, 6) = C_MassUp / v2; - YIJS2(1, 7) = C_MassCharm / v2; - YIJS2(2, 8) = C_MassTop / v2; + YIJS2(0, 6) = SMConstants.C_MassUp / v2; + YIJS2(1, 7) = SMConstants.C_MassCharm / v2; + YIJS2(2, 8) = SMConstants.C_MassTop / v2; - YIJSD(3, 9) = C_MassDown / vD; - YIJSD(4, 10) = C_MassStrange / vD; - YIJSD(5, 11) = C_MassBottom / vD; + YIJSD(3, 9) = SMConstants.C_MassDown / vD; + YIJSD(4, 10) = SMConstants.C_MassStrange / vD; + YIJSD(5, 11) = SMConstants.C_MassBottom / vD; - YIJRD(3, 6) = V11 * C_MassDown / vD; - YIJRD(3, 7) = V21 * C_MassDown / vD; - YIJRD(3, 8) = V31 * C_MassDown / vD; - YIJRD(4, 6) = V12 * C_MassStrange / vD; - YIJRD(4, 7) = V22 * C_MassStrange / vD; - YIJRD(4, 8) = V32 * C_MassStrange / vD; - YIJRD(5, 6) = V13 * C_MassBottom / vD; - YIJRD(5, 7) = V23 * C_MassBottom / vD; - YIJRD(5, 8) = V33 * C_MassBottom / vD; + YIJRD(3, 6) = V11 * SMConstants.C_MassDown / vD; + YIJRD(3, 7) = V21 * SMConstants.C_MassDown / vD; + YIJRD(3, 8) = V31 * SMConstants.C_MassDown / vD; + YIJRD(4, 6) = V12 * SMConstants.C_MassStrange / vD; + YIJRD(4, 7) = V22 * SMConstants.C_MassStrange / vD; + YIJRD(4, 8) = V32 * SMConstants.C_MassStrange / vD; + YIJRD(5, 6) = V13 * SMConstants.C_MassBottom / vD; + YIJRD(5, 7) = V23 * SMConstants.C_MassBottom / vD; + YIJRD(5, 8) = V33 * SMConstants.C_MassBottom / vD; - YIJRL(1, 6) = C_MassElectron / vL; - YIJRL(3, 7) = C_MassMu / vL; - YIJRL(5, 8) = C_MassTau / vL; + YIJRL(1, 6) = SMConstants.C_MassElectron / vL; + YIJRL(3, 7) = SMConstants.C_MassMu / vL; + YIJRL(5, 8) = SMConstants.C_MassTau / vL; - YIJSL(0, 1) = C_MassElectron / vL; - YIJSL(2, 3) = C_MassMu / vL; - YIJSL(4, 5) = C_MassTau / vL; + YIJSL(0, 1) = SMConstants.C_MassElectron / vL; + YIJSL(2, 3) = SMConstants.C_MassMu / vL; + YIJSL(4, 5) = SMConstants.C_MassTau / vL; for (std::size_t i = 0; i < NQuarks; i++) { @@ -1339,17 +1383,24 @@ bool Class_Potential_R2HDM::CalculateDebyeSimplified() if (Type == 1 or Type == 3) // Type I 2HDM oder Lepton Specific { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_SinBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_SinBeta); } if (Type == 2 or Type == 4) // Type II 2HDM oder Flipped { - cb = std::sqrt(2) * C_MassBottom / (C_vev0 * C_CosBeta); + cb = std::sqrt(2) * SMConstants.C_MassBottom / + (SMConstants.C_vev0 * C_CosBeta); } CTempC1 = 1.0 / 48 * - (12 * L1 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs)); - double ct = std::sqrt(2) * C_MassTop / (C_vev0 * C_SinBeta); - CTempC2 = 1.0 / 48 * - (12 * L2 + 8 * L3 + 4 * L4 + 3 * (3 * C_g * C_g + C_gs * C_gs) + + (12 * L1 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs)); + double ct = + std::sqrt(2) * SMConstants.C_MassTop / (SMConstants.C_vev0 * C_SinBeta); + CTempC2 = 1.0 / 48 * + (12 * L2 + 8 * L3 + 4 * L4 + + 3 * (3 * SMConstants.C_g * SMConstants.C_g + + SMConstants.C_gs * SMConstants.C_gs) + 12 * ct * ct); if (Type == 1 or Type == 3) @@ -1375,10 +1426,10 @@ bool Class_Potential_R2HDM::CalculateDebyeSimplified() bool Class_Potential_R2HDM::CalculateDebyeGaugeSimplified() { - DebyeGauge[0][0] = 2 * C_g * C_g; - DebyeGauge[1][1] = 2 * C_g * C_g; - DebyeGauge[2][2] = 2 * C_g * C_g; - DebyeGauge[3][3] = 2 * C_gs * C_gs; + DebyeGauge[0][0] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[1][1] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[2][2] = 2 * SMConstants.C_g * SMConstants.C_g; + DebyeGauge[3][3] = 2 * SMConstants.C_gs * SMConstants.C_gs; return true; } diff --git a/src/models/ClassPotentialSM.cpp b/src/models/ClassPotentialSM.cpp new file mode 100644 index 00000000..37e95c74 --- /dev/null +++ b/src/models/ClassPotentialSM.cpp @@ -0,0 +1,657 @@ +// Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include +#include +using namespace Eigen; + +/** + * @file + * Implementation of the SM + */ + +namespace BSMPT +{ +namespace Models +{ + +Class_SM::Class_SM(const ISMConstants &smConstants) + : Class_Potential_Origin(smConstants) +{ + Model = ModelID::ModelIDs::SM; + NNeutralHiggs = 2; // number of neutral Higgs bosons at T = 0 + NChargedHiggs = 2; // number of charged Higgs bosons at T = 0 (all d.o.f.) + + nPar = 2; // number of parameters in the tree-Level Lagrangian + nParCT = 6; // number of parameters in the counterterm potential + + nVEV = 1; // number of VEVs to minimize the potential + + NHiggs = NNeutralHiggs + NChargedHiggs; + + VevOrder.resize(nVEV); + VevOrder[0] = 2; + + // Set UseVTreeSimplified to use the tree-level potential defined in + // VTreeSimplified + UseVTreeSimplified = false; + + // Set UseVCounterSimplified to use the counterterm potential defined in + // VCounterSimplified + UseVCounterSimplified = false; +} + +Class_SM::~Class_SM() +{ +} + +std::vector Class_SM::addLegendCT() const +{ + std::vector labels; + labels.push_back("dmuSq"); + labels.push_back("dlambda"); + labels.push_back("dT1"); + labels.push_back("dT2"); + labels.push_back("dT3"); + labels.push_back("dT4"); + return labels; +} + +std::vector Class_SM::addLegendTemp() const +{ + std::vector labels; + labels.push_back("T_c"); + labels.push_back("v_c"); + labels.push_back("omega_c/T_c"); + labels.push_back("omega_c"); + return labels; +} + +std::vector Class_SM::addLegendTripleCouplings() const +{ + std::vector labels; + std::vector particles; + particles.resize(NHiggs); + + particles[0] = "G+"; + particles[1] = "G-"; + particles[2] = "G0"; + particles[3] = "H"; + + for (std::size_t i = 0; i < NHiggs; i++) + { + for (std::size_t j = i; j < NHiggs; j++) + { + for (std::size_t k = j; k < NHiggs; k++) + { + labels.push_back("Tree_" + particles.at(i) + particles.at(j) + + particles.at(k)); + labels.push_back("CT_" + particles.at(i) + particles.at(j) + + particles.at(k)); + labels.push_back("CW_" + particles.at(i) + particles.at(j) + + particles.at(k)); + } + } + } + + return labels; +} + +std::vector Class_SM::addLegendVEV() const +{ + std::vector labels; + labels.push_back("omega"); + return labels; +} + +void Class_SM::ReadAndSet(const std::string &linestr, std::vector &par) +{ + std::stringstream ss(linestr); + double tmp; + + if (UseIndexCol) + { + ss >> tmp; + } + + for (int k = 1; k <= 2; k++) + { + ss >> tmp; + + if (k == 1) + par[0] = tmp; // muSq + else if (k == 2) + par[1] = tmp; // lambda + } + + set_gen(par); + return; +} + +void Class_SM::set_gen(const std::vector &par) +{ + v0 = SMConstants.C_vev0; + + // uncomment if you want to load muSq from data + // muSq = par[0]; + + // muSq calculated from SM Higgs Mass directly + (void)par; + muSq = -std::pow(SMConstants.C_MassSMHiggs, 0.2e1) / 2; + + lambda = -muSq * std::pow(v0, -0.2e1); + + scale = v0; + + vevTreeMin.resize(nVEV); + vevTree.resize(NHiggs); + + vevTreeMin[0] = v0; + + vevTree = MinimizeOrderVEV(vevTreeMin); + if (!SetCurvatureDone) SetCurvatureArrays(); +} + +void Class_SM::set_CT_Pot_Par(const std::vector &par) +{ + dmuSq = par[0]; + dlambda = par[1]; + dT1 = par[2]; + dT2 = par[3]; + dT3 = par[4]; + dT4 = par[5]; + + Curvature_Higgs_CT_L1[0] = dT1; + Curvature_Higgs_CT_L1[1] = dT2; + Curvature_Higgs_CT_L1[2] = dT3; + Curvature_Higgs_CT_L1[3] = dT4; + + Curvature_Higgs_CT_L2[0][0] = dmuSq; + Curvature_Higgs_CT_L2[1][1] = dmuSq; + Curvature_Higgs_CT_L2[2][2] = dmuSq; + Curvature_Higgs_CT_L2[3][3] = dmuSq; + + Curvature_Higgs_CT_L4[0][0][0][0] = 6 * dlambda; + Curvature_Higgs_CT_L4[0][0][1][1] = 2 * dlambda; + Curvature_Higgs_CT_L4[0][0][2][2] = 2 * dlambda; + Curvature_Higgs_CT_L4[0][0][3][3] = 2 * dlambda; + Curvature_Higgs_CT_L4[1][1][1][1] = 6 * dlambda; + Curvature_Higgs_CT_L4[1][1][2][2] = 2 * dlambda; + Curvature_Higgs_CT_L4[1][1][3][3] = 2 * dlambda; + Curvature_Higgs_CT_L4[2][2][2][2] = 6 * dlambda; + Curvature_Higgs_CT_L4[2][2][3][3] = 2 * dlambda; + Curvature_Higgs_CT_L4[3][3][3][3] = 6 * dlambda; + + sym4Dim(Curvature_Higgs_CT_L4, NHiggs, NHiggs, NHiggs, NHiggs); +} + +void Class_SM::write() const +{ + std::stringstream ss; + typedef std::numeric_limits dbl; + ss.precision(dbl::max_digits10); + + ss << "The parameters are : " + << "\n" + << "\tmuSq = " << muSq << "\n" + << "\tlambda = " << lambda << "\n" + << "\tv0 = " << v0 << "\n"; + + ss << "The counterterm parameters are : " + << "\n"; + ss << "\tdmuSq = " << dmuSq << "\n" + << "\tdlambda = " << dlambda << "\n" + << "\tdT1 = " << dT1 << "\n" + << "\tdT2 = " << dT2 << "\n" + << "\tdT3 = " << dT3 << "\n" + << "\tdT4 = " << dT4 << "\n"; + + ss << "The scale is given by mu = " << scale << " GeV " + << "\n"; + + std::vector HiggsMasses; + HiggsMasses = HiggsMassesSquared(vevTree, 0); + + ss << "The mass spectrum is given by :\n"; + ss << "m_{G^+}^2 = " << HiggsMasses[0] << " GeV^2 \n" + << "m_{G^-}^2 = " << HiggsMasses[1] << " GeV^2 \n" + << "m_{G^0}^2 = " << HiggsMasses[2] << " GeV^2 \n" + << "m_{H_SM} = " << std::sqrt(HiggsMasses[3]) << " GeV \n"; + + Logger::Write(LoggingLevel::Default, ss.str()); +} + +std::vector Class_SM::calc_CT() const +{ + std::vector parCT; + + if (!SetCurvatureDone) + { + std::string retmes = __func__; + retmes += " was called before SetCurvatureArrays()!\n"; + throw std::runtime_error(retmes); + } + if (!CalcCouplingsdone) + { + std::string retmes = __func__; + retmes += " was called before CalculatePhysicalCouplings()!\n"; + throw std::runtime_error(retmes); + } + + std::vector WeinbergNabla, WeinbergHesse; + WeinbergNabla = WeinbergFirstDerivative(); + WeinbergHesse = WeinbergSecondDerivative(); + + VectorXd NablaWeinberg(NHiggs); + MatrixXd HesseWeinberg(NHiggs, NHiggs), HiggsRot(NHiggs, NHiggs); + for (std::size_t i = 0; i < NHiggs; i++) + { + NablaWeinberg[i] = WeinbergNabla[i]; + for (std::size_t j = 0; j < NHiggs; j++) + HesseWeinberg(i, j) = WeinbergHesse.at(j * NHiggs + i); + } + + parCT.push_back(HesseWeinberg(2, 2) / 2 - + 0.3e1 / 0.2e1 * HesseWeinberg(3, 3)); // dmuSq + parCT.push_back((-HesseWeinberg(2, 2) + HesseWeinberg(3, 3)) * pow(v0, -2) / + 2); // dlambda + parCT.push_back(-NablaWeinberg(0)); // dT1 + parCT.push_back(-NablaWeinberg(1)); // dT2 + parCT.push_back(HesseWeinberg(3, 3) * v0 - NablaWeinberg(2)); // dT3 + parCT.push_back(-NablaWeinberg(3)); // dT4 + + return parCT; +} + +void Class_SM::TripleHiggsCouplings() +{ + if (!SetCurvatureDone) SetCurvatureArrays(); + if (!CalcCouplingsdone) CalculatePhysicalCouplings(); + + std::vector HiggsOrder(NHiggs); + + for (std::size_t i = 0; i < NHiggs; i++) + { + HiggsOrder[i] = i; + } + + std::vector TripleDeriv; + TripleDeriv = WeinbergThirdDerivative(); + std::vector>> GaugeBasis( + NHiggs, + std::vector>(NHiggs, std::vector(NHiggs))); + for (std::size_t i = 0; i < NHiggs; i++) + { + for (std::size_t j = 0; j < NHiggs; j++) + { + for (std::size_t k = 0; k < NHiggs; k++) + { + GaugeBasis[i][j][k] = + TripleDeriv.at(i + j * NHiggs + k * NHiggs * NHiggs); + } + } + } + + MatrixXd HiggsRot(NHiggs, NHiggs); + for (std::size_t i = 0; i < NHiggs; i++) + { + for (std::size_t j = 0; j < NHiggs; j++) + { + HiggsRot(i, j) = HiggsRotationMatrix[i][j]; + } + } + + MatrixXd HiggsRotSort(NHiggs, NHiggs); + + for (std::size_t i = 0; i < NHiggs; i++) + { + HiggsRotSort.row(i) = HiggsRot.row(HiggsOrder[i]); + } + + TripleHiggsCorrectionsCWPhysical.resize(NHiggs); + TripleHiggsCorrectionsTreePhysical.resize(NHiggs); + TripleHiggsCorrectionsCTPhysical.resize(NHiggs); + for (std::size_t i = 0; i < NHiggs; i++) + { + TripleHiggsCorrectionsTreePhysical[i].resize(NHiggs); + TripleHiggsCorrectionsCWPhysical[i].resize(NHiggs); + TripleHiggsCorrectionsCTPhysical[i].resize(NHiggs); + for (std::size_t j = 0; j < NHiggs; j++) + { + TripleHiggsCorrectionsCWPhysical[i][j].resize(NHiggs); + TripleHiggsCorrectionsTreePhysical[i][j].resize(NHiggs); + TripleHiggsCorrectionsCTPhysical[i][j].resize(NHiggs); + } + } + + for (std::size_t i = 0; i < NHiggs; i++) + { + for (std::size_t j = 0; j < NHiggs; j++) + { + for (std::size_t k = 0; k < NHiggs; k++) + { + TripleHiggsCorrectionsCWPhysical[i][j][k] = 0; + TripleHiggsCorrectionsTreePhysical[i][j][k] = 0; + TripleHiggsCorrectionsCTPhysical[i][j][k] = 0; + for (std::size_t l = 0; l < NHiggs; l++) + { + for (std::size_t m = 0; m < NHiggs; m++) + { + for (std::size_t n = 0; n < NHiggs; n++) + { + double RotFac = + HiggsRotSort(i, l) * HiggsRotSort(j, m) * HiggsRotSort(k, n); + TripleHiggsCorrectionsCWPhysical[i][j][k] += + RotFac * GaugeBasis[l][m][n]; + TripleHiggsCorrectionsTreePhysical[i][j][k] += + RotFac * LambdaHiggs_3[l][m][n]; + TripleHiggsCorrectionsCTPhysical[i][j][k] += + RotFac * LambdaHiggs_3_CT[l][m][n]; + } + } + } + } + } + } +} + +void Class_SM::SetCurvatureArrays() +{ + initVectors(); + + for (std::size_t i = 0; i < NHiggs; i++) + HiggsVev[i] = vevTree[i]; + + Curvature_Higgs_L2[0][0] = muSq; + Curvature_Higgs_L2[1][1] = muSq; + Curvature_Higgs_L2[2][2] = muSq; + Curvature_Higgs_L2[3][3] = muSq; + + Curvature_Higgs_L4[0][0][0][0] = 6 * lambda; + Curvature_Higgs_L4[0][0][1][1] = 2 * lambda; + Curvature_Higgs_L4[0][0][2][2] = 2 * lambda; + Curvature_Higgs_L4[0][0][3][3] = 2 * lambda; + Curvature_Higgs_L4[1][1][1][1] = 6 * lambda; + Curvature_Higgs_L4[1][1][2][2] = 2 * lambda; + Curvature_Higgs_L4[1][1][3][3] = 2 * lambda; + Curvature_Higgs_L4[2][2][2][2] = 6 * lambda; + Curvature_Higgs_L4[2][2][3][3] = 2 * lambda; + Curvature_Higgs_L4[3][3][3][3] = 6 * lambda; + + sym4Dim(Curvature_Higgs_L4, NHiggs, NHiggs, NHiggs, NHiggs); + + Curvature_Gauge_G2H2[0][0][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][0][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][0][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][1][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][2][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[0][3][3][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][1][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][0][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][1][2] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][2][1] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[1][3][3][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][0][0] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][1][1] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][2][2] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][2][3][3] = SMConstants.C_g * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][0][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][1][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][2][2] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[2][3][3][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][0][2] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][1][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][2][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][0][3][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][0][3] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][1][2] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][2][1] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][1][3][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][0][0] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][1][1] = SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][2][2] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][2][3][3] = + -SMConstants.C_gs * SMConstants.C_g / 0.2e1; + Curvature_Gauge_G2H2[3][3][0][0] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][1][1] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][2][2] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + Curvature_Gauge_G2H2[3][3][3][3] = + SMConstants.C_gs * SMConstants.C_gs / 0.2e1; + + MatrixXcd YIJQc1(NQuarks, NQuarks), YIJQc2(NQuarks, NQuarks), + YIJQc2OI(NQuarks, NQuarks), YIJQg0(NQuarks, NQuarks), + YIJQg0OI(NQuarks, NQuarks), YIJQh1(NQuarks, NQuarks), + YIJQh2(NQuarks, NQuarks), YIJQh3(NQuarks, NQuarks); + + std::complex V11, V12, V13, V21, V22, V23, V31, V32, V33; + V11 = SMConstants.C_Vud; + V12 = SMConstants.C_Vus; + V13 = SMConstants.C_Vub; + V21 = SMConstants.C_Vcd; + V22 = SMConstants.C_Vcs; + V23 = SMConstants.C_Vcb; + V31 = SMConstants.C_Vtd; + V32 = SMConstants.C_Vts; + V33 = SMConstants.C_Vtb; + + std::complex VC11, VC12, VC13, VC21, VC22, VC23, VC31, VC32, VC33; + VC11 = std::conj(SMConstants.C_Vud); + VC12 = std::conj(SMConstants.C_Vus); + VC13 = std::conj(SMConstants.C_Vub); + VC21 = std::conj(SMConstants.C_Vcd); + VC22 = std::conj(SMConstants.C_Vcs); + VC23 = std::conj(SMConstants.C_Vcb); + VC31 = std::conj(SMConstants.C_Vtd); + VC32 = std::conj(SMConstants.C_Vts); + VC33 = std::conj(SMConstants.C_Vtb); + + Curvature_Lepton_F2H1[0][1][2] = 0.1e1 / v0 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[0][1][3] = II / v0 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][0][2] = 0.1e1 / v0 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][0][3] = II / v0 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][6][0] = 0.1e1 / v0 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[1][6][1] = II / v0 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[2][3][2] = 0.1e1 / v0 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[2][3][3] = II / v0 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][2][2] = 0.1e1 / v0 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][2][3] = II / v0 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][7][0] = 0.1e1 / v0 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[3][7][1] = II / v0 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[4][5][2] = 0.1e1 / v0 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[4][5][3] = II / v0 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][4][2] = 0.1e1 / v0 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][4][3] = II / v0 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][8][0] = 0.1e1 / v0 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[5][8][1] = II / v0 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[6][1][0] = 0.1e1 / v0 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[6][1][1] = II / v0 * SMConstants.C_MassElectron; + Curvature_Lepton_F2H1[7][3][0] = 0.1e1 / v0 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[7][3][1] = II / v0 * SMConstants.C_MassMu; + Curvature_Lepton_F2H1[8][5][0] = 0.1e1 / v0 * SMConstants.C_MassTau; + Curvature_Lepton_F2H1[8][5][1] = II / v0 * SMConstants.C_MassTau; + + Curvature_Quark_F2H1[0][6][2] = 0.1e1 / v0 * SMConstants.C_MassUp; + Curvature_Quark_F2H1[0][6][3] = -II / v0 * SMConstants.C_MassUp; + Curvature_Quark_F2H1[0][9][0] = + -0.1e1 / v0 * SMConstants.C_MassUp * conj(V11); + Curvature_Quark_F2H1[0][9][1] = II / v0 * SMConstants.C_MassUp * conj(V11); + Curvature_Quark_F2H1[0][10][0] = + -0.1e1 / v0 * SMConstants.C_MassUp * conj(V12); + Curvature_Quark_F2H1[0][10][1] = II / v0 * SMConstants.C_MassUp * conj(V12); + Curvature_Quark_F2H1[0][11][0] = + -0.1e1 / v0 * SMConstants.C_MassUp * conj(V13); + Curvature_Quark_F2H1[0][11][1] = II / v0 * SMConstants.C_MassUp * conj(V13); + Curvature_Quark_F2H1[1][7][2] = 0.1e1 / v0 * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[1][7][3] = -II / v0 * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[1][9][0] = + -0.1e1 / v0 * SMConstants.C_MassCharm * conj(V21); + Curvature_Quark_F2H1[1][9][1] = II / v0 * SMConstants.C_MassCharm * conj(V21); + Curvature_Quark_F2H1[1][10][0] = + -0.1e1 / v0 * SMConstants.C_MassCharm * conj(V22); + Curvature_Quark_F2H1[1][10][1] = + II / v0 * SMConstants.C_MassCharm * conj(V22); + Curvature_Quark_F2H1[1][11][0] = + -0.1e1 / v0 * SMConstants.C_MassCharm * conj(V23); + Curvature_Quark_F2H1[1][11][1] = + II / v0 * SMConstants.C_MassCharm * conj(V23); + Curvature_Quark_F2H1[2][8][2] = 0.1e1 / v0 * SMConstants.C_MassTop; + Curvature_Quark_F2H1[2][8][3] = -II / v0 * SMConstants.C_MassTop; + Curvature_Quark_F2H1[2][9][0] = + -0.1e1 / v0 * SMConstants.C_MassTop * conj(V31); + Curvature_Quark_F2H1[2][9][1] = II / v0 * SMConstants.C_MassTop * conj(V31); + Curvature_Quark_F2H1[2][10][0] = + -0.1e1 / v0 * SMConstants.C_MassTop * conj(V32); + Curvature_Quark_F2H1[2][10][1] = II / v0 * SMConstants.C_MassTop * conj(V32); + Curvature_Quark_F2H1[2][11][0] = + -0.1e1 / v0 * SMConstants.C_MassTop * conj(V33); + Curvature_Quark_F2H1[2][11][1] = II / v0 * SMConstants.C_MassTop * conj(V33); + Curvature_Quark_F2H1[3][6][0] = 0.1e1 / v0 * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[3][6][1] = II / v0 * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[3][7][0] = V21 / v0 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][7][1] = II * V21 / v0 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][8][0] = 0.1e1 / v0 * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[3][8][1] = II / v0 * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[3][9][2] = 0.1e1 / v0 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[3][9][3] = II / v0 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[4][6][0] = 0.1e1 / v0 * SMConstants.C_MassStrange * V12; + Curvature_Quark_F2H1[4][6][1] = II / v0 * SMConstants.C_MassStrange * V12; + Curvature_Quark_F2H1[4][7][0] = V22 / v0 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[4][7][1] = II * V22 / v0 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[4][8][0] = 0.1e1 / v0 * SMConstants.C_MassStrange * V32; + Curvature_Quark_F2H1[4][8][1] = II / v0 * SMConstants.C_MassStrange * V32; + Curvature_Quark_F2H1[4][10][2] = 0.1e1 / v0 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[4][10][3] = II / v0 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[5][6][0] = V13 / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][6][1] = II / v0 * SMConstants.C_MassBottom * V13; + Curvature_Quark_F2H1[5][7][0] = V23 / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][7][1] = II / v0 * SMConstants.C_MassBottom * V23; + Curvature_Quark_F2H1[5][8][0] = V33 / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][8][1] = II / v0 * SMConstants.C_MassBottom * V33; + Curvature_Quark_F2H1[5][11][2] = 0.1e1 / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[5][11][3] = II / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[6][0][2] = 0.1e1 / v0 * SMConstants.C_MassUp; + Curvature_Quark_F2H1[6][0][3] = -II / v0 * SMConstants.C_MassUp; + Curvature_Quark_F2H1[6][3][0] = 0.1e1 / v0 * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[6][3][1] = II / v0 * SMConstants.C_MassDown * V11; + Curvature_Quark_F2H1[6][4][0] = 0.1e1 / v0 * SMConstants.C_MassStrange * V12; + Curvature_Quark_F2H1[6][4][1] = II / v0 * SMConstants.C_MassStrange * V12; + Curvature_Quark_F2H1[6][5][0] = V13 / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[6][5][1] = II / v0 * SMConstants.C_MassBottom * V13; + Curvature_Quark_F2H1[7][1][2] = 0.1e1 / v0 * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[7][1][3] = -II / v0 * SMConstants.C_MassCharm; + Curvature_Quark_F2H1[7][3][0] = V21 / v0 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[7][3][1] = II * V21 / v0 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[7][4][0] = V22 / v0 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][4][1] = II * V22 / v0 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[7][5][0] = V23 / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[7][5][1] = II / v0 * SMConstants.C_MassBottom * V23; + Curvature_Quark_F2H1[8][2][2] = 0.1e1 / v0 * SMConstants.C_MassTop; + Curvature_Quark_F2H1[8][2][3] = -II / v0 * SMConstants.C_MassTop; + Curvature_Quark_F2H1[8][3][0] = 0.1e1 / v0 * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[8][3][1] = II / v0 * SMConstants.C_MassDown * V31; + Curvature_Quark_F2H1[8][4][0] = 0.1e1 / v0 * SMConstants.C_MassStrange * V32; + Curvature_Quark_F2H1[8][4][1] = II / v0 * SMConstants.C_MassStrange * V32; + Curvature_Quark_F2H1[8][5][0] = V33 / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[8][5][1] = II / v0 * SMConstants.C_MassBottom * V33; + Curvature_Quark_F2H1[9][0][0] = + -0.1e1 / v0 * SMConstants.C_MassUp * conj(V11); + Curvature_Quark_F2H1[9][0][1] = II / v0 * SMConstants.C_MassUp * conj(V11); + Curvature_Quark_F2H1[9][1][0] = + -0.1e1 / v0 * SMConstants.C_MassCharm * conj(V21); + Curvature_Quark_F2H1[9][1][1] = II / v0 * SMConstants.C_MassCharm * conj(V21); + Curvature_Quark_F2H1[9][2][0] = + -0.1e1 / v0 * SMConstants.C_MassTop * conj(V31); + Curvature_Quark_F2H1[9][2][1] = II / v0 * SMConstants.C_MassTop * conj(V31); + Curvature_Quark_F2H1[9][3][2] = 0.1e1 / v0 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[9][3][3] = II / v0 * SMConstants.C_MassDown; + Curvature_Quark_F2H1[10][0][0] = + -0.1e1 / v0 * SMConstants.C_MassUp * conj(V12); + Curvature_Quark_F2H1[10][0][1] = II / v0 * SMConstants.C_MassUp * conj(V12); + Curvature_Quark_F2H1[10][1][0] = + -0.1e1 / v0 * SMConstants.C_MassCharm * conj(V22); + Curvature_Quark_F2H1[10][1][1] = + II / v0 * SMConstants.C_MassCharm * conj(V22); + Curvature_Quark_F2H1[10][2][0] = + -0.1e1 / v0 * SMConstants.C_MassTop * conj(V32); + Curvature_Quark_F2H1[10][2][1] = II / v0 * SMConstants.C_MassTop * conj(V32); + Curvature_Quark_F2H1[10][4][2] = 0.1e1 / v0 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[10][4][3] = II / v0 * SMConstants.C_MassStrange; + Curvature_Quark_F2H1[11][0][0] = + -0.1e1 / v0 * SMConstants.C_MassUp * conj(V13); + Curvature_Quark_F2H1[11][0][1] = II / v0 * SMConstants.C_MassUp * conj(V13); + Curvature_Quark_F2H1[11][1][0] = + -0.1e1 / v0 * SMConstants.C_MassCharm * conj(V23); + Curvature_Quark_F2H1[11][1][1] = + II / v0 * SMConstants.C_MassCharm * conj(V23); + Curvature_Quark_F2H1[11][2][0] = + -0.1e1 / v0 * SMConstants.C_MassTop * conj(V33); + Curvature_Quark_F2H1[11][2][1] = II / v0 * SMConstants.C_MassTop * conj(V33); + Curvature_Quark_F2H1[11][5][2] = 0.1e1 / v0 * SMConstants.C_MassBottom; + Curvature_Quark_F2H1[11][5][3] = II / v0 * SMConstants.C_MassBottom; + + SetCurvatureDone = true; +} + +bool Class_SM::CalculateDebyeSimplified() +{ + return false; +} + +bool Class_SM::CalculateDebyeGaugeSimplified() +{ + return false; +} +double Class_SM::VTreeSimplified(const std::vector &v) const +{ + double vtmp = v[2]; + + double res = 0; + + res += 0.5 * muSq * std::pow(vtmp, 2); + res += 0.25 * lambda * std::pow(vtmp, 4); + + return res; +} + +double Class_SM::VCounterSimplified(const std::vector &v) const +{ + if (not UseVCounterSimplified) return 0; + + double vtmp = v[2]; + double res = 0; + + res += 0.5 * dmuSq * std::pow(vtmp, 2); + res += 0.25 * dlambda * std::pow(vtmp, 4); + res += dT3 * vtmp; + + return res; +} + +void Class_SM::Debugging(const std::vector &input, + std::vector &output) const +{ + (void)input; + (void)output; +} +} // namespace Models +} // namespace BSMPT diff --git a/src/models/ClassTemplate.cpp b/src/models/ClassTemplate.cpp index 51b59f7c..938cafcd 100644 --- a/src/models/ClassTemplate.cpp +++ b/src/models/ClassTemplate.cpp @@ -33,7 +33,8 @@ namespace Models * Lagrangian parameters AFTER using the tadpole conditions), nParCT (number of * counterterms) as well as nVEV (number of VEVs for minimization) */ -Class_Template::Class_Template() +Class_Template::Class_Template(const ISMConstants &smConstants) + : Class_Potential_Origin(smConstants) { Model = ModelID::ModelIDs::TEMPLATE; // global int constant which will be used to @@ -179,14 +180,15 @@ void Class_Template::set_gen(const std::vector &par) { ms = par[0]; // Class member is set accordingly to the input parameters lambda = par[1]; // Class member is set accordingly to the input parameters - g = C_g; // SM SU (2) gauge coupling --> SMparam .h - yt = std::sqrt(2) / C_vev0 * C_MassTop; // Top Yukawa coupling --> SMparam .h - scale = C_vev0; // Renormalisation scale is set to the SM VEV + g = SMConstants.C_g; // SM SU (2) gauge coupling --> SMparam .h + yt = std::sqrt(2) / SMConstants.C_vev0 * + SMConstants.C_MassTop; // Top Yukawa coupling --> SMparam .h + scale = SMConstants.C_vev0; // Renormalisation scale is set to the SM VEV vevTreeMin.resize(nVEV); vevTree.resize(NHiggs); // Here you have to set the vector vevTreeMin. The vector vevTree will then be // set by the function MinimizeOrderVEV - vevTreeMin[0] = C_vev0; + vevTreeMin[0] = SMConstants.C_vev0; vevTree = MinimizeOrderVEV(vevTreeMin); if (!SetCurvatureDone) SetCurvatureArrays(); } @@ -266,12 +268,13 @@ std::vector Class_Template::calc_CT() const // Here you have to use your formulae for the counterterm scheme double t = 0; parCT.push_back(t); // dT - parCT.push_back(3.0 * t / std::pow(C_vev0, 3) + - 3.0 / std::pow(C_vev0, 3) * NablaWeinberg(0) - - 3.0 / std::pow(C_vev0, 2) * HesseWeinberg(0, 0)); // dlambda - parCT.push_back(-3.0 / (2 * C_vev0) * NablaWeinberg(0) + + parCT.push_back(3.0 * t / std::pow(SMConstants.C_vev0, 3) + + 3.0 / std::pow(SMConstants.C_vev0, 3) * NablaWeinberg(0) - + 3.0 / std::pow(SMConstants.C_vev0, 2) * + HesseWeinberg(0, 0)); // dlambda + parCT.push_back(-3.0 / (2 * SMConstants.C_vev0) * NablaWeinberg(0) + 1.0 / 2.0 * HesseWeinberg(0, 0) - - 3.0 * t / (2 * C_vev0)); // dms + 3.0 * t / (2 * SMConstants.C_vev0)); // dms return parCT; } diff --git a/src/models/IncludeAllModels.cpp b/src/models/IncludeAllModels.cpp index 45aa37f0..0fd8dcb1 100644 --- a/src/models/IncludeAllModels.cpp +++ b/src/models/IncludeAllModels.cpp @@ -7,9 +7,10 @@ #include #include #include +#include #include // for Class_Potential_Origin #include -#include +#include #include #include // for isdigit, tolower #include // for operator<<, cerr, ost... @@ -25,20 +26,33 @@ namespace ModelID { std::unique_ptr FChoose(ModelIDs choice) +{ + return FChoose(choice, GetSMConstants()); +} + +std::unique_ptr FChoose(ModelIDs choice, + const ISMConstants &smConstants) { using namespace Models; switch (choice) { - case ModelIDs::R2HDM: return std::make_unique(); break; - case ModelIDs::C2HDM: return std::make_unique(); break; - case ModelIDs::RN2HDM: - return std::make_unique(); + case ModelIDs::SM: return std::make_unique(smConstants); break; + case ModelIDs::R2HDM: + return std::make_unique(smConstants); + break; + case ModelIDs::C2HDM: + return std::make_unique(smConstants); break; - case ModelIDs::CXSM: return std::make_unique(); break; + case ModelIDs::N2HDM: + return std::make_unique(smConstants); + break; + case ModelIDs::CXSM: return std::make_unique(smConstants); break; case ModelIDs::CPINTHEDARK: - return std::make_unique(); + return std::make_unique(smConstants); + break; + case ModelIDs::TEMPLATE: + return std::make_unique(smConstants); break; - case ModelIDs::TEMPLATE: return std::make_unique(); break; default: throw std::runtime_error("Invalid model"); } } @@ -48,7 +62,8 @@ ModelIDs getModel(const std::string &s) std::string ModelInput = s; std::transform( ModelInput.begin(), ModelInput.end(), ModelInput.begin(), ::tolower); - for (auto entry : ModelNames) + + for (const auto &entry : ModelNames) { auto key = entry.first; std::transform(key.begin(), key.end(), key.begin(), ::tolower); diff --git a/src/models/ModelTestfunctions.cpp b/src/models/ModelTestfunctions.cpp index 1d582b81..ce975917 100644 --- a/src/models/ModelTestfunctions.cpp +++ b/src/models/ModelTestfunctions.cpp @@ -254,9 +254,9 @@ TestResults CheckGaugeBosonMasses(const Class_Potential_Origin &point) std::vector gaugeMassesInput; gaugeMassesInput.push_back(0); - gaugeMassesInput.push_back(pow(C_MassW, 2)); - gaugeMassesInput.push_back(pow(C_MassW, 2)); - gaugeMassesInput.push_back(pow(C_MassZ, 2)); + gaugeMassesInput.push_back(pow(point.SMConstants.C_MassW, 2)); + gaugeMassesInput.push_back(pow(point.SMConstants.C_MassW, 2)); + gaugeMassesInput.push_back(pow(point.SMConstants.C_MassZ, 2)); std::sort(gaugeMassesInput.begin(), gaugeMassesInput.end()); auto GaugeMassCalculated = point.GaugeMassesSquared( point.MinimizeOrderVEV(point.get_vevTreeMin()), 0, 0); @@ -312,26 +312,26 @@ CheckFermionicMasses(const Class_Potential_Origin &point) leptonMassesInput.push_back(0); leptonMassesInput.push_back(0); leptonMassesInput.push_back(0); - leptonMassesInput.push_back(pow(C_MassElectron, 2)); - leptonMassesInput.push_back(pow(-C_MassElectron, 2)); - leptonMassesInput.push_back(pow(C_MassMu, 2)); - leptonMassesInput.push_back(pow(-C_MassMu, 2)); - leptonMassesInput.push_back(pow(C_MassTau, 2)); - leptonMassesInput.push_back(pow(-C_MassTau, 2)); - - quarkMassesInput.push_back(pow(C_MassUp, 2)); - quarkMassesInput.push_back(pow(-C_MassUp, 2)); - quarkMassesInput.push_back(pow(C_MassCharm, 2)); - quarkMassesInput.push_back(pow(-C_MassCharm, 2)); - quarkMassesInput.push_back(pow(C_MassTop, 2)); - quarkMassesInput.push_back(pow(-C_MassTop, 2)); - - quarkMassesInput.push_back(pow(C_MassDown, 2)); - quarkMassesInput.push_back(pow(-C_MassDown, 2)); - quarkMassesInput.push_back(pow(C_MassStrange, 2)); - quarkMassesInput.push_back(pow(-C_MassStrange, 2)); - quarkMassesInput.push_back(pow(C_MassBottom, 2)); - quarkMassesInput.push_back(pow(-C_MassBottom, 2)); + leptonMassesInput.push_back(pow(point.SMConstants.C_MassElectron, 2)); + leptonMassesInput.push_back(pow(-point.SMConstants.C_MassElectron, 2)); + leptonMassesInput.push_back(pow(point.SMConstants.C_MassMu, 2)); + leptonMassesInput.push_back(pow(-point.SMConstants.C_MassMu, 2)); + leptonMassesInput.push_back(pow(point.SMConstants.C_MassTau, 2)); + leptonMassesInput.push_back(pow(-point.SMConstants.C_MassTau, 2)); + + quarkMassesInput.push_back(pow(point.SMConstants.C_MassUp, 2)); + quarkMassesInput.push_back(pow(-point.SMConstants.C_MassUp, 2)); + quarkMassesInput.push_back(pow(point.SMConstants.C_MassCharm, 2)); + quarkMassesInput.push_back(pow(-point.SMConstants.C_MassCharm, 2)); + quarkMassesInput.push_back(pow(point.SMConstants.C_MassTop, 2)); + quarkMassesInput.push_back(pow(-point.SMConstants.C_MassTop, 2)); + + quarkMassesInput.push_back(pow(point.SMConstants.C_MassDown, 2)); + quarkMassesInput.push_back(pow(-point.SMConstants.C_MassDown, 2)); + quarkMassesInput.push_back(pow(point.SMConstants.C_MassStrange, 2)); + quarkMassesInput.push_back(pow(-point.SMConstants.C_MassStrange, 2)); + quarkMassesInput.push_back(pow(point.SMConstants.C_MassBottom, 2)); + quarkMassesInput.push_back(pow(-point.SMConstants.C_MassBottom, 2)); if (point.get_NLepton() == 0) { @@ -443,6 +443,7 @@ TestResults CheckTreeLevelMin(const Class_Potential_Origin &point, Minimizer::Minimize_gen_all_tree_level(point.get_Model(), point.get_parStored(), point.get_parCTStored(), + point.SMConstants, CheckVector, start, WhichMinimizer); @@ -642,19 +643,19 @@ TestResults CheckVCounterSimplified(const Class_Potential_Origin &point) return result; } -TestResults CheckCKMUnitarity() +TestResults CheckCKMUnitarity(const ISMConstants &SMConstants) { using namespace Eigen; MatrixXcd VCKM(3, 3); - VCKM(0, 0) = C_Vud; - VCKM(0, 1) = C_Vus; - VCKM(0, 2) = C_Vub; - VCKM(1, 0) = C_Vcd; - VCKM(1, 1) = C_Vcs; - VCKM(1, 2) = C_Vcb; - VCKM(2, 0) = C_Vtd; - VCKM(2, 1) = C_Vts; - VCKM(2, 2) = C_Vtb; + VCKM(0, 0) = SMConstants.C_Vud; + VCKM(0, 1) = SMConstants.C_Vus; + VCKM(0, 2) = SMConstants.C_Vub; + VCKM(1, 0) = SMConstants.C_Vcd; + VCKM(1, 1) = SMConstants.C_Vcs; + VCKM(1, 2) = SMConstants.C_Vcb; + VCKM(2, 0) = SMConstants.C_Vtd; + VCKM(2, 1) = SMConstants.C_Vts; + VCKM(2, 2) = SMConstants.C_Vtb; double ZeroMass = std::pow(10, -5); auto norm = (VCKM.adjoint() * VCKM - MatrixXcd::Identity(3, 3)).norm(); diff --git a/src/models/SMParam.cpp b/src/models/SMParam.cpp new file mode 100644 index 00000000..665082bd --- /dev/null +++ b/src/models/SMParam.cpp @@ -0,0 +1,63 @@ +#include + +namespace BSMPT +{ +const ISMConstants GetSMConstants() +{ + ISMConstants SM; + SM.C_Wolfenstein_lambda = 0.22537; + SM.C_Wolfenstein_A = 0.814; + SM.C_Wolfenstein_rho = 0.117; + SM.C_Wolfenstein_eta = 0.353; + SM.theta12 = std::asin(SM.C_Wolfenstein_lambda); + SM.theta23 = + std::asin(SM.C_Wolfenstein_A * std::pow(SM.C_Wolfenstein_lambda, 2)); + SM.delta = + std::arg(SM.C_Wolfenstein_A * std::pow(SM.C_Wolfenstein_lambda, 3) * + (SM.C_Wolfenstein_rho + II * SM.C_Wolfenstein_eta)); + SM.theta13 = std::asin( + std::abs(SM.C_Wolfenstein_A * std::pow(SM.C_Wolfenstein_lambda, 3) * + (SM.C_Wolfenstein_rho + II * SM.C_Wolfenstein_eta))); + SM.C_Vud = std::cos(SM.theta12) * std::cos(SM.theta13); + SM.C_Vus = std::sin(SM.theta12) * std::cos(SM.theta13); + SM.C_Vub = std::sin(SM.theta13) * std::exp(-SM.delta * II); + SM.C_Vcd = -std::sin(SM.theta12) * std::cos(SM.theta23) - + std::cos(SM.theta12) * std::sin(SM.theta23) * + std::sin(SM.theta13) * std::exp(II * SM.delta); + SM.C_Vcs = std::cos(SM.theta12) * std::cos(SM.theta23) - + std::sin(SM.theta12) * std::sin(SM.theta23) * + std::sin(SM.theta13) * std::exp(II * SM.delta); + SM.C_Vcb = std::sin(SM.theta23) * std::cos(SM.theta13); + SM.C_Vtd = std::sin(SM.theta12) * std::sin(SM.theta23) - + std::cos(SM.theta12) * std::cos(SM.theta23) * + std::sin(SM.theta13) * std::exp(II * SM.delta); + SM.C_Vts = -std::cos(SM.theta12) * std::sin(SM.theta23) - + std::sin(SM.theta12) * std::cos(SM.theta23) * + std::sin(SM.theta13) * std::exp(II * SM.delta); + SM.C_Vtb = std::cos(SM.theta23) * std::cos(SM.theta13); + + SM.C_MassW = 80.385; + SM.C_MassZ = 91.1876; + SM.C_MassSMHiggs = 125.09; + SM.C_MassUp = 0.1; + SM.C_MassDown = 0.1; + SM.C_MassStrange = 0.1; + SM.C_MassTop = 172.5; + SM.C_MassCharm = 1.51; + SM.C_MassBottom = 4.92; + SM.C_MassTau = 1.77682; + SM.C_MassMu = 0.1056583715; + SM.C_MassElectron = 0.510998928 * std::pow(10.0, -3.0); + SM.C_GF = 1.1663787 * 1e-5; + + SM.C_sinsquaredWeinberg = + 1 - (SM.C_MassW * SM.C_MassW) / (SM.C_MassZ * SM.C_MassZ); + SM.C_vev0 = std::sqrt(1 / std::sqrt(2) * 1 / SM.C_GF); + SM.C_g = 2 * SM.C_MassW / SM.C_vev0; + SM.C_gs = 2 * std::sqrt(std::pow(SM.C_MassZ, 2) - std::pow(SM.C_MassW, 2)) / + SM.C_vev0; + SM.C_SMTriHiggs = 3 * SM.C_MassSMHiggs * SM.C_MassSMHiggs / (SM.C_vev0); + + return SM; +} +} // namespace BSMPT diff --git a/src/prog/BSMPT.cpp b/src/prog/BSMPT.cpp index 0c4f635e..27be55c2 100644 --- a/src/prog/BSMPT.cpp +++ b/src/prog/BSMPT.cpp @@ -27,6 +27,8 @@ #include // for pair #include // for vector +#include + using namespace std; using namespace BSMPT; @@ -42,20 +44,28 @@ struct CLIOptions int WhichMinimizer{Minimizer::WhichMinimizerDefault}; bool UseMultithreading{true}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; }; +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + int main(int argc, char *argv[]) try { + const auto SMConstants = GetSMConstants(); /** * PrintErrorLines decides if parameter points with no valid EWPT (no NLO * stability or T=300 vanishing VEV) are printed in the output file */ bool PrintErrorLines = true; - const CLIOptions args(argc, argv); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); + if (not args.good()) { return EXIT_FAILURE; @@ -79,7 +89,7 @@ try } std::string linestr; std::shared_ptr modelPointer = - ModelID::FChoose(args.Model); + ModelID::FChoose(args.Model, SMConstants); while (getline(infile, linestr)) { if (linecounter > args.LastLine) break; @@ -226,146 +236,56 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) +CLIOptions::CLIOptions(const BSMPT::parser &argparser) { + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + FirstLine = argparser.get_value("firstLine"); + LastLine = argparser.get_value("lastLine"); + try + { + TerminalOutput = (argparser.get_value("terminalOutput") == "y"); + } + catch (BSMPT::parserException &) + { + TerminalOutput = false; + } - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); + try + { + UseGSL = argparser.get_value("useGSL"); + } + catch (BSMPT::parserException &) + { + } - if (argc < 6 or args.at(0) == "--help") + try + { + UseCMAES = argparser.get_value("useCMAES"); + } + catch (BSMPT::parserException &) { - int SizeOfFirstColumn = std::string("--TerminalOutput= ").size(); - std::stringstream ss; - - ss << std::boolalpha - << "BSMPT calculates the strength of the electroweak phase transition" - << std::endl - << "It is called either by " << std::endl - << "./BSMPT model input output FirstLine LastLine" << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to investigate" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--output=" - << "The output file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--FirstLine=" - << "The first line in the input file to calculate the EWPT. Expects " - "line 1 to be a legend." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--LastLine=" - << "The last line in the input file to calculate the EWPT." << std::endl; - std::string GSLhelp{"--UseGSL="}; - GSLhelp += Minimizer::UseGSLDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << GSLhelp - << "Use the GSL library to minimize the effective potential" - << std::endl; - std::string CMAEShelp{"--UseCMAES="}; - CMAEShelp += Minimizer::UseLibCMAESDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << CMAEShelp - << "Use the CMAES library to minimize the effective potential" - << std::endl; - std::string NLoptHelp{"--UseNLopt="}; - NLoptHelp += Minimizer::UseNLoptDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << NLoptHelp - << "Use the NLopt library to minimize the effective potential" - << std::endl; - ss << std::setw(SizeOfFirstColumn) << std::left - << "--UseMultithreading = true" - << "Enables/Disables multi threading for the minimizers" << std::endl; - ss << std::setw(SizeOfFirstColumn) << std::left << "--TerminalOutput=" - << "y/n Turns on additional information in the terminal during " - "the calculation." - << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); } - if (args.size() > 0 and args.at(0) == "--help") + try { - throw int{0}; + UseNLopt = argparser.get_value("useNLopt"); } - else if (argc < 6) + catch (BSMPT::parserException &) { - throw std::runtime_error("Too few arguments."); } - std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusedArgs; - if (UsePrefix) + try { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - } - else if (StringStartsWith(el, "--output=")) - { - OutputFile = arg.substr(std::string("--output=").size()); - } - else if (StringStartsWith(el, "--firstline=")) - { - FirstLine = std::stoi(el.substr(std::string("--firstline=").size())); - } - else if (StringStartsWith(el, "--lastline=")) - { - LastLine = std::stoi(el.substr(std::string("--lastline=").size())); - } - else if (StringStartsWith(el, "--terminaloutput=")) - { - TerminalOutput = - el.substr(std::string("--terminaloutput=").size()) == "y"; - } - else if (StringStartsWith(el, "--usegsl=")) - { - UseGSL = el.substr(std::string("--usegsl=").size()) == "true"; - } - else if (StringStartsWith(el, "--usecmaes=")) - { - UseCMAES = el.substr(std::string("--usecmaes=").size()) == "true"; - } - else if (StringStartsWith(el, "--usenlopt=")) - { - UseNLopt = el.substr(std::string("--usenlopt=").size()) == "true"; - } - else if (StringStartsWith(el, "--usemultithreading=")) - { - UseMultithreading = - el.substr(std::string("--usemultithreading=").size()) == "true"; - } - else - { - UnusedArgs.push_back(el); - } - } - WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); - SetLogger(UnusedArgs); + UseMultithreading = argparser.get_value("useMultithreading"); } - else + catch (BSMPT::parserException &) { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - OutputFile = args.at(2); - FirstLine = std::stoi(args.at(3)); - LastLine = std::stoi(args.at(4)); - if (argc == 7) - { - TerminalOutput = ("y" == std::string(argv[6])); - } } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); } bool CLIOptions::good() const @@ -373,17 +293,17 @@ bool CLIOptions::good() const if (UseGSL and not Minimizer::UseGSLDefault) { throw std::runtime_error( - "You set --UseGSL=true but GSL was not found during compilation."); + "You set --useGSL=true but GSL was not found during compilation."); } if (UseCMAES and not Minimizer::UseLibCMAESDefault) { throw std::runtime_error( - "You set --UseCMAES=true but CMAES was not found during compilation."); + "You set --useCMAES=true but CMAES was not found during compilation."); } if (UseNLopt and not Minimizer::UseNLoptDefault) { throw std::runtime_error( - "You set --UseNLopt=true but NLopt was not found during compilation."); + "You set --useNLopt=true but NLopt was not found during compilation."); } if (WhichMinimizer == 0) { @@ -412,3 +332,78 @@ bool CLIOptions::good() const } return true; } + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument("output", "The output file in tsv format.", true); + argparser.add_argument("firstLine", + "The first line in the input file to calculate the " + "EWPT. Expects line 1 to be a legend.", + true); + argparser.add_argument( + "lastLine", + "The last line in the input file to calculate the EWPT.", + true); + argparser.add_argument( + "terminalOutput", + "y/n Turns on additional information in the terminal during " + "the calculation.", + false); + + std::stringstream ss; + ss << "BSMPT calculates the strength of the electroweak phase transition" + << std::endl + << "It is called either by " << std::endl + << "./BSMPT model input output FirstLine LastLine" << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + argparser.enable_minimizer_options(); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--firstLine=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--lastLine=" + std::string(argv[5])); + } + } + return arguments; +} diff --git a/src/prog/CalcCT.cpp b/src/prog/CalcCT.cpp index bcb1cf16..b93e8157 100644 --- a/src/prog/CalcCT.cpp +++ b/src/prog/CalcCT.cpp @@ -13,6 +13,7 @@ #include // for Class_Potential_Origin #include #include +#include #include #include #include @@ -27,20 +28,30 @@ using namespace BSMPT; struct CLIOptions { +public: BSMPT::ModelID::ModelIDs Model{ModelID::ModelIDs::NotSet}; int FirstLine{}, LastLine{}; std::string InputFile, OutputFile; bool TerminalOutput{false}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; + +private: + BSMPT::parser mArgparser; }; +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + int main(int argc, char *argv[]) try { - - const CLIOptions args(argc, argv); + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); if (not args.good()) { @@ -64,7 +75,7 @@ try std::string linestr; std::unique_ptr modelPointer = - ModelID::FChoose(args.Model); + ModelID::FChoose(args.Model, SMConstants); while (getline(infile, linestr)) { @@ -100,107 +111,21 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) +CLIOptions::CLIOptions(const BSMPT::parser &argparser) { - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); - - if (argc < 6 or args.at(0) == "--help") - { - std::stringstream ss; - int SizeOfFirstColumn = std::string("--TerminalOutput= ").size(); - ss << "CalcCT calculates the counterterm parameters for the given " - "paramter points" - << std::endl - << "It is called either by " << std::endl - << "./CalcCT model input output FirstLine LastLine" << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to investigate" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--output=" - << "The output file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--FirstLine=" - << "The first line in the input file to calculate the EWPT. " - "Expects line 1 to be a legend." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--LastLine=" - << "The last line in the input file to calculate the EWPT." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--TerminalOutput=" - << "y/n Turns on additional information in the terminal during " - "the calculation." - << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); - } - - if (args.size() > 0 and args.at(0) == "--help") + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + FirstLine = argparser.get_value("firstLine"); + LastLine = argparser.get_value("lastLine"); + try { - throw int{0}; + TerminalOutput = (argparser.get_value("terminalOutput") == "y"); } - else if (argc < 6) + catch (BSMPT::parserException &) { - throw std::runtime_error("Too few arguments."); - } - - std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusedArgs; - if (UsePrefix) - { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - } - else if (StringStartsWith(el, "--output=")) - { - OutputFile = arg.substr(std::string("--output=").size()); - } - else if (StringStartsWith(el, "--firstline=")) - { - FirstLine = std::stoi(el.substr(std::string("--firstline=").size())); - } - else if (StringStartsWith(el, "--lastline=")) - { - LastLine = std::stoi(el.substr(std::string("--lastline=").size())); - } - else if (StringStartsWith(el, "--terminaloutput=")) - { - TerminalOutput = - el.substr(std::string("--terminaloutput=").size()) == "y"; - } - else - { - UnusedArgs.push_back(el); - } - } - SetLogger(UnusedArgs); - } - else - { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - OutputFile = args.at(2); - FirstLine = std::stoi(args.at(3)); - LastLine = std::stoi(args.at(4)); - if (argc == 7) - { - TerminalOutput = ("y" == std::string(argv[6])); - } + TerminalOutput = false; } } @@ -226,3 +151,77 @@ bool CLIOptions::good() const } return true; } + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument("output", "The output file in tsv format.", true); + argparser.add_argument("firstLine", + "The first line in the input file to calculate the " + "EWPT. Expects line 1 to be a legend.", + true); + argparser.add_argument( + "lastLine", + "The last line in the input file to calculate the EWPT.", + true); + argparser.add_argument( + "terminalOutput", + "y/n Turns on additional information in the terminal during " + "the calculation.", + false); + + std::stringstream ss; + ss << "CalcCT calculates the counterterm parameters for the given " + "paramter points" + << std::endl + << "It is called either by " << std::endl + << "./CalcCT model input output FirstLine LastLine" << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--firstLine=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--lastLine=" + std::string(argv[5])); + } + } + return arguments; +} diff --git a/src/prog/CalcGW.cpp b/src/prog/CalcGW.cpp new file mode 100644 index 00000000..df908925 --- /dev/null +++ b/src/prog/CalcGW.cpp @@ -0,0 +1,732 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and +// Jonas Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file + * This program calculates properties of graviational waves sourced by phase + * transitions + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for atoi, EXIT_FAILURE +#include // for string, operator<< +#include // for pair +#include // for vector + +using namespace std; +using namespace BSMPT; + +struct CLIOptions +{ + BSMPT::ModelID::ModelIDs Model{ModelID::ModelIDs::NotSet}; + int firstline{0}, lastline{0}; + double templow{0}, temphigh{300}; + double UserDefined_vwall = 0.95; + double UserDefined_epsturb = 0.1; + int MaxPathIntegrations = 7; + std::string inputfile, outputfile; + bool UseGSL{Minimizer::UseGSLDefault}; + bool UseCMAES{Minimizer::UseLibCMAESDefault}; + bool UseNLopt{Minimizer::UseNLoptDefault}; + int WhichMinimizer{Minimizer::WhichMinimizerDefault}; + bool UseMultithreading{false}; + int UseMultiStepPTMode{-1}; + int CheckEWSymmetryRestoration{1}; + double perc_prbl{.71}; + double compl_prbl{.01}; + int num_check_pts{10}; + int CheckNLOStability{1}; + int WhichTransitionTemperature{ + 3}; // 1 = nucl_approx, 2 = nucl, 3 = perc, 4 = compl + + CLIOptions(const BSMPT::parser &argparser); + bool good() const; +}; + +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + +int main(int argc, char *argv[]) +try +{ + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); + if (not args.good()) + { + return EXIT_FAILURE; + } + + std::ifstream infile(args.inputfile); + if (!infile.good()) + { + Logger::Write(LoggingLevel::Default, + "Input file " + args.inputfile + " not found "); + return EXIT_FAILURE; + } + + Logger::Write(LoggingLevel::ProgDetailed, "Found file"); + + std::shared_ptr modelPointer = + ModelID::FChoose(args.Model, SMConstants); + + Logger::Write(LoggingLevel::ProgDetailed, "Created modelpointer "); + + std::string linestr, linestr_store; + int linecounter = 1; + std::size_t count = 0; + int num_points = args.lastline - args.firstline + 1; + + // output contents storage + std::vector output_contents; + output_contents.resize(num_points); // reserve one row per point + std::vector transition_history; + std::vector legend; + + while (getline(infile, linestr)) + { + if (linecounter == 1) linestr_store = linestr; + + if (linecounter > args.lastline) break; + + if (linecounter >= args.firstline and linecounter <= args.lastline) + { + count += 1; // keep track at which point we are + output_contents.at(count - 1).precision( + std::numeric_limits::max_digits10); + + Logger::Write(LoggingLevel::ProgDetailed, + "Currently at line " + std::to_string(linecounter)); + + modelPointer->setUseIndexCol(linestr_store); + + std::pair, std::vector> parameters = + modelPointer->initModel(linestr); + + if (args.firstline == args.lastline) + { + modelPointer->write(); + } + + auto start = std::chrono::high_resolution_clock::now(); + + user_input input{modelPointer, + args.templow, + args.temphigh, + args.UserDefined_vwall, + args.perc_prbl, + args.compl_prbl, + args.UserDefined_epsturb, + args.MaxPathIntegrations, + args.UseMultiStepPTMode, + args.num_check_pts, + args.CheckEWSymmetryRestoration, + args.CheckNLOStability, + args.WhichMinimizer, + args.UseMultithreading, + true, + args.WhichTransitionTemperature}; + + TransitionTracer trans(input); + + auto time = std::chrono::duration_cast( + std::chrono::high_resolution_clock::now() - start) + .count() / + 1000.; + + BSMPT::Logger::Write(BSMPT::LoggingLevel::ProgDetailed, + "Took\t" + std::to_string(time) + " seconds.\n"); + + auto output = trans.output_store; + + output_contents.at(count - 1) + << linestr << sep << parameters.second << sep + << output.status.status_nlo_stability << sep + << output.status.status_ewsr << sep << output.status.status_tracing + << sep << output.status.status_coex_pairs << sep << time << sep; + + if ((output.status.status_tracing == StatusTracing::Success) && + (output.status.status_coex_pairs == StatusCoexPair::Success)) + { + for (std::size_t i = 0; i < trans.output_store.num_coex_phase_pairs; + i++) + { + output_contents.at(count - 1) + << output.status.status_crit.at(i) << sep + << output.vec_trans_data.at(i).crit_temp.value_or(EmptyValue) + << sep << output.vec_trans_data.at(i).crit_false_vev << sep + << output.vec_trans_data.at(i).crit_true_vev << sep + << output.status.status_bounce_sol.at(i) << sep + << output.status.status_nucl_approx.at(i) << sep + << output.vec_trans_data.at(i).nucl_approx_temp.value_or( + EmptyValue) + << sep << output.vec_trans_data.at(i).nucl_approx_false_vev << sep + << output.vec_trans_data.at(i).nucl_approx_true_vev << sep + << output.status.status_nucl.at(i) << sep + << output.vec_trans_data.at(i).nucl_temp.value_or(EmptyValue) + << sep << output.vec_trans_data.at(i).nucl_false_vev << sep + << output.vec_trans_data.at(i).nucl_true_vev << sep + << output.status.status_perc.at(i) << sep + << output.vec_trans_data.at(i).perc_temp.value_or(EmptyValue) + << sep << output.vec_trans_data.at(i).perc_false_vev << sep + << output.vec_trans_data.at(i).perc_true_vev << sep + << output.status.status_compl.at(i) << sep + << output.vec_trans_data.at(i).compl_temp.value_or(EmptyValue) + << sep << output.vec_trans_data.at(i).compl_false_vev << sep + << output.vec_trans_data.at(i).compl_true_vev << sep + << output.vec_gw_data.at(i).status_gw << sep + << output.vec_gw_data.at(i).trans_temp.value_or(EmptyValue) << sep + << output.vec_gw_data.at(i).vwall.value_or(EmptyValue) << sep + << output.vec_gw_data.at(i).alpha.value_or(EmptyValue) << sep + << output.vec_gw_data.at(i).beta_over_H.value_or(EmptyValue) + << sep << output.vec_gw_data.at(i).K_sw.value_or(EmptyValue) + << sep << output.vec_gw_data.at(i).fpeak_sw.value_or(EmptyValue) + << sep << output.vec_gw_data.at(i).h2Omega_sw.value_or(EmptyValue) + << sep << output.vec_gw_data.at(i).SNR_sw.value_or(EmptyValue) + << sep << output.vec_gw_data.at(i).K_turb.value_or(EmptyValue) + << sep << output.vec_gw_data.at(i).fpeak_turb.value_or(EmptyValue) + << sep + << output.vec_gw_data.at(i).h2Omega_turb.value_or(EmptyValue) + << sep << output.vec_gw_data.at(i).SNR_turb.value_or(EmptyValue) + << sep << output.vec_gw_data.at(i).SNR.value_or(EmptyValue) + << sep; + } + } + + transition_history.push_back(output.transition_history); + + if (legend.size() < output.legend.size()) + { + legend = output.legend; // update legend + } + + // write to output file + std::ofstream outfile(args.outputfile); + if (!outfile.good()) + { + Logger::Write(LoggingLevel::Default, + "Can not create file " + args.outputfile); + return EXIT_FAILURE; + } + + int tab_count_legend = 1; + std::stringstream full_legend; + full_legend << linestr_store << sep << modelPointer->addLegendCT() << sep + << legend; + outfile << full_legend.str() << std::endl; + + // get length of legend and of contents + std::string str_legend = full_legend.str(); + for (auto &el : str_legend) + { + if (el == '\t') + { + tab_count_legend += 1; + } + } + + std::vector tab_count(count, 1); + for (std::size_t i = 0; i < count; i++) + { + std::string line = output_contents.at(i).str(); + for (auto &el : line) + { + if (el == '\t') + { + tab_count.at(i) += 1; + } + } + } + + // fill up previous rows to match multi-line + for (std::size_t i = 0; i < count; i++) + { + outfile << output_contents.at(i).str(); + + int diff = int(tab_count_legend - tab_count.at(i)); + + while (diff > 0) + { + outfile << "nan" << sep; + diff--; + } + outfile << transition_history.at(i) << std::endl; + } + + outfile.close(); + } + + linecounter++; + if (infile.eof()) break; + } + return EXIT_SUCCESS; +} +catch (int) +{ + return EXIT_SUCCESS; +} +catch (exception &e) +{ + Logger::Write(LoggingLevel::Default, e.what()); + return EXIT_FAILURE; +} + +bool CLIOptions::good() const +{ + if (UseGSL and not Minimizer::UseGSLDefault) + { + throw std::runtime_error( + "You set --UseGSL=true but GSL was not found during compilation."); + } + if (UseCMAES and not Minimizer::UseLibCMAESDefault) + { + throw std::runtime_error("You set --UseCMAES=true but CMAES was not " + "found during compilation."); + } + if (UseNLopt and not Minimizer::UseNLoptDefault) + { + throw std::runtime_error("You set --UseNLopt=true but NLopt was not " + "found during compilation."); + } + if (WhichMinimizer == 0) + { + throw std::runtime_error( + "You disabled all minimizers. You need at least one."); + } + + if (Model == ModelID::ModelIDs::NotSet) + { + Logger::Write( + LoggingLevel::Default, + "Your Model parameter does not match with the implemented Models."); + ShowInputError(); + return false; + } + if (firstline == 0 or lastline == 0) + { + Logger::Write(LoggingLevel::Default, "firstline or lastline not set."); + return false; + } + if (firstline > lastline) + { + Logger::Write(LoggingLevel::Default, "firstline is smaller then lastline."); + return false; + } + if (templow > temphigh) + { + Logger::Write(LoggingLevel::Default, + "Invalid temperature choice. Thigh has to be > 0 GeV."); + return false; + } + if (UserDefined_epsturb != -1 and + (UserDefined_epsturb < 0 or UserDefined_epsturb > 1)) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for eps_turb."); + return false; + } + if ((UserDefined_vwall != -1 and UserDefined_vwall != -2) and + (UserDefined_vwall <= 0 or UserDefined_vwall > 1)) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for vwall."); + return false; + } + if (UseMultiStepPTMode > 3 or UseMultiStepPTMode < -1) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for MultiStepPTMode."); + return false; + } + if (num_check_pts < 0) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for num_check_pts."); + return false; + } + if (CheckEWSymmetryRestoration > 3 or CheckEWSymmetryRestoration < 0) + { + Logger::Write(LoggingLevel::Default, + "Invalid choice for CheckEWSymmetryRestoration."); + return false; + } + if (CheckNLOStability < 0 or CheckNLOStability > 1) + { + Logger::Write(LoggingLevel::Default, + "Invalid choice for CheckNLOStability."); + return false; + } + if (perc_prbl < 0 or perc_prbl > 1) + { + Logger::Write(LoggingLevel::Default, + "Invalid false vacuum fraction for determination of " + "percolation temperature given."); + return false; + } + if (compl_prbl < 0 or compl_prbl > 1) + { + Logger::Write(LoggingLevel::Default, + "Invalid false vacuum fraction for determination of " + "completion temperature given."); + return false; + } + if (WhichTransitionTemperature < 1 or WhichTransitionTemperature > 4) + { + Logger::Write(LoggingLevel::Default, + "Invalid transition temperature given."); + } + + return true; +} + +CLIOptions::CLIOptions(const BSMPT::parser &argparser) +{ + std::stringstream ss; + argparser.check_required_parameters(); + + // required arguments + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + inputfile = argparser.get_value("input"); + outputfile = argparser.get_value("output"); + firstline = argparser.get_value("firstline"); + lastline = argparser.get_value("lastline"); + + // optional arguments + try + { + temphigh = argparser.get_value("thigh"); + } + catch (BSMPT::parserException &) + { + ss << "--thigh not set, using default value: " << temphigh << "\n"; + } + + std::string GSLhelp = Minimizer::UseGSLDefault ? "true" : "false"; + std::string CMAEShelp = Minimizer::UseLibCMAESDefault ? "true" : "false"; + std::string NLoptHelp = Minimizer::UseNLoptDefault ? "true" : "false"; + try + { + UseGSL = (argparser.get_value("usegsl") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usegsl not set, using default value: " << GSLhelp << "\n"; + } + + try + { + UseCMAES = (argparser.get_value("usecmaes") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usecmaes not set, using default value: " << CMAEShelp << "\n"; + } + + try + { + UseNLopt = (argparser.get_value("usenlopt") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usenlopt not set, using default value: " << NLoptHelp << "\n"; + } + + try + { + UseMultithreading = (argparser.get_value("usemultithreading") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usemultithreading not set, using default value: false\n"; + } + + // UseMultiStepPTMode + try + { + auto multistepPT_string = argparser.get_value("multistepmode"); + if (multistepPT_string == "default") + { + UseMultiStepPTMode = -1; + } + else if (multistepPT_string == "auto") + { + UseMultiStepPTMode = 3; + } + else + { + UseMultiStepPTMode = std::stoi(multistepPT_string); + } + } + catch (BSMPT::parserException &) + { + ss << "--multistepmode not set, using default value: default\n"; + } + + try + { + num_check_pts = argparser.get_value("num_pts"); + } + catch (BSMPT::parserException &) + { + ss << "--num_check_pts not set, using default value: " << num_check_pts + << "\n"; + } + + try + { + UserDefined_vwall = argparser.get_value("vwall"); + } + catch (BSMPT::parserException &) + { + ss << "--vwall not set, using default value: " << UserDefined_vwall << "\n"; + } + + try + { + perc_prbl = argparser.get_value("perc_prbl"); + } + catch (BSMPT::parserException &) + { + ss << "--perc_prbl not set, using default value: " << perc_prbl << "\n"; + } + + try + { + compl_prbl = argparser.get_value("compl_prbl"); + } + catch (BSMPT::parserException &) + { + ss << "--compl_prbl not set, using default value: " << compl_prbl << "\n"; + } + + try + { + auto trans_string = argparser.get_value("trans_temp"); + if (trans_string == "nucl_approx") + { + WhichTransitionTemperature = 1; + } + else if (trans_string == "nucl") + { + WhichTransitionTemperature = 2; + } + else if (trans_string == "perc") + { + WhichTransitionTemperature = 3; + } + else if (trans_string == "compl") + { + WhichTransitionTemperature = 4; + } + } + catch (BSMPT::parserException &) + { + ss << "--trans_string not set, using default value: perc\n"; + } + + try + { + UserDefined_epsturb = argparser.get_value("epsturb"); + } + catch (BSMPT::parserException &) + { + ss << "--epsturb not set, using default value: " << UserDefined_epsturb + << "\n"; + } + + // CheckNLOStability + try + { + auto nlo_string = argparser.get_value("checknlo"); + if (nlo_string == "on") + { + CheckNLOStability = 1; + } + else if (nlo_string == "off") + { + CheckNLOStability = 0; + } + } + catch (BSMPT::parserException &) + { + ss << "--checknlo not set, using default value: on\n"; + } + + // CheckEWSymmetryRestoration + try + { + auto ewsr_string = argparser.get_value("checkewsr"); + if (ewsr_string == "on") + { + CheckEWSymmetryRestoration = 1; + } + else if (ewsr_string == "off") + { + CheckEWSymmetryRestoration = 0; + } + else if (ewsr_string == "keep_bfb") + { + CheckEWSymmetryRestoration = 2; + } + else if (ewsr_string == "keep_ewsr") + { + CheckEWSymmetryRestoration = 3; + } + } + catch (BSMPT::parserException &) + { + ss << "--checkewsr not set, using default value: on\n"; + } + + try + { + MaxPathIntegrations = argparser.get_value("maxpathintegrations"); + } + catch (BSMPT::parserException &) + { + ss << "--maxpathintegrations not set, using default value: " + << MaxPathIntegrations << "\n"; + } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); + + Logger::Write(LoggingLevel::ProgDetailed, ss.str()); +} + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser(true); + argparser.add_argument("help", "shows this menu", false); + argparser.add_argument("model", "[*] model name", true); + argparser.add_argument("input", "[*] input file (in tsv format)", true); + argparser.add_argument("output", "[*] output file (in tsv format)", true); + argparser.add_argument( + "firstline", "[*] line number of first line in input file", true); + argparser.add_subtext(" (expects line 1 to be a legend)"); + argparser.add_argument( + "lastline", "[*] line number of last line in input file", true); + argparser.add_argument("thigh", "high temperature [GeV]", "300", false); + argparser.add_argument( + "multistepmode", "multi-step PT mode", "default", false); + argparser.add_subtext("default: default mode"); + argparser.add_subtext("0: single-step PT mode"); + argparser.add_subtext(">0 for multi-step PT modes:"); + argparser.add_subtext("1: tracing coverage"); + argparser.add_subtext("2: global minimum tracing coverage"); + argparser.add_subtext("auto: automatic mode"); + argparser.add_argument( + "num_pts", "intermediate grid-size for default mode", "10", false); + argparser.add_argument( + "vwall", "wall velocity: >0 user defined", "0.95", false); + argparser.add_subtext("-1: approximation"); + argparser.add_subtext("-2: upper bound"); + argparser.add_argument( + "perc_prbl", "false vacuum fraction for percolation", "0.71", false); + argparser.add_argument( + "compl_prbl", "false vacuum fraction for completion", "0.01", false); + argparser.add_argument( + "trans_temp", "transition temperature, options are:", "perc", false); + argparser.add_subtext("nucl_approx: approx nucleation temperature"); + argparser.add_subtext("nucl: nucleation temperature"); + argparser.add_subtext("perc: percolation temperature"); + argparser.add_subtext("compl: completion temperature"); + argparser.add_argument( + "epsturb", "turbulence efficiency factor", "0.1", false); + argparser.add_subtext(">0: user defined"); + argparser.add_subtext("-1: upper bound"); + argparser.add_argument("checknlo", "check for NLO stability", "on", false); + argparser.add_subtext("on: only keep NLO stable points"); + argparser.add_subtext("off: check disabled"); + argparser.add_argument( + "checkewsr", "check for EWSR at high temperature", "on", false); + argparser.add_subtext("on: perform check and add info"); + argparser.add_subtext("keep_bfb: only keep BFB points"); + argparser.add_subtext("keep_ewsr: only keep EWSR points"); + argparser.add_subtext("off: check disabled"); + + argparser.add_argument("maxpathintegrations", + "number of solutions of 1D equation =", + "7", + false); + argparser.add_subtext("number of path deformations + 1"); + + std::string GSLhelp = Minimizer::UseGSLDefault ? "true" : "false"; + std::string CMAEShelp = Minimizer::UseLibCMAESDefault ? "true" : "false"; + std::string NLoptHelp = Minimizer::UseNLoptDefault ? "true" : "false"; + + argparser.add_argument( + "usegsl", "use GSL library for minimization", GSLhelp, false); + argparser.add_argument( + "usecmaes", "use CMAES library for minimization", CMAEShelp, false); + argparser.add_argument( + "usenlopt", "use NLopt library for minimization", NLoptHelp, false); + argparser.add_argument("usemultithreading", + "enable multi-threading for minimizers", + "false", + false); + argparser.add_argument( + "json", "use a json file instead of cli parameters", false); + + std::stringstream ss; + ss << "CalcGW calculates the gravitational wave signal\nit is called " + "by\n\n\t./bin/CalcGW model input output firstline " + "lastline\n\nor " + "with arguments\n\n\t./bin/CalcGW [arguments]\n\nwith the " + "following arguments, ([*] are required arguments, others " + "are optional):\n"; + argparser.set_help_header(ss.str()); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--firstline=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--lastline=" + std::string(argv[5])); + } + } + return arguments; +} \ No newline at end of file diff --git a/src/prog/CalcTemps.cpp b/src/prog/CalcTemps.cpp new file mode 100644 index 00000000..c8c3efad --- /dev/null +++ b/src/prog/CalcTemps.cpp @@ -0,0 +1,663 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and +// Jonas Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file + * This program calculates characteristic temperatures for + * phase transitions + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for atoi, EXIT_FAILURE +#include // for string, operator<< +#include // for pair +#include // for vector + +using namespace std; +using namespace BSMPT; + +struct CLIOptions +{ + BSMPT::ModelID::ModelIDs Model{ModelID::ModelIDs::NotSet}; + int firstline{0}, lastline{0}; + double templow{0}, temphigh{300}; + double UserDefined_vwall = 0.95; + int MaxPathIntegrations = 7; + std::string inputfile, outputfile; + bool UseGSL{Minimizer::UseGSLDefault}; + bool UseCMAES{Minimizer::UseLibCMAESDefault}; + bool UseNLopt{Minimizer::UseNLoptDefault}; + int WhichMinimizer{Minimizer::WhichMinimizerDefault}; + bool UseMultithreading{false}; + int UseMultiStepPTMode{-1}; + int CheckEWSymmetryRestoration{1}; + double perc_prbl{.71}; + double compl_prbl{.01}; + int num_check_pts{10}; + int CheckNLOStability{1}; + + CLIOptions(const BSMPT::parser &argparser); + bool good() const; +}; + +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + +int main(int argc, char *argv[]) +try +{ + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); + if (not args.good()) + { + return EXIT_FAILURE; + } + + std::ifstream infile(args.inputfile); + if (!infile.good()) + { + Logger::Write(LoggingLevel::Default, + "Input file " + args.inputfile + " not found "); + return EXIT_FAILURE; + } + + Logger::Write(LoggingLevel::ProgDetailed, "Found file"); + + std::shared_ptr modelPointer = + ModelID::FChoose(args.Model, SMConstants); + + Logger::Write(LoggingLevel::ProgDetailed, "Created modelpointer "); + + std::string linestr, linestr_store; + int linecounter = 1; + std::size_t count = 0; + int num_points = args.lastline - args.firstline + 1; + + // output contents storage + std::vector output_contents; + output_contents.resize(num_points); // reserve one row per point + std::vector transition_history; + std::vector legend; + + while (getline(infile, linestr)) + { + if (linecounter == 1) linestr_store = linestr; + + if (linecounter > args.lastline) break; + + if (linecounter >= args.firstline and linecounter <= args.lastline) + { + count += 1; // keep track at which point we are + output_contents.at(count - 1).precision( + std::numeric_limits::max_digits10); + + Logger::Write(LoggingLevel::ProgDetailed, + "Currently at line " + std::to_string(linecounter)); + + modelPointer->setUseIndexCol(linestr_store); + + std::pair, std::vector> parameters = + modelPointer->initModel(linestr); + + if (args.firstline == args.lastline) + { + modelPointer->write(); + } + + auto start = std::chrono::high_resolution_clock::now(); + + user_input input{modelPointer, + args.templow, + args.temphigh, + args.UserDefined_vwall, + args.perc_prbl, + args.compl_prbl, + 0.1, + args.MaxPathIntegrations, + args.UseMultiStepPTMode, + args.num_check_pts, + args.CheckEWSymmetryRestoration, + args.CheckNLOStability, + args.WhichMinimizer, + args.UseMultithreading, + false}; + + TransitionTracer trans(input); + + auto time = std::chrono::duration_cast( + std::chrono::high_resolution_clock::now() - start) + .count() / + 1000.; + + BSMPT::Logger::Write(BSMPT::LoggingLevel::ProgDetailed, + "Took\t" + std::to_string(time) + " seconds.\n"); + + auto output = trans.output_store; + + output_contents.at(count - 1) + << linestr << sep << parameters.second << sep + << output.status.status_nlo_stability << sep + << output.status.status_ewsr << sep << output.status.status_tracing + << sep << output.status.status_coex_pairs << sep << time << sep; + + if ((output.status.status_tracing == StatusTracing::Success) && + (output.status.status_coex_pairs == StatusCoexPair::Success)) + { + for (std::size_t i = 0; i < trans.output_store.num_coex_phase_pairs; + i++) + { + output_contents.at(count - 1) + << output.status.status_crit.at(i) << sep + << output.vec_trans_data.at(i).crit_temp.value_or(EmptyValue) + << sep << output.vec_trans_data.at(i).crit_false_vev << sep + << output.vec_trans_data.at(i).crit_true_vev << sep + << output.status.status_bounce_sol.at(i) << sep + << output.status.status_nucl_approx.at(i) << sep + << output.vec_trans_data.at(i).nucl_approx_temp.value_or( + EmptyValue) + << sep << output.vec_trans_data.at(i).nucl_approx_false_vev << sep + << output.vec_trans_data.at(i).nucl_approx_true_vev << sep + << output.status.status_nucl.at(i) << sep + << output.vec_trans_data.at(i).nucl_temp.value_or(EmptyValue) + << sep << output.vec_trans_data.at(i).nucl_false_vev << sep + << output.vec_trans_data.at(i).nucl_true_vev << sep + << output.status.status_perc.at(i) << sep + << output.vec_trans_data.at(i).perc_temp.value_or(EmptyValue) + << sep << output.vec_trans_data.at(i).perc_false_vev << sep + << output.vec_trans_data.at(i).perc_true_vev << sep + << output.status.status_compl.at(i) << sep + << output.vec_trans_data.at(i).compl_temp.value_or(EmptyValue) + << sep << output.vec_trans_data.at(i).compl_false_vev << sep + << output.vec_trans_data.at(i).compl_true_vev << sep; + } + } + + transition_history.push_back(output.transition_history); + + if (legend.size() < output.legend.size()) + { + legend = output.legend; // update legend + } + + // write to output file + std::ofstream outfile(args.outputfile); + if (!outfile.good()) + { + Logger::Write(LoggingLevel::Default, + "Can not create file " + args.outputfile); + return EXIT_FAILURE; + } + + int tab_count_legend = 1; + std::stringstream full_legend; + full_legend << linestr_store << sep << modelPointer->addLegendCT() << sep + << legend; + outfile << full_legend.str() << std::endl; + + // get length of legend and of contents + std::string str_legend = full_legend.str(); + for (auto &el : str_legend) + { + if (el == '\t') + { + tab_count_legend += 1; + } + } + + std::vector tab_count(count, 1); + for (std::size_t i = 0; i < count; i++) + { + std::string line = output_contents.at(i).str(); + for (auto &el : line) + { + if (el == '\t') + { + tab_count.at(i) += 1; + } + } + } + + // fill up previous rows to match multi-line + for (std::size_t i = 0; i < count; i++) + { + outfile << output_contents.at(i).str(); + + int diff = int(tab_count_legend - tab_count.at(i)); + + while (diff > 0) + { + outfile << "nan" << sep; + diff--; + } + outfile << transition_history.at(i) << std::endl; + } + + outfile.close(); + } + + linecounter++; + if (infile.eof()) break; + } + return EXIT_SUCCESS; +} +catch (int) +{ + return EXIT_SUCCESS; +} +catch (exception &e) +{ + Logger::Write(LoggingLevel::Default, e.what()); + return EXIT_FAILURE; +} + +bool CLIOptions::good() const +{ + if (UseGSL and not Minimizer::UseGSLDefault) + { + throw std::runtime_error("You set --UseGSL=true but GSL was not " + "found during compilation."); + } + if (UseCMAES and not Minimizer::UseLibCMAESDefault) + { + throw std::runtime_error("You set --UseCMAES=true but CMAES was not " + "found during compilation."); + } + if (UseNLopt and not Minimizer::UseNLoptDefault) + { + throw std::runtime_error("You set --UseNLopt=true but NLopt was not " + "found during compilation."); + } + if (WhichMinimizer == 0) + { + throw std::runtime_error( + "You disabled all minimizers. You need at least one."); + } + + if (Model == ModelID::ModelIDs::NotSet) + { + Logger::Write(LoggingLevel::Default, + "Your Model parameter does not match with the " + "implemented Models."); + ShowInputError(); + return false; + } + if (firstline == 0 or lastline == 0) + { + Logger::Write(LoggingLevel::Default, "firstline or lastline not set."); + return false; + } + if (firstline < 0 or lastline < 0) + { + Logger::Write(LoggingLevel::Default, + "Invalid input for first- or lastline."); + return false; + } + if (firstline > lastline) + { + Logger::Write(LoggingLevel::Default, "lastline is smaller then firstline."); + return false; + } + if (templow >= temphigh) + { + Logger::Write(LoggingLevel::Default, + "Invalid temperature choice. Thigh has to be > 0 GeV."); + return false; + } + if ((UserDefined_vwall != -1 and UserDefined_vwall != -2) and + (UserDefined_vwall <= 0 or UserDefined_vwall > 1)) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for vwall."); + return false; + } + if (UseMultiStepPTMode > 3 or UseMultiStepPTMode < -1) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for MultiStepPTMode."); + return false; + } + if (num_check_pts < 0) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for num_check_pts."); + return false; + } + if (CheckEWSymmetryRestoration > 2 or CheckEWSymmetryRestoration < 0) + { + Logger::Write(LoggingLevel::Default, + "Invalid choice for CheckEWSymmetryRestoration."); + return false; + } + if (CheckNLOStability < 0 or CheckNLOStability > 1) + { + Logger::Write(LoggingLevel::Default, + "Invalid choice for CheckNLOStability."); + return false; + } + if (perc_prbl < 0 or perc_prbl > 1) + { + Logger::Write(LoggingLevel::Default, + "Invalid false vacuum fraction for determination of " + "percolation temperature given."); + return false; + } + if (compl_prbl < 0 or compl_prbl > 1) + { + Logger::Write(LoggingLevel::Default, + "Invalid false vacuum fraction for determination of " + "completion temperature given."); + return false; + } + + return true; +} + +CLIOptions::CLIOptions(const BSMPT::parser &argparser) +{ + std::stringstream ss; + argparser.check_required_parameters(); + + // required arguments + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + inputfile = argparser.get_value("input"); + outputfile = argparser.get_value("output"); + firstline = argparser.get_value("firstline"); + lastline = argparser.get_value("lastline"); + + // optional arguments + try + { + temphigh = argparser.get_value("thigh"); + } + catch (BSMPT::parserException &) + { + ss << "--thigh not set, using default value: " << temphigh << "\n"; + } + + std::string GSLhelp = Minimizer::UseGSLDefault ? "true" : "false"; + std::string CMAEShelp = Minimizer::UseLibCMAESDefault ? "true" : "false"; + std::string NLoptHelp = Minimizer::UseNLoptDefault ? "true" : "false"; + try + { + UseGSL = (argparser.get_value("usegsl") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usegsl not set, using default value: " << GSLhelp << "\n"; + } + + try + { + UseCMAES = (argparser.get_value("usecmaes") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usecmaes not set, using default value: " << CMAEShelp << "\n"; + } + + try + { + UseNLopt = (argparser.get_value("usenlopt") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usenlopt not set, using default value: " << NLoptHelp << "\n"; + } + + try + { + UseMultithreading = (argparser.get_value("usemultithreading") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usemultithreading not set, using default value: false\n"; + } + + // UseMultiStepPTMode + try + { + auto multistepPT_string = argparser.get_value("multistepmode"); + if (multistepPT_string == "default") + { + UseMultiStepPTMode = -1; + } + else if (multistepPT_string == "auto") + { + UseMultiStepPTMode = 3; + } + else + { + UseMultiStepPTMode = std::stoi(multistepPT_string); + } + } + catch (BSMPT::parserException &) + { + ss << "--multistepmode not set, using default value: default\n"; + } + + try + { + num_check_pts = argparser.get_value("num_pts"); + } + catch (BSMPT::parserException &) + { + ss << "--num_check_pts not set, using default value: " << num_check_pts + << "\n"; + } + + try + { + UserDefined_vwall = argparser.get_value("vwall"); + } + catch (BSMPT::parserException &) + { + ss << "--vwall not set, using default value: " << UserDefined_vwall << "\n"; + } + + try + { + perc_prbl = argparser.get_value("perc_prbl"); + } + catch (BSMPT::parserException &) + { + ss << "--perc_prbl not set, using default value: " << perc_prbl << "\n"; + } + + try + { + compl_prbl = argparser.get_value("compl_prbl"); + } + catch (BSMPT::parserException &) + { + ss << "--compl_prbl not set, using default value: " << compl_prbl << "\n"; + } + + // CheckNLOStability + try + { + auto nlo_string = argparser.get_value("checknlo"); + if (nlo_string == "on") + { + CheckNLOStability = 1; + } + else if (nlo_string == "off") + { + CheckNLOStability = 0; + } + } + catch (BSMPT::parserException &) + { + ss << "--checknlo not set, using default value: on\n"; + } + + // CheckEWSymmetryRestoration + try + { + auto ewsr_string = argparser.get_value("checkewsr"); + if (ewsr_string == "on") + { + CheckEWSymmetryRestoration = 1; + } + else if (ewsr_string == "off") + { + CheckEWSymmetryRestoration = 0; + } + else if (ewsr_string == "keep_bfb") + { + CheckEWSymmetryRestoration = 2; + } + else if (ewsr_string == "keep_ewsr") + { + CheckEWSymmetryRestoration = 3; + } + } + catch (BSMPT::parserException &) + { + ss << "--checkewsr not set, using default value: on\n"; + } + + try + { + MaxPathIntegrations = argparser.get_value("maxpathintegrations"); + } + catch (BSMPT::parserException &) + { + ss << "--maxpathintegrations not set, using default value: " + << MaxPathIntegrations << "\n"; + } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); + + Logger::Write(LoggingLevel::ProgDetailed, ss.str()); +} + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser(true); + argparser.add_argument("help", "shows this menu", false); + argparser.add_argument("model", "[*] model name", true); + argparser.add_argument("input", "[*] input file (in tsv format)", true); + argparser.add_argument("output", "[*] output file (in tsv format)", true); + argparser.add_argument( + "firstline", "[*] line number of first line in input file", true); + argparser.add_subtext(" (expects line 1 to be a legend)"); + argparser.add_argument( + "lastline", "[*] line number of last line in input file", true); + argparser.add_argument("thigh", "high temperature [GeV]", "300", false); + argparser.add_argument( + "multistepmode", "multi-step PT mode", "default", false); + argparser.add_subtext("default: default mode"); + argparser.add_subtext("0: single-step PT mode"); + argparser.add_subtext(">0 for multi-step PT modes:"); + argparser.add_subtext("1: tracing coverage"); + argparser.add_subtext("2: global minimum tracing coverage"); + argparser.add_subtext("auto: automatic mode"); + argparser.add_argument( + "num_pts", "intermediate grid-size for default mode", "10", false); + argparser.add_argument( + "vwall", "wall velocity: >0 user defined", "0.95", false); + argparser.add_subtext("-1: approximation"); + argparser.add_subtext("-2: upper bound"); + argparser.add_argument( + "perc_prbl", "false vacuum fraction for percolation", "0.71", false); + argparser.add_argument( + "compl_prbl", "false vacuum fraction for completion", "0.01", false); + argparser.add_argument("checknlo", "check for NLO stability", "on", false); + argparser.add_subtext("on: only keep NLO stable points"); + argparser.add_subtext("off: check disabled"); + argparser.add_argument( + "checkewsr", "check for EWSR at high temperature", "on", false); + argparser.add_subtext("on: perform check and add info"); + argparser.add_subtext("keep_bfb: only keep BFB points"); + argparser.add_subtext("keep_ewsr: only keep EWSR points"); + argparser.add_subtext("off: check disabled"); + + argparser.add_argument("maxpathintegrations", + "number of solutions of 1D equation =", + "7", + false); + argparser.add_subtext("number of path deformations + 1"); + + std::string GSLhelp = Minimizer::UseGSLDefault ? "true" : "false"; + std::string CMAEShelp = Minimizer::UseLibCMAESDefault ? "true" : "false"; + std::string NLoptHelp = Minimizer::UseNLoptDefault ? "true" : "false"; + + argparser.add_argument( + "usegsl", "use GSL library for minimization", GSLhelp, false); + argparser.add_argument( + "usecmaes", "use CMAES library for minimization", CMAEShelp, false); + argparser.add_argument( + "usenlopt", "use NLopt library for minimization", NLoptHelp, false); + argparser.add_argument("usemultithreading", + "enable multi-threading for minimizers", + "false", + false); + argparser.add_argument( + "json", "use a json file instead of cli parameters", false); + + std::stringstream ss; + ss << "CalcTemps calculates characteristic temperatures for phase " + "transitions\nit is called " + "by\n\n\t./bin/CalcTemps model input output firstline " + "lastline\n\nor " + "with arguments\n\n\t./bin/CalcTemps [arguments]\n\nwith the " + "following arguments, ([*] are required arguments, others " + "are optional):\n"; + argparser.set_help_header(ss.str()); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--firstline=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--lastline=" + std::string(argv[5])); + } + } + return arguments; +} \ No newline at end of file diff --git a/src/prog/CalculateEWBG.cpp b/src/prog/CalculateEWBG.cpp index 472f6758..8d11e56c 100644 --- a/src/prog/CalculateEWBG.cpp +++ b/src/prog/CalculateEWBG.cpp @@ -18,6 +18,7 @@ #include // for Class_Pot... #include #include +#include #include #include // for max, copy #include @@ -43,15 +44,23 @@ struct CLIOptions int WhichMinimizer{Minimizer::WhichMinimizerDefault}; bool UseMultithreading{true}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; }; +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + int main(int argc, char *argv[]) try { - const CLIOptions args(argc, argv); + const auto SMConstants = GetSMConstants(); + + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); if (not args.good()) { @@ -59,7 +68,7 @@ try } // Init: Interface Class for the different transport methods - Baryo::CalculateEtaInterface EtaInterface(args.ConfigFile); + Baryo::CalculateEtaInterface EtaInterface(args.ConfigFile, SMConstants); int linecounter = 1; std::ifstream infile(args.InputFile); @@ -78,7 +87,8 @@ try } std::string linestr; std::shared_ptr modelPointer = ModelID::FChoose( - args.Model); // Declare the model pointer with the necessary parameters + args.Model, + SMConstants); // Declare the model pointer with the necessary parameters std::vector etaLegend = EtaInterface.legend(); // Declare the vector for the PTFinder algorithm // Begin: Input Read @@ -239,160 +249,64 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) +CLIOptions::CLIOptions(const BSMPT::parser &argparser) { + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + FirstLine = argparser.get_value("firstLine"); + LastLine = argparser.get_value("lastLine"); + ConfigFile = argparser.get_value("config"); + try + { + TerminalOutput = (argparser.get_value("terminalOutput") == "y"); + } + catch (BSMPT::parserException &) + { + TerminalOutput = false; + } - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); + try + { + UseGSL = argparser.get_value("useGSL"); + } + catch (BSMPT::parserException &) + { + } - if (argc < 7 or args.at(0) == "--help") + try + { + UseCMAES = argparser.get_value("useCMAES"); + } + catch (BSMPT::parserException &) { - int SizeOfFirstColumn = std::string("--TerminalOutput= ").size(); - std::stringstream ss; - ss << "CalculateEWBG calculates the strength of the electroweak " - "baryogenesis" - << std::endl - << "It is called either by " << std::endl - << "./CalculateEWBG model input output FirstLine LastLine ConfigFile" - << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to investigate" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--output=" - << "The output file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--FirstLine=" - << "The first line in the input file to calculate the EWPT. Expects " - "line 1 to be a legend." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--LastLine=" - << "The last line in the input file to calculate the EWPT." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--config=" - << "The EWBG config file." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--TerminalOutput=" - << "y/n Turns on additional information in the terminal during the " - "calculation." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--vw=" - << "Wall velocity for the EWBG calculation. Default value of 0.1." - << std::endl; - std::string GSLhelp{"--UseGSL="}; - GSLhelp += Minimizer::UseGSLDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << GSLhelp - << "Use the GSL library to minimize the effective potential" - << std::endl; - std::string CMAEShelp{"--UseCMAES="}; - CMAEShelp += Minimizer::UseLibCMAESDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << CMAEShelp - << "Use the CMAES library to minimize the effective potential" - << std::endl; - std::string NLoptHelp{"--UseNLopt="}; - NLoptHelp += Minimizer::UseNLoptDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << NLoptHelp - << "Use the NLopt library to minimize the effective potential" - << std::endl; - ss << std::setw(SizeOfFirstColumn) << std::left - << "--UseMultithreading = true" - << "Enables/Disables multi threading for the minimizers" << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); } - if (args.size() > 0 and args.at(0) == "--help") + try { - throw int{0}; + UseNLopt = argparser.get_value("useNLopt"); } - else if (argc < 7) + catch (BSMPT::parserException &) { - throw std::runtime_error("Too few arguments."); } - std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusedArgs; - if (UsePrefix) + try { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - } - else if (StringStartsWith(el, "--output=")) - { - OutputFile = arg.substr(std::string("--output=").size()); - } - else if (StringStartsWith(el, "--firstline=")) - { - FirstLine = std::stoi(el.substr(std::string("--firstline=").size())); - } - else if (StringStartsWith(el, "--lastline=")) - { - LastLine = std::stoi(el.substr(std::string("--lastline=").size())); - } - else if (StringStartsWith(el, "--terminaloutput=")) - { - TerminalOutput = - el.substr(std::string("--terminaloutput=").size()) == "y"; - } - else if (StringStartsWith(el, "--vw=")) - { - vw = std::stod(el.substr(std::string("--vw=").size())); - } - else if (StringStartsWith(el, "--config=")) - { - ConfigFile = arg.substr(std::string("--config=").size()); - } - else if (StringStartsWith(el, "--usegsl=")) - { - UseGSL = el.substr(std::string("--usegsl=").size()) == "true"; - } - else if (StringStartsWith(el, "--usecmaes=")) - { - UseCMAES = el.substr(std::string("--usecmaes=").size()) == "true"; - } - else if (StringStartsWith(el, "--usenlopt=")) - { - UseNLopt = el.substr(std::string("--usenlopt=").size()) == "true"; - } - else if (StringStartsWith(el, "--usemultithreading=")) - { - UseMultithreading = - el.substr(std::string("--usemultithreading=").size()) == "true"; - } - else - { - UnusedArgs.push_back(el); - } - } - WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); - SetLogger(UnusedArgs); + UseMultithreading = argparser.get_value("useMultithreading"); } - else + catch (BSMPT::parserException &) + { + } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); + + try + { + vw = std::stod(argparser.get_value("vw")); + } + catch (BSMPT::parserException &) { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - OutputFile = args.at(2); - FirstLine = std::stoi(args.at(3)); - LastLine = std::stoi(args.at(4)); - ConfigFile = args.at(5); - if (argc == 8) - { - std::string s7 = argv[6]; - TerminalOutput = ("y" == std::string(args.at(6))); - } } } @@ -401,17 +315,17 @@ bool CLIOptions::good() const if (UseGSL and not Minimizer::UseGSLDefault) { throw std::runtime_error( - "You set --UseGSL=true but GSL was not found during compilation."); + "You set --useGSL=true but GSL was not found during compilation."); } if (UseCMAES and not Minimizer::UseLibCMAESDefault) { throw std::runtime_error( - "You set --UseCMAES=true but CMAES was not found during compilation."); + "You set --useCMAES=true but CMAES was not found during compilation."); } if (UseNLopt and not Minimizer::UseNLoptDefault) { throw std::runtime_error( - "You set --UseNLopt=true but NLopt was not found during compilation."); + "You set --useNLopt=true but NLopt was not found during compilation."); } if (WhichMinimizer == 0) { @@ -443,3 +357,90 @@ bool CLIOptions::good() const return true; } + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument("output", "The output file in tsv format.", true); + argparser.add_argument("firstLine", + "The first line in the input file to calculate the " + "EWPT. Expects line 1 to be a legend.", + true); + argparser.add_argument( + "lastLine", + "The last line in the input file to calculate the EWPT.", + true); + argparser.add_argument("config", "The EWBG config file.", true); + argparser.add_argument( + "terminalOutput", + "y/n Turns on additional information in the terminal during " + "the calculation.", + false); + + argparser.add_argument( + "vw", + "Wall velocity for the EWBG calculation. Default value of 0.1.", + false); + + std::stringstream ss; + ss << "CalculateEWBG calculates the strength of the electroweak " + "baryogenesis" + << std::endl + << "It is called either by " << std::endl + << "./CalculateEWBG model input output FirstLine LastLine ConfigFile" + << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + argparser.enable_minimizer_options(); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--firstLine=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--lastLine=" + std::string(argv[5])); + } + if (argc >= 7) + { + arguments.emplace_back("--config=" + std::string(argv[6])); + } + } + return arguments; +} diff --git a/src/prog/Kfactor_grid.cpp b/src/prog/Kfactor_grid.cpp index 3e316de3..6ec23834 100644 --- a/src/prog/Kfactor_grid.cpp +++ b/src/prog/Kfactor_grid.cpp @@ -1,5 +1,6 @@ // Copyright (C) 2020 Philipp Basler, Margarete Mühlleitner and Jonas -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -111,7 +112,7 @@ void CreateKtildeInterpolationData() outputNormalisation << "const std::vector msquaredTsquared{"; //<< - //msquaredTsquared.size() + // msquaredTsquared.size() //<< "] = {"; for (std::size_t i = 0; i < msquaredTsquared.size(); i++) { @@ -133,7 +134,7 @@ void CreateKtildeInterpolationData() outputNormalisation << "const std::vector KtildeNormFermion_grid{"; //<< - //KtildeNormFermion.size() + // KtildeNormFermion.size() //<< "] = {"; for (std::size_t i = 0; i < KtildeNormFermion.size(); i++) { diff --git a/src/prog/MinimaTracer.cpp b/src/prog/MinimaTracer.cpp new file mode 100644 index 00000000..32140377 --- /dev/null +++ b/src/prog/MinimaTracer.cpp @@ -0,0 +1,571 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and +// Jonas Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file + * This program traces all minima in a temperature range + * + */ + +#include +#include // MinimumTracer +#include // for Class_Potential_Origin +#include +#include // TransitionTracer +#include +#include +#include +#include // for copy, max +#include +#include +#include +#include // for shared_ptr, __shared_... +#include +#include // for atoi, EXIT_FAILURE +#include // for string, operator<< +#include // for pair +#include // for vector + +using namespace std; +using namespace BSMPT; + +struct CLIOptions +{ + BSMPT::ModelID::ModelIDs Model{ModelID::ModelIDs::NotSet}; + int firstline{0}, lastline{0}; + std::string inputfile, outputfile; + double templow{0}, temphigh{300}; + bool UseGSL{Minimizer::UseGSLDefault}; + bool UseCMAES{Minimizer::UseLibCMAESDefault}; + bool UseNLopt{Minimizer::UseNLoptDefault}; + int WhichMinimizer{Minimizer::WhichMinimizerDefault}; + bool UseMultithreading{false}; + int UseMultiStepPTMode{-1}; + int CheckEWSymmetryRestoration{1}; + int num_check_pts{10}; + + CLIOptions(const BSMPT::parser &argparser); + bool good() const; +}; + +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + +int main(int argc, char *argv[]) +try +{ + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); + if (not args.good()) + { + return EXIT_FAILURE; + } + + std::ifstream infile(args.inputfile); + if (!infile.good()) + { + Logger::Write(LoggingLevel::Default, + "Input file " + args.inputfile + " not found "); + return EXIT_FAILURE; + } + + Logger::Write(LoggingLevel::ProgDetailed, "Found file"); + + std::shared_ptr modelPointer = + ModelID::FChoose(args.Model, SMConstants); + + Logger::Write(LoggingLevel::ProgDetailed, "Created modelpointer "); + + std::string linestr, linestr_store; + int linecounter = 1, filecounter = 1; + + while (getline(infile, linestr)) + { + if (linecounter == 1) linestr_store = linestr; + + if (linecounter > args.lastline) break; + + if (linecounter >= args.firstline and linecounter <= args.lastline) + { + Logger::Write(LoggingLevel::ProgDetailed, + "Currently at line " + std::to_string(linecounter)); + + std::string outfilename = + args.outputfile + "_" + std::to_string(filecounter) + ".tsv"; + Logger::Write(LoggingLevel::ProgDetailed, + "Creating outfile with name " + outfilename); + std::ofstream outfile(outfilename); + if (!outfile.good()) + { + Logger::Write(LoggingLevel::Default, + "Can not create file " + outfilename); + return EXIT_FAILURE; + } + + modelPointer->setUseIndexCol(linestr_store); + + std::pair, std::vector> parameters = + modelPointer->initModel(linestr); + + if (args.firstline == args.lastline) + { + modelPointer->write(); + } + + auto start = std::chrono::high_resolution_clock::now(); + + std::shared_ptr MinTracer(new MinimumTracer( + modelPointer, args.WhichMinimizer, args.UseMultithreading)); + + // NLO stability check + bool nlostable = modelPointer->CheckNLOVEV( + MinTracer->ConvertToVEVDim(MinTracer->GetGlobalMinimum(0))); + StatusNLOStability status_nlostable = + MinTracer->GetStatusNLOVEV(nlostable); + Logger::Write(LoggingLevel::ProgDetailed, + "Status of NLO stability check is: " + + StatusNLOStabilityToString.at(status_nlostable)); + + // EWSR check + double EWSymmetryRestoration_status = 0; + StatusEWSR status_ewsr = StatusEWSR::Off; + + if (args.CheckEWSymmetryRestoration > 0) + { + EWSymmetryRestoration_status = + MinTracer->IsThereEWSymmetryRestoration(); + status_ewsr = MinTracer->GetStatusEWSR(EWSymmetryRestoration_status); + } + else + { + Logger::Write(LoggingLevel::ProgDetailed, + "Check for EW symmetry restoration is disabled.\n"); + } + + // phase tracking + Logger::Write( + LoggingLevel::ProgDetailed, + "Track phases in between T_low = " + std::to_string(args.templow) + + " and T_high = " + std::to_string(args.temphigh)); + + bool do_only_tracing = true; + + Vacuum vac(args.templow, + args.temphigh, + MinTracer, + modelPointer, + args.UseMultiStepPTMode, + args.num_check_pts, + do_only_tracing); + + Logger::Write(LoggingLevel::ProgDetailed, + "Found and traced " + + std::to_string(vac.PhasesList.size()) + + " minima with status = " + + StatusTracingToString.at(vac.status_vacuum) + + ".\n-------------------------------"); + + // prepare legend + std::vector LegendMinima; + LegendMinima.push_back("status_nlo_stability"); + LegendMinima.push_back("status_ewsr"); + LegendMinima.push_back("status_tracing"); + for (std::size_t i = 0; i < vac.PhasesList.size(); i++) + { + LegendMinima.push_back("Temp_" + std::to_string(i)); + for (std::size_t j = 0; j < modelPointer->get_nVEV(); j++) + { + LegendMinima.push_back(modelPointer->addLegendVEV().at(j).append( + "(Temp_" + std::to_string(i) + ")")); + } + LegendMinima.push_back("Veff(Temp_" + std::to_string(i) + ")"); + } + LegendMinima.push_back("runtime"); + outfile << linestr_store << sep << modelPointer->addLegendCT() << sep + << LegendMinima << std::endl; + + std::size_t length = 0; + for (std::size_t j = 0; j < vac.PhasesList.size(); j++) + { + if (length == 0) + { + length = vac.PhasesList.at(j).MinimumPhaseVector.size(); + } + else if (length < vac.PhasesList.at(j).MinimumPhaseVector.size()) + { + length = vac.PhasesList.at(j).MinimumPhaseVector.size(); + } + } + + if (length == 0) + { + outfile << std::setprecision(16); + outfile << linestr; + outfile << sep << parameters.second; + outfile << sep << status_nlostable; + outfile << sep << status_ewsr; + outfile << sep << vac.status_vacuum; + auto time = std::chrono::duration_cast( + std::chrono::high_resolution_clock::now() - start) + .count() / + 1000.; + + outfile << sep << time; + outfile << std::endl; + } + + for (std::size_t i = 0; i < length; i++) + { + outfile << std::setprecision(16); + outfile << linestr; + outfile << sep << parameters.second; + outfile << sep << status_nlostable; + outfile << sep << status_ewsr; + outfile << sep << vac.status_vacuum; + for (std::size_t j = 0; j < vac.PhasesList.size(); j++) + { + if (i < vac.PhasesList.at(j).MinimumPhaseVector.size()) + { + outfile << sep + << vac.PhasesList.at(j).MinimumPhaseVector.at(i).temp; + outfile << sep + << vac.PhasesList.at(j).MinimumPhaseVector.at(i).point; + outfile << sep + << vac.PhasesList.at(j).MinimumPhaseVector.at(i).potential; + } + else + { + std::vector error_phase_ended( + 2 + modelPointer->get_nVEV(), "nan"); + outfile << sep << error_phase_ended; + } + } + + auto time = std::chrono::duration_cast( + std::chrono::high_resolution_clock::now() - start) + .count() / + 1000.; + + outfile << sep << time; + outfile << std::endl; + } + + filecounter++; + outfile.close(); + + auto time = std::chrono::duration_cast( + std::chrono::high_resolution_clock::now() - start) + .count() / + 1000.; + + BSMPT::Logger::Write(BSMPT::LoggingLevel::ProgDetailed, + "Took\t" + std::to_string(time) + " seconds.\n"); + } + linecounter++; + if (infile.eof()) break; + } + return EXIT_SUCCESS; +} +catch (int) +{ + return EXIT_SUCCESS; +} +catch (exception &e) +{ + Logger::Write(LoggingLevel::Default, e.what()); + return EXIT_FAILURE; +} + +bool CLIOptions::good() const +{ + if (UseGSL and not Minimizer::UseGSLDefault) + { + throw std::runtime_error( + "You set --UseGSL=true but GSL was not found during compilation."); + } + if (UseCMAES and not Minimizer::UseLibCMAESDefault) + { + throw std::runtime_error( + "You set --UseCMAES=true but CMAES was not found during compilation."); + } + if (UseNLopt and not Minimizer::UseNLoptDefault) + { + throw std::runtime_error( + "You set --UseNLopt=true but NLopt was not found during compilation."); + } + if (WhichMinimizer == 0) + { + throw std::runtime_error( + "You disabled all minimizers. You need at least one."); + } + + if (Model == ModelID::ModelIDs::NotSet) + { + Logger::Write( + LoggingLevel::Default, + "Your Model parameter does not match with the implemented Models."); + ShowInputError(); + return false; + } + if (firstline == 0 or lastline == 0) + { + Logger::Write(LoggingLevel::Default, "firstline or lastline not set."); + return false; + } + if (firstline < 0 or lastline < 0) + { + Logger::Write(LoggingLevel::Default, + "Invalid input for first- or lastline."); + return false; + } + if (firstline > lastline) + { + Logger::Write(LoggingLevel::Default, "lastline is smaller then firstline."); + return false; + } + if (templow >= temphigh) + { + Logger::Write(LoggingLevel::Default, + "Invalid temperature choice. Thigh has to be > 0 GeV."); + return false; + } + if (UseMultiStepPTMode > 3 or UseMultiStepPTMode < -1) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for MultiStepPTMode."); + return false; + } + if (num_check_pts < 0) + { + Logger::Write(LoggingLevel::Default, "Invalid choice for num_check_pts."); + return false; + } + if (CheckEWSymmetryRestoration > 2 or CheckEWSymmetryRestoration < 0) + { + Logger::Write(LoggingLevel::Default, + "Invalid choice for CheckEWSymmetryRestoration."); + return false; + } + + return true; +} + +CLIOptions::CLIOptions(const BSMPT::parser &argparser) +{ + std::stringstream ss; + argparser.check_required_parameters(); + + // required arguments + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + inputfile = argparser.get_value("input"); + outputfile = argparser.get_value("output"); + firstline = argparser.get_value("firstline"); + lastline = argparser.get_value("lastline"); + + // optional arguments + try + { + temphigh = argparser.get_value("thigh"); + } + catch (BSMPT::parserException &) + { + ss << "--thigh not set, using default value: " << temphigh << "\n"; + } + + std::string GSLhelp = Minimizer::UseGSLDefault ? "true" : "false"; + std::string CMAEShelp = Minimizer::UseLibCMAESDefault ? "true" : "false"; + std::string NLoptHelp = Minimizer::UseNLoptDefault ? "true" : "false"; + try + { + UseGSL = (argparser.get_value("usegsl") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usegsl not set, using default value: " << GSLhelp << "\n"; + } + + try + { + UseCMAES = (argparser.get_value("usecmaes") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usecmaes not set, using default value: " << CMAEShelp << "\n"; + } + + try + { + UseNLopt = (argparser.get_value("usenlopt") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usenlopt not set, using default value: " << NLoptHelp << "\n"; + } + + try + { + UseMultithreading = (argparser.get_value("usemultithreading") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--usemultithreading not set, using default value: false\n"; + } + + // UseMultiStepPTMode + try + { + auto multistepPT_string = argparser.get_value("multistepmode"); + if (multistepPT_string == "default") + { + UseMultiStepPTMode = -1; + } + else if (multistepPT_string == "auto") + { + UseMultiStepPTMode = 3; + } + else + { + UseMultiStepPTMode = std::stoi(multistepPT_string); + } + } + catch (BSMPT::parserException &) + { + ss << "--multistepmode not set, using default value: default\n"; + } + + try + { + num_check_pts = argparser.get_value("num_pts"); + } + catch (BSMPT::parserException &) + { + ss << "--num_check_pts not set, using default value: " << num_check_pts + << "\n"; + } + + // CheckEWSymmetryRestoration + try + { + auto ewsr_string = argparser.get_value("checkewsr"); + if (ewsr_string == "on") + { + CheckEWSymmetryRestoration = 1; + } + else if (ewsr_string == "off") + { + CheckEWSymmetryRestoration = 0; + } + } + catch (BSMPT::parserException &) + { + ss << "--checkewsr not set, using default value: on\n"; + } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); + + Logger::Write(LoggingLevel::ProgDetailed, ss.str()); +} + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser(true); + argparser.add_argument("help", "shows this menu", false); + argparser.add_argument("model", "[*] model name", true); + argparser.add_argument("input", "[*] input file (in tsv format)", true); + argparser.add_argument("output", "[*] output file (in tsv format)", true); + argparser.add_argument( + "firstline", "[*] line number of first line in input file", true); + argparser.add_subtext("(expects line 1 to be a legend)"); + argparser.add_argument( + "lastline", "[*] line number of last line in input file", true); + argparser.add_argument("thigh", "high temperature [GeV]", "300", false); + argparser.add_argument( + "multistepmode", "multi-step PT mode", "default", false); + argparser.add_subtext("default: default mode"); + argparser.add_subtext("0: single-step PT mode"); + argparser.add_subtext(">0 for multi-step PT modes:"); + argparser.add_subtext("1: tracing coverage"); + argparser.add_subtext("2: global minimum tracing coverage"); + argparser.add_subtext("auto: automatic mode"); + argparser.add_argument( + "num_pts", "intermediate grid-size for default mode", "10", false); + argparser.add_argument( + "checkewsr", "check for EWSR at high temperature", "on", false); + argparser.add_subtext("on: perform check"); + argparser.add_subtext("off: check disabled"); + + std::string GSLhelp = Minimizer::UseGSLDefault ? "true" : "false"; + std::string CMAEShelp = Minimizer::UseLibCMAESDefault ? "true" : "false"; + std::string NLoptHelp = Minimizer::UseNLoptDefault ? "true" : "false"; + + argparser.add_argument( + "usegsl", "use GSL library for minimization", GSLhelp, false); + argparser.add_argument( + "usecmaes", "use CMAES library for minimization", CMAEShelp, false); + argparser.add_argument( + "usenlopt", "use NLopt library for minimization", NLoptHelp, false); + argparser.add_argument("usemultithreading", + "enable multi-threading for minimizers", + "false", + false); + argparser.add_argument( + "json", "use a json file instead of cli parameters", false); + + std::stringstream ss; + ss << "MinimaTracer traces phases in T = [0, Thigh] GeV\nit is called " + "by\n\n\t./bin/MinimaTracer model input output firstline " + "lastline\n\nor " + "with arguments\n\n\t./bin/MinimaTracer [arguments]\n\nwith the " + "following arguments, ([*] are required arguments, others " + "are optional):\n"; + argparser.set_help_header(ss.str()); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--firstline=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--lastline=" + std::string(argv[5])); + } + } + return arguments; +} \ No newline at end of file diff --git a/src/prog/NLOVEV.cpp b/src/prog/NLOVEV.cpp index 3636c862..8cd51f77 100644 --- a/src/prog/NLOVEV.cpp +++ b/src/prog/NLOVEV.cpp @@ -16,6 +16,7 @@ #include // for Class_Potential_Origin #include #include +#include #include #include // for copy, max #include @@ -38,16 +39,23 @@ struct CLIOptions bool UseCMAES{Minimizer::UseLibCMAESDefault}; bool UseNLopt{Minimizer::UseNLoptDefault}; int WhichMinimizer{Minimizer::WhichMinimizerDefault}; + bool UseMultithreading{true}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; }; +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + int main(int argc, char *argv[]) try { - - const CLIOptions args(argc, argv); + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); if (not args.good()) { return EXIT_FAILURE; @@ -70,7 +78,7 @@ try std::string linestr; std::shared_ptr modelPointer = - ModelID::FChoose(args.Model); + ModelID::FChoose(args.Model, SMConstants); std::vector Check; while (true) { @@ -102,7 +110,8 @@ try 0, Check, modelPointer->get_vevTreeMin(), - args.WhichMinimizer); + args.WhichMinimizer, + args.UseMultithreading); std::vector solPot, solSym; solPot = modelPointer->MinimizeOrderVEV(sol); @@ -141,140 +150,22 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) -{ - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); - - if (argc < 6 or args.at(0) == "--help") - { - std::stringstream ss; - int SizeOfFirstColumn = std::string("--TerminalOutput= ").size(); - ss << "NLOVEV calculates the EW VEV at NLO" << std::endl - << "It is called either by " << std::endl - << "./NLOVEV model input output FirstLine LastLine" << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to investigate" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--output=" - << "The output file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--FirstLine=" - << "The first line in the input file to calculate the NLO EW " - "VEV. Expects line 1 to be a legend." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--LastLine=" - << "The last line in the input file to calculate the NLO EW VEV." - << std::endl; - std::string GSLhelp{"--UseGSL="}; - GSLhelp += Minimizer::UseGSLDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << GSLhelp - << "Use the GSL library to minimize the effective potential" - << std::endl; - std::string CMAEShelp{"--UseCMAES="}; - CMAEShelp += Minimizer::UseLibCMAESDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << CMAEShelp - << "Use the CMAES library to minimize the effective potential" - << std::endl; - std::string NLoptHelp{"--UseNLopt="}; - NLoptHelp += Minimizer::UseNLoptDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << NLoptHelp - << "Use the NLopt library to minimize the effective potential" - << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); - } - - if (args.size() > 0 and args.at(0) == "--help") - { - throw int{0}; - } - else if (argc < 6) - { - throw std::runtime_error("Too few arguments."); - } - - const std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusedArgs; - if (UsePrefix) - { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - } - else if (StringStartsWith(el, "--output=")) - { - OutputFile = arg.substr(std::string("--output=").size()); - } - else if (StringStartsWith(el, "--firstline=")) - { - FirstLine = std::stoi(el.substr(std::string("--firstline=").size())); - } - else if (StringStartsWith(el, "--lastline=")) - { - LastLine = std::stoi(el.substr(std::string("--lastline=").size())); - } - else if (StringStartsWith(el, "--usegsl=")) - { - UseGSL = el.substr(std::string("--usegsl=").size()) == "true"; - } - else if (StringStartsWith(el, "--usecmaes=")) - { - UseCMAES = el.substr(std::string("--usecmaes=").size()) == "true"; - } - else if (StringStartsWith(el, "--usenlopt=")) - { - UseNLopt = el.substr(std::string("--usenlopt=").size()) == "true"; - } - else - { - UnusedArgs.push_back(el); - } - } - WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); - SetLogger(UnusedArgs); - } - else - { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - OutputFile = args.at(2); - FirstLine = std::stoi(args.at(3)); - LastLine = std::stoi(args.at(4)); - } -} - bool CLIOptions::good() const { if (UseGSL and not Minimizer::UseGSLDefault) { throw std::runtime_error( - "You set --UseGSL=true but GSL was not found during compilation."); + "You set --useGSL=true but GSL was not found during compilation."); } if (UseCMAES and not Minimizer::UseLibCMAESDefault) { throw std::runtime_error( - "You set --UseCMAES=true but CMAES was not found during compilation."); + "You set --useCMAES=true but CMAES was not found during compilation."); } if (UseNLopt and not Minimizer::UseNLoptDefault) { throw std::runtime_error( - "You set --UseNLopt=true but NLopt was not found during compilation."); + "You set --useNLopt=true but NLopt was not found during compilation."); } if (WhichMinimizer == 0) { @@ -301,3 +192,121 @@ bool CLIOptions::good() const } return true; } + +CLIOptions::CLIOptions(const BSMPT::parser &argparser) +{ + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + FirstLine = argparser.get_value("firstLine"); + LastLine = argparser.get_value("lastLine"); + + try + { + UseGSL = argparser.get_value("useGSL"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseCMAES = argparser.get_value("useCMAES"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseNLopt = argparser.get_value("useNLopt"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseMultithreading = argparser.get_value("useMultithreading"); + } + catch (BSMPT::parserException &) + { + } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); +} + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument("output", "The output file in tsv format.", true); + argparser.add_argument("firstLine", + "The first line in the input file to calculate the " + "EWPT. Expects line 1 to be a legend.", + true); + argparser.add_argument( + "lastLine", + "The last line in the input file to calculate the EWPT.", + true); + argparser.add_argument( + "terminalOutput", + "y/n Turns on additional information in the terminal during " + "the calculation.", + false); + + std::stringstream ss; + ss << "NLOVEV calculates the EW VEV at NLO" << std::endl + << "It is called either by " << std::endl + << "./NLOVEV model input output FirstLine LastLine" << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + argparser.enable_minimizer_options(); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--firstLine=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--lastLine=" + std::string(argv[5])); + } + } + return arguments; +} diff --git a/src/prog/PlotEWBG_nL.cpp b/src/prog/PlotEWBG_nL.cpp index 88d1ce76..f18af4ef 100644 --- a/src/prog/PlotEWBG_nL.cpp +++ b/src/prog/PlotEWBG_nL.cpp @@ -16,6 +16,7 @@ #include // for Class_Pot... #include #include +#include #include #include // for copy, max #include @@ -39,24 +40,32 @@ struct CLIOptions bool UseCMAES{Minimizer::UseLibCMAESDefault}; bool UseNLopt{Minimizer::UseNLoptDefault}; int WhichMinimizer{Minimizer::WhichMinimizerDefault}; + bool UseMultithreading{true}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; }; +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + int main(int argc, char *argv[]) try { - const CLIOptions args(argc, argv); + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); if (not args.good()) { return EXIT_FAILURE; } // Set up of BSMPT/Baryo Classes - Baryo::CalculateEtaInterface EtaInterface(args.ConfigFile); + Baryo::CalculateEtaInterface EtaInterface(args.ConfigFile, SMConstants); std::shared_ptr modelPointer = - ModelID::FChoose(args.Model); + ModelID::FChoose(args.Model, SMConstants); std::vector start, solPot; @@ -134,8 +143,12 @@ try std::vector vevsymmetricSolution, checksym, startpoint; for (std::size_t i = 0; i < modelPointer->get_nVEV(); i++) startpoint.push_back(0.5 * vcritical.at(i)); - vevsymmetricSolution = Minimizer::Minimize_gen_all( - modelPointer, TC + 1, checksym, startpoint, args.WhichMinimizer); + vevsymmetricSolution = Minimizer::Minimize_gen_all(modelPointer, + TC + 1, + checksym, + startpoint, + args.WhichMinimizer, + args.UseMultithreading); ///////////////////////////////////////////////////////////////////////////////// std::size_t nstep = 100; @@ -158,7 +171,7 @@ try "Starting setting the class instances", __FILE__, __LINE__); - BSMPT::Baryo::tau_source C_tau; + BSMPT::Baryo::tau_source C_tau(SMConstants); EtaInterface.set_transport_method( TransportMethod::tau); // setting to tau class bool botflag = true; @@ -209,165 +222,22 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) -{ - - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); - - if (argc < 7 or args.at(0) == "--help") - { - std::stringstream ss; - int SizeOfFirstColumn = std::string("--TerminalOutput= ").size(); - ss << "Calculation of the left-handed chemical potentials or " - "particle densities triggering the EW" - << " sphaleron transitions as a function of the wall distance z ." - << std::endl - << "It is called either by " << std::endl - << "./PlotEWBG_nL Model Inputfile Outputfile Line vw " - "EWBGConfigFile TerminalOutput(y/n)" - << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to investigate" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--output=" - << "The output file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--Line=" - << "The line with the given parameter point. Expects line 1 to " - "be a legend." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--config=" - << "The EWBG config file." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--TerminalOutput=" - << "y/n Turns on additional information in the terminal during " - "the calculation." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--vw=" - << "The wall velocity. Default value of 0.1." << std::endl; - std::string GSLhelp{"--UseGSL="}; - GSLhelp += Minimizer::UseGSLDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << GSLhelp - << "Use the GSL library to minimize the effective potential" - << std::endl; - std::string CMAEShelp{"--UseCMAES="}; - CMAEShelp += Minimizer::UseLibCMAESDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << CMAEShelp - << "Use the CMAES library to minimize the effective potential" - << std::endl; - std::string NLoptHelp{"--UseNLopt="}; - NLoptHelp += Minimizer::UseNLoptDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << NLoptHelp - << "Use the NLopt library to minimize the effective potential" - << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); - } - - if (args.size() > 0 and args.at(0) == "--help") - { - throw int{0}; - } - else if (argc < 7) - { - throw std::runtime_error("Too few arguments."); - } - - const std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusedArgs; - if (UsePrefix) - { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - } - else if (StringStartsWith(el, "--output=")) - { - OutputFile = arg.substr(std::string("--output=").size()); - } - else if (StringStartsWith(el, "--line=")) - { - Line = std::stoi(el.substr(std::string("--line=").size())); - } - else if (StringStartsWith(el, "--terminaloutput=")) - { - TerminalOutput = - el.substr(std::string("--terminaloutput=").size()) == "y"; - } - else if (StringStartsWith(el, "--vw=")) - { - vw = std::stod(el.substr(std::string("--vw=").size())); - } - else if (StringStartsWith(el, "--config=")) - { - ConfigFile = arg.substr(std::string("--config=").size()); - } - else if (StringStartsWith(el, "--usegsl=")) - { - UseGSL = el.substr(std::string("--usegsl=").size()) == "true"; - } - else if (StringStartsWith(el, "--usecmaes=")) - { - UseCMAES = el.substr(std::string("--usecmaes=").size()) == "true"; - } - else if (StringStartsWith(el, "--usenlopt=")) - { - UseNLopt = el.substr(std::string("--usenlopt=").size()) == "true"; - } - else - { - UnusedArgs.push_back(el); - } - } - WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); - SetLogger(UnusedArgs); - } - else - { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - OutputFile = args.at(2); - Line = std::stoi(args.at(3)); - vw = std::stod(args.at(4)); - ConfigFile = args.at(5); - if (argc == 8) - { - TerminalOutput = ("y" == std::string(args.at(6))); - } - } -} - bool CLIOptions::good() const { if (UseGSL and not Minimizer::UseGSLDefault) { throw std::runtime_error( - "You set --UseGSL=true but GSL was not found during compilation."); + "You set --useGSL=true but GSL was not found during compilation."); } if (UseCMAES and not Minimizer::UseLibCMAESDefault) { throw std::runtime_error( - "You set --UseCMAES=true but CMAES was not found during compilation."); + "You set --useCMAES=true but CMAES was not found during compilation."); } if (UseNLopt and not Minimizer::UseNLoptDefault) { throw std::runtime_error( - "You set --UseNLopt=true but NLopt was not found during compilation."); + "You set --useNLopt=true but NLopt was not found during compilation."); } if (WhichMinimizer == 0) { @@ -393,3 +263,141 @@ bool CLIOptions::good() const } return true; } + +CLIOptions::CLIOptions(const BSMPT::parser &argparser) +{ + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + Line = argparser.get_value("line"); + vw = argparser.get_value("vw"); + ConfigFile = argparser.get_value("config"); + try + { + TerminalOutput = (argparser.get_value("terminalOutput") == "y"); + } + catch (BSMPT::parserException &) + { + TerminalOutput = false; + } + + try + { + UseGSL = argparser.get_value("useGSL"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseCMAES = argparser.get_value("useCMAES"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseNLopt = argparser.get_value("useNLopt"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseMultithreading = argparser.get_value("useMultithreading"); + } + catch (BSMPT::parserException &) + { + } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); +} + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument("output", "The output file in tsv format.", true); + argparser.add_argument( + "line", + "The line with the given parameter point. Expects line 1 to " + "be a legend.", + true); + argparser.add_argument( + "vw", + "Wall velocity for the EWBG calculation. Default value of 0.1.", + true); + argparser.add_argument("config", "The EWBG config file.", true); + argparser.add_argument( + "terminalOutput", + "y/n Turns on additional information in the terminal during " + "the calculation.", + false); + + std::stringstream ss; + ss << "Calculation of the left-handed chemical potentials or " + "particle densities triggering the EW sphaleron transitions as a " + "function of the wall distance z ." + << std::endl + << "It is called either by " << std::endl + << "./PlotEWBG_nL Model Inputfile Outputfile Line vw " + "EWBGConfigFile" + << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + argparser.enable_minimizer_options(); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--line=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--vw=" + std::string(argv[5])); + } + if (argc >= 7) + { + arguments.emplace_back("--config=" + std::string(argv[6])); + } + } + return arguments; +} diff --git a/src/prog/PlotEWBG_vw.cpp b/src/prog/PlotEWBG_vw.cpp index d16ab4dc..63a2e887 100644 --- a/src/prog/PlotEWBG_vw.cpp +++ b/src/prog/PlotEWBG_vw.cpp @@ -15,6 +15,7 @@ #include // for Class_Pot... #include #include +#include #include #include // for copy, max #include @@ -37,25 +38,32 @@ struct CLIOptions bool UseCMAES{Minimizer::UseLibCMAESDefault}; bool UseNLopt{Minimizer::UseNLoptDefault}; int WhichMinimizer{Minimizer::WhichMinimizerDefault}; + bool UseMultithreading{true}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; }; +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); int main(int argc, char *argv[]) try { - const CLIOptions args(argc, argv); + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); if (not args.good()) { return EXIT_FAILURE; } // Set up of BSMPT/Baryo Classes - Baryo::CalculateEtaInterface EtaInterface(args.ConfigFile); + Baryo::CalculateEtaInterface EtaInterface(args.ConfigFile, SMConstants); std::shared_ptr modelPointer = - ModelID::FChoose(args.Model); + ModelID::FChoose(args.Model, SMConstants); std::ifstream infile(args.InputFile); if (!infile.good()) @@ -113,7 +121,8 @@ try // CALL: BSMPT-->Phasetransition if (args.TerminalOutput) Logger::Write(LoggingLevel::ProgDetailed, "PTFinder called..."); - auto EWPT = Minimizer::PTFinder_gen_all(modelPointer, 0, 300); + auto EWPT = Minimizer::PTFinder_gen_all( + modelPointer, 0, 300, args.WhichMinimizer, args.UseMultithreading); // SFOEWPT FOUND if (EWPT.StatusFlag == Minimizer::MinimizerStatus::SUCCESS and @@ -130,9 +139,13 @@ try std::vector vevsymmetricSolution, checksym, startpoint; for (std::size_t i = 0; i < modelPointer->get_nVEV(); i++) startpoint.push_back(0.5 * vcritical.at(i)); - vevsymmetricSolution = - Minimizer::Minimize_gen_all(modelPointer, TC + 1, checksym, startpoint); - double vw = 0; + vevsymmetricSolution = Minimizer::Minimize_gen_all(modelPointer, + TC + 1, + checksym, + startpoint, + args.WhichMinimizer, + args.UseMultithreading); + double vw = 0; if (args.TerminalOutput) Logger::Write(LoggingLevel::ProgDetailed, "Currently calculating vw:", @@ -172,161 +185,59 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) +CLIOptions::CLIOptions(const BSMPT::parser &argparser) { + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + Line = argparser.get_value("line"); + ConfigFile = argparser.get_value("config"); + vw_min = argparser.get_value("vw_min"); + vw_max = argparser.get_value("vw_max"); + vw_Stepsize = argparser.get_value("vw_stepsize"); + try + { + TerminalOutput = (argparser.get_value("terminalOutput") == "y"); + } + catch (BSMPT::parserException &) + { + TerminalOutput = false; + } - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); + try + { + UseGSL = argparser.get_value("useGSL"); + } + catch (BSMPT::parserException &) + { + } - if (argc < 9 or args.at(0) == "--help") + try + { + UseCMAES = argparser.get_value("useCMAES"); + } + catch (BSMPT::parserException &) { - std::stringstream ss; - int SizeOfFirstColumn = std::string("--TerminalOutput= ").size(); - ss << "PlotEWBG_vw calculates the EWBG for varying wall velocity " - "for a given parameter point." - << std::endl - << "It is called either by " << std::endl - << "./PlotEWBG_vw Model Inputfile Outputfile Line vwMin " - "vwStepsize vwMax EWBGConfigFile TerminalOutput(y/n)" - << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to investigate" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--output=" - << "The output file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--Line=" - << "The line with the given parameter point. Expects line 1 to " - "be a legend." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--config=" - << "The EWBG config file." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--TerminalOutput=" - << "y/n Turns on additional information in the terminal during " - "the calculation." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--vw_min=" - << "The minimum wall velocity." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--vw_max=" - << "The maximum wall velocity." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--vw_Stepsize=" - << "The stepsize to increase the wall velocity." << std::endl; - std::string GSLhelp{"--UseGSL="}; - GSLhelp += Minimizer::UseGSLDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << GSLhelp - << "Use the GSL library to minimize the effective potential" - << std::endl; - std::string CMAEShelp{"--UseCMAES="}; - CMAEShelp += Minimizer::UseLibCMAESDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << CMAEShelp - << "Use the CMAES library to minimize the effective potential" - << std::endl; - std::string NLoptHelp{"--UseNLopt="}; - NLoptHelp += Minimizer::UseNLoptDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << NLoptHelp - << "Use the NLopt library to minimize the effective potential" - << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); } - if (args.size() > 0 and args.at(0) == "--help") + try { - throw int{0}; + UseNLopt = argparser.get_value("useNLopt"); } - else if (argc < 9) + catch (BSMPT::parserException &) { - throw std::runtime_error("Too few arguments."); } - const std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusuedArgs; - if (UsePrefix) + try { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - } - else if (StringStartsWith(el, "--output=")) - { - OutputFile = arg.substr(std::string("--output=").size()); - } - else if (StringStartsWith(el, "--line=")) - { - Line = std::stoi(el.substr(std::string("--line=").size())); - } - else if (StringStartsWith(el, "--terminaloutput=")) - { - TerminalOutput = - el.substr(std::string("--terminaloutput=").size()) == "y"; - } - else if (StringStartsWith(el, "--vw_min=")) - { - vw_min = std::stod(el.substr(std::string("--vw_min=").size())); - } - else if (StringStartsWith(el, "--vw_max=")) - { - vw_max = std::stod(el.substr(std::string("--vw_max=").size())); - } - else if (StringStartsWith(el, "--vw_stepsize=")) - { - vw_Stepsize = - std::stod(el.substr(std::string("--vw_stepsize=").size())); - } - else if (StringStartsWith(el, "--config=")) - { - ConfigFile = arg.substr(std::string("--config=").size()); - } - else if (StringStartsWith(el, "--usegsl=")) - { - UseGSL = el.substr(std::string("--usegsl=").size()) == "true"; - } - else if (StringStartsWith(el, "--usecmaes=")) - { - UseCMAES = el.substr(std::string("--usecmaes=").size()) == "true"; - } - else if (StringStartsWith(el, "--usenlopt=")) - { - UseNLopt = el.substr(std::string("--usenlopt=").size()) == "true"; - } - else - { - UnusuedArgs.push_back(el); - } - } - WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); - SetLogger(UnusuedArgs); + UseMultithreading = argparser.get_value("useMultithreading"); } - else + catch (BSMPT::parserException &) { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - OutputFile = args.at(2); - Line = std::stoi(args.at(3)); - vw_min = std::stod(args.at(4)); - vw_Stepsize = std::stod(args.at(5)); - vw_max = std::stod(args.at(6)); - ConfigFile = args.at(7); - if (argc == 10) - { - TerminalOutput = ("y" == std::string(args[8])); - } } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); } bool CLIOptions::good() const @@ -334,17 +245,17 @@ bool CLIOptions::good() const if (UseGSL and not Minimizer::UseGSLDefault) { throw std::runtime_error( - "You set --UseGSL=true but GSL was not found during compilation."); + "You set --useGSL=true but GSL was not found during compilation."); } if (UseCMAES and not Minimizer::UseLibCMAESDefault) { throw std::runtime_error( - "You set --UseCMAES=true but CMAES was not found during compilation."); + "You set --useCMAES=true but CMAES was not found during compilation."); } if (UseNLopt and not Minimizer::UseNLoptDefault) { throw std::runtime_error( - "You set --UseNLopt=true but NLopt was not found during compilation."); + "You set --useNLopt=true but NLopt was not found during compilation."); } if (WhichMinimizer == 0) { @@ -380,3 +291,97 @@ bool CLIOptions::good() const return true; } + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument("output", "The output file in tsv format.", true); + argparser.add_argument( + "line", + "The line with the given parameter point. Expects line 1 to " + "be a legend.", + true); + argparser.add_argument("config", "The EWBG config file.", true); + + argparser.add_argument("vw_min", "The minimum wall velocity.", true); + argparser.add_argument("vw_max", "The maximum wall velocity.", true); + argparser.add_argument( + "vw_stepsize", "The stepsize to increase the wall velocity.", true); + + argparser.add_argument( + "terminalOutput", + "y/n Turns on additional information in the terminal during " + "the calculation.", + false); + + std::stringstream ss; + ss << "PlotEWBG_vw calculates the EWBG for varying wall velocity " + "for a given parameter point." + << std::endl + << "It is called either by " << std::endl + << "./PlotEWBG_vw Model Inputfile Outputfile Line vwMin vwStepsize vwMax " + "EWBGConfigFile" + << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + argparser.enable_minimizer_options(); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--line=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--vw_min=" + std::string(argv[5])); + } + if (argc >= 7) + { + arguments.emplace_back("--vw_stepsize=" + std::string(argv[6])); + } + if (argc >= 8) + { + arguments.emplace_back("--vw_max=" + std::string(argv[7])); + } + if (argc >= 9) + { + arguments.emplace_back("--config=" + std::string(argv[8])); + } + } + return arguments; +} diff --git a/src/prog/PotPlotter.cpp b/src/prog/PotPlotter.cpp new file mode 100644 index 00000000..ec4d8da0 --- /dev/null +++ b/src/prog/PotPlotter.cpp @@ -0,0 +1,720 @@ +// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João +// Viana SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and +// Jonas Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file + * This program calculates Veff on a user-specified field grid + */ + +#include +#include // MinimumTracer +#include // for Class_Potential_Origin +#include +#include +#include +#include +#include // for copy, max +#include +#include // for operator<<, setprecision +#include +#include // for sqrt, abs +#include // for shared_ptr, __shared_... +#include // for atof, EXIT_FAILURE, atoi +#include // for getline, operator<< +#include // for pair +#include // for vector + +using namespace std; +using namespace BSMPT; + +struct CLIOptions +{ + BSMPT::ModelID::ModelIDs Model{ModelID::ModelIDs::NotSet}; + int Line{2}; + std::string InputFile, OutputFile; + double Temperature{-1}; + int npoints{100}, npoints1{0}, npoints2{0}, npoints3{0}, npoints4{0}, + npoints5{0}, npoints6{0}; + double low1{-1}, low2{-1}, low3{-1}, low4{-1}, low5{-1}, low6{-1}, high1{-1}, + high2{-1}, high3{-1}, high4{-1}, high5{-1}, high6{-1}; + bool use_slice_plotter = false; + std::vector min_start, min_end; + std::vector point; + + CLIOptions(const BSMPT::parser &argparser); + bool good() const; +}; + +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + +int main(int argc, char *argv[]) +try +{ + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); + if (not args.good()) + { + return EXIT_FAILURE; + } + + std::vector sol, start, solPot; + + std::shared_ptr modelPointer = + ModelID::FChoose(args.Model, SMConstants); + + std::ifstream infile(args.InputFile); + if (!infile.good()) + { + Logger::Write(LoggingLevel::Default, "Input file not found "); + return EXIT_FAILURE; + } + + Logger::Write(LoggingLevel::ProgDetailed, "Found file"); + + std::ofstream outfile(args.OutputFile); + if (!outfile.good()) + { + Logger::Write(LoggingLevel::Default, + "Can not create file " + args.OutputFile); + return EXIT_FAILURE; + } + std::string linestr; + int linecounter = 1; + + bool found = false; + while (true) + { + if (infile.eof()) break; + std::getline(infile, linestr); + if (linecounter == 1) + { + modelPointer->setUseIndexCol(linestr); + } + else if (linecounter == args.Line) + { + std::pair, std::vector> parameters = + modelPointer->initModel(linestr); + found = true; + } + else if (linecounter > args.Line) + break; + linecounter++; + if (infile.eof()) break; + } + infile.close(); + if (!found) + { + Logger::Write(LoggingLevel::Default, "Line not found !"); + return EXIT_FAILURE; + } + + double temp = args.Temperature; + + if (args.use_slice_plotter) + { + if ((args.min_end.size() == args.min_start.size()) and + (args.min_end.size() == modelPointer->get_nVEV())) + { + for (auto x : modelPointer->addLegendVEV()) + outfile << std::setprecision(16) << x << sep; + + outfile << "Veff(v,T)" << sep << "T" << std::endl; + + Logger::Write(LoggingLevel::ProgDetailed, + "Evaluating slice between start minimum at (" + + vec_to_string(args.min_start) + + ") and end minimum at (" + vec_to_string(args.min_end) + + ") with " + std::to_string(args.npoints) + + " points at T = " + std::to_string(temp) + " GeV."); + + auto grid_points = + Create1DimGrid(args.min_start, args.min_end, args.npoints); + for (auto point : grid_points) + { + outfile << point << sep + << modelPointer->VEff(modelPointer->MinimizeOrderVEV(point), + temp) + << sep << temp << std::endl; + } + } + else + { + Logger::Write( + LoggingLevel::Default, + "Given false and/or true minimum has dimensions different from " + "model VEV dimension."); + return EXIT_FAILURE; + } + } + else + { + for (auto x : modelPointer->addLegendVEV()) + outfile << std::setprecision(16) << x << sep; + + for (auto x : modelPointer->addLegendVEV()) + { + outfile << x.append("_point") << sep; + } + outfile << "Veff(v,T)" << sep << "Veff(point,T)" << sep << "T" << std::endl; + + Logger::Write(LoggingLevel::ProgDetailed, + "Temperature is set to T = " + std::to_string(temp)); + + std::vector vevStart; + if (args.point.size() == 0) + { + vevStart = std::vector(modelPointer->get_nVEV(), 0); + } + else + { + if (args.point.size() == modelPointer->get_nVEV()) + vevStart = args.point; + else + { + Logger::Write(LoggingLevel::Default, + "Given reference point has dimensions different from " + "model VEV dimension."); + return EXIT_FAILURE; + } + } + Logger::Write(LoggingLevel::ProgDetailed, + "Potential grid reference point is: " + + vec_to_string(vevStart)); + + std::vector vevStartIni = vevStart; + + std::vector npoints = {args.npoints1, + args.npoints2, + args.npoints3, + args.npoints4, + args.npoints5, + args.npoints6}; + + for (std::size_t i = 0; i < vevStartIni.size(); i++) + { + if (npoints.at(i) > 0) + { + vevStartIni.at(i) = + 0; // reset start vector to zero in directions with npoints > 0 + } + } + + std::vector> res_vec_outer, res_vec_inner_1, + res_vec_inner_2, res_vec_inner_3, res_vec_inner_4, res_vec_inner_5; + + for (std::size_t i = 0; i < modelPointer->get_nVEV(); i++) + { + res_vec_outer = + Create1DimGrid(vevStartIni, i, args.low1, args.high1, args.npoints1); + + if (modelPointer->get_nVEV() == 1) + { + for (std::vector a1 : res_vec_outer) + { + outfile << a1 << sep; + outfile << vevStart << sep; + outfile << modelPointer->VEff(modelPointer->MinimizeOrderVEV(a1), + temp) + << sep; + outfile << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(vevStart), temp) + << sep << temp << std::endl; + } + } + else if (i + 1 < modelPointer->get_nVEV()) + { + for (std::vector a1 : res_vec_outer) + { + res_vec_inner_1 = + Create1DimGrid(a1, i + 1, args.low2, args.high2, args.npoints2); + + if (modelPointer->get_nVEV() == 2) + { + for (std::vector a2 : res_vec_inner_1) + { + outfile << a2 << sep; + outfile << vevStart << sep; + outfile << modelPointer->VEff(modelPointer->MinimizeOrderVEV(a2), + temp) + << sep; + outfile << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(vevStart), temp) + << sep << temp << std::endl; + } + } + else if (i + 2 < modelPointer->get_nVEV()) + { + for (std::vector a2 : res_vec_inner_1) + { + res_vec_inner_2 = Create1DimGrid( + a2, i + 2, args.low3, args.high3, args.npoints3); + + if (modelPointer->get_nVEV() == 3) + { + for (std::vector a3 : res_vec_inner_2) + { + outfile << a3 << sep; + outfile << vevStart << sep; + outfile << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(a3), temp) + << sep; + outfile << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(vevStart), temp) + << sep << temp << std::endl; + } + } + else if (i + 3 < modelPointer->get_nVEV()) + { + for (std::vector a3 : res_vec_inner_2) + { + res_vec_inner_3 = Create1DimGrid( + a3, i + 3, args.low4, args.high4, args.npoints4); + + if (modelPointer->get_nVEV() == 4) + { + for (std::vector a4 : res_vec_inner_3) + { + outfile << a4 << sep; + outfile << vevStart << sep; + outfile << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(a4), temp) + << sep; + outfile + << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(vevStart), temp) + << sep << temp << std::endl; + } + } + else if (i + 4 < modelPointer->get_nVEV()) + { + for (std::vector a4 : res_vec_inner_3) + { + res_vec_inner_4 = Create1DimGrid( + a4, i + 4, args.low5, args.high5, args.npoints5); + + if (modelPointer->get_nVEV() == 5) + { + for (std::vector a5 : res_vec_inner_4) + { + outfile << a5 << sep; + outfile << vevStart << sep; + outfile + << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(a5), temp) + << sep; + outfile + << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(vevStart), + temp) + << sep << temp << std::endl; + } + } + else if (i + 5 < modelPointer->get_nVEV()) + { + for (std::vector a5 : res_vec_inner_4) + { + res_vec_inner_5 = Create1DimGrid( + a5, i + 5, args.low6, args.high6, args.npoints6); + + if (modelPointer->get_nVEV() == 6) + { + for (std::vector a6 : res_vec_inner_5) + { + outfile << a6 << sep; + outfile << vevStart << sep; + outfile << modelPointer->VEff( + modelPointer->MinimizeOrderVEV(a6), + temp) + << sep; + outfile << modelPointer->VEff( + modelPointer->MinimizeOrderVEV( + vevStart), + temp) + << sep << temp << std::endl; + } + } + else if (i + 6 < modelPointer->get_nVEV()) + { + throw std::runtime_error( + "Error. More than 6-dim grids " + "are not implemented."); + } + } + } + } + } + } + } + } + } + } + } + } + } + outfile.close(); + return EXIT_SUCCESS; +} +catch (int) +{ + return EXIT_SUCCESS; +} +catch (exception &e) +{ + Logger::Write(LoggingLevel::Default, e.what()); + return EXIT_FAILURE; +} + +bool CLIOptions::good() const +{ + if (Model == ModelID::ModelIDs::NotSet) + { + Logger::Write(LoggingLevel::Default, + "Your Model parameter does not match with the " + "implemented Models."); + ShowInputError(); + return false; + } + if (Temperature < 0) + { + if (Temperature == -1) + Logger::Write(LoggingLevel::Default, "No input for temperature."); + else + Logger::Write(LoggingLevel::Default, "Invalid input for temperature."); + return false; + } + if (use_slice_plotter and ((min_start.size() == 0 or min_end.size() == 0))) + { + Logger::Write( + LoggingLevel::Default, + "Slice plotter mode chosen but no input for false and/or true vacuum."); + return false; + } + if ((npoints1 < 0) or (npoints2 < 0) or (npoints3 < 0) or (npoints4 < 0) or + (npoints5 < 0) or (npoints6 < 0) or (npoints < 0)) + { + Logger::Write(LoggingLevel::Default, "Invalid grid size requested."); + return false; + } + if ((low1 > high1) or (low2 > high2) or (low3 > high3) or (low4 > high4) or + (low5 > high5) or (low6 > high6)) + { + Logger::Write(LoggingLevel::Default, + "Invalid field value boundaries requested."); + return false; + } + if ((npoints1 > 0 and (low1 == -1 or high1 == -1)) or + (npoints2 > 0 and (low2 == -1 or high2 == -1)) or + (npoints3 > 0 and (low3 == -1 or high3 == -1)) or + (npoints4 > 0 and (low4 == -1 or high4 == -1)) or + (npoints5 > 0 and (low5 == -1 or high5 == -1)) or + (npoints6 > 0 and (low6 == -1 or high6 == -1))) + { + Logger::Write(LoggingLevel::Default, + "Grid size in VEV direction non-zero, but no low/high field " + "values defined."); + return false; + } + return true; +} + +CLIOptions::CLIOptions(const BSMPT::parser &argparser) +{ + std::stringstream ss; + argparser.check_required_parameters(); + + // required arguments + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + Line = argparser.get_value("line"); + Temperature = argparser.get_value("temperature"); + + // optional arguments + + try + { + auto vec_str = split(argparser.get_value("point"), ','); + for (std::size_t i = 0; i < vec_str.size(); i++) + { + point.push_back(std::stod(vec_str.at(i))); + } + } + catch (BSMPT::parserException &) + { + ss << "--point not set\n"; + } + + try + { + npoints1 = argparser.get_value("npoints1"); + } + catch (BSMPT::parserException &) + { + ss << "--npoints1 not set, using default value: " << npoints1 << "\n"; + } + try + { + npoints2 = argparser.get_value("npoints2"); + } + catch (BSMPT::parserException &) + { + ss << "--npoints2 not set, using default value: " << npoints2 << "\n"; + } + try + { + npoints3 = argparser.get_value("npoints3"); + } + catch (BSMPT::parserException &) + { + ss << "--npoints3 not set, using default value: " << npoints3 << "\n"; + } + try + { + npoints4 = argparser.get_value("npoints4"); + } + catch (BSMPT::parserException &) + { + ss << "--npoints4 not set, using default value: " << npoints4 << "\n"; + } + try + { + npoints5 = argparser.get_value("npoints5"); + } + catch (BSMPT::parserException &) + { + ss << "--npoints5 not set, using default value: " << npoints5 << "\n"; + } + try + { + npoints6 = argparser.get_value("npoints6"); + } + catch (BSMPT::parserException &) + { + ss << "--npoints6 not set, using default value: " << npoints6 << "\n"; + } + + try + { + low1 = argparser.get_value("low1"); + } + catch (BSMPT::parserException &) + { + ss << "--low1 not set, using default value: " << low1 << "\n"; + } + try + { + low2 = argparser.get_value("low2"); + } + catch (BSMPT::parserException &) + { + ss << "--low2 not set, using default value: " << low2 << "\n"; + } + try + { + low3 = argparser.get_value("low3"); + } + catch (BSMPT::parserException &) + { + ss << "--low3 not set, using default value: " << low3 << "\n"; + } + try + { + low4 = argparser.get_value("low4"); + } + catch (BSMPT::parserException &) + { + ss << "--low4 not set, using default value: " << low4 << "\n"; + } + try + { + low5 = argparser.get_value("low5"); + } + catch (BSMPT::parserException &) + { + ss << "--low5 not set, using default value: " << low5 << "\n"; + } + try + { + low6 = argparser.get_value("low6"); + } + catch (BSMPT::parserException &) + { + ss << "--low6 not set, using default value: " << low6 << "\n"; + } + + try + { + high1 = argparser.get_value("high1"); + } + catch (BSMPT::parserException &) + { + ss << "--high1 not set, using default value: " << high1 << "\n"; + } + try + { + high2 = argparser.get_value("high2"); + } + catch (BSMPT::parserException &) + { + ss << "--high2 not set, using default value: " << high2 << "\n"; + } + try + { + high3 = argparser.get_value("high3"); + } + catch (BSMPT::parserException &) + { + ss << "--high3 not set, using default value: " << high3 << "\n"; + } + try + { + high4 = argparser.get_value("high4"); + } + catch (BSMPT::parserException &) + { + ss << "--high4 not set, using default value: " << high4 << "\n"; + } + try + { + high5 = argparser.get_value("high5"); + } + catch (BSMPT::parserException &) + { + ss << "--high5 not set, using default value: " << high5 << "\n"; + } + try + { + high6 = argparser.get_value("high6"); + } + catch (BSMPT::parserException &) + { + ss << "--high6 not set, using default value: " << high6 << "\n"; + } + + try + { + use_slice_plotter = (argparser.get_value("slice") == "true"); + } + catch (BSMPT::parserException &) + { + ss << "--slice not set, using default value: false \n"; + } + + try + { + auto vec_str = split(argparser.get_value("min_start"), ','); + for (std::size_t i = 0; i < vec_str.size(); i++) + { + min_start.push_back(std::stod(vec_str.at(i))); + } + } + catch (BSMPT::parserException &) + { + ss << "--min_start not set\n"; + } + + try + { + auto vec_str = split(argparser.get_value("min_end"), ','); + for (std::size_t i = 0; i < vec_str.size(); i++) + { + min_end.push_back(std::stod(vec_str.at(i))); + } + } + catch (BSMPT::parserException &) + { + ss << "--min_end not set\n"; + } + + try + { + npoints = argparser.get_value("npoints"); + } + catch (BSMPT::parserException &) + { + ss << "--npoints not set, using default value: " << npoints << "\n"; + } +} + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser(true); + argparser.add_argument("help", "shows this menu", false); + argparser.add_argument("model", "[*] model name", true); + argparser.add_argument("input", "[*] input file (in tsv format)", true); + argparser.add_argument("output", "[*] output file (in tsv format)", true); + argparser.add_argument("line", "[*] line number of line in input file", true); + argparser.add_subtext(" (expects line 1 to be a legend)"); + argparser.add_argument("temperature", "[*] temperature [GeV]", true); + argparser.add_argument("point", "grid reference point", "0,..,0", false); + argparser.add_argument_only_display( + "npointsi", "number of points in direction i", "0"); + argparser.add_subtext("(with i = [1,..,6])"); + argparser.add_argument("npoints1", false); + argparser.add_argument("npoints2", false); + argparser.add_argument("npoints3", false); + argparser.add_argument("npoints4", false); + argparser.add_argument("npoints5", false); + argparser.add_argument("npoints6", false); + argparser.add_argument_only_display( + "lowi", "lowest field value in direction i", "0"); + argparser.add_subtext("[* if npointsi > 0] (with i = [1,..,6])"); + argparser.add_argument("low1", false); + argparser.add_argument("low2", false); + argparser.add_argument("low3", false); + argparser.add_argument("low4", false); + argparser.add_argument("low5", false); + argparser.add_argument("low6", false); + argparser.add_argument_only_display( + "highi", "highest field value in direction i", "0"); + argparser.add_subtext("[* if npointsi > 0] (with i = [1,..,6])"); + argparser.add_argument("high1", false); + argparser.add_argument("high2", false); + argparser.add_argument("high3", false); + argparser.add_argument("high4", false); + argparser.add_argument("high5", false); + argparser.add_argument("high6", false); + argparser.add_argument("slice", "enable slice mode", "false", false); + argparser.add_argument("min_start", "[* in slice mode] start minimum", false); + argparser.add_argument("min_end", "[* in slice mode] end minimum", false); + argparser.add_argument("npoints", "grid size in slice mode", "100", false); + argparser.add_argument( + "json", "use a json file instead of cli parameters", "", false); + + std::stringstream ss; + ss << "PotPlotter calculates the effective potential on a user-specified " + "field grid\nit is " + "called " + "by\n\n\t./bin/PotPlotter [arguments]\n\nwith the " + "following arguments, ([*] are required arguments, others " + "are optional):\n"; + argparser.set_help_header(ss.str()); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + return arguments; +} \ No newline at end of file diff --git a/src/prog/Test.cpp b/src/prog/Test.cpp index b51ca3f6..87367e14 100644 --- a/src/prog/Test.cpp +++ b/src/prog/Test.cpp @@ -16,6 +16,7 @@ #include // for Class_Potential_Origin #include #include +#include #include #include // for copy #include @@ -26,6 +27,7 @@ #include // for getline, string #include // for pair #include // for vector + using namespace std; using namespace BSMPT; @@ -38,15 +40,23 @@ struct CLIOptions bool UseCMAES{Minimizer::UseLibCMAESDefault}; bool UseNLopt{Minimizer::UseNLoptDefault}; int WhichMinimizer{Minimizer::WhichMinimizerDefault}; + bool UseMultithreading{true}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; }; + +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + int main(int argc, char *argv[]) try { - - const CLIOptions args(argc, argv); + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); if (not args.good()) { return EXIT_FAILURE; @@ -64,7 +74,7 @@ try std::string linestr; std::unique_ptr modelPointer = - ModelID::FChoose(args.Model); + ModelID::FChoose(args.Model, SMConstants); Logger::Write(LoggingLevel::ProgDetailed, "Created modelpointer "); @@ -101,129 +111,22 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) -{ - - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); - - if (argc < 4 or args.at(0) == "--help") - { - std::stringstream ss; - int SizeOfFirstColumn = std::string("--TerminalOutput= ").size(); - ss << "Test performs a serious of tests on the given model. " - "Intended for testing new models." - << std::endl - << "It is called either by " << std::endl - << "./Test model input Line" << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to test" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--Line=" - << "The line in the input file with the parameter point used to " - "check the model." - << std::endl; - std::string GSLhelp{"--UseGSL="}; - GSLhelp += Minimizer::UseGSLDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << GSLhelp - << "Use the GSL library to minimize the effective potential" - << std::endl; - std::string CMAEShelp{"--UseCMAES="}; - CMAEShelp += Minimizer::UseLibCMAESDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << CMAEShelp - << "Use the CMAES library to minimize the effective potential" - << std::endl; - std::string NLoptHelp{"--UseNLopt="}; - NLoptHelp += Minimizer::UseNLoptDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << NLoptHelp - << "Use the NLopt library to minimize the effective potential" - << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); - } - - if (args.size() > 0 and args.at(0) == "--help") - { - throw int{0}; - } - else if (argc < 4) - { - throw std::runtime_error("Too few arguments."); - } - - const std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusedArgs; - if (UsePrefix) - { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - Logger::Write(LoggingLevel::ProgDetailed, "Inputfile = " + InputFile); - } - else if (StringStartsWith(el, "--line=")) - { - Line = std::stoi(el.substr(std::string("--line=").size())); - } - else if (StringStartsWith(el, "--usegsl=")) - { - UseGSL = el.substr(std::string("--usegsl=").size()) == "true"; - } - else if (StringStartsWith(el, "--usecmaes=")) - { - UseCMAES = el.substr(std::string("--usecmaes=").size()) == "true"; - } - else if (StringStartsWith(el, "--usenlopt=")) - { - UseNLopt = el.substr(std::string("--usenlopt=").size()) == "true"; - } - else - { - UnusedArgs.push_back(el); - } - } - WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); - SetLogger(UnusedArgs); - } - else - { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - Line = std::stoi(args.at(2)); - } -} - bool CLIOptions::good() const { if (UseGSL and not Minimizer::UseGSLDefault) { throw std::runtime_error( - "You set --UseGSL=true but GSL was not found during compilation."); + "You set --useGSL=true but GSL was not found during compilation."); } if (UseCMAES and not Minimizer::UseLibCMAESDefault) { throw std::runtime_error( - "You set --UseCMAES=true but CMAES was not found during compilation."); + "You set --useCMAES=true but CMAES was not found during compilation."); } if (UseNLopt and not Minimizer::UseNLoptDefault) { throw std::runtime_error( - "You set --UseNLopt=true but NLopt was not found during compilation."); + "You set --useNLopt=true but NLopt was not found during compilation."); } if (WhichMinimizer == 0) { @@ -245,3 +148,104 @@ bool CLIOptions::good() const } return true; } + +CLIOptions::CLIOptions(const BSMPT::parser &argparser) +{ + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + Line = argparser.get_value("line"); + + try + { + UseGSL = argparser.get_value("useGSL"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseCMAES = argparser.get_value("useCMAES"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseNLopt = argparser.get_value("useNLopt"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseMultithreading = argparser.get_value("useMultithreading"); + } + catch (BSMPT::parserException &) + { + } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); +} + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument( + "line", + "The line in the input file with the parameter point used to " + "check the model.", + true); + + std::stringstream ss; + ss << "Test performs a serious of tests on the given model. " + "Intended for testing new models." + << std::endl + << "It is called either by " << std::endl + << "./Test model input Line" << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + argparser.enable_minimizer_options(); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--line=" + std::string(argv[3])); + } + } + return arguments; +} diff --git a/src/prog/TestNewKheader.cpp b/src/prog/TestNewKheader.cpp index b9c9e6f6..a1103756 100644 --- a/src/prog/TestNewKheader.cpp +++ b/src/prog/TestNewKheader.cpp @@ -1,4 +1,5 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later diff --git a/src/prog/TripleHiggsNLO.cpp b/src/prog/TripleHiggsNLO.cpp index c8f4ca7f..5c01f90c 100644 --- a/src/prog/TripleHiggsNLO.cpp +++ b/src/prog/TripleHiggsNLO.cpp @@ -13,6 +13,7 @@ #include // for Class_Potential_Origin #include #include +#include #include #include #include @@ -32,15 +33,21 @@ struct CLIOptions std::string InputFile, OutputFile; bool TerminalOutput{false}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; }; +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + int main(int argc, char *argv[]) try { - - const CLIOptions args(argc, argv); + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); if (not args.good()) { return EXIT_FAILURE; @@ -63,7 +70,7 @@ try std::string linestr; std::unique_ptr modelPointer = - ModelID::FChoose(args.Model); + ModelID::FChoose(args.Model, SMConstants); std::size_t nPar, nParCT; nPar = modelPointer->get_nPar(); nParCT = modelPointer->get_nParCT(); @@ -147,110 +154,23 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) +CLIOptions::CLIOptions(const BSMPT::parser &argparser) { - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); - - if (argc < 6 or args.at(0) == "--help") - { - std::stringstream ss; - int SizeOfFirstColumn = std::string("--TerminalOutput= ").size(); - ss << "TripleHiggsNLO calculates the coupling between three Higgs bosons" - << std::endl - << "It is called either by " << std::endl - << "./TripleHiggsNLO Model Inputfile Outputfile LineStart LineEnd" - << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to investigate" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--output=" - << "The output file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--FirstLine=" - << "The first line in the input file to calculate the EWPT. Expects " - "line 1 to be a legend." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--LastLine=" - << "The last line in the input file to calculate the EWPT." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--TerminalOutput=" - << "y/n Turns on additional information in the terminal during the " - "calculation." - << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); - } - - if (args.size() > 0 and args.at(0) == "--help") + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + FirstLine = argparser.get_value("firstLine"); + LastLine = argparser.get_value("lastLine"); + try { - throw int{0}; + TerminalOutput = (argparser.get_value("terminalOutput") == "y"); } - else if (argc < 6) - { - throw std::runtime_error("Too few arguments."); - } - - const std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusuedArgs; - if (UsePrefix) - { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - } - else if (StringStartsWith(el, "--output=")) - { - OutputFile = arg.substr(std::string("--output=").size()); - } - else if (StringStartsWith(el, "--firstline=")) - { - FirstLine = std::stoi(el.substr(std::string("--firstline=").size())); - } - else if (StringStartsWith(el, "--lastline=")) - { - LastLine = std::stoi(el.substr(std::string("--lastline=").size())); - } - else if (StringStartsWith(el, "--terminaloutput=")) - { - TerminalOutput = - el.substr(std::string("--terminaloutput=").size()) == "y"; - } - else - { - UnusuedArgs.push_back(el); - } - } - SetLogger(UnusuedArgs); - } - else + catch (BSMPT::parserException &) { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - OutputFile = args.at(2); - FirstLine = std::stoi(args.at(3)); - LastLine = std::stoi(args.at(4)); - if (argc == 7) - { - TerminalOutput = ("y" == std::string(argv[6])); - } + TerminalOutput = false; } } - bool CLIOptions::good() const { if (Model == ModelID::ModelIDs::NotSet) @@ -274,3 +194,77 @@ bool CLIOptions::good() const } return true; } + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument("output", "The output file in tsv format.", true); + argparser.add_argument("firstLine", + "The first line in the input file to calculate the " + "EWPT. Expects line 1 to be a legend.", + true); + argparser.add_argument( + "lastLine", + "The last line in the input file to calculate the EWPT.", + true); + argparser.add_argument( + "terminalOutput", + "y/n Turns on additional information in the terminal during " + "the calculation.", + false); + + std::stringstream ss; + ss << "TripleHiggsNLO calculates the coupling between three Higgs bosons" + << std::endl + << "It is called either by " << std::endl + << "./TripleHiggsNLO Model Inputfile Outputfile LineStart LineEnd" + << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--firstLine=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--lastLine=" + std::string(argv[5])); + } + } + return arguments; +} diff --git a/src/prog/VEVEVO.cpp b/src/prog/VEVEVO.cpp index 22c4be59..2903286a 100644 --- a/src/prog/VEVEVO.cpp +++ b/src/prog/VEVEVO.cpp @@ -13,6 +13,7 @@ #include // for Class_Potential_Origin #include #include +#include #include #include // for copy, max #include @@ -37,15 +38,23 @@ struct CLIOptions bool UseCMAES{Minimizer::UseLibCMAESDefault}; bool UseNLopt{Minimizer::UseNLoptDefault}; int WhichMinimizer{Minimizer::WhichMinimizerDefault}; + bool UseMultithreading{true}; - CLIOptions(int argc, char *argv[]); + CLIOptions(const BSMPT::parser &argparser); bool good() const; }; +BSMPT::parser prepare_parser(); + +std::vector convert_input(int argc, char *argv[]); + int main(int argc, char *argv[]) try { - const CLIOptions args(argc, argv); + const auto SMConstants = GetSMConstants(); + auto argparser = prepare_parser(); + argparser.add_input(convert_input(argc, argv)); + const CLIOptions args(argparser); if (not args.good()) { return EXIT_FAILURE; @@ -54,7 +63,7 @@ try std::vector sol, start, solPot; std::shared_ptr modelPointer = - ModelID::FChoose(args.Model); + ModelID::FChoose(args.Model, SMConstants); std::ifstream infile(args.InputFile); if (!infile.good()) { @@ -103,10 +112,8 @@ try outfile << std::setprecision(16); - outfile << "T" << sep << "v"; - for (auto x : modelPointer->addLegendVEV()) - outfile << sep << x; - outfile << sep << "Veff(v,T)" << std::endl; + outfile << "T" << sep << "v" << sep << modelPointer->addLegendVEV() << sep + << "Veff(v,T)" << std::endl; for (double Temp = args.TemperatureStart; Temp <= args.TemperatureEnd; Temp += args.TemperatureStep) @@ -123,8 +130,12 @@ try sol.clear(); Check.clear(); solPot.clear(); - sol = Minimizer::Minimize_gen_all( - modelPointer, Temp, Check, start, args.WhichMinimizer); + sol = Minimizer::Minimize_gen_all(modelPointer, + Temp, + Check, + start, + args.WhichMinimizer, + args.UseMultithreading); solPot = modelPointer->MinimizeOrderVEV(sol); vev = modelPointer->EWSBVEV(solPot); @@ -148,162 +159,22 @@ catch (exception &e) return EXIT_FAILURE; } -CLIOptions::CLIOptions(int argc, char *argv[]) -{ - std::vector args; - for (int i{1}; i < argc; ++i) - args.push_back(argv[i]); - - if (argc < 8 or args.at(0) == "--help") - { - std::stringstream ss; - int SizeOfFirstColumn = - std::string("--TemperatureStart= ").size(); - ss << "VEVEVO calculates the evolution of the global minimum with " - "rising temperature for a given parameter point" - << std::endl - << "It is called either by " << std::endl - << "./VEVEVO Model Inputfile Outputfile Line TemperatureStart " - "TemperatureStep TemperatureEnd" - << std::endl - << "or with the following arguments" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--help" - << "Shows this menu" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--model=" - << "The model you want to investigate" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--input=" - << "The input file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--output=" - << "The output file in tsv format" << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--Line=" - << "The line in the input file with the given parameter point. " - "Expects line 1 to be a legend." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--TemperatureStart=" - << "The starting temperature to calculate the global minimum." - << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--TemperatureStep=" - << "The stepsize for the temperature." << std::endl - << std::setw(SizeOfFirstColumn) << std::left << "--TemperatureEnd=" - << "The last temperature to calculate the global minimum." << std::endl; - std::string GSLhelp{"--UseGSL="}; - GSLhelp += Minimizer::UseGSLDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << GSLhelp - << "Use the GSL library to minimize the effective potential" - << std::endl; - std::string CMAEShelp{"--UseCMAES="}; - CMAEShelp += Minimizer::UseLibCMAESDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << CMAEShelp - << "Use the CMAES library to minimize the effective potential" - << std::endl; - std::string NLoptHelp{"--UseNLopt="}; - NLoptHelp += Minimizer::UseNLoptDefault ? "true" : "false"; - ss << std::setw(SizeOfFirstColumn) << std::left << NLoptHelp - << "Use the NLopt library to minimize the effective potential" - << std::endl; - Logger::Write(LoggingLevel::Default, ss.str()); - ShowLoggerHelp(); - ShowInputError(); - } - - if (args.size() > 0 and args.at(0) == "--help") - { - throw int{0}; - } - else if (argc < 8) - { - throw std::runtime_error("Too few arguments."); - } - - const std::string prefix{"--"}; - bool UsePrefix = StringStartsWith(args.at(0), prefix); - std::vector UnusedArgs; - if (UsePrefix) - { - for (const auto &arg : args) - { - auto el = arg; - std::transform(el.begin(), el.end(), el.begin(), ::tolower); - if (StringStartsWith(el, "--model=")) - { - Model = - BSMPT::ModelID::getModel(el.substr(std::string("--model=").size())); - } - else if (StringStartsWith(el, "--input=")) - { - InputFile = arg.substr(std::string("--input=").size()); - } - else if (StringStartsWith(el, "--output=")) - { - OutputFile = arg.substr(std::string("--output=").size()); - } - else if (StringStartsWith(el, "--line=")) - { - Line = std::stoi(el.substr(std::string("--line=").size())); - } - else if (StringStartsWith(el, "--temperaturestart=")) - { - TemperatureStart = - std::stod(el.substr(std::string("--temperaturestart=").size())); - } - else if (StringStartsWith(el, "--temperaturestep=")) - { - TemperatureStep = - std::stod(el.substr(std::string("--temperaturestep=").size())); - } - else if (StringStartsWith(el, "--temperatureend=")) - { - TemperatureEnd = - std::stod(el.substr(std::string("--temperatureend=").size())); - } - else if (StringStartsWith(el, "--usegsl=")) - { - UseGSL = el.substr(std::string("--usegsl=").size()) == "true"; - } - else if (StringStartsWith(el, "--usecmaes=")) - { - UseCMAES = el.substr(std::string("--usecmaes=").size()) == "true"; - } - else if (StringStartsWith(el, "--usenlopt=")) - { - UseNLopt = el.substr(std::string("--usenlopt=").size()) == "true"; - } - else - { - UnusedArgs.push_back(el); - } - } - WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); - SetLogger(UnusedArgs); - } - else - { - Model = ModelID::getModel(args.at(0)); - InputFile = args.at(1); - OutputFile = args.at(2); - Line = std::stoi(args.at(3)); - TemperatureStart = std::stod(args.at(4)); - TemperatureStep = std::stod(args.at(5)); - TemperatureEnd = std::stod(args.at(6)); - } -} - bool CLIOptions::good() const { if (UseGSL and not Minimizer::UseGSLDefault) { throw std::runtime_error( - "You set --UseGSL=true but GSL was not found during compilation."); + "You set --useGSL=true but GSL was not found during compilation."); } if (UseCMAES and not Minimizer::UseLibCMAESDefault) { throw std::runtime_error( - "You set --UseCMAES=true but CMAES was not found during compilation."); + "You set --useCMAES=true but CMAES was not found during compilation."); } if (UseNLopt and not Minimizer::UseNLoptDefault) { throw std::runtime_error( - "You set --UseNLopt=true but NLopt was not found during compilation."); + "You set --useNLopt=true but NLopt was not found during compilation."); } if (WhichMinimizer == 0) { @@ -335,3 +206,143 @@ bool CLIOptions::good() const } return true; } + +CLIOptions::CLIOptions(const BSMPT::parser &argparser) +{ + argparser.check_required_parameters(); + Model = BSMPT::ModelID::getModel(argparser.get_value("model")); + InputFile = argparser.get_value("input"); + OutputFile = argparser.get_value("output"); + Line = argparser.get_value("line"); + TemperatureStart = argparser.get_value("temperatureStart"); + TemperatureEnd = argparser.get_value("temperatureEnd"); + TemperatureStep = argparser.get_value("temperatureStep"); + + try + { + UseGSL = argparser.get_value("useGSL"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseCMAES = argparser.get_value("useCMAES"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseNLopt = argparser.get_value("useNLopt"); + } + catch (BSMPT::parserException &) + { + } + + try + { + UseMultithreading = argparser.get_value("useMultithreading"); + } + catch (BSMPT::parserException &) + { + } + + WhichMinimizer = Minimizer::CalcWhichMinimizer(UseGSL, UseCMAES, UseNLopt); +} + +BSMPT::parser prepare_parser() +{ + BSMPT::parser argparser; + argparser.add_argument("model", "The model you want to investigate.", true); + argparser.add_argument("input", "The input file in tsv format.", true); + argparser.add_argument("output", "The output file in tsv format.", true); + argparser.add_argument( + "line", + "The line with the given parameter point. Expects line 1 to " + "be a legend.", + true); + + argparser.add_argument( + "temperatureStart", + "The starting temperature to calculate the global minimum.", + true); + argparser.add_argument( + "temperatureStep", "The stepsize for the temperature.", true); + argparser.add_argument( + "temperatureEnd", + "The last temperature to calculate the global minimum.", + true); + argparser.add_argument( + "terminalOutput", + "y/n Turns on additional information in the terminal during " + "the calculation.", + false); + + std::stringstream ss; + ss << "VEVEVO calculates the evolution of the global minimum with " + "rising temperature for a given parameter point" + << std::endl + << "It is called either by " << std::endl + << "./VEVEVO Model Inputfile Outputfile Line TemperatureStart " + "TemperatureStep TemperatureEnd" + << std::endl + << "or with the following arguments" << std::endl; + argparser.set_help_header(ss.str()); + + argparser.enable_minimizer_options(); + + return argparser; +} + +std::vector convert_input(int argc, char *argv[]) +{ + std::vector arguments; + if (argc == 1) return arguments; + auto first_arg = std::string(argv[1]); + + bool UsePrefix = + StringStartsWith(first_arg, "--") or StringStartsWith(first_arg, "-"); + + if (UsePrefix) + { + for (int i{1}; i < argc; ++i) + { + arguments.emplace_back(argv[i]); + } + } + else + { + if (argc >= 2) + { + arguments.emplace_back("--model=" + std::string(argv[1])); + } + if (argc >= 3) + { + arguments.emplace_back("--input=" + std::string(argv[2])); + } + if (argc >= 4) + { + arguments.emplace_back("--output=" + std::string(argv[3])); + } + if (argc >= 5) + { + arguments.emplace_back("--line=" + std::string(argv[4])); + } + if (argc >= 6) + { + arguments.emplace_back("--temperatureStart=" + std::string(argv[5])); + } + if (argc >= 7) + { + arguments.emplace_back("--temperatureStep=" + std::string(argv[6])); + } + if (argc >= 8) + { + arguments.emplace_back("--temperatureEnd=" + std::string(argv[7])); + } + } + return arguments; +} diff --git a/src/transition_tracer/CMakeLists.txt b/src/transition_tracer/CMakeLists.txt new file mode 100644 index 00000000..34e0ce89 --- /dev/null +++ b/src/transition_tracer/CMakeLists.txt @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, +# João Viana +# +# SPDX-License-Identifier: GPL-3.0-or-later + +set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/transition_tracer") +set(header ${header_path}/transition_tracer.h) + +set(src transition_tracer.cpp) + +add_library(TransitionTracer ${header} ${src}) +target_link_libraries(TransitionTracer PUBLIC MinimumTracer BounceSolution GW) +target_include_directories(TransitionTracer PUBLIC ${BSMPT_SOURCE_DIR}/include) +target_compile_features(TransitionTracer PUBLIC cxx_std_14) diff --git a/src/transition_tracer/transition_tracer.cpp b/src/transition_tracer/transition_tracer.cpp new file mode 100644 index 00000000..5041100c --- /dev/null +++ b/src/transition_tracer/transition_tracer.cpp @@ -0,0 +1,492 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/** + * @file transition history evaluator + */ + +#include + +namespace BSMPT +{ + +TransitionTracer::TransitionTracer(user_input &input) +{ + num_vev = input.modelPointer->get_nVEV(); + + std::shared_ptr mintracer(new MinimumTracer( + input.modelPointer, input.which_minimizer, input.use_multithreading)); + + // initialize legend + output_store.legend = mintracer->GetLegend(0, input.gw_calculation); + + // NLO stability check + if (input.nlo_check) + { + auto glob_min = mintracer->ConvertToVEVDim(mintracer->GetGlobalMinimum(0)); + Logger::Write(LoggingLevel::TransitionDetailed, + "Global minimum at T = 0 found at " + + vec_to_string(glob_min)); + output_store.status.status_nlo_stability = + mintracer->GetStatusNLOVEV(input.modelPointer->CheckNLOVEV(glob_min)); + } + else + { + Logger::Write(LoggingLevel::TransitionDetailed, + "Check for NLO stability is disabled."); + output_store.status.status_nlo_stability = BSMPT::StatusNLOStability::Off; + } + + if (output_store.status.status_nlo_stability == + BSMPT::StatusNLOStability::Success or + output_store.status.status_nlo_stability == + BSMPT::StatusNLOStability::Off) + { + // Electroweak Symmetry Restoration check + bool point_filtered_out_due_to_snr = false; + if (input.ewsr_check > 0) + { + double ewsr_status = mintracer->IsThereEWSymmetryRestoration(); + output_store.status.status_ewsr = mintracer->GetStatusEWSR(ewsr_status); + + // If no minimum was found at high temperature + if (input.ewsr_check == 2 && ewsr_status < 2) + { + + Logger::Write( + LoggingLevel::TransitionDetailed, + "EW symmetry restoration check failed. Point will be filtered out"); + + point_filtered_out_due_to_snr = true; + } + // If EW was not restored + if (input.ewsr_check == 3 && ewsr_status < 3) + { + Logger::Write( + LoggingLevel::TransitionDetailed, + "EW symmetry restoration check failed. Point will be filtered out"); + + point_filtered_out_due_to_snr = true; + } + } + else + { + Logger::Write(LoggingLevel::TransitionDetailed, + "Check for EW symmetry restoration is disabled."); + output_store.status.status_ewsr = StatusEWSR::Off; + } + + if (not point_filtered_out_due_to_snr) + { + Logger::Write( + LoggingLevel::TransitionDetailed, + "Track phases in between T_low = " + std::to_string(input.T_low) + + " GeV and T_high = " + std::to_string(input.T_high) + " GeV"); + + Vacuum vac(input.T_low, + input.T_high, + mintracer, + input.modelPointer, + input.multistepmode, + input.num_points); + + vec_coex = vac.CoexPhasesList; + + output_store.num_coex_phase_pairs = vec_coex.size(); + + Logger::Write(LoggingLevel::TransitionDetailed, + "\nIdentified " + + std::to_string(output_store.num_coex_phase_pairs) + + " coexisiting phase pair(s) in total."); + + output_store.status.status_tracing = vac.status_vacuum; + output_store.status.status_coex_pairs = vac.status_coex_pairs; + + if ((output_store.status.status_tracing == StatusTracing::Success) && + (output_store.status.status_coex_pairs == StatusCoexPair::Success)) + { + output_store.legend = mintracer->GetLegend( + output_store.num_coex_phase_pairs, input.gw_calculation); + + for (auto pair : vec_coex) + { + transition_data new_transition_data; + gw_data new_gw_data; + + Logger::Write(LoggingLevel::TransitionDetailed, + "Pair " + std::to_string(pair.coex_pair_id) + + " (phase " + std::to_string(pair.false_phase.id) + + " -> phase " + std::to_string(pair.true_phase.id) + + ") with Tc = " + std::to_string(pair.crit_temp) + + " (" + StatusCritToString.at(pair.crit_status) + + ")"); + + output_store.status.status_crit.push_back(pair.crit_status); + if ((pair.crit_status == BSMPT::StatusCrit::Success) || + (pair.crit_status == BSMPT::StatusCrit::TrueLower)) + { + + Logger::Write(LoggingLevel::TransitionDetailed, + "Calculate bounce solution, for more output, use " + "--logginglevel::bouncedetailed=true."); + + new_transition_data.crit_temp = pair.crit_temp; + new_transition_data.crit_true_vev = + pair.true_phase.Get(pair.crit_temp).point; + new_transition_data.crit_false_vev = + pair.false_phase.Get(pair.crit_temp).point; + + BounceSolution bounce(input.modelPointer, + mintracer, + pair, + input.vwall, + input.epsturb, + input.maxpathintegrations, + input.number_of_initial_scan_temperatures); + + ListBounceSolution.push_back(bounce); + + output_store.status.status_bounce_sol.push_back( + bounce.status_bounce_sol); + + if (bounce.status_bounce_sol == StatusGW::Success) + { + bounce.CalculateNucleationTempApprox(); + + output_store.status.status_nucl_approx.push_back( + bounce.status_nucl_approx); + if (bounce.status_nucl_approx == + BSMPT::StatusTemperature::Success) + { + new_transition_data.nucl_approx_temp = + bounce.GetNucleationTempApprox(); + new_transition_data.nucl_approx_true_vev = + pair.true_phase + .Get(new_transition_data.nucl_approx_temp.value_or( + EmptyValue)) + .point; + new_transition_data.nucl_approx_false_vev = + pair.false_phase + .Get(new_transition_data.nucl_approx_temp.value_or( + EmptyValue)) + .point; + } + else + { + new_transition_data.nucl_approx_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.nucl_approx_false_vev = + std::vector(num_vev, EmptyValue); + } + + bounce.CalculateNucleationTemp(); + + output_store.status.status_nucl.push_back(bounce.status_nucl); + if (bounce.status_nucl == BSMPT::StatusTemperature::Success) + { + new_transition_data.nucl_temp = bounce.GetNucleationTemp(); + new_transition_data.nucl_true_vev = + pair.true_phase + .Get(new_transition_data.nucl_temp.value_or(EmptyValue)) + .point; + new_transition_data.nucl_false_vev = + pair.false_phase + .Get(new_transition_data.nucl_temp.value_or(EmptyValue)) + .point; + } + else + { + new_transition_data.nucl_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.nucl_false_vev = + std::vector(num_vev, EmptyValue); + } + + bounce.CalculatePercolationTemp(); + + output_store.status.status_perc.push_back(bounce.status_perc); + if (bounce.status_perc == BSMPT::StatusTemperature::Success) + { + new_transition_data.perc_temp = bounce.GetPercolationTemp(); + new_transition_data.perc_true_vev = + pair.true_phase + .Get(new_transition_data.perc_temp.value_or(EmptyValue)) + .point; + new_transition_data.perc_false_vev = + pair.false_phase + .Get(new_transition_data.perc_temp.value_or(EmptyValue)) + .point; + } + else + { + new_transition_data.perc_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.perc_false_vev = + std::vector(num_vev, EmptyValue); + } + + bounce.CalculateCompletionTemp(); + + output_store.status.status_compl.push_back(bounce.status_compl); + if (bounce.status_compl == BSMPT::StatusTemperature::Success) + { + new_transition_data.compl_temp = bounce.GetCompletionTemp(); + new_transition_data.compl_true_vev = + pair.true_phase + .Get( + new_transition_data.compl_temp.value_or(EmptyValue)) + .point; + new_transition_data.compl_false_vev = + pair.false_phase + .Get( + new_transition_data.compl_temp.value_or(EmptyValue)) + .point; + } + else + { + new_transition_data.compl_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.compl_false_vev = + std::vector(num_vev, EmptyValue); + } + + BSMPT::StatusTemperature trans_status = + BSMPT::StatusTemperature::NotSet; + if (input.which_transition_temp == 1) + { + trans_status = bounce.status_nucl_approx; + } + else if (input.which_transition_temp == 2) + { + trans_status = bounce.status_nucl; + } + else if (input.which_transition_temp == 3) + { + trans_status = bounce.status_perc; + } + else if (input.which_transition_temp == 4) + { + trans_status = bounce.status_compl; + } + + if (trans_status == BSMPT::StatusTemperature::Success && + input.gw_calculation) + { + Logger::Write(LoggingLevel::TransitionDetailed, + "Start GW parameters calculation."); + + new_gw_data.vwall = bounce.GetWallVelocity(); + + bounce.CalculatePTStrength(); + new_gw_data.alpha = bounce.GetPTStrength(); + new_gw_data.beta_over_H = bounce.GetInvTimeScale(); + + GravitationalWave gw(bounce, input.which_transition_temp); + + new_gw_data.status_gw = gw.data.status; + new_gw_data.trans_temp = gw.data.transitionTemp; + + if (new_gw_data.status_gw != StatusGW::Failure) + { + gw.CalcPeakFrequencySoundWave(); + gw.CalcPeakAmplitudeSoundWave(); + new_gw_data.fpeak_sw = gw.data.fPeakSoundWave; + new_gw_data.h2Omega_sw = gw.data.h2OmegaPeakSoundWave; + + gw.CalcPeakFrequencyTurbulence(); + gw.CalcPeakAmplitudeTurbulence(); + new_gw_data.fpeak_turb = gw.data.fPeakTurbulence; + new_gw_data.h2Omega_turb = gw.data.h2OmegaPeakTurbulence; + + // center integration limits around fpeak + gw.data.swON = true; + gw.data.turbON = false; + new_gw_data.SNR_sw = gw.GetSNR(1e-6, 10); + + gw.data.swON = false; + gw.data.turbON = true; + new_gw_data.SNR_turb = gw.GetSNR(1e-6, 10); + + gw.data.swON = true; + gw.data.turbON = true; + new_gw_data.SNR = gw.GetSNR(1e-6, 10); + + new_gw_data.K_sw = gw.data.K_sw; + new_gw_data.K_turb = gw.data.K_turb; + + new_gw_data.status_gw = gw.data.status; + } + } + else if (input.gw_calculation && + trans_status != BSMPT::StatusTemperature::Success) + { + Logger::Write(LoggingLevel::TransitionDetailed, + "Requested transition temperature could not be " + "calculated."); + } + } + else + { + output_store.status.status_nucl_approx.push_back( + BSMPT::StatusTemperature::NaN); + output_store.status.status_nucl.push_back( + BSMPT::StatusTemperature::NaN); + output_store.status.status_perc.push_back( + BSMPT::StatusTemperature::NaN); + output_store.status.status_compl.push_back( + BSMPT::StatusTemperature::NaN); + + new_transition_data.nucl_approx_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.nucl_approx_false_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.nucl_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.nucl_false_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.perc_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.perc_false_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.compl_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.compl_false_vev = + std::vector(num_vev, EmptyValue); + } + } + else + { + new_transition_data.crit_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.crit_false_vev = + std::vector(num_vev, EmptyValue); + + output_store.status.status_bounce_sol.push_back(StatusGW::NotSet); + + output_store.status.status_nucl_approx.push_back( + BSMPT::StatusTemperature::NaN); + output_store.status.status_nucl.push_back( + BSMPT::StatusTemperature::NaN); + output_store.status.status_perc.push_back( + BSMPT::StatusTemperature::NaN); + output_store.status.status_compl.push_back( + BSMPT::StatusTemperature::NaN); + + new_transition_data.nucl_approx_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.nucl_approx_false_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.nucl_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.nucl_false_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.perc_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.perc_false_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.compl_true_vev = + std::vector(num_vev, EmptyValue); + new_transition_data.compl_false_vev = + std::vector(num_vev, EmptyValue); + } + + new_transition_data.crit_temp = pair.crit_temp; + output_store.vec_trans_data.push_back(new_transition_data); + output_store.vec_gw_data.push_back(new_gw_data); + } + + // transition history evaluator + std::vector transition_history; + std::vector pair_history; + bool final_true_phase_reached = false; + int tmp_phase_id = 0; // initial false phase + double tmp_compl_temp = -1; + + int tmp_next_phase_id; + double pair_compl_temp; + int tmp_pair_id; + + while (not final_true_phase_reached) + { + // store current false phase + transition_history.push_back(tmp_phase_id); + tmp_next_phase_id = -1; + tmp_compl_temp = -1; + + for (auto pair : vec_coex) + { + // get pair with matching false phase id + if (pair.false_phase.id == tmp_phase_id) + { + pair_compl_temp = + output_store.vec_trans_data.at(pair.coex_pair_id) + .compl_temp.value_or(EmptyValue); + + if (std::isnan(pair_compl_temp)) // completion temperature not + // reached in pair + { + continue; + } + else + { + // update next phase id with true phase with highest + // completion temperature + if (tmp_compl_temp == -1) + { + tmp_compl_temp = pair_compl_temp; + tmp_next_phase_id = pair.true_phase.id; + tmp_pair_id = pair.coex_pair_id; + } + else + { + if (pair_compl_temp > tmp_compl_temp) + { + tmp_compl_temp = pair_compl_temp; + tmp_next_phase_id = pair.true_phase.id; + tmp_pair_id = pair.coex_pair_id; + } + } + } + } + } + + if (tmp_next_phase_id == -1) + { + final_true_phase_reached = true; + } + else + { + tmp_phase_id = tmp_next_phase_id; + tmp_next_phase_id = -1; + pair_history.push_back(tmp_pair_id); + tmp_pair_id = -1; + } + } + output_store.transition_history = + std::to_string(transition_history.at(0)); + if (transition_history.size() > 1) + { + for (std::size_t i = 1; i < transition_history.size(); i++) + { + output_store.transition_history += + "-(" + std::to_string(pair_history.at(i - 1)) + ")->" + + std::to_string(transition_history.at(i)); + } + } + } + } + } + else + { + Logger::Write(LoggingLevel::TransitionDetailed, "Point is not NLO stable."); + } + return; +} + +TransitionTracer::~TransitionTracer() +{ +} + +} // namespace BSMPT \ No newline at end of file diff --git a/src/utility/CMakeLists.txt b/src/utility/CMakeLists.txt index a0a2dc17..43b1036b 100644 --- a/src/utility/CMakeLists.txt +++ b/src/utility/CMakeLists.txt @@ -1,14 +1,25 @@ +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller +# +# SPDX-License-Identifier: GPL-3.0-or-later + set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/utility") set(header - ${header_path}/utility.h - ${header_path}/Logger.h) -set(src - utility.cpp - Logger.cpp) + ${header_path}/utility.h ${header_path}/Logger.h ${header_path}/parser.h + ${header_path}/const_velocity_spline.h + ${header_path}/NumericalDerivatives.h) +set(src utility.cpp Logger.cpp parser.cpp const_velocity_spline.cpp + NumericalDerivatives.cpp) add_library(Utility ${header} ${src}) -target_include_directories(Utility PUBLIC ${BSMPT_SOURCE_DIR}/include ${BSMPT_BINARY_DIR}/include) +target_include_directories(Utility PUBLIC ${BSMPT_SOURCE_DIR}/include + ${BSMPT_BINARY_DIR}/include) if(Boost_FOUND) target_link_libraries(Utility PUBLIC Boost::boost) endif() -target_compile_features(Utility PUBLIC cxx_std_14) +target_compile_features(Utility PUBLIC cxx_std_17) + +if(nlohmann_json_FOUND) + target_link_libraries(Utility PRIVATE nlohmann_json::nlohmann_json) +endif() +target_link_libraries(Utility PUBLIC ASCIIPlotter Spline GSL::gsl) diff --git a/src/utility/Logger.cpp b/src/utility/Logger.cpp index 506a34f9..061282d5 100644 --- a/src/utility/Logger.cpp +++ b/src/utility/Logger.cpp @@ -9,6 +9,7 @@ */ #include +#include #include #include #include @@ -19,14 +20,16 @@ namespace BSMPT { static std::map LoggingPrefixes{ - { - "--logginglevel::default=", - LoggingLevel::Default, - }, + {"--logginglevel::default=", LoggingLevel::Default}, {"--logginglevel::debug=", LoggingLevel::Debug}, {"--logginglevel::ewbgdetailed=", LoggingLevel::EWBGDetailed}, {"--logginglevel::progdetailed=", LoggingLevel::ProgDetailed}, - {"--logginglevel::minimizerdetailed=", LoggingLevel::MinimizerDetailed}}; + {"--logginglevel::minimizerdetailed=", LoggingLevel::MinimizerDetailed}, + {"--logginglevel::transitiondetailed=", LoggingLevel::TransitionDetailed}, + {"--logginglevel::mintracerdetailed=", LoggingLevel::MinTracerDetailed}, + {"--logginglevel::bouncedetailed=", LoggingLevel::BounceDetailed}, + {"--logginglevel::gwdetailed=", LoggingLevel::GWDetailed}, + {"--logginglevel::complete=", LoggingLevel::Complete}}; void ShowLoggerHelp() { @@ -44,6 +47,43 @@ void ShowLoggerHelp() } Logger::Write(LoggingLevel::Default, ss.str()); } + +void SetLogger(const BSMPT::parser &argparser) +{ + try + { + argparser.get_value("logginglevel::disabled"); + Logger::Disable(); + return; + } + catch (BSMPT::parserException &) + { + } + + for (const auto &[prefix, enumValue] : LoggingPrefixes) + { + auto beginning = prefix.find_first_not_of("-"); + auto seperator = prefix.find("="); + std::string key = prefix.substr(beginning, seperator - beginning); + + try + { + auto value = argparser.get_value(key); + Logger::SetLevel(enumValue, value == "true"); + // Catch logginglevel::complete + if ((key == "logginglevel::complete") and (value == "true")) + { + for (const auto &[prefix_, enumValue_] : LoggingPrefixes) + Logger::SetLevel(enumValue_, true); + Logger::SetLevel(LoggingLevel::MinimizerDetailed, false); + } + } + catch (BSMPT::parserException &) + { + } + } +} + void SetLogger(const std::vector &args) { auto posDisable = @@ -64,6 +104,14 @@ void SetLogger(const std::vector &args) { Logger::SetLevel(pos->second, el.substr(pos->first.size()) == "true"); } + // Catch logginglevel::complete + if ((pos->second == LoggingLevel::Complete) and + (el.substr(pos->first.size()) == "true")) + { + for (const auto &[prefix, enumValue] : LoggingPrefixes) + Logger::SetLevel(enumValue, true); + Logger::SetLevel(LoggingLevel::MinimizerDetailed, false); + } } } @@ -102,6 +150,7 @@ void BSMPTLogger::SetOStream(const std::string &file) void BSMPTLogger::Disable() { + std::cout << "Disable logger" << std::endl; mCurrentSetup.clear(); } diff --git a/src/utility/NumericalDerivatives.cpp b/src/utility/NumericalDerivatives.cpp new file mode 100644 index 00000000..8eab467a --- /dev/null +++ b/src/utility/NumericalDerivatives.cpp @@ -0,0 +1,82 @@ +#include + +namespace BSMPT +{ + +std::vector +NablaNumerical(const std::vector &phi, + const std::function)> &f, + const double &eps) +{ + std::vector result(phi.size()); + + for (size_t i = 0; i < phi.size(); i++) + { + std::vector lp2 = phi; + lp2[i] += 2 * eps; + std::vector lp1 = phi; + lp1[i] += eps; + std::vector lm1 = phi; + lm1[i] -= eps; + std::vector lm2 = phi; + lm2[i] -= 2 * eps; + result[i] = (-f(lp2) + 8 * f(lp1) - 8 * f(lm1) + f(lm2)) / (12 * eps); + } + return result; +} + +std::vector> +HessianNumerical(const std::vector &phi, + const std::function)> &V, + double eps) +{ + std::vector> result(phi.size(), + std::vector(phi.size())); + for (size_t i = 0; i < phi.size(); i++) + { + double val = 0; + auto xp = phi; + xp[i] += 2 * eps; + val += V(xp); + + val -= 2 * V(phi); + + xp = phi; + xp[i] -= 2 * eps; + val += V(xp); + + result[i][i] = val / (4 * eps * eps); + + // https://en.wikipedia.org/wiki/Finite_difference + for (size_t j = i + 1; j < phi.size(); j++) + { + double r = 0; + + xp = phi; // F(x+h, y+h) + xp[i] += eps; + xp[j] += eps; + r += V(xp); + + xp = phi; //-F(x+h, y-h) + xp[i] += eps; + xp[j] -= eps; + r -= V(xp); + + xp = phi; //-F(x-h, y+h) + xp[i] -= eps; + xp[j] += eps; + r -= V(xp); + + xp = phi; // F(x-h, y-h) + xp[i] -= eps; + xp[j] -= eps; + r += V(xp); + + result[i][j] = r / (4 * eps * eps); + result[j][i] = r / (4 * eps * eps); + } + } + + return result; +} +} // namespace BSMPT \ No newline at end of file diff --git a/src/utility/asciiplotter/CMakeLists.txt b/src/utility/asciiplotter/CMakeLists.txt new file mode 100644 index 00000000..9c295266 --- /dev/null +++ b/src/utility/asciiplotter/CMakeLists.txt @@ -0,0 +1,19 @@ +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller +# +# SPDX-License-Identifier: GPL-3.0-or-later + +set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/utility/asciiplotter") +set(header ${header_path}/asciiplotter.h) +set(src asciiplotter.cpp) +add_library(ASCIIPlotter ${header} ${src}) +target_include_directories(ASCIIPlotter PUBLIC ${BSMPT_SOURCE_DIR}/include + ${BSMPT_BINARY_DIR}/include) +if(Boost_FOUND) + target_link_libraries(ASCIIPlotter PUBLIC Boost::boost) +endif() +target_compile_features(ASCIIPlotter PUBLIC cxx_std_17) + +if(nlohmann_json_FOUND) + target_link_libraries(ASCIIPlotter PRIVATE nlohmann_json::nlohmann_json) +endif() diff --git a/src/utility/asciiplotter/README.md b/src/utility/asciiplotter/README.md new file mode 100644 index 00000000..480c020a --- /dev/null +++ b/src/utility/asciiplotter/README.md @@ -0,0 +1,6 @@ +**joehood::asciiplotter** is a C++ package used to construct ASCII plots in text format as a quick way of checking the results. + +The source code can be found in [joehood's GitHub](https://github.com/joehood/asciiplotter) (commit [f32de9a](https://github.com/joehood/asciiplotter/tree/f32de9a66aca4aa19321f6e1a6d62af4a4f43377)). + +#### Modifications: +- Converted some ```int``` to ```std::size_t``` to avoid some warnings. \ No newline at end of file diff --git a/src/utility/asciiplotter/asciiplotter.cpp b/src/utility/asciiplotter/asciiplotter.cpp new file mode 100644 index 00000000..10651315 --- /dev/null +++ b/src/utility/asciiplotter/asciiplotter.cpp @@ -0,0 +1,505 @@ +/* +MIT License + +Copyright (c) 2017 Joe Hood + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include + +using namespace std; + +int max(vector data) +{ + int xmax = data[0]; + for (std::size_t i = 1; i < sizeof(data); i++) + { + if (data[i] > xmax) + { + xmax = data[i]; + } + } + return xmax; +} + +int min(vector data) +{ + int xmin = data[0]; + for (std::size_t i = 1; i < data.size(); i++) + { + if (data[i] < xmin) + { + xmin = data[i]; + } + } + return xmin; +} + +double max(vector data) +{ + double xmax = data[0]; + for (std::size_t i = 1; i < data.size(); i++) + { + if (data[i] > xmax) + { + xmax = data[i]; + } + } + return xmax; +} + +double min(vector data) +{ + double xmin = data[0]; + for (std::size_t i = 1; i < data.size(); i++) + { + if (data[i] < xmin) + { + xmin = data[i]; + } + } + return xmin; +} + +int max(int x1, int x2) +{ + if (x1 > x2) + { + return x1; + } + else + { + return x2; + } +} + +int min(int x1, int x2) +{ + if (x1 < x2) + { + return x1; + } + else + { + return x2; + } +} + +double max(double x1, double x2) +{ + if (x1 > x2) + { + return x1; + } + else + { + return x2; + } +} + +double min(double x1, double x2) +{ + if (x1 < x2) + { + return x1; + } + else + { + return x2; + } +} + +double +map(double x, double in_min, double in_max, double out_min, double out_max) +{ + return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; +} + +vector +resample(vector xdata, vector ydata, int newlength) +{ + int oldlength = ydata.size(); + vector newdata(newlength); + double x, y, x1, y1, x2, y2; + + if (oldlength == newlength) + { + return ydata; + } + else + { + for (int newindex = 0; newindex < newlength; newindex++) + { + x = (double)newindex / ((double)newlength - 1.0) * + (xdata.back() - xdata.front()) + + xdata.front(); + for (std::size_t ii = 0; ii < xdata.size() - 1; ii++) + if (x >= xdata[ii] and x <= xdata[ii + 1]) // Determine bin + { + x1 = xdata[ii]; + x2 = xdata[ii + 1]; + y1 = ydata[ii]; + y2 = ydata[ii + 1]; + y = y1 + (y2 - y1) * (x - x1) / (x2 - x1); + newdata[min(max(0, newindex), newlength - 1)] = y; + break; + } + } + newdata[0] = ydata[0]; + newdata[newlength - 1] = ydata[oldlength - 1]; + + return newdata; + } +} + +AsciiPlotter::AsciiPlotter() +{ + _title = ""; + _width = 100; + _height = 50; + _curves = 0; +} + +AsciiPlotter::AsciiPlotter(string title) +{ + _title = title; + _width = 100; + _height = 50; + _curves = 0; +} + +AsciiPlotter::AsciiPlotter(string title, int width, int height) +{ + _title = title; + _width = width; + _height = height; + _curves = 0; +} + +void AsciiPlotter::addPlot(vector xdata, + vector ydata, + string label = "", + char marker = ' ') +{ + _xdata[_curves] = xdata; + _markers[_curves] = marker; + _labels[_curves] = label; + _ydata[_curves++] = ydata; +} + +void AsciiPlotter::show() +{ + std::stringstream ss; + AsciiPlotter::show(ss); + cout << ss.str(); +} + +void AsciiPlotter::show(std::stringstream &ss) +{ + + double xmin = _xdata[0].front(); + double xmax = _xdata[0].back(); + + for (int curve = 0; curve < _curves; curve++) + { + xmin = min(xmin, _xdata[curve].front()); + xmax = max(xmax, _xdata[curve].back()); + } + + double ymax = 1.0e-15; + double ymin = 1.0e15; + + vector resampled; + vector> plane; + + int padding; + string lmargin = " "; + + plane.resize(_width); + for (int i = 0; i < _width; i++) + { + plane[i].resize(_height); + for (int j = 0; j < _height; j++) + { + plane[i][j] = ' '; + } + } + + for (int curve = 0; curve < _curves; curve++) + { + double mx = max(_ydata[curve]); + double mn = min(_ydata[curve]); + + if (mx > ymax) + { + ymax = mx; + } + + if (mn < ymin) + { + ymin = mn; + } + } + + for (int curve = 0; curve < _curves; curve++) + { + int nBefore = + floor(_width * (_xdata[curve].front() - xmin) / (xmax - xmin)); + int nAfter = floor(_width * (xmax - _xdata[curve].back()) / (xmax - xmin)); + resampled = + resample(_xdata[curve], _ydata[curve], _width - nBefore - nAfter); + for (std::size_t row = 0; row < resampled.size(); row++) + { + int colindex = (int)map(resampled[row], ymin, ymax, 0.0, (double)_height); + plane[nBefore + row][min(max(0, colindex), _height - 1)] = + _markers[curve]; + } + } + + // title: + + ss << endl << endl; + + for (std::size_t i = 0; + i < lmargin.length() + (_width - _title.length()) / 2 - 1; + i++) + { + ss << " "; + } + + ss << _title << endl << endl; + + // main plot plane: + + ss << std::setfill(' ') << std::setw(9) << std::setprecision(3) << ymax + << " +"; + + // sprintf(ss, " %8.2g +", ymax); + + for (int row = 0; row < _width; row++) + { + ss << "-"; + } + ss << "+" << endl; + + for (int col = _height - 1; col >= 0; col--) + { + if (col == _height / 2) + { + padding = lmargin.length() - _ylabel.length(); + if (padding >= 0) + { + int totwidth = 0; + for (int i = 0; i < padding - 1; i++) + { + ss << " "; + totwidth++; + } + ss << _ylabel; + for (std::size_t i = totwidth; i < lmargin.length() - _ylabel.length(); + i++) + { + ss << " "; + } + ss << "|"; + } + else + { + } + } + else + { + ss << lmargin << "|"; + } + for (int row = 0; row < _width; row++) + { + ss << plane[row][col]; + } + ss << "|" << endl; + } + + // printf(" %8.2g +", ymin); + ss << std::setfill(' ') << std::setw(9) << std::setprecision(3) << ymin + << " +"; + for (int row = 0; row < _width; row++) + { + ss << "-"; + } + ss << "+" << endl; + + ss << lmargin; + // printf("%-8.2g", xmin); + ss << xmin; + + int buf = (_width - _xlabel.length()) / 2; + for (int row = 0; row < buf; row++) + { + ss << " "; + } + + ss << _xlabel; + + for (int row = 0; row < buf; row++) + { + ss << " "; + } + + // printf("%8g", xmax); + ss << xmax; + + ss << endl << endl; + + // legend: + + if (_legend) + { + ss << lmargin << "+"; + for (int row = 0; row < _width; row++) + { + ss << "-"; + } + ss << "+" << endl; + + for (int curve = 0; curve < _curves; curve++) + { + ss << lmargin << "| " << _markers[curve] << " " << _labels[curve]; + + for (std::size_t i = 0; i < (_width - _labels[curve].length() - 5); i++) + { + ss << " "; + } + ss << "|" << endl; + } + + ss << lmargin << "+"; + for (int row = 0; row < _width; row++) + { + ss << "-"; + } + ss << "+" << endl; + } +} + +void AsciiPlotter::xlabel(string label) +{ + _xlabel = label; +} + +void AsciiPlotter::ylabel(string label) +{ + _ylabel = label; +} + +void AsciiPlotter::legend() +{ + _legend = true; +} + +void AsciiPlotter::example() +{ + _width = 120; + _height = 20; + + vector t(101); + vector a(101); + vector b(101); + vector c(101); + double A = 10.0; + + double dt = 0.0002; + + for (int i = 0; i < 101; i++) + { + if (i != 0) + { + t[i] = t[i - 1] + dt; + } + a[i] = A * sin(6.28 * 60.0 * t[i]); + b[i] = A * sin(6.28 * 60.0 * t[i] + 2.09); + c[i] = A * sin(6.28 * 60.0 * t[i] + 4.19); + } + + _title = "Three Phase Currents"; + _height = 20; + + AsciiPlotter::addPlot(t, a, "Ia", '.'); + AsciiPlotter::addPlot(t, b, "Ib", 'x'); + AsciiPlotter::addPlot(t, c, "Ic", '*'); + AsciiPlotter::legend(); + AsciiPlotter::xlabel("t (s)"); + AsciiPlotter::ylabel("I (A)"); + AsciiPlotter::show(); + + vector x(101); + vector f(101); + + dt = 0.05; + + for (int i = 0; i < 101; i++) + { + if (i != 0) + { + t[i] = t[i - 1] + dt; + } + + x[i] = sin(6.28 * t[i] - 2.0 * sin(6.28 * 0.2 * t[i])); + } + + _curves = 0; + _title = "FM Signal"; + + AsciiPlotter::addPlot(t, x, "Signal", 'x'); + + AsciiPlotter::legend(); + AsciiPlotter::xlabel("t (s)"); + AsciiPlotter::ylabel(""); + AsciiPlotter::show(); + + vector x1(101); + vector x2(101); + + dt = 0.2; + + for (int i = 0; i < 101; i++) + { + if (i != 0) + { + t[i] = t[i - 1] + dt; + } + x1[i] = sin(t[i]) * exp(-t[i] / 10); + x2[i] = cos(t[i]) * exp(-t[i] / 10); + } + + _curves = 0; + _title = "Dampened Sine Waves with Envelope"; + + AsciiPlotter::addPlot(t, x1, "sin(t) * exp(-t/10)", '*'); + AsciiPlotter::addPlot(t, x2, "cos(t) * exp(-t/10)", 'x'); + + AsciiPlotter::legend(); + AsciiPlotter::xlabel("t (s)"); + AsciiPlotter::ylabel(""); + AsciiPlotter::show(); +} + +AsciiPlotter::~AsciiPlotter() +{ + // do nothing +} diff --git a/src/utility/const_velocity_spline.cpp b/src/utility/const_velocity_spline.cpp new file mode 100644 index 00000000..907e39d5 --- /dev/null +++ b/src/utility/const_velocity_spline.cpp @@ -0,0 +1,337 @@ +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +/* + * spline.cpp + * + * cubic spline interpolation for path in VEV space using constant speed (in + * particular = 1) + * + * We use the lib spline.h to make a spline in each direction, the parameter is + * the linear length between the points (not important as long as it + * monotonically increasing) Then we make a thoroughly integration (Simpson 3/8 + * rule) to convert from linear length to spline length, and vice-versa. + * Interpolate using a spline + * + */ + +#include + +double cvspline::lin_abs_deriv( + double x) // Length of vector speed of non constant velocity spline +{ + double r = 0; + for (int i = 0; i < dim; i++) + { + r += std::pow(splines[i].deriv(1, x), 2); // Calculates the speed vector + } + return std::sqrt(r); +} +double cvspline::Simpson_step( + double t0, + double + t1) // Function to take single integration step using Simpson 3/8 rule + // https://en.wikipedia.org/wiki/Simpson%27s_rule#:~:text=Simpson%27s%20method.-,Simpson%27s%203/8%20rule%5Bedit%5D,-Simpson%27s%203/8 +{ + double r = lin_abs_deriv(t0); + r += 3 * lin_abs_deriv((2 * t0 + t1) / 3); + r += 3 * lin_abs_deriv((t0 + 2 * t1) / 3); + r += lin_abs_deriv(t1); + + return r * (t1 - t0) / 8; +} + +cvspline::cvspline() = default; // Default constructor + +cvspline::cvspline(const std::vector> &phipath_in) + : num_inter(10000) // Constructor +{ + this->phipath = phipath_in; + initialize(); +} + +cvspline::cvspline( + const std::vector> &phipath_in, + int input_num_inter) // Constructor with specified num of interpolations +{ + this->phipath = phipath_in; + num_inter = input_num_inter; + initialize(); +} + +void cvspline::initialize() // Initalizes the class +{ + dim = phipath[0].size(); + num_points = phipath.size(); + + if (phipath.size() == 2) // Cannot fit a spline with two points (or less), + // adding a middle point if len = 2 + { + std::vector middle_vector1; + std::vector middle_vector2; + + for (int i = 0; i < dim; i++) + { + middle_vector1.push_back(phipath[0][i] * 2 / 3 + + phipath[1][i] * 1 / + 3); // Calculates middle point + } + + for (int i = 0; i < dim; i++) + { + middle_vector2.push_back(phipath[0][i] * 1 / 3 + + phipath[1][i] * 2 / + 3); // Calculates middle point + } + phipath.insert(phipath.begin() + 1, + middle_vector1); // Adds it to the 2nd position + phipath.insert(phipath.begin() + 2, + middle_vector2); // Adds it to the 3nd position + + num_points = phipath.size(); + } + + std::vector direction; + lin_lengths = {0}; // Reset the list + for (std::size_t i = 1; i < phipath.size(); i++) + { + direction = phipath[i]; + for (int j = 0; j < dim; j++) + { + direction[j] -= phipath[i - 1][j]; + } + lin_lengths.push_back(lin_lengths.back() + BSMPT::L2NormVector(direction)); + } + + linL = + lin_lengths + .back(); // Linear Length is the last element of the list of lengths + + transposed_phi = BSMPT::Transpose( + phipath); // Transposes the path, helpfull when computing the spline + splines = {}; // Reset splines list + for (int i = 0; i < dim; i++) + { + tk::spline s(lin_lengths, + transposed_phi[i], + tk::spline::cspline, + false, + tk::spline::not_a_knot, + 0.0, + tk::spline::not_a_knot, + 0.0); + splines.push_back(s); + } + + list_l = {0}; // Reset the list + list_x = {0}; // Reset the list + + for (int i = 1; i <= num_inter; + i++) // Integrates the path using Simpson 3/8 rule to find the + // correspondence between x and l + { + double step = linL / num_inter; + list_l.push_back(list_l.back() + + Simpson_step(list_l.back(), list_l.back() + step)); + list_x.push_back(list_x.back() + step); + } + L = list_l.back(); // Set complet length of the path + // This method seems to be stable, l_to_x(x_to_l(value) = + // value + x_to_l.set_points(list_x, list_l); // Compute x to l spline + l_to_x.set_points(list_l, list_x); // Compute l to x spline + + vev_position = {}; // Reset the list + for (int i = 0; i < num_points; + i++) // Integrates the path using Simpson 3/8 rule to find the + // correspondence between x and l + { + vev_position.push_back(x_to_l(lin_lengths[i])); + } +} +void cvspline::add_point(const double &p, + const std::vector &new_vev, + const bool &compile) +{ + // Function to add a new vev "new_vev" at the position "p" + // We allow for p < 0 as an easy way to add a new true vacuum + // The position "p" is going to be rewritten when the path is recompiled + // It is necessary in order to disambiguate the order of the VEVs + + if (p < 0) + { + phipath.insert(phipath.begin(), new_vev); // Add VEV + if (compile) initialize(); // Redo calculations + return; + } + // We allow for p > L as an easy way to add a new false vacuum, no (good) + // reason to do this tho + if (p > L) + { + phipath.push_back(new_vev); // Add VEV + if (compile) initialize(); // Redo calculations + return; + } + + int lower = 0; // Index of lower bound + int upper = phipath.size(); // Index of upper bound + int lower_temp, upper_temp; // Floor/Ceil of the middle point + + while (upper - lower != + 1) // When upper - lower = 1 then we add the point at that position + { + + // Use the integer version of the bisection method + lower_temp = int(floor((upper + lower) / 2)); // Floor of the middle point + upper_temp = int(ceil((upper + lower) / 2)); // Ceiling of the middle point + + if ((vev_position[upper] == upper_temp) or + (vev_position[lower] == lower_temp)) + { + // Point already exists in the position "p", no point is added + BSMPT::Logger::Write(BSMPT::LoggingLevel::TransitionDetailed, + "Point in that position already exists!"); + return; + } + if (vev_position[lower_temp] < p) + { + lower = lower_temp; + } + if (vev_position[upper_temp] > p) + { + upper = upper_temp; + } + } + phipath.insert(phipath.begin() + upper, new_vev); // Add the point + vev_position.insert(vev_position.begin() + upper, + p); // Update the "vev_positions" list, very importante + // to initialize() after all new VEVs are added. + + if (compile) initialize(); // Redo calculations +} +std::vector cvspline::deriv(int order, double x) +{ + // Derivatives of spline with ( linear argument - speed with norm NOT equal + // to 1) + std::vector r; + for (int i = 0; i < dim; i++) + { + r.push_back(splines[i].deriv(order, x)); // Calculates the speed vector + } + return r; +} + +std::vector cvspline::dl(double l) +{ + // Vector speed of spline with size = 1 (this way is analytically) + std::vector r; + double tL = 0; + for (int i = 0; i < dim; i++) + { + r.push_back(splines[i].deriv(1, l_to_x(l))); // Calculates the speed vector + tL += r.back() * r.back(); // Calculates the length of the speed vector + } + tL = std::sqrt(tL); + for (int i = 0; i < dim; i++) + { + r[i] = r[i] / tL; // Normalizes speed vector + } + + return r; +} +std::vector cvspline::d2l(double l) +{ + // Normal acceleration (since v = 1 all acceleration is normal) of spline + // The analytical form seems less stable than the numerical one, + // i.e. numerical(| gamma'(s).gamma''(s) |) < | gamma'(s).gamma''(s) | which + // should be zero We're still going to use the analytical version in the + // meanwhile + + std::vector rr, gammaPPx, gammaPl; + double dldxSqrd, d2ld2x; + + double x = l_to_x(l); + + gammaPPx = deriv(2, x); // Gamma''(x) + gammaPl = dl(l); // Gamma'(l) + dldxSqrd = std::pow(x_to_l.deriv(1, x), 2); // dldx(l)^2 = l'(x)^2 + d2ld2x = x_to_l.deriv(2, x); // d2ldx(l) = l''(x) + + for (int i = 0; i < dim; i++) + { + rr.push_back((gammaPPx[i] - gammaPl[i] * d2ld2x) / dldxSqrd); + } + + return rr; +} +std::vector cvspline::operator()(double l) const +{ + // Calculates the VEV at the position l in spline length, + l = l_to_x(l); // Convert from spline length to linear length. + std::vector r; + for (int i = 0; i < dim; i++) + { + r.push_back(splines[i](l)); + } + return r; +} + +void cvspline::print_path() const +{ + int wid = 15; + + std::stringstream ss; + + ss << std::string(15 * (dim + 2), '-') << std::endl; + ss << std::setw(5) << std::right << "id" << std::setw(wid) << std::right + << "l"; + + for (int i = 0; i < dim; i++) + { + ss << std::setw(wid) << std::right << ("Field " + std::to_string(i)) + << std::setw(wid) << std::right; + } + + ss << "\n" << std::string(15 * (dim + 2), '-') << std::endl; + + for (int i = 0; i < num_points; i++) + { + + ss << std::setw(5) << std::right << i << std::setw(wid) << std::right + << vev_position[i] << std::setw(wid) << std::right; + for (int j = 0; j < dim; j++) + { + ss << phipath[i][j] << std::setw(wid) << std::right; + } + ss << " " << std::endl; + } + ss << std::string(15 * (dim + 2), '-') << std::endl; + + BSMPT::Logger::Write(BSMPT::LoggingLevel::BounceDetailed, ss.str()); +} +void cvspline::save_path(const std::string &file_name, const bool &header) +{ + std::ofstream myfile; + myfile.open(file_name); + if (header) + { + for (int i = 0; i < dim; i++) + { + myfile << "field " << i << "\t"; + } + myfile << "\n"; + } + for (int i = 0; i < num_points; i++) + { + for (int j = 0; j < dim; j++) + { + myfile << phipath[i][j] << "\t"; + } + myfile << " " + << "\n"; + } + + myfile.close(); +} diff --git a/src/utility/parser.cpp b/src/utility/parser.cpp new file mode 100644 index 00000000..2f838bb4 --- /dev/null +++ b/src/utility/parser.cpp @@ -0,0 +1,450 @@ +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include +#include +#include +#include + +#ifdef nlohmann_json_FOUND +#include +#include +#endif + +namespace BSMPT +{ + +parserException::parserException(const std::string &msg) : message{msg} +{ +} + +const char *parserException::what() const noexcept +{ + return message.c_str(); +} + +parser::parser() +{ + add_argument("logginglevel::default", + "Turn on/off (true/false) the default output.", + false); + add_argument("logginglevel::debug", + "Turn on/off (true/false) the debug output for the logger.", + false); + add_argument("logginglevel::disabled", "Disable the Logger.", false); + + add_argument("logginglevel::ewbgdetailed", + "Turn on/off (true/false) the output for the EWBG calculation.", + false); + add_argument( + "logginglevel::progdetailed", + "Turn on/off (true/false) the additional output for the main program.", + false); + add_argument( + "logginglevel::minimizerdetailed", + "Turn on/off (true/false) the additional output of the minimizers.", + false); + + add_argument("json", + "Use a json file to define the input instead of additional cli " + "parameters.", + false); +} + +parser::parser(const bool &enable_column_output) +{ + this->extra_column_output = enable_column_output; + + add_argument("logginglevel::default", "default output", "true", false); + add_argument("logginglevel::debug", "debug output", "false", false); + add_argument("logginglevel::disabled", "disable all output", "", false); + add_argument("logginglevel::ewbgdetailed", + "baryogenesis calculation output", + "false", + false); + add_argument( + "logginglevel::progdetailed", "executable output", "false", false); + add_argument( + "logginglevel::minimizerdetailed", "minimizer output", "false", false); + add_argument("logginglevel::transitiondetailed", + "transition calculation output", + "false", + false); + add_argument("logginglevel::mintracerdetailed", + "minimum tracking output", + "false", + false); + add_argument("logginglevel::bouncedetailed", + "bounce solution calculation output", + "false", + false); + add_argument("logginglevel::gwdetailed", + "gravitational wave calculation output", + "false", + false); + add_argument("logginglevel::complete", + "enable all except minimizer output", + "false", + false); +} + +void parser::enable_minimizer_options() +{ + add_argument("useGSL", + "Use the GSL library to minimize the effective potential.", + false); + add_argument("useCMAES", + "Use the CMAES library to minimize the effective potential", + false); + add_argument("useNLopt", + "Use the NLopt library to minimize the effective potential", + false); + add_argument("useMultithreading", + "Enables/Disables multi threading for the minimizers", + false); +} + +void parser::add_argument_only_display(const std::string &argument, + const std::string &description, + const std::string &default_val) +{ + auto arg = to_lower(argument); + Options options; + options.argument = argument; + options.description = description; + options.default_val = default_val; + + mOrderedArguments.push_back(std::pair(arg, options)); +} + +void parser::add_argument(const std::string &argument, bool required) +{ + auto arg = to_lower(argument); + Options options; + options.argument = argument; + options.value = std::nullopt; + + if (required) + { + mRequiredArguments.emplace(arg, options); + } + else + { + mOptionalArguments.emplace(arg, options); + } +} + +void parser::add_argument(const std::string &argument, + const std::string &description, + bool required) +{ + auto arg = to_lower(argument); + Options options; + options.argument = argument; + options.description = description; + options.value = std::nullopt; + + mOrderedArguments.push_back(std::pair(arg, options)); + + if (required) + { + mRequiredArguments.emplace(arg, options); + } + else + { + mOptionalArguments.emplace(arg, options); + } +} + +void parser::add_argument(const std::string &argument, + const std::string &description, + const std::string &default_val, + bool required) +{ + auto arg = to_lower(argument); + Options options; + options.argument = argument; + options.description = description; + options.value = std::nullopt; + options.default_val = default_val; + + mOrderedArguments.push_back(std::pair(arg, options)); + + if (required) + { + mRequiredArguments.emplace(arg, options); + } + else + { + mOptionalArguments.emplace(arg, options); + } +} + +void parser::add_subtext(const std::string &subtext) +{ + Options options; + options.description = subtext; + mOrderedArguments.push_back( + std::pair("subtext", options)); +} + +void parser::add_input(const std::vector &input) +{ + if (input.size() == 1) + { + std::string arg{input.at(0)}; + auto [argument, value] = get_key_value(arg); + if (argument == "help") + { + print_help(); + return; + } + else if (argument == "json") + { +#ifdef nlohmann_json_FOUND + add_json_input(value); + return; +#else + throw parserException( + "nlohmann_json is required for the json config file."); +#endif + } + } + + std::vector sepInput; + for (const auto &arg : input) + { + sepInput.emplace_back(get_key_value(arg)); + } + add_input(sepInput); +} + +bool parser::all_required_set() const +{ + for (const auto &[key, value] : mRequiredArguments) + { + (void)key; + if (not value.value.has_value()) + { + Logger::Write(LoggingLevel::Default, + "The required parameter " + key + " is not set."); + return false; + } + } + return true; +} + +void parser::check_required_parameters() const +{ + if (not all_required_set()) + { + print_help(); + throw parserException("Not all required parameters are set."); + } +} + +void parser::print_help() const +{ + if (mHelpAlreadyPrinted) + { + return; + } + mHelpAlreadyPrinted = true; + std::stringstream ss, ss_end; + ss << mHeader << std::endl; + ss_end << "The following options for the Logger are available:\n\n"; + + int size_first_column = 37; + int size_second_column = 10; + if (extra_column_output) + { + ss << std::setw(size_first_column) << std::left << "argument" + << std::setw(size_second_column) << std::left << "default" + << "description" << std::endl; + + for (const auto &el : mOrderedArguments) + { + if (el.first == "subtext") + { + ss << std::setw(size_first_column) << std::left << "" + << std::setw(size_second_column) << std::left << "" + << el.second.description << std::endl; + } + else if (StringStartsWith(el.second.argument, "logginglevel")) + { + if (el.second.argument.find("disable")) + { + ss_end << std::setw(size_first_column) << std::left + << "--" + el.second.argument << std::setw(size_second_column) + << std::left << el.second.default_val << el.second.description + << std::endl; + } + else + { + ss_end << std::setw(size_first_column) << std::left + << "--" + el.second.argument + "=" + << std::setw(size_second_column) << std::left + << el.second.default_val << el.second.description << std::endl; + } + } + else if (StringStartsWith(el.second.argument, "help")) + { + ss << std::setw(size_first_column) << std::left + << "--" + el.second.argument << std::setw(size_second_column) + << std::left << el.second.default_val << el.second.description + << std::endl; + } + else + { + ss << std::setw(size_first_column) << std::left + << "--" + el.second.argument + "=" << std::setw(size_second_column) + << std::left << el.second.default_val << el.second.description + << std::endl; + } + } + Logger::Write(LoggingLevel::Default, ss.str()); + Logger::Write(LoggingLevel::Default, ss_end.str()); + ShowInputError(); + } + else + { + ss << "The required options are:" << std::endl; + for (const auto &[arg, options] : mRequiredArguments) + { + (void)arg; + ss << "--" << options.argument << "=\t" << options.description + << std::endl; + } + ss << "The optional arguments are:" << std::endl; + for (const auto &[arg, options] : mOptionalArguments) + { + (void)arg; + ss << "--" << options.argument << "=\t" << options.description + << std::endl; + } + Logger::Write(LoggingLevel::Default, ss.str()); + } +} + +std::string parser::get_value_as_string(const std::string &argument) const +{ + auto throwError = [](const std::string &arg) + { throw parserException("Option " + arg + " is not defined."); }; + auto arg = to_lower(argument); + if (auto posReq = mRequiredArguments.find(arg); + posReq != mRequiredArguments.end()) + { + auto &optVal = posReq->second.value; + if (not optVal.has_value()) + { + throwError(argument); + } + return optVal.value(); + } + else if (auto posOpt = mOptionalArguments.find(arg); + posOpt != mOptionalArguments.end()) + { + auto &optVal = posOpt->second.value; + if (not optVal.has_value()) + { + throwError(argument); + } + return optVal.value(); + } + else + { + throwError(argument); + } + return std::string(); +} + +void parser::add_json_input(const std::string &filename) +{ +#ifdef nlohmann_json_FOUND + using json = nlohmann::json; + std::ifstream f(filename); + if (not f.good()) + { + throw parserException("Can not open the json file " + filename); + } + json data = json::parse(f); + std::vector input; + for (const auto &[key, value] : data.items()) + { + if (StringEndsWith(key, "_comment")) + { + continue; + } + input.push_back({key, value.get()}); + } + add_input(input); +#else + throw parserException("nlohmann_json is required."); +#endif +} +void parser::set_help_header(const std::string &header) +{ + mHeader = header; +} + +void parser::add_input(const std::vector &input) +{ + auto throwError = [](const std::string &argument) { + throw parserException("Argument " + argument + " found but not expected."); + }; + for (const auto &arg : input) + { + auto argument = to_lower(arg.key); + if (argument == "help") + { + print_help(); + } + else + { + if (auto pos = mRequiredArguments.find(argument); + pos != mRequiredArguments.end()) + { + pos->second.value = arg.value; + } + else if (auto posOptional = mOptionalArguments.find(argument); + posOptional != mOptionalArguments.end()) + { + posOptional->second.value = arg.value; + } + else + { + throwError(argument); + } + } + } + SetLogger(*this); +} + +parser::KeyValue parser::get_key_value(const std::string &input) +{ + auto beginning = input.find_first_not_of("-"); + auto seperator = input.find("="); + if (seperator == std::string::npos) + { + seperator = input.find(" "); + } + std::string key = input.substr(beginning, seperator - beginning); + std::string value = input.substr(seperator + 1, input.size()); + return {key, value}; +} + +std::string parser::to_lower(const std::string &input) const +{ + auto arg = input; + std::transform(arg.begin(), + arg.end(), + arg.begin(), + [](unsigned char c) { return std::tolower(c); }); + return arg; +} + +} // namespace BSMPT diff --git a/src/utility/spline/CMakeLists.txt b/src/utility/spline/CMakeLists.txt new file mode 100644 index 00000000..1b630dc8 --- /dev/null +++ b/src/utility/spline/CMakeLists.txt @@ -0,0 +1,21 @@ +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller +# +# SPDX-License-Identifier: GPL-3.0-or-later + +set(header_path "${BSMPT_SOURCE_DIR}/include/BSMPT/utility/spline") +set(header ${header_path}/spline.h) +set(src spline.cpp) +add_library(Spline ${header} ${src}) +target_include_directories(Spline PUBLIC ${BSMPT_SOURCE_DIR}/include + ${BSMPT_BINARY_DIR}/include) +if(Boost_FOUND) + target_link_libraries(Spline PUBLIC Boost::boost) +endif() +target_compile_features(Spline PUBLIC cxx_std_17) + +if(nlohmann_json_FOUND) + target_link_libraries(Spline PRIVATE nlohmann_json::nlohmann_json) +endif() + +target_compile_definitions(Spline PRIVATE _USE_MATH_DEFINES) diff --git a/src/utility/spline/README.md b/src/utility/spline/README.md new file mode 100644 index 00000000..75de14e1 --- /dev/null +++ b/src/utility/spline/README.md @@ -0,0 +1,6 @@ +**tk::spline** is a C++ package used to construct cubic splines. + +The source code can be found in [ttk592's GitHub](https://github.com/ttk592/spline) (commit [5894bea](https://github.com/ttk592/spline/tree/5894beaf91e9adbfdbe5c6c9a1c60770e380e8e8)) and the documentation at https://kluge.in-chemnitz.de/. + +#### Modifications: +- Split the code into declarations and implementations. \ No newline at end of file diff --git a/src/utility/spline/spline.cpp b/src/utility/spline/spline.cpp new file mode 100644 index 00000000..9060bb9c --- /dev/null +++ b/src/utility/spline/spline.cpp @@ -0,0 +1,870 @@ +/* + * spline.h + * + * simple cubic spline interpolation library without external + * dependencies + * + * --------------------------------------------------------------------- + * Copyright (C) 2011, 2014, 2016, 2021 Tino Kluge (ttk448 at gmail.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * --------------------------------------------------------------------- + * + */ + +#include + +namespace tk +{ + +// --------------------------------------------------------------------- +// implementation part, which could be separated into a cpp file +// --------------------------------------------------------------------- + +// spline implementation +// ----------------------- + +void spline::set_boundary(spline::bd_type left, + double left_value, + spline::bd_type right, + double right_value) +{ + assert(m_x.size() == 0); // set_points() must not have happened yet + m_left = left; + m_right = right; + m_left_value = left_value; + m_right_value = right_value; +} + +void spline::set_coeffs_from_b() +{ + assert(m_x.size() == m_y.size()); + assert(m_x.size() == m_b.size()); + assert(m_x.size() > 2); + size_t n = m_b.size(); + if (m_c.size() != n) m_c.resize(n); + if (m_d.size() != n) m_d.resize(n); + + for (std::size_t i = 0; i < n - 1; i++) + { + const double h = m_x[i + 1] - m_x[i]; + // from continuity and differentiability condition + m_c[i] = + (3.0 * (m_y[i + 1] - m_y[i]) / h - (2.0 * m_b[i] + m_b[i + 1])) / h; + // from differentiability condition + m_d[i] = ((m_b[i + 1] - m_b[i]) / (3.0 * h) - 2.0 / 3.0 * m_c[i]) / h; + } + + // for left extrapolation coefficients + m_c0 = (m_left == first_deriv) ? 0.0 : m_c[0]; +} + +void spline::set_points(const std::vector &x, + const std::vector &y, + spline_type type) +{ + assert(x.size() == y.size()); + assert(x.size() >= 3); + // not-a-knot with 3 points has many solutions + if (m_left == not_a_knot || m_right == not_a_knot) assert(x.size() >= 4); + m_type = type; + m_made_monotonic = false; + m_x = x; + m_y = y; + int n = (int)x.size(); + // check strict monotonicity of input vector x + for (int i = 0; i < n - 1; i++) + { + assert(m_x[i] < m_x[i + 1]); + } + + if (type == linear) + { + // linear interpolation + m_d.resize(n); + m_c.resize(n); + m_b.resize(n); + for (int i = 0; i < n - 1; i++) + { + m_d[i] = 0.0; + m_c[i] = 0.0; + m_b[i] = (m_y[i + 1] - m_y[i]) / (m_x[i + 1] - m_x[i]); + } + // ignore boundary conditions, set slope equal to the last segment + m_b[n - 1] = m_b[n - 2]; + m_c[n - 1] = 0.0; + m_d[n - 1] = 0.0; + } + else if (type == cspline) + { + // classical cubic splines which are C^2 (twice cont differentiable) + // this requires solving an equation system + + // setting up the matrix and right hand side of the equation system + // for the parameters b[] + int n_upper = (m_left == spline::not_a_knot) ? 2 : 1; + int n_lower = (m_right == spline::not_a_knot) ? 2 : 1; + internal::band_matrix A(n, n_upper, n_lower); + std::vector rhs(n); + for (int i = 1; i < n - 1; i++) + { + A(i, i - 1) = 1.0 / 3.0 * (x[i] - x[i - 1]); + A(i, i) = 2.0 / 3.0 * (x[i + 1] - x[i - 1]); + A(i, i + 1) = 1.0 / 3.0 * (x[i + 1] - x[i]); + rhs[i] = (y[i + 1] - y[i]) / (x[i + 1] - x[i]) - + (y[i] - y[i - 1]) / (x[i] - x[i - 1]); + } + // boundary conditions + if (m_left == spline::second_deriv) + { + // 2*c[0] = f'' + A(0, 0) = 2.0; + A(0, 1) = 0.0; + rhs[0] = m_left_value; + } + else if (m_left == spline::first_deriv) + { + // b[0] = f', needs to be re-expressed in terms of c: + // (2c[0]+c[1])(x[1]-x[0]) = 3 ((y[1]-y[0])/(x[1]-x[0]) - f') + A(0, 0) = 2.0 * (x[1] - x[0]); + A(0, 1) = 1.0 * (x[1] - x[0]); + rhs[0] = 3.0 * ((y[1] - y[0]) / (x[1] - x[0]) - m_left_value); + } + else if (m_left == spline::not_a_knot) + { + // f'''(x[1]) exists, i.e. d[0]=d[1], or re-expressed in c: + // -h1*c[0] + (h0+h1)*c[1] - h0*c[2] = 0 + A(0, 0) = -(x[2] - x[1]); + A(0, 1) = x[2] - x[0]; + A(0, 2) = -(x[1] - x[0]); + rhs[0] = 0.0; + } + else + { + assert(false); + } + if (m_right == spline::second_deriv) + { + // 2*c[n-1] = f'' + A(n - 1, n - 1) = 2.0; + A(n - 1, n - 2) = 0.0; + rhs[n - 1] = m_right_value; + } + else if (m_right == spline::first_deriv) + { + // b[n-1] = f', needs to be re-expressed in terms of c: + // (c[n-2]+2c[n-1])(x[n-1]-x[n-2]) + // = 3 (f' - (y[n-1]-y[n-2])/(x[n-1]-x[n-2])) + A(n - 1, n - 1) = 2.0 * (x[n - 1] - x[n - 2]); + A(n - 1, n - 2) = 1.0 * (x[n - 1] - x[n - 2]); + rhs[n - 1] = + 3.0 * (m_right_value - (y[n - 1] - y[n - 2]) / (x[n - 1] - x[n - 2])); + } + else if (m_right == spline::not_a_knot) + { + // f'''(x[n-2]) exists, i.e. d[n-3]=d[n-2], or re-expressed in c: + // -h_{n-2}*c[n-3] + (h_{n-3}+h_{n-2})*c[n-2] - h_{n-3}*c[n-1] = 0 + A(n - 1, n - 3) = -(x[n - 1] - x[n - 2]); + A(n - 1, n - 2) = x[n - 1] - x[n - 3]; + A(n - 1, n - 1) = -(x[n - 2] - x[n - 3]); + rhs[0] = 0.0; + } + else + { + assert(false); + } + + // solve the equation system to obtain the parameters c[] + m_c = A.lu_solve(rhs); + + // calculate parameters b[] and d[] based on c[] + m_d.resize(n); + m_b.resize(n); + for (int i = 0; i < n - 1; i++) + { + m_d[i] = 1.0 / 3.0 * (m_c[i + 1] - m_c[i]) / (x[i + 1] - x[i]); + m_b[i] = (y[i + 1] - y[i]) / (x[i + 1] - x[i]) - + 1.0 / 3.0 * (2.0 * m_c[i] + m_c[i + 1]) * (x[i + 1] - x[i]); + } + // for the right extrapolation coefficients (zero cubic term) + // f_{n-1}(x) = y_{n-1} + b*(x-x_{n-1}) + c*(x-x_{n-1})^2 + double h = x[n - 1] - x[n - 2]; + // m_c[n-1] is determined by the boundary condition + m_d[n - 1] = 0.0; + m_b[n - 1] = 3.0 * m_d[n - 2] * h * h + 2.0 * m_c[n - 2] * h + + m_b[n - 2]; // = f'_{n-2}(x_{n-1}) + if (m_right == first_deriv) m_c[n - 1] = 0.0; // force linear extrapolation + } + else if (type == cspline_hermite) + { + // hermite cubic splines which are C^1 (cont. differentiable) + // and derivatives are specified on each grid point + // (here we use 3-point finite differences) + m_b.resize(n); + m_c.resize(n); + m_d.resize(n); + // set b to match 1st order derivative finite difference + for (int i = 1; i < n - 1; i++) + { + const double h = m_x[i + 1] - m_x[i]; + const double hl = m_x[i] - m_x[i - 1]; + m_b[i] = -h / (hl * (hl + h)) * m_y[i - 1] + + (h - hl) / (hl * h) * m_y[i] + hl / (h * (hl + h)) * m_y[i + 1]; + } + // boundary conditions determine b[0] and b[n-1] + if (m_left == first_deriv) + { + m_b[0] = m_left_value; + } + else if (m_left == second_deriv) + { + const double h = m_x[1] - m_x[0]; + m_b[0] = 0.5 * + (-m_b[1] - 0.5 * m_left_value * h + 3.0 * (m_y[1] - m_y[0]) / h); + } + else if (m_left == not_a_knot) + { + // f''' continuous at x[1] + const double h0 = m_x[1] - m_x[0]; + const double h1 = m_x[2] - m_x[1]; + m_b[0] = -m_b[1] + 2.0 * (m_y[1] - m_y[0]) / h0 + + h0 * h0 / (h1 * h1) * + (m_b[1] + m_b[2] - 2.0 * (m_y[2] - m_y[1]) / h1); + } + else + { + assert(false); + } + if (m_right == first_deriv) + { + m_b[n - 1] = m_right_value; + m_c[n - 1] = 0.0; + } + else if (m_right == second_deriv) + { + const double h = m_x[n - 1] - m_x[n - 2]; + m_b[n - 1] = 0.5 * (-m_b[n - 2] + 0.5 * m_right_value * h + + 3.0 * (m_y[n - 1] - m_y[n - 2]) / h); + m_c[n - 1] = 0.5 * m_right_value; + } + else if (m_right == not_a_knot) + { + // f''' continuous at x[n-2] + const double h0 = m_x[n - 2] - m_x[n - 3]; + const double h1 = m_x[n - 1] - m_x[n - 2]; + m_b[n - 1] = + -m_b[n - 2] + 2.0 * (m_y[n - 1] - m_y[n - 2]) / h1 + + h1 * h1 / (h0 * h0) * + (m_b[n - 3] + m_b[n - 2] - 2.0 * (m_y[n - 2] - m_y[n - 3]) / h0); + // f'' continuous at x[n-1]: c[n-1] = 3*d[n-2]*h[n-2] + c[n-1] + m_c[n - 1] = (m_b[n - 2] + 2.0 * m_b[n - 1]) / h1 - + 3.0 * (m_y[n - 1] - m_y[n - 2]) / (h1 * h1); + } + else + { + assert(false); + } + m_d[n - 1] = 0.0; + + // parameters c and d are determined by continuity and differentiability + set_coeffs_from_b(); + } + else + { + assert(false); + } + + // for left extrapolation coefficients + m_c0 = (m_left == first_deriv) ? 0.0 : m_c[0]; +} + +bool spline::make_monotonic() +{ + assert(m_x.size() == m_y.size()); + assert(m_x.size() == m_b.size()); + assert(m_x.size() > 2); + bool modified = false; + const int n = (int)m_x.size(); + // make sure: input data monotonic increasing --> b_i>=0 + // input data monotonic decreasing --> b_i<=0 + for (int i = 0; i < n; i++) + { + int im1 = std::max(i - 1, 0); + int ip1 = std::min(i + 1, n - 1); + if (((m_y[im1] <= m_y[i]) && (m_y[i] <= m_y[ip1]) && m_b[i] < 0.0) || + ((m_y[im1] >= m_y[i]) && (m_y[i] >= m_y[ip1]) && m_b[i] > 0.0)) + { + modified = true; + m_b[i] = 0.0; + } + } + // if input data is monotonic (b[i], b[i+1], avg have all the same sign) + // ensure a sufficient criteria for monotonicity is satisfied: + // std::sqrt(b[i]^2+b[i+1]^2) <= 3 |avg|, with avg=(y[i+1]-y[i])/h, + for (int i = 0; i < n - 1; i++) + { + double h = m_x[i + 1] - m_x[i]; + double avg = (m_y[i + 1] - m_y[i]) / h; + if (avg == 0.0 && (m_b[i] != 0.0 || m_b[i + 1] != 0.0)) + { + modified = true; + m_b[i] = 0.0; + m_b[i + 1] = 0.0; + } + else if ((m_b[i] >= 0.0 && m_b[i + 1] >= 0.0 && avg > 0.0) || + (m_b[i] <= 0.0 && m_b[i + 1] <= 0.0 && avg < 0.0)) + { + // input data is monotonic + double r = + std::sqrt(m_b[i] * m_b[i] + m_b[i + 1] * m_b[i + 1]) / std::fabs(avg); + if (r > 3.0) + { + // sufficient criteria for monotonicity: r<=3 + // adjust b[i] and b[i+1] + modified = true; + m_b[i] *= (3.0 / r); + m_b[i + 1] *= (3.0 / r); + } + } + } + + if (modified == true) + { + set_coeffs_from_b(); + m_made_monotonic = true; + } + + return modified; +} + +// return the closest idx so that m_x[idx] <= x (return 0 if x::const_iterator it; + it = std::upper_bound(m_x.begin(), m_x.end(), x); // *it > x + size_t idx = std::max(int(it - m_x.begin()) - 1, 0); // m_x[idx] <= x + return idx; +} + +double spline::operator()(double x) const +{ + // polynomial evaluation using Horner's scheme + // TODO: consider more numerically accurate algorithms, e.g.: + // - Clenshaw + // - Even-Odd method by A.C.R. Newbery + // - Compensated Horner Scheme + size_t n = m_x.size(); + size_t idx = find_closest(x); + + double h = x - m_x[idx]; + double interpol; + if (x < m_x[0]) + { + // extrapolation to the left + interpol = (m_c0 * h + m_b[0]) * h + m_y[0]; + } + else if (x > m_x[n - 1]) + { + // extrapolation to the right + interpol = (m_c[n - 1] * h + m_b[n - 1]) * h + m_y[n - 1]; + } + else + { + // interpolation + interpol = ((m_d[idx] * h + m_c[idx]) * h + m_b[idx]) * h + m_y[idx]; + } + return interpol; +} + +double spline::deriv(int order, double x) const +{ + assert(order > 0); + size_t n = m_x.size(); + size_t idx = find_closest(x); + + double h = x - m_x[idx]; + double interpol; + if (x < m_x[0]) + { + // extrapolation to the left + switch (order) + { + case 1: interpol = 2.0 * m_c0 * h + m_b[0]; break; + case 2: interpol = 2.0 * m_c0; break; + default: interpol = 0.0; break; + } + } + else if (x > m_x[n - 1]) + { + // extrapolation to the right + switch (order) + { + case 1: interpol = 2.0 * m_c[n - 1] * h + m_b[n - 1]; break; + case 2: interpol = 2.0 * m_c[n - 1]; break; + default: interpol = 0.0; break; + } + } + else + { + // interpolation + switch (order) + { + case 1: + interpol = (3.0 * m_d[idx] * h + 2.0 * m_c[idx]) * h + m_b[idx]; + break; + case 2: interpol = 6.0 * m_d[idx] * h + 2.0 * m_c[idx]; break; + case 3: interpol = 6.0 * m_d[idx]; break; + default: interpol = 0.0; break; + } + } + return interpol; +} + +std::vector spline::solve(double y, bool ignore_extrapolation) const +{ + std::vector x; // roots for the entire spline + std::vector root; // roots for each piecewise cubic + const size_t n = m_x.size(); + + // left extrapolation + if (ignore_extrapolation == false) + { + root = internal::solve_cubic(m_y[0] - y, m_b[0], m_c0, 0.0, 1); + for (std::size_t j = 0; j < root.size(); j++) + { + if (root[j] < 0.0) + { + x.push_back(m_x[0] + root[j]); + } + } + } + + // brute force check if piecewise cubic has roots in their resp. segment + // TODO: make more efficient + for (std::size_t i = 0; i < n - 1; i++) + { + root = internal::solve_cubic(m_y[i] - y, m_b[i], m_c[i], m_d[i], 1); + for (std::size_t j = 0; j < root.size(); j++) + { + double h = (i > 0) ? (m_x[i] - m_x[i - 1]) : 0.0; + double eps = internal::get_eps() * 512.0 * std::min(h, 1.0); + if ((-eps <= root[j]) && (root[j] < m_x[i + 1] - m_x[i])) + { + double new_root = m_x[i] + root[j]; + if (x.size() > 0 && x.back() + eps > new_root) + { + x.back() = new_root; // avoid spurious duplicate roots + } + else + { + x.push_back(new_root); + } + } + } + } + + // right extrapolation + if (ignore_extrapolation == false) + { + root = + internal::solve_cubic(m_y[n - 1] - y, m_b[n - 1], m_c[n - 1], 0.0, 1); + for (std::size_t j = 0; j < root.size(); j++) + { + if (0.0 <= root[j]) + { + x.push_back(m_x[n - 1] + root[j]); + } + } + } + + return x; +} + +namespace internal +{ + +// band_matrix implementation +// ------------------------- + +band_matrix::band_matrix(int dim, int n_u, int n_l) +{ + resize(dim, n_u, n_l); +} +void band_matrix::resize(int dim, int n_u, int n_l) +{ + assert(dim > 0); + assert(n_u >= 0); + assert(n_l >= 0); + m_upper.resize(n_u + 1); + m_lower.resize(n_l + 1); + for (std::size_t i = 0; i < m_upper.size(); i++) + { + m_upper[i].resize(dim); + } + for (std::size_t i = 0; i < m_lower.size(); i++) + { + m_lower[i].resize(dim); + } +} +int band_matrix::dim() const +{ + if (m_upper.size() > 0) + { + return m_upper[0].size(); + } + else + { + return 0; + } +} + +// defines the new operator (), so that we can access the elements +// by A(i,j), index going from i=0,...,dim()-1 +double &band_matrix::operator()(int i, int j) +{ + int k = j - i; // what band is the entry + assert((i >= 0) && (i < dim()) && (j >= 0) && (j < dim())); + assert((-num_lower() <= k) && (k <= num_upper())); + // k=0 -> diagonal, k<0 lower left part, k>0 upper right part + if (k >= 0) + return m_upper[k][i]; + else + return m_lower[-k][i]; +} +double band_matrix::operator()(int i, int j) const +{ + int k = j - i; // what band is the entry + assert((i >= 0) && (i < dim()) && (j >= 0) && (j < dim())); + assert((-num_lower() <= k) && (k <= num_upper())); + // k=0 -> diagonal, k<0 lower left part, k>0 upper right part + if (k >= 0) + return m_upper[k][i]; + else + return m_lower[-k][i]; +} +// second diag (used in LU decomposition), saved in m_lower +double band_matrix::saved_diag(int i) const +{ + assert((i >= 0) && (i < dim())); + return m_lower[0][i]; +} +double &band_matrix::saved_diag(int i) +{ + assert((i >= 0) && (i < dim())); + return m_lower[0][i]; +} + +// LR-Decomposition of a band matrix +void band_matrix::lu_decompose() +{ + int i_max, j_max; + int j_min; + double x; + + // preconditioning + // normalize column i so that a_ii=1 + for (int i = 0; i < this->dim(); i++) + { + assert(this->operator()(i, i) != 0.0); + this->saved_diag(i) = 1.0 / this->operator()(i, i); + j_min = std::max(0, i - this->num_lower()); + j_max = std::min(this->dim() - 1, i + this->num_upper()); + for (int j = j_min; j <= j_max; j++) + { + this->operator()(i, j) *= this->saved_diag(i); + } + this->operator()(i, i) = 1.0; // prevents rounding errors + } + + // Gauss LR-Decomposition + for (int k = 0; k < this->dim(); k++) + { + i_max = std::min(this->dim() - 1, + k + this->num_lower()); // num_lower not a mistake! + for (int i = k + 1; i <= i_max; i++) + { + assert(this->operator()(k, k) != 0.0); + x = -this->operator()(i, k) / this->operator()(k, k); + this->operator()(i, k) = -x; // assembly part of L + j_max = std::min(this->dim() - 1, k + this->num_upper()); + for (int j = k + 1; j <= j_max; j++) + { + // assembly part of R + this->operator()(i, j) = + this->operator()(i, j) + x * this->operator()(k, j); + } + } + } +} +// solves Ly=b +std::vector band_matrix::l_solve(const std::vector &b) const +{ + assert(this->dim() == (int)b.size()); + std::vector x(this->dim()); + int j_start; + double sum; + for (int i = 0; i < this->dim(); i++) + { + sum = 0; + j_start = std::max(0, i - this->num_lower()); + for (int j = j_start; j < i; j++) + sum += this->operator()(i, j) * x[j]; + x[i] = (b[i] * this->saved_diag(i)) - sum; + } + return x; +} +// solves Rx=y +std::vector band_matrix::r_solve(const std::vector &b) const +{ + assert(this->dim() == (int)b.size()); + std::vector x(this->dim()); + int j_stop; + double sum; + for (int i = this->dim() - 1; i >= 0; i--) + { + sum = 0; + j_stop = std::min(this->dim() - 1, i + this->num_upper()); + for (int j = i + 1; j <= j_stop; j++) + sum += this->operator()(i, j) * x[j]; + x[i] = (b[i] - sum) / this->operator()(i, i); + } + return x; +} + +std::vector band_matrix::lu_solve(const std::vector &b, + bool is_lu_decomposed) +{ + assert(this->dim() == (int)b.size()); + std::vector x, y; + if (is_lu_decomposed == false) + { + this->lu_decompose(); + } + y = this->l_solve(b); + x = this->r_solve(y); + return x; +} + +// machine precision of a double, i.e. the successor of 1 is 1+eps +double get_eps() +{ + // return std::numeric_limits::epsilon(); // __DBL_EPSILON__ + return 2.2204460492503131e-16; // 2^-52 +} + +// solutions for a + b*x = 0 +std::vector solve_linear(double a, double b) +{ + std::vector x; // roots + if (b == 0.0) + { + if (a == 0.0) + { + // 0*x = 0 + x.resize(1); + x[0] = 0.0; // any x solves it but we need to pick one + return x; + } + else + { + // 0*x + ... = 0, no solution + return x; + } + } + else + { + x.resize(1); + x[0] = -a / b; + return x; + } +} + +// solutions for a + b*x + c*x^2 = 0 +std::vector +solve_quadratic(double a, double b, double c, int newton_iter) +{ + if (c == 0.0) + { + return solve_linear(a, b); + } + // rescale so that we solve x^2 + 2p x + q = (x+p)^2 + q - p^2 = 0 + double p = 0.5 * b / c; + double q = a / c; + double discr = p * p - q; + const double eps = 0.5 * internal::get_eps(); + double discr_err = (6.0 * (p * p) + 3.0 * fabs(q) + fabs(discr)) * eps; + + std::vector x; // roots + if (fabs(discr) <= discr_err) + { + // discriminant is zero --> one root + x.resize(1); + x[0] = -p; + } + else if (discr < 0) + { + // no root + } + else + { + // two roots + x.resize(2); + x[0] = -p - std::sqrt(discr); + x[1] = -p + std::sqrt(discr); + } + + // improve solution via newton steps + for (std::size_t i = 0; i < x.size(); i++) + { + for (int k = 0; k < newton_iter; k++) + { + double f = (c * x[i] + b) * x[i] + a; + double f1 = 2.0 * c * x[i] + b; + // only adjust if slope is large enough + if (fabs(f1) > 1e-8) + { + x[i] -= f / f1; + } + } + } + + return x; +} + +// solutions for the cubic equation: a + b*x +c*x^2 + d*x^3 = 0 +// this is a naive implementation of the analytic solution without +// optimisation for speed or numerical accuracy +// newton_iter: number of newton iterations to improve analytical solution +// see also +// gsl: gsl_poly_solve_cubic() in solve_cubic.c +// octave: roots.m - via eigenvalues of the Frobenius companion matrix +std::vector +solve_cubic(double a, double b, double c, double d, int newton_iter) +{ + if (d == 0.0) + { + return solve_quadratic(a, b, c, newton_iter); + } + + // convert to normalised form: a + bx + cx^2 + x^3 = 0 + if (d != 1.0) + { + a /= d; + b /= d; + c /= d; + } + + // convert to depressed cubic: z^3 - 3pz - 2q = 0 + // via substitution: z = x + c/3 + std::vector z; // roots of the depressed cubic + double p = -(1.0 / 3.0) * b + (1.0 / 9.0) * (c * c); + double r = 2.0 * (c * c) - 9.0 * b; + double q = -0.5 * a - (1.0 / 54.0) * (c * r); + double discr = p * p * p - q * q; // discriminant + // calculating numerical round-off errors with assumptions: + // - each operation is precise but each intermediate result x + // when stored has max error of x*eps + // - only multiplication with a power of 2 introduces no new error + // - a,b,c,d and some fractions (e.g. 1/3) have rounding errors eps + // - p_err << |p|, q_err << |q|, ... (this is violated in rare cases) + // would be more elegant to use boost::numeric::interval + const double eps = internal::get_eps(); + double p_err = + eps * ((3.0 / 3.0) * fabs(b) + (4.0 / 9.0) * (c * c) + fabs(p)); + double r_err = eps * (6.0 * (c * c) + 18.0 * fabs(b) + fabs(r)); + double q_err = 0.5 * fabs(a) * eps + + (1.0 / 54.0) * fabs(c) * (r_err + fabs(r) * 3.0 * eps) + + fabs(q) * eps; + double discr_err = (p * p) * (3.0 * p_err + fabs(p) * 2.0 * eps) + + fabs(q) * (2.0 * q_err + fabs(q) * eps) + + fabs(discr) * eps; + + // depending on the discriminant we get different solutions + if (fabs(discr) <= discr_err) + { + // discriminant zero: one or two real roots + if (fabs(p) <= p_err) + { + // p and q are zero: single root + z.resize(1); + z[0] = 0.0; // triple root + } + else + { + z.resize(2); + z[0] = 2.0 * q / p; // single root + z[1] = -0.5 * z[0]; // double root + } + } + else if (discr > 0) + { + // three real roots: via trigonometric solution + z.resize(3); + double ac = (1.0 / 3.0) * acos(q / (p * std::sqrt(p))); + double sq = 2.0 * std::sqrt(p); + z[0] = sq * cos(ac); + z[1] = sq * cos(ac - 2.0 * M_PI / 3.0); + z[2] = sq * cos(ac - 4.0 * M_PI / 3.0); + } + else if (discr < 0.0) + { + // single real root: via Cardano's fromula + z.resize(1); + double sgnq = (q >= 0 ? 1 : -1); + double basis = fabs(q) + std::sqrt(-discr); + double C = sgnq * std::pow(basis, 1.0 / 3.0); // c++11 has std::cbrt() + z[0] = C + p / C; + } + for (std::size_t i = 0; i < z.size(); i++) + { + // convert depressed cubic roots to original cubic: x = z - c/3 + z[i] -= (1.0 / 3.0) * c; + // improve solution via newton steps + for (int k = 0; k < newton_iter; k++) + { + double f = ((z[i] + c) * z[i] + b) * z[i] + a; + double f1 = (3.0 * z[i] + 2.0 * c) * z[i] + b; + // only adjust if slope is large enough + if (fabs(f1) > 1e-8) + { + z[i] -= f / f1; + } + } + } + // ensure if a=0 we get exactly x=0 as root + // TODO: remove this fudge + if (a == 0.0) + { + assert(z.size() > 0); // cubic should always have at least one root + double xmin = fabs(z[0]); + size_t imin = 0; + for (std::size_t i = 1; i < z.size(); i++) + { + if (xmin > fabs(z[i])) + { + xmin = fabs(z[i]); + imin = i; + } + } + z[imin] = 0.0; // replace the smallest absolute value with 0 + } + std::sort(z.begin(), z.end()); + return z; +} + +} // namespace internal + +} // namespace tk + +/* TK_SPLINE_H */ \ No newline at end of file diff --git a/src/utility/utility.cpp b/src/utility/utility.cpp index a19e9b9e..300066a8 100644 --- a/src/utility/utility.cpp +++ b/src/utility/utility.cpp @@ -6,9 +6,9 @@ #include #include -#include #include #include +#include /** * @file @@ -23,6 +23,19 @@ std::ostream &operator<<(std::ostream &os, const ModelID::ModelIDs &Model) return os; } +std::vector split(const std::string &str, char delimiter) +{ + // Using str in a string stream + std::stringstream ss(str); + std::vector res; + std::string token; + while (getline(ss, token, delimiter)) + { + res.push_back(token); + } + return res; +} + std::string ModelIDToString(const ModelID::ModelIDs &Model) { std::stringstream ss; @@ -35,4 +48,85 @@ bool StringStartsWith(const std::string &str, const std::string &prefix) return str.size() >= prefix.size() and str.find(prefix) == 0; } +int factorial(const int &a) +{ + return (a == 1 || a == 0) ? 1 : factorial(a - 1) * a; +} + +double L2NormVector(const std::vector &vec) +{ + double r = 0.0; + int dim = vec.size(); + for (int i = 0; i < dim; i++) + { + r += vec[i] * vec[i]; + } + return std::sqrt(r); +} + +std::vector> +Transpose(const std::vector> &A) +{ + int rows = A.size(); + if (rows == 0) return {{}}; + int cols = A[0].size(); + std::vector> r(cols, std::vector(rows)); + for (int i = 0; i < rows; ++i) + { + for (int j = 0; j < cols; ++j) + { + r[j][i] = A[i][j]; + } + } + return r; +} + +double Li2(const double &x) +{ + if (x == 0) return 0; + if (x == 1) return pow(M_PI, 2) / 6.; + if (x < -1) return -pow(M_PI, 2) / 6. - pow(log(-x), 2) / 2. - Li2(1. / x); + if (x < 0) return 1 / 2. * Li2(-x * -x) - Li2(-x); + if (x > 0.5) return pow(M_PI, 2) / 6. - log(x) * log(1 - x) - Li2(1 - x); + double sum = x; // k = 1 element of the sum + for (int k = 2; k <= 1e5; k++) // Sum starts at k = 2 + { + if (abs((pow(x, k) / pow(k, 2.)) / sum) < 1e-10) + { + sum += pow(x, k) / pow(k, 2.); + return sum; + } + sum += pow(x, k) / pow(k, 2.); + } + return sum; +} + +bool StringEndsWith(const std::string &str, const std::string &suffix) +{ + return str.size() >= suffix.size() and + str.substr(str.size() - suffix.size(), str.size()) == suffix; +} + +double EllipIntSecond(const double &x) +{ + std::function integrand = [&](double x_int) + { return sqrt(1 + 2 * pow(sinh(x_int), 2)); }; + + gsl_integration_workspace *w = gsl_integration_workspace_alloc(1000); + + double result, error; + + gsl_function F = {[](double d, void *vf) -> double + { + auto &f = + *static_cast *>(vf); + return f(d); + }, + &integrand}; + + gsl_integration_qags(&F, 0, x, 0, 1e-7, 1000, w, &result, &error); + gsl_integration_workspace_free(w); + return result; +} + } // namespace BSMPT diff --git a/standalone/CMakeLists.txt b/standalone/CMakeLists.txt new file mode 100644 index 00000000..3f787f0b --- /dev/null +++ b/standalone/CMakeLists.txt @@ -0,0 +1,29 @@ +# SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, +# João Viana +# +# SPDX-License-Identifier: GPL-3.0-or-later + +set(STANDALONE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) +file(GLOB SOURCE_FILES "*.cpp" CONFIURE_DEPENDS) + +foreach(file_path ${SOURCE_FILES}) + get_filename_component(filename "${file_path}" NAME) + string(REPLACE ".cpp" "" filename "${filename}") + add_executable("${filename}" "${file_path}") + target_link_libraries( + "${filename}" + PRIVATE Minimizer + MinimumTracer + Models + Utility + TestCompares + ThermalFunctions + BounceSolution + TransitionTracer + GW) + set_target_properties( + "${filename}" PROPERTIES RUNTIME_OUTPUT_DIRECTORY + "${CMAKE_BINARY_DIR}/bin/standalone") + + target_compile_features("${filename}" PUBLIC cxx_std_14) +endforeach() diff --git a/standalone/CalculateAction.cpp b/standalone/CalculateAction.cpp new file mode 100644 index 00000000..1dbb87f9 --- /dev/null +++ b/standalone/CalculateAction.cpp @@ -0,0 +1,74 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include +#include +#include // for Class_Potential_Origin +#include +#include +#include +#include // for Logger Class +#include + +using namespace BSMPT; + +int main() +{ + // Set the logger + SetLogger({"--logginglevel::complete=true"}); + + // Define the potential + // BounceActionInt only takes std::vector functions as arguments. + std::function)> V = [&](std::vector x) + { + double c = 5; + double fx = 0; + double fy = 80; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return (r1 * r2 + r3); + }; + + // Define the potential's gradient (optional) + std::function(std::vector)> dV = + [&](std::vector l0) + { + std::vector result = { + 2 * l0[0] * (5 * pow(-1 + l0[0], 2) + pow(-1 + l0[1], 2)) + + 10 * (-1 + l0[0]) * (pow(l0[0], 2) + 5 * pow(l0[1], 2)), + 10 * (5 * pow(-1 + l0[0], 2) + pow(-1 + l0[1], 2)) * l0[1] + + 2 * (-1 + l0[1]) * (pow(l0[0], 2) + 5 * pow(l0[1], 2)) + + 80 * (-1. * pow(l0[1], 2) + 1. * pow(l0[1], 3))}; + return result; + }; + + // Define the false and true vacuum + std::vector FalseVacuum = {0, 0}; + std::vector TrueVacuum = {1, 1}; + + // Your best guess for the path + std::vector> path = {TrueVacuum, FalseVacuum}; + + // Calculate the action if NO gradient was provided + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.CalculateAction(); + + // Calculate the action if gradient was provided + BounceActionInt bcdV(path, TrueVacuum, FalseVacuum, V, dV, 0, 6); + bcdV.CalculateAction(); + + std::cout << "Action calculated using numerical derivatives is " << bc.Action + << "\n"; + std::cout << "Action calculated using analytical derivatives is " + << bcdV.Action << "\n"; + + return 0; +} \ No newline at end of file diff --git a/standalone/GenericModel.cpp b/standalone/GenericModel.cpp new file mode 100644 index 00000000..767f5cf3 --- /dev/null +++ b/standalone/GenericModel.cpp @@ -0,0 +1,155 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include +#include +#include // for Class_Potential_Origin +#include +#include +#include +#include // for Logger Class +#include + +using namespace BSMPT; +using namespace Minimizer; + +class Class_Potential_OriginDerived : public Class_Potential_Origin +{ +public: + //////////////////////////////////////////////////////////// + void ReadAndSet(const std::string &linestr, std::vector &par) override + { + (void)linestr; + (void)par; + return; + }; + std::vector addLegendCT() const override { return {}; }; + std::vector addLegendTemp() const override { return {}; }; + std::vector addLegendTripleCouplings() const override + { + return {}; + }; + + void set_gen(const std::vector &par) override + { + (void)par; + return; + }; + void set_CT_Pot_Par(const std::vector &par) override + { + (void)par; + return; + }; + void write() const override { return; }; + void SetCurvatureArrays() override { return; }; + bool CalculateDebyeSimplified() override { return true; }; + bool CalculateDebyeGaugeSimplified() override { return true; }; + double VTreeSimplified(const std::vector &v) const override + { + (void)v; + return 0; + }; + double VCounterSimplified(const std::vector &v) const override + { + (void)v; + return 0; + }; + void TripleHiggsCouplings() override { return; }; + std::vector calc_CT() const override { return {0}; }; + void Debugging(const std::vector &input, + std::vector &output) const override + { + (void)input; + (void)output; + return; + }; + //////////////////////////////////////////////////////////// + Class_Potential_OriginDerived() : Class_Potential_Origin(GetSMConstants()) + { + NNeutralHiggs = 4; // number of neutral Higgs bosons at T = 0, w/ goldstones + NChargedHiggs = 0; // number of charged Higgs bosons at T = 0 (all d.o.f.) + + NHiggs = NNeutralHiggs + NChargedHiggs; + + nVEV = 1; // number of VEVs to minimize the potential + + // Treelevel minimum + vevTreeMin = {246.22}; + + // This is the mapping from the "manifold vacuum fields" into the full + // fields. + VevOrder.resize(nVEV); + VevOrder[0] = 0; // omegaCB + } + + // Labels for the VEVS + std::vector addLegendVEV() const override { return {"v"}; }; + + /** + * This function calculates the EW breaking VEV from all contributing field + * configurations. + */ + double EWSBVEV(const std::vector &v) const override + { + (void)v; + return 0; + } + + // Set all EW breaking directions to zero + void SetEWVEVZero(std::vector &sol) const override + { + sol = std::vector(nVEV, 0); + } + + double VEff(const std::vector &v, + double Temp = 0, + int diff = 0, + int Order = 1) const override + { + (void)diff; + (void)Order; + double r = 0.152808 * (pow(Temp, 2) - pow(160, 2)) * pow(v[0], 2) + + 0.0322634 * pow(v[0], 4); + return r; + } +}; + +int main() +{ + // Set the logger + SetLogger({"--logginglevel::complete=true"}); + + std::shared_ptr modelPointerDerived; + modelPointerDerived = std::make_shared(); + + std::shared_ptr modelPointer = + std::dynamic_pointer_cast( + modelPointerDerived); + + user_input input{modelPointer, /* modelPointer */ + 0, /* templow */ + 400, /* temphigh */ + 0.95, /* UserDefined_vwall */ + .71, /* perc_prbl */ + .01, /* compl_prbl */ + 0.1, /* UserDefined_epsturb */ + 7, /* MaxPathIntegrations */ + -1, /* UseMultiStepPTMode */ + 10, /* num_check_pts */ + 0, /* CheckEWSymmetryRestoration*/ + 0, /* CheckNLOStability*/ + WhichMinimizerDefault, /* WhichMinimizer*/ + false, /* GW calculation*/ + true}; /* WhichTransitionTemperature*/ + + TransitionTracer trans(input); + + auto output = trans.output_store; // Results are here. Check the other classes + // to learn how to access it. + + return 0; +} diff --git a/standalone/README.md b/standalone/README.md new file mode 100644 index 00000000..8dae7689 --- /dev/null +++ b/standalone/README.md @@ -0,0 +1,9 @@ +In case you want to use certain classes/functions of BSMPT without using the whole program we provide some examples on how to do it. +To use it just put your `.cpp` file inside this folder and (re-)compile BSMPT. + +The executables will be placed in `bin/standalone/` inside the build-folder. + +We provide a few examples: +- `CalculateAction.cpp` - Solves the bounce equation and calculate the Euclidian action. The user is expected to provide the initial guess path and the potential, the gradient is optional. +- `GenericModel.cpp` - The user provides a potential \f$V(\phi)\f$, the zero-temperature VEV and the dimensionality of the VEV. This tracks the minima and calculates characteristic temperatures as well as the GW spectrum of first-order phase transitions. +- `TunnelingPath.cpp` - Solve the bounce equation using the full `BSMPTv3` and prints the tunneling path and the VEV profile in `Mathematica` and `python` formats. diff --git a/standalone/TunnelingPath.cpp b/standalone/TunnelingPath.cpp new file mode 100644 index 00000000..552aeb12 --- /dev/null +++ b/standalone/TunnelingPath.cpp @@ -0,0 +1,117 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include +#include +#include // for Class_Potential_Origin +#include +#include +#include +#include // for Logger Class +#include + +// C++ version of the python function ", ".join() +std::string join(const std::vector &sequence, + const std::string &separator) +{ + std::string result; + for (size_t i = 0; i < sequence.size(); ++i) + result += std::to_string(sequence[i]) + + ((i != sequence.size() - 1) ? separator : ""); + return result; +} + +using namespace BSMPT; +using namespace Minimizer; + +int main() +{ + // Set the logger + SetLogger({"--logginglevel::complete=true"}); + + const std::vector example_point_CXSM{/* v = */ 245.34120667410863, + /* vs = */ 0, + /* va = */ 0, + /* msq = */ -15650, + /* lambda = */ 0.52, + /* delta2 = */ 0.55, + /* b2 = */ -8859, + /* d2 = */ 0.5, + /* Reb1 = */ 0, + /* Imb1 = */ 0, + /* Rea1 = */ 0, + /* Ima1 = */ 0}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); + modelPointer->initModel(example_point_CXSM); + + user_input input{modelPointer, /*modelPointer*/ + 0, /*templow*/ + 400, /*temphigh*/ + 0.95, /*UserDefined_vwall*/ + .71, /*perc_prbl*/ + .01, /*compl_prbl*/ + 0.1, /*UserDefined_epsturb*/ + 7, /*MaxPathIntegrations*/ + -1, /*UseMultiStepPTMode*/ + 10, /*num_check_pts*/ + 0, /*CheckEWSymmetryRestoration*/ + 1, /*CheckNLOStability*/ + WhichMinimizerDefault, /*WhichMinimizer*/ + false, /*GW calculation*/ + true}; /*WhichTransitionTemperature*/ + + TransitionTracer trans(input); + auto output = trans.output_store; + + for (auto &bounce : trans.ListBounceSolution) + { + // Calculate percolation temperature + bounce.CalculatePercolationTemp(); + if (bounce.GetPercolationTemp() == -1) continue; + double errorTtoTp = 1e100; + BounceActionInt const *ClosestBounceActionInt; + std::cout << "Found a transitions with Tp =\t" + << bounce.GetPercolationTemp() << " GeV.\n"; + for (const auto &BAInt : bounce.SolutionList) + { + if (abs(BAInt.T - bounce.GetPercolationTemp()) < errorTtoTp) + { + errorTtoTp = abs(BAInt.T - bounce.GetPercolationTemp()); + ClosestBounceActionInt = &BAInt; + } + } + std::cout << "The closest solution is at a distance of " << errorTtoTp + << " GeV from Tp.\n The tunnenling path is\n"; + ClosestBounceActionInt->Spline.print_path(); + std::cout << "\n ------ The tunneling profile in Mathematica format ------ " + "\n {rho, l, point}\n\n"; + + // Save the path and VEV profile into, e.g, Mathematica + for (size_t i = 0; i < ClosestBounceActionInt->rho_sol.size(); i++) + std::cout << "{" << ClosestBounceActionInt->rho_sol[i] << ", " + << ClosestBounceActionInt->l_sol[i] << ", " + << join(ClosestBounceActionInt->Spline( + ClosestBounceActionInt->l_sol[i]), + ", ") + << "},\n"; + std::cout << "\n ------ The tunneling profile in python format ------ " + "\n {rho, l, point}\n\n"; + // Save the path and VEV profile into, e.g, python + for (size_t i = 0; i < ClosestBounceActionInt->rho_sol.size(); i++) + std::cout << "[" << ClosestBounceActionInt->rho_sol[i] << ", " + << ClosestBounceActionInt->l_sol[i] << ", " + << join(ClosestBounceActionInt->Spline( + ClosestBounceActionInt->l_sol[i]), + ", ") + << "],\n"; + } + return 0; +} diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 48846313..f0000eaa 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,37 +1,20 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later -find_package(Catch2 3 QUIET) -if(NOT Catch2_FOUND) - message("Fetching Catch2") - include(FetchContent) - FetchContent_Declare( - Catch2 - GIT_SHALLOW TRUE - GIT_REPOSITORY https://github.com/catchorg/Catch2.git - GIT_TAG v3.1.0) - FetchContent_MakeAvailable(Catch2) - - set(CodeCoverageExcludesFromOtherPkgs - "${CodeCoverageExcludesFromOtherPkgs} ${Catch2_SOURCE_DIR}/*") - -endif() +find_package(Catch2 3 CONFIG QUIET) list(APPEND CMAKE_MODULE_PATH ${Catch2_SOURCE_DIR}/extras) if(Catch2_FOUND) if(NOT "${Catch2_DIR}" STREQUAL "") - set(CodeCoverageExcludesFromOtherPkgs - ${CodeCoverageExcludesFromOtherPkgs} - "${Catch2_DIR}/*" - ) + set(CodeCoverageExcludesFromOtherPkgs ${CodeCoverageExcludesFromOtherPkgs} + "${Catch2_DIR}/*") endif() if(NOT "${Catch2_ROOT_DIR}" STREQUAL "") - set(CodeCoverageExcludesFromOtherPkgs - ${CodeCoverageExcludesFromOtherPkgs} - "${Catch2_ROOT_DIR}/*" - ) + set(CodeCoverageExcludesFromOtherPkgs ${CodeCoverageExcludesFromOtherPkgs} + "${Catch2_ROOT_DIR}/*") endif() endif() @@ -39,7 +22,3 @@ add_subdirectory(catcheventlistener) add_subdirectory(GenerateTestCompares) add_subdirectory(unittests) add_subdirectory(benchmarks) - - - - diff --git a/tests/GenerateTestCompares/C2HDM.cpp b/tests/GenerateTestCompares/C2HDM.cpp index 13af72f3..0c5e4741 100644 --- a/tests/GenerateTestCompares/C2HDM.cpp +++ b/tests/GenerateTestCompares/C2HDM.cpp @@ -1,5 +1,4 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas -// Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler // // SPDX-License-Identifier: GPL-3.0-or-later #include "C2HDM.h" @@ -12,115 +11,121 @@ Compare_C2HDM::Compare_C2HDM() Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; CheckTripleCT = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - EWPTPerSetting[4].Tc = 129.282; - EWPTPerSetting[4].vc = 223.536; + EWPTPerSetting[4].Tc = 130.206; + EWPTPerSetting[4].vc = 217.467; EWPTPerSetting[4].EWMinimum.push_back(0); - EWPTPerSetting[4].EWMinimum.push_back(53.6199); - EWPTPerSetting[4].EWMinimum.push_back(217.01); - EWPTPerSetting[4].EWMinimum.push_back(-0.426764); + EWPTPerSetting[4].EWMinimum.push_back(-52.2481); + EWPTPerSetting[4].EWMinimum.push_back(-211.096); + EWPTPerSetting[4].EWMinimum.push_back(0.640146); vevSymmetricPerSetting[4].push_back(0); vevSymmetricPerSetting[4].push_back(0); vevSymmetricPerSetting[4].push_back(0); vevSymmetricPerSetting[4].push_back(0); - LWPerSetting[4] = 0.0185271; - etaPerSetting[4].push_back(-3.69152e-10); - etaPerSetting[4].push_back(-3.6938e-10); - etaPerSetting[4].push_back(-3.69375e-10); - etaPerSetting[4].push_back(-2.45831e-11); - etaPerSetting[4].push_back(-1.85729e-11); - EWPTPerSetting[1].Tc = 145.569; - EWPTPerSetting[1].vc = 200.796; + LWPerSetting[4] = 0.0187284; + etaPerSetting[4].push_back(-2.40575e-10); + etaPerSetting[4].push_back(-2.40716e-10); + etaPerSetting[4].push_back(-2.40713e-10); + etaPerSetting[4].push_back(-1.50784e-11); + etaPerSetting[4].push_back(-1.13619e-11); + EWPTPerSetting[1].Tc = 143.701; + EWPTPerSetting[1].vc = 200.381; EWPTPerSetting[1].EWMinimum.push_back(0); - EWPTPerSetting[1].EWMinimum.push_back(49.9295); - EWPTPerSetting[1].EWMinimum.push_back(194.485); - EWPTPerSetting[1].EWMinimum.push_back(-1.33912); + EWPTPerSetting[1].EWMinimum.push_back(49.3619); + EWPTPerSetting[1].EWMinimum.push_back(194.202); + EWPTPerSetting[1].EWMinimum.push_back(-1.30784); vevSymmetricPerSetting[1].push_back(0); vevSymmetricPerSetting[1].push_back(0); vevSymmetricPerSetting[1].push_back(0); vevSymmetricPerSetting[1].push_back(0); - LWPerSetting[1] = 0.0337941; - etaPerSetting[1].push_back(-3.33452e-11); - etaPerSetting[1].push_back(-3.34485e-11); - etaPerSetting[1].push_back(-3.3448e-11); - etaPerSetting[1].push_back(-4.54892e-13); - etaPerSetting[1].push_back(-3.37505e-13); - EWPTPerSetting[5].Tc = 145.569; - EWPTPerSetting[5].vc = 200.796; + LWPerSetting[1] = 0.0341278; + etaPerSetting[1].push_back(-3.2609e-11); + etaPerSetting[1].push_back(-3.27114e-11); + etaPerSetting[1].push_back(-3.2711e-11); + etaPerSetting[1].push_back(-4.50954e-13); + etaPerSetting[1].push_back(-3.34631e-13); + EWPTPerSetting[5].Tc = 143.701; + EWPTPerSetting[5].vc = 200.381; EWPTPerSetting[5].EWMinimum.push_back(0); - EWPTPerSetting[5].EWMinimum.push_back(49.9295); - EWPTPerSetting[5].EWMinimum.push_back(194.485); - EWPTPerSetting[5].EWMinimum.push_back(-1.33913); + EWPTPerSetting[5].EWMinimum.push_back(49.3619); + EWPTPerSetting[5].EWMinimum.push_back(194.202); + EWPTPerSetting[5].EWMinimum.push_back(-1.30785); vevSymmetricPerSetting[5].push_back(0); vevSymmetricPerSetting[5].push_back(0); vevSymmetricPerSetting[5].push_back(0); vevSymmetricPerSetting[5].push_back(0); - LWPerSetting[5] = 0.0337941; - etaPerSetting[5].push_back(-3.33425e-11); - etaPerSetting[5].push_back(-3.34458e-11); - etaPerSetting[5].push_back(-3.34453e-11); - etaPerSetting[5].push_back(-4.54855e-13); - etaPerSetting[5].push_back(-3.37477e-13); - EWPTPerSetting[2].Tc = 300; - EWPTPerSetting[2].vc = 0; - EWPTPerSetting[2].EWMinimum.push_back(0); - EWPTPerSetting[2].EWMinimum.push_back(0); - EWPTPerSetting[2].EWMinimum.push_back(0); - EWPTPerSetting[2].EWMinimum.push_back(0); + LWPerSetting[5] = 0.0341278; + etaPerSetting[5].push_back(-3.26167e-11); + etaPerSetting[5].push_back(-3.27191e-11); + etaPerSetting[5].push_back(-3.27187e-11); + etaPerSetting[5].push_back(-4.5106e-13); + etaPerSetting[5].push_back(-3.3471e-13); + EWPTPerSetting[2].Tc = 143.701; + EWPTPerSetting[2].vc = 200.381; + EWPTPerSetting[2].EWMinimum.push_back(1.92717e-05); + EWPTPerSetting[2].EWMinimum.push_back(-49.3619); + EWPTPerSetting[2].EWMinimum.push_back(-194.202); + EWPTPerSetting[2].EWMinimum.push_back(1.30788); vevSymmetricPerSetting[2].push_back(0); vevSymmetricPerSetting[2].push_back(0); vevSymmetricPerSetting[2].push_back(0); vevSymmetricPerSetting[2].push_back(0); - EWPTPerSetting[6].Tc = 145.569; - EWPTPerSetting[6].vc = 200.796; - EWPTPerSetting[6].EWMinimum.push_back(-1.42328e-05); - EWPTPerSetting[6].EWMinimum.push_back(49.9295); - EWPTPerSetting[6].EWMinimum.push_back(194.485); - EWPTPerSetting[6].EWMinimum.push_back(-1.33912); + LWPerSetting[2] = 0.0341278; + etaPerSetting[2].push_back(-3.261e-11); + etaPerSetting[2].push_back(-3.27124e-11); + etaPerSetting[2].push_back(-3.2712e-11); + etaPerSetting[2].push_back(-4.50968e-13); + etaPerSetting[2].push_back(-3.34641e-13); + EWPTPerSetting[6].Tc = 143.701; + EWPTPerSetting[6].vc = 200.381; + EWPTPerSetting[6].EWMinimum.push_back(1.88772e-05); + EWPTPerSetting[6].EWMinimum.push_back(-49.3619); + EWPTPerSetting[6].EWMinimum.push_back(-194.202); + EWPTPerSetting[6].EWMinimum.push_back(1.30786); vevSymmetricPerSetting[6].push_back(0); vevSymmetricPerSetting[6].push_back(0); vevSymmetricPerSetting[6].push_back(0); vevSymmetricPerSetting[6].push_back(0); - LWPerSetting[6] = 0.0337941; - etaPerSetting[6].push_back(-3.33465e-11); - etaPerSetting[6].push_back(-3.34498e-11); - etaPerSetting[6].push_back(-3.34493e-11); - etaPerSetting[6].push_back(-4.5491e-13); - etaPerSetting[6].push_back(-3.37518e-13); - EWPTPerSetting[3].Tc = 145.569; - EWPTPerSetting[3].vc = 200.796; + LWPerSetting[6] = 0.0341278; + etaPerSetting[6].push_back(-3.26094e-11); + etaPerSetting[6].push_back(-3.27118e-11); + etaPerSetting[6].push_back(-3.27114e-11); + etaPerSetting[6].push_back(-4.5096e-13); + etaPerSetting[6].push_back(-3.34636e-13); + EWPTPerSetting[3].Tc = 143.701; + EWPTPerSetting[3].vc = 200.381; EWPTPerSetting[3].EWMinimum.push_back(0); - EWPTPerSetting[3].EWMinimum.push_back(49.9295); - EWPTPerSetting[3].EWMinimum.push_back(194.485); - EWPTPerSetting[3].EWMinimum.push_back(-1.33912); + EWPTPerSetting[3].EWMinimum.push_back(49.3619); + EWPTPerSetting[3].EWMinimum.push_back(194.202); + EWPTPerSetting[3].EWMinimum.push_back(-1.30785); vevSymmetricPerSetting[3].push_back(0); vevSymmetricPerSetting[3].push_back(0); vevSymmetricPerSetting[3].push_back(0); vevSymmetricPerSetting[3].push_back(0); - LWPerSetting[3] = 0.0337941; - etaPerSetting[3].push_back(-3.33487e-11); - etaPerSetting[3].push_back(-3.3452e-11); - etaPerSetting[3].push_back(-3.34516e-11); - etaPerSetting[3].push_back(-4.5494e-13); - etaPerSetting[3].push_back(-3.3754e-13); - EWPTPerSetting[7].Tc = 145.569; - EWPTPerSetting[7].vc = 200.796; + LWPerSetting[3] = 0.0341278; + etaPerSetting[3].push_back(-3.26059e-11); + etaPerSetting[3].push_back(-3.27082e-11); + etaPerSetting[3].push_back(-3.27078e-11); + etaPerSetting[3].push_back(-4.5091e-13); + etaPerSetting[3].push_back(-3.34599e-13); + EWPTPerSetting[7].Tc = 143.701; + EWPTPerSetting[7].vc = 200.381; EWPTPerSetting[7].EWMinimum.push_back(0); - EWPTPerSetting[7].EWMinimum.push_back(49.9295); - EWPTPerSetting[7].EWMinimum.push_back(194.485); - EWPTPerSetting[7].EWMinimum.push_back(-1.33913); + EWPTPerSetting[7].EWMinimum.push_back(49.3619); + EWPTPerSetting[7].EWMinimum.push_back(194.202); + EWPTPerSetting[7].EWMinimum.push_back(-1.30784); vevSymmetricPerSetting[7].push_back(0); vevSymmetricPerSetting[7].push_back(0); vevSymmetricPerSetting[7].push_back(0); vevSymmetricPerSetting[7].push_back(0); - LWPerSetting[7] = 0.0337941; - etaPerSetting[7].push_back(-3.33448e-11); - etaPerSetting[7].push_back(-3.34481e-11); - etaPerSetting[7].push_back(-3.34476e-11); - etaPerSetting[7].push_back(-4.54887e-13); - etaPerSetting[7].push_back(-3.375e-13); - CheckTripleTree.at(0).at(0).at(4) = -6.66134e-16; - CheckTripleCT.at(0).at(0).at(4) = -2.60209e-18; - CheckTripleCW.at(0).at(0).at(4) = 6.02643e-15; + LWPerSetting[7] = 0.0341278; + etaPerSetting[7].push_back(-3.2611e-11); + etaPerSetting[7].push_back(-3.27134e-11); + etaPerSetting[7].push_back(-3.2713e-11); + etaPerSetting[7].push_back(-4.50982e-13); + etaPerSetting[7].push_back(-3.34652e-13); + CheckTripleTree.at(0).at(0).at(4) = -5.16264e-16; + CheckTripleCT.at(0).at(0).at(4) = -1.74372e-18; + CheckTripleCW.at(0).at(0).at(4) = 5.67654e-15; CheckTripleTree.at(0).at(0).at(5) = 62.8092; CheckTripleCT.at(0).at(0).at(5) = -59.0416; CheckTripleCW.at(0).at(0).at(5) = 59.0416; @@ -130,18 +135,21 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(0).at(0).at(7) = 6.91258; CheckTripleCT.at(0).at(0).at(7) = -0.719745; CheckTripleCW.at(0).at(0).at(7) = 0.719745; - CheckTripleCW.at(0).at(1).at(4) = -8.67362e-17; - CheckTripleTree.at(0).at(1).at(5) = -8.97719e-17; - CheckTripleCT.at(0).at(1).at(5) = 1.84314e-18; - CheckTripleCW.at(0).at(1).at(5) = -1.23599e-17; - CheckTripleTree.at(0).at(1).at(6) = -1.56992e-16; - CheckTripleCT.at(0).at(1).at(6) = -2.98156e-19; - CheckTripleCW.at(0).at(1).at(6) = -1.9868e-17; - CheckTripleTree.at(0).at(1).at(7) = 6.10623e-16; - CheckTripleCT.at(0).at(1).at(7) = -1.12757e-17; - CheckTripleCW.at(0).at(1).at(7) = -3.60822e-16; - CheckTripleTree.at(0).at(2).at(4) = -8.88178e-16; - CheckTripleCW.at(0).at(2).at(4) = -2.74086e-16; + CheckTripleTree.at(0).at(1).at(4) = 4.95063e-17; + CheckTripleCT.at(0).at(1).at(4) = -3.28356e-18; + CheckTripleCW.at(0).at(1).at(4) = 1.56284e-17; + CheckTripleTree.at(0).at(1).at(5) = 1.99597e-16; + CheckTripleCT.at(0).at(1).at(5) = 1.56943e-18; + CheckTripleCW.at(0).at(1).at(5) = 2.63551e-16; + CheckTripleTree.at(0).at(1).at(6) = -3.45069e-16; + CheckTripleCT.at(0).at(1).at(6) = -2.50533e-18; + CheckTripleCW.at(0).at(1).at(6) = -4.70867e-17; + CheckTripleTree.at(0).at(1).at(7) = 5.50161e-16; + CheckTripleCT.at(0).at(1).at(7) = -1.1021e-17; + CheckTripleCW.at(0).at(1).at(7) = -1.65908e-15; + CheckTripleTree.at(0).at(2).at(4) = -1.04768e-15; + CheckTripleCT.at(0).at(2).at(4) = -4.44008e-18; + CheckTripleCW.at(0).at(2).at(4) = -5.40975e-17; CheckTripleTree.at(0).at(2).at(5) = -85.5922; CheckTripleCT.at(0).at(2).at(5) = -5.42929; CheckTripleCW.at(0).at(2).at(5) = 5.42929; @@ -151,9 +159,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(0).at(2).at(7) = 0.633893; CheckTripleCT.at(0).at(2).at(7) = -0.114735; CheckTripleCW.at(0).at(2).at(7) = 0.114735; - CheckTripleTree.at(0).at(3).at(4) = -1.77636e-15; - CheckTripleCT.at(0).at(3).at(4) = 5.55112e-17; - CheckTripleCW.at(0).at(3).at(4) = 2.77556e-16; + CheckTripleTree.at(0).at(3).at(4) = -2.75577e-15; + CheckTripleCT.at(0).at(3).at(4) = 5.15824e-17; + CheckTripleCW.at(0).at(3).at(4) = -8.40492e-17; CheckTripleTree.at(0).at(3).at(5) = 8.02502; CheckTripleCT.at(0).at(3).at(5) = 0.040989; CheckTripleCW.at(0).at(3).at(5) = -0.040989; @@ -163,21 +171,24 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(0).at(3).at(7) = 25.558; CheckTripleCT.at(0).at(3).at(7) = -0.734647; CheckTripleCW.at(0).at(3).at(7) = 0.734647; - CheckTripleTree.at(0).at(4).at(0) = -6.66134e-16; - CheckTripleCT.at(0).at(4).at(0) = -1.73472e-18; - CheckTripleCW.at(0).at(4).at(0) = 6.04031e-15; - CheckTripleCW.at(0).at(4).at(1) = -9.36751e-17; - CheckTripleTree.at(0).at(4).at(2) = -8.88178e-16; - CheckTripleCW.at(0).at(4).at(2) = -2.67147e-16; - CheckTripleTree.at(0).at(4).at(3) = -1.77636e-15; - CheckTripleCT.at(0).at(4).at(3) = 5.55112e-17; - CheckTripleCW.at(0).at(4).at(3) = 2.77556e-16; + CheckTripleTree.at(0).at(4).at(0) = -5.16264e-16; + CheckTripleCT.at(0).at(4).at(0) = -1.74372e-18; + CheckTripleCW.at(0).at(4).at(0) = 5.71589e-15; + CheckTripleTree.at(0).at(4).at(1) = 4.95063e-17; + CheckTripleCT.at(0).at(4).at(1) = -3.28356e-18; + CheckTripleCW.at(0).at(4).at(1) = 8.6895e-18; + CheckTripleTree.at(0).at(4).at(2) = -1.04768e-15; + CheckTripleCT.at(0).at(4).at(2) = -4.44008e-18; + CheckTripleCW.at(0).at(4).at(2) = -8.16707e-18; + CheckTripleTree.at(0).at(4).at(3) = -2.75577e-15; + CheckTripleCT.at(0).at(4).at(3) = 5.15824e-17; + CheckTripleCW.at(0).at(4).at(3) = -8.40492e-17; CheckTripleTree.at(0).at(5).at(0) = 62.8092; CheckTripleCT.at(0).at(5).at(0) = -59.0416; CheckTripleCW.at(0).at(5).at(0) = 59.0416; - CheckTripleTree.at(0).at(5).at(1) = -8.97719e-17; - CheckTripleCT.at(0).at(5).at(1) = 1.84314e-18; - CheckTripleCW.at(0).at(5).at(1) = -1.27936e-17; + CheckTripleTree.at(0).at(5).at(1) = 3.1062e-16; + CheckTripleCT.at(0).at(5).at(1) = 2.43679e-18; + CheckTripleCW.at(0).at(5).at(1) = 2.6202e-16; CheckTripleTree.at(0).at(5).at(2) = -85.5922; CheckTripleCT.at(0).at(5).at(2) = -5.42929; CheckTripleCW.at(0).at(5).at(2) = 5.42929; @@ -187,9 +198,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(0).at(6).at(0) = 13.6784; CheckTripleCT.at(0).at(6).at(0) = -4.10233; CheckTripleCW.at(0).at(6).at(0) = 4.10233; - CheckTripleTree.at(0).at(6).at(1) = 2.87097e-16; - CheckTripleCT.at(0).at(6).at(1) = 1.35525e-19; - CheckTripleCW.at(0).at(6).at(1) = -2.09522e-17; + CheckTripleTree.at(0).at(6).at(1) = 9.90197e-17; + CheckTripleCT.at(0).at(6).at(1) = -7.70611e-19; + CheckTripleCW.at(0).at(6).at(1) = -4.90654e-17; CheckTripleTree.at(0).at(6).at(2) = 531.406; CheckTripleCT.at(0).at(6).at(2) = 2.93805; CheckTripleCW.at(0).at(6).at(2) = -2.93805; @@ -199,28 +210,30 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(0).at(7).at(0) = 6.91258; CheckTripleCT.at(0).at(7).at(0) = -0.719745; CheckTripleCW.at(0).at(7).at(0) = 0.719745; - CheckTripleTree.at(0).at(7).at(1) = -2.77556e-16; - CheckTripleCT.at(0).at(7).at(1) = 1.64799e-17; - CheckTripleCW.at(0).at(7).at(1) = -3.88578e-16; + CheckTripleTree.at(0).at(7).at(1) = -3.38018e-16; + CheckTripleCT.at(0).at(7).at(1) = 1.67345e-17; + CheckTripleCW.at(0).at(7).at(1) = -1.68683e-15; CheckTripleTree.at(0).at(7).at(2) = 0.633893; CheckTripleCT.at(0).at(7).at(2) = -0.114735; CheckTripleCW.at(0).at(7).at(2) = 0.114735; CheckTripleTree.at(0).at(7).at(3) = 25.558; CheckTripleCT.at(0).at(7).at(3) = -0.734647; CheckTripleCW.at(0).at(7).at(3) = 0.734647; - CheckTripleCW.at(1).at(0).at(4) = -8.67362e-17; - CheckTripleTree.at(1).at(0).at(5) = 8.93383e-17; - CheckTripleCT.at(1).at(0).at(5) = 7.72494e-19; - CheckTripleCW.at(1).at(0).at(5) = -1.32544e-17; - CheckTripleTree.at(1).at(0).at(6) = -7.30319e-16; - CheckTripleCT.at(1).at(0).at(6) = -6.23416e-19; - CheckTripleCW.at(1).at(0).at(6) = -1.9082e-17; - CheckTripleTree.at(1).at(0).at(7) = 1.22125e-15; - CheckTripleCT.at(1).at(0).at(7) = -4.51028e-17; - CheckTripleCW.at(1).at(0).at(7) = -3.59088e-16; - CheckTripleTree.at(1).at(1).at(4) = -4.44089e-16; - CheckTripleCT.at(1).at(1).at(4) = -2.60209e-18; - CheckTripleCW.at(1).at(1).at(4) = 6.06806e-15; + CheckTripleTree.at(1).at(0).at(4) = 2.5605e-17; + CheckTripleCT.at(1).at(0).at(4) = -2.8257e-18; + CheckTripleCW.at(1).at(0).at(4) = 1.6834e-17; + CheckTripleTree.at(1).at(0).at(5) = 1.12079e-16; + CheckTripleCT.at(1).at(0).at(5) = 7.24185e-19; + CheckTripleCW.at(1).at(0).at(5) = 2.61213e-16; + CheckTripleTree.at(1).at(0).at(6) = -4.96858e-16; + CheckTripleCT.at(1).at(0).at(6) = -3.20072e-19; + CheckTripleCW.at(1).at(0).at(6) = -4.90756e-17; + CheckTripleTree.at(1).at(0).at(7) = 1.06864e-15; + CheckTripleCT.at(1).at(0).at(7) = -3.77586e-17; + CheckTripleCW.at(1).at(0).at(7) = -1.67055e-15; + CheckTripleTree.at(1).at(1).at(4) = -4.95101e-16; + CheckTripleCT.at(1).at(1).at(4) = -1.41609e-18; + CheckTripleCW.at(1).at(1).at(4) = 5.74808e-15; CheckTripleTree.at(1).at(1).at(5) = 62.8092; CheckTripleCT.at(1).at(1).at(5) = -59.0416; CheckTripleCW.at(1).at(1).at(5) = 59.0416; @@ -230,9 +243,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(1).at(1).at(7) = 6.91258; CheckTripleCT.at(1).at(1).at(7) = -0.719745; CheckTripleCW.at(1).at(1).at(7) = 0.719745; - CheckTripleTree.at(1).at(2).at(4) = 1.77636e-15; - CheckTripleCT.at(1).at(2).at(4) = -5.55112e-17; - CheckTripleCW.at(1).at(2).at(4) = -6.66134e-16; + CheckTripleTree.at(1).at(2).at(4) = 2.75577e-15; + CheckTripleCT.at(1).at(2).at(4) = -5.15824e-17; + CheckTripleCW.at(1).at(2).at(4) = 1.598e-16; CheckTripleTree.at(1).at(2).at(5) = -8.02502; CheckTripleCT.at(1).at(2).at(5) = -0.040989; CheckTripleCW.at(1).at(2).at(5) = 0.040989; @@ -242,8 +255,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(1).at(2).at(7) = -25.558; CheckTripleCT.at(1).at(2).at(7) = 0.734647; CheckTripleCW.at(1).at(2).at(7) = -0.734647; - CheckTripleTree.at(1).at(3).at(4) = -8.88178e-16; - CheckTripleCW.at(1).at(3).at(4) = -9.19403e-17; + CheckTripleTree.at(1).at(3).at(4) = -1.04768e-15; + CheckTripleCT.at(1).at(3).at(4) = -4.44008e-18; + CheckTripleCW.at(1).at(3).at(4) = 1.37861e-16; CheckTripleTree.at(1).at(3).at(5) = -85.5922; CheckTripleCT.at(1).at(3).at(5) = -5.42929; CheckTripleCW.at(1).at(3).at(5) = 5.42929; @@ -253,18 +267,21 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(1).at(3).at(7) = 0.633893; CheckTripleCT.at(1).at(3).at(7) = -0.114735; CheckTripleCW.at(1).at(3).at(7) = 0.114735; - CheckTripleCW.at(1).at(4).at(0) = -7.97973e-17; - CheckTripleTree.at(1).at(4).at(1) = -4.44089e-16; - CheckTripleCT.at(1).at(4).at(1) = -2.60209e-18; - CheckTripleCW.at(1).at(4).at(1) = 6.05418e-15; - CheckTripleTree.at(1).at(4).at(2) = 1.77636e-15; - CheckTripleCT.at(1).at(4).at(2) = -5.55112e-17; - CheckTripleCW.at(1).at(4).at(2) = -6.93889e-16; - CheckTripleTree.at(1).at(4).at(3) = -8.88178e-16; - CheckTripleCW.at(1).at(4).at(3) = -8.32667e-17; - CheckTripleTree.at(1).at(5).at(0) = 8.93383e-17; - CheckTripleCT.at(1).at(5).at(0) = 3.38813e-19; - CheckTripleCW.at(1).at(5).at(0) = -1.28207e-17; + CheckTripleTree.at(1).at(4).at(0) = 2.5605e-17; + CheckTripleCT.at(1).at(4).at(0) = -2.8257e-18; + CheckTripleCW.at(1).at(4).at(0) = 2.03034e-17; + CheckTripleTree.at(1).at(4).at(1) = -4.95101e-16; + CheckTripleCT.at(1).at(4).at(1) = -1.41609e-18; + CheckTripleCW.at(1).at(4).at(1) = 5.77446e-15; + CheckTripleTree.at(1).at(4).at(2) = 2.75577e-15; + CheckTripleCT.at(1).at(4).at(2) = -5.15824e-17; + CheckTripleCW.at(1).at(4).at(2) = 1.32045e-16; + CheckTripleTree.at(1).at(4).at(3) = -1.04768e-15; + CheckTripleCT.at(1).at(4).at(3) = -4.44008e-18; + CheckTripleCW.at(1).at(4).at(3) = 1.02449e-16; + CheckTripleTree.at(1).at(5).at(0) = 1.12653e-16; + CheckTripleCT.at(1).at(5).at(0) = -1.02733e-18; + CheckTripleCW.at(1).at(5).at(0) = 2.62965e-16; CheckTripleTree.at(1).at(5).at(1) = 62.8092; CheckTripleCT.at(1).at(5).at(1) = -59.0416; CheckTripleCW.at(1).at(5).at(1) = 59.0416; @@ -274,9 +291,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(1).at(5).at(3) = -85.5922; CheckTripleCT.at(1).at(5).at(3) = -5.42929; CheckTripleCW.at(1).at(5).at(3) = 5.42929; - CheckTripleTree.at(1).at(6).at(0) = -1.1189e-15; - CheckTripleCT.at(1).at(6).at(0) = -1.27394e-18; - CheckTripleCW.at(1).at(6).at(0) = -1.84314e-17; + CheckTripleTree.at(1).at(6).at(0) = -9.13192e-16; + CheckTripleCT.at(1).at(6).at(0) = -9.70594e-19; + CheckTripleCW.at(1).at(6).at(0) = -4.84251e-17; CheckTripleTree.at(1).at(6).at(1) = 13.6784; CheckTripleCT.at(1).at(6).at(1) = -4.10233; CheckTripleCW.at(1).at(6).at(1) = 4.10233; @@ -286,9 +303,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(1).at(6).at(3) = 531.406; CheckTripleCT.at(1).at(6).at(3) = 2.93805; CheckTripleCW.at(1).at(6).at(3) = -2.93805; - CheckTripleTree.at(1).at(7).at(0) = 1.22125e-15; - CheckTripleCT.at(1).at(7).at(0) = -7.28584e-17; - CheckTripleCW.at(1).at(7).at(0) = -3.31332e-16; + CheckTripleTree.at(1).at(7).at(0) = 1.95682e-15; + CheckTripleCT.at(1).at(7).at(0) = -3.77586e-17; + CheckTripleCW.at(1).at(7).at(0) = -1.67055e-15; CheckTripleTree.at(1).at(7).at(1) = 6.91258; CheckTripleCT.at(1).at(7).at(1) = -0.719745; CheckTripleCW.at(1).at(7).at(1) = 0.719745; @@ -298,9 +315,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(1).at(7).at(3) = 0.633893; CheckTripleCT.at(1).at(7).at(3) = -0.114735; CheckTripleCW.at(1).at(7).at(3) = 0.114735; - CheckTripleTree.at(2).at(0).at(4) = -8.32667e-16; - CheckTripleCT.at(2).at(0).at(4) = -3.25261e-18; - CheckTripleCW.at(2).at(0).at(4) = -3.26128e-16; + CheckTripleTree.at(2).at(0).at(4) = -1.00764e-15; + CheckTripleCT.at(2).at(0).at(4) = -4.25992e-18; + CheckTripleCW.at(2).at(0).at(4) = -6.3926e-18; CheckTripleTree.at(2).at(0).at(5) = -85.5922; CheckTripleCT.at(2).at(0).at(5) = -5.42929; CheckTripleCW.at(2).at(0).at(5) = 5.42929; @@ -310,9 +327,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(2).at(0).at(7) = 0.633893; CheckTripleCT.at(2).at(0).at(7) = -0.114735; CheckTripleCW.at(2).at(0).at(7) = 0.114735; - CheckTripleTree.at(2).at(1).at(4) = 1.88738e-15; - CheckTripleCT.at(2).at(1).at(4) = -5.81132e-17; - CheckTripleCW.at(2).at(1).at(4) = -6.78277e-16; + CheckTripleTree.at(2).at(1).at(4) = 1.96945e-15; + CheckTripleCT.at(2).at(1).at(4) = -5.41687e-17; + CheckTripleCW.at(2).at(1).at(4) = 1.35199e-16; CheckTripleTree.at(2).at(1).at(5) = -8.02502; CheckTripleCT.at(2).at(1).at(5) = -0.040989; CheckTripleCW.at(2).at(1).at(5) = 0.040989; @@ -322,9 +339,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(2).at(1).at(7) = -25.558; CheckTripleCT.at(2).at(1).at(7) = 0.734647; CheckTripleCW.at(2).at(1).at(7) = -0.734647; - CheckTripleTree.at(2).at(2).at(4) = 6.66134e-16; - CheckTripleCT.at(2).at(2).at(4) = 2.42861e-17; - CheckTripleCW.at(2).at(2).at(4) = 1.91093e-14; + CheckTripleTree.at(2).at(2).at(4) = 5.16264e-16; + CheckTripleCT.at(2).at(2).at(4) = 1.21521e-17; + CheckTripleCW.at(2).at(2).at(4) = 7.72857e-15; CheckTripleTree.at(2).at(2).at(5) = 1205.98; CheckTripleCT.at(2).at(2).at(5) = -85.0338; CheckTripleCW.at(2).at(2).at(5) = 121.102; @@ -334,26 +351,30 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(2).at(2).at(7) = 10.2186; CheckTripleCT.at(2).at(2).at(7) = -1.77325; CheckTripleCW.at(2).at(2).at(7) = 0.670659; - CheckTripleCW.at(2).at(3).at(4) = 8.67362e-17; - CheckTripleTree.at(2).at(3).at(5) = 8.93383e-17; - CheckTripleCT.at(2).at(3).at(5) = 7.72494e-19; - CheckTripleCW.at(2).at(3).at(5) = 1.01779e-17; - CheckTripleTree.at(2).at(3).at(6) = -7.30319e-16; - CheckTripleCT.at(2).at(3).at(6) = -6.23416e-19; - CheckTripleCW.at(2).at(3).at(6) = 2.07896e-17; - CheckTripleTree.at(2).at(3).at(7) = 1.22125e-15; - CheckTripleCT.at(2).at(3).at(7) = -4.51028e-17; - CheckTripleCW.at(2).at(3).at(7) = 3.89445e-16; - CheckTripleTree.at(2).at(4).at(0) = -8.04912e-16; - CheckTripleCT.at(2).at(4).at(0) = -3.03577e-18; - CheckTripleCW.at(2).at(4).at(0) = -3.41741e-16; - CheckTripleTree.at(2).at(4).at(1) = 1.88738e-15; - CheckTripleCT.at(2).at(4).at(1) = -5.81132e-17; - CheckTripleCW.at(2).at(4).at(1) = -7.06032e-16; - CheckTripleTree.at(2).at(4).at(2) = 6.66134e-16; - CheckTripleCT.at(2).at(4).at(2) = 2.25514e-17; - CheckTripleCW.at(2).at(4).at(2) = 1.90958e-14; - CheckTripleCW.at(2).at(4).at(3) = 9.36751e-17; + CheckTripleTree.at(2).at(3).at(4) = 2.5605e-17; + CheckTripleCT.at(2).at(3).at(4) = -2.8257e-18; + CheckTripleCW.at(2).at(3).at(4) = -1.6458e-17; + CheckTripleTree.at(2).at(3).at(5) = 1.12079e-16; + CheckTripleCT.at(2).at(3).at(5) = 7.24185e-19; + CheckTripleCW.at(2).at(3).at(5) = -2.65845e-16; + CheckTripleTree.at(2).at(3).at(6) = -4.96858e-16; + CheckTripleCT.at(2).at(3).at(6) = -3.20072e-19; + CheckTripleCW.at(2).at(3).at(6) = 4.94513e-17; + CheckTripleTree.at(2).at(3).at(7) = 1.06864e-15; + CheckTripleCT.at(2).at(3).at(7) = -3.77586e-17; + CheckTripleCW.at(2).at(3).at(7) = 1.6801e-15; + CheckTripleTree.at(2).at(4).at(0) = -9.79882e-16; + CheckTripleCT.at(2).at(4).at(0) = -4.1515e-18; + CheckTripleCW.at(2).at(4).at(0) = 5.06545e-19; + CheckTripleTree.at(2).at(4).at(1) = 1.96945e-15; + CheckTripleCT.at(2).at(4).at(1) = -5.41687e-17; + CheckTripleCW.at(2).at(4).at(1) = 1.09178e-16; + CheckTripleTree.at(2).at(4).at(2) = 5.16264e-16; + CheckTripleCT.at(2).at(4).at(2) = 1.30194e-17; + CheckTripleCW.at(2).at(4).at(2) = 7.88728e-15; + CheckTripleTree.at(2).at(4).at(3) = 2.5605e-17; + CheckTripleCT.at(2).at(4).at(3) = -2.8257e-18; + CheckTripleCW.at(2).at(4).at(3) = -6.04969e-18; CheckTripleTree.at(2).at(5).at(0) = -85.5922; CheckTripleCT.at(2).at(5).at(0) = -5.42929; CheckTripleCW.at(2).at(5).at(0) = 5.42929; @@ -363,9 +384,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(2).at(5).at(2) = 1205.98; CheckTripleCT.at(2).at(5).at(2) = -85.0338; CheckTripleCW.at(2).at(5).at(2) = 121.102; - CheckTripleTree.at(2).at(5).at(3) = 8.93383e-17; - CheckTripleCT.at(2).at(5).at(3) = 7.72494e-19; - CheckTripleCW.at(2).at(5).at(3) = 9.74427e-18; + CheckTripleTree.at(2).at(5).at(3) = 3.34124e-16; + CheckTripleCT.at(2).at(5).at(3) = 7.24185e-19; + CheckTripleCW.at(2).at(5).at(3) = -2.63432e-16; CheckTripleTree.at(2).at(6).at(0) = 531.406; CheckTripleCT.at(2).at(6).at(0) = 2.93805; CheckTripleCW.at(2).at(6).at(0) = -2.93805; @@ -375,9 +396,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(2).at(6).at(2) = 26.5279; CheckTripleCT.at(2).at(6).at(2) = 11.8991; CheckTripleCW.at(2).at(6).at(2) = -57.0764; - CheckTripleTree.at(2).at(6).at(3) = -2.86229e-16; - CheckTripleCT.at(2).at(6).at(3) = -6.23416e-19; - CheckTripleCW.at(2).at(6).at(3) = 2.18738e-17; + CheckTripleTree.at(2).at(6).at(3) = -2.50134e-17; + CheckTripleCT.at(2).at(6).at(3) = 3.30449e-19; + CheckTripleCW.at(2).at(6).at(3) = 4.94784e-17; CheckTripleTree.at(2).at(7).at(0) = 0.633893; CheckTripleCT.at(2).at(7).at(0) = -0.114735; CheckTripleCW.at(2).at(7).at(0) = 0.114735; @@ -387,12 +408,12 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(2).at(7).at(2) = 10.2186; CheckTripleCT.at(2).at(7).at(2) = -1.77325; CheckTripleCW.at(2).at(7).at(2) = 0.670659; - CheckTripleTree.at(2).at(7).at(3) = 3.33067e-16; - CheckTripleCT.at(2).at(7).at(3) = -1.73472e-17; - CheckTripleCW.at(2).at(7).at(3) = 3.89445e-16; - CheckTripleTree.at(3).at(0).at(4) = -1.88738e-15; - CheckTripleCT.at(3).at(0).at(4) = 5.81132e-17; - CheckTripleCW.at(3).at(0).at(4) = 2.81025e-16; + CheckTripleTree.at(2).at(7).at(3) = 3.74751e-16; + CheckTripleCT.at(2).at(7).at(3) = -1.78093e-17; + CheckTripleCW.at(2).at(7).at(3) = 1.68791e-15; + CheckTripleTree.at(3).at(0).at(4) = -1.96945e-15; + CheckTripleCT.at(3).at(0).at(4) = 5.41687e-17; + CheckTripleCW.at(3).at(0).at(4) = -6.32721e-17; CheckTripleTree.at(3).at(0).at(5) = 8.02502; CheckTripleCT.at(3).at(0).at(5) = 0.040989; CheckTripleCW.at(3).at(0).at(5) = -0.040989; @@ -402,9 +423,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(3).at(0).at(7) = 25.558; CheckTripleCT.at(3).at(0).at(7) = -0.734647; CheckTripleCW.at(3).at(0).at(7) = 0.734647; - CheckTripleTree.at(3).at(1).at(4) = -8.32667e-16; - CheckTripleCT.at(3).at(1).at(4) = -3.03577e-18; - CheckTripleCW.at(3).at(1).at(4) = -7.28584e-17; + CheckTripleTree.at(3).at(1).at(4) = -9.90464e-16; + CheckTripleCT.at(3).at(1).at(4) = -4.20689e-18; + CheckTripleCW.at(3).at(1).at(4) = 1.08371e-16; CheckTripleTree.at(3).at(1).at(5) = -85.5922; CheckTripleCT.at(3).at(1).at(5) = -5.42929; CheckTripleCW.at(3).at(1).at(5) = 5.42929; @@ -414,19 +435,21 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(3).at(1).at(7) = 0.633893; CheckTripleCT.at(3).at(1).at(7) = -0.114735; CheckTripleCW.at(3).at(1).at(7) = 0.114735; - CheckTripleCW.at(3).at(2).at(4) = 8.67362e-17; - CheckTripleTree.at(3).at(2).at(5) = -8.97719e-17; - CheckTripleCT.at(3).at(2).at(5) = 1.84314e-18; - CheckTripleCW.at(3).at(2).at(5) = 1.23735e-17; - CheckTripleTree.at(3).at(2).at(6) = -1.56992e-16; - CheckTripleCT.at(3).at(2).at(6) = -2.98156e-19; - CheckTripleCW.at(3).at(2).at(6) = 2.08709e-17; - CheckTripleTree.at(3).at(2).at(7) = 6.10623e-16; - CheckTripleCT.at(3).at(2).at(7) = -1.12757e-17; - CheckTripleCW.at(3).at(2).at(7) = 3.87711e-16; - CheckTripleTree.at(3).at(3).at(4) = 4.44089e-16; - CheckTripleCT.at(3).at(3).at(4) = 2.42861e-17; - CheckTripleCW.at(3).at(3).at(4) = 1.85264e-14; + CheckTripleTree.at(3).at(2).at(4) = 4.95063e-17; + CheckTripleCT.at(3).at(2).at(4) = -3.28356e-18; + CheckTripleCW.at(3).at(2).at(4) = -1.41942e-17; + CheckTripleTree.at(3).at(2).at(5) = 1.99597e-16; + CheckTripleCT.at(3).at(2).at(5) = 1.56943e-18; + CheckTripleCW.at(3).at(2).at(5) = -2.6394e-16; + CheckTripleTree.at(3).at(2).at(6) = -3.45069e-16; + CheckTripleCT.at(3).at(2).at(6) = -2.50533e-18; + CheckTripleCW.at(3).at(2).at(6) = 5.14403e-17; + CheckTripleTree.at(3).at(2).at(7) = 5.50161e-16; + CheckTripleCT.at(3).at(2).at(7) = -1.1021e-17; + CheckTripleCW.at(3).at(2).at(7) = 1.71933e-15; + CheckTripleTree.at(3).at(3).at(4) = 4.95101e-16; + CheckTripleCT.at(3).at(3).at(4) = 1.26918e-17; + CheckTripleCW.at(3).at(3).at(4) = 7.7815e-15; CheckTripleTree.at(3).at(3).at(5) = 1205.98; CheckTripleCT.at(3).at(3).at(5) = -85.0338; CheckTripleCW.at(3).at(3).at(5) = 121.102; @@ -436,25 +459,27 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(3).at(3).at(7) = 10.2186; CheckTripleCT.at(3).at(3).at(7) = -1.77325; CheckTripleCW.at(3).at(3).at(7) = 0.670659; - CheckTripleTree.at(3).at(4).at(0) = -1.88738e-15; - CheckTripleCT.at(3).at(4).at(0) = 5.81132e-17; - CheckTripleCW.at(3).at(4).at(0) = 3.08781e-16; - CheckTripleTree.at(3).at(4).at(1) = -8.32667e-16; - CheckTripleCT.at(3).at(4).at(1) = -3.03577e-18; - CheckTripleCW.at(3).at(4).at(1) = -8.41341e-17; - CheckTripleCW.at(3).at(4).at(2) = 8.32667e-17; - CheckTripleTree.at(3).at(4).at(3) = 4.44089e-16; - CheckTripleCT.at(3).at(4).at(3) = 2.34188e-17; - CheckTripleCW.at(3).at(4).at(3) = 1.85544e-14; + CheckTripleTree.at(3).at(4).at(0) = -1.96945e-15; + CheckTripleCT.at(3).at(4).at(0) = 5.41687e-17; + CheckTripleCW.at(3).at(4).at(0) = -3.72512e-17; + CheckTripleTree.at(3).at(4).at(1) = -9.90464e-16; + CheckTripleCT.at(3).at(4).at(1) = -4.20689e-18; + CheckTripleCW.at(3).at(4).at(1) = 8.94385e-17; + CheckTripleTree.at(3).at(4).at(2) = 4.95063e-17; + CheckTripleCT.at(3).at(4).at(2) = -3.28356e-18; + CheckTripleCW.at(3).at(4).at(2) = -2.11331e-17; + CheckTripleTree.at(3).at(4).at(3) = 4.95101e-16; + CheckTripleCT.at(3).at(4).at(3) = 1.35592e-17; + CheckTripleCW.at(3).at(4).at(3) = 7.74533e-15; CheckTripleTree.at(3).at(5).at(0) = 8.02502; CheckTripleCT.at(3).at(5).at(0) = 0.040989; CheckTripleCW.at(3).at(5).at(0) = -0.040989; CheckTripleTree.at(3).at(5).at(1) = -85.5922; CheckTripleCT.at(3).at(5).at(1) = -5.42929; CheckTripleCW.at(3).at(5).at(1) = 5.42929; - CheckTripleTree.at(3).at(5).at(2) = -8.97719e-17; - CheckTripleCT.at(3).at(5).at(2) = 1.0842e-19; - CheckTripleCW.at(3).at(5).at(2) = 1.23735e-17; + CheckTripleTree.at(3).at(5).at(2) = 1.99597e-16; + CheckTripleCT.at(3).at(5).at(2) = 1.56943e-18; + CheckTripleCW.at(3).at(5).at(2) = -2.65241e-16; CheckTripleTree.at(3).at(5).at(3) = 1205.98; CheckTripleCT.at(3).at(5).at(3) = -85.0338; CheckTripleCW.at(3).at(5).at(3) = 121.102; @@ -464,9 +489,9 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(3).at(6).at(1) = 531.406; CheckTripleCT.at(3).at(6).at(1) = 2.93805; CheckTripleCW.at(3).at(6).at(1) = -2.93805; - CheckTripleTree.at(3).at(6).at(2) = -6.01082e-16; - CheckTripleCT.at(3).at(6).at(2) = -2.46656e-18; - CheckTripleCW.at(3).at(6).at(2) = 2.52077e-17; + CheckTripleTree.at(3).at(6).at(2) = -7.34795e-16; + CheckTripleCT.at(3).at(6).at(2) = -3.33911e-18; + CheckTripleCW.at(3).at(6).at(2) = 5.44424e-17; CheckTripleTree.at(3).at(6).at(3) = 26.5279; CheckTripleCT.at(3).at(6).at(3) = 11.8991; CheckTripleCW.at(3).at(6).at(3) = -57.0764; @@ -476,53 +501,63 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(3).at(7).at(1) = 0.633893; CheckTripleCT.at(3).at(7).at(1) = -0.114735; CheckTripleCW.at(3).at(7).at(1) = 0.114735; - CheckTripleTree.at(3).at(7).at(2) = 6.10623e-16; - CheckTripleCT.at(3).at(7).at(2) = -3.90313e-17; - CheckTripleCW.at(3).at(7).at(2) = 4.15466e-16; + CheckTripleTree.at(3).at(7).at(2) = 1.21629e-15; + CheckTripleCT.at(3).at(7).at(2) = -3.09703e-17; + CheckTripleCW.at(3).at(7).at(2) = 1.73928e-15; CheckTripleTree.at(3).at(7).at(3) = 10.2186; CheckTripleCT.at(3).at(7).at(3) = -1.77325; CheckTripleCW.at(3).at(7).at(3) = 0.670659; - CheckTripleTree.at(4).at(0).at(0) = -6.66134e-16; - CheckTripleCT.at(4).at(0).at(0) = -1.73472e-18; - CheckTripleCW.at(4).at(0).at(0) = 6.07153e-15; - CheckTripleCW.at(4).at(0).at(1) = -9.36751e-17; - CheckTripleTree.at(4).at(0).at(2) = -8.88178e-16; - CheckTripleCW.at(4).at(0).at(2) = -2.39392e-16; - CheckTripleTree.at(4).at(0).at(3) = -1.77636e-15; - CheckTripleCT.at(4).at(0).at(3) = 5.55112e-17; - CheckTripleCW.at(4).at(0).at(3) = 2.77556e-16; - CheckTripleCW.at(4).at(1).at(0) = -7.97973e-17; - CheckTripleTree.at(4).at(1).at(1) = -4.44089e-16; - CheckTripleCT.at(4).at(1).at(1) = -3.46945e-18; - CheckTripleCW.at(4).at(1).at(1) = 6.04725e-15; - CheckTripleTree.at(4).at(1).at(2) = 1.77636e-15; - CheckTripleCT.at(4).at(1).at(2) = -5.55112e-17; - CheckTripleCW.at(4).at(1).at(2) = -6.66134e-16; - CheckTripleTree.at(4).at(1).at(3) = -8.88178e-16; - CheckTripleCW.at(4).at(1).at(3) = -1.10155e-16; - CheckTripleTree.at(4).at(2).at(0) = -9.99201e-16; - CheckTripleCT.at(4).at(2).at(0) = 7.58942e-19; - CheckTripleCW.at(4).at(2).at(0) = -2.41994e-16; - CheckTripleTree.at(4).at(2).at(1) = 1.7486e-15; - CheckTripleCT.at(4).at(2).at(1) = -4.51028e-17; - CheckTripleCW.at(4).at(2).at(1) = -6.97359e-16; - CheckTripleTree.at(4).at(2).at(2) = 6.66134e-16; - CheckTripleCT.at(4).at(2).at(2) = 2.08167e-17; - CheckTripleCW.at(4).at(2).at(2) = 1.92624e-14; - CheckTripleCW.at(4).at(2).at(3) = 9.36751e-17; - CheckTripleTree.at(4).at(3).at(0) = -1.7486e-15; - CheckTripleCT.at(4).at(3).at(0) = 4.51028e-17; - CheckTripleCW.at(4).at(3).at(0) = 3.10516e-16; - CheckTripleTree.at(4).at(3).at(1) = -9.71445e-16; - CheckTripleCT.at(4).at(3).at(1) = -2.38524e-18; - CheckTripleCW.at(4).at(3).at(1) = -1.04951e-16; - CheckTripleCW.at(4).at(3).at(2) = 8.32667e-17; - CheckTripleTree.at(4).at(3).at(3) = 4.44089e-16; - CheckTripleCT.at(4).at(3).at(3) = 2.25514e-17; - CheckTripleCW.at(4).at(3).at(3) = 1.85854e-14; - CheckTripleTree.at(4).at(4).at(4) = -1.33227e-15; - CheckTripleCT.at(4).at(4).at(4) = -3.46945e-18; - CheckTripleCW.at(4).at(4).at(4) = 1.84158e-14; + CheckTripleTree.at(4).at(0).at(0) = -6.27287e-16; + CheckTripleCT.at(4).at(0).at(0) = -1.74372e-18; + CheckTripleCW.at(4).at(0).at(0) = 5.7478e-15; + CheckTripleTree.at(4).at(0).at(1) = 4.95063e-17; + CheckTripleCT.at(4).at(0).at(1) = -3.28356e-18; + CheckTripleCW.at(4).at(0).at(1) = 5.22006e-18; + CheckTripleTree.at(4).at(0).at(2) = -1.04768e-15; + CheckTripleCT.at(4).at(0).at(2) = -4.44008e-18; + CheckTripleCW.at(4).at(0).at(2) = 3.46925e-17; + CheckTripleTree.at(4).at(0).at(3) = -2.75577e-15; + CheckTripleCT.at(4).at(0).at(3) = 7.93379e-17; + CheckTripleCW.at(4).at(0).at(3) = -5.62936e-17; + CheckTripleTree.at(4).at(1).at(0) = 2.5605e-17; + CheckTripleCT.at(4).at(1).at(0) = -2.8257e-18; + CheckTripleCW.at(4).at(1).at(0) = 2.37729e-17; + CheckTripleTree.at(4).at(1).at(1) = -4.95101e-16; + CheckTripleCT.at(4).at(1).at(1) = -1.41609e-18; + CheckTripleCW.at(4).at(1).at(1) = 5.74876e-15; + CheckTripleTree.at(4).at(1).at(2) = 2.75577e-15; + CheckTripleCT.at(4).at(1).at(2) = -7.93379e-17; + CheckTripleCW.at(4).at(1).at(2) = 1.32045e-16; + CheckTripleTree.at(4).at(1).at(3) = -1.04768e-15; + CheckTripleCT.at(4).at(1).at(3) = -9.70629e-19; + CheckTripleCW.at(4).at(1).at(3) = 4.10755e-17; + CheckTripleTree.at(4).at(2).at(0) = -1.17417e-15; + CheckTripleCT.at(4).at(2).at(0) = -2.95888e-18; + CheckTripleCW.at(4).at(2).at(0) = 2.8621e-17; + CheckTripleTree.at(4).at(2).at(1) = 1.83068e-15; + CheckTripleCT.at(4).at(2).at(1) = -6.63118e-17; + CheckTripleCW.at(4).at(2).at(1) = 8.3157e-17; + CheckTripleTree.at(4).at(2).at(2) = 6.27287e-16; + CheckTripleCT.at(4).at(2).at(2) = 1.38868e-17; + CheckTripleCW.at(4).at(2).at(2) = 7.94993e-15; + CheckTripleTree.at(4).at(2).at(3) = 2.5605e-17; + CheckTripleCT.at(4).at(2).at(3) = -2.8257e-18; + CheckTripleCW.at(4).at(2).at(3) = -6.04969e-18; + CheckTripleTree.at(4).at(3).at(0) = -1.83068e-15; + CheckTripleCT.at(4).at(3).at(0) = 6.63118e-17; + CheckTripleCW.at(4).at(3).at(0) = -3.03124e-17; + CheckTripleTree.at(4).at(3).at(1) = -1.12924e-15; + CheckTripleCT.at(4).at(3).at(1) = -2.68901e-18; + CheckTripleCW.at(4).at(3).at(1) = 3.15345e-17; + CheckTripleTree.at(4).at(3).at(2) = 4.95063e-17; + CheckTripleCT.at(4).at(3).at(2) = -3.28356e-18; + CheckTripleCW.at(4).at(3).at(2) = -2.11331e-17; + CheckTripleTree.at(4).at(3).at(3) = 4.95101e-16; + CheckTripleCT.at(4).at(3).at(3) = 1.52939e-17; + CheckTripleCW.at(4).at(3).at(3) = 7.68001e-15; + CheckTripleTree.at(4).at(4).at(4) = -1.33923e-15; + CheckTripleCT.at(4).at(4).at(4) = -3.06322e-18; + CheckTripleCW.at(4).at(4).at(4) = 1.74186e-14; CheckTripleTree.at(4).at(4).at(5) = 62.8092; CheckTripleCT.at(4).at(4).at(5) = -59.0416; CheckTripleCW.at(4).at(4).at(5) = 59.0416; @@ -535,7 +570,7 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(4).at(5).at(4) = 62.8092; CheckTripleCT.at(4).at(5).at(4) = -59.0416; CheckTripleCW.at(4).at(5).at(4) = 59.0416; - CheckTripleTree.at(4).at(5).at(5) = 1.79579e-14; + CheckTripleTree.at(4).at(5).at(5) = 1.53529e-14; CheckTripleCT.at(4).at(5).at(5) = 0.142003; CheckTripleCW.at(4).at(5).at(5) = -0.142003; CheckTripleTree.at(4).at(5).at(6) = 0.27977; @@ -550,7 +585,7 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(4).at(6).at(5) = 0.27977; CheckTripleCT.at(4).at(6).at(5) = -0.119192; CheckTripleCW.at(4).at(6).at(5) = 0.119192; - CheckTripleTree.at(4).at(6).at(6) = 4.58245e-14; + CheckTripleTree.at(4).at(6).at(6) = -5.89467e-14; CheckTripleCT.at(4).at(6).at(6) = 0.0509546; CheckTripleCW.at(4).at(6).at(6) = -0.0509546; CheckTripleTree.at(4).at(6).at(7) = 556.787; @@ -565,24 +600,24 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(4).at(7).at(6) = 556.787; CheckTripleCT.at(4).at(7).at(6) = 2.20949; CheckTripleCW.at(4).at(7).at(6) = -2.20949; - CheckTripleTree.at(4).at(7).at(7) = 6.95832e-14; + CheckTripleTree.at(4).at(7).at(7) = 8.34343e-14; CheckTripleCT.at(4).at(7).at(7) = -0.192957; CheckTripleCW.at(4).at(7).at(7) = 0.192957; CheckTripleTree.at(5).at(0).at(0) = 62.8092; CheckTripleCT.at(5).at(0).at(0) = -59.0416; CheckTripleCW.at(5).at(0).at(0) = 59.0416; - CheckTripleTree.at(5).at(0).at(1) = -4.33681e-19; - CheckTripleCT.at(5).at(0).at(1) = 1.3146e-18; - CheckTripleCW.at(5).at(0).at(1) = -1.17636e-17; + CheckTripleTree.at(5).at(0).at(1) = 3.95187e-16; + CheckTripleCT.at(5).at(0).at(1) = 1.3797e-18; + CheckTripleCW.at(5).at(0).at(1) = 2.64283e-16; CheckTripleTree.at(5).at(0).at(2) = -85.5922; CheckTripleCT.at(5).at(0).at(2) = -5.42929; CheckTripleCW.at(5).at(0).at(2) = 5.42929; CheckTripleTree.at(5).at(0).at(3) = 8.02502; CheckTripleCT.at(5).at(0).at(3) = 0.040989; CheckTripleCW.at(5).at(0).at(3) = -0.040989; - CheckTripleTree.at(5).at(1).at(0) = -4.33681e-19; - CheckTripleCT.at(5).at(1).at(0) = 4.47233e-19; - CheckTripleCW.at(5).at(1).at(0) = -1.21566e-17; + CheckTripleTree.at(5).at(1).at(0) = 2.72178e-17; + CheckTripleCT.at(5).at(1).at(0) = 4.76999e-19; + CheckTripleCW.at(5).at(1).at(0) = 2.63087e-16; CheckTripleTree.at(5).at(1).at(1) = 62.8092; CheckTripleCT.at(5).at(1).at(1) = -59.0416; CheckTripleCW.at(5).at(1).at(1) = 59.0416; @@ -601,25 +636,25 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(5).at(2).at(2) = 1205.98; CheckTripleCT.at(5).at(2).at(2) = -85.0338; CheckTripleCW.at(5).at(2).at(2) = 121.102; - CheckTripleTree.at(5).at(2).at(3) = -4.33681e-19; - CheckTripleCT.at(5).at(2).at(3) = 1.3146e-18; - CheckTripleCW.at(5).at(2).at(3) = 8.68717e-18; + CheckTripleTree.at(5).at(2).at(3) = 2.48688e-16; + CheckTripleCT.at(5).at(2).at(3) = 1.36115e-18; + CheckTripleCW.at(5).at(2).at(3) = -2.6659e-16; CheckTripleTree.at(5).at(3).at(0) = 8.02502; CheckTripleCT.at(5).at(3).at(0) = 0.040989; CheckTripleCW.at(5).at(3).at(0) = -0.040989; CheckTripleTree.at(5).at(3).at(1) = -85.5922; CheckTripleCT.at(5).at(3).at(1) = -5.42929; CheckTripleCW.at(5).at(3).at(1) = 5.42929; - CheckTripleTree.at(5).at(3).at(2) = -4.33681e-19; - CheckTripleCT.at(5).at(3).at(2) = 4.47233e-19; - CheckTripleCW.at(5).at(3).at(2) = 1.03948e-17; + CheckTripleTree.at(5).at(3).at(2) = 1.73576e-16; + CheckTripleCT.at(5).at(3).at(2) = 9.32464e-19; + CheckTripleCW.at(5).at(3).at(2) = -2.64049e-16; CheckTripleTree.at(5).at(3).at(3) = 1205.98; CheckTripleCT.at(5).at(3).at(3) = -85.0338; CheckTripleCW.at(5).at(3).at(3) = 121.102; CheckTripleTree.at(5).at(4).at(4) = 62.8092; CheckTripleCT.at(5).at(4).at(4) = -59.0416; CheckTripleCW.at(5).at(4).at(4) = 59.0416; - CheckTripleTree.at(5).at(4).at(5) = 1.80134e-14; + CheckTripleTree.at(5).at(4).at(5) = 1.6019e-14; CheckTripleCT.at(5).at(4).at(5) = 0.142003; CheckTripleCW.at(5).at(4).at(5) = -0.142003; CheckTripleTree.at(5).at(4).at(6) = 0.27977; @@ -628,7 +663,7 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(5).at(4).at(7) = -89.6461; CheckTripleCT.at(5).at(4).at(7) = -5.31526; CheckTripleCW.at(5).at(4).at(7) = 5.31526; - CheckTripleTree.at(5).at(5).at(4) = 1.89488e-14; + CheckTripleTree.at(5).at(5).at(4) = 1.63707e-14; CheckTripleCT.at(5).at(5).at(4) = 0.142003; CheckTripleCW.at(5).at(5).at(4) = -0.142003; CheckTripleTree.at(5).at(5).at(5) = 190.368; @@ -667,18 +702,18 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(6).at(0).at(0) = 13.6784; CheckTripleCT.at(6).at(0).at(0) = -4.10233; CheckTripleCW.at(6).at(0).at(0) = 4.10233; - CheckTripleTree.at(6).at(0).at(1) = 2.86229e-17; - CheckTripleCT.at(6).at(0).at(1) = -4.87891e-19; - CheckTripleCW.at(6).at(0).at(1) = -2.13588e-17; + CheckTripleTree.at(6).at(0).at(1) = 2.43002e-16; + CheckTripleCT.at(6).at(0).at(1) = -4.72456e-19; + CheckTripleCW.at(6).at(0).at(1) = -4.87943e-17; CheckTripleTree.at(6).at(0).at(2) = 531.406; CheckTripleCT.at(6).at(0).at(2) = 2.93805; CheckTripleCW.at(6).at(0).at(2) = -2.93805; CheckTripleTree.at(6).at(0).at(3) = -12.3149; CheckTripleCT.at(6).at(0).at(3) = -0.042303; CheckTripleCW.at(6).at(0).at(3) = 0.042303; - CheckTripleTree.at(6).at(1).at(0) = -8.04044e-16; - CheckTripleCT.at(6).at(1).at(0) = -2.00577e-18; - CheckTripleCW.at(6).at(1).at(0) = -1.88109e-17; + CheckTripleTree.at(6).at(1).at(0) = -9.73907e-16; + CheckTripleCT.at(6).at(1).at(0) = -1.89217e-18; + CheckTripleCW.at(6).at(1).at(0) = -4.54978e-17; CheckTripleTree.at(6).at(1).at(1) = 13.6784; CheckTripleCT.at(6).at(1).at(1) = -4.10233; CheckTripleCW.at(6).at(1).at(1) = 4.10233; @@ -697,18 +732,18 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(6).at(2).at(2) = 26.5279; CheckTripleCT.at(6).at(2).at(2) = 11.8991; CheckTripleCW.at(6).at(2).at(2) = -57.0764; - CheckTripleTree.at(6).at(2).at(3) = 2.86229e-17; - CheckTripleCT.at(6).at(2).at(3) = -4.87891e-19; - CheckTripleCW.at(6).at(2).at(3) = 2.32019e-17; + CheckTripleTree.at(6).at(2).at(3) = -1.12617e-16; + CheckTripleCT.at(6).at(2).at(3) = -1.84547e-19; + CheckTripleCW.at(6).at(2).at(3) = 4.96953e-17; CheckTripleTree.at(6).at(3).at(0) = -12.3149; CheckTripleCT.at(6).at(3).at(0) = -0.042303; CheckTripleCW.at(6).at(3).at(0) = 0.042303; CheckTripleTree.at(6).at(3).at(1) = 531.406; CheckTripleCT.at(6).at(3).at(1) = 2.93805; CheckTripleCW.at(6).at(3).at(1) = -2.93805; - CheckTripleTree.at(6).at(3).at(2) = -8.04044e-16; - CheckTripleCT.at(6).at(3).at(2) = -2.00577e-18; - CheckTripleCW.at(6).at(3).at(2) = 2.41235e-17; + CheckTripleTree.at(6).at(3).at(2) = -6.18569e-16; + CheckTripleCT.at(6).at(3).at(2) = -2.60727e-18; + CheckTripleCW.at(6).at(3).at(2) = 4.99972e-17; CheckTripleTree.at(6).at(3).at(3) = 26.5279; CheckTripleCT.at(6).at(3).at(3) = 11.8991; CheckTripleCW.at(6).at(3).at(3) = -57.0764; @@ -718,7 +753,7 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(6).at(4).at(5) = 0.27977; CheckTripleCT.at(6).at(4).at(5) = -0.119192; CheckTripleCW.at(6).at(4).at(5) = 0.119192; - CheckTripleTree.at(6).at(4).at(6) = 4.8489e-14; + CheckTripleTree.at(6).at(4).at(6) = -5.65042e-14; CheckTripleCT.at(6).at(4).at(6) = 0.0509546; CheckTripleCW.at(6).at(4).at(6) = -0.0509546; CheckTripleTree.at(6).at(4).at(7) = 556.787; @@ -736,7 +771,7 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(6).at(5).at(7) = 0.952387; CheckTripleCT.at(6).at(5).at(7) = 0.204556; CheckTripleCW.at(6).at(5).at(7) = -0.0440307; - CheckTripleTree.at(6).at(6).at(4) = 4.53955e-14; + CheckTripleTree.at(6).at(6).at(4) = -5.65718e-14; CheckTripleCT.at(6).at(6).at(4) = 0.0509546; CheckTripleCW.at(6).at(6).at(4) = -0.0509546; CheckTripleTree.at(6).at(6).at(5) = 187.557; @@ -763,18 +798,18 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(7).at(0).at(0) = 6.91258; CheckTripleCT.at(7).at(0).at(0) = -0.719745; CheckTripleCW.at(7).at(0).at(0) = 0.719745; - CheckTripleTree.at(7).at(0).at(1) = 5.55112e-17; - CheckTripleCT.at(7).at(0).at(1) = -8.67362e-19; - CheckTripleCW.at(7).at(0).at(1) = -3.85109e-16; + CheckTripleTree.at(7).at(0).at(1) = -4.95088e-18; + CheckTripleCT.at(7).at(0).at(1) = -5.81686e-18; + CheckTripleCW.at(7).at(0).at(1) = -1.69204e-15; CheckTripleTree.at(7).at(0).at(2) = 0.633893; CheckTripleCT.at(7).at(0).at(2) = -0.114735; CheckTripleCW.at(7).at(0).at(2) = 0.114735; CheckTripleTree.at(7).at(0).at(3) = 25.558; CheckTripleCT.at(7).at(0).at(3) = -0.734647; CheckTripleCW.at(7).at(0).at(3) = 0.734647; - CheckTripleTree.at(7).at(1).at(0) = 9.4369e-16; - CheckTripleCT.at(7).at(1).at(0) = -5.63785e-17; - CheckTripleCW.at(7).at(1).at(0) = -3.322e-16; + CheckTripleTree.at(7).at(1).at(0) = 1.65151e-15; + CheckTripleCT.at(7).at(1).at(0) = -4.38302e-17; + CheckTripleCW.at(7).at(1).at(0) = -1.62892e-15; CheckTripleTree.at(7).at(1).at(1) = 6.91258; CheckTripleCT.at(7).at(1).at(1) = -0.719745; CheckTripleCW.at(7).at(1).at(1) = 0.719745; @@ -793,18 +828,18 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(7).at(2).at(2) = 10.2186; CheckTripleCT.at(7).at(2).at(2) = -1.77325; CheckTripleCW.at(7).at(2).at(2) = 0.670659; - CheckTripleTree.at(7).at(2).at(3) = 5.55112e-17; - CheckTripleCT.at(7).at(2).at(3) = -8.67362e-19; - CheckTripleCW.at(7).at(2).at(3) = 3.86843e-16; + CheckTripleTree.at(7).at(2).at(3) = 6.94398e-17; + CheckTripleCT.at(7).at(2).at(3) = 3.87473e-18; + CheckTripleCW.at(7).at(2).at(3) = 1.69398e-15; CheckTripleTree.at(7).at(3).at(0) = 25.558; CheckTripleCT.at(7).at(3).at(0) = -0.734647; CheckTripleCW.at(7).at(3).at(0) = 0.734647; CheckTripleTree.at(7).at(3).at(1) = 0.633893; CheckTripleCT.at(7).at(3).at(1) = -0.114735; CheckTripleCW.at(7).at(3).at(1) = 0.114735; - CheckTripleTree.at(7).at(3).at(2) = 9.4369e-16; - CheckTripleCT.at(7).at(3).at(2) = -5.63785e-17; - CheckTripleCW.at(7).at(3).at(2) = 4.17201e-16; + CheckTripleTree.at(7).at(3).at(2) = 1.57712e-15; + CheckTripleCT.at(7).at(3).at(2) = -5.35218e-17; + CheckTripleCW.at(7).at(3).at(2) = 1.72627e-15; CheckTripleTree.at(7).at(3).at(3) = 10.2186; CheckTripleCT.at(7).at(3).at(3) = -1.77325; CheckTripleCW.at(7).at(3).at(3) = 0.670659; @@ -817,7 +852,7 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(7).at(4).at(6) = 556.787; CheckTripleCT.at(7).at(4).at(6) = 2.20949; CheckTripleCW.at(7).at(4).at(6) = -2.20949; - CheckTripleTree.at(7).at(4).at(7) = 7.06935e-14; + CheckTripleTree.at(7).at(4).at(7) = 8.34343e-14; CheckTripleCT.at(7).at(4).at(7) = -0.192957; CheckTripleCW.at(7).at(4).at(7) = 0.192957; CheckTripleTree.at(7).at(5).at(4) = -89.6461; @@ -844,7 +879,7 @@ Compare_C2HDM::Compare_C2HDM() CheckTripleTree.at(7).at(6).at(7) = 34.3045; CheckTripleCT.at(7).at(6).at(7) = 11.6793; CheckTripleCW.at(7).at(6).at(7) = -61.5471; - CheckTripleTree.at(7).at(7).at(4) = 6.4837e-14; + CheckTripleTree.at(7).at(7).at(4) = 7.71892e-14; CheckTripleCT.at(7).at(7).at(4) = -0.192957; CheckTripleCW.at(7).at(7).at(4) = 0.192957; CheckTripleTree.at(7).at(7).at(5) = 1256.44; diff --git a/tests/GenerateTestCompares/C2HDM.h b/tests/GenerateTestCompares/C2HDM.h index 08f25b4c..06d143cc 100644 --- a/tests/GenerateTestCompares/C2HDM.h +++ b/tests/GenerateTestCompares/C2HDM.h @@ -1,5 +1,4 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas -// Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler // // SPDX-License-Identifier: GPL-3.0-or-later #include diff --git a/tests/GenerateTestCompares/CMakeLists.txt b/tests/GenerateTestCompares/CMakeLists.txt index f0204d08..ac553036 100644 --- a/tests/GenerateTestCompares/CMakeLists.txt +++ b/tests/GenerateTestCompares/CMakeLists.txt @@ -1,28 +1,13 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later +set(header C2HDM.h R2HDM.h N2HDM.h CPINTHEDARK.h CXSM.h SM.h) -set(header - C2HDM.h - R2HDM.h - RN2HDM.h - CPINTHEDARK.h - CXSM.h - ) - -set(src - C2HDM.cpp - R2HDM.cpp - RN2HDM.cpp - CPINTHEDARK.cpp - CXSM.cpp - ) +set(src C2HDM.cpp R2HDM.cpp N2HDM.cpp CPINTHEDARK.cpp CXSM.cpp SM.cpp) add_library(TestCompares ${header} ${src}) -target_compile_features(TestCompares PUBLIC cxx_std_14) -target_link_libraries(TestCompares PRIVATE Minimizer ) +target_compile_features(TestCompares PUBLIC cxx_std_17) +target_link_libraries(TestCompares PRIVATE Minimizer) target_include_directories(TestCompares PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) - - - diff --git a/tests/GenerateTestCompares/CPINTHEDARK.cpp b/tests/GenerateTestCompares/CPINTHEDARK.cpp index 02d2b621..671273e1 100644 --- a/tests/GenerateTestCompares/CPINTHEDARK.cpp +++ b/tests/GenerateTestCompares/CPINTHEDARK.cpp @@ -1,6 +1,4 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas -// Müller -// +// SPDX-FileCopyrightText: 2021 Philipp Basler // // SPDX-License-Identifier: GPL-3.0-or-later #include "CPINTHEDARK.h" @@ -13,52 +11,52 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; CheckTripleCT = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - EWPTPerSetting[4].Tc = 201.599; - EWPTPerSetting[4].vc = 185.063; + EWPTPerSetting[4].Tc = 202.615; + EWPTPerSetting[4].vc = 177.534; EWPTPerSetting[4].EWMinimum.push_back(0); - EWPTPerSetting[4].EWMinimum.push_back(-185.063); + EWPTPerSetting[4].EWMinimum.push_back(177.534); EWPTPerSetting[4].EWMinimum.push_back(0); EWPTPerSetting[4].EWMinimum.push_back(0); EWPTPerSetting[4].EWMinimum.push_back(0); - EWPTPerSetting[1].Tc = 228.552; - EWPTPerSetting[1].vc = 159.987; + EWPTPerSetting[1].Tc = 224.551; + EWPTPerSetting[1].vc = 154.173; EWPTPerSetting[1].EWMinimum.push_back(0); - EWPTPerSetting[1].EWMinimum.push_back(159.987); + EWPTPerSetting[1].EWMinimum.push_back(154.173); EWPTPerSetting[1].EWMinimum.push_back(0); EWPTPerSetting[1].EWMinimum.push_back(0); - EWPTPerSetting[1].EWMinimum.push_back(1.33704e-05); - EWPTPerSetting[5].Tc = 201.599; - EWPTPerSetting[5].vc = 185.05; + EWPTPerSetting[1].EWMinimum.push_back(1.81339e-05); + EWPTPerSetting[5].Tc = 202.679; + EWPTPerSetting[5].vc = 177.468; EWPTPerSetting[5].EWMinimum.push_back(0); - EWPTPerSetting[5].EWMinimum.push_back(185.05); + EWPTPerSetting[5].EWMinimum.push_back(177.468); EWPTPerSetting[5].EWMinimum.push_back(0); EWPTPerSetting[5].EWMinimum.push_back(0); EWPTPerSetting[5].EWMinimum.push_back(0); - EWPTPerSetting[2].Tc = 184.717; - EWPTPerSetting[2].vc = 198.073; + EWPTPerSetting[2].Tc = 185.202; + EWPTPerSetting[2].vc = 192.757; + EWPTPerSetting[2].EWMinimum.push_back(0); + EWPTPerSetting[2].EWMinimum.push_back(192.757); + EWPTPerSetting[2].EWMinimum.push_back(0); + EWPTPerSetting[2].EWMinimum.push_back(0); EWPTPerSetting[2].EWMinimum.push_back(0); - EWPTPerSetting[2].EWMinimum.push_back(198.073); - EWPTPerSetting[2].EWMinimum.push_back(-1.14246e-05); - EWPTPerSetting[2].EWMinimum.push_back(1.17576e-05); - EWPTPerSetting[2].EWMinimum.push_back(1.54765e-05); - EWPTPerSetting[6].Tc = 184.717; - EWPTPerSetting[6].vc = 198.073; + EWPTPerSetting[6].Tc = 185.202; + EWPTPerSetting[6].vc = 192.757; + EWPTPerSetting[6].EWMinimum.push_back(0); + EWPTPerSetting[6].EWMinimum.push_back(192.757); + EWPTPerSetting[6].EWMinimum.push_back(0); + EWPTPerSetting[6].EWMinimum.push_back(0); EWPTPerSetting[6].EWMinimum.push_back(0); - EWPTPerSetting[6].EWMinimum.push_back(198.073); - EWPTPerSetting[6].EWMinimum.push_back(-1.14246e-05); - EWPTPerSetting[6].EWMinimum.push_back(1.17576e-05); - EWPTPerSetting[6].EWMinimum.push_back(1.54765e-05); - EWPTPerSetting[3].Tc = 184.717; - EWPTPerSetting[3].vc = 198.073; + EWPTPerSetting[3].Tc = 185.202; + EWPTPerSetting[3].vc = 192.757; EWPTPerSetting[3].EWMinimum.push_back(0); - EWPTPerSetting[3].EWMinimum.push_back(198.073); + EWPTPerSetting[3].EWMinimum.push_back(192.757); EWPTPerSetting[3].EWMinimum.push_back(0); EWPTPerSetting[3].EWMinimum.push_back(0); EWPTPerSetting[3].EWMinimum.push_back(0); - EWPTPerSetting[7].Tc = 184.717; - EWPTPerSetting[7].vc = 198.073; + EWPTPerSetting[7].Tc = 185.202; + EWPTPerSetting[7].vc = 192.757; EWPTPerSetting[7].EWMinimum.push_back(0); - EWPTPerSetting[7].EWMinimum.push_back(198.073); + EWPTPerSetting[7].EWMinimum.push_back(192.757); EWPTPerSetting[7].EWMinimum.push_back(0); EWPTPerSetting[7].EWMinimum.push_back(0); EWPTPerSetting[7].EWMinimum.push_back(0); @@ -275,7 +273,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(5).at(5).at(4) = 63.551; CheckTripleCT.at(5).at(5).at(4) = -65.8413; CheckTripleCW.at(5).at(5).at(4) = 65.8413; - CheckTripleTree.at(5).at(6).at(6) = -3.6593e-13; + CheckTripleTree.at(5).at(6).at(6) = -3.1664e-13; CheckTripleCT.at(5).at(6).at(6) = -0.419379; CheckTripleCW.at(5).at(6).at(6) = 0.419379; CheckTripleTree.at(5).at(6).at(7) = 53.5156; @@ -287,7 +285,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(5).at(7).at(6) = 53.5156; CheckTripleCT.at(5).at(7).at(6) = -0.343723; CheckTripleCW.at(5).at(7).at(6) = 0.343723; - CheckTripleTree.at(5).at(7).at(7) = 3.24185e-13; + CheckTripleTree.at(5).at(7).at(7) = 2.92999e-13; CheckTripleCT.at(5).at(7).at(7) = 0.68013; CheckTripleCW.at(5).at(7).at(7) = -0.68013; CheckTripleTree.at(5).at(7).at(8) = 142.293; @@ -299,7 +297,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(5).at(8).at(7) = 142.293; CheckTripleCT.at(5).at(8).at(7) = -1.37743; CheckTripleCW.at(5).at(8).at(7) = 1.37743; - CheckTripleTree.at(5).at(8).at(8) = 4.9738e-14; + CheckTripleTree.at(5).at(8).at(8) = 2.07475e-14; CheckTripleCT.at(5).at(8).at(8) = -0.260752; CheckTripleCW.at(5).at(8).at(8) = 0.260752; CheckTripleTree.at(6).at(0).at(2) = 83.6912; @@ -335,7 +333,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(6).at(4).at(8) = 449.782; CheckTripleCT.at(6).at(4).at(8) = 0.178107; CheckTripleCW.at(6).at(4).at(8) = 315.248; - CheckTripleTree.at(6).at(5).at(6) = -3.6593e-13; + CheckTripleTree.at(6).at(5).at(6) = -3.1664e-13; CheckTripleCT.at(6).at(5).at(6) = -0.419379; CheckTripleCW.at(6).at(5).at(6) = 0.419379; CheckTripleTree.at(6).at(5).at(7) = 53.5156; @@ -347,7 +345,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(6).at(6).at(4) = -61.509; CheckTripleCT.at(6).at(6).at(4) = 3.46871; CheckTripleCW.at(6).at(6).at(4) = 79.5555; - CheckTripleTree.at(6).at(6).at(5) = -3.6593e-13; + CheckTripleTree.at(6).at(6).at(5) = -3.1664e-13; CheckTripleCT.at(6).at(6).at(5) = -0.419379; CheckTripleCW.at(6).at(6).at(5) = 0.419379; CheckTripleTree.at(6).at(7).at(4) = 67.2656; @@ -398,7 +396,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(7).at(5).at(6) = 53.5156; CheckTripleCT.at(7).at(5).at(6) = -0.343723; CheckTripleCW.at(7).at(5).at(6) = 0.343723; - CheckTripleTree.at(7).at(5).at(7) = 3.24185e-13; + CheckTripleTree.at(7).at(5).at(7) = 2.92999e-13; CheckTripleCT.at(7).at(5).at(7) = 0.68013; CheckTripleCW.at(7).at(5).at(7) = -0.68013; CheckTripleTree.at(7).at(5).at(8) = 142.293; @@ -413,7 +411,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(7).at(7).at(4) = -137.401; CheckTripleCT.at(7).at(7).at(4) = 3.13061; CheckTripleCW.at(7).at(7).at(4) = -16.7975; - CheckTripleTree.at(7).at(7).at(5) = 3.24185e-13; + CheckTripleTree.at(7).at(7).at(5) = 2.92999e-13; CheckTripleCT.at(7).at(7).at(5) = 0.68013; CheckTripleCW.at(7).at(7).at(5) = -0.68013; CheckTripleTree.at(7).at(8).at(4) = 141.657; @@ -461,7 +459,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(8).at(5).at(7) = 142.293; CheckTripleCT.at(8).at(5).at(7) = -1.37743; CheckTripleCW.at(8).at(5).at(7) = 1.37743; - CheckTripleTree.at(8).at(5).at(8) = 4.9738e-14; + CheckTripleTree.at(8).at(5).at(8) = 2.07475e-14; CheckTripleCT.at(8).at(5).at(8) = -0.260752; CheckTripleCW.at(8).at(5).at(8) = 0.260752; CheckTripleTree.at(8).at(6).at(4) = 449.782; @@ -479,7 +477,7 @@ Compare_CPINTHEDARK::Compare_CPINTHEDARK() CheckTripleTree.at(8).at(8).at(4) = 1552.7; CheckTripleCT.at(8).at(8).at(4) = -0.679378; CheckTripleCW.at(8).at(8).at(4) = 892.734; - CheckTripleTree.at(8).at(8).at(5) = 4.9738e-14; + CheckTripleTree.at(8).at(8).at(5) = 2.07475e-14; CheckTripleCT.at(8).at(8).at(5) = -0.260752; CheckTripleCW.at(8).at(8).at(5) = 0.260752; } diff --git a/tests/GenerateTestCompares/CPINTHEDARK.h b/tests/GenerateTestCompares/CPINTHEDARK.h index f544e9ac..572de6cb 100644 --- a/tests/GenerateTestCompares/CPINTHEDARK.h +++ b/tests/GenerateTestCompares/CPINTHEDARK.h @@ -1,6 +1,4 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas -// Müller -// +// SPDX-FileCopyrightText: 2021 Philipp Basler // // SPDX-License-Identifier: GPL-3.0-or-later #include diff --git a/tests/GenerateTestCompares/CXSM.cpp b/tests/GenerateTestCompares/CXSM.cpp index e6482f3f..ee35af2b 100644 --- a/tests/GenerateTestCompares/CXSM.cpp +++ b/tests/GenerateTestCompares/CXSM.cpp @@ -1,6 +1,5 @@ // SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas // Müller -// // SPDX-License-Identifier: GPL-3.0-or-later #include "CXSM.h" Compare_CXSM::Compare_CXSM() @@ -12,41 +11,41 @@ Compare_CXSM::Compare_CXSM() Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; CheckTripleCT = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - EWPTPerSetting[4].Tc = 300; - EWPTPerSetting[4].vc = 0; + EWPTPerSetting[4].Tc = 159.21; + EWPTPerSetting[4].vc = 21.0029; + EWPTPerSetting[4].EWMinimum.push_back(21.0029); + EWPTPerSetting[4].EWMinimum.push_back(538.699); EWPTPerSetting[4].EWMinimum.push_back(0); - EWPTPerSetting[4].EWMinimum.push_back(0); - EWPTPerSetting[4].EWMinimum.push_back(0); - EWPTPerSetting[1].Tc = 160.208; - EWPTPerSetting[1].vc = 20.93; - EWPTPerSetting[1].EWMinimum.push_back(20.93); - EWPTPerSetting[1].EWMinimum.push_back(538.687); + EWPTPerSetting[1].Tc = 159.082; + EWPTPerSetting[1].vc = 18.8436; + EWPTPerSetting[1].EWMinimum.push_back(-18.8436); + EWPTPerSetting[1].EWMinimum.push_back(538.715); EWPTPerSetting[1].EWMinimum.push_back(0); - EWPTPerSetting[5].Tc = 160.208; - EWPTPerSetting[5].vc = 20.9296; - EWPTPerSetting[5].EWMinimum.push_back(20.9296); - EWPTPerSetting[5].EWMinimum.push_back(538.687); - EWPTPerSetting[5].EWMinimum.push_back(-1.63173e-05); - EWPTPerSetting[2].Tc = 160.181; - EWPTPerSetting[2].vc = 24.2265; - EWPTPerSetting[2].EWMinimum.push_back(-24.2265); - EWPTPerSetting[2].EWMinimum.push_back(-538.689); - EWPTPerSetting[2].EWMinimum.push_back(0); - EWPTPerSetting[6].Tc = 160.181; - EWPTPerSetting[6].vc = 24.2265; - EWPTPerSetting[6].EWMinimum.push_back(-24.2265); - EWPTPerSetting[6].EWMinimum.push_back(-538.689); - EWPTPerSetting[6].EWMinimum.push_back(0); - EWPTPerSetting[3].Tc = 160.181; - EWPTPerSetting[3].vc = 24.2264; - EWPTPerSetting[3].EWMinimum.push_back(24.2264); - EWPTPerSetting[3].EWMinimum.push_back(-538.689); - EWPTPerSetting[3].EWMinimum.push_back(0); - EWPTPerSetting[7].Tc = 160.181; - EWPTPerSetting[7].vc = 24.2264; - EWPTPerSetting[7].EWMinimum.push_back(24.2264); - EWPTPerSetting[7].EWMinimum.push_back(-538.689); - EWPTPerSetting[7].EWMinimum.push_back(1.30964e-05); + EWPTPerSetting[5].Tc = 159.073; + EWPTPerSetting[5].vc = 20.4261; + EWPTPerSetting[5].EWMinimum.push_back(20.4261); + EWPTPerSetting[5].EWMinimum.push_back(538.715); + EWPTPerSetting[5].EWMinimum.push_back(-2.25701e-05); + EWPTPerSetting[2].Tc = 159.055; + EWPTPerSetting[2].vc = 22.4402; + EWPTPerSetting[2].EWMinimum.push_back(22.4402); + EWPTPerSetting[2].EWMinimum.push_back(-538.717); + EWPTPerSetting[2].EWMinimum.push_back(1.26363e-05); + EWPTPerSetting[6].Tc = 159.055; + EWPTPerSetting[6].vc = 22.4402; + EWPTPerSetting[6].EWMinimum.push_back(22.4402); + EWPTPerSetting[6].EWMinimum.push_back(-538.717); + EWPTPerSetting[6].EWMinimum.push_back(1.26363e-05); + EWPTPerSetting[3].Tc = 159.055; + EWPTPerSetting[3].vc = 22.4402; + EWPTPerSetting[3].EWMinimum.push_back(22.4402); + EWPTPerSetting[3].EWMinimum.push_back(-538.717); + EWPTPerSetting[3].EWMinimum.push_back(1.26363e-05); + EWPTPerSetting[7].Tc = 159.055; + EWPTPerSetting[7].vc = 22.4402; + EWPTPerSetting[7].EWMinimum.push_back(22.4402); + EWPTPerSetting[7].EWMinimum.push_back(-538.717); + EWPTPerSetting[7].EWMinimum.push_back(1.26363e-05); CheckTripleTree.at(0).at(0).at(4) = -63.5495; CheckTripleCT.at(0).at(0).at(4) = 5.21565; CheckTripleCW.at(0).at(0).at(4) = -5.21565; diff --git a/tests/GenerateTestCompares/CXSM.h b/tests/GenerateTestCompares/CXSM.h index 802cf67f..d741c06e 100644 --- a/tests/GenerateTestCompares/CXSM.h +++ b/tests/GenerateTestCompares/CXSM.h @@ -1,6 +1,4 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas -// Müller -// +// SPDX-FileCopyrightText: 2021 Philipp Basler // // SPDX-License-Identifier: GPL-3.0-or-later #include diff --git a/tests/GenerateTestCompares/N2HDM.cpp b/tests/GenerateTestCompares/N2HDM.cpp new file mode 100644 index 00000000..7ce5d66a --- /dev/null +++ b/tests/GenerateTestCompares/N2HDM.cpp @@ -0,0 +1,609 @@ +#include "N2HDM.h" +Compare_N2HDM::Compare_N2HDM() +{ + std::size_t NHiggs = 9; + CheckTripleTree = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + CheckTripleCW = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + CheckTripleCT = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + EWPTPerSetting[4].Tc = 300; + EWPTPerSetting[4].vc = 0; + EWPTPerSetting[4].EWMinimum.push_back(0); + EWPTPerSetting[4].EWMinimum.push_back(0); + EWPTPerSetting[4].EWMinimum.push_back(0); + EWPTPerSetting[4].EWMinimum.push_back(0); + EWPTPerSetting[4].EWMinimum.push_back(0); + EWPTPerSetting[1].Tc = 124.42; + EWPTPerSetting[1].vc = 144.396; + EWPTPerSetting[1].EWMinimum.push_back(2.43346e-05); + EWPTPerSetting[1].EWMinimum.push_back(0); + EWPTPerSetting[1].EWMinimum.push_back(26.8306); + EWPTPerSetting[1].EWMinimum.push_back(141.881); + EWPTPerSetting[1].EWMinimum.push_back(298.493); + EWPTPerSetting[5].Tc = 124.411; + EWPTPerSetting[5].vc = 145.323; + EWPTPerSetting[5].EWMinimum.push_back(1.40226e-05); + EWPTPerSetting[5].EWMinimum.push_back(0); + EWPTPerSetting[5].EWMinimum.push_back(26.9905); + EWPTPerSetting[5].EWMinimum.push_back(142.795); + EWPTPerSetting[5].EWMinimum.push_back(298.46); + EWPTPerSetting[2].Tc = 120.218; + EWPTPerSetting[2].vc = 180.081; + EWPTPerSetting[2].EWMinimum.push_back(-0.0001018); + EWPTPerSetting[2].EWMinimum.push_back(-2.31819e-05); + EWPTPerSetting[2].EWMinimum.push_back(-32.5818); + EWPTPerSetting[2].EWMinimum.push_back(-177.109); + EWPTPerSetting[2].EWMinimum.push_back(297.015); + EWPTPerSetting[6].Tc = 120.218; + EWPTPerSetting[6].vc = 180.081; + EWPTPerSetting[6].EWMinimum.push_back(-0.0001018); + EWPTPerSetting[6].EWMinimum.push_back(-2.31819e-05); + EWPTPerSetting[6].EWMinimum.push_back(-32.5818); + EWPTPerSetting[6].EWMinimum.push_back(-177.109); + EWPTPerSetting[6].EWMinimum.push_back(297.015); + EWPTPerSetting[3].Tc = 120.218; + EWPTPerSetting[3].vc = 180.081; + EWPTPerSetting[3].EWMinimum.push_back(-0.0001018); + EWPTPerSetting[3].EWMinimum.push_back(-2.31819e-05); + EWPTPerSetting[3].EWMinimum.push_back(-32.5818); + EWPTPerSetting[3].EWMinimum.push_back(-177.109); + EWPTPerSetting[3].EWMinimum.push_back(297.015); + EWPTPerSetting[7].Tc = 120.218; + EWPTPerSetting[7].vc = 180.081; + EWPTPerSetting[7].EWMinimum.push_back(-0.0001018); + EWPTPerSetting[7].EWMinimum.push_back(-2.31819e-05); + EWPTPerSetting[7].EWMinimum.push_back(-32.5818); + EWPTPerSetting[7].EWMinimum.push_back(-177.109); + EWPTPerSetting[7].EWMinimum.push_back(297.015); + CheckTripleTree.at(0).at(0).at(6) = -63.363; + CheckTripleCT.at(0).at(0).at(6) = 73.3299; + CheckTripleCW.at(0).at(0).at(6) = -73.3299; + CheckTripleTree.at(0).at(0).at(7) = 5.2208; + CheckTripleCT.at(0).at(0).at(7) = -3.26127; + CheckTripleCW.at(0).at(0).at(7) = 3.26127; + CheckTripleTree.at(0).at(0).at(8) = -210.394; + CheckTripleCT.at(0).at(0).at(8) = 50.8122; + CheckTripleCW.at(0).at(0).at(8) = -50.8122; + CheckTripleTree.at(0).at(1).at(4) = 5.41788e-16; + CheckTripleCT.at(0).at(1).at(4) = 1.12952e-16; + CheckTripleCW.at(0).at(1).at(4) = 2.47188e-16; + CheckTripleTree.at(0).at(1).at(5) = -3.90528e-15; + CheckTripleCT.at(0).at(1).at(5) = -2.29222e-17; + CheckTripleCW.at(0).at(1).at(5) = -5.13836e-15; + CheckTripleTree.at(0).at(2).at(6) = 1.02686; + CheckTripleCT.at(0).at(2).at(6) = -0.186289; + CheckTripleCW.at(0).at(2).at(6) = 0.186289; + CheckTripleTree.at(0).at(2).at(7) = -33.9201; + CheckTripleCT.at(0).at(2).at(7) = -1.34287; + CheckTripleCW.at(0).at(2).at(7) = 1.34287; + CheckTripleTree.at(0).at(2).at(8) = 73.114; + CheckTripleCT.at(0).at(2).at(8) = -15.5881; + CheckTripleCW.at(0).at(2).at(8) = 15.5881; + CheckTripleTree.at(0).at(3).at(4) = 1.70102e-14; + CheckTripleCT.at(0).at(3).at(4) = -7.62682e-16; + CheckTripleCW.at(0).at(3).at(4) = -5.75384e-15; + CheckTripleTree.at(0).at(3).at(5) = 979.072; + CheckTripleCT.at(0).at(3).at(5) = 93.3687; + CheckTripleCW.at(0).at(3).at(5) = -93.3687; + CheckTripleTree.at(0).at(4).at(1) = 5.41788e-16; + CheckTripleCT.at(0).at(4).at(1) = 1.12952e-16; + CheckTripleCW.at(0).at(4).at(1) = 2.47188e-16; + CheckTripleTree.at(0).at(4).at(3) = 1.70102e-14; + CheckTripleCT.at(0).at(4).at(3) = -7.62682e-16; + CheckTripleCW.at(0).at(4).at(3) = -5.75384e-15; + CheckTripleTree.at(0).at(5).at(1) = -3.90528e-15; + CheckTripleCT.at(0).at(5).at(1) = -2.29222e-17; + CheckTripleCW.at(0).at(5).at(1) = -5.13836e-15; + CheckTripleTree.at(0).at(5).at(3) = 979.072; + CheckTripleCT.at(0).at(5).at(3) = 93.3687; + CheckTripleCW.at(0).at(5).at(3) = -93.3687; + CheckTripleTree.at(0).at(6).at(0) = -63.363; + CheckTripleCT.at(0).at(6).at(0) = 73.3299; + CheckTripleCW.at(0).at(6).at(0) = -73.3299; + CheckTripleTree.at(0).at(6).at(2) = 1.02686; + CheckTripleCT.at(0).at(6).at(2) = -0.186289; + CheckTripleCW.at(0).at(6).at(2) = 0.186289; + CheckTripleTree.at(0).at(7).at(0) = 5.2208; + CheckTripleCT.at(0).at(7).at(0) = -3.26127; + CheckTripleCW.at(0).at(7).at(0) = 3.26127; + CheckTripleTree.at(0).at(7).at(2) = -33.9201; + CheckTripleCT.at(0).at(7).at(2) = -1.34287; + CheckTripleCW.at(0).at(7).at(2) = 1.34287; + CheckTripleTree.at(0).at(8).at(0) = -210.394; + CheckTripleCT.at(0).at(8).at(0) = 50.8122; + CheckTripleCW.at(0).at(8).at(0) = -50.8122; + CheckTripleTree.at(0).at(8).at(2) = 73.114; + CheckTripleCT.at(0).at(8).at(2) = -15.5881; + CheckTripleCW.at(0).at(8).at(2) = 15.5881; + CheckTripleTree.at(1).at(0).at(4) = -5.41788e-16; + CheckTripleCT.at(1).at(0).at(4) = -1.12952e-16; + CheckTripleCW.at(1).at(0).at(4) = -2.71218e-16; + CheckTripleTree.at(1).at(0).at(5) = 3.90528e-15; + CheckTripleCT.at(1).at(0).at(5) = 2.29222e-17; + CheckTripleCW.at(1).at(0).at(5) = -3.16796e-15; + CheckTripleTree.at(1).at(1).at(6) = -63.363; + CheckTripleCT.at(1).at(1).at(6) = 73.3299; + CheckTripleCW.at(1).at(1).at(6) = -73.3299; + CheckTripleTree.at(1).at(1).at(7) = 5.2208; + CheckTripleCT.at(1).at(1).at(7) = -3.26127; + CheckTripleCW.at(1).at(1).at(7) = 3.26127; + CheckTripleTree.at(1).at(1).at(8) = -210.394; + CheckTripleCT.at(1).at(1).at(8) = 50.8122; + CheckTripleCW.at(1).at(1).at(8) = -50.8122; + CheckTripleTree.at(1).at(2).at(4) = -1.70102e-14; + CheckTripleCT.at(1).at(2).at(4) = 7.62682e-16; + CheckTripleCW.at(1).at(2).at(4) = 5.533e-15; + CheckTripleTree.at(1).at(2).at(5) = -979.072; + CheckTripleCT.at(1).at(2).at(5) = -93.3687; + CheckTripleCW.at(1).at(2).at(5) = 93.3687; + CheckTripleTree.at(1).at(3).at(6) = 1.02686; + CheckTripleCT.at(1).at(3).at(6) = -0.186289; + CheckTripleCW.at(1).at(3).at(6) = 0.186289; + CheckTripleTree.at(1).at(3).at(7) = -33.9201; + CheckTripleCT.at(1).at(3).at(7) = -1.34287; + CheckTripleCW.at(1).at(3).at(7) = 1.34287; + CheckTripleTree.at(1).at(3).at(8) = 73.114; + CheckTripleCT.at(1).at(3).at(8) = -15.5881; + CheckTripleCW.at(1).at(3).at(8) = 15.5881; + CheckTripleTree.at(1).at(4).at(0) = -5.41788e-16; + CheckTripleCT.at(1).at(4).at(0) = -1.12952e-16; + CheckTripleCW.at(1).at(4).at(0) = -2.71218e-16; + CheckTripleTree.at(1).at(4).at(2) = -1.70102e-14; + CheckTripleCT.at(1).at(4).at(2) = 7.62682e-16; + CheckTripleCW.at(1).at(4).at(2) = 5.533e-15; + CheckTripleTree.at(1).at(5).at(0) = 3.90528e-15; + CheckTripleCT.at(1).at(5).at(0) = 2.29222e-17; + CheckTripleCW.at(1).at(5).at(0) = -3.16796e-15; + CheckTripleTree.at(1).at(5).at(2) = -979.072; + CheckTripleCT.at(1).at(5).at(2) = -93.3687; + CheckTripleCW.at(1).at(5).at(2) = 93.3687; + CheckTripleTree.at(1).at(6).at(1) = -63.363; + CheckTripleCT.at(1).at(6).at(1) = 73.3299; + CheckTripleCW.at(1).at(6).at(1) = -73.3299; + CheckTripleTree.at(1).at(6).at(3) = 1.02686; + CheckTripleCT.at(1).at(6).at(3) = -0.186289; + CheckTripleCW.at(1).at(6).at(3) = 0.186289; + CheckTripleTree.at(1).at(7).at(1) = 5.2208; + CheckTripleCT.at(1).at(7).at(1) = -3.26127; + CheckTripleCW.at(1).at(7).at(1) = 3.26127; + CheckTripleTree.at(1).at(7).at(3) = -33.9201; + CheckTripleCT.at(1).at(7).at(3) = -1.34287; + CheckTripleCW.at(1).at(7).at(3) = 1.34287; + CheckTripleTree.at(1).at(8).at(1) = -210.394; + CheckTripleCT.at(1).at(8).at(1) = 50.8122; + CheckTripleCW.at(1).at(8).at(1) = -50.8122; + CheckTripleTree.at(1).at(8).at(3) = 73.114; + CheckTripleCT.at(1).at(8).at(3) = -15.5881; + CheckTripleCW.at(1).at(8).at(3) = 15.5881; + CheckTripleTree.at(2).at(0).at(6) = 1.02686; + CheckTripleCT.at(2).at(0).at(6) = -0.186289; + CheckTripleCW.at(2).at(0).at(6) = 0.186289; + CheckTripleTree.at(2).at(0).at(7) = -33.9201; + CheckTripleCT.at(2).at(0).at(7) = -1.34287; + CheckTripleCW.at(2).at(0).at(7) = 1.34287; + CheckTripleTree.at(2).at(0).at(8) = 73.114; + CheckTripleCT.at(2).at(0).at(8) = -15.5881; + CheckTripleCW.at(2).at(0).at(8) = 15.5881; + CheckTripleTree.at(2).at(1).at(4) = -1.7228e-14; + CheckTripleCT.at(2).at(1).at(4) = 8.09745e-16; + CheckTripleCW.at(2).at(1).at(4) = 5.68631e-15; + CheckTripleTree.at(2).at(1).at(5) = -979.072; + CheckTripleCT.at(2).at(1).at(5) = -93.3687; + CheckTripleCW.at(2).at(1).at(5) = 93.3687; + CheckTripleTree.at(2).at(2).at(6) = 17.1796; + CheckTripleCT.at(2).at(2).at(6) = -137.986; + CheckTripleCW.at(2).at(2).at(6) = -72.4157; + CheckTripleTree.at(2).at(2).at(7) = -2.31824; + CheckTripleCT.at(2).at(2).at(7) = -538.331; + CheckTripleCW.at(2).at(2).at(7) = 3.8593; + CheckTripleTree.at(2).at(2).at(8) = 209.333; + CheckTripleCT.at(2).at(2).at(8) = -38.4073; + CheckTripleCW.at(2).at(2).at(8) = 39.5718; + CheckTripleTree.at(2).at(3).at(4) = -5.41788e-16; + CheckTripleCT.at(2).at(3).at(4) = -1.12952e-16; + CheckTripleCW.at(2).at(3).at(4) = -2.47188e-16; + CheckTripleTree.at(2).at(3).at(5) = 3.90528e-15; + CheckTripleCT.at(2).at(3).at(5) = 2.29222e-17; + CheckTripleCW.at(2).at(3).at(5) = 5.13836e-15; + CheckTripleTree.at(2).at(4).at(1) = -1.7228e-14; + CheckTripleCT.at(2).at(4).at(1) = 8.09745e-16; + CheckTripleCW.at(2).at(4).at(1) = 5.68631e-15; + CheckTripleTree.at(2).at(4).at(3) = -5.41788e-16; + CheckTripleCT.at(2).at(4).at(3) = -1.12952e-16; + CheckTripleCW.at(2).at(4).at(3) = -2.47188e-16; + CheckTripleTree.at(2).at(5).at(1) = -979.072; + CheckTripleCT.at(2).at(5).at(1) = -93.3687; + CheckTripleCW.at(2).at(5).at(1) = 93.3687; + CheckTripleTree.at(2).at(5).at(3) = 3.90528e-15; + CheckTripleCT.at(2).at(5).at(3) = 2.29222e-17; + CheckTripleCW.at(2).at(5).at(3) = 5.13836e-15; + CheckTripleTree.at(2).at(6).at(0) = 1.02686; + CheckTripleCT.at(2).at(6).at(0) = -0.186289; + CheckTripleCW.at(2).at(6).at(0) = 0.186289; + CheckTripleTree.at(2).at(6).at(2) = 17.1796; + CheckTripleCT.at(2).at(6).at(2) = -137.986; + CheckTripleCW.at(2).at(6).at(2) = -72.4157; + CheckTripleTree.at(2).at(7).at(0) = -33.9201; + CheckTripleCT.at(2).at(7).at(0) = -1.34287; + CheckTripleCW.at(2).at(7).at(0) = 1.34287; + CheckTripleTree.at(2).at(7).at(2) = -2.31824; + CheckTripleCT.at(2).at(7).at(2) = -538.331; + CheckTripleCW.at(2).at(7).at(2) = 3.8593; + CheckTripleTree.at(2).at(8).at(0) = 73.114; + CheckTripleCT.at(2).at(8).at(0) = -15.5881; + CheckTripleCW.at(2).at(8).at(0) = 15.5881; + CheckTripleTree.at(2).at(8).at(2) = 209.333; + CheckTripleCT.at(2).at(8).at(2) = -38.4073; + CheckTripleCW.at(2).at(8).at(2) = 39.5718; + CheckTripleTree.at(3).at(0).at(4) = 1.7228e-14; + CheckTripleCT.at(3).at(0).at(4) = -8.09745e-16; + CheckTripleCW.at(3).at(0).at(4) = -7.55334e-15; + CheckTripleTree.at(3).at(0).at(5) = 979.072; + CheckTripleCT.at(3).at(0).at(5) = 93.3687; + CheckTripleCW.at(3).at(0).at(5) = -93.3687; + CheckTripleTree.at(3).at(1).at(6) = 1.02686; + CheckTripleCT.at(3).at(1).at(6) = -0.186289; + CheckTripleCW.at(3).at(1).at(6) = 0.186289; + CheckTripleTree.at(3).at(1).at(7) = -33.9201; + CheckTripleCT.at(3).at(1).at(7) = -1.34287; + CheckTripleCW.at(3).at(1).at(7) = 1.34287; + CheckTripleTree.at(3).at(1).at(8) = 73.114; + CheckTripleCT.at(3).at(1).at(8) = -15.5881; + CheckTripleCW.at(3).at(1).at(8) = 15.5881; + CheckTripleTree.at(3).at(2).at(4) = 5.41788e-16; + CheckTripleCT.at(3).at(2).at(4) = 1.12952e-16; + CheckTripleCW.at(3).at(2).at(4) = 2.71218e-16; + CheckTripleTree.at(3).at(2).at(5) = -3.90528e-15; + CheckTripleCT.at(3).at(2).at(5) = -2.29222e-17; + CheckTripleCW.at(3).at(2).at(5) = 3.16796e-15; + CheckTripleTree.at(3).at(3).at(6) = 17.1796; + CheckTripleCT.at(3).at(3).at(6) = -137.986; + CheckTripleCW.at(3).at(3).at(6) = -72.4157; + CheckTripleTree.at(3).at(3).at(7) = -2.31824; + CheckTripleCT.at(3).at(3).at(7) = -538.331; + CheckTripleCW.at(3).at(3).at(7) = 3.8593; + CheckTripleTree.at(3).at(3).at(8) = 209.333; + CheckTripleCT.at(3).at(3).at(8) = -38.4073; + CheckTripleCW.at(3).at(3).at(8) = 39.5718; + CheckTripleTree.at(3).at(4).at(0) = 1.7228e-14; + CheckTripleCT.at(3).at(4).at(0) = -8.09745e-16; + CheckTripleCW.at(3).at(4).at(0) = -7.55334e-15; + CheckTripleTree.at(3).at(4).at(2) = 5.41788e-16; + CheckTripleCT.at(3).at(4).at(2) = 1.12952e-16; + CheckTripleCW.at(3).at(4).at(2) = 2.71218e-16; + CheckTripleTree.at(3).at(5).at(0) = 979.072; + CheckTripleCT.at(3).at(5).at(0) = 93.3687; + CheckTripleCW.at(3).at(5).at(0) = -93.3687; + CheckTripleTree.at(3).at(5).at(2) = -3.90528e-15; + CheckTripleCT.at(3).at(5).at(2) = -2.29222e-17; + CheckTripleCW.at(3).at(5).at(2) = 3.16796e-15; + CheckTripleTree.at(3).at(6).at(1) = 1.02686; + CheckTripleCT.at(3).at(6).at(1) = -0.186289; + CheckTripleCW.at(3).at(6).at(1) = 0.186289; + CheckTripleTree.at(3).at(6).at(3) = 17.1796; + CheckTripleCT.at(3).at(6).at(3) = -137.986; + CheckTripleCW.at(3).at(6).at(3) = -72.4157; + CheckTripleTree.at(3).at(7).at(1) = -33.9201; + CheckTripleCT.at(3).at(7).at(1) = -1.34287; + CheckTripleCW.at(3).at(7).at(1) = 1.34287; + CheckTripleTree.at(3).at(7).at(3) = -2.31824; + CheckTripleCT.at(3).at(7).at(3) = -538.331; + CheckTripleCW.at(3).at(7).at(3) = 3.8593; + CheckTripleTree.at(3).at(8).at(1) = 73.114; + CheckTripleCT.at(3).at(8).at(1) = -15.5881; + CheckTripleCW.at(3).at(8).at(1) = 15.5881; + CheckTripleTree.at(3).at(8).at(3) = 209.333; + CheckTripleCT.at(3).at(8).at(3) = -38.4073; + CheckTripleCW.at(3).at(8).at(3) = 39.5718; + CheckTripleTree.at(4).at(0).at(1) = 5.41788e-16; + CheckTripleCT.at(4).at(0).at(1) = 1.12952e-16; + CheckTripleCW.at(4).at(0).at(1) = 2.47188e-16; + CheckTripleTree.at(4).at(0).at(3) = 1.70102e-14; + CheckTripleCT.at(4).at(0).at(3) = -7.62682e-16; + CheckTripleCW.at(4).at(0).at(3) = -5.75384e-15; + CheckTripleTree.at(4).at(1).at(0) = -5.41788e-16; + CheckTripleCT.at(4).at(1).at(0) = -1.12952e-16; + CheckTripleCW.at(4).at(1).at(0) = -2.71218e-16; + CheckTripleTree.at(4).at(1).at(2) = -1.70102e-14; + CheckTripleCT.at(4).at(1).at(2) = 7.62682e-16; + CheckTripleCW.at(4).at(1).at(2) = 5.533e-15; + CheckTripleTree.at(4).at(2).at(1) = -2.43334e-14; + CheckTripleCT.at(4).at(2).at(1) = 9.76279e-16; + CheckTripleCW.at(4).at(2).at(1) = 5.74182e-15; + CheckTripleTree.at(4).at(2).at(3) = -5.41788e-16; + CheckTripleCT.at(4).at(2).at(3) = -1.12952e-16; + CheckTripleCW.at(4).at(2).at(3) = -2.47188e-16; + CheckTripleTree.at(4).at(3).at(0) = 2.43334e-14; + CheckTripleCT.at(4).at(3).at(0) = -9.76279e-16; + CheckTripleCW.at(4).at(3).at(0) = -7.71988e-15; + CheckTripleTree.at(4).at(3).at(2) = 5.41788e-16; + CheckTripleCT.at(4).at(3).at(2) = 1.12952e-16; + CheckTripleCW.at(4).at(3).at(2) = 2.71218e-16; + CheckTripleTree.at(4).at(4).at(6) = -63.363; + CheckTripleCT.at(4).at(4).at(6) = 73.3299; + CheckTripleCW.at(4).at(4).at(6) = -73.3299; + CheckTripleTree.at(4).at(4).at(7) = 5.2208; + CheckTripleCT.at(4).at(4).at(7) = -3.26127; + CheckTripleCW.at(4).at(4).at(7) = 3.26127; + CheckTripleTree.at(4).at(4).at(8) = -210.394; + CheckTripleCT.at(4).at(4).at(8) = 50.8122; + CheckTripleCW.at(4).at(4).at(8) = -50.8122; + CheckTripleTree.at(4).at(5).at(6) = 44.9668; + CheckTripleCT.at(4).at(5).at(6) = 4.00402; + CheckTripleCW.at(4).at(5).at(6) = -4.00402; + CheckTripleTree.at(4).at(5).at(7) = 943.914; + CheckTripleCT.at(4).at(5).at(7) = 91.9078; + CheckTripleCW.at(4).at(5).at(7) = -91.9078; + CheckTripleTree.at(4).at(5).at(8) = 50.9425; + CheckTripleCT.at(4).at(5).at(8) = -17.7025; + CheckTripleCW.at(4).at(5).at(8) = 17.7025; + CheckTripleTree.at(4).at(6).at(4) = -63.363; + CheckTripleCT.at(4).at(6).at(4) = 73.3299; + CheckTripleCW.at(4).at(6).at(4) = -73.3299; + CheckTripleTree.at(4).at(6).at(5) = 44.9668; + CheckTripleCT.at(4).at(6).at(5) = 4.00402; + CheckTripleCW.at(4).at(6).at(5) = -4.00402; + CheckTripleTree.at(4).at(7).at(4) = 5.2208; + CheckTripleCT.at(4).at(7).at(4) = -3.26127; + CheckTripleCW.at(4).at(7).at(4) = 3.26127; + CheckTripleTree.at(4).at(7).at(5) = 943.914; + CheckTripleCT.at(4).at(7).at(5) = 91.9078; + CheckTripleCW.at(4).at(7).at(5) = -91.9078; + CheckTripleTree.at(4).at(8).at(4) = -210.394; + CheckTripleCT.at(4).at(8).at(4) = 50.8122; + CheckTripleCW.at(4).at(8).at(4) = -50.8122; + CheckTripleTree.at(4).at(8).at(5) = 50.9425; + CheckTripleCT.at(4).at(8).at(5) = -17.7025; + CheckTripleCW.at(4).at(8).at(5) = 17.7025; + CheckTripleTree.at(5).at(0).at(1) = 3.20015e-15; + CheckTripleCT.at(5).at(0).at(1) = -1.89456e-16; + CheckTripleCW.at(5).at(0).at(1) = -5.47143e-15; + CheckTripleTree.at(5).at(0).at(3) = 979.072; + CheckTripleCT.at(5).at(0).at(3) = 93.3687; + CheckTripleCW.at(5).at(0).at(3) = -93.3687; + CheckTripleTree.at(5).at(1).at(0) = -3.20015e-15; + CheckTripleCT.at(5).at(1).at(0) = 1.89456e-16; + CheckTripleCW.at(5).at(1).at(0) = -2.89041e-15; + CheckTripleTree.at(5).at(1).at(2) = -979.072; + CheckTripleCT.at(5).at(1).at(2) = -93.3687; + CheckTripleCW.at(5).at(1).at(2) = 93.3687; + CheckTripleTree.at(5).at(2).at(1) = -979.072; + CheckTripleCT.at(5).at(2).at(1) = -93.3687; + CheckTripleCW.at(5).at(2).at(1) = 93.3687; + CheckTripleTree.at(5).at(2).at(3) = -3.20015e-15; + CheckTripleCT.at(5).at(2).at(3) = 1.89456e-16; + CheckTripleCW.at(5).at(2).at(3) = 5.47143e-15; + CheckTripleTree.at(5).at(3).at(0) = 979.072; + CheckTripleCT.at(5).at(3).at(0) = 93.3687; + CheckTripleCW.at(5).at(3).at(0) = -93.3687; + CheckTripleTree.at(5).at(3).at(2) = 3.20015e-15; + CheckTripleCT.at(5).at(3).at(2) = -1.89456e-16; + CheckTripleCW.at(5).at(3).at(2) = 2.89041e-15; + CheckTripleTree.at(5).at(4).at(6) = 44.9668; + CheckTripleCT.at(5).at(4).at(6) = 4.00402; + CheckTripleCW.at(5).at(4).at(6) = -4.00402; + CheckTripleTree.at(5).at(4).at(7) = 943.914; + CheckTripleCT.at(5).at(4).at(7) = 91.9078; + CheckTripleCW.at(5).at(4).at(7) = -91.9078; + CheckTripleTree.at(5).at(4).at(8) = 50.9425; + CheckTripleCT.at(5).at(4).at(8) = -17.7025; + CheckTripleCW.at(5).at(4).at(8) = 17.7025; + CheckTripleTree.at(5).at(5).at(6) = -1935.17; + CheckTripleCT.at(5).at(5).at(6) = -324.171; + CheckTripleCW.at(5).at(5).at(6) = 60.2999; + CheckTripleTree.at(5).at(5).at(7) = 82.5947; + CheckTripleCT.at(5).at(5).at(7) = -530.233; + CheckTripleCW.at(5).at(5).at(7) = -8.50806; + CheckTripleTree.at(5).at(5).at(8) = 85.0571; + CheckTripleCT.at(5).at(5).at(8) = -50.2588; + CheckTripleCW.at(5).at(5).at(8) = 497.175; + CheckTripleTree.at(5).at(6).at(4) = 44.9668; + CheckTripleCT.at(5).at(6).at(4) = 4.00402; + CheckTripleCW.at(5).at(6).at(4) = -4.00402; + CheckTripleTree.at(5).at(6).at(5) = -1935.17; + CheckTripleCT.at(5).at(6).at(5) = -324.171; + CheckTripleCW.at(5).at(6).at(5) = 60.2999; + CheckTripleTree.at(5).at(7).at(4) = 943.914; + CheckTripleCT.at(5).at(7).at(4) = 91.9078; + CheckTripleCW.at(5).at(7).at(4) = -91.9078; + CheckTripleTree.at(5).at(7).at(5) = 82.5947; + CheckTripleCT.at(5).at(7).at(5) = -530.233; + CheckTripleCW.at(5).at(7).at(5) = -8.50806; + CheckTripleTree.at(5).at(8).at(4) = 50.9425; + CheckTripleCT.at(5).at(8).at(4) = -17.7025; + CheckTripleCW.at(5).at(8).at(4) = 17.7025; + CheckTripleTree.at(5).at(8).at(5) = 85.0571; + CheckTripleCT.at(5).at(8).at(5) = -50.2588; + CheckTripleCW.at(5).at(8).at(5) = 497.175; + CheckTripleTree.at(6).at(0).at(0) = -63.363; + CheckTripleCT.at(6).at(0).at(0) = 73.3299; + CheckTripleCW.at(6).at(0).at(0) = -73.3299; + CheckTripleTree.at(6).at(0).at(2) = 1.02686; + CheckTripleCT.at(6).at(0).at(2) = -0.186289; + CheckTripleCW.at(6).at(0).at(2) = 0.186289; + CheckTripleTree.at(6).at(1).at(1) = -63.363; + CheckTripleCT.at(6).at(1).at(1) = 73.3299; + CheckTripleCW.at(6).at(1).at(1) = -73.3299; + CheckTripleTree.at(6).at(1).at(3) = 1.02686; + CheckTripleCT.at(6).at(1).at(3) = -0.186289; + CheckTripleCW.at(6).at(1).at(3) = 0.186289; + CheckTripleTree.at(6).at(2).at(0) = 1.02686; + CheckTripleCT.at(6).at(2).at(0) = -0.186289; + CheckTripleCW.at(6).at(2).at(0) = 0.186289; + CheckTripleTree.at(6).at(2).at(2) = 17.1796; + CheckTripleCT.at(6).at(2).at(2) = -137.986; + CheckTripleCW.at(6).at(2).at(2) = -72.4157; + CheckTripleTree.at(6).at(3).at(1) = 1.02686; + CheckTripleCT.at(6).at(3).at(1) = -0.186289; + CheckTripleCW.at(6).at(3).at(1) = 0.186289; + CheckTripleTree.at(6).at(3).at(3) = 17.1796; + CheckTripleCT.at(6).at(3).at(3) = -137.986; + CheckTripleCW.at(6).at(3).at(3) = -72.4157; + CheckTripleTree.at(6).at(4).at(4) = -63.363; + CheckTripleCT.at(6).at(4).at(4) = 73.3299; + CheckTripleCW.at(6).at(4).at(4) = -73.3299; + CheckTripleTree.at(6).at(4).at(5) = 44.9668; + CheckTripleCT.at(6).at(4).at(5) = 4.00402; + CheckTripleCW.at(6).at(4).at(5) = -4.00402; + CheckTripleTree.at(6).at(5).at(4) = 44.9668; + CheckTripleCT.at(6).at(5).at(4) = 4.00402; + CheckTripleCW.at(6).at(5).at(4) = -4.00402; + CheckTripleTree.at(6).at(5).at(5) = -1935.17; + CheckTripleCT.at(6).at(5).at(5) = -324.171; + CheckTripleCW.at(6).at(5).at(5) = 60.2999; + CheckTripleTree.at(6).at(6).at(6) = -188.547; + CheckTripleCT.at(6).at(6).at(6) = 216.835; + CheckTripleCW.at(6).at(6).at(6) = -290.182; + CheckTripleTree.at(6).at(6).at(7) = 11.1893; + CheckTripleCT.at(6).at(6).at(7) = -23.129; + CheckTripleCW.at(6).at(6).at(7) = 3.31125; + CheckTripleTree.at(6).at(6).at(8) = -221.518; + CheckTripleCT.at(6).at(6).at(8) = 76.5066; + CheckTripleCW.at(6).at(6).at(8) = -76.498; + CheckTripleTree.at(6).at(7).at(6) = 11.1893; + CheckTripleCT.at(6).at(7).at(6) = -23.129; + CheckTripleCW.at(6).at(7).at(6) = 3.31125; + CheckTripleTree.at(6).at(7).at(7) = -51.1429; + CheckTripleCT.at(6).at(7).at(7) = -188.292; + CheckTripleCW.at(6).at(7).at(7) = -65.9015; + CheckTripleTree.at(6).at(7).at(8) = 96.6509; + CheckTripleCT.at(6).at(7).at(8) = -23.4745; + CheckTripleCW.at(6).at(7).at(8) = 26.6894; + CheckTripleTree.at(6).at(8).at(6) = -221.518; + CheckTripleCT.at(6).at(8).at(6) = 76.5066; + CheckTripleCW.at(6).at(8).at(6) = -76.498; + CheckTripleTree.at(6).at(8).at(7) = 96.6509; + CheckTripleCT.at(6).at(8).at(7) = -23.4745; + CheckTripleCW.at(6).at(8).at(7) = 26.6894; + CheckTripleTree.at(6).at(8).at(8) = 319.197; + CheckTripleCT.at(6).at(8).at(8) = -316.801; + CheckTripleCW.at(6).at(8).at(8) = 405.982; + CheckTripleTree.at(7).at(0).at(0) = 5.2208; + CheckTripleCT.at(7).at(0).at(0) = -3.26127; + CheckTripleCW.at(7).at(0).at(0) = 3.26127; + CheckTripleTree.at(7).at(0).at(2) = -33.9201; + CheckTripleCT.at(7).at(0).at(2) = -1.34287; + CheckTripleCW.at(7).at(0).at(2) = 1.34287; + CheckTripleTree.at(7).at(1).at(1) = 5.2208; + CheckTripleCT.at(7).at(1).at(1) = -3.26127; + CheckTripleCW.at(7).at(1).at(1) = 3.26127; + CheckTripleTree.at(7).at(1).at(3) = -33.9201; + CheckTripleCT.at(7).at(1).at(3) = -1.34287; + CheckTripleCW.at(7).at(1).at(3) = 1.34287; + CheckTripleTree.at(7).at(2).at(0) = -33.9201; + CheckTripleCT.at(7).at(2).at(0) = -1.34287; + CheckTripleCW.at(7).at(2).at(0) = 1.34287; + CheckTripleTree.at(7).at(2).at(2) = -2.31824; + CheckTripleCT.at(7).at(2).at(2) = -538.331; + CheckTripleCW.at(7).at(2).at(2) = 3.8593; + CheckTripleTree.at(7).at(3).at(1) = -33.9201; + CheckTripleCT.at(7).at(3).at(1) = -1.34287; + CheckTripleCW.at(7).at(3).at(1) = 1.34287; + CheckTripleTree.at(7).at(3).at(3) = -2.31824; + CheckTripleCT.at(7).at(3).at(3) = -538.331; + CheckTripleCW.at(7).at(3).at(3) = 3.8593; + CheckTripleTree.at(7).at(4).at(4) = 5.2208; + CheckTripleCT.at(7).at(4).at(4) = -3.26127; + CheckTripleCW.at(7).at(4).at(4) = 3.26127; + CheckTripleTree.at(7).at(4).at(5) = 943.914; + CheckTripleCT.at(7).at(4).at(5) = 91.9078; + CheckTripleCW.at(7).at(4).at(5) = -91.9078; + CheckTripleTree.at(7).at(5).at(4) = 943.914; + CheckTripleCT.at(7).at(5).at(4) = 91.9078; + CheckTripleCW.at(7).at(5).at(4) = -91.9078; + CheckTripleTree.at(7).at(5).at(5) = 82.5947; + CheckTripleCT.at(7).at(5).at(5) = -530.233; + CheckTripleCW.at(7).at(5).at(5) = -8.50806; + CheckTripleTree.at(7).at(6).at(6) = 11.1893; + CheckTripleCT.at(7).at(6).at(6) = -23.129; + CheckTripleCW.at(7).at(6).at(6) = 3.31125; + CheckTripleTree.at(7).at(6).at(7) = -51.1429; + CheckTripleCT.at(7).at(6).at(7) = -188.292; + CheckTripleCW.at(7).at(6).at(7) = -65.9015; + CheckTripleTree.at(7).at(6).at(8) = 96.6509; + CheckTripleCT.at(7).at(6).at(8) = -23.4745; + CheckTripleCW.at(7).at(6).at(8) = 26.6894; + CheckTripleTree.at(7).at(7).at(6) = -51.1429; + CheckTripleCT.at(7).at(7).at(6) = -188.292; + CheckTripleCW.at(7).at(7).at(6) = -65.9015; + CheckTripleTree.at(7).at(7).at(7) = 1.90163; + CheckTripleCT.at(7).at(7).at(7) = -1610.51; + CheckTripleCW.at(7).at(7).at(7) = 10.5816; + CheckTripleTree.at(7).at(7).at(8) = 195.857; + CheckTripleCT.at(7).at(7).at(8) = -9.66018; + CheckTripleCW.at(7).at(7).at(8) = 35.3349; + CheckTripleTree.at(7).at(8).at(6) = 96.6509; + CheckTripleCT.at(7).at(8).at(6) = -23.4745; + CheckTripleCW.at(7).at(8).at(6) = 26.6894; + CheckTripleTree.at(7).at(8).at(7) = 195.857; + CheckTripleCT.at(7).at(8).at(7) = -9.66018; + CheckTripleCW.at(7).at(8).at(7) = 35.3349; + CheckTripleTree.at(7).at(8).at(8) = -142.349; + CheckTripleCT.at(7).at(8).at(8) = 131.967; + CheckTripleCW.at(7).at(8).at(8) = -172.595; + CheckTripleTree.at(8).at(0).at(0) = -210.394; + CheckTripleCT.at(8).at(0).at(0) = 50.8122; + CheckTripleCW.at(8).at(0).at(0) = -50.8122; + CheckTripleTree.at(8).at(0).at(2) = 73.114; + CheckTripleCT.at(8).at(0).at(2) = -15.5881; + CheckTripleCW.at(8).at(0).at(2) = 15.5881; + CheckTripleTree.at(8).at(1).at(1) = -210.394; + CheckTripleCT.at(8).at(1).at(1) = 50.8122; + CheckTripleCW.at(8).at(1).at(1) = -50.8122; + CheckTripleTree.at(8).at(1).at(3) = 73.114; + CheckTripleCT.at(8).at(1).at(3) = -15.5881; + CheckTripleCW.at(8).at(1).at(3) = 15.5881; + CheckTripleTree.at(8).at(2).at(0) = 73.114; + CheckTripleCT.at(8).at(2).at(0) = -15.5881; + CheckTripleCW.at(8).at(2).at(0) = 15.5881; + CheckTripleTree.at(8).at(2).at(2) = 209.333; + CheckTripleCT.at(8).at(2).at(2) = -38.4073; + CheckTripleCW.at(8).at(2).at(2) = 39.5718; + CheckTripleTree.at(8).at(3).at(1) = 73.114; + CheckTripleCT.at(8).at(3).at(1) = -15.5881; + CheckTripleCW.at(8).at(3).at(1) = 15.5881; + CheckTripleTree.at(8).at(3).at(3) = 209.333; + CheckTripleCT.at(8).at(3).at(3) = -38.4073; + CheckTripleCW.at(8).at(3).at(3) = 39.5718; + CheckTripleTree.at(8).at(4).at(4) = -210.394; + CheckTripleCT.at(8).at(4).at(4) = 50.8122; + CheckTripleCW.at(8).at(4).at(4) = -50.8122; + CheckTripleTree.at(8).at(4).at(5) = 50.9425; + CheckTripleCT.at(8).at(4).at(5) = -17.7025; + CheckTripleCW.at(8).at(4).at(5) = 17.7025; + CheckTripleTree.at(8).at(5).at(4) = 50.9425; + CheckTripleCT.at(8).at(5).at(4) = -17.7025; + CheckTripleCW.at(8).at(5).at(4) = 17.7025; + CheckTripleTree.at(8).at(5).at(5) = 85.0571; + CheckTripleCT.at(8).at(5).at(5) = -50.2588; + CheckTripleCW.at(8).at(5).at(5) = 497.175; + CheckTripleTree.at(8).at(6).at(6) = -221.518; + CheckTripleCT.at(8).at(6).at(6) = 76.5066; + CheckTripleCW.at(8).at(6).at(6) = -76.498; + CheckTripleTree.at(8).at(6).at(7) = 96.6509; + CheckTripleCT.at(8).at(6).at(7) = -23.4745; + CheckTripleCW.at(8).at(6).at(7) = 26.6894; + CheckTripleTree.at(8).at(6).at(8) = 319.197; + CheckTripleCT.at(8).at(6).at(8) = -316.801; + CheckTripleCW.at(8).at(6).at(8) = 405.982; + CheckTripleTree.at(8).at(7).at(6) = 96.6509; + CheckTripleCT.at(8).at(7).at(6) = -23.4745; + CheckTripleCW.at(8).at(7).at(6) = 26.6894; + CheckTripleTree.at(8).at(7).at(7) = 195.857; + CheckTripleCT.at(8).at(7).at(7) = -9.66018; + CheckTripleCW.at(8).at(7).at(7) = 35.3349; + CheckTripleTree.at(8).at(7).at(8) = -142.349; + CheckTripleCT.at(8).at(7).at(8) = 131.967; + CheckTripleCW.at(8).at(7).at(8) = -172.595; + CheckTripleTree.at(8).at(8).at(6) = 319.197; + CheckTripleCT.at(8).at(8).at(6) = -316.801; + CheckTripleCW.at(8).at(8).at(6) = 405.982; + CheckTripleTree.at(8).at(8).at(7) = -142.349; + CheckTripleCT.at(8).at(8).at(7) = 131.967; + CheckTripleCW.at(8).at(8).at(7) = -172.595; + CheckTripleTree.at(8).at(8).at(8) = -8302.35; + CheckTripleCT.at(8).at(8).at(8) = 5790.5; + CheckTripleCW.at(8).at(8).at(8) = -8021.66; +} diff --git a/tests/GenerateTestCompares/N2HDM.h b/tests/GenerateTestCompares/N2HDM.h new file mode 100644 index 00000000..b6084a86 --- /dev/null +++ b/tests/GenerateTestCompares/N2HDM.h @@ -0,0 +1,14 @@ +#include +#include +#include +class Compare_N2HDM +{ +public: + using Matrix3D = std::vector>>; + using Matrix2D = std::vector>; + Compare_N2HDM(); + Matrix3D CheckTripleCT; + Matrix3D CheckTripleCW; + Matrix3D CheckTripleTree; + std::map EWPTPerSetting; +}; diff --git a/tests/GenerateTestCompares/R2HDM.cpp b/tests/GenerateTestCompares/R2HDM.cpp index 0a5eb192..a6f45e56 100644 --- a/tests/GenerateTestCompares/R2HDM.cpp +++ b/tests/GenerateTestCompares/R2HDM.cpp @@ -1,412 +1,437 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// -// SPDX-License-Identifier: GPL-3.0-or-later - -#include "R2HDM.h" +#include "R2HDM.h" Compare_R2HDM::Compare_R2HDM() { std::size_t NHiggs = 8; - CheckTripleTree = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - CheckTripleCW = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - CheckTripleCT = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - EWPTPerSetting[4].Tc = 108.838; - EWPTPerSetting[4].vc = 238.589; + CheckTripleTree = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + CheckTripleCW = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + CheckTripleCT = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + EWPTPerSetting[4].Tc = 108.353; + EWPTPerSetting[4].vc = 237.422; EWPTPerSetting[4].EWMinimum.push_back(0); - EWPTPerSetting[4].EWMinimum.push_back(-54.1076); - EWPTPerSetting[4].EWMinimum.push_back(-232.373); + EWPTPerSetting[4].EWMinimum.push_back(53.8028); + EWPTPerSetting[4].EWMinimum.push_back(231.245); EWPTPerSetting[4].EWMinimum.push_back(0); - EWPTPerSetting[1].Tc = 155.283; - EWPTPerSetting[1].vc = 190.738; + EWPTPerSetting[1].Tc = 152.673; + EWPTPerSetting[1].vc = 191.514; EWPTPerSetting[1].EWMinimum.push_back(0); - EWPTPerSetting[1].EWMinimum.push_back(54.2467); - EWPTPerSetting[1].EWMinimum.push_back(182.861); + EWPTPerSetting[1].EWMinimum.push_back(53.5655); + EWPTPerSetting[1].EWMinimum.push_back(183.871); EWPTPerSetting[1].EWMinimum.push_back(0); - EWPTPerSetting[5].Tc = 155.283; - EWPTPerSetting[5].vc = 190.738; + EWPTPerSetting[5].Tc = 152.673; + EWPTPerSetting[5].vc = 191.514; + EWPTPerSetting[5].EWMinimum.push_back(-1.36966e-05); + EWPTPerSetting[5].EWMinimum.push_back(53.5655); + EWPTPerSetting[5].EWMinimum.push_back(183.871); EWPTPerSetting[5].EWMinimum.push_back(0); - EWPTPerSetting[5].EWMinimum.push_back(54.2467); - EWPTPerSetting[5].EWMinimum.push_back(182.861); - EWPTPerSetting[5].EWMinimum.push_back(1.81177e-05); - EWPTPerSetting[2].Tc = 155.283; - EWPTPerSetting[2].vc = 190.738; - EWPTPerSetting[2].EWMinimum.push_back(1.66586e-05); - EWPTPerSetting[2].EWMinimum.push_back(-54.2468); - EWPTPerSetting[2].EWMinimum.push_back(-182.861); + EWPTPerSetting[2].Tc = 152.673; + EWPTPerSetting[2].vc = 191.514; EWPTPerSetting[2].EWMinimum.push_back(0); - EWPTPerSetting[6].Tc = 155.283; - EWPTPerSetting[6].vc = 190.738; - EWPTPerSetting[6].EWMinimum.push_back(2.05901e-05); - EWPTPerSetting[6].EWMinimum.push_back(54.2467); - EWPTPerSetting[6].EWMinimum.push_back(182.861); - EWPTPerSetting[6].EWMinimum.push_back(-1.29244e-05); - EWPTPerSetting[3].Tc = 155.283; - EWPTPerSetting[3].vc = 190.738; + EWPTPerSetting[2].EWMinimum.push_back(-53.5655); + EWPTPerSetting[2].EWMinimum.push_back(-183.871); + EWPTPerSetting[2].EWMinimum.push_back(0); + EWPTPerSetting[6].Tc = 152.673; + EWPTPerSetting[6].vc = 191.514; + EWPTPerSetting[6].EWMinimum.push_back(0); + EWPTPerSetting[6].EWMinimum.push_back(-53.5655); + EWPTPerSetting[6].EWMinimum.push_back(-183.871); + EWPTPerSetting[6].EWMinimum.push_back(4.30435e-05); + EWPTPerSetting[3].Tc = 152.673; + EWPTPerSetting[3].vc = 191.514; EWPTPerSetting[3].EWMinimum.push_back(0); - EWPTPerSetting[3].EWMinimum.push_back(54.2467); - EWPTPerSetting[3].EWMinimum.push_back(182.861); + EWPTPerSetting[3].EWMinimum.push_back(53.5655); + EWPTPerSetting[3].EWMinimum.push_back(183.871); EWPTPerSetting[3].EWMinimum.push_back(0); - EWPTPerSetting[7].Tc = 155.283; - EWPTPerSetting[7].vc = 190.738; + EWPTPerSetting[7].Tc = 152.673; + EWPTPerSetting[7].vc = 191.514; EWPTPerSetting[7].EWMinimum.push_back(0); - EWPTPerSetting[7].EWMinimum.push_back(54.2467); - EWPTPerSetting[7].EWMinimum.push_back(182.861); + EWPTPerSetting[7].EWMinimum.push_back(53.5656); + EWPTPerSetting[7].EWMinimum.push_back(183.871); EWPTPerSetting[7].EWMinimum.push_back(0); CheckTripleTree.at(0).at(0).at(6) = -61.4198; - CheckTripleCT.at(0).at(0).at(6) = 77.8048; - CheckTripleCW.at(0).at(0).at(6) = -77.8048; + CheckTripleCT.at(0).at(0).at(6) = 77.8048; + CheckTripleCW.at(0).at(0).at(6) = -77.8048; CheckTripleTree.at(0).at(0).at(7) = 45.1709; - CheckTripleCT.at(0).at(0).at(7) = -24.2999; - CheckTripleCW.at(0).at(0).at(7) = 24.2999; - CheckTripleTree.at(0).at(1).at(5) = -2.22045e-16; - CheckTripleCT.at(0).at(1).at(5) = 1.38778e-17; - CheckTripleCW.at(0).at(1).at(5) = 3.1225e-17; + CheckTripleCT.at(0).at(0).at(7) = -24.2999; + CheckTripleCW.at(0).at(0).at(7) = 24.2999; + CheckTripleTree.at(0).at(1).at(4) = -3.63589e-17; + CheckTripleCT.at(0).at(1).at(4) = 1.3236e-17; + CheckTripleCW.at(0).at(1).at(4) = -2.03308e-17; + CheckTripleTree.at(0).at(1).at(5) = 6.79617e-16; + CheckTripleCT.at(0).at(1).at(5) = 4.16433e-17; + CheckTripleCW.at(0).at(1).at(5) = -9.26402e-17; CheckTripleTree.at(0).at(2).at(6) = -174.929; - CheckTripleCT.at(0).at(2).at(6) = 5.08295; - CheckTripleCW.at(0).at(2).at(6) = -5.08295; + CheckTripleCT.at(0).at(2).at(6) = 5.08295; + CheckTripleCW.at(0).at(2).at(6) = -5.08295; CheckTripleTree.at(0).at(2).at(7) = -549.757; - CheckTripleCT.at(0).at(2).at(7) = 5.48284; - CheckTripleCW.at(0).at(2).at(7) = -5.48284; - CheckTripleCW.at(0).at(3).at(4) = -1.11022e-16; + CheckTripleCT.at(0).at(2).at(7) = 5.48284; + CheckTripleCW.at(0).at(2).at(7) = -5.48284; + CheckTripleTree.at(0).at(3).at(4) = -1.40746e-15; + CheckTripleCT.at(0).at(3).at(4) = 2.99276e-17; + CheckTripleCW.at(0).at(3).at(4) = 1.52267e-16; CheckTripleTree.at(0).at(3).at(5) = 44.255; - CheckTripleCT.at(0).at(3).at(5) = -3.27917; - CheckTripleCW.at(0).at(3).at(5) = 3.27917; - CheckTripleTree.at(0).at(4).at(1) = -4.44089e-16; - CheckTripleCT.at(0).at(4).at(1) = 2.77556e-17; - CheckTripleCW.at(0).at(4).at(1) = -2.77556e-17; - CheckTripleCW.at(0).at(4).at(3) = -1.11022e-16; - CheckTripleTree.at(0).at(5).at(1) = -2.22045e-16; - CheckTripleCT.at(0).at(5).at(1) = 1.38778e-17; - CheckTripleCW.at(0).at(5).at(1) = 3.1225e-17; + CheckTripleCT.at(0).at(3).at(5) = -3.27917; + CheckTripleCW.at(0).at(3).at(5) = 3.27917; + CheckTripleTree.at(0).at(4).at(1) = -4.80448e-16; + CheckTripleCT.at(0).at(4).at(1) = 4.09916e-17; + CheckTripleCW.at(0).at(4).at(1) = -4.80863e-17; + CheckTripleTree.at(0).at(4).at(3) = 3.68894e-16; + CheckTripleCT.at(0).at(4).at(3) = 2.99276e-17; + CheckTripleCW.at(0).at(4).at(3) = 1.52267e-16; + CheckTripleTree.at(0).at(5).at(1) = 6.79617e-16; + CheckTripleCT.at(0).at(5).at(1) = 4.16433e-17; + CheckTripleCW.at(0).at(5).at(1) = -9.26402e-17; CheckTripleTree.at(0).at(5).at(3) = 44.255; - CheckTripleCT.at(0).at(5).at(3) = -3.27917; - CheckTripleCW.at(0).at(5).at(3) = 3.27917; + CheckTripleCT.at(0).at(5).at(3) = -3.27917; + CheckTripleCW.at(0).at(5).at(3) = 3.27917; CheckTripleTree.at(0).at(6).at(0) = -61.4198; - CheckTripleCT.at(0).at(6).at(0) = 77.8048; - CheckTripleCW.at(0).at(6).at(0) = -77.8048; + CheckTripleCT.at(0).at(6).at(0) = 77.8048; + CheckTripleCW.at(0).at(6).at(0) = -77.8048; CheckTripleTree.at(0).at(6).at(2) = -174.929; - CheckTripleCT.at(0).at(6).at(2) = 5.08295; - CheckTripleCW.at(0).at(6).at(2) = -5.08295; + CheckTripleCT.at(0).at(6).at(2) = 5.08295; + CheckTripleCW.at(0).at(6).at(2) = -5.08295; CheckTripleTree.at(0).at(7).at(0) = 45.1709; - CheckTripleCT.at(0).at(7).at(0) = -24.2999; - CheckTripleCW.at(0).at(7).at(0) = 24.2999; + CheckTripleCT.at(0).at(7).at(0) = -24.2999; + CheckTripleCW.at(0).at(7).at(0) = 24.2999; CheckTripleTree.at(0).at(7).at(2) = -549.757; - CheckTripleCT.at(0).at(7).at(2) = 5.48284; - CheckTripleCW.at(0).at(7).at(2) = -5.48284; - CheckTripleTree.at(1).at(0).at(5) = 2.22045e-16; - CheckTripleCT.at(1).at(0).at(5) = -1.38778e-17; - CheckTripleCW.at(1).at(0).at(5) = -3.1225e-17; + CheckTripleCT.at(0).at(7).at(2) = 5.48284; + CheckTripleCW.at(0).at(7).at(2) = -5.48284; + CheckTripleTree.at(1).at(0).at(4) = 3.63589e-17; + CheckTripleCT.at(1).at(0).at(4) = -1.3236e-17; + CheckTripleCW.at(1).at(0).at(4) = -2.44329e-17; + CheckTripleTree.at(1).at(0).at(5) = -6.79617e-16; + CheckTripleCT.at(1).at(0).at(5) = -4.16433e-17; + CheckTripleCW.at(1).at(0).at(5) = -2.08456e-16; CheckTripleTree.at(1).at(1).at(6) = -61.4198; - CheckTripleCT.at(1).at(1).at(6) = 77.8048; - CheckTripleCW.at(1).at(1).at(6) = -77.8048; + CheckTripleCT.at(1).at(1).at(6) = 77.8048; + CheckTripleCW.at(1).at(1).at(6) = -77.8048; CheckTripleTree.at(1).at(1).at(7) = 45.1709; - CheckTripleCT.at(1).at(1).at(7) = -24.2999; - CheckTripleCW.at(1).at(1).at(7) = 24.2999; - CheckTripleCW.at(1).at(2).at(4) = 1.11022e-16; + CheckTripleCT.at(1).at(1).at(7) = -24.2999; + CheckTripleCW.at(1).at(1).at(7) = 24.2999; + CheckTripleTree.at(1).at(2).at(4) = 1.40746e-15; + CheckTripleCT.at(1).at(2).at(4) = -2.99276e-17; + CheckTripleCW.at(1).at(2).at(4) = -2.48628e-16; CheckTripleTree.at(1).at(2).at(5) = -44.255; - CheckTripleCT.at(1).at(2).at(5) = 3.27917; - CheckTripleCW.at(1).at(2).at(5) = -3.27917; + CheckTripleCT.at(1).at(2).at(5) = 3.27917; + CheckTripleCW.at(1).at(2).at(5) = -3.27917; CheckTripleTree.at(1).at(3).at(6) = -174.929; - CheckTripleCT.at(1).at(3).at(6) = 5.08295; - CheckTripleCW.at(1).at(3).at(6) = -5.08295; + CheckTripleCT.at(1).at(3).at(6) = 5.08295; + CheckTripleCW.at(1).at(3).at(6) = -5.08295; CheckTripleTree.at(1).at(3).at(7) = -549.757; - CheckTripleCT.at(1).at(3).at(7) = 5.48284; - CheckTripleCW.at(1).at(3).at(7) = -5.48284; - CheckTripleTree.at(1).at(4).at(0) = 4.44089e-16; - CheckTripleCT.at(1).at(4).at(0) = -2.77556e-17; - CheckTripleCW.at(1).at(4).at(0) = 2.77556e-17; - CheckTripleCW.at(1).at(4).at(2) = 1.11022e-16; - CheckTripleTree.at(1).at(5).at(0) = 2.22045e-16; - CheckTripleCT.at(1).at(5).at(0) = -1.38778e-17; - CheckTripleCW.at(1).at(5).at(0) = -3.1225e-17; + CheckTripleCT.at(1).at(3).at(7) = 5.48284; + CheckTripleCW.at(1).at(3).at(7) = -5.48284; + CheckTripleTree.at(1).at(4).at(0) = 4.80448e-16; + CheckTripleCT.at(1).at(4).at(0) = -4.09916e-17; + CheckTripleCW.at(1).at(4).at(0) = 3.32268e-18; + CheckTripleTree.at(1).at(4).at(2) = -3.68894e-16; + CheckTripleCT.at(1).at(4).at(2) = -2.99276e-17; + CheckTripleCW.at(1).at(4).at(2) = -2.48628e-16; + CheckTripleTree.at(1).at(5).at(0) = -6.79617e-16; + CheckTripleCT.at(1).at(5).at(0) = -4.16433e-17; + CheckTripleCW.at(1).at(5).at(0) = -2.08456e-16; CheckTripleTree.at(1).at(5).at(2) = -44.255; - CheckTripleCT.at(1).at(5).at(2) = 3.27917; - CheckTripleCW.at(1).at(5).at(2) = -3.27917; + CheckTripleCT.at(1).at(5).at(2) = 3.27917; + CheckTripleCW.at(1).at(5).at(2) = -3.27917; CheckTripleTree.at(1).at(6).at(1) = -61.4198; - CheckTripleCT.at(1).at(6).at(1) = 77.8048; - CheckTripleCW.at(1).at(6).at(1) = -77.8048; + CheckTripleCT.at(1).at(6).at(1) = 77.8048; + CheckTripleCW.at(1).at(6).at(1) = -77.8048; CheckTripleTree.at(1).at(6).at(3) = -174.929; - CheckTripleCT.at(1).at(6).at(3) = 5.08295; - CheckTripleCW.at(1).at(6).at(3) = -5.08295; + CheckTripleCT.at(1).at(6).at(3) = 5.08295; + CheckTripleCW.at(1).at(6).at(3) = -5.08295; CheckTripleTree.at(1).at(7).at(1) = 45.1709; - CheckTripleCT.at(1).at(7).at(1) = -24.2999; - CheckTripleCW.at(1).at(7).at(1) = 24.2999; + CheckTripleCT.at(1).at(7).at(1) = -24.2999; + CheckTripleCW.at(1).at(7).at(1) = 24.2999; CheckTripleTree.at(1).at(7).at(3) = -549.757; - CheckTripleCT.at(1).at(7).at(3) = 5.48284; - CheckTripleCW.at(1).at(7).at(3) = -5.48284; + CheckTripleCT.at(1).at(7).at(3) = 5.48284; + CheckTripleCW.at(1).at(7).at(3) = -5.48284; CheckTripleTree.at(2).at(0).at(6) = -174.929; - CheckTripleCT.at(2).at(0).at(6) = 5.08295; - CheckTripleCW.at(2).at(0).at(6) = -5.08295; + CheckTripleCT.at(2).at(0).at(6) = 5.08295; + CheckTripleCW.at(2).at(0).at(6) = -5.08295; CheckTripleTree.at(2).at(0).at(7) = -549.757; - CheckTripleCT.at(2).at(0).at(7) = 5.48284; - CheckTripleCW.at(2).at(0).at(7) = -5.48284; - CheckTripleTree.at(2).at(1).at(4) = 5.55112e-17; - CheckTripleCT.at(2).at(1).at(4) = 3.46945e-18; - CheckTripleCW.at(2).at(1).at(4) = 1.14492e-16; + CheckTripleCT.at(2).at(0).at(7) = 5.48284; + CheckTripleCW.at(2).at(0).at(7) = -5.48284; + CheckTripleTree.at(2).at(1).at(4) = -3.3727e-16; + CheckTripleCT.at(2).at(1).at(4) = -2.90969e-17; + CheckTripleCW.at(2).at(1).at(4) = -2.56443e-16; CheckTripleTree.at(2).at(1).at(5) = -44.255; - CheckTripleCT.at(2).at(1).at(5) = 3.27917; - CheckTripleCW.at(2).at(1).at(5) = -3.27917; + CheckTripleCT.at(2).at(1).at(5) = 3.27917; + CheckTripleCW.at(2).at(1).at(5) = -3.27917; CheckTripleTree.at(2).at(2).at(6) = -1307.14; - CheckTripleCT.at(2).at(2).at(6) = 97.6374; - CheckTripleCW.at(2).at(2).at(6) = -156.454; + CheckTripleCT.at(2).at(2).at(6) = 97.6374; + CheckTripleCW.at(2).at(2).at(6) = -156.454; CheckTripleTree.at(2).at(2).at(7) = 449.738; - CheckTripleCT.at(2).at(2).at(7) = 15.6005; - CheckTripleCW.at(2).at(2).at(7) = 79.7108; - CheckTripleTree.at(2).at(3).at(5) = 2.22045e-16; - CheckTripleCT.at(2).at(3).at(5) = -1.38778e-17; - CheckTripleCW.at(2).at(3).at(5) = -3.1225e-17; - CheckTripleCT.at(2).at(4).at(1) = 6.93889e-18; - CheckTripleCW.at(2).at(4).at(1) = 1.11022e-16; - CheckTripleTree.at(2).at(4).at(3) = -4.44089e-16; - CheckTripleCT.at(2).at(4).at(3) = 2.77556e-17; - CheckTripleCW.at(2).at(4).at(3) = -2.77556e-17; + CheckTripleCT.at(2).at(2).at(7) = 15.6005; + CheckTripleCW.at(2).at(2).at(7) = 79.7108; + CheckTripleTree.at(2).at(3).at(4) = 3.63589e-17; + CheckTripleCT.at(2).at(3).at(4) = -1.3236e-17; + CheckTripleCW.at(2).at(3).at(4) = 2.03308e-17; + CheckTripleTree.at(2).at(3).at(5) = -6.79617e-16; + CheckTripleCT.at(2).at(3).at(5) = -4.16433e-17; + CheckTripleCW.at(2).at(3).at(5) = 9.26402e-17; + CheckTripleTree.at(2).at(4).at(1) = -4.02061e-16; + CheckTripleCT.at(2).at(4).at(1) = -2.42961e-17; + CheckTripleCW.at(2).at(4).at(1) = -2.61243e-16; + CheckTripleTree.at(2).at(4).at(3) = -4.0773e-16; + CheckTripleCT.at(2).at(4).at(3) = 1.45196e-17; + CheckTripleCW.at(2).at(4).at(3) = -7.42481e-18; CheckTripleTree.at(2).at(5).at(1) = -44.255; - CheckTripleCT.at(2).at(5).at(1) = 3.27917; - CheckTripleCW.at(2).at(5).at(1) = -3.27917; - CheckTripleTree.at(2).at(5).at(3) = 2.77556e-16; - CheckTripleCT.at(2).at(5).at(3) = -1.73472e-17; - CheckTripleCW.at(2).at(5).at(3) = -2.77556e-17; + CheckTripleCT.at(2).at(5).at(1) = 3.27917; + CheckTripleCW.at(2).at(5).at(1) = -3.27917; + CheckTripleTree.at(2).at(5).at(3) = -6.14826e-16; + CheckTripleCT.at(2).at(5).at(3) = -4.64442e-17; + CheckTripleCW.at(2).at(5).at(3) = 9.7441e-17; CheckTripleTree.at(2).at(6).at(0) = -174.929; - CheckTripleCT.at(2).at(6).at(0) = 5.08295; - CheckTripleCW.at(2).at(6).at(0) = -5.08295; + CheckTripleCT.at(2).at(6).at(0) = 5.08295; + CheckTripleCW.at(2).at(6).at(0) = -5.08295; CheckTripleTree.at(2).at(6).at(2) = -1307.14; - CheckTripleCT.at(2).at(6).at(2) = 97.6374; - CheckTripleCW.at(2).at(6).at(2) = -156.454; + CheckTripleCT.at(2).at(6).at(2) = 97.6374; + CheckTripleCW.at(2).at(6).at(2) = -156.454; CheckTripleTree.at(2).at(7).at(0) = -549.757; - CheckTripleCT.at(2).at(7).at(0) = 5.48284; - CheckTripleCW.at(2).at(7).at(0) = -5.48284; + CheckTripleCT.at(2).at(7).at(0) = 5.48284; + CheckTripleCW.at(2).at(7).at(0) = -5.48284; CheckTripleTree.at(2).at(7).at(2) = 449.738; - CheckTripleCT.at(2).at(7).at(2) = 15.6005; - CheckTripleCW.at(2).at(7).at(2) = 79.7108; - CheckTripleTree.at(3).at(0).at(4) = -5.55112e-17; - CheckTripleCT.at(3).at(0).at(4) = -3.46945e-18; - CheckTripleCW.at(3).at(0).at(4) = -1.14492e-16; + CheckTripleCT.at(2).at(7).at(2) = 15.6005; + CheckTripleCW.at(2).at(7).at(2) = 79.7108; + CheckTripleTree.at(3).at(0).at(4) = 3.3727e-16; + CheckTripleCT.at(3).at(0).at(4) = 2.90969e-17; + CheckTripleCW.at(3).at(0).at(4) = 1.62021e-16; CheckTripleTree.at(3).at(0).at(5) = 44.255; - CheckTripleCT.at(3).at(0).at(5) = -3.27917; - CheckTripleCW.at(3).at(0).at(5) = 3.27917; + CheckTripleCT.at(3).at(0).at(5) = -3.27917; + CheckTripleCW.at(3).at(0).at(5) = 3.27917; CheckTripleTree.at(3).at(1).at(6) = -174.929; - CheckTripleCT.at(3).at(1).at(6) = 5.08295; - CheckTripleCW.at(3).at(1).at(6) = -5.08295; + CheckTripleCT.at(3).at(1).at(6) = 5.08295; + CheckTripleCW.at(3).at(1).at(6) = -5.08295; CheckTripleTree.at(3).at(1).at(7) = -549.757; - CheckTripleCT.at(3).at(1).at(7) = 5.48284; - CheckTripleCW.at(3).at(1).at(7) = -5.48284; - CheckTripleTree.at(3).at(2).at(5) = -2.22045e-16; - CheckTripleCT.at(3).at(2).at(5) = 1.38778e-17; - CheckTripleCW.at(3).at(2).at(5) = 3.1225e-17; + CheckTripleCT.at(3).at(1).at(7) = 5.48284; + CheckTripleCW.at(3).at(1).at(7) = -5.48284; + CheckTripleTree.at(3).at(2).at(4) = -3.63589e-17; + CheckTripleCT.at(3).at(2).at(4) = 1.3236e-17; + CheckTripleCW.at(3).at(2).at(4) = 2.44329e-17; + CheckTripleTree.at(3).at(2).at(5) = 6.79617e-16; + CheckTripleCT.at(3).at(2).at(5) = 4.16433e-17; + CheckTripleCW.at(3).at(2).at(5) = 2.08456e-16; CheckTripleTree.at(3).at(3).at(6) = -1307.14; - CheckTripleCT.at(3).at(3).at(6) = 97.6374; - CheckTripleCW.at(3).at(3).at(6) = -156.454; + CheckTripleCT.at(3).at(3).at(6) = 97.6374; + CheckTripleCW.at(3).at(3).at(6) = -156.454; CheckTripleTree.at(3).at(3).at(7) = 449.738; - CheckTripleCT.at(3).at(3).at(7) = 15.6005; - CheckTripleCW.at(3).at(3).at(7) = 79.7108; - CheckTripleCT.at(3).at(4).at(0) = -6.93889e-18; - CheckTripleCW.at(3).at(4).at(0) = -1.11022e-16; - CheckTripleTree.at(3).at(4).at(2) = 4.44089e-16; - CheckTripleCT.at(3).at(4).at(2) = -2.77556e-17; - CheckTripleCW.at(3).at(4).at(2) = 2.77556e-17; + CheckTripleCT.at(3).at(3).at(7) = 15.6005; + CheckTripleCW.at(3).at(3).at(7) = 79.7108; + CheckTripleTree.at(3).at(4).at(0) = 4.02061e-16; + CheckTripleCT.at(3).at(4).at(0) = 2.42961e-17; + CheckTripleCW.at(3).at(4).at(0) = 1.66822e-16; + CheckTripleTree.at(3).at(4).at(2) = 4.0773e-16; + CheckTripleCT.at(3).at(4).at(2) = -1.45196e-17; + CheckTripleCW.at(3).at(4).at(2) = 2.44329e-17; CheckTripleTree.at(3).at(5).at(0) = 44.255; - CheckTripleCT.at(3).at(5).at(0) = -3.27917; - CheckTripleCW.at(3).at(5).at(0) = 3.27917; - CheckTripleTree.at(3).at(5).at(2) = -2.77556e-16; - CheckTripleCT.at(3).at(5).at(2) = 1.73472e-17; - CheckTripleCW.at(3).at(5).at(2) = 2.77556e-17; + CheckTripleCT.at(3).at(5).at(0) = -3.27917; + CheckTripleCW.at(3).at(5).at(0) = 3.27917; + CheckTripleTree.at(3).at(5).at(2) = 6.14826e-16; + CheckTripleCT.at(3).at(5).at(2) = 4.64442e-17; + CheckTripleCW.at(3).at(5).at(2) = 2.03655e-16; CheckTripleTree.at(3).at(6).at(1) = -174.929; - CheckTripleCT.at(3).at(6).at(1) = 5.08295; - CheckTripleCW.at(3).at(6).at(1) = -5.08295; + CheckTripleCT.at(3).at(6).at(1) = 5.08295; + CheckTripleCW.at(3).at(6).at(1) = -5.08295; CheckTripleTree.at(3).at(6).at(3) = -1307.14; - CheckTripleCT.at(3).at(6).at(3) = 97.6374; - CheckTripleCW.at(3).at(6).at(3) = -156.454; + CheckTripleCT.at(3).at(6).at(3) = 97.6374; + CheckTripleCW.at(3).at(6).at(3) = -156.454; CheckTripleTree.at(3).at(7).at(1) = -549.757; - CheckTripleCT.at(3).at(7).at(1) = 5.48284; - CheckTripleCW.at(3).at(7).at(1) = -5.48284; + CheckTripleCT.at(3).at(7).at(1) = 5.48284; + CheckTripleCW.at(3).at(7).at(1) = -5.48284; CheckTripleTree.at(3).at(7).at(3) = 449.738; - CheckTripleCT.at(3).at(7).at(3) = 15.6005; - CheckTripleCW.at(3).at(7).at(3) = 79.7108; - CheckTripleTree.at(4).at(0).at(1) = -4.44089e-16; - CheckTripleCT.at(4).at(0).at(1) = 2.77556e-17; - CheckTripleCW.at(4).at(0).at(1) = -2.77556e-17; - CheckTripleCW.at(4).at(0).at(3) = -1.11022e-16; - CheckTripleTree.at(4).at(1).at(0) = 4.44089e-16; - CheckTripleCT.at(4).at(1).at(0) = -2.77556e-17; - CheckTripleCW.at(4).at(1).at(0) = 2.77556e-17; - CheckTripleCW.at(4).at(1).at(2) = 1.11022e-16; - CheckTripleTree.at(4).at(2).at(1) = 2.22045e-16; - CheckTripleCT.at(4).at(2).at(1) = -1.38778e-17; - CheckTripleCW.at(4).at(2).at(1) = 7.97973e-17; - CheckTripleTree.at(4).at(2).at(3) = -4.44089e-16; - CheckTripleCT.at(4).at(2).at(3) = 2.77556e-17; - CheckTripleCW.at(4).at(2).at(3) = -2.77556e-17; - CheckTripleTree.at(4).at(3).at(0) = -2.22045e-16; - CheckTripleCT.at(4).at(3).at(0) = 1.38778e-17; - CheckTripleCW.at(4).at(3).at(0) = -7.97973e-17; - CheckTripleTree.at(4).at(3).at(2) = 4.44089e-16; - CheckTripleCT.at(4).at(3).at(2) = -2.77556e-17; - CheckTripleCW.at(4).at(3).at(2) = 2.77556e-17; + CheckTripleCT.at(3).at(7).at(3) = 15.6005; + CheckTripleCW.at(3).at(7).at(3) = 79.7108; + CheckTripleTree.at(4).at(0).at(1) = -4.80448e-16; + CheckTripleCT.at(4).at(0).at(1) = 4.09916e-17; + CheckTripleCW.at(4).at(0).at(1) = -4.80863e-17; + CheckTripleTree.at(4).at(0).at(3) = 3.68894e-16; + CheckTripleCT.at(4).at(0).at(3) = 2.99276e-17; + CheckTripleCW.at(4).at(0).at(3) = 1.52267e-16; + CheckTripleTree.at(4).at(1).at(0) = 4.80448e-16; + CheckTripleCT.at(4).at(1).at(0) = -4.09916e-17; + CheckTripleCW.at(4).at(1).at(0) = 3.32268e-18; + CheckTripleTree.at(4).at(1).at(2) = -3.68894e-16; + CheckTripleCT.at(4).at(1).at(2) = -2.99276e-17; + CheckTripleCW.at(4).at(1).at(2) = -1.37606e-16; + CheckTripleTree.at(4).at(2).at(1) = -1.80017e-16; + CheckTripleCT.at(4).at(2).at(1) = -2.42961e-17; + CheckTripleCW.at(4).at(2).at(1) = -2.8553e-16; + CheckTripleTree.at(4).at(2).at(3) = -4.0773e-16; + CheckTripleCT.at(4).at(2).at(3) = 1.45196e-17; + CheckTripleCW.at(4).at(2).at(3) = -7.42481e-18; + CheckTripleTree.at(4).at(3).at(0) = 1.80017e-16; + CheckTripleCT.at(4).at(3).at(0) = 2.42961e-17; + CheckTripleCW.at(4).at(3).at(0) = 1.98047e-16; + CheckTripleTree.at(4).at(3).at(2) = 4.0773e-16; + CheckTripleCT.at(4).at(3).at(2) = -1.45196e-17; + CheckTripleCW.at(4).at(3).at(2) = 2.44329e-17; CheckTripleTree.at(4).at(4).at(6) = -61.4198; - CheckTripleCT.at(4).at(4).at(6) = 77.8048; - CheckTripleCW.at(4).at(4).at(6) = -77.8048; + CheckTripleCT.at(4).at(4).at(6) = 77.8048; + CheckTripleCW.at(4).at(4).at(6) = -77.8048; CheckTripleTree.at(4).at(4).at(7) = 45.1709; - CheckTripleCT.at(4).at(4).at(7) = -24.2999; - CheckTripleCW.at(4).at(4).at(7) = 24.2999; + CheckTripleCT.at(4).at(4).at(7) = -24.2999; + CheckTripleCW.at(4).at(4).at(7) = 24.2999; CheckTripleTree.at(4).at(5).at(6) = 163.564; - CheckTripleCT.at(4).at(5).at(6) = -4.24085; - CheckTripleCW.at(4).at(5).at(6) = 4.24085; + CheckTripleCT.at(4).at(5).at(6) = -4.24085; + CheckTripleCW.at(4).at(5).at(6) = 4.24085; CheckTripleTree.at(4).at(5).at(7) = 506.986; - CheckTripleCT.at(4).at(5).at(7) = -2.31364; - CheckTripleCW.at(4).at(5).at(7) = 2.31364; + CheckTripleCT.at(4).at(5).at(7) = -2.31364; + CheckTripleCW.at(4).at(5).at(7) = 2.31364; CheckTripleTree.at(4).at(6).at(4) = -61.4198; - CheckTripleCT.at(4).at(6).at(4) = 77.8048; - CheckTripleCW.at(4).at(6).at(4) = -77.8048; + CheckTripleCT.at(4).at(6).at(4) = 77.8048; + CheckTripleCW.at(4).at(6).at(4) = -77.8048; CheckTripleTree.at(4).at(6).at(5) = 163.564; - CheckTripleCT.at(4).at(6).at(5) = -4.24085; - CheckTripleCW.at(4).at(6).at(5) = 4.24085; + CheckTripleCT.at(4).at(6).at(5) = -4.24085; + CheckTripleCW.at(4).at(6).at(5) = 4.24085; CheckTripleTree.at(4).at(7).at(4) = 45.1709; - CheckTripleCT.at(4).at(7).at(4) = -24.2999; - CheckTripleCW.at(4).at(7).at(4) = 24.2999; + CheckTripleCT.at(4).at(7).at(4) = -24.2999; + CheckTripleCW.at(4).at(7).at(4) = 24.2999; CheckTripleTree.at(4).at(7).at(5) = 506.986; - CheckTripleCT.at(4).at(7).at(5) = -2.31364; - CheckTripleCW.at(4).at(7).at(5) = 2.31364; - CheckTripleTree.at(5).at(0).at(1) = 5.55112e-17; - CheckTripleCT.at(5).at(0).at(1) = -3.46945e-18; - CheckTripleCW.at(5).at(0).at(1) = 3.46945e-18; + CheckTripleCT.at(4).at(7).at(5) = -2.31364; + CheckTripleCW.at(4).at(7).at(5) = 2.31364; + CheckTripleTree.at(5).at(0).at(1) = 9.01662e-16; + CheckTripleCT.at(5).at(0).at(1) = 4.51128e-17; + CheckTripleCW.at(5).at(0).at(1) = -1.30804e-16; CheckTripleTree.at(5).at(0).at(3) = 44.255; - CheckTripleCT.at(5).at(0).at(3) = -3.27917; - CheckTripleCW.at(5).at(0).at(3) = 3.27917; - CheckTripleTree.at(5).at(1).at(0) = -5.55112e-17; - CheckTripleCT.at(5).at(1).at(0) = 3.46945e-18; - CheckTripleCW.at(5).at(1).at(0) = -3.46945e-18; + CheckTripleCT.at(5).at(0).at(3) = -3.27917; + CheckTripleCW.at(5).at(0).at(3) = 3.27917; + CheckTripleTree.at(5).at(1).at(0) = -9.01662e-16; + CheckTripleCT.at(5).at(1).at(0) = -4.51128e-17; + CheckTripleCW.at(5).at(1).at(0) = -1.77231e-16; CheckTripleTree.at(5).at(1).at(2) = -44.255; - CheckTripleCT.at(5).at(1).at(2) = 3.27917; - CheckTripleCW.at(5).at(1).at(2) = -3.27917; + CheckTripleCT.at(5).at(1).at(2) = 3.27917; + CheckTripleCW.at(5).at(1).at(2) = -3.27917; CheckTripleTree.at(5).at(2).at(1) = -44.255; - CheckTripleCT.at(5).at(2).at(1) = 3.27917; - CheckTripleCW.at(5).at(2).at(1) = -3.27917; - CheckTripleTree.at(5).at(2).at(3) = 5.55112e-17; - CheckTripleCT.at(5).at(2).at(3) = -3.46945e-18; - CheckTripleCW.at(5).at(2).at(3) = 3.46945e-18; + CheckTripleCT.at(5).at(2).at(1) = 3.27917; + CheckTripleCW.at(5).at(2).at(1) = -3.27917; + CheckTripleTree.at(5).at(2).at(3) = -7.81359e-16; + CheckTripleCT.at(5).at(2).at(3) = -5.3383e-17; + CheckTripleCW.at(5).at(2).at(3) = 1.42544e-16; CheckTripleTree.at(5).at(3).at(0) = 44.255; - CheckTripleCT.at(5).at(3).at(0) = -3.27917; - CheckTripleCW.at(5).at(3).at(0) = 3.27917; - CheckTripleTree.at(5).at(3).at(2) = -5.55112e-17; - CheckTripleCT.at(5).at(3).at(2) = 3.46945e-18; - CheckTripleCW.at(5).at(3).at(2) = -3.46945e-18; + CheckTripleCT.at(5).at(3).at(0) = -3.27917; + CheckTripleCW.at(5).at(3).at(0) = 3.27917; + CheckTripleTree.at(5).at(3).at(2) = 7.81359e-16; + CheckTripleCT.at(5).at(3).at(2) = 5.3383e-17; + CheckTripleCW.at(5).at(3).at(2) = 1.6896e-16; CheckTripleTree.at(5).at(4).at(6) = 163.564; - CheckTripleCT.at(5).at(4).at(6) = -4.24085; - CheckTripleCW.at(5).at(4).at(6) = 4.24085; + CheckTripleCT.at(5).at(4).at(6) = -4.24085; + CheckTripleCW.at(5).at(4).at(6) = 4.24085; CheckTripleTree.at(5).at(4).at(7) = 506.986; - CheckTripleCT.at(5).at(4).at(7) = -2.31364; - CheckTripleCW.at(5).at(4).at(7) = 2.31364; + CheckTripleCT.at(5).at(4).at(7) = -2.31364; + CheckTripleCW.at(5).at(4).at(7) = 2.31364; CheckTripleTree.at(5).at(5).at(6) = -1221.6; - CheckTripleCT.at(5).at(5).at(6) = 91.299; - CheckTripleCW.at(5).at(5).at(6) = -137.072; + CheckTripleCT.at(5).at(5).at(6) = 91.299; + CheckTripleCW.at(5).at(5).at(6) = -137.072; CheckTripleTree.at(5).at(5).at(7) = 427.008; - CheckTripleCT.at(5).at(5).at(7) = 17.2847; - CheckTripleCW.at(5).at(5).at(7) = 71.1447; + CheckTripleCT.at(5).at(5).at(7) = 17.2847; + CheckTripleCW.at(5).at(5).at(7) = 71.1447; CheckTripleTree.at(5).at(6).at(4) = 163.564; - CheckTripleCT.at(5).at(6).at(4) = -4.24085; - CheckTripleCW.at(5).at(6).at(4) = 4.24085; + CheckTripleCT.at(5).at(6).at(4) = -4.24085; + CheckTripleCW.at(5).at(6).at(4) = 4.24085; CheckTripleTree.at(5).at(6).at(5) = -1221.6; - CheckTripleCT.at(5).at(6).at(5) = 91.299; - CheckTripleCW.at(5).at(6).at(5) = -137.072; + CheckTripleCT.at(5).at(6).at(5) = 91.299; + CheckTripleCW.at(5).at(6).at(5) = -137.072; CheckTripleTree.at(5).at(7).at(4) = 506.986; - CheckTripleCT.at(5).at(7).at(4) = -2.31364; - CheckTripleCW.at(5).at(7).at(4) = 2.31364; + CheckTripleCT.at(5).at(7).at(4) = -2.31364; + CheckTripleCW.at(5).at(7).at(4) = 2.31364; CheckTripleTree.at(5).at(7).at(5) = 427.008; - CheckTripleCT.at(5).at(7).at(5) = 17.2847; - CheckTripleCW.at(5).at(7).at(5) = 71.1447; + CheckTripleCT.at(5).at(7).at(5) = 17.2847; + CheckTripleCW.at(5).at(7).at(5) = 71.1447; CheckTripleTree.at(6).at(0).at(0) = -61.4198; - CheckTripleCT.at(6).at(0).at(0) = 77.8048; - CheckTripleCW.at(6).at(0).at(0) = -77.8048; + CheckTripleCT.at(6).at(0).at(0) = 77.8048; + CheckTripleCW.at(6).at(0).at(0) = -77.8048; CheckTripleTree.at(6).at(0).at(2) = -174.929; - CheckTripleCT.at(6).at(0).at(2) = 5.08295; - CheckTripleCW.at(6).at(0).at(2) = -5.08295; + CheckTripleCT.at(6).at(0).at(2) = 5.08295; + CheckTripleCW.at(6).at(0).at(2) = -5.08295; CheckTripleTree.at(6).at(1).at(1) = -61.4198; - CheckTripleCT.at(6).at(1).at(1) = 77.8048; - CheckTripleCW.at(6).at(1).at(1) = -77.8048; + CheckTripleCT.at(6).at(1).at(1) = 77.8048; + CheckTripleCW.at(6).at(1).at(1) = -77.8048; CheckTripleTree.at(6).at(1).at(3) = -174.929; - CheckTripleCT.at(6).at(1).at(3) = 5.08295; - CheckTripleCW.at(6).at(1).at(3) = -5.08295; + CheckTripleCT.at(6).at(1).at(3) = 5.08295; + CheckTripleCW.at(6).at(1).at(3) = -5.08295; CheckTripleTree.at(6).at(2).at(0) = -174.929; - CheckTripleCT.at(6).at(2).at(0) = 5.08295; - CheckTripleCW.at(6).at(2).at(0) = -5.08295; + CheckTripleCT.at(6).at(2).at(0) = 5.08295; + CheckTripleCW.at(6).at(2).at(0) = -5.08295; CheckTripleTree.at(6).at(2).at(2) = -1307.14; - CheckTripleCT.at(6).at(2).at(2) = 97.6374; - CheckTripleCW.at(6).at(2).at(2) = -156.454; + CheckTripleCT.at(6).at(2).at(2) = 97.6374; + CheckTripleCW.at(6).at(2).at(2) = -156.454; CheckTripleTree.at(6).at(3).at(1) = -174.929; - CheckTripleCT.at(6).at(3).at(1) = 5.08295; - CheckTripleCW.at(6).at(3).at(1) = -5.08295; + CheckTripleCT.at(6).at(3).at(1) = 5.08295; + CheckTripleCW.at(6).at(3).at(1) = -5.08295; CheckTripleTree.at(6).at(3).at(3) = -1307.14; - CheckTripleCT.at(6).at(3).at(3) = 97.6374; - CheckTripleCW.at(6).at(3).at(3) = -156.454; + CheckTripleCT.at(6).at(3).at(3) = 97.6374; + CheckTripleCW.at(6).at(3).at(3) = -156.454; CheckTripleTree.at(6).at(4).at(4) = -61.4198; - CheckTripleCT.at(6).at(4).at(4) = 77.8048; - CheckTripleCW.at(6).at(4).at(4) = -77.8048; + CheckTripleCT.at(6).at(4).at(4) = 77.8048; + CheckTripleCW.at(6).at(4).at(4) = -77.8048; CheckTripleTree.at(6).at(4).at(5) = 163.564; - CheckTripleCT.at(6).at(4).at(5) = -4.24085; - CheckTripleCW.at(6).at(4).at(5) = 4.24085; + CheckTripleCT.at(6).at(4).at(5) = -4.24085; + CheckTripleCW.at(6).at(4).at(5) = 4.24085; CheckTripleTree.at(6).at(5).at(4) = 163.564; - CheckTripleCT.at(6).at(5).at(4) = -4.24085; - CheckTripleCW.at(6).at(5).at(4) = 4.24085; + CheckTripleCT.at(6).at(5).at(4) = -4.24085; + CheckTripleCW.at(6).at(5).at(4) = 4.24085; CheckTripleTree.at(6).at(5).at(5) = -1221.6; - CheckTripleCT.at(6).at(5).at(5) = 91.299; - CheckTripleCW.at(6).at(5).at(5) = -137.072; + CheckTripleCT.at(6).at(5).at(5) = 91.299; + CheckTripleCW.at(6).at(5).at(5) = -137.072; CheckTripleTree.at(6).at(6).at(6) = -170.222; - CheckTripleCT.at(6).at(6).at(6) = 229.769; - CheckTripleCW.at(6).at(6).at(6) = -325.36; + CheckTripleCT.at(6).at(6).at(6) = 229.769; + CheckTripleCW.at(6).at(6).at(6) = -325.36; CheckTripleTree.at(6).at(6).at(7) = 30.1014; - CheckTripleCT.at(6).at(6).at(7) = -23.3707; - CheckTripleCW.at(6).at(6).at(7) = 65.133; + CheckTripleCT.at(6).at(6).at(7) = -23.3707; + CheckTripleCW.at(6).at(6).at(7) = 65.133; CheckTripleTree.at(6).at(7).at(6) = 30.1014; - CheckTripleCT.at(6).at(7).at(6) = -23.3707; - CheckTripleCW.at(6).at(7).at(6) = 65.133; + CheckTripleCT.at(6).at(7).at(6) = -23.3707; + CheckTripleCW.at(6).at(7).at(6) = 65.133; CheckTripleTree.at(6).at(7).at(7) = -156.506; - CheckTripleCT.at(6).at(7).at(7) = 109.139; - CheckTripleCW.at(6).at(7).at(7) = -96.4585; + CheckTripleCT.at(6).at(7).at(7) = 109.139; + CheckTripleCW.at(6).at(7).at(7) = -96.4585; CheckTripleTree.at(7).at(0).at(0) = 45.1709; - CheckTripleCT.at(7).at(0).at(0) = -24.2999; - CheckTripleCW.at(7).at(0).at(0) = 24.2999; + CheckTripleCT.at(7).at(0).at(0) = -24.2999; + CheckTripleCW.at(7).at(0).at(0) = 24.2999; CheckTripleTree.at(7).at(0).at(2) = -549.757; - CheckTripleCT.at(7).at(0).at(2) = 5.48284; - CheckTripleCW.at(7).at(0).at(2) = -5.48284; + CheckTripleCT.at(7).at(0).at(2) = 5.48284; + CheckTripleCW.at(7).at(0).at(2) = -5.48284; CheckTripleTree.at(7).at(1).at(1) = 45.1709; - CheckTripleCT.at(7).at(1).at(1) = -24.2999; - CheckTripleCW.at(7).at(1).at(1) = 24.2999; + CheckTripleCT.at(7).at(1).at(1) = -24.2999; + CheckTripleCW.at(7).at(1).at(1) = 24.2999; CheckTripleTree.at(7).at(1).at(3) = -549.757; - CheckTripleCT.at(7).at(1).at(3) = 5.48284; - CheckTripleCW.at(7).at(1).at(3) = -5.48284; + CheckTripleCT.at(7).at(1).at(3) = 5.48284; + CheckTripleCW.at(7).at(1).at(3) = -5.48284; CheckTripleTree.at(7).at(2).at(0) = -549.757; - CheckTripleCT.at(7).at(2).at(0) = 5.48284; - CheckTripleCW.at(7).at(2).at(0) = -5.48284; + CheckTripleCT.at(7).at(2).at(0) = 5.48284; + CheckTripleCW.at(7).at(2).at(0) = -5.48284; CheckTripleTree.at(7).at(2).at(2) = 449.738; - CheckTripleCT.at(7).at(2).at(2) = 15.6005; - CheckTripleCW.at(7).at(2).at(2) = 79.7108; + CheckTripleCT.at(7).at(2).at(2) = 15.6005; + CheckTripleCW.at(7).at(2).at(2) = 79.7108; CheckTripleTree.at(7).at(3).at(1) = -549.757; - CheckTripleCT.at(7).at(3).at(1) = 5.48284; - CheckTripleCW.at(7).at(3).at(1) = -5.48284; + CheckTripleCT.at(7).at(3).at(1) = 5.48284; + CheckTripleCW.at(7).at(3).at(1) = -5.48284; CheckTripleTree.at(7).at(3).at(3) = 449.738; - CheckTripleCT.at(7).at(3).at(3) = 15.6005; - CheckTripleCW.at(7).at(3).at(3) = 79.7108; + CheckTripleCT.at(7).at(3).at(3) = 15.6005; + CheckTripleCW.at(7).at(3).at(3) = 79.7108; CheckTripleTree.at(7).at(4).at(4) = 45.1709; - CheckTripleCT.at(7).at(4).at(4) = -24.2999; - CheckTripleCW.at(7).at(4).at(4) = 24.2999; + CheckTripleCT.at(7).at(4).at(4) = -24.2999; + CheckTripleCW.at(7).at(4).at(4) = 24.2999; CheckTripleTree.at(7).at(4).at(5) = 506.986; - CheckTripleCT.at(7).at(4).at(5) = -2.31364; - CheckTripleCW.at(7).at(4).at(5) = 2.31364; + CheckTripleCT.at(7).at(4).at(5) = -2.31364; + CheckTripleCW.at(7).at(4).at(5) = 2.31364; CheckTripleTree.at(7).at(5).at(4) = 506.986; - CheckTripleCT.at(7).at(5).at(4) = -2.31364; - CheckTripleCW.at(7).at(5).at(4) = 2.31364; + CheckTripleCT.at(7).at(5).at(4) = -2.31364; + CheckTripleCW.at(7).at(5).at(4) = 2.31364; CheckTripleTree.at(7).at(5).at(5) = 427.008; - CheckTripleCT.at(7).at(5).at(5) = 17.2847; - CheckTripleCW.at(7).at(5).at(5) = 71.1447; + CheckTripleCT.at(7).at(5).at(5) = 17.2847; + CheckTripleCW.at(7).at(5).at(5) = 71.1447; CheckTripleTree.at(7).at(6).at(6) = 30.1014; - CheckTripleCT.at(7).at(6).at(6) = -23.3707; - CheckTripleCW.at(7).at(6).at(6) = 65.133; + CheckTripleCT.at(7).at(6).at(6) = -23.3707; + CheckTripleCW.at(7).at(6).at(6) = 65.133; CheckTripleTree.at(7).at(6).at(7) = -156.506; - CheckTripleCT.at(7).at(6).at(7) = 109.139; - CheckTripleCW.at(7).at(6).at(7) = -96.4585; + CheckTripleCT.at(7).at(6).at(7) = 109.139; + CheckTripleCW.at(7).at(6).at(7) = -96.4585; CheckTripleTree.at(7).at(7).at(6) = -156.506; - CheckTripleCT.at(7).at(7).at(6) = 109.139; - CheckTripleCW.at(7).at(7).at(6) = -96.4585; + CheckTripleCT.at(7).at(7).at(6) = 109.139; + CheckTripleCW.at(7).at(7).at(6) = -96.4585; CheckTripleTree.at(7).at(7).at(7) = 450.506; - CheckTripleCT.at(7).at(7).at(7) = 47.0721; - CheckTripleCW.at(7).at(7).at(7) = 86.0667; + CheckTripleCT.at(7).at(7).at(7) = 47.0721; + CheckTripleCW.at(7).at(7).at(7) = 86.0667; } diff --git a/tests/GenerateTestCompares/R2HDM.h b/tests/GenerateTestCompares/R2HDM.h index bc01fa34..6b879a06 100644 --- a/tests/GenerateTestCompares/R2HDM.h +++ b/tests/GenerateTestCompares/R2HDM.h @@ -1,4 +1,5 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller // // SPDX-License-Identifier: GPL-3.0-or-later @@ -6,13 +7,13 @@ #include #include class Compare_R2HDM - { +{ public: - using Matrix3D = std::vector>>; - using Matrix2D = std::vector>; - Compare_R2HDM(); - Matrix3D CheckTripleCT; - Matrix3D CheckTripleCW; - Matrix3D CheckTripleTree; - std::map EWPTPerSetting; + using Matrix3D = std::vector>>; + using Matrix2D = std::vector>; + Compare_R2HDM(); + Matrix3D CheckTripleCT; + Matrix3D CheckTripleCW; + Matrix3D CheckTripleTree; + std::map EWPTPerSetting; }; diff --git a/tests/GenerateTestCompares/RN2HDM.cpp b/tests/GenerateTestCompares/RN2HDM.cpp deleted file mode 100644 index 92c63df6..00000000 --- a/tests/GenerateTestCompares/RN2HDM.cpp +++ /dev/null @@ -1,598 +0,0 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// -// SPDX-License-Identifier: GPL-3.0-or-later - -#include "RN2HDM.h" -Compare_RN2HDM::Compare_RN2HDM() -{ - std::size_t NHiggs = 9; - CheckTripleTree = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - CheckTripleCW = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - CheckTripleCT = Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; - EWPTPerSetting[4].Tc = 300; - EWPTPerSetting[4].vc = 256.077; - EWPTPerSetting[4].EWMinimum.push_back(166.682); - EWPTPerSetting[4].EWMinimum.push_back(166.682); - EWPTPerSetting[4].EWMinimum.push_back(-0.823045); - EWPTPerSetting[4].EWMinimum.push_back(-100.046); - EWPTPerSetting[4].EWMinimum.push_back(-291.907); - EWPTPerSetting[1].Tc = 125.995; - EWPTPerSetting[1].vc = 141.319; - EWPTPerSetting[1].EWMinimum.push_back(-4.59002e-05); - EWPTPerSetting[1].EWMinimum.push_back(1.31843e-05); - EWPTPerSetting[1].EWMinimum.push_back(26.4225); - EWPTPerSetting[1].EWMinimum.push_back(138.827); - EWPTPerSetting[1].EWMinimum.push_back(298.683); - EWPTPerSetting[5].Tc = 125.995; - EWPTPerSetting[5].vc = 141.319; - EWPTPerSetting[5].EWMinimum.push_back(-7.63675e-05); - EWPTPerSetting[5].EWMinimum.push_back(4.41778e-05); - EWPTPerSetting[5].EWMinimum.push_back(26.4225); - EWPTPerSetting[5].EWMinimum.push_back(138.827); - EWPTPerSetting[5].EWMinimum.push_back(298.683); - EWPTPerSetting[2].Tc = 120.731; - EWPTPerSetting[2].vc = 180.592; - EWPTPerSetting[2].EWMinimum.push_back(-3.98066e-05); - EWPTPerSetting[2].EWMinimum.push_back(0); - EWPTPerSetting[2].EWMinimum.push_back(32.7083); - EWPTPerSetting[2].EWMinimum.push_back(177.605); - EWPTPerSetting[2].EWMinimum.push_back(-297.042); - EWPTPerSetting[6].Tc = 120.731; - EWPTPerSetting[6].vc = 180.592; - EWPTPerSetting[6].EWMinimum.push_back(-0.000124918); - EWPTPerSetting[6].EWMinimum.push_back(-1.38369e-05); - EWPTPerSetting[6].EWMinimum.push_back(32.7083); - EWPTPerSetting[6].EWMinimum.push_back(177.605); - EWPTPerSetting[6].EWMinimum.push_back(-297.042); - EWPTPerSetting[3].Tc = 120.731; - EWPTPerSetting[3].vc = 180.592; - EWPTPerSetting[3].EWMinimum.push_back(0); - EWPTPerSetting[3].EWMinimum.push_back(1.49144e-05); - EWPTPerSetting[3].EWMinimum.push_back(-32.7083); - EWPTPerSetting[3].EWMinimum.push_back(-177.605); - EWPTPerSetting[3].EWMinimum.push_back(297.042); - EWPTPerSetting[7].Tc = 120.731; - EWPTPerSetting[7].vc = 180.592; - EWPTPerSetting[7].EWMinimum.push_back(0); - EWPTPerSetting[7].EWMinimum.push_back(0); - EWPTPerSetting[7].EWMinimum.push_back(-32.7083); - EWPTPerSetting[7].EWMinimum.push_back(-177.605); - EWPTPerSetting[7].EWMinimum.push_back(297.042); - CheckTripleTree.at(0).at(0).at(6) = -63.363; - CheckTripleCT.at(0).at(0).at(6) = 73.3299; - CheckTripleCW.at(0).at(0).at(6) = -73.3299; - CheckTripleTree.at(0).at(0).at(7) = 5.2208; - CheckTripleCT.at(0).at(0).at(7) = -3.26127; - CheckTripleCW.at(0).at(0).at(7) = 3.26127; - CheckTripleTree.at(0).at(0).at(8) = -210.394; - CheckTripleCT.at(0).at(0).at(8) = 50.8122; - CheckTripleCW.at(0).at(0).at(8) = -50.8122; - CheckTripleTree.at(0).at(1).at(5) = -7.10543e-15; - CheckTripleCT.at(0).at(1).at(5) = 1.11022e-16; - CheckTripleCW.at(0).at(1).at(5) = 6.10623e-16; - CheckTripleTree.at(0).at(2).at(6) = 1.02686; - CheckTripleCT.at(0).at(2).at(6) = -0.186289; - CheckTripleCW.at(0).at(2).at(6) = 0.186289; - CheckTripleTree.at(0).at(2).at(7) = -33.9201; - CheckTripleCT.at(0).at(2).at(7) = -1.34287; - CheckTripleCW.at(0).at(2).at(7) = 1.34287; - CheckTripleTree.at(0).at(2).at(8) = 73.114; - CheckTripleCT.at(0).at(2).at(8) = -15.5881; - CheckTripleCW.at(0).at(2).at(8) = 15.5881; - CheckTripleTree.at(0).at(3).at(4) = 2.84217e-14; - CheckTripleCT.at(0).at(3).at(4) = 1.77636e-15; - CheckTripleCW.at(0).at(3).at(4) = -8.88178e-15; - CheckTripleTree.at(0).at(3).at(5) = 979.072; - CheckTripleCT.at(0).at(3).at(5) = 93.3687; - CheckTripleCW.at(0).at(3).at(5) = -93.3687; - CheckTripleTree.at(0).at(4).at(1) = 3.55271e-15; - CheckTripleCT.at(0).at(4).at(1) = 4.44089e-16; - CheckTripleCW.at(0).at(4).at(1) = -4.44089e-16; - CheckTripleTree.at(0).at(4).at(3) = 2.84217e-14; - CheckTripleCT.at(0).at(4).at(3) = 3.55271e-15; - CheckTripleCW.at(0).at(4).at(3) = -1.06581e-14; - CheckTripleTree.at(0).at(5).at(1) = -3.55271e-14; - CheckTripleCT.at(0).at(5).at(1) = -1.66533e-15; - CheckTripleCW.at(0).at(5).at(1) = 4.16334e-15; - CheckTripleTree.at(0).at(5).at(3) = 979.072; - CheckTripleCT.at(0).at(5).at(3) = 93.3687; - CheckTripleCW.at(0).at(5).at(3) = -93.3687; - CheckTripleTree.at(0).at(6).at(0) = -63.363; - CheckTripleCT.at(0).at(6).at(0) = 73.3299; - CheckTripleCW.at(0).at(6).at(0) = -73.3299; - CheckTripleTree.at(0).at(6).at(2) = 1.02686; - CheckTripleCT.at(0).at(6).at(2) = -0.186289; - CheckTripleCW.at(0).at(6).at(2) = 0.186289; - CheckTripleTree.at(0).at(7).at(0) = 5.2208; - CheckTripleCT.at(0).at(7).at(0) = -3.26127; - CheckTripleCW.at(0).at(7).at(0) = 3.26127; - CheckTripleTree.at(0).at(7).at(2) = -33.9201; - CheckTripleCT.at(0).at(7).at(2) = -1.34287; - CheckTripleCW.at(0).at(7).at(2) = 1.34287; - CheckTripleTree.at(0).at(8).at(0) = -210.394; - CheckTripleCT.at(0).at(8).at(0) = 50.8122; - CheckTripleCW.at(0).at(8).at(0) = -50.8122; - CheckTripleTree.at(0).at(8).at(2) = 73.114; - CheckTripleCT.at(0).at(8).at(2) = -15.5881; - CheckTripleCW.at(0).at(8).at(2) = 15.5881; - CheckTripleTree.at(1).at(0).at(5) = 7.10543e-15; - CheckTripleCT.at(1).at(0).at(5) = -1.11022e-16; - CheckTripleCW.at(1).at(0).at(5) = -6.10623e-16; - CheckTripleTree.at(1).at(1).at(6) = -63.363; - CheckTripleCT.at(1).at(1).at(6) = 73.3299; - CheckTripleCW.at(1).at(1).at(6) = -73.3299; - CheckTripleTree.at(1).at(1).at(7) = 5.2208; - CheckTripleCT.at(1).at(1).at(7) = -3.26127; - CheckTripleCW.at(1).at(1).at(7) = 3.26127; - CheckTripleTree.at(1).at(1).at(8) = -210.394; - CheckTripleCT.at(1).at(1).at(8) = 50.8122; - CheckTripleCW.at(1).at(1).at(8) = -50.8122; - CheckTripleTree.at(1).at(2).at(4) = -2.84217e-14; - CheckTripleCT.at(1).at(2).at(4) = -1.77636e-15; - CheckTripleCW.at(1).at(2).at(4) = 8.88178e-15; - CheckTripleTree.at(1).at(2).at(5) = -979.072; - CheckTripleCT.at(1).at(2).at(5) = -93.3687; - CheckTripleCW.at(1).at(2).at(5) = 93.3687; - CheckTripleTree.at(1).at(3).at(6) = 1.02686; - CheckTripleCT.at(1).at(3).at(6) = -0.186289; - CheckTripleCW.at(1).at(3).at(6) = 0.186289; - CheckTripleTree.at(1).at(3).at(7) = -33.9201; - CheckTripleCT.at(1).at(3).at(7) = -1.34287; - CheckTripleCW.at(1).at(3).at(7) = 1.34287; - CheckTripleTree.at(1).at(3).at(8) = 73.114; - CheckTripleCT.at(1).at(3).at(8) = -15.5881; - CheckTripleCW.at(1).at(3).at(8) = 15.5881; - CheckTripleTree.at(1).at(4).at(0) = -3.55271e-15; - CheckTripleCT.at(1).at(4).at(0) = -4.44089e-16; - CheckTripleCW.at(1).at(4).at(0) = 4.44089e-16; - CheckTripleTree.at(1).at(4).at(2) = -2.84217e-14; - CheckTripleCT.at(1).at(4).at(2) = -3.55271e-15; - CheckTripleCW.at(1).at(4).at(2) = 1.06581e-14; - CheckTripleTree.at(1).at(5).at(0) = 3.55271e-14; - CheckTripleCT.at(1).at(5).at(0) = 1.66533e-15; - CheckTripleCW.at(1).at(5).at(0) = -4.16334e-15; - CheckTripleTree.at(1).at(5).at(2) = -979.072; - CheckTripleCT.at(1).at(5).at(2) = -93.3687; - CheckTripleCW.at(1).at(5).at(2) = 93.3687; - CheckTripleTree.at(1).at(6).at(1) = -63.363; - CheckTripleCT.at(1).at(6).at(1) = 73.3299; - CheckTripleCW.at(1).at(6).at(1) = -73.3299; - CheckTripleTree.at(1).at(6).at(3) = 1.02686; - CheckTripleCT.at(1).at(6).at(3) = -0.186289; - CheckTripleCW.at(1).at(6).at(3) = 0.186289; - CheckTripleTree.at(1).at(7).at(1) = 5.2208; - CheckTripleCT.at(1).at(7).at(1) = -3.26127; - CheckTripleCW.at(1).at(7).at(1) = 3.26127; - CheckTripleTree.at(1).at(7).at(3) = -33.9201; - CheckTripleCT.at(1).at(7).at(3) = -1.34287; - CheckTripleCW.at(1).at(7).at(3) = 1.34287; - CheckTripleTree.at(1).at(8).at(1) = -210.394; - CheckTripleCT.at(1).at(8).at(1) = 50.8122; - CheckTripleCW.at(1).at(8).at(1) = -50.8122; - CheckTripleTree.at(1).at(8).at(3) = 73.114; - CheckTripleCT.at(1).at(8).at(3) = -15.5881; - CheckTripleCW.at(1).at(8).at(3) = 15.5881; - CheckTripleTree.at(2).at(0).at(6) = 1.02686; - CheckTripleCT.at(2).at(0).at(6) = -0.186289; - CheckTripleCW.at(2).at(0).at(6) = 0.186289; - CheckTripleTree.at(2).at(0).at(7) = -33.9201; - CheckTripleCT.at(2).at(0).at(7) = -1.34287; - CheckTripleCW.at(2).at(0).at(7) = 1.34287; - CheckTripleTree.at(2).at(0).at(8) = 73.114; - CheckTripleCT.at(2).at(0).at(8) = -15.5881; - CheckTripleCW.at(2).at(0).at(8) = 15.5881; - CheckTripleTree.at(2).at(1).at(4) = -2.93099e-14; - CheckTripleCT.at(2).at(1).at(4) = -1.83187e-15; - CheckTripleCW.at(2).at(1).at(4) = 9.15934e-15; - CheckTripleTree.at(2).at(1).at(5) = -979.072; - CheckTripleCT.at(2).at(1).at(5) = -93.3687; - CheckTripleCW.at(2).at(1).at(5) = 93.3687; - CheckTripleTree.at(2).at(2).at(6) = 17.1796; - CheckTripleCT.at(2).at(2).at(6) = -137.986; - CheckTripleCW.at(2).at(2).at(6) = -72.4157; - CheckTripleTree.at(2).at(2).at(7) = -2.31824; - CheckTripleCT.at(2).at(2).at(7) = -538.331; - CheckTripleCW.at(2).at(2).at(7) = 3.8593; - CheckTripleTree.at(2).at(2).at(8) = 209.333; - CheckTripleCT.at(2).at(2).at(8) = -38.4073; - CheckTripleCW.at(2).at(2).at(8) = 39.5718; - CheckTripleTree.at(2).at(3).at(5) = 7.10543e-15; - CheckTripleCT.at(2).at(3).at(5) = -1.11022e-16; - CheckTripleCW.at(2).at(3).at(5) = -6.10623e-16; - CheckTripleTree.at(2).at(4).at(1) = -2.84217e-14; - CheckTripleCT.at(2).at(4).at(1) = -3.55271e-15; - CheckTripleCW.at(2).at(4).at(1) = 1.08802e-14; - CheckTripleTree.at(2).at(4).at(3) = 3.55271e-15; - CheckTripleCT.at(2).at(4).at(3) = 4.44089e-16; - CheckTripleCW.at(2).at(4).at(3) = -4.44089e-16; - CheckTripleTree.at(2).at(5).at(1) = -979.072; - CheckTripleCT.at(2).at(5).at(1) = -93.3687; - CheckTripleCW.at(2).at(5).at(1) = 93.3687; - CheckTripleTree.at(2).at(5).at(3) = -2.13163e-14; - CheckTripleCT.at(2).at(5).at(3) = -1.88738e-15; - CheckTripleCW.at(2).at(5).at(3) = 2.94209e-15; - CheckTripleTree.at(2).at(6).at(0) = 1.02686; - CheckTripleCT.at(2).at(6).at(0) = -0.186289; - CheckTripleCW.at(2).at(6).at(0) = 0.186289; - CheckTripleTree.at(2).at(6).at(2) = 17.1796; - CheckTripleCT.at(2).at(6).at(2) = -137.986; - CheckTripleCW.at(2).at(6).at(2) = -72.4157; - CheckTripleTree.at(2).at(7).at(0) = -33.9201; - CheckTripleCT.at(2).at(7).at(0) = -1.34287; - CheckTripleCW.at(2).at(7).at(0) = 1.34287; - CheckTripleTree.at(2).at(7).at(2) = -2.31824; - CheckTripleCT.at(2).at(7).at(2) = -538.331; - CheckTripleCW.at(2).at(7).at(2) = 3.8593; - CheckTripleTree.at(2).at(8).at(0) = 73.114; - CheckTripleCT.at(2).at(8).at(0) = -15.5881; - CheckTripleCW.at(2).at(8).at(0) = 15.5881; - CheckTripleTree.at(2).at(8).at(2) = 209.333; - CheckTripleCT.at(2).at(8).at(2) = -38.4073; - CheckTripleCW.at(2).at(8).at(2) = 39.5718; - CheckTripleTree.at(3).at(0).at(4) = 2.93099e-14; - CheckTripleCT.at(3).at(0).at(4) = 1.83187e-15; - CheckTripleCW.at(3).at(0).at(4) = -9.15934e-15; - CheckTripleTree.at(3).at(0).at(5) = 979.072; - CheckTripleCT.at(3).at(0).at(5) = 93.3687; - CheckTripleCW.at(3).at(0).at(5) = -93.3687; - CheckTripleTree.at(3).at(1).at(6) = 1.02686; - CheckTripleCT.at(3).at(1).at(6) = -0.186289; - CheckTripleCW.at(3).at(1).at(6) = 0.186289; - CheckTripleTree.at(3).at(1).at(7) = -33.9201; - CheckTripleCT.at(3).at(1).at(7) = -1.34287; - CheckTripleCW.at(3).at(1).at(7) = 1.34287; - CheckTripleTree.at(3).at(1).at(8) = 73.114; - CheckTripleCT.at(3).at(1).at(8) = -15.5881; - CheckTripleCW.at(3).at(1).at(8) = 15.5881; - CheckTripleTree.at(3).at(2).at(5) = -7.10543e-15; - CheckTripleCT.at(3).at(2).at(5) = 1.11022e-16; - CheckTripleCW.at(3).at(2).at(5) = 6.10623e-16; - CheckTripleTree.at(3).at(3).at(6) = 17.1796; - CheckTripleCT.at(3).at(3).at(6) = -137.986; - CheckTripleCW.at(3).at(3).at(6) = -72.4157; - CheckTripleTree.at(3).at(3).at(7) = -2.31824; - CheckTripleCT.at(3).at(3).at(7) = -538.331; - CheckTripleCW.at(3).at(3).at(7) = 3.8593; - CheckTripleTree.at(3).at(3).at(8) = 209.333; - CheckTripleCT.at(3).at(3).at(8) = -38.4073; - CheckTripleCW.at(3).at(3).at(8) = 39.5718; - CheckTripleTree.at(3).at(4).at(0) = 2.84217e-14; - CheckTripleCT.at(3).at(4).at(0) = 3.55271e-15; - CheckTripleCW.at(3).at(4).at(0) = -1.08802e-14; - CheckTripleTree.at(3).at(4).at(2) = -3.55271e-15; - CheckTripleCT.at(3).at(4).at(2) = -4.44089e-16; - CheckTripleCW.at(3).at(4).at(2) = 4.44089e-16; - CheckTripleTree.at(3).at(5).at(0) = 979.072; - CheckTripleCT.at(3).at(5).at(0) = 93.3687; - CheckTripleCW.at(3).at(5).at(0) = -93.3687; - CheckTripleTree.at(3).at(5).at(2) = 2.13163e-14; - CheckTripleCT.at(3).at(5).at(2) = 1.88738e-15; - CheckTripleCW.at(3).at(5).at(2) = -2.94209e-15; - CheckTripleTree.at(3).at(6).at(1) = 1.02686; - CheckTripleCT.at(3).at(6).at(1) = -0.186289; - CheckTripleCW.at(3).at(6).at(1) = 0.186289; - CheckTripleTree.at(3).at(6).at(3) = 17.1796; - CheckTripleCT.at(3).at(6).at(3) = -137.986; - CheckTripleCW.at(3).at(6).at(3) = -72.4157; - CheckTripleTree.at(3).at(7).at(1) = -33.9201; - CheckTripleCT.at(3).at(7).at(1) = -1.34287; - CheckTripleCW.at(3).at(7).at(1) = 1.34287; - CheckTripleTree.at(3).at(7).at(3) = -2.31824; - CheckTripleCT.at(3).at(7).at(3) = -538.331; - CheckTripleCW.at(3).at(7).at(3) = 3.8593; - CheckTripleTree.at(3).at(8).at(1) = 73.114; - CheckTripleCT.at(3).at(8).at(1) = -15.5881; - CheckTripleCW.at(3).at(8).at(1) = 15.5881; - CheckTripleTree.at(3).at(8).at(3) = 209.333; - CheckTripleCT.at(3).at(8).at(3) = -38.4073; - CheckTripleCW.at(3).at(8).at(3) = 39.5718; - CheckTripleTree.at(4).at(0).at(1) = 3.55271e-15; - CheckTripleCT.at(4).at(0).at(1) = 4.44089e-16; - CheckTripleCW.at(4).at(0).at(1) = -4.44089e-16; - CheckTripleTree.at(4).at(0).at(3) = 2.84217e-14; - CheckTripleCT.at(4).at(0).at(3) = 3.55271e-15; - CheckTripleCW.at(4).at(0).at(3) = -1.42109e-14; - CheckTripleTree.at(4).at(1).at(0) = -3.55271e-15; - CheckTripleCT.at(4).at(1).at(0) = -4.44089e-16; - CheckTripleCW.at(4).at(1).at(0) = 4.44089e-16; - CheckTripleTree.at(4).at(1).at(2) = -2.84217e-14; - CheckTripleCT.at(4).at(1).at(2) = -3.55271e-15; - CheckTripleCW.at(4).at(1).at(2) = 1.42109e-14; - CheckTripleTree.at(4).at(2).at(1) = -3.28626e-14; - CheckTripleCT.at(4).at(2).at(1) = -3.21965e-15; - CheckTripleCW.at(4).at(2).at(1) = 1.45994e-14; - CheckTripleTree.at(4).at(2).at(3) = 3.55271e-15; - CheckTripleCT.at(4).at(2).at(3) = 4.44089e-16; - CheckTripleCW.at(4).at(2).at(3) = -4.44089e-16; - CheckTripleTree.at(4).at(3).at(0) = 3.28626e-14; - CheckTripleCT.at(4).at(3).at(0) = 3.21965e-15; - CheckTripleCW.at(4).at(3).at(0) = -1.45994e-14; - CheckTripleTree.at(4).at(3).at(2) = -3.55271e-15; - CheckTripleCT.at(4).at(3).at(2) = -4.44089e-16; - CheckTripleCW.at(4).at(3).at(2) = 4.44089e-16; - CheckTripleTree.at(4).at(4).at(6) = -63.363; - CheckTripleCT.at(4).at(4).at(6) = 73.3299; - CheckTripleCW.at(4).at(4).at(6) = -73.3299; - CheckTripleTree.at(4).at(4).at(7) = 5.2208; - CheckTripleCT.at(4).at(4).at(7) = -3.26127; - CheckTripleCW.at(4).at(4).at(7) = 3.26127; - CheckTripleTree.at(4).at(4).at(8) = -210.394; - CheckTripleCT.at(4).at(4).at(8) = 50.8122; - CheckTripleCW.at(4).at(4).at(8) = -50.8122; - CheckTripleTree.at(4).at(5).at(6) = 44.9668; - CheckTripleCT.at(4).at(5).at(6) = 4.00402; - CheckTripleCW.at(4).at(5).at(6) = -4.00402; - CheckTripleTree.at(4).at(5).at(7) = 943.914; - CheckTripleCT.at(4).at(5).at(7) = 91.9078; - CheckTripleCW.at(4).at(5).at(7) = -91.9078; - CheckTripleTree.at(4).at(5).at(8) = 50.9425; - CheckTripleCT.at(4).at(5).at(8) = -17.7025; - CheckTripleCW.at(4).at(5).at(8) = 17.7025; - CheckTripleTree.at(4).at(6).at(4) = -63.363; - CheckTripleCT.at(4).at(6).at(4) = 73.3299; - CheckTripleCW.at(4).at(6).at(4) = -73.3299; - CheckTripleTree.at(4).at(6).at(5) = 44.9668; - CheckTripleCT.at(4).at(6).at(5) = 4.00402; - CheckTripleCW.at(4).at(6).at(5) = -4.00402; - CheckTripleTree.at(4).at(7).at(4) = 5.2208; - CheckTripleCT.at(4).at(7).at(4) = -3.26127; - CheckTripleCW.at(4).at(7).at(4) = 3.26127; - CheckTripleTree.at(4).at(7).at(5) = 943.914; - CheckTripleCT.at(4).at(7).at(5) = 91.9078; - CheckTripleCW.at(4).at(7).at(5) = -91.9078; - CheckTripleTree.at(4).at(8).at(4) = -210.394; - CheckTripleCT.at(4).at(8).at(4) = 50.8122; - CheckTripleCW.at(4).at(8).at(4) = -50.8122; - CheckTripleTree.at(4).at(8).at(5) = 50.9425; - CheckTripleCT.at(4).at(8).at(5) = -17.7025; - CheckTripleCW.at(4).at(8).at(5) = 17.7025; - CheckTripleTree.at(5).at(0).at(1) = -2.84217e-14; - CheckTripleCT.at(5).at(0).at(1) = -1.77636e-15; - CheckTripleCW.at(5).at(0).at(1) = 1.77636e-15; - CheckTripleTree.at(5).at(0).at(3) = 979.072; - CheckTripleCT.at(5).at(0).at(3) = 93.3687; - CheckTripleCW.at(5).at(0).at(3) = -93.3687; - CheckTripleTree.at(5).at(1).at(0) = 2.84217e-14; - CheckTripleCT.at(5).at(1).at(0) = 1.77636e-15; - CheckTripleCW.at(5).at(1).at(0) = -1.77636e-15; - CheckTripleTree.at(5).at(1).at(2) = -979.072; - CheckTripleCT.at(5).at(1).at(2) = -93.3687; - CheckTripleCW.at(5).at(1).at(2) = 93.3687; - CheckTripleTree.at(5).at(2).at(1) = -979.072; - CheckTripleCT.at(5).at(2).at(1) = -93.3687; - CheckTripleCW.at(5).at(2).at(1) = 93.3687; - CheckTripleTree.at(5).at(2).at(3) = -2.84217e-14; - CheckTripleCT.at(5).at(2).at(3) = -1.77636e-15; - CheckTripleCW.at(5).at(2).at(3) = 1.77636e-15; - CheckTripleTree.at(5).at(3).at(0) = 979.072; - CheckTripleCT.at(5).at(3).at(0) = 93.3687; - CheckTripleCW.at(5).at(3).at(0) = -93.3687; - CheckTripleTree.at(5).at(3).at(2) = 2.84217e-14; - CheckTripleCT.at(5).at(3).at(2) = 1.77636e-15; - CheckTripleCW.at(5).at(3).at(2) = -1.77636e-15; - CheckTripleTree.at(5).at(4).at(6) = 44.9668; - CheckTripleCT.at(5).at(4).at(6) = 4.00402; - CheckTripleCW.at(5).at(4).at(6) = -4.00402; - CheckTripleTree.at(5).at(4).at(7) = 943.914; - CheckTripleCT.at(5).at(4).at(7) = 91.9078; - CheckTripleCW.at(5).at(4).at(7) = -91.9078; - CheckTripleTree.at(5).at(4).at(8) = 50.9425; - CheckTripleCT.at(5).at(4).at(8) = -17.7025; - CheckTripleCW.at(5).at(4).at(8) = 17.7025; - CheckTripleTree.at(5).at(5).at(6) = -1935.17; - CheckTripleCT.at(5).at(5).at(6) = -324.171; - CheckTripleCW.at(5).at(5).at(6) = 60.2999; - CheckTripleTree.at(5).at(5).at(7) = 82.5947; - CheckTripleCT.at(5).at(5).at(7) = -530.233; - CheckTripleCW.at(5).at(5).at(7) = -8.50806; - CheckTripleTree.at(5).at(5).at(8) = 85.0571; - CheckTripleCT.at(5).at(5).at(8) = -50.2588; - CheckTripleCW.at(5).at(5).at(8) = 497.175; - CheckTripleTree.at(5).at(6).at(4) = 44.9668; - CheckTripleCT.at(5).at(6).at(4) = 4.00402; - CheckTripleCW.at(5).at(6).at(4) = -4.00402; - CheckTripleTree.at(5).at(6).at(5) = -1935.17; - CheckTripleCT.at(5).at(6).at(5) = -324.171; - CheckTripleCW.at(5).at(6).at(5) = 60.2999; - CheckTripleTree.at(5).at(7).at(4) = 943.914; - CheckTripleCT.at(5).at(7).at(4) = 91.9078; - CheckTripleCW.at(5).at(7).at(4) = -91.9078; - CheckTripleTree.at(5).at(7).at(5) = 82.5947; - CheckTripleCT.at(5).at(7).at(5) = -530.233; - CheckTripleCW.at(5).at(7).at(5) = -8.50806; - CheckTripleTree.at(5).at(8).at(4) = 50.9425; - CheckTripleCT.at(5).at(8).at(4) = -17.7025; - CheckTripleCW.at(5).at(8).at(4) = 17.7025; - CheckTripleTree.at(5).at(8).at(5) = 85.0571; - CheckTripleCT.at(5).at(8).at(5) = -50.2588; - CheckTripleCW.at(5).at(8).at(5) = 497.175; - CheckTripleTree.at(6).at(0).at(0) = -63.363; - CheckTripleCT.at(6).at(0).at(0) = 73.3299; - CheckTripleCW.at(6).at(0).at(0) = -73.3299; - CheckTripleTree.at(6).at(0).at(2) = 1.02686; - CheckTripleCT.at(6).at(0).at(2) = -0.186289; - CheckTripleCW.at(6).at(0).at(2) = 0.186289; - CheckTripleTree.at(6).at(1).at(1) = -63.363; - CheckTripleCT.at(6).at(1).at(1) = 73.3299; - CheckTripleCW.at(6).at(1).at(1) = -73.3299; - CheckTripleTree.at(6).at(1).at(3) = 1.02686; - CheckTripleCT.at(6).at(1).at(3) = -0.186289; - CheckTripleCW.at(6).at(1).at(3) = 0.186289; - CheckTripleTree.at(6).at(2).at(0) = 1.02686; - CheckTripleCT.at(6).at(2).at(0) = -0.186289; - CheckTripleCW.at(6).at(2).at(0) = 0.186289; - CheckTripleTree.at(6).at(2).at(2) = 17.1796; - CheckTripleCT.at(6).at(2).at(2) = -137.986; - CheckTripleCW.at(6).at(2).at(2) = -72.4157; - CheckTripleTree.at(6).at(3).at(1) = 1.02686; - CheckTripleCT.at(6).at(3).at(1) = -0.186289; - CheckTripleCW.at(6).at(3).at(1) = 0.186289; - CheckTripleTree.at(6).at(3).at(3) = 17.1796; - CheckTripleCT.at(6).at(3).at(3) = -137.986; - CheckTripleCW.at(6).at(3).at(3) = -72.4157; - CheckTripleTree.at(6).at(4).at(4) = -63.363; - CheckTripleCT.at(6).at(4).at(4) = 73.3299; - CheckTripleCW.at(6).at(4).at(4) = -73.3299; - CheckTripleTree.at(6).at(4).at(5) = 44.9668; - CheckTripleCT.at(6).at(4).at(5) = 4.00402; - CheckTripleCW.at(6).at(4).at(5) = -4.00402; - CheckTripleTree.at(6).at(5).at(4) = 44.9668; - CheckTripleCT.at(6).at(5).at(4) = 4.00402; - CheckTripleCW.at(6).at(5).at(4) = -4.00402; - CheckTripleTree.at(6).at(5).at(5) = -1935.17; - CheckTripleCT.at(6).at(5).at(5) = -324.171; - CheckTripleCW.at(6).at(5).at(5) = 60.2999; - CheckTripleTree.at(6).at(6).at(6) = -188.547; - CheckTripleCT.at(6).at(6).at(6) = 216.835; - CheckTripleCW.at(6).at(6).at(6) = -290.182; - CheckTripleTree.at(6).at(6).at(7) = 11.1893; - CheckTripleCT.at(6).at(6).at(7) = -23.129; - CheckTripleCW.at(6).at(6).at(7) = 3.31125; - CheckTripleTree.at(6).at(6).at(8) = -221.518; - CheckTripleCT.at(6).at(6).at(8) = 76.5066; - CheckTripleCW.at(6).at(6).at(8) = -76.498; - CheckTripleTree.at(6).at(7).at(6) = 11.1893; - CheckTripleCT.at(6).at(7).at(6) = -23.129; - CheckTripleCW.at(6).at(7).at(6) = 3.31125; - CheckTripleTree.at(6).at(7).at(7) = -51.1429; - CheckTripleCT.at(6).at(7).at(7) = -188.292; - CheckTripleCW.at(6).at(7).at(7) = -65.9015; - CheckTripleTree.at(6).at(7).at(8) = 96.6509; - CheckTripleCT.at(6).at(7).at(8) = -23.4745; - CheckTripleCW.at(6).at(7).at(8) = 26.6894; - CheckTripleTree.at(6).at(8).at(6) = -221.518; - CheckTripleCT.at(6).at(8).at(6) = 76.5066; - CheckTripleCW.at(6).at(8).at(6) = -76.498; - CheckTripleTree.at(6).at(8).at(7) = 96.6509; - CheckTripleCT.at(6).at(8).at(7) = -23.4745; - CheckTripleCW.at(6).at(8).at(7) = 26.6894; - CheckTripleTree.at(6).at(8).at(8) = 319.197; - CheckTripleCT.at(6).at(8).at(8) = -316.801; - CheckTripleCW.at(6).at(8).at(8) = 405.982; - CheckTripleTree.at(7).at(0).at(0) = 5.2208; - CheckTripleCT.at(7).at(0).at(0) = -3.26127; - CheckTripleCW.at(7).at(0).at(0) = 3.26127; - CheckTripleTree.at(7).at(0).at(2) = -33.9201; - CheckTripleCT.at(7).at(0).at(2) = -1.34287; - CheckTripleCW.at(7).at(0).at(2) = 1.34287; - CheckTripleTree.at(7).at(1).at(1) = 5.2208; - CheckTripleCT.at(7).at(1).at(1) = -3.26127; - CheckTripleCW.at(7).at(1).at(1) = 3.26127; - CheckTripleTree.at(7).at(1).at(3) = -33.9201; - CheckTripleCT.at(7).at(1).at(3) = -1.34287; - CheckTripleCW.at(7).at(1).at(3) = 1.34287; - CheckTripleTree.at(7).at(2).at(0) = -33.9201; - CheckTripleCT.at(7).at(2).at(0) = -1.34287; - CheckTripleCW.at(7).at(2).at(0) = 1.34287; - CheckTripleTree.at(7).at(2).at(2) = -2.31824; - CheckTripleCT.at(7).at(2).at(2) = -538.331; - CheckTripleCW.at(7).at(2).at(2) = 3.8593; - CheckTripleTree.at(7).at(3).at(1) = -33.9201; - CheckTripleCT.at(7).at(3).at(1) = -1.34287; - CheckTripleCW.at(7).at(3).at(1) = 1.34287; - CheckTripleTree.at(7).at(3).at(3) = -2.31824; - CheckTripleCT.at(7).at(3).at(3) = -538.331; - CheckTripleCW.at(7).at(3).at(3) = 3.8593; - CheckTripleTree.at(7).at(4).at(4) = 5.2208; - CheckTripleCT.at(7).at(4).at(4) = -3.26127; - CheckTripleCW.at(7).at(4).at(4) = 3.26127; - CheckTripleTree.at(7).at(4).at(5) = 943.914; - CheckTripleCT.at(7).at(4).at(5) = 91.9078; - CheckTripleCW.at(7).at(4).at(5) = -91.9078; - CheckTripleTree.at(7).at(5).at(4) = 943.914; - CheckTripleCT.at(7).at(5).at(4) = 91.9078; - CheckTripleCW.at(7).at(5).at(4) = -91.9078; - CheckTripleTree.at(7).at(5).at(5) = 82.5947; - CheckTripleCT.at(7).at(5).at(5) = -530.233; - CheckTripleCW.at(7).at(5).at(5) = -8.50806; - CheckTripleTree.at(7).at(6).at(6) = 11.1893; - CheckTripleCT.at(7).at(6).at(6) = -23.129; - CheckTripleCW.at(7).at(6).at(6) = 3.31125; - CheckTripleTree.at(7).at(6).at(7) = -51.1429; - CheckTripleCT.at(7).at(6).at(7) = -188.292; - CheckTripleCW.at(7).at(6).at(7) = -65.9015; - CheckTripleTree.at(7).at(6).at(8) = 96.6509; - CheckTripleCT.at(7).at(6).at(8) = -23.4745; - CheckTripleCW.at(7).at(6).at(8) = 26.6894; - CheckTripleTree.at(7).at(7).at(6) = -51.1429; - CheckTripleCT.at(7).at(7).at(6) = -188.292; - CheckTripleCW.at(7).at(7).at(6) = -65.9015; - CheckTripleTree.at(7).at(7).at(7) = 1.90163; - CheckTripleCT.at(7).at(7).at(7) = -1610.51; - CheckTripleCW.at(7).at(7).at(7) = 10.5816; - CheckTripleTree.at(7).at(7).at(8) = 195.857; - CheckTripleCT.at(7).at(7).at(8) = -9.66018; - CheckTripleCW.at(7).at(7).at(8) = 35.3349; - CheckTripleTree.at(7).at(8).at(6) = 96.6509; - CheckTripleCT.at(7).at(8).at(6) = -23.4745; - CheckTripleCW.at(7).at(8).at(6) = 26.6894; - CheckTripleTree.at(7).at(8).at(7) = 195.857; - CheckTripleCT.at(7).at(8).at(7) = -9.66018; - CheckTripleCW.at(7).at(8).at(7) = 35.3349; - CheckTripleTree.at(7).at(8).at(8) = -142.349; - CheckTripleCT.at(7).at(8).at(8) = 131.967; - CheckTripleCW.at(7).at(8).at(8) = -172.595; - CheckTripleTree.at(8).at(0).at(0) = -210.394; - CheckTripleCT.at(8).at(0).at(0) = 50.8122; - CheckTripleCW.at(8).at(0).at(0) = -50.8122; - CheckTripleTree.at(8).at(0).at(2) = 73.114; - CheckTripleCT.at(8).at(0).at(2) = -15.5881; - CheckTripleCW.at(8).at(0).at(2) = 15.5881; - CheckTripleTree.at(8).at(1).at(1) = -210.394; - CheckTripleCT.at(8).at(1).at(1) = 50.8122; - CheckTripleCW.at(8).at(1).at(1) = -50.8122; - CheckTripleTree.at(8).at(1).at(3) = 73.114; - CheckTripleCT.at(8).at(1).at(3) = -15.5881; - CheckTripleCW.at(8).at(1).at(3) = 15.5881; - CheckTripleTree.at(8).at(2).at(0) = 73.114; - CheckTripleCT.at(8).at(2).at(0) = -15.5881; - CheckTripleCW.at(8).at(2).at(0) = 15.5881; - CheckTripleTree.at(8).at(2).at(2) = 209.333; - CheckTripleCT.at(8).at(2).at(2) = -38.4073; - CheckTripleCW.at(8).at(2).at(2) = 39.5718; - CheckTripleTree.at(8).at(3).at(1) = 73.114; - CheckTripleCT.at(8).at(3).at(1) = -15.5881; - CheckTripleCW.at(8).at(3).at(1) = 15.5881; - CheckTripleTree.at(8).at(3).at(3) = 209.333; - CheckTripleCT.at(8).at(3).at(3) = -38.4073; - CheckTripleCW.at(8).at(3).at(3) = 39.5718; - CheckTripleTree.at(8).at(4).at(4) = -210.394; - CheckTripleCT.at(8).at(4).at(4) = 50.8122; - CheckTripleCW.at(8).at(4).at(4) = -50.8122; - CheckTripleTree.at(8).at(4).at(5) = 50.9425; - CheckTripleCT.at(8).at(4).at(5) = -17.7025; - CheckTripleCW.at(8).at(4).at(5) = 17.7025; - CheckTripleTree.at(8).at(5).at(4) = 50.9425; - CheckTripleCT.at(8).at(5).at(4) = -17.7025; - CheckTripleCW.at(8).at(5).at(4) = 17.7025; - CheckTripleTree.at(8).at(5).at(5) = 85.0571; - CheckTripleCT.at(8).at(5).at(5) = -50.2588; - CheckTripleCW.at(8).at(5).at(5) = 497.175; - CheckTripleTree.at(8).at(6).at(6) = -221.518; - CheckTripleCT.at(8).at(6).at(6) = 76.5066; - CheckTripleCW.at(8).at(6).at(6) = -76.498; - CheckTripleTree.at(8).at(6).at(7) = 96.6509; - CheckTripleCT.at(8).at(6).at(7) = -23.4745; - CheckTripleCW.at(8).at(6).at(7) = 26.6894; - CheckTripleTree.at(8).at(6).at(8) = 319.197; - CheckTripleCT.at(8).at(6).at(8) = -316.801; - CheckTripleCW.at(8).at(6).at(8) = 405.982; - CheckTripleTree.at(8).at(7).at(6) = 96.6509; - CheckTripleCT.at(8).at(7).at(6) = -23.4745; - CheckTripleCW.at(8).at(7).at(6) = 26.6894; - CheckTripleTree.at(8).at(7).at(7) = 195.857; - CheckTripleCT.at(8).at(7).at(7) = -9.66018; - CheckTripleCW.at(8).at(7).at(7) = 35.3349; - CheckTripleTree.at(8).at(7).at(8) = -142.349; - CheckTripleCT.at(8).at(7).at(8) = 131.967; - CheckTripleCW.at(8).at(7).at(8) = -172.595; - CheckTripleTree.at(8).at(8).at(6) = 319.197; - CheckTripleCT.at(8).at(8).at(6) = -316.801; - CheckTripleCW.at(8).at(8).at(6) = 405.982; - CheckTripleTree.at(8).at(8).at(7) = -142.349; - CheckTripleCT.at(8).at(8).at(7) = 131.967; - CheckTripleCW.at(8).at(8).at(7) = -172.595; - CheckTripleTree.at(8).at(8).at(8) = -8302.35; - CheckTripleCT.at(8).at(8).at(8) = 5790.5; - CheckTripleCW.at(8).at(8).at(8) = -8021.66; -} diff --git a/tests/GenerateTestCompares/RN2HDM.h b/tests/GenerateTestCompares/RN2HDM.h deleted file mode 100644 index 1832ed31..00000000 --- a/tests/GenerateTestCompares/RN2HDM.h +++ /dev/null @@ -1,18 +0,0 @@ -// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller -// -// SPDX-License-Identifier: GPL-3.0-or-later - -#include -#include -#include -class Compare_RN2HDM - { -public: - using Matrix3D = std::vector>>; - using Matrix2D = std::vector>; - Compare_RN2HDM(); - Matrix3D CheckTripleCT; - Matrix3D CheckTripleCW; - Matrix3D CheckTripleTree; - std::map EWPTPerSetting; -}; diff --git a/tests/GenerateTestCompares/SM.cpp b/tests/GenerateTestCompares/SM.cpp new file mode 100644 index 00000000..04d74be8 --- /dev/null +++ b/tests/GenerateTestCompares/SM.cpp @@ -0,0 +1,65 @@ +// SPDX-FileCopyrightText: 2021 Philipp Basler +// +// SPDX-License-Identifier: GPL-3.0-or-later +#include "SM.h" +Compare_SM::Compare_SM() +{ + std::size_t NHiggs = 4; + CheckTripleTree = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + CheckTripleCW = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + CheckTripleCT = + Matrix3D{NHiggs, Matrix2D{NHiggs, std::vector(NHiggs, 0)}}; + EWPTPerSetting[4].Tc = 159.082; + EWPTPerSetting[4].vc = 22.6653; + EWPTPerSetting[4].EWMinimum.push_back(-22.6653); + EWPTPerSetting[1].Tc = 159.082; + EWPTPerSetting[1].vc = 22.6654; + EWPTPerSetting[1].EWMinimum.push_back(-22.6654); + EWPTPerSetting[5].Tc = 159.082; + EWPTPerSetting[5].vc = 22.6653; + EWPTPerSetting[5].EWMinimum.push_back(-22.6653); + EWPTPerSetting[2].Tc = 159.082; + EWPTPerSetting[2].vc = 22.6654; + EWPTPerSetting[2].EWMinimum.push_back(-22.6654); + EWPTPerSetting[6].Tc = 159.082; + EWPTPerSetting[6].vc = 22.6653; + EWPTPerSetting[6].EWMinimum.push_back(-22.6653); + EWPTPerSetting[3].Tc = 159.082; + EWPTPerSetting[3].vc = 22.6654; + EWPTPerSetting[3].EWMinimum.push_back(-22.6654); + EWPTPerSetting[7].Tc = 159.082; + EWPTPerSetting[7].vc = 22.6653; + EWPTPerSetting[7].EWMinimum.push_back(-22.6653); + CheckTripleTree.at(0).at(0).at(3) = 63.551; + CheckTripleCT.at(0).at(0).at(3) = -5.21625; + CheckTripleCW.at(0).at(0).at(3) = 5.21625; + CheckTripleTree.at(0).at(3).at(0) = 63.551; + CheckTripleCT.at(0).at(3).at(0) = -5.21625; + CheckTripleCW.at(0).at(3).at(0) = 5.21625; + CheckTripleTree.at(1).at(1).at(3) = 63.551; + CheckTripleCT.at(1).at(1).at(3) = -5.21625; + CheckTripleCW.at(1).at(1).at(3) = 5.21625; + CheckTripleTree.at(1).at(3).at(1) = 63.551; + CheckTripleCT.at(1).at(3).at(1) = -5.21625; + CheckTripleCW.at(1).at(3).at(1) = 5.21625; + CheckTripleTree.at(2).at(2).at(3) = 63.551; + CheckTripleCT.at(2).at(2).at(3) = -5.21625; + CheckTripleCW.at(2).at(2).at(3) = 5.21625; + CheckTripleTree.at(2).at(3).at(2) = 63.551; + CheckTripleCT.at(2).at(3).at(2) = -5.21625; + CheckTripleCW.at(2).at(3).at(2) = 5.21625; + CheckTripleTree.at(3).at(0).at(0) = 63.551; + CheckTripleCT.at(3).at(0).at(0) = -5.21625; + CheckTripleCW.at(3).at(0).at(0) = 5.21625; + CheckTripleTree.at(3).at(1).at(1) = 63.551; + CheckTripleCT.at(3).at(1).at(1) = -5.21625; + CheckTripleCW.at(3).at(1).at(1) = 5.21625; + CheckTripleTree.at(3).at(2).at(2) = 63.551; + CheckTripleCT.at(3).at(2).at(2) = -5.21625; + CheckTripleCW.at(3).at(2).at(2) = 5.21625; + CheckTripleTree.at(3).at(3).at(3) = 190.653; + CheckTripleCT.at(3).at(3).at(3) = -15.6487; + CheckTripleCW.at(3).at(3).at(3) = -0.202437; +} diff --git a/tests/GenerateTestCompares/SM.h b/tests/GenerateTestCompares/SM.h new file mode 100644 index 00000000..90e53928 --- /dev/null +++ b/tests/GenerateTestCompares/SM.h @@ -0,0 +1,17 @@ +// SPDX-FileCopyrightText: 2021 Philipp Basler +// +// SPDX-License-Identifier: GPL-3.0-or-later +#include +#include +#include +class Compare_SM +{ +public: + using Matrix3D = std::vector>>; + using Matrix2D = std::vector>; + Compare_SM(); + Matrix3D CheckTripleCT; + Matrix3D CheckTripleCW; + Matrix3D CheckTripleTree; + std::map EWPTPerSetting; +}; diff --git a/tests/benchmarks/CMakeLists.txt b/tests/benchmarks/CMakeLists.txt index 68edf9fa..457d48b1 100644 --- a/tests/benchmarks/CMakeLists.txt +++ b/tests/benchmarks/CMakeLists.txt @@ -1,30 +1,29 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later - find_package(benchmark QUIET) if(benchmark_FOUND) -set(TESTDIR ${CMAKE_CURRENT_SOURCE_DIR}) + set(TESTDIR ${CMAKE_CURRENT_SOURCE_DIR}) -set(SOURCE_FILES - benchmark-ewpt-c2hdm.cpp) + set(SOURCE_FILES benchmark-ewpt-c2hdm.cpp) -if(BSMPTCompileBaryo) - set(SOURCE_FILES - ${SOURCE_FILES} - benchmark-ewbg-c2hdm.cpp) -endif() -add_executable(benchmarks ${SOURCE_FILES}) -target_link_libraries(benchmarks Minimizer Models Utility TestCompares ThermalFunctions) -target_link_libraries(benchmarks benchmark::benchmark) -target_compile_features(benchmarks PUBLIC cxx_std_14) + if(BSMPTCompileBaryo) + set(SOURCE_FILES ${SOURCE_FILES} benchmark-ewbg-c2hdm.cpp) + endif() + add_executable(benchmarks ${SOURCE_FILES}) + target_link_libraries(benchmarks Minimizer Models Utility TestCompares + ThermalFunctions) + target_link_libraries(benchmarks benchmark::benchmark) + target_compile_features(benchmarks PUBLIC cxx_std_17) -if(BSMPTCompileBaryo) - target_link_libraries(benchmarks Baryo) -endif(BSMPTCompileBaryo) + if(BSMPTCompileBaryo) + target_link_libraries(benchmarks Baryo) + endif(BSMPTCompileBaryo) else() - message(WARNING "Did not find google benchmark. Benchmarks will not be compiled.") + message( + WARNING "Did not find google benchmark. Benchmarks will not be compiled.") endif() diff --git a/tests/benchmarks/benchmark-ewbg-c2hdm.cpp b/tests/benchmarks/benchmark-ewbg-c2hdm.cpp index 5fde0335..933c1b3d 100644 --- a/tests/benchmarks/benchmark-ewbg-c2hdm.cpp +++ b/tests/benchmarks/benchmark-ewbg-c2hdm.cpp @@ -40,40 +40,40 @@ void CompareValues(T expected, T result, double epsilon, double threshold) } } // namespace - -static void BM_EWBG(benchmark::State& state) +static void BM_EWBG(benchmark::State &state) { - using namespace BSMPT; - std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); - modelPointer->initModel(example_point_C2HDM); + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); + modelPointer->initModel(example_point_C2HDM); - const auto WhichMin = Minimizer::WhichMinimizerDefault; + const auto WhichMin = Minimizer::WhichMinimizerDefault; - const auto EWPT = Expected.EWPTPerSetting.at(WhichMin); + const auto EWPT = Expected.EWPTPerSetting.at(WhichMin); - std::vector vevsymmetricSolution, checksym, startpoint; - for (const auto &el : EWPT.EWMinimum) - startpoint.push_back(0.5 * el); - vevsymmetricSolution = Minimizer::Minimize_gen_all( - modelPointer, EWPT.Tc + 1, checksym, startpoint, WhichMin, true); - auto min_expected = Expected.vevSymmetricPerSetting.at(WhichMin); + std::vector vevsymmetricSolution, checksym, startpoint; + for (const auto &el : EWPT.EWMinimum) + startpoint.push_back(0.5 * el); + vevsymmetricSolution = Minimizer::Minimize_gen_all( + modelPointer, EWPT.Tc + 1, checksym, startpoint, WhichMin, true); + auto min_expected = Expected.vevSymmetricPerSetting.at(WhichMin); - auto config = - std::pair, int>{std::vector(5, true), 1}; - const double testVW = Expected.testVW; + auto config = + std::pair, int>{std::vector(5, true), 1}; + const double testVW = Expected.testVW; - for(auto _ : state) - { - Baryo::CalculateEtaInterface benchmarkEtaInterface(config); - auto result = benchmarkEtaInterface.CalcEta(testVW, - EWPT.EWMinimum, - vevsymmetricSolution, - EWPT.Tc, - modelPointer, - WhichMin); - (void)result; - } + for (auto _ : state) + { + Baryo::CalculateEtaInterface benchmarkEtaInterface(config, SMConstants); + auto result = benchmarkEtaInterface.CalcEta(testVW, + EWPT.EWMinimum, + vevsymmetricSolution, + EWPT.Tc, + modelPointer, + WhichMin); + (void)result; + } } BENCHMARK(BM_EWBG)->Repetitions(5); diff --git a/tests/benchmarks/benchmark-ewpt-c2hdm.cpp b/tests/benchmarks/benchmark-ewpt-c2hdm.cpp index 3d57e73b..e4049de0 100644 --- a/tests/benchmarks/benchmark-ewpt-c2hdm.cpp +++ b/tests/benchmarks/benchmark-ewpt-c2hdm.cpp @@ -3,7 +3,6 @@ // // SPDX-License-Identifier: GPL-3.0-or-later - #include #include @@ -26,43 +25,41 @@ const std::vector example_point_C2HDM{/* lambda_1 = */ 3.29771, /* Yukawa Type = */ 1}; } -static void BM_NLOVEV(benchmark::State& state) +static void BM_NLOVEV(benchmark::State &state) { - using namespace BSMPT; - std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); - modelPointer->initModel(example_point_C2HDM); - for(auto _ : state) - { - std::vector Check; - auto result = Minimizer::Minimize_gen_all(modelPointer, - 0, - Check, - modelPointer->get_vevTreeMin(), - Minimizer::WhichMinimizerDefault); - (void)result; - } + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); + modelPointer->initModel(example_point_C2HDM); + for (auto _ : state) + { + std::vector Check; + auto result = Minimizer::Minimize_gen_all(modelPointer, + 0, + Check, + modelPointer->get_vevTreeMin(), + Minimizer::WhichMinimizerDefault); + (void)result; + } } - -static void BM_EWPT(benchmark::State& state) +static void BM_EWPT(benchmark::State &state) { - using namespace BSMPT; - std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); - modelPointer->initModel(example_point_C2HDM); - for(auto _ : state) - { - std::vector Check; - auto result = Minimizer::PTFinder_gen_all( - modelPointer, 0, 300, Minimizer::WhichMinimizerDefault); - (void)result; - } + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); + modelPointer->initModel(example_point_C2HDM); + for (auto _ : state) + { + std::vector Check; + auto result = Minimizer::PTFinder_gen_all( + modelPointer, 0, 300, Minimizer::WhichMinimizerDefault); + (void)result; + } } - BENCHMARK(BM_NLOVEV); BENCHMARK(BM_EWPT)->Repetitions(5); BENCHMARK_MAIN(); - - diff --git a/tests/catcheventlistener/CMakeLists.txt b/tests/catcheventlistener/CMakeLists.txt index 1304fdbb..5e2c9bc2 100644 --- a/tests/catcheventlistener/CMakeLists.txt +++ b/tests/catcheventlistener/CMakeLists.txt @@ -1,4 +1,5 @@ add_library(CatchEventListener catcheventlistener.cpp) target_link_libraries(CatchEventListener PRIVATE Utility Catch2::Catch2WithMain) -target_include_directories(CatchEventListener INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}) -target_compile_features(CatchEventListener PUBLIC cxx_std_14) +target_include_directories(CatchEventListener + INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}) +target_compile_features(CatchEventListener PUBLIC cxx_std_17) diff --git a/tests/unittests/CMakeLists.txt b/tests/unittests/CMakeLists.txt index 17087359..0b380fa1 100644 --- a/tests/unittests/CMakeLists.txt +++ b/tests/unittests/CMakeLists.txt @@ -1,16 +1,27 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later - set(TESTDIR ${CMAKE_CURRENT_SOURCE_DIR}) - file(GLOB SOURCE_FILES "Test-*.cpp" CONFIURE_DEPENDS) add_executable(GenericTests ${SOURCE_FILES}) -target_link_libraries(GenericTests PRIVATE - Catch2::Catch2WithMain CatchEventListener Minimizer Models Utility TestCompares ThermalFunctions) -target_compile_features(GenericTests PUBLIC cxx_std_14) +target_link_libraries( + GenericTests + PRIVATE GSL::gsl + Catch2::Catch2WithMain + CatchEventListener + Minimizer + MinimumTracer + Models + Utility + TestCompares + ThermalFunctions + BounceSolution + TransitionTracer + GW) +target_compile_features(GenericTests PUBLIC cxx_std_17) include(Catch) catch_discover_tests(GenericTests) @@ -18,6 +29,3 @@ catch_discover_tests(GenericTests) if(BSMPTCompileBaryo) add_subdirectory(baryotests) endif(BSMPTCompileBaryo) - - - diff --git a/tests/unittests/Test-c2hdm.cpp b/tests/unittests/Test-c2hdm.cpp index 78a8e301..28fe2540 100644 --- a/tests/unittests/Test-c2hdm.cpp +++ b/tests/unittests/Test-c2hdm.cpp @@ -31,8 +31,9 @@ using Approx = Catch::Approx; TEST_CASE("Checking NLOVEV for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); std::vector Check; auto sol = Minimizer::Minimize_gen_all(modelPointer, @@ -51,8 +52,9 @@ TEST_CASE("Checking NLOVEV for C2HDM", "[c2hdm]") TEST_CASE("Checking EWPT for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); std::vector Check; auto EWPT = Minimizer::PTFinder_gen_all( @@ -90,8 +92,9 @@ TEST_CASE("Checking EWPT for C2HDM", "[c2hdm]") TEST_CASE("Checking number of CT parameters for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckNumberOfCTParameters(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -100,8 +103,9 @@ TEST_CASE("Checking number of CT parameters for C2HDM", "[c2hdm]") TEST_CASE("Checking number of VEV labels for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckNumberOfVEVLabels(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -112,8 +116,9 @@ TEST_CASE( "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckLegendTemp(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -122,8 +127,9 @@ TEST_CASE( TEST_CASE("Checking number of triple Higgs couplings for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckNumberOfTripleCouplings(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -132,8 +138,9 @@ TEST_CASE("Checking number of triple Higgs couplings for C2HDM", "[c2hdm]") TEST_CASE("Checking Gauge Boson masses for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckGaugeBosonMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -142,8 +149,9 @@ TEST_CASE("Checking Gauge Boson masses for C2HDM", "[c2hdm]") TEST_CASE("Checking fermion and quark masses masses for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckFermionicMasses(*modelPointer); REQUIRE(result.first == ModelTests::TestResults::Pass); @@ -153,8 +161,9 @@ TEST_CASE("Checking fermion and quark masses masses for C2HDM", "[c2hdm]") TEST_CASE("Checking tree level minimum for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckTreeLevelMin(*modelPointer, Minimizer::WhichMinimizerDefault); @@ -164,8 +173,9 @@ TEST_CASE("Checking tree level minimum for C2HDM", "[c2hdm]") TEST_CASE("Checking tree level tadpoles for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckTadpoleRelations(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -174,8 +184,9 @@ TEST_CASE("Checking tree level tadpoles for C2HDM", "[c2hdm]") TEST_CASE("Checking NLO masses matching tree level masses for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckNLOMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -184,8 +195,9 @@ TEST_CASE("Checking NLO masses matching tree level masses for C2HDM", "[c2hdm]") TEST_CASE("Checking VTreeSimplified for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); if (modelPointer->UseVTreeSimplified) { modelPointer->initModel(example_point_C2HDM); @@ -201,8 +213,9 @@ TEST_CASE("Checking VTreeSimplified for C2HDM", "[c2hdm]") TEST_CASE("Checking VCounterSimplified for C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); if (modelPointer->UseVCounterSimplified) { modelPointer->initModel(example_point_C2HDM); @@ -219,8 +232,9 @@ TEST_CASE("Checking first derivative of the sum of CT and CW in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckCTConditionsFirstDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -230,8 +244,9 @@ TEST_CASE("Checking second derivative of the sum of CT and CW in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckCTConditionsSecondDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -241,8 +256,9 @@ TEST_CASE("Checking the identities required to vanish for the CT in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); auto result = ModelTests::CheckCTIdentities(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -252,13 +268,15 @@ TEST_CASE("Checking triple higgs NLO couplings in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); modelPointer->Prepare_Triple(); modelPointer->TripleHiggsCouplings(); - auto Check = [](auto result, auto expected) { + auto Check = [](auto result, auto expected) + { if (std::abs(expected) > 1e-4) { REQUIRE(result == Approx(expected).epsilon(1e-4)); @@ -305,8 +323,9 @@ TEST_CASE("Checking triple higgs NLO couplings in the C2HDM", "[c2hdm]") TEST_CASE("Check number of calculated CT parameters in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckCTNumber(*modelPointer)); @@ -316,8 +335,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lij in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -329,8 +349,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijk in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -342,8 +363,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijkl in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -355,8 +377,9 @@ TEST_CASE("Check symmetric properties of the gauge tensor in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -368,8 +391,9 @@ TEST_CASE("Check symmetric properties of the Lepton tensor in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -381,8 +405,9 @@ TEST_CASE("Check symmetric properties of the mass Lepton tensor in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -394,8 +419,9 @@ TEST_CASE("Check symmetric properties of the mass quark tensor in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -407,8 +433,9 @@ TEST_CASE("Check symmetric properties of the quark tensor in the C2HDM", "[c2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); REQUIRE(ModelTests::TestResults::Pass == diff --git a/tests/unittests/Test-cpinthedark.cpp b/tests/unittests/Test-cpinthedark.cpp index 2caf631b..6ef8e0ef 100644 --- a/tests/unittests/Test-cpinthedark.cpp +++ b/tests/unittests/Test-cpinthedark.cpp @@ -36,8 +36,9 @@ const Compare_CPINTHEDARK Expected; TEST_CASE("Checking NLOVEV for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); std::vector Check; auto sol = Minimizer::Minimize_gen_all(modelPointer, @@ -56,8 +57,9 @@ TEST_CASE("Checking NLOVEV for CPINTHEDARK", "[cpinthedark]") TEST_CASE("Checking EWPT for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); std::vector Check; auto EWPT = Minimizer::PTFinder_gen_all( @@ -95,8 +97,9 @@ TEST_CASE("Checking EWPT for CPINTHEDARK", "[cpinthedark]") TEST_CASE("Checking number of CT parameters for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckNumberOfCTParameters(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -105,8 +108,9 @@ TEST_CASE("Checking number of CT parameters for CPINTHEDARK", "[cpinthedark]") TEST_CASE("Checking number of VEV labels for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckNumberOfVEVLabels(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -117,8 +121,9 @@ TEST_CASE("Checking number of labels for temperature dependend results for " "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckLegendTemp(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -128,8 +133,9 @@ TEST_CASE("Checking number of triple Higgs couplings for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckNumberOfTripleCouplings(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -138,8 +144,9 @@ TEST_CASE("Checking number of triple Higgs couplings for CPINTHEDARK", TEST_CASE("Checking Gauge Boson masses for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckGaugeBosonMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -149,8 +156,9 @@ TEST_CASE("Checking fermion and quark masses masses for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckFermionicMasses(*modelPointer); REQUIRE(result.first == ModelTests::TestResults::Pass); @@ -160,8 +168,9 @@ TEST_CASE("Checking fermion and quark masses masses for CPINTHEDARK", TEST_CASE("Checking tree level minimum for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckTreeLevelMin(*modelPointer, Minimizer::WhichMinimizerDefault); @@ -171,8 +180,9 @@ TEST_CASE("Checking tree level minimum for CPINTHEDARK", "[cpinthedark]") TEST_CASE("Checking tree level tadpoles for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckTadpoleRelations(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -182,8 +192,9 @@ TEST_CASE("Checking NLO masses matching tree level masses for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckNLOMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -192,8 +203,9 @@ TEST_CASE("Checking NLO masses matching tree level masses for CPINTHEDARK", TEST_CASE("Checking VTreeSimplified for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); if (modelPointer->UseVTreeSimplified) { modelPointer->initModel(example_point_CPINTHEDARK); @@ -209,8 +221,9 @@ TEST_CASE("Checking VTreeSimplified for CPINTHEDARK", "[cpinthedark]") TEST_CASE("Checking VCounterSimplified for CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); if (modelPointer->UseVCounterSimplified) { modelPointer->initModel(example_point_CPINTHEDARK); @@ -228,8 +241,9 @@ TEST_CASE( "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckCTConditionsFirstDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -240,8 +254,9 @@ TEST_CASE( "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckCTConditionsSecondDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -252,8 +267,9 @@ TEST_CASE( "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); auto result = ModelTests::CheckCTIdentities(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -264,13 +280,15 @@ TEST_CASE("Checking triple higgs NLO couplings in the CPINTHEDARK", { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); modelPointer->Prepare_Triple(); modelPointer->TripleHiggsCouplings(); - auto Check = [](auto result, auto expected) { + auto Check = [](auto result, auto expected) + { if (std::abs(expected) > 1e-4) { REQUIRE(result == Approx(expected).epsilon(1e-4)); @@ -318,8 +336,9 @@ TEST_CASE("Check number of calculated CT parameters in the CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckCTNumber(*modelPointer)); @@ -330,8 +349,9 @@ TEST_CASE( "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == @@ -344,8 +364,9 @@ TEST_CASE( "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == @@ -358,8 +379,9 @@ TEST_CASE( "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == @@ -371,8 +393,9 @@ TEST_CASE("Check symmetric properties of the gauge tensor in the CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == @@ -384,8 +407,9 @@ TEST_CASE("Check symmetric properties of the Lepton tensor in the CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == @@ -398,8 +422,9 @@ TEST_CASE( "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == @@ -412,8 +437,9 @@ TEST_CASE( "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == @@ -425,8 +451,9 @@ TEST_CASE("Check symmetric properties of the quark tensor in the CPINTHEDARK", "[cpinthedark]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK); + ModelID::FChoose(ModelID::ModelIDs::CPINTHEDARK, SMConstants); modelPointer->initModel(example_point_CPINTHEDARK); REQUIRE(ModelTests::TestResults::Pass == diff --git a/tests/unittests/Test-cxsm.cpp b/tests/unittests/Test-cxsm.cpp index 3fcaff02..302065eb 100644 --- a/tests/unittests/Test-cxsm.cpp +++ b/tests/unittests/Test-cxsm.cpp @@ -35,8 +35,9 @@ const Compare_CXSM Expected; TEST_CASE("Checking NLOVEV for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); std::vector Check; auto sol = Minimizer::Minimize_gen_all(modelPointer, @@ -59,8 +60,9 @@ TEST_CASE("Checking NLOVEV for CXSM", "[CXSM]") TEST_CASE("Checking EWPT for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); std::vector Check; auto EWPT = Minimizer::PTFinder_gen_all( @@ -98,8 +100,9 @@ TEST_CASE("Checking EWPT for CXSM", "[CXSM]") TEST_CASE("Checking number of CT parameters for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckNumberOfCTParameters(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -108,8 +111,9 @@ TEST_CASE("Checking number of CT parameters for CXSM", "[CXSM]") TEST_CASE("Checking number of VEV labels for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckNumberOfVEVLabels(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -120,8 +124,9 @@ TEST_CASE( "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckLegendTemp(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -130,8 +135,9 @@ TEST_CASE( TEST_CASE("Checking number of triple Higgs couplings for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckNumberOfTripleCouplings(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -140,8 +146,9 @@ TEST_CASE("Checking number of triple Higgs couplings for CXSM", "[CXSM]") TEST_CASE("Checking Gauge Boson masses for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckGaugeBosonMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -150,8 +157,9 @@ TEST_CASE("Checking Gauge Boson masses for CXSM", "[CXSM]") TEST_CASE("Checking fermion and quark masses masses for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckFermionicMasses(*modelPointer); REQUIRE(result.first == ModelTests::TestResults::Pass); @@ -161,8 +169,9 @@ TEST_CASE("Checking fermion and quark masses masses for CXSM", "[CXSM]") TEST_CASE("Checking tree level minimum for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckTreeLevelMin(*modelPointer, Minimizer::WhichMinimizerDefault); @@ -172,8 +181,9 @@ TEST_CASE("Checking tree level minimum for CXSM", "[CXSM]") TEST_CASE("Checking tree level tadpoles for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckTadpoleRelations(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -182,8 +192,9 @@ TEST_CASE("Checking tree level tadpoles for CXSM", "[CXSM]") TEST_CASE("Checking NLO masses matching tree level masses for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckNLOMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -192,8 +203,9 @@ TEST_CASE("Checking NLO masses matching tree level masses for CXSM", "[CXSM]") TEST_CASE("Checking VTreeSimplified for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); if (modelPointer->UseVTreeSimplified) { modelPointer->initModel(example_point_CXSM); @@ -209,8 +221,9 @@ TEST_CASE("Checking VTreeSimplified for CXSM", "[CXSM]") TEST_CASE("Checking VCounterSimplified for CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); if (modelPointer->UseVCounterSimplified) { modelPointer->initModel(example_point_CXSM); @@ -227,8 +240,9 @@ TEST_CASE("Checking first derivative of the sum of CT and CW in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckCTConditionsFirstDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -238,8 +252,9 @@ TEST_CASE("Checking second derivative of the sum of CT and CW in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckCTConditionsSecondDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -249,8 +264,9 @@ TEST_CASE("Checking the identities required to vanish for the CT in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); auto result = ModelTests::CheckCTIdentities(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -260,13 +276,15 @@ TEST_CASE("Checking triple higgs NLO couplings in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); modelPointer->Prepare_Triple(); modelPointer->TripleHiggsCouplings(); - auto Check = [](auto result, auto expected) { + auto Check = [](auto result, auto expected) + { if (expected != 0) { REQUIRE(result == Approx(expected).epsilon(1e-4)); @@ -301,8 +319,9 @@ TEST_CASE("Checking triple higgs NLO couplings in the CXSM", "[CXSM]") TEST_CASE("Check number of calculated CT parameters in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckCTNumber(*modelPointer)); @@ -312,8 +331,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lij in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == @@ -325,8 +345,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijk in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == @@ -338,8 +359,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijkl in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == @@ -351,8 +373,9 @@ TEST_CASE("Check symmetric properties of the gauge tensor in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == @@ -364,8 +387,9 @@ TEST_CASE("Check symmetric properties of the Lepton tensor in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == @@ -377,8 +401,9 @@ TEST_CASE("Check symmetric properties of the mass Lepton tensor in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == @@ -390,8 +415,9 @@ TEST_CASE("Check symmetric properties of the mass quark tensor in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == @@ -403,8 +429,9 @@ TEST_CASE("Check symmetric properties of the quark tensor in the CXSM", "[CXSM]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::CXSM); + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); modelPointer->initModel(example_point_CXSM); REQUIRE(ModelTests::TestResults::Pass == diff --git a/tests/unittests/Test-general.cpp b/tests/unittests/Test-general.cpp index 04a41e2a..0c4e033d 100644 --- a/tests/unittests/Test-general.cpp +++ b/tests/unittests/Test-general.cpp @@ -10,11 +10,13 @@ using Approx = Catch::Approx; #include #include +#include TEST_CASE("Checking CKM Unitarity", "[general]") { using namespace BSMPT; - REQUIRE(ModelTests::CheckCKMUnitarity() == ModelTests::TestResults::Pass); + REQUIRE(ModelTests::CheckCKMUnitarity(GetSMConstants()) == + ModelTests::TestResults::Pass); } TEST_CASE("Check get model", "[general]") diff --git a/tests/unittests/Test-gw.cpp b/tests/unittests/Test-gw.cpp new file mode 100644 index 00000000..83292683 --- /dev/null +++ b/tests/unittests/Test-gw.cpp @@ -0,0 +1,1426 @@ +// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui +// Santos, João Viana +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include + +using Approx = Catch::Approx; + +#include +#include +#include +#include +#include // for Class_Potential_Origin +#include +#include +#include +#include // for Logger Class +#include +#include + +TEST_CASE("Test GetStatusEWSR", "[gw]") +{ + // Tests bounce solver with analytical derivative + using namespace BSMPT; + + MinimumTracer MinTracer; + REQUIRE(MinTracer.GetStatusEWSR(3) == StatusEWSR::EWSymRes); + REQUIRE(MinTracer.GetStatusEWSR(2) == StatusEWSR::EWSymNonRes); + REQUIRE(MinTracer.GetStatusEWSR(1) == StatusEWSR::FlatRegion); + REQUIRE(MinTracer.GetStatusEWSR(0) == StatusEWSR::Failure); + REQUIRE(MinTracer.GetStatusEWSR(-1) == StatusEWSR::NotBFB); +} + +TEST_CASE("Test Create1DimGrid (point, k, low_value, high_value, nsteps)", + "[gw]") +{ + using namespace BSMPT; + + auto grid = Create1DimGrid({1, 3}, 0, 0, 2, 4); + std::vector> result = { + {0, 3}, {0.5, 3}, {1, 3}, {1.5, 3}, {2.0, 3.0}}; + + REQUIRE(grid == result); +} + +TEST_CASE("Test Create1DimGrid (min_start,min_end,npoints)", "[gw] ") +{ + using namespace BSMPT; + + auto grid = Create1DimGrid({0, 3}, {2, 3}, 4); + std::vector> result = { + {0, 3}, {0.5, 3}, {1, 3}, {1.5, 3}, {2.0, 3.0}}; + + REQUIRE(grid == result); +} + +TEST_CASE("Test almost_the_same", "[gw]") +{ + using namespace BSMPT; + + REQUIRE(almost_the_same({0, 1}, {0, 0.991}, false, 0.01, 1e-5)); + REQUIRE(not almost_the_same({0, 1}, {0, 1.02}, false, 0.01, 1e-5)); + REQUIRE(not almost_the_same({0, 1}, {0, 0.991}, false, 0.01, 0)); +} + +TEST_CASE("Test I_alpha", "[gw]") +{ + // Tests bounce solver with analytical derivative + using namespace BSMPT; + + BounceActionInt BACalc; + + REQUIRE(BACalc.BesselI(3, 1) == Approx(0.0221684249).epsilon(1e-8)); + REQUIRE(BACalc.BesselI(1, 3) == Approx(3.953370217).epsilon(1e-8)); + REQUIRE(BACalc.BesselI(1, 1.5) == Approx(0.9816664285779).epsilon(1e-8)); +} + +TEST_CASE("Test J_1", "[gw]") +{ + // Tests bounce solver with analytical derivative + using namespace BSMPT; + + BounceActionInt BACalc; + + REQUIRE(BACalc.BesselJ(1) == Approx(0.440050585744).epsilon(1e-8)); + REQUIRE(BACalc.BesselJ(3) == Approx(0.3390589585259).epsilon(1e-8)); + REQUIRE(BACalc.BesselJ(1.5) == Approx(0.5579365079).epsilon(1e-8)); +} + +TEST_CASE("Solve bounce equation with analytical derivative", "[gw]") +{ + // Tests bounce solver with analytical derivative + using namespace BSMPT; + std::function)> V = [&](std::vector x) + { + double c = 5; + double fx = 0; + double fy = 80; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return (r1 * r2 + r3); + }; + + std::function(std::vector)> dV = + [&](std::vector l0) + { + int dim = 2; + std::vector result(dim); + result = {2 * l0[0] * (5 * pow(-1 + l0[0], 2) + pow(-1 + l0[1], 2)) + + 10 * (-1 + l0[0]) * (pow(l0[0], 2) + 5 * pow(l0[1], 2)), + 10 * (5 * pow(-1 + l0[0], 2) + pow(-1 + l0[1], 2)) * l0[1] + + 2 * (-1 + l0[1]) * (pow(l0[0], 2) + 5 * pow(l0[1], 2)) + + 80 * (-1. * pow(l0[1], 2) + 1. * pow(l0[1], 3))}; + return result; + }; + + std::vector FalseVacuum = {0, 0}; + std::vector TrueVacuum = {1, 1}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, dV, 0, 6); + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(4.5011952256).epsilon(5e-2)); +} + +TEST_CASE( + "Solve bounce equation with analytical derivative and Alpha = 3 (T = 0)", + "[gw]") +{ + // Tests bounce solver with analytical derivative + using namespace BSMPT; + std::function)> V = [&](std::vector x) + { + double c = 5; + double fx = 0; + double fy = 80; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return (r1 * r2 + r3); + }; + + std::function(std::vector)> dV = + [&](std::vector l0) + { + int dim = 2; + std::vector result(dim); + result = {2 * l0[0] * (5 * pow(-1 + l0[0], 2) + pow(-1 + l0[1], 2)) + + 10 * (-1 + l0[0]) * (pow(l0[0], 2) + 5 * pow(l0[1], 2)), + 10 * (5 * pow(-1 + l0[0], 2) + pow(-1 + l0[1], 2)) * l0[1] + + 2 * (-1 + l0[1]) * (pow(l0[0], 2) + 5 * pow(l0[1], 2)) + + 80 * (-1. * pow(l0[1], 2) + 1. * pow(l0[1], 3))}; + return result; + }; + + std::vector FalseVacuum = {0, 0}; + std::vector TrueVacuum = {1, 1}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(13.3129767888).epsilon(5e-2)); +} + +TEST_CASE("Solve bounce equation with numerical derivative", "[gw]") +{ + // Tests bounce solver with numerical derivative + using namespace BSMPT; + + std::function)> V = [&](std::vector x) + { + double c = 5; + double fx = 0; + double fy = 80; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return (r1 * r2 + r3); + }; + + std::vector FalseVacuum = {0, 0}; + std::vector TrueVacuum = {1, 1}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(4.5011952256).epsilon(5e-2)); +} + +TEST_CASE("Solve bounce equation with numerical derivative and displaced " + "potential in VEV space", + "[gw]") +{ + // Tests bounce solver with numerical derivative and displaced potential in + // the VEV space + using namespace BSMPT; + + double disp_0 = 1; + double disp_1 = 1; + + std::function)> V = [&](std::vector x) + { + x[0] += disp_0; + x[1] += disp_1; + + double c = 5; + double fx = 0; + double fy = 80; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return (r1 * r2 + r3); + }; + + std::vector FalseVacuum = {0, 0}; + std::vector TrueVacuum = {1, 1}; + + FalseVacuum[0] -= disp_0; + FalseVacuum[1] -= disp_1; + + TrueVacuum[0] -= disp_0; + TrueVacuum[1] -= disp_1; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(4.5011952256).epsilon(5e-2)); +} + +TEST_CASE("Solve bounce equation with numerical derivative and displaced " + "potential in energy", + "[gw]") +{ + // Tests bounce solver with numerical derivative and displaced potential in + // the VEV space + using namespace BSMPT; + + double disp_V = 1; + + std::function)> V = [&](std::vector x) + { + double c = 5; + double fx = 0; + double fy = 80; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return ((r1 * r2 + r3) - disp_V); + }; + + std::vector FalseVacuum = {0, 0}; + std::vector TrueVacuum = {1, 1}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(4.5011952256).epsilon(5e-2)); +} + +TEST_CASE("Solve bounce equation with numerical derivative and displaced " + "potential in VEV space and in energy", + "[gw]") +{ + // Tests bounce solver with numerical derivative and displaced potential in + // the VEV space + using namespace BSMPT; + + double disp_0 = 1; + double disp_1 = 1; + double disp_V = 1; + + std::function)> V = [&](std::vector x) + { + x[0] += disp_0; + x[1] += disp_1; + + double c = 5; + double fx = 0; + double fy = 80; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return (r1 * r2 + r3) - disp_V; + }; + + std::vector FalseVacuum = {0, 0}; + std::vector TrueVacuum = {1, 1}; + + FalseVacuum[0] -= disp_0; + FalseVacuum[1] -= disp_1; + + TrueVacuum[0] -= disp_0; + TrueVacuum[1] -= disp_1; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(4.5011952256).epsilon(5e-2)); +} + +TEST_CASE("Solve bounce equation with numerical derivative thin walled", "[gw]") +{ + // Tests bounce solver with numerical derivative + using namespace BSMPT; + std::function)> V = [&](std::vector x) + { + double c = 5; + double fx = 0; + double fy = 2.; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return (r1 * r2 + r3); + }; + + std::vector FalseVacuum = {0, 0}; + std::vector TrueVacuum = {1, 1}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(1946.3823079011).epsilon(5e-2)); +} + +TEST_CASE("Catch if path if backwards on the bounce solver", "[gw]") +{ + // Tests bounce solver with numerical derivative + using namespace BSMPT; + std::function)> V = [&](std::vector x) + { + double c = 5; + double fx = 0; + double fy = 80.; + + double r1 = x[0] * x[0] + c * x[1] * x[1]; + double r2 = c * pow(x[0] - 1, 2) + pow(x[1] - 1, 2); + double r3 = fx * (0.25 * pow(x[0], 4) - pow(x[0], 3) / 3.); + r3 += fy * (0.25 * pow(x[1], 4) - pow(x[1], 3) / 3.); + + return (r1 * r2 + r3); + }; + + std::vector TrueVacuum = {0, 0}; + std::vector FalseVacuum = {1, 1}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + + bc.CalculateAction(); + + REQUIRE(BSMPT::BounceActionInt::ActionStatus::BackwardsPropagationFailed == + bc.StateOfBounceActionInt); +} + +TEST_CASE("Checking phase tracking for SM", "[gw]") +{ + const std::vector example_point_SM{ + /* muSq = */ -7823.7540500000005, + /* lambda = */ 0.12905349405143487}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, -1, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for BP1 - Mode auto", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.9309437685026, + /* lambda_2 = */ 0.26305141403285998, + /* lambda_3 = */ 1.2865950045595, + /* lambda_4 = */ 4.7721306931875001, + /* lambda_5 = */ 4.7275722046239004, + /* m_{12}^2 = */ 18933.440789693999, + /* tan(beta) = */ 16.577896825227999, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, -1, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for BP1 - Mode 0", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.9309437685026, + /* lambda_2 = */ 0.26305141403285998, + /* lambda_3 = */ 1.2865950045595, + /* lambda_4 = */ 4.7721306931875001, + /* lambda_5 = */ 4.7275722046239004, + /* m_{12}^2 = */ 18933.440789693999, + /* tan(beta) = */ 16.577896825227999, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 0, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for BP1 - Mode 1", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.9309437685026, + /* lambda_2 = */ 0.26305141403285998, + /* lambda_3 = */ 1.2865950045595, + /* lambda_4 = */ 4.7721306931875001, + /* lambda_5 = */ 4.7275722046239004, + /* m_{12}^2 = */ 18933.440789693999, + /* tan(beta) = */ 16.577896825227999, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 1, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} +TEST_CASE("Checking phase tracking for BP1 - Mode 2", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.9309437685026, + /* lambda_2 = */ 0.26305141403285998, + /* lambda_3 = */ 1.2865950045595, + /* lambda_4 = */ 4.7721306931875001, + /* lambda_5 = */ 4.7275722046239004, + /* m_{12}^2 = */ 18933.440789693999, + /* tan(beta) = */ 16.577896825227999, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 2, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for BP2 - Mode auto", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.8467197321288999, + /* lambda_2 = */ 0.25889890874393001, + /* lambda_3 = */ 1.4661775278406, + /* lambda_4 = */ 4.4975594646125998, + /* lambda_5 = */ 4.4503516057569996, + /* m_{12}^2 = */ 6629.9728323804002, + /* tan(beta) = */ 45.319927369307997, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, -1, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for BP2 - Mode 0", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.8467197321288999, + /* lambda_2 = */ 0.25889890874393001, + /* lambda_3 = */ 1.4661775278406, + /* lambda_4 = */ 4.4975594646125998, + /* lambda_5 = */ 4.4503516057569996, + /* m_{12}^2 = */ 6629.9728323804002, + /* tan(beta) = */ 45.319927369307997, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 0, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for BP2 - Mode 1", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.8467197321288999, + /* lambda_2 = */ 0.25889890874393001, + /* lambda_3 = */ 1.4661775278406, + /* lambda_4 = */ 4.4975594646125998, + /* lambda_5 = */ 4.4503516057569996, + /* m_{12}^2 = */ 6629.9728323804002, + /* tan(beta) = */ 45.319927369307997, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 0, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for BP2 - Mode 2", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.8467197321288999, + /* lambda_2 = */ 0.25889890874393001, + /* lambda_3 = */ 1.4661775278406, + /* lambda_4 = */ 4.4975594646125998, + /* lambda_5 = */ 4.4503516057569996, + /* m_{12}^2 = */ 6629.9728323804002, + /* tan(beta) = */ 45.319927369307997, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 0, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for BP3 with Mode 0", "[gw]") +{ + const std::vector example_point_CXSM{/* v = */ 245.34120667410863, + /* vs = */ 0, + /* va = */ 0, + /* msq = */ -15650, + /* lambda = */ 0.52, + /* delta2 = */ 0.55, + /* b2 = */ -8859, + /* d2 = */ 0.5, + /* Reb1 = */ 0, + /* Imb1 = */ 0, + /* Rea1 = */ 0, + /* Ima1 = */ 0}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); + modelPointer->initModel(example_point_CXSM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 0, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for SM with Mode 1", "[gw]") +{ + const std::vector example_point_SM{ + /* muSq = */ -7823.7540500000005, + /* lambda = */ 0.12905349405143487}; + + using namespace BSMPT; + // Check the ASCIIPlotter + SetLogger({"--logginglevel::mintracerdetailed=true"}); + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 1, 10, true); + SetLogger({"--logginglevel::mintracerdetailed=false"}); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking for SM with Mode 2", "[gw]") +{ + const std::vector example_point_SM{ + /* muSq = */ -7823.7540500000005, + /* lambda = */ 0.12905349405143487}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + Vacuum vac(0, 300, MinTracer, modelPointer, 2, 10, true); + + REQUIRE(vac.PhasesList.size() == 2); +} + +TEST_CASE("Checking phase tracking and GW for BP3", "[gw]") +{ + const std::vector example_point_CXSM{/* v = */ 245.34120667410863, + /* vs = */ 0, + /* va = */ 0, + /* msq = */ -15650, + /* lambda = */ 0.52, + /* delta2 = */ 0.55, + /* b2 = */ -8859, + /* d2 = */ 0.5, + /* Reb1 = */ 0, + /* Imb1 = */ 0, + /* Rea1 = */ 0, + /* Ima1 = */ 0}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); + modelPointer->initModel(example_point_CXSM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + + user_input input; + input.modelPointer = modelPointer; + input.gw_calculation = true; + TransitionTracer trans(input); + trans.ListBounceSolution.at(0).CalculatePercolationTemp(); + + auto output = trans.output_store; + + REQUIRE(126.0223716 == + Approx(output.vec_trans_data.at(0).crit_temp.value()).epsilon(1e-2)); + REQUIRE(121.0869527 == + Approx(output.vec_trans_data.at(0).nucl_approx_temp.value()) + .epsilon(1e-2)); + REQUIRE(121.212833 == + Approx(output.vec_trans_data.at(0).nucl_temp.value()).epsilon(1e-2)); + REQUIRE(120.7670659 == + Approx(output.vec_trans_data.at(0).perc_temp.value()).epsilon(1e-2)); + REQUIRE(120.7267244 == + Approx(output.vec_trans_data.at(0).compl_temp.value()).epsilon(1e-2)); + + REQUIRE(0.00537281 == + Approx(output.vec_gw_data.at(0).alpha.value()).epsilon(1e-2)); + REQUIRE(7658.8931 == + Approx(output.vec_gw_data.at(0).beta_over_H.value()).epsilon(1e-2)); + REQUIRE(4.40964e-05 == + Approx(output.vec_gw_data.at(0).K_sw.value()).epsilon(1e-2)); + REQUIRE(4.40964e-06 == + Approx(output.vec_gw_data.at(0).K_turb.value()).epsilon(1e-2)); + REQUIRE(0.0884755 == + Approx(output.vec_gw_data.at(0).fpeak_sw.value()).epsilon(1e-2)); + REQUIRE(0.269136 == + Approx(output.vec_gw_data.at(0).fpeak_turb.value()).epsilon(1e-2)); + REQUIRE(1.70812e-20 == + Approx(output.vec_gw_data.at(0).h2Omega_sw.value()).epsilon(1e-2)); + REQUIRE(3.69052e-16 == + Approx(output.vec_gw_data.at(0).h2Omega_turb.value()).epsilon(1e-2)); + REQUIRE(1.23742e-09 == + Approx(output.vec_gw_data.at(0).SNR_sw.value()).epsilon(5e-2)); + REQUIRE(1.28789e-20 == + Approx(output.vec_gw_data.at(0).SNR_turb.value()).epsilon(5e-2)); + REQUIRE(1.23742e-09 == + Approx(output.vec_gw_data.at(0).SNR.value()).epsilon(5e-2)); + + // Check different vwalls + trans.ListBounceSolution.at(0).UserDefined_vwall = -1; + trans.ListBounceSolution.at(0).CalculatePTStrength(); + REQUIRE(0.374931042806113 == + Approx(trans.ListBounceSolution.at(0).vwall).epsilon(1e-2)); + + trans.ListBounceSolution.at(0).UserDefined_vwall = -2; + trans.ListBounceSolution.at(0).CalculatePTStrength(); + REQUIRE(0.303761086384691 == + Approx(trans.ListBounceSolution.at(0).vwall).epsilon(1e-2)); +} + +TEST_CASE("Checking phase tracking and GW for BP3 (low sample)", "[gw]") +{ + const std::vector example_point_CXSM{/* v = */ 245.34120667410863, + /* vs = */ 0, + /* va = */ 0, + /* msq = */ -15650, + /* lambda = */ 0.52, + /* delta2 = */ 0.55, + /* b2 = */ -8859, + /* d2 = */ 0.5, + /* Reb1 = */ 0, + /* Imb1 = */ 0, + /* Rea1 = */ 0, + /* Ima1 = */ 0}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); + modelPointer->initModel(example_point_CXSM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + + user_input input; + input.modelPointer = modelPointer; + input.gw_calculation = true; + input.number_of_initial_scan_temperatures = 6; + TransitionTracer trans(input); + trans.ListBounceSolution.at(0).CalculatePercolationTemp(); + + auto output = trans.output_store; + + REQUIRE(126.0223716 == + Approx(output.vec_trans_data.at(0).crit_temp.value()).epsilon(1e-2)); + REQUIRE(121.0869527 == + Approx(output.vec_trans_data.at(0).nucl_approx_temp.value()) + .epsilon(1e-2)); + REQUIRE(121.212833 == + Approx(output.vec_trans_data.at(0).nucl_temp.value()).epsilon(1e-2)); + REQUIRE(120.7670659 == + Approx(output.vec_trans_data.at(0).perc_temp.value()).epsilon(1e-2)); + REQUIRE(120.7267244 == + Approx(output.vec_trans_data.at(0).compl_temp.value()).epsilon(1e-2)); + + REQUIRE(0.00537281 == + Approx(output.vec_gw_data.at(0).alpha.value()).epsilon(1e-2)); + REQUIRE(7658.8931 == + Approx(output.vec_gw_data.at(0).beta_over_H.value()).epsilon(1e-2)); + REQUIRE(4.40964e-05 == + Approx(output.vec_gw_data.at(0).K_sw.value()).epsilon(1e-2)); + REQUIRE(4.40964e-06 == + Approx(output.vec_gw_data.at(0).K_turb.value()).epsilon(1e-2)); + REQUIRE(0.0884755 == + Approx(output.vec_gw_data.at(0).fpeak_sw.value()).epsilon(1e-2)); + REQUIRE(0.269136 == + Approx(output.vec_gw_data.at(0).fpeak_turb.value()).epsilon(1e-2)); + REQUIRE(1.70812e-20 == + Approx(output.vec_gw_data.at(0).h2Omega_sw.value()).epsilon(1e-2)); + REQUIRE(3.69052e-16 == + Approx(output.vec_gw_data.at(0).h2Omega_turb.value()).epsilon(1e-2)); + REQUIRE(1.23742e-09 == + Approx(output.vec_gw_data.at(0).SNR_sw.value()).epsilon(5e-2)); + REQUIRE(1.28789e-20 == + Approx(output.vec_gw_data.at(0).SNR_turb.value()).epsilon(5e-2)); + REQUIRE(1.23742e-09 == + Approx(output.vec_gw_data.at(0).SNR.value()).epsilon(5e-2)); + + // Check different vwalls + trans.ListBounceSolution.at(0).UserDefined_vwall = -1; + trans.ListBounceSolution.at(0).CalculatePTStrength(); + REQUIRE(0.374931042806113 == + Approx(trans.ListBounceSolution.at(0).vwall).epsilon(1e-2)); + + trans.ListBounceSolution.at(0).UserDefined_vwall = -2; + trans.ListBounceSolution.at(0).CalculatePTStrength(); + REQUIRE(0.303761086384691 == + Approx(trans.ListBounceSolution.at(0).vwall).epsilon(1e-2)); +} + +TEST_CASE( + "Checking phase tracking and GW for BP3 (low sample) (suposed to fail)", + "[gw]") +{ + const std::vector example_point_CXSM{/* v = */ 245.34120667410863, + /* vs = */ 0, + /* va = */ 0, + /* msq = */ -15650, + /* lambda = */ 0.52, + /* delta2 = */ 0.55, + /* b2 = */ -8859, + /* d2 = */ 0.5, + /* Reb1 = */ 0, + /* Imb1 = */ 0, + /* Rea1 = */ 0, + /* Ima1 = */ 0}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); + modelPointer->initModel(example_point_CXSM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + + user_input input; + input.modelPointer = modelPointer; + input.gw_calculation = true; + + input.maxpathintegrations = 1; + TransitionTracer trans(input); + auto output = trans.output_store; + REQUIRE(trans.ListBounceSolution.at(0).status_bounce_sol == + StatusGW::Failure); + REQUIRE(126.0223716 == + Approx(output.vec_trans_data.at(0).crit_temp.value()).epsilon(1e-2)); + REQUIRE(not output.vec_trans_data.at(0).nucl_approx_temp.has_value()); + REQUIRE(not output.vec_trans_data.at(0).nucl_temp.has_value()); + REQUIRE(not output.vec_trans_data.at(0).perc_temp.has_value()); + REQUIRE(not output.vec_trans_data.at(0).compl_temp.has_value()); + REQUIRE(not output.vec_gw_data.at(0).alpha.has_value()); + REQUIRE(not output.vec_gw_data.at(0).beta_over_H.has_value()); + REQUIRE(not output.vec_gw_data.at(0).K_sw.has_value()); + REQUIRE(not output.vec_gw_data.at(0).K_turb.has_value()); + REQUIRE(not output.vec_gw_data.at(0).fpeak_sw.has_value()); + REQUIRE(not output.vec_gw_data.at(0).fpeak_turb.has_value()); + REQUIRE(not output.vec_gw_data.at(0).h2Omega_sw.has_value()); + REQUIRE(not output.vec_gw_data.at(0).h2Omega_turb.has_value()); + REQUIRE(not output.vec_gw_data.at(0).SNR_sw.has_value()); + REQUIRE(not output.vec_gw_data.at(0).SNR_turb.has_value()); + REQUIRE(not output.vec_gw_data.at(0).SNR.has_value()); +} + +TEST_CASE("Test for SO(3)", "[gw]") +{ + const std::vector example_point_CXSM{/* v = */ 10, + /* vs = */ 10, + /* va = */ 10, + /* msq = */ -100, + /* lambda = */ 0, + /* delta2 = */ 0, + /* b2 = */ -100, + /* d2 = */ 0, + /* Reb1 = */ 0, + /* Imb1 = */ 0, + /* Rea1 = */ 0, + /* Ima1 = */ 0}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); + modelPointer->initModel(example_point_CXSM); + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + MinTracer->FindFlatDirections(); + REQUIRE(MinTracer->flat_3D_dirs.size() == 1); +} + +TEST_CASE("Test for EW symmetry restoration BP1", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.9309437685026, + /* lambda_2 = */ 0.26305141403285998, + /* lambda_3 = */ 1.2865950045595, + /* lambda_4 = */ 4.7721306931875001, + /* lambda_5 = */ 4.7275722046239004, + /* m_{12}^2 = */ 18933.440789693999, + /* tan(beta) = */ 16.577896825227999, + /* Yukawa Type = */ 1}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + REQUIRE(MinTracer->IsThereEWSymmetryRestoration() == -1); +} + +TEST_CASE("Test for EW symmetry restoration BP2", "[gw]") +{ + const std::vector example_point_R2HDM{ + /* lambda_1 = */ 6.8467197321288999, + /* lambda_2 = */ 0.25889890874393001, + /* lambda_3 = */ 1.4661775278406, + /* lambda_4 = */ 4.4975594646125998, + /* lambda_5 = */ 4.4503516057569996, + /* m_{12}^2 = */ 6629.9728323804002, + /* tan(beta) = */ 45.319927369307997, + /* Yukawa Type = */ 1}; + using namespace BSMPT; + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); + modelPointer->initModel(example_point_R2HDM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + REQUIRE(MinTracer->IsThereEWSymmetryRestoration() == -1); +} + +TEST_CASE("Test for EW symmetry restoration BP3", "[gw]") +{ + const std::vector example_point_CXSM{/* v = */ 245.34120667410863, + /* vs = */ 0, + /* va = */ 0, + /* msq = */ -15650, + /* lambda = */ 0.52, + /* delta2 = */ 0.55, + /* b2 = */ -8859, + /* d2 = */ 0.5, + /* Reb1 = */ 0, + /* Imb1 = */ 0, + /* Rea1 = */ 0, + /* Ima1 = */ 0}; + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::CXSM, SMConstants); + modelPointer->initModel(example_point_CXSM); + + std::shared_ptr MinTracer( + new MinimumTracer(modelPointer, Minimizer::WhichMinimizerDefault, false)); + REQUIRE(MinTracer->IsThereEWSymmetryRestoration() == 3); +} + +TEST_CASE("Test string conversion of enums", "[gw]") +{ + using namespace BSMPT; + std::stringstream ss; + REQUIRE_NOTHROW( + ss << StatusNLOStability::NotSet << StatusNLOStability::Off + << StatusNLOStability::NoNLOStability << StatusNLOStability::Success + << StatusEWSR::EWSymNonRes << StatusEWSR::EWSymRes + << StatusEWSR::Failure << StatusEWSR::FlatRegion << StatusEWSR::NotBFB + << StatusEWSR::NotSet << StatusEWSR::Off << StatusTracing::Failure + << StatusTracing::NoCoverage << StatusTracing::NoGlobMinCoverage + << StatusTracing::NoGlobMinCoverage + << StatusTracing::NoMinsAtBoundaries << StatusTracing::NotSet + << StatusTracing::Success << StatusCoexPair::NoCoexPairs + << StatusCoexPair::NotSet << StatusCoexPair::Success + << StatusCrit::Failure << StatusCrit::FalseLower << StatusCrit::NotSet + << StatusCrit::Success << StatusCrit::TrueLower << StatusGW::Failure + << StatusGW::NotSet << StatusGW::Success << StatusTemperature::NaN + << StatusTemperature::NotMet << StatusTemperature::NotSet + << StatusTemperature::Success); +} + +TEST_CASE( + "Espinosa-Konstandin - Example A: Polynomial Vt - Phi0 = 0.99 (thin wall)", + "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 0.99; + std::function)> V = [&](std::vector x) + { + if (x[0] == 0) return 0.; + if (x[0] == 1) return -1.; + return x[0] * x[0] * + (2 * x[0] - 3 + + pow(1 - x[0], 2) * log((pow(1. - x[0], 2) * phi0 * phi0) / + (pow(1. - phi0, 2) * x[0] * x[0]))); + }; + + std::vector FalseVacuum = {0}; + std::vector TrueVacuum = {1}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == + Approx(-pow(M_PI, 2) / 3. * (phi0 + Li2(phi0 / (phi0 - 1)))) + .epsilon(1e-3)); +} + +TEST_CASE( + "Espinosa-Konstandin - Example A: Polynomial Vt - Phi0 = 0.5 (thick wall)", + "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 0.5; + std::function)> V = [&](std::vector x) + { + if (x[0] == 0) return 0.; + if (x[0] == 1) return -1.; + return x[0] * x[0] * + (2 * x[0] - 3 + + pow(1 - x[0], 2) * log((pow(1. - x[0], 2) * phi0 * phi0) / + (pow(1. - phi0, 2) * x[0] * x[0]))); + }; + + std::vector FalseVacuum = {0}; + std::vector TrueVacuum = {1 - 0.17}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == + Approx(-pow(M_PI, 2) / 3. * (phi0 + Li2(phi0 / (phi0 - 1)))) + .epsilon(1e-3)); +} + +TEST_CASE("Espinosa-Konstandin - Example B: Trigonometric tunneling potential " + "- Phi0 = 1.4 (thick wall)", + "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 1.4; + std::function)> V = [&](std::vector x) + { + if (x[0] == 0) return 0.; + x[0] = abs(x[0]); + return pow(sin(x[0]), 2) * (-1. + 2. / 3. * pow(cos(x[0]), 2) * + log(tan(phi0) / abs(tan(x[0])))); + }; + + std::vector FalseVacuum = {0}; + std::vector TrueVacuum = {1.54751}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == + Approx(pow(M_PI, 2) / 4. * + (pow(M_PI, 2) / 2. + 6 * pow(log(1. / tan(phi0)), 2) + + 3 * Li2(-pow(1. / tan(phi0), 2)))) + .epsilon(1e-3)); +} + +TEST_CASE("Espinosa-Konstandin - Example B: Trigonometric tunneling potential " + "- Phi0 = 1.54 (thin wall)", + "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 1.54; + std::function)> V = [&](std::vector x) + { + if (x[0] == 0) return 0.; + x[0] = abs(x[0]); + return pow(sin(x[0]), 2) * (-1. + 2. / 3. * pow(cos(x[0]), 2) * + log(tan(phi0) / abs(tan(x[0])))); + }; + + std::vector FalseVacuum = {0}; + std::vector TrueVacuum = {1.5666275}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == + Approx(pow(M_PI, 2) / 4. * + (pow(M_PI, 2) / 2. + 6 * pow(log(1. / tan(phi0)), 2) + + 3 * Li2(-pow(1. / tan(phi0), 2)))) + .epsilon(1e-3)); +} + +TEST_CASE("Espinosa-Konstandin - Example C: Finite mass " + "- Phi0 = 0.8", + "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 0.8; + double cut_off = 1.3; + + std::function)> V = [&](std::vector x) + { + if (x[0] < 0) x[0] = -x[0]; + if (x[0] > cut_off) x[0] = 2 * cut_off - x[0]; + if (x[0] == 0) x[0] = 1e-100; + + return pow(x[0], 2) / (-0.5 + log(x[0])) + + (8. * pow(x[0], 2) * pow(-1 + log(x[0]), 2) * + (2. * pow(log(x[0]), 2) - 2. * pow(log(phi0), 2) + + log((-1 + log(x[0])) / (-1 + log(phi0))))) / + (3. * pow(1. - 2. * log(x[0]), 4)); + }; + + std::vector FalseVacuum = {0}; + std::vector TrueVacuum = {cut_off}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(3.236736977787636).epsilon(1e-3)); +} + +TEST_CASE( + "Espinosa-Konstandin - Example D: Derivative of the tunneling potential " + "- Phi0 = 0.8", + "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 0.8; + double cut_off = 0.95; + + std::function)> V = [&](std::vector x) + { + if (x[0] < 0) x[0] = -x[0]; + if (x[0] > cut_off) x[0] = 2 * cut_off - x[0]; + + return gsl_sf_expint_Ei(2 * log(x[0] + 1e-100)) + + 1. / 6. * pow(x[0], 2) * (1. - pow(log(phi0) / log(x[0]), 2)); + }; + + std::vector FalseVacuum = {0}; + std::vector TrueVacuum = {cut_off}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(5.1968779132).epsilon(1e-3)); +} + +TEST_CASE("Espinosa-Konstandin - Example E: Finite mass with thin-wall limit " + "- Phi0 = 0.8", + "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 0.8; + double cut_off = 0.9; + + std::function)> V = [&](std::vector x) + { + if (x[0] < 0) x[0] = -x[0]; + if (x[0] > cut_off) x[0] = 2 * cut_off - x[0]; + if (x[0] == 0) x[0] = 1e-100; + + return exp(2) * gsl_sf_expint_Ei(-2 + 2 * log(x[0])) - + exp(3) * gsl_sf_expint_Ei(-3 + 3 * log(x[0])) + + (pow(-1 + x[0], 2) * pow(x[0], 2) * + (pow(log(x[0]), 2) - pow(log(phi0), 2) + + 2 * log(((-1 + x[0]) * phi0) / (x[0] * (-1 + phi0))) + + 2 * Li2(1 - x[0]) - 2 * Li2(1 - phi0))) / + (6. * pow(-1 + log(x[0]), 2)); + }; + + std::vector FalseVacuum = {0}; + std::vector TrueVacuum = {cut_off}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(37.878999).epsilon(1e-3)); +} + +TEST_CASE("Espinosa-Konstandin - Two-Field Examples", "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 0.999; + double alpha = 1 / 2.; + + std::function)> V = [&](std::vector x) + { + x[0] = x[0] + 1e-100; + x[1] = x[1] + 1e-100; + return -4.5 * (-2. + x[0]) * pow(1. + pow(x[0], 2) - 1. * pow(x[1], 2), 2) + + pow(EllipIntSecond(asinh(x[0])), 2) * + (-3 + 2 * EllipIntSecond(asinh(x[0])) + + pow(-1 + EllipIntSecond(asinh(x[0])), 2) * + log((pow(phi0, 2) * + pow(-1 + EllipIntSecond(asinh(x[0])), 2)) / + (pow(-1 + phi0, 2) * + pow(EllipIntSecond(asinh(x[0])), 2)))) + + ((-sqrt(1 + pow(x[0], 2)) + x[1]) * + (-1 + EllipIntSecond(asinh(x[0]))) * EllipIntSecond(asinh(x[0])) * + pow(1. / cosh(x[0] / alpha), 3) * + (4 * pow(EllipIntSecond(asinh(x[0])), 2) * + log((pow(phi0, 2) * pow(-1 + EllipIntSecond(asinh(x[0])), 2)) / + (pow(-1 + phi0, 2) * + pow(EllipIntSecond(asinh(x[0])), 2))) - + 4 * alpha * pow(cosh(x[0] / alpha), 2) * + (-4 + log((pow(phi0, 2) * + pow(-1 + EllipIntSecond(asinh(x[0])), 2)) / + (pow(-1 + phi0, 2) * + pow(EllipIntSecond(asinh(x[0])), 2)))) * + sinh(x[0] / alpha) + + 2 * EllipIntSecond(asinh(x[0])) * + log((pow(phi0, 2) * pow(-1 + EllipIntSecond(asinh(x[0])), 2)) / + (pow(-1 + phi0, 2) * + pow(EllipIntSecond(asinh(x[0])), 2))) * + (-2 + alpha * sinh(x[0] / alpha) + + alpha * sinh((3 * x[0]) / alpha)))) / + (2. * alpha); + }; + + std::vector FalseVacuum = {0., 1.}; + std::vector TrueVacuum = {0.9181398979435043, 1.3575643168526}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(80.59).epsilon(2e-2)); +} + +TEST_CASE("Espinosa-Konstandin - Three-Field Examples - rho = 1/6", "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 0.999; + double alpha = 1 / 2.; + double rho = 1 / 6.; + + std::function)> V = [&](std::vector x) + { + x[0] = x[0] + 1e-100; + x[1] = x[1] + 1e-100; + x[2] = x[2] + 1e-100; + if (x[0] == 0.5) x[0] -= 0.0000001; + return 25 * pow(x[2] - rho + + rho * cos((sqrt(1 - pow(alpha, 2)) * x[0]) / + (alpha * rho)), + 2) + + (pow(x[0], 2) * + (alpha * (-3 * alpha + 2 * x[0]) + + pow(alpha - x[0], 2) * log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2))))) / + pow(alpha, 4) + + 25 * pow(x[1] - rho * sin((sqrt(1 - pow(alpha, 2)) * x[0]) / + (alpha * rho)), + 2) + + (2 * (alpha - x[0]) * x[0] * + (x[1] - + rho * sin((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho))) * + (alpha * sqrt(1 - pow(alpha, 2)) * rho * + cos((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho)) * + (-4 * alpha + (alpha - 2 * x[0]) * + log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2)))) + + (-1 + pow(alpha, 2)) * (alpha - x[0]) * x[0] * + log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2))) * + sin((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho)))) / + (pow(alpha, 4) * rho) - + (2 * x[0] * (-alpha + x[0]) * + (x[2] - rho + + rho * cos((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho))) * + (-((-1 + pow(alpha, 2)) * (alpha - x[0]) * x[0] * + cos((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho)) * + log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2)))) + + alpha * sqrt(1 - pow(alpha, 2)) * rho * + (-4 * alpha + (alpha - 2 * x[0]) * + log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2)))) * + sin((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho)))) / + (pow(alpha, 4) * rho); + }; + + std::vector FalseVacuum = {0., 0., 0.}; + std::vector TrueVacuum = {0.500068, -0.147487, 0.0890438}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(80.59).epsilon(2e-2)); +} + +TEST_CASE("Espinosa-Konstandin - Three-Field Examples - rho = 1/8", "[gw]") +{ + // Espinosa-Konstandin examples from arXiv:2312.12360 + using namespace BSMPT; + double phi0 = 0.999; + double alpha = 1 / 2.; + double rho = 1 / 8.; + + std::function)> V = [&](std::vector x) + { + x[0] = x[0] + 1e-100; + x[1] = x[1] + 1e-100; + x[2] = x[2] + 1e-100; + if (x[0] == 0.5) x[0] -= 0.0000001; + return 25 * pow(x[2] - rho + + rho * cos((sqrt(1 - pow(alpha, 2)) * x[0]) / + (alpha * rho)), + 2) + + (pow(x[0], 2) * + (alpha * (-3 * alpha + 2 * x[0]) + + pow(alpha - x[0], 2) * log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2))))) / + pow(alpha, 4) + + 25 * pow(x[1] - rho * sin((sqrt(1 - pow(alpha, 2)) * x[0]) / + (alpha * rho)), + 2) + + (2 * (alpha - x[0]) * x[0] * + (x[1] - + rho * sin((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho))) * + (alpha * sqrt(1 - pow(alpha, 2)) * rho * + cos((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho)) * + (-4 * alpha + (alpha - 2 * x[0]) * + log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2)))) + + (-1 + pow(alpha, 2)) * (alpha - x[0]) * x[0] * + log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2))) * + sin((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho)))) / + (pow(alpha, 4) * rho) - + (2 * x[0] * (-alpha + x[0]) * + (x[2] - rho + + rho * cos((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho))) * + (-((-1 + pow(alpha, 2)) * (alpha - x[0]) * x[0] * + cos((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho)) * + log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2)))) + + alpha * sqrt(1 - pow(alpha, 2)) * rho * + (-4 * alpha + (alpha - 2 * x[0]) * + log((pow(phi0, 2) * pow(alpha - x[0], 2)) / + (pow(-1 + phi0, 2) * pow(x[0], 2)))) * + sin((sqrt(1 - pow(alpha, 2)) * x[0]) / (alpha * rho)))) / + (pow(alpha, 4) * rho); + }; + + std::vector FalseVacuum = {0., 0., 0.}; + std::vector TrueVacuum = {0.500068, 0.0752454, 0.0251845}; + + std::vector> path = {TrueVacuum, FalseVacuum}; + + BounceActionInt bc(path, TrueVacuum, FalseVacuum, V, 0, 6); + bc.Alpha = 3; + bc.CalculateAction(); + + REQUIRE(bc.Action == Approx(55.6).epsilon(2e-2)); +} diff --git a/tests/unittests/Test-rn2hdm.cpp b/tests/unittests/Test-n2hdm.cpp similarity index 68% rename from tests/unittests/Test-rn2hdm.cpp rename to tests/unittests/Test-n2hdm.cpp index 1f672919..e63e908b 100644 --- a/tests/unittests/Test-rn2hdm.cpp +++ b/tests/unittests/Test-n2hdm.cpp @@ -14,30 +14,31 @@ using Approx = Catch::Approx; #include #include -#include "RN2HDM.h" - -const std::vector example_point_RN2HDM{/* lambda_1 = */ 0.300812, - /* lambda_2 = */ 0.321809, - /* lambda_3 = */ -0.133425, - /* lambda_4 = */ 4.11105, - /* lambda_5 = */ -3.84178, - /* lambda_6 = */ 9.46329, - /* lambda_7 = */ -0.750455, - /* lambda_8 = */ 0.743982, - /* tan(beta) = */ 5.91129, - /* v_s = */ 293.035, - /* m_{12}^2 = */ 4842.28, - /* Yukawa Type = */ 1}; - -constexpr auto Model = BSMPT::ModelID::ModelIDs::RN2HDM; -const Compare_RN2HDM Expected; +#include "N2HDM.h" + +const std::vector example_point_N2HDM{/* lambda_1 = */ 0.300812, + /* lambda_2 = */ 0.321809, + /* lambda_3 = */ -0.133425, + /* lambda_4 = */ 4.11105, + /* lambda_5 = */ -3.84178, + /* lambda_6 = */ 9.46329, + /* lambda_7 = */ -0.750455, + /* lambda_8 = */ 0.743982, + /* tan(beta) = */ 5.91129, + /* v_s = */ 293.035, + /* m_{12}^2 = */ 4842.28, + /* Yukawa Type = */ 1}; + +constexpr auto Model = BSMPT::ModelID::ModelIDs::N2HDM; +const Compare_N2HDM Expected; TEST_CASE("Checking NLOVEV for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(Model); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(Model, SMConstants); + modelPointer->initModel(example_point_N2HDM); std::vector Check; auto sol = Minimizer::Minimize_gen_all(modelPointer, 0, @@ -55,9 +56,10 @@ TEST_CASE("Checking NLOVEV for N2HDM", "[n2hdm]") TEST_CASE("Checking EWPT for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(Model); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(Model, SMConstants); + modelPointer->initModel(example_point_N2HDM); std::vector Check; auto EWPT = Minimizer::PTFinder_gen_all( modelPointer, 0, 300, Minimizer::WhichMinimizerDefault); @@ -89,9 +91,10 @@ TEST_CASE("Checking EWPT for N2HDM", "[n2hdm]") TEST_CASE("Checking number of CT parameters for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckNumberOfCTParameters(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -99,9 +102,10 @@ TEST_CASE("Checking number of CT parameters for N2HDM", "[n2hdm]") TEST_CASE("Checking number of VEV labels for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckNumberOfVEVLabels(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -111,9 +115,10 @@ TEST_CASE( "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckLegendTemp(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -121,9 +126,10 @@ TEST_CASE( TEST_CASE("Checking number of triple Higgs couplings for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckNumberOfTripleCouplings(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -131,9 +137,10 @@ TEST_CASE("Checking number of triple Higgs couplings for N2HDM", "[n2hdm]") TEST_CASE("Checking Gauge Boson masses for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckGaugeBosonMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -141,9 +148,10 @@ TEST_CASE("Checking Gauge Boson masses for N2HDM", "[n2hdm]") TEST_CASE("Checking fermion and quark masses masses for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckFermionicMasses(*modelPointer); REQUIRE(result.first == ModelTests::TestResults::Pass); REQUIRE(result.second == ModelTests::TestResults::Pass); @@ -152,9 +160,10 @@ TEST_CASE("Checking fermion and quark masses masses for N2HDM", "[n2hdm]") TEST_CASE("Checking tree level minimum for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckTreeLevelMin(*modelPointer, Minimizer::WhichMinimizerDefault); REQUIRE(result == ModelTests::TestResults::Pass); @@ -163,9 +172,10 @@ TEST_CASE("Checking tree level minimum for N2HDM", "[n2hdm]") TEST_CASE("Checking tree level tadpoles for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckTadpoleRelations(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -173,9 +183,10 @@ TEST_CASE("Checking tree level tadpoles for N2HDM", "[n2hdm]") TEST_CASE("Checking NLO masses matching tree level masses for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckNLOMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -183,11 +194,12 @@ TEST_CASE("Checking NLO masses matching tree level masses for N2HDM", "[n2hdm]") TEST_CASE("Checking VTreeSimplified for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); if (modelPointer->UseVTreeSimplified) { - modelPointer->initModel(example_point_RN2HDM); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckVTreeSimplified(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -200,11 +212,12 @@ TEST_CASE("Checking VTreeSimplified for N2HDM", "[n2hdm]") TEST_CASE("Checking VCounterSimplified for N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); if (modelPointer->UseVCounterSimplified) { - modelPointer->initModel(example_point_RN2HDM); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckVCounterSimplified(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -218,9 +231,10 @@ TEST_CASE("Checking first derivative of the sum of CT and CW in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckCTConditionsFirstDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -229,9 +243,10 @@ TEST_CASE("Checking second derivative of the sum of CT and CW in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); auto result = ModelTests::CheckCTConditionsSecondDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); } @@ -240,13 +255,15 @@ TEST_CASE("Checking triple higgs NLO couplings in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); modelPointer->Prepare_Triple(); modelPointer->TripleHiggsCouplings(); - auto Check = [](auto result, auto expected) { + auto Check = [](auto result, auto expected) + { if (std::abs(expected) > 1e-4) { REQUIRE(result == Approx(expected).epsilon(1e-4)); @@ -278,9 +295,10 @@ TEST_CASE("Checking triple higgs NLO couplings in the N2HDM", "[n2hdm]") TEST_CASE("Check number of calculated CT parameters in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckCTNumber(*modelPointer)); } @@ -289,9 +307,10 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lij in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorScalarSecond( @@ -302,9 +321,10 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijk in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorScalarThird( @@ -315,9 +335,10 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijkl in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorScalarFourth( @@ -328,9 +349,10 @@ TEST_CASE("Check symmetric properties of the gauge tensor in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorGauge( @@ -341,9 +363,10 @@ TEST_CASE("Check symmetric properties of the Lepton tensor in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorLeptonsThird( @@ -354,9 +377,10 @@ TEST_CASE("Check symmetric properties of the mass Lepton tensor in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorLeptons( @@ -367,9 +391,10 @@ TEST_CASE("Check symmetric properties of the mass quark tensor in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorQuarks( @@ -380,9 +405,10 @@ TEST_CASE("Check symmetric properties of the quark tensor in the N2HDM", "[n2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorQuarksThird( diff --git a/tests/unittests/Test-origin.cpp b/tests/unittests/Test-origin.cpp index eb512506..40cef790 100644 --- a/tests/unittests/Test-origin.cpp +++ b/tests/unittests/Test-origin.cpp @@ -3,6 +3,10 @@ // // SPDX-License-Identifier: GPL-3.0-or-later +/** + * @file + */ + #include #include @@ -24,13 +28,58 @@ const std::vector example_point_C2HDM{/* lambda_1 = */ 3.29771, /* Re(m_{12}^2) = */ 2706.86, /* tan(beta) = */ 4.64487, /* Yukawa Type = */ 1}; + +} // namespace + +/** + * @test Check if the automatic Debye corrections match the SM one in the SM + * case. This should be y_t^2/4. + */ +TEST_CASE("Test Calculate Debye", "[origin]") +{ + + using namespace BSMPT; + ISMConstants SM; + SM.C_MassTop = 172; + SM.C_vev0 = 246; + + // This is not a legal point but just a dummy point to only have the top + // coupling in the Debye Contributions + const std::vector example_point_CXSM{/* vh = */ SM.C_vev0, + /* vs = */ 0, + /* va = */ 0, + /* ms = */ 41.67, + /* lambda = */ 0, + /* delta2 = */ 0, + /* b2 = */ 0, + /* d2 = */ 0, + /* Reb1 = */ 0, + /* Imb1 = */ 0, + /* Rea1 = */ 0, + /* Ima1 = */ 0}; + + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::CXSM, SM); + modelPointer->initModel(example_point_CXSM); + modelPointer->CalculateDebye(true); + auto debye = modelPointer->get_DebyeHiggs(); + + double topCoupling = SM.C_MassTop * std::sqrt(2) / SM.C_vev0; + double expected = std::pow(topCoupling, 2) / 4.0; + + auto calculated = debye.at(3).at(3); + + REQUIRE(calculated != 0); + + REQUIRE(calculated == Approx(expected).margin(1e-4)); } TEST_CASE("Check f_{abcd}", "[origin]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); modelPointer->resetScale(200); diff --git a/tests/unittests/Test-parser.cpp b/tests/unittests/Test-parser.cpp new file mode 100644 index 00000000..136a1877 --- /dev/null +++ b/tests/unittests/Test-parser.cpp @@ -0,0 +1,80 @@ +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include +#include +#include + +using Approx = Catch::Approx; + +TEST_CASE("Ask unexpected option", "[parser]") +{ + auto parser = BSMPT::parser(); + REQUIRE_THROWS_AS(parser.get_value("non existent"), BSMPT::parserException); +} + +TEST_CASE("Check bool input", "[parser]") +{ + auto parser = BSMPT::parser(); + std::string argName{"arg"}, argNameF{"arg2"}; + parser.add_argument(argName, "foo", true); + parser.add_argument(argNameF, "foo", true); + std::vector input; + input.emplace_back("--" + argName + "=True"); + input.emplace_back("--" + argNameF + "=foo"); + parser.add_input(input); + REQUIRE(parser.get_value(argName)); + REQUIRE_FALSE(parser.get_value(argNameF)); +} + +TEST_CASE("Set unexpected input", "[parser]") +{ + auto parser = BSMPT::parser(); + std::string argName{"ExampleArg"}; + std::vector input; + input.emplace_back("--" + argName + "=foo"); + REQUIRE_THROWS_AS(parser.add_input(input), BSMPT::parserException); +} + +TEST_CASE("Add argument and retrieve it", "[parser]") +{ + auto parser = BSMPT::parser(); + std::string argName{"ExampleArg"}; + parser.add_argument(argName, "some example description", false); + std::vector input; + input.emplace_back("--" + argName + "=foo"); + parser.add_input(input); + REQUIRE_NOTHROW(parser.get_value(argName)); +} + +TEST_CASE("Check for logger print", "[parser]") +{ + auto parser = BSMPT::parser(); + std::string argName{"ExampleArg"}; + std::string description{"Example description"}; + std::string header{"Some header"}; + parser.add_argument(argName, description, false); + parser.set_help_header(header); + std::stringstream ss; + BSMPT::Logger::SetOStream(ss); + parser.print_help(); + auto str = ss.str(); + CHECK(str.find(header) != std::string::npos); + CHECK(str.find(argName) != std::string::npos); + CHECK(str.find(description) != std::string::npos); + BSMPT::Logger::SetOStream(std::cout); +} + +TEST_CASE("Check for all required parameters", "[parser]") +{ + auto parser = BSMPT::parser(); + std::string argName{"ExampleArg"}; + std::string description{"Example description"}; + std::string header{"Some header"}; + parser.add_argument(argName, description, true); + REQUIRE_THROWS_AS(parser.check_required_parameters(), BSMPT::parserException); +} diff --git a/tests/unittests/Test-r2hdm.cpp b/tests/unittests/Test-r2hdm.cpp index f42b013e..0d9c18aa 100644 --- a/tests/unittests/Test-r2hdm.cpp +++ b/tests/unittests/Test-r2hdm.cpp @@ -10,6 +10,7 @@ using Approx = Catch::Approx; #include #include // for Class_Potential_Origin +#include #include #include @@ -26,11 +27,22 @@ const std::vector example_point_R2HDM{/* lambda_1 = */ 2.740595, /* tan(beta) = */ 4.63286, /* Yukawa Type = */ 1}; +const std::vector example_point_R2HDM_negTanBeta{ + /* lambda_1 = */ 2.740595, + /* lambda_2 = */ 0.242356, + /* lambda_3 = */ 5.534491, + /* lambda_4 = */ -2.585467, + /* lambda_5 = */ -2.225991, + /* m_{12}^2 = */ -7738.56, + /* tan(beta) = */ -4.63286, + /* Yukawa Type = */ 1}; + TEST_CASE("Checking NLOVEV for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); std::vector Check; auto sol = Minimizer::Minimize_gen_all(modelPointer, @@ -49,8 +61,9 @@ TEST_CASE("Checking NLOVEV for R2HDM", "[r2hdm]") TEST_CASE("Checking EWPT for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); std::vector Check; auto EWPT = Minimizer::PTFinder_gen_all( @@ -82,11 +95,52 @@ TEST_CASE("Checking EWPT for R2HDM", "[r2hdm]") } } +TEST_CASE("Checking sign of SinBeta for pos. TanBeta", "[r2hdm]") +{ + using namespace BSMPT; + using namespace Models; + const auto SMConstants = GetSMConstants(); + Class_Potential_R2HDM point(SMConstants); + point.set_gen(example_point_R2HDM); + REQUIRE(point.C_SinBeta >= 0); +} + +TEST_CASE("Checking sign of SinBeta for neg. TanBeta", "[r2hdm]") +{ + using namespace BSMPT; + using namespace Models; + const auto SMConstants = GetSMConstants(); + Class_Potential_R2HDM point(SMConstants); + point.set_gen(example_point_R2HDM_negTanBeta); + REQUIRE(point.C_SinBeta <= 0); +} + +TEST_CASE("Checking sign of CosBeta for pos. TanBeta", "[r2hdm]") +{ + using namespace BSMPT; + using namespace Models; + const auto SMConstants = GetSMConstants(); + Class_Potential_R2HDM point(SMConstants); + point.set_gen(example_point_R2HDM); + REQUIRE(point.C_CosBeta >= 0); +} + +TEST_CASE("Checking sign of CosBeta for neg. TanBeta", "[r2hdm]") +{ + using namespace BSMPT; + using namespace Models; + const auto SMConstants = GetSMConstants(); + Class_Potential_R2HDM point(SMConstants); + point.set_gen(example_point_R2HDM_negTanBeta); + REQUIRE(point.C_CosBeta >= 0); +} + TEST_CASE("Checking number of CT parameters for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckNumberOfCTParameters(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -95,8 +149,9 @@ TEST_CASE("Checking number of CT parameters for R2HDM", "[r2hdm]") TEST_CASE("Checking number of VEV labels for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckNumberOfVEVLabels(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -107,8 +162,9 @@ TEST_CASE( "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckLegendTemp(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -117,8 +173,9 @@ TEST_CASE( TEST_CASE("Checking number of triple Higgs couplings for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckNumberOfTripleCouplings(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -127,8 +184,9 @@ TEST_CASE("Checking number of triple Higgs couplings for R2HDM", "[r2hdm]") TEST_CASE("Checking Gauge Boson masses for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckGaugeBosonMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -137,8 +195,9 @@ TEST_CASE("Checking Gauge Boson masses for R2HDM", "[r2hdm]") TEST_CASE("Checking fermion and quark masses masses for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckFermionicMasses(*modelPointer); REQUIRE(result.first == ModelTests::TestResults::Pass); @@ -148,8 +207,9 @@ TEST_CASE("Checking fermion and quark masses masses for R2HDM", "[r2hdm]") TEST_CASE("Checking tree level minimum for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckTreeLevelMin(*modelPointer, Minimizer::WhichMinimizerDefault); @@ -159,8 +219,9 @@ TEST_CASE("Checking tree level minimum for R2HDM", "[r2hdm]") TEST_CASE("Checking tree level tadpoles for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckTadpoleRelations(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -169,8 +230,9 @@ TEST_CASE("Checking tree level tadpoles for R2HDM", "[r2hdm]") TEST_CASE("Checking NLO masses matching tree level masses for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckNLOMasses(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -179,8 +241,9 @@ TEST_CASE("Checking NLO masses matching tree level masses for R2HDM", "[r2hdm]") TEST_CASE("Checking VTreeSimplified for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); if (modelPointer->UseVTreeSimplified) { modelPointer->initModel(example_point_R2HDM); @@ -196,8 +259,9 @@ TEST_CASE("Checking VTreeSimplified for R2HDM", "[r2hdm]") TEST_CASE("Checking VCounterSimplified for R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); if (modelPointer->UseVCounterSimplified) { modelPointer->initModel(example_point_R2HDM); @@ -214,8 +278,9 @@ TEST_CASE("Checking first derivative of the sum of CT and CW in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckCTConditionsFirstDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -225,8 +290,9 @@ TEST_CASE("Checking second derivative of the sum of CT and CW in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); auto result = ModelTests::CheckCTConditionsSecondDerivative(*modelPointer); REQUIRE(result == ModelTests::TestResults::Pass); @@ -236,13 +302,15 @@ TEST_CASE("Checking triple higgs NLO couplings in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); modelPointer->Prepare_Triple(); modelPointer->TripleHiggsCouplings(); - auto Check = [](auto result, auto expected) { + auto Check = [](auto result, auto expected) + { if (std::abs(expected) > 1e-4) { REQUIRE(result == Approx(expected).epsilon(1e-4)); @@ -274,8 +342,9 @@ TEST_CASE("Checking triple higgs NLO couplings in the R2HDM", "[r2hdm]") TEST_CASE("Check number of calculated CT parameters in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckCTNumber(*modelPointer)); @@ -285,8 +354,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lij in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -298,8 +368,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijk in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -311,8 +382,9 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijkl in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -324,8 +396,9 @@ TEST_CASE("Check symmetric properties of the gauge tensor in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -337,8 +410,9 @@ TEST_CASE("Check symmetric properties of the Lepton tensor in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -350,8 +424,9 @@ TEST_CASE("Check symmetric properties of the mass Lepton tensor in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -363,8 +438,9 @@ TEST_CASE("Check symmetric properties of the mass quark tensor in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == @@ -376,8 +452,9 @@ TEST_CASE("Check symmetric properties of the quark tensor in the R2HDM", "[r2hdm]") { using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::R2HDM); + ModelID::FChoose(ModelID::ModelIDs::R2HDM, SMConstants); modelPointer->initModel(example_point_R2HDM); REQUIRE(ModelTests::TestResults::Pass == diff --git a/tests/unittests/Test-sm.cpp b/tests/unittests/Test-sm.cpp new file mode 100644 index 00000000..bb7fc80e --- /dev/null +++ b/tests/unittests/Test-sm.cpp @@ -0,0 +1,425 @@ +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include + +using Approx = Catch::Approx; + +#include +#include // for Class_Potential_Origin +#include +#include +#include + +#include "SM.h" +#include + +const std::vector example_point_SM{/* muSq = */ -7823.7540500000005, + /* lambda = */ 0.12905349405143487}; + +const Compare_SM Expected; + +TEST_CASE("Checking NLOVEV for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + std::vector Check; + auto sol = Minimizer::Minimize_gen_all(modelPointer, + 0, + Check, + modelPointer->get_vevTreeMin(), + Minimizer::WhichMinimizerDefault); + + for (std::size_t i{0}; i < sol.size(); ++i) + { + auto expected = std::abs(modelPointer->get_vevTreeMin(i)); + auto res = std::abs(sol.at(i)); + + INFO(i << " (res/expected) = (" << res << "/" << expected << ")"); + + REQUIRE(res == Approx(expected).margin(1e-4)); + } +} + +TEST_CASE("Checking EWPT for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + std::vector Check; + auto EWPT = Minimizer::PTFinder_gen_all( + modelPointer, 0, 300, Minimizer::WhichMinimizerDefault); + const double omega_c_expected = + Expected.EWPTPerSetting.at(Minimizer::WhichMinimizerDefault).vc; + const double Tc_expected = + Expected.EWPTPerSetting.at(Minimizer::WhichMinimizerDefault).Tc; + const std::vector min_expected = + Expected.EWPTPerSetting.at(Minimizer::WhichMinimizerDefault).EWMinimum; + REQUIRE(EWPT.StatusFlag == Minimizer::MinimizerStatus::SUCCESS); + REQUIRE(std::abs(EWPT.vc) == Approx(omega_c_expected).epsilon(1e-4)); + REQUIRE(EWPT.Tc == Approx(Tc_expected).epsilon(1e-4)); + const double threshold = 1e-4; + for (std::size_t i{0}; i < EWPT.EWMinimum.size(); ++i) + { + auto res = std::abs(EWPT.EWMinimum.at(i)); + auto expected = std::abs(min_expected.at(i)); + if (expected > threshold) + { + UNSCOPED_INFO("Current Option for Minimizer:\t" + << Minimizer::WhichMinimizerDefault); + UNSCOPED_INFO("This ist the position:" + << i << "\tFound solution =" << EWPT.EWMinimum.at(i) + << "\tExpected solution = " << min_expected.at(i)); + REQUIRE(res == Approx(expected).epsilon(1e-4)); + } + else + { + REQUIRE(res <= threshold); + } + } +} + +TEST_CASE("Checking number of CT parameters for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckNumberOfCTParameters(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking number of VEV labels for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckNumberOfVEVLabels(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking number of labels for temperature dependend results for SM", + "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckLegendTemp(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking number of triple Higgs couplings for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckNumberOfTripleCouplings(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking Gauge Boson masses for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckGaugeBosonMasses(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking fermion and quark masses masses for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckFermionicMasses(*modelPointer); + REQUIRE(result.first == ModelTests::TestResults::Pass); + REQUIRE(result.second == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking tree level minimum for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckTreeLevelMin(*modelPointer, + Minimizer::WhichMinimizerDefault); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking tree level tadpoles for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckTadpoleRelations(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking NLO masses matching tree level masses for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckNLOMasses(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking VTreeSimplified for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + if (modelPointer->UseVTreeSimplified) + { + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckVTreeSimplified(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); + } + else + { + REQUIRE(true); + } +} + +TEST_CASE("Checking VCounterSimplified for SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + if (modelPointer->UseVCounterSimplified) + { + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckVCounterSimplified(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); + } + else + { + REQUIRE(true); + } +} + +TEST_CASE("Checking first derivative of the sum of CT and CW in the SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckCTConditionsFirstDerivative(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking second derivative of the sum of CT and CW in the SM", + "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckCTConditionsSecondDerivative(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking the identities required to vanish for the CT in the SM", + "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + auto result = ModelTests::CheckCTIdentities(*modelPointer); + REQUIRE(result == ModelTests::TestResults::Pass); +} + +TEST_CASE("Checking triple higgs NLO couplings in the SM", "[SM]") +{ + + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + modelPointer->Prepare_Triple(); + modelPointer->TripleHiggsCouplings(); + + auto Check = [](auto result, auto expected) + { + if (expected != 0) + { + REQUIRE(result == Approx(expected).epsilon(1e-4)); + } + else + { + REQUIRE(std::abs(result) < 1e-4); + } + }; + + auto NHiggs = modelPointer->get_NHiggs(); + for (std::size_t i{0}; i < NHiggs; ++i) + { + for (std::size_t j{0}; j < NHiggs; ++j) + { + for (std::size_t k{0}; k < NHiggs; ++k) + { + INFO("Checking TreePhysical"); + Check(modelPointer->get_TripleHiggsCorrectionsTreePhysical(i, j, k), + Expected.CheckTripleTree.at(i).at(j).at(k)); + INFO("Checking CTPhysical"); + Check(modelPointer->get_TripleHiggsCorrectionsCTPhysical(i, j, k), + Expected.CheckTripleCT.at(i).at(j).at(k)); + INFO("Checking CWPhysical"); + Check(modelPointer->get_TripleHiggsCorrectionsCWPhysical(i, j, k), + Expected.CheckTripleCW.at(i).at(j).at(k)); + } + } + } +} + +TEST_CASE("Check number of calculated CT parameters in the SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckCTNumber(*modelPointer)); +} + +TEST_CASE("Check symmetric properties of the scalar tensor Lij in the SM", + "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckSymmetricTensorScalarSecond( + modelPointer->Get_Curvature_Higgs_L2())); +} + +TEST_CASE("Check symmetric properties of the scalar tensor Lijk in the SM", + "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckSymmetricTensorScalarThird( + modelPointer->Get_Curvature_Higgs_L3())); +} + +TEST_CASE("Check symmetric properties of the scalar tensor Lijkl in the SM", + "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckSymmetricTensorScalarFourth( + modelPointer->Get_Curvature_Higgs_L4())); +} + +TEST_CASE("Check symmetric properties of the gauge tensor in the SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckSymmetricTensorGauge( + modelPointer->Get_Curvature_Gauge_G2H2())); +} + +TEST_CASE("Check symmetric properties of the Lepton tensor in the SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckSymmetricTensorLeptonsThird( + modelPointer->Get_Curvature_Lepton_F2H1())); +} + +TEST_CASE("Check symmetric properties of the mass Lepton tensor in the SM", + "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckSymmetricTensorLeptons( + modelPointer->Get_Curvature_Lepton_F2())); +} + +TEST_CASE("Check symmetric properties of the mass quark tensor in the SM", + "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckSymmetricTensorQuarks( + modelPointer->Get_Curvature_Quark_F2())); +} + +TEST_CASE("Check symmetric properties of the quark tensor in the SM", "[SM]") +{ + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); + std::shared_ptr modelPointer = + ModelID::FChoose(ModelID::ModelIDs::SM, SMConstants); + modelPointer->initModel(example_point_SM); + + REQUIRE(ModelTests::TestResults::Pass == + ModelTests::CheckSymmetricTensorQuarksThird( + modelPointer->Get_Curvature_Quark_F2H1())); +} diff --git a/tests/unittests/Test-utility.cpp b/tests/unittests/Test-utility.cpp new file mode 100644 index 00000000..edb07e7e --- /dev/null +++ b/tests/unittests/Test-utility.cpp @@ -0,0 +1,1348 @@ +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include + +using Approx = Catch::Approx; + +#include + +TEST_CASE("Check vector . vector product", "[utility]") +{ + using namespace BSMPT; + std::vector v1 = {2.237, 0.189, -1.202, 6.911, 2.754}; + std::vector v2 = {8.39, -3.968, 8.046, 3.925, 2.209}; + REQUIRE(v1 * v2 == Approx(41.556447).margin(1e-10)); +} + +TEST_CASE("Check matrix . vector", "[utility]") +{ + using namespace BSMPT; + std::vector> H = { + {-3.493, -1.695, -8.702, -3.008, -3.011}, + {7.26, 9.379, -2.769, -6.25, 7.548}, + {4.295, -1.01, -7.67, -4.673, -2.335}, + {-6.258, 4.273, 1.702, -3.612, -8.57}, + {-5.182, -5.749, 2.92, 0.864, 4.06}}; + std::vector v1 = {0.856, 8.936, -5.996, 4.987, 9.301}; + + std::vector result = H * v1; + + REQUIRE(result[0] == Approx(-8.965543).margin(1e-10)); + REQUIRE(result[1] == Approx(145.6634260).margin(1e-10)); + REQUIRE(result[2] == Approx(-4.381606).margin(1e-10)); + REQUIRE(result[3] == Approx(-75.101126).margin(1e-10)); + REQUIRE(result[4] == Approx(-31.246348).margin(1e-10)); +} + +TEST_CASE("Check vector . matrix . vector", "[utility]") +{ + using namespace BSMPT; + std::vector> H = {{-6.945, -6.422, 8.201, 7.182, -4.665}, + {9.531, 9.744, 2.673, -5.752, -6.406}, + {-3.209, 8.142, -3.635, -7.9, 6.279}, + {-7.554, -3.314, 5.775, 2.42, -5.703}, + {-3.549, 2.838, 6.843, 3.395, 2.009}}; + std::vector v1 = {-8.429, -9.61, -1.958, 8.316, -7.775}; + std::vector v2 = {4.882, -0.446, 9.56, -7.453, 0.934}; + + REQUIRE(v1 * (H * v2) == Approx(-1149.174865593).margin(1e-10)); +} + +TEST_CASE("Check Transpose", "[utility]") +{ + using namespace BSMPT; + std::vector> H = { + {-7.697, 3.259, -2.48, 9.655, -2.463}, + {1.17, -1.936, -0.053, 9.129, 4.828}, + {-4.173, -1.695, -8.372, -8.434, -7.375}, + {-1.807, -3.037, 4.649, 5.487, -5.915}, + {-2.805, -8.22, 3.369, -4.824, -7.272}}; + + std::vector> H_Transpose = { + {{-7.697, 1.17, -4.173, -1.807, -2.805}, + {3.259, -1.936, -1.695, -3.037, -8.22}, + {-2.48, -0.053, -8.372, 4.649, 3.369}, + {9.655, 9.129, -8.434, 5.487, -4.824}, + {-2.463, 4.828, -7.375, -5.915, -7.272}}}; + + REQUIRE(H_Transpose == BSMPT::Transpose(H)); +} + +TEST_CASE("Check L2NormVector", "[utility]") +{ + using namespace BSMPT; + std::vector v1 = {0.856, 8.936, -5.996, 4.987, 9.301}; + + REQUIRE(BSMPT::L2NormVector(v1) == Approx(15.096874).margin(1e-10)); +} + +TEST_CASE("Check Li2 function", "[utility]") +{ + using namespace BSMPT; + // https://en.wikipedia.org/wiki/Dilogarithm + REQUIRE(Li2(-1) == Approx(-pow(M_PI, 2) / 12.).margin(1e-10)); + REQUIRE(Li2(0) == Approx(0).margin(1e-10)); + REQUIRE(Li2(1. / 2.) == + Approx(pow(M_PI, 2) / 12. - pow(log(2), 2) / 2).margin(1e-10)); + REQUIRE(Li2((1 - sqrt(5)) / 2) == + Approx(-pow(M_PI, 2) / 15. + pow(log((sqrt(5) + 1) / 2), 2) / 2.) + .margin(1e-10)); + REQUIRE(Li2(-(1 + sqrt(5)) / 2) == + Approx(-pow(M_PI, 2) / 10. - pow(log((sqrt(5) + 1) / 2), 2)) + .margin(1e-10)); + REQUIRE(Li2((3 - sqrt(5)) / 2) == + Approx(pow(M_PI, 2) / 15. - pow(log((sqrt(5) + 1) / 2), 2)) + .margin(1e-10)); + REQUIRE(Li2((-1 + sqrt(5)) / 2) == + Approx(pow(M_PI, 2) / 10. - pow(log((sqrt(5) + 1) / 2), 2)) + .margin(1e-10)); + + REQUIRE(Li2(1 - 1e-5) == Approx(1.644808937).margin(1e-10)); + REQUIRE(Li2(1 - 1e-4) == Approx(1.643912984).margin(1e-10)); + REQUIRE(Li2(1 - 1e-3) == Approx(1.637022605).margin(1e-10)); + REQUIRE(Li2(1 - 1e-2) == Approx(1.588625448).margin(1e-10)); + REQUIRE(Li2(1 - 1e-1) == Approx(1.299714723).margin(1e-10)); + REQUIRE(Li2(1 - 1e0) == Approx(0.).margin(1e-10)); + REQUIRE(Li2(1 - 1e1) == Approx(-3.950663778).margin(1e-10)); + REQUIRE(Li2(1 - 1e2) == Approx(-12.19242167).margin(1e-10)); + REQUIRE(Li2(1 - 1e3) == Approx(-25.4955641).margin(1e-10)); + REQUIRE(Li2(1 - 1e4) == Approx(-44.05909787).margin(1e-10)); + REQUIRE(Li2(1 - 1e5) == Approx(-67.91853532).margin(1e-10)); + + REQUIRE(Li2(-1 + 1e-5) == Approx(-0.8224601019).margin(1e-10)); + REQUIRE(Li2(-1 + 1e-4) == Approx(-0.8223977177).margin(1e-10)); + REQUIRE(Li2(-1 + 1e-3) == Approx(-0.8217737896).margin(1e-10)); + REQUIRE(Li2(-1 + 1e-2) == Approx(-0.8155258815).margin(1e-10)); + REQUIRE(Li2(-1 + 1e-1) == Approx(-0.7521631792).margin(1e-10)); + + REQUIRE(Li2(1e-5) == Approx(0.000010000025).margin(1e-10)); + REQUIRE(Li2(1e-4) == Approx(0.0001000025001).margin(1e-10)); + REQUIRE(Li2(1e-3) == Approx(0.001000250111).margin(1e-10)); + REQUIRE(Li2(1e-2) == Approx(0.01002511174).margin(1e-10)); + REQUIRE(Li2(1e-1) == Approx(0.1026177911).margin(1e-10)); + + REQUIRE(Li2(-1e-5) == Approx(-9.999975e-6).margin(1e-10)); + REQUIRE(Li2(-1e-4) == Approx(-0.00009999750025).margin(1e-10)); + REQUIRE(Li2(-1e-3) == Approx(-0.000999750111).margin(1e-10)); + REQUIRE(Li2(-1e-2) == Approx(-0.00997511049).margin(1e-10)); + REQUIRE(Li2(-1e-1) == Approx(-0.09760523523).margin(1e-10)); + REQUIRE(Li2(-1e0) == Approx(-0.8224670334).margin(1e-10)); + REQUIRE(Li2(-1e1) == Approx(-4.198277887).margin(1e-10)); + REQUIRE(Li2(-1e2) == Approx(-12.23875518).margin(1e-10)); + REQUIRE(Li2(-1e3) == Approx(-25.50247581).margin(1e-10)); + REQUIRE(Li2(-1e4) == Approx(-44.06001895).margin(1e-10)); + REQUIRE(Li2(-1e5) == Approx(-67.91865045).margin(1e-10)); + + REQUIRE(Li2(-1.) == Approx(-0.8224670334).margin(1e-10)); + REQUIRE(Li2(-0.99) == Approx(-0.8155258815).margin(1e-10)); + REQUIRE(Li2(-0.98) == Approx(-0.8085652776).margin(1e-10)); + REQUIRE(Li2(-0.97) == Approx(-0.801585083).margin(1e-10)); + REQUIRE(Li2(-0.96) == Approx(-0.7945851575).margin(1e-10)); + REQUIRE(Li2(-0.95) == Approx(-0.7875653589).margin(1e-10)); + REQUIRE(Li2(-0.94) == Approx(-0.7805255435).margin(1e-10)); + REQUIRE(Li2(-0.93) == Approx(-0.773465566).margin(1e-10)); + REQUIRE(Li2(-0.92) == Approx(-0.7663852791).margin(1e-10)); + REQUIRE(Li2(-0.91) == Approx(-0.7592845337).margin(1e-10)); + REQUIRE(Li2(-0.9) == Approx(-0.7521631792).margin(1e-10)); + REQUIRE(Li2(-0.89) == Approx(-0.7450210629).margin(1e-10)); + REQUIRE(Li2(-0.88) == Approx(-0.7378580301).margin(1e-10)); + REQUIRE(Li2(-0.87) == Approx(-0.7306739245).margin(1e-10)); + REQUIRE(Li2(-0.86) == Approx(-0.7234685878).margin(1e-10)); + REQUIRE(Li2(-0.85) == Approx(-0.7162418594).margin(1e-10)); + REQUIRE(Li2(-0.84) == Approx(-0.7089935771).margin(1e-10)); + REQUIRE(Li2(-0.83) == Approx(-0.7017235764).margin(1e-10)); + REQUIRE(Li2(-0.82) == Approx(-0.6944316907).margin(1e-10)); + REQUIRE(Li2(-0.81) == Approx(-0.6871177515).margin(1e-10)); + REQUIRE(Li2(-0.8) == Approx(-0.6797815878).margin(1e-10)); + REQUIRE(Li2(-0.79) == Approx(-0.6724230268).margin(1e-10)); + REQUIRE(Li2(-0.78) == Approx(-0.6650418931).margin(1e-10)); + REQUIRE(Li2(-0.77) == Approx(-0.6576380092).margin(1e-10)); + REQUIRE(Li2(-0.76) == Approx(-0.6502111952).margin(1e-10)); + REQUIRE(Li2(-0.75) == Approx(-0.6427612688).margin(1e-10)); + REQUIRE(Li2(-0.74) == Approx(-0.6352880455).margin(1e-10)); + REQUIRE(Li2(-0.73) == Approx(-0.6277913381).margin(1e-10)); + REQUIRE(Li2(-0.72) == Approx(-0.620270957).margin(1e-10)); + REQUIRE(Li2(-0.71) == Approx(-0.61272671).margin(1e-10)); + REQUIRE(Li2(-0.7) == Approx(-0.6051584023).margin(1e-10)); + REQUIRE(Li2(-0.69) == Approx(-0.5975658366).margin(1e-10)); + REQUIRE(Li2(-0.68) == Approx(-0.5899488126).margin(1e-10)); + REQUIRE(Li2(-0.67) == Approx(-0.5823071275).margin(1e-10)); + REQUIRE(Li2(-0.66) == Approx(-0.5746405756).margin(1e-10)); + REQUIRE(Li2(-0.65) == Approx(-0.5669489483).margin(1e-10)); + REQUIRE(Li2(-0.64) == Approx(-0.5592320342).margin(1e-10)); + REQUIRE(Li2(-0.63) == Approx(-0.5514896188).margin(1e-10)); + REQUIRE(Li2(-0.62) == Approx(-0.5437214845).margin(1e-10)); + REQUIRE(Li2(-0.61) == Approx(-0.5359274109).margin(1e-10)); + REQUIRE(Li2(-0.6) == Approx(-0.528107174).margin(1e-10)); + REQUIRE(Li2(-0.59) == Approx(-0.520260547).margin(1e-10)); + REQUIRE(Li2(-0.58) == Approx(-0.5123872996).margin(1e-10)); + REQUIRE(Li2(-0.57) == Approx(-0.504487198).margin(1e-10)); + REQUIRE(Li2(-0.56) == Approx(-0.4965600052).margin(1e-10)); + REQUIRE(Li2(-0.55) == Approx(-0.4886054807).margin(1e-10)); + REQUIRE(Li2(-0.54) == Approx(-0.4806233803).margin(1e-10)); + REQUIRE(Li2(-0.53) == Approx(-0.4726134562).margin(1e-10)); + REQUIRE(Li2(-0.52) == Approx(-0.4645754568).margin(1e-10)); + REQUIRE(Li2(-0.51) == Approx(-0.4565091268).margin(1e-10)); + REQUIRE(Li2(-0.5) == Approx(-0.4484142069).margin(1e-10)); + REQUIRE(Li2(-0.49) == Approx(-0.440290434).margin(1e-10)); + REQUIRE(Li2(-0.48) == Approx(-0.4321375408).margin(1e-10)); + REQUIRE(Li2(-0.47) == Approx(-0.4239552559).margin(1e-10)); + REQUIRE(Li2(-0.46) == Approx(-0.4157433035).margin(1e-10)); + REQUIRE(Li2(-0.45) == Approx(-0.4075014037).margin(1e-10)); + REQUIRE(Li2(-0.44) == Approx(-0.3992292721).margin(1e-10)); + REQUIRE(Li2(-0.43) == Approx(-0.3909266197).margin(1e-10)); + REQUIRE(Li2(-0.42) == Approx(-0.3825931528).margin(1e-10)); + REQUIRE(Li2(-0.41) == Approx(-0.3742285731).margin(1e-10)); + REQUIRE(Li2(-0.4) == Approx(-0.3658325775).margin(1e-10)); + REQUIRE(Li2(-0.39) == Approx(-0.3574048577).margin(1e-10)); + REQUIRE(Li2(-0.38) == Approx(-0.3489451006).margin(1e-10)); + REQUIRE(Li2(-0.37) == Approx(-0.3404529876).margin(1e-10)); + REQUIRE(Li2(-0.36) == Approx(-0.331928195).margin(1e-10)); + REQUIRE(Li2(-0.35) == Approx(-0.3233703936).margin(1e-10)); + REQUIRE(Li2(-0.34) == Approx(-0.3147792486).margin(1e-10)); + REQUIRE(Li2(-0.33) == Approx(-0.3061544195).margin(1e-10)); + REQUIRE(Li2(-0.32) == Approx(-0.2974955599).margin(1e-10)); + REQUIRE(Li2(-0.31) == Approx(-0.2888023175).margin(1e-10)); + REQUIRE(Li2(-0.3) == Approx(-0.2800743338).margin(1e-10)); + REQUIRE(Li2(-0.29) == Approx(-0.2713112439).margin(1e-10)); + REQUIRE(Li2(-0.28) == Approx(-0.2625126766).margin(1e-10)); + REQUIRE(Li2(-0.27) == Approx(-0.2536782541).margin(1e-10)); + REQUIRE(Li2(-0.26) == Approx(-0.2448075917).margin(1e-10)); + REQUIRE(Li2(-0.25) == Approx(-0.2359002977).margin(1e-10)); + REQUIRE(Li2(-0.24) == Approx(-0.2269559734).margin(1e-10)); + REQUIRE(Li2(-0.23) == Approx(-0.2179742128).margin(1e-10)); + REQUIRE(Li2(-0.22) == Approx(-0.2089546022).margin(1e-10)); + REQUIRE(Li2(-0.21) == Approx(-0.1998967202).margin(1e-10)); + REQUIRE(Li2(-0.2) == Approx(-0.1908001378).margin(1e-10)); + REQUIRE(Li2(-0.19) == Approx(-0.1816644174).margin(1e-10)); + REQUIRE(Li2(-0.18) == Approx(-0.1724891134).margin(1e-10)); + REQUIRE(Li2(-0.17) == Approx(-0.1632737713).margin(1e-10)); + REQUIRE(Li2(-0.16) == Approx(-0.1540179282).margin(1e-10)); + REQUIRE(Li2(-0.15) == Approx(-0.1447211118).margin(1e-10)); + REQUIRE(Li2(-0.14) == Approx(-0.1353828405).margin(1e-10)); + REQUIRE(Li2(-0.13) == Approx(-0.1260026232).margin(1e-10)); + REQUIRE(Li2(-0.12) == Approx(-0.1165799591).margin(1e-10)); + REQUIRE(Li2(-0.11) == Approx(-0.1071143369).margin(1e-10)); + REQUIRE(Li2(-0.1) == Approx(-0.09760523523).margin(1e-10)); + REQUIRE(Li2(-0.09) == Approx(-0.08805212172).margin(1e-10)); + REQUIRE(Li2(-0.08) == Approx(-0.07845445308).margin(1e-10)); + REQUIRE(Li2(-0.07) == Approx(-0.06881167461).margin(1e-10)); + REQUIRE(Li2(-0.06) == Approx(-0.05912321986).margin(1e-10)); + REQUIRE(Li2(-0.05) == Approx(-0.04938851035).margin(1e-10)); + REQUIRE(Li2(-0.04) == Approx(-0.0396069551).margin(1e-10)); + REQUIRE(Li2(-0.03) == Approx(-0.02977795033).margin(1e-10)); + REQUIRE(Li2(-0.02) == Approx(-0.01990087902).margin(1e-10)); + REQUIRE(Li2(-0.01) == Approx(-0.00997511049).margin(1e-10)); + REQUIRE(Li2(0.) == Approx(0.).margin(1e-10)); + REQUIRE(Li2(0.01) == Approx(0.01002511174).margin(1e-10)); + REQUIRE(Li2(0.02) == Approx(0.02010089902).margin(1e-10)); + REQUIRE(Li2(0.03) == Approx(0.03022805162).margin(1e-10)); + REQUIRE(Li2(0.04) == Approx(0.04040727532).margin(1e-10)); + REQUIRE(Li2(0.05) == Approx(0.05063929246).margin(1e-10)); + REQUIRE(Li2(0.06) == Approx(0.06092484246).margin(1e-10)); + REQUIRE(Li2(0.07) == Approx(0.07126468241).margin(1e-10)); + REQUIRE(Li2(0.08) == Approx(0.0816595877).margin(1e-10)); + REQUIRE(Li2(0.09) == Approx(0.09211035263).margin(1e-10)); + REQUIRE(Li2(0.1) == Approx(0.1026177911).margin(1e-10)); + REQUIRE(Li2(0.11) == Approx(0.1131827373).margin(1e-10)); + REQUIRE(Li2(0.12) == Approx(0.1238060463).margin(1e-10)); + REQUIRE(Li2(0.13) == Approx(0.1344885952).margin(1e-10)); + REQUIRE(Li2(0.14) == Approx(0.1452312834).margin(1e-10)); + REQUIRE(Li2(0.15) == Approx(0.1560350339).margin(1e-10)); + REQUIRE(Li2(0.16) == Approx(0.1669007939).margin(1e-10)); + REQUIRE(Li2(0.17) == Approx(0.1778295358).margin(1e-10)); + REQUIRE(Li2(0.18) == Approx(0.1888222581).margin(1e-10)); + REQUIRE(Li2(0.19) == Approx(0.1998799866).margin(1e-10)); + REQUIRE(Li2(0.2) == Approx(0.2110037754).margin(1e-10)); + REQUIRE(Li2(0.21) == Approx(0.2221947079).margin(1e-10)); + REQUIRE(Li2(0.22) == Approx(0.233453898).margin(1e-10)); + REQUIRE(Li2(0.23) == Approx(0.2447824916).margin(1e-10)); + REQUIRE(Li2(0.24) == Approx(0.2561816675).margin(1e-10)); + REQUIRE(Li2(0.25) == Approx(0.2676526391).margin(1e-10)); + REQUIRE(Li2(0.26) == Approx(0.2791966559).margin(1e-10)); + REQUIRE(Li2(0.27) == Approx(0.2908150047).margin(1e-10)); + REQUIRE(Li2(0.28) == Approx(0.3025090116).margin(1e-10)); + REQUIRE(Li2(0.29) == Approx(0.3142800435).margin(1e-10)); + REQUIRE(Li2(0.3) == Approx(0.3261295101).margin(1e-10)); + REQUIRE(Li2(0.31) == Approx(0.3380588655).margin(1e-10)); + REQUIRE(Li2(0.32) == Approx(0.3500696107).margin(1e-10)); + REQUIRE(Li2(0.33) == Approx(0.3621632955).margin(1e-10)); + REQUIRE(Li2(0.34) == Approx(0.3743415208).margin(1e-10)); + REQUIRE(Li2(0.35) == Approx(0.3866059412).margin(1e-10)); + REQUIRE(Li2(0.36) == Approx(0.3989582673).margin(1e-10)); + REQUIRE(Li2(0.37) == Approx(0.4114002691).margin(1e-10)); + REQUIRE(Li2(0.38) == Approx(0.4239337783).margin(1e-10)); + REQUIRE(Li2(0.39) == Approx(0.4365606916).margin(1e-10)); + REQUIRE(Li2(0.4) == Approx(0.4492829745).margin(1e-10)); + REQUIRE(Li2(0.41) == Approx(0.4621026643).margin(1e-10)); + REQUIRE(Li2(0.42) == Approx(0.4750218745).margin(1e-10)); + REQUIRE(Li2(0.43) == Approx(0.4880427986).margin(1e-10)); + REQUIRE(Li2(0.44) == Approx(0.5011677144).margin(1e-10)); + REQUIRE(Li2(0.45) == Approx(0.5143989892).margin(1e-10)); + REQUIRE(Li2(0.46) == Approx(0.5277390845).margin(1e-10)); + REQUIRE(Li2(0.47) == Approx(0.5411905619).margin(1e-10)); + REQUIRE(Li2(0.48) == Approx(0.5547560886).margin(1e-10)); + REQUIRE(Li2(0.49) == Approx(0.5684384439).margin(1e-10)); + REQUIRE(Li2(0.5) == Approx(0.5822405265).margin(1e-10)); + REQUIRE(Li2(0.51) == Approx(0.5961653614).margin(1e-10)); + REQUIRE(Li2(0.52) == Approx(0.6102161084).margin(1e-10)); + REQUIRE(Li2(0.53) == Approx(0.624396071).margin(1e-10)); + REQUIRE(Li2(0.54) == Approx(0.6387087054).margin(1e-10)); + REQUIRE(Li2(0.55) == Approx(0.6531576315).margin(1e-10)); + REQUIRE(Li2(0.56) == Approx(0.6677466442).margin(1e-10)); + REQUIRE(Li2(0.57) == Approx(0.6824797254).margin(1e-10)); + REQUIRE(Li2(0.58) == Approx(0.6973610584).margin(1e-10)); + REQUIRE(Li2(0.59) == Approx(0.712395042).margin(1e-10)); + REQUIRE(Li2(0.6) == Approx(0.7275863077).margin(1e-10)); + REQUIRE(Li2(0.61) == Approx(0.7429397374).margin(1e-10)); + REQUIRE(Li2(0.62) == Approx(0.7584604836).margin(1e-10)); + REQUIRE(Li2(0.63) == Approx(0.7741539916).margin(1e-10)); + REQUIRE(Li2(0.64) == Approx(0.7900260243).margin(1e-10)); + REQUIRE(Li2(0.65) == Approx(0.8060826895).margin(1e-10)); + REQUIRE(Li2(0.66) == Approx(0.8223304706).margin(1e-10)); + REQUIRE(Li2(0.67) == Approx(0.8387762613).margin(1e-10)); + REQUIRE(Li2(0.68) == Approx(0.8554274037).margin(1e-10)); + REQUIRE(Li2(0.69) == Approx(0.8722917326).margin(1e-10)); + REQUIRE(Li2(0.7) == Approx(0.8893776243).margin(1e-10)); + REQUIRE(Li2(0.71) == Approx(0.9066940527).margin(1e-10)); + REQUIRE(Li2(0.72) == Approx(0.9242506536).margin(1e-10)); + REQUIRE(Li2(0.73) == Approx(0.9420577978).margin(1e-10)); + REQUIRE(Li2(0.74) == Approx(0.9601266752).margin(1e-10)); + REQUIRE(Li2(0.75) == Approx(0.9784693929).margin(1e-10)); + REQUIRE(Li2(0.76) == Approx(0.9970990883).margin(1e-10)); + REQUIRE(Li2(0.77) == Approx(1.016030062).margin(1e-10)); + REQUIRE(Li2(0.78) == Approx(1.035277934).margin(1e-10)); + REQUIRE(Li2(0.79) == Approx(1.05485983).margin(1e-10)); + REQUIRE(Li2(0.8) == Approx(1.0747946).margin(1e-10)); + REQUIRE(Li2(0.81) == Approx(1.095103088).margin(1e-10)); + REQUIRE(Li2(0.82) == Approx(1.115808451).margin(1e-10)); + REQUIRE(Li2(0.83) == Approx(1.13693656).margin(1e-10)); + REQUIRE(Li2(0.84) == Approx(1.158516488).margin(1e-10)); + REQUIRE(Li2(0.85) == Approx(1.180581124).margin(1e-10)); + REQUIRE(Li2(0.86) == Approx(1.203167961).margin(1e-10)); + REQUIRE(Li2(0.87) == Approx(1.226320101).margin(1e-10)); + REQUIRE(Li2(0.88) == Approx(1.250087584).margin(1e-10)); + REQUIRE(Li2(0.89) == Approx(1.27452916).margin(1e-10)); + REQUIRE(Li2(0.9) == Approx(1.299714723).margin(1e-10)); + REQUIRE(Li2(0.91) == Approx(1.325728728).margin(1e-10)); + REQUIRE(Li2(0.92) == Approx(1.352675161).margin(1e-10)); + REQUIRE(Li2(0.93) == Approx(1.380685041).margin(1e-10)); + REQUIRE(Li2(0.94) == Approx(1.4099283).margin(1e-10)); + REQUIRE(Li2(0.95) == Approx(1.440633797).margin(1e-10)); + REQUIRE(Li2(0.96) == Approx(1.47312586).margin(1e-10)); + REQUIRE(Li2(0.97) == Approx(1.507899041).margin(1e-10)); + REQUIRE(Li2(0.98) == Approx(1.545799712).margin(1e-10)); + REQUIRE(Li2(0.99) == Approx(1.588625448).margin(1e-10)); + REQUIRE(Li2(1.) == Approx(1.644934067).margin(1e-10)); +} + +TEST_CASE("Check Incomplete elliptic integral of the second kind", "[utility]") +{ + using namespace BSMPT; + // https://en.wikipedia.org/wiki/Elliptic_integral#Incomplete_elliptic_integral_of_the_second_kind + REQUIRE(EllipIntSecond(0.) == Approx(0.).margin(1e-10)); + REQUIRE(EllipIntSecond(0.01) == Approx(0.01000033333).margin(1e-10)); + REQUIRE(EllipIntSecond(0.02) == Approx(0.02000266656).margin(1e-10)); + REQUIRE(EllipIntSecond(0.03) == Approx(0.03000899919).margin(1e-10)); + REQUIRE(EllipIntSecond(0.04) == Approx(0.04002132992).margin(1e-10)); + REQUIRE(EllipIntSecond(0.05) == Approx(0.05004165627).margin(1e-10)); + REQUIRE(EllipIntSecond(0.06) == Approx(0.06007197416).margin(1e-10)); + REQUIRE(EllipIntSecond(0.07) == Approx(0.07011427756).margin(1e-10)); + REQUIRE(EllipIntSecond(0.08) == Approx(0.08017055807).margin(1e-10)); + REQUIRE(EllipIntSecond(0.09) == Approx(0.0902428046).margin(1e-10)); + REQUIRE(EllipIntSecond(0.1) == Approx(0.100333003).margin(1e-10)); + REQUIRE(EllipIntSecond(0.11) == Approx(0.1104431356).margin(1e-10)); + REQUIRE(EllipIntSecond(0.12) == Approx(0.1205751812).margin(1e-10)); + REQUIRE(EllipIntSecond(0.13) == Approx(0.1307311144).margin(1e-10)); + REQUIRE(EllipIntSecond(0.14) == Approx(0.1409129052).margin(1e-10)); + REQUIRE(EllipIntSecond(0.15) == Approx(0.1511225194).margin(1e-10)); + REQUIRE(EllipIntSecond(0.16) == Approx(0.1613619174).margin(1e-10)); + REQUIRE(EllipIntSecond(0.17) == Approx(0.1716330547).margin(1e-10)); + REQUIRE(EllipIntSecond(0.18) == Approx(0.1819378813).margin(1e-10)); + REQUIRE(EllipIntSecond(0.19) == Approx(0.1922783416).margin(1e-10)); + REQUIRE(EllipIntSecond(0.2) == Approx(0.2026563739).margin(1e-10)); + REQUIRE(EllipIntSecond(0.21) == Approx(0.2130739107).margin(1e-10)); + REQUIRE(EllipIntSecond(0.22) == Approx(0.2235328784).margin(1e-10)); + REQUIRE(EllipIntSecond(0.23) == Approx(0.2340351968).margin(1e-10)); + REQUIRE(EllipIntSecond(0.24) == Approx(0.2445827794).margin(1e-10)); + REQUIRE(EllipIntSecond(0.25) == Approx(0.2551775332).margin(1e-10)); + REQUIRE(EllipIntSecond(0.26) == Approx(0.2658213586).margin(1e-10)); + REQUIRE(EllipIntSecond(0.27) == Approx(0.2765161492).margin(1e-10)); + REQUIRE(EllipIntSecond(0.28) == Approx(0.2872637919).margin(1e-10)); + REQUIRE(EllipIntSecond(0.29) == Approx(0.2980661672).margin(1e-10)); + REQUIRE(EllipIntSecond(0.3) == Approx(0.3089251485).margin(1e-10)); + REQUIRE(EllipIntSecond(0.31) == Approx(0.3198426026).margin(1e-10)); + REQUIRE(EllipIntSecond(0.32) == Approx(0.33082039).margin(1e-10)); + REQUIRE(EllipIntSecond(0.33) == Approx(0.3418603642).margin(1e-10)); + REQUIRE(EllipIntSecond(0.34) == Approx(0.3529643724).margin(1e-10)); + REQUIRE(EllipIntSecond(0.35) == Approx(0.3641342554).margin(1e-10)); + REQUIRE(EllipIntSecond(0.36) == Approx(0.3753718479).margin(1e-10)); + REQUIRE(EllipIntSecond(0.37) == Approx(0.3866789783).margin(1e-10)); + REQUIRE(EllipIntSecond(0.38) == Approx(0.398057469).margin(1e-10)); + REQUIRE(EllipIntSecond(0.39) == Approx(0.4095091368).margin(1e-10)); + REQUIRE(EllipIntSecond(0.4) == Approx(0.4210357926).margin(1e-10)); + REQUIRE(EllipIntSecond(0.41) == Approx(0.4326392423).margin(1e-10)); + REQUIRE(EllipIntSecond(0.42) == Approx(0.4443212862).margin(1e-10)); + REQUIRE(EllipIntSecond(0.43) == Approx(0.4560837198).margin(1e-10)); + REQUIRE(EllipIntSecond(0.44) == Approx(0.4679283339).margin(1e-10)); + REQUIRE(EllipIntSecond(0.45) == Approx(0.4798569147).margin(1e-10)); + REQUIRE(EllipIntSecond(0.46) == Approx(0.4918712444).margin(1e-10)); + REQUIRE(EllipIntSecond(0.47) == Approx(0.5039731011).margin(1e-10)); + REQUIRE(EllipIntSecond(0.48) == Approx(0.5161642591).margin(1e-10)); + REQUIRE(EllipIntSecond(0.49) == Approx(0.5284464895).margin(1e-10)); + REQUIRE(EllipIntSecond(0.5) == Approx(0.5408215603).margin(1e-10)); + REQUIRE(EllipIntSecond(0.51) == Approx(0.5532912368).margin(1e-10)); + REQUIRE(EllipIntSecond(0.52) == Approx(0.5658572817).margin(1e-10)); + REQUIRE(EllipIntSecond(0.53) == Approx(0.5785214555).margin(1e-10)); + REQUIRE(EllipIntSecond(0.54) == Approx(0.5912855172).margin(1e-10)); + REQUIRE(EllipIntSecond(0.55) == Approx(0.604151224).margin(1e-10)); + REQUIRE(EllipIntSecond(0.56) == Approx(0.6171203321).margin(1e-10)); + REQUIRE(EllipIntSecond(0.57) == Approx(0.6301945969).margin(1e-10)); + REQUIRE(EllipIntSecond(0.58) == Approx(0.6433757733).margin(1e-10)); + REQUIRE(EllipIntSecond(0.59) == Approx(0.6566656161).margin(1e-10)); + REQUIRE(EllipIntSecond(0.6) == Approx(0.6700658804).margin(1e-10)); + REQUIRE(EllipIntSecond(0.61) == Approx(0.6835783219).margin(1e-10)); + REQUIRE(EllipIntSecond(0.62) == Approx(0.6972046971).margin(1e-10)); + REQUIRE(EllipIntSecond(0.63) == Approx(0.710946764).margin(1e-10)); + REQUIRE(EllipIntSecond(0.64) == Approx(0.7248062822).margin(1e-10)); + REQUIRE(EllipIntSecond(0.65) == Approx(0.7387850133).margin(1e-10)); + REQUIRE(EllipIntSecond(0.66) == Approx(0.7528847212).margin(1e-10)); + REQUIRE(EllipIntSecond(0.67) == Approx(0.7671071728).margin(1e-10)); + REQUIRE(EllipIntSecond(0.68) == Approx(0.781454138).margin(1e-10)); + REQUIRE(EllipIntSecond(0.69) == Approx(0.7959273901).margin(1e-10)); + REQUIRE(EllipIntSecond(0.7) == Approx(0.8105287063).margin(1e-10)); + REQUIRE(EllipIntSecond(0.71) == Approx(0.8252598681).margin(1e-10)); + REQUIRE(EllipIntSecond(0.72) == Approx(0.8401226613).margin(1e-10)); + REQUIRE(EllipIntSecond(0.73) == Approx(0.855118877).margin(1e-10)); + REQUIRE(EllipIntSecond(0.74) == Approx(0.8702503113).margin(1e-10)); + REQUIRE(EllipIntSecond(0.75) == Approx(0.885518766).margin(1e-10)); + REQUIRE(EllipIntSecond(0.76) == Approx(0.900926049).margin(1e-10)); + REQUIRE(EllipIntSecond(0.77) == Approx(0.9164739743).margin(1e-10)); + REQUIRE(EllipIntSecond(0.78) == Approx(0.932164363).margin(1e-10)); + REQUIRE(EllipIntSecond(0.79) == Approx(0.947999043).margin(1e-10)); + REQUIRE(EllipIntSecond(0.8) == Approx(0.9639798497).margin(1e-10)); + REQUIRE(EllipIntSecond(0.81) == Approx(0.9801086262).margin(1e-10)); + REQUIRE(EllipIntSecond(0.82) == Approx(0.9963872237).margin(1e-10)); + REQUIRE(EllipIntSecond(0.83) == Approx(1.012817502).margin(1e-10)); + REQUIRE(EllipIntSecond(0.84) == Approx(1.02940133).margin(1e-10)); + REQUIRE(EllipIntSecond(0.85) == Approx(1.046140584).margin(1e-10)); + REQUIRE(EllipIntSecond(0.86) == Approx(1.063037153).margin(1e-10)); + REQUIRE(EllipIntSecond(0.87) == Approx(1.080092933).margin(1e-10)); + REQUIRE(EllipIntSecond(0.88) == Approx(1.097309831).margin(1e-10)); + REQUIRE(EllipIntSecond(0.89) == Approx(1.114689765).margin(1e-10)); + REQUIRE(EllipIntSecond(0.9) == Approx(1.132234664).margin(1e-10)); + REQUIRE(EllipIntSecond(0.91) == Approx(1.149946466).margin(1e-10)); + REQUIRE(EllipIntSecond(0.92) == Approx(1.167827125).margin(1e-10)); + REQUIRE(EllipIntSecond(0.93) == Approx(1.185878601).margin(1e-10)); + REQUIRE(EllipIntSecond(0.94) == Approx(1.204102871).margin(1e-10)); + REQUIRE(EllipIntSecond(0.95) == Approx(1.222501923).margin(1e-10)); + REQUIRE(EllipIntSecond(0.96) == Approx(1.241077756).margin(1e-10)); + REQUIRE(EllipIntSecond(0.97) == Approx(1.259832384).margin(1e-10)); + REQUIRE(EllipIntSecond(0.98) == Approx(1.278767835).margin(1e-10)); + REQUIRE(EllipIntSecond(0.99) == Approx(1.29788615).margin(1e-10)); + REQUIRE(EllipIntSecond(1.) == Approx(1.317189382).margin(1e-10)); + REQUIRE(EllipIntSecond(1.01) == Approx(1.336679602).margin(1e-10)); + REQUIRE(EllipIntSecond(1.02) == Approx(1.356358894).margin(1e-10)); + REQUIRE(EllipIntSecond(1.03) == Approx(1.376229358).margin(1e-10)); + REQUIRE(EllipIntSecond(1.04) == Approx(1.396293106).margin(1e-10)); + REQUIRE(EllipIntSecond(1.05) == Approx(1.41655227).margin(1e-10)); + REQUIRE(EllipIntSecond(1.06) == Approx(1.437008997).margin(1e-10)); + REQUIRE(EllipIntSecond(1.07) == Approx(1.457665447).margin(1e-10)); + REQUIRE(EllipIntSecond(1.08) == Approx(1.478523802).margin(1e-10)); + REQUIRE(EllipIntSecond(1.09) == Approx(1.499586256).margin(1e-10)); + REQUIRE(EllipIntSecond(1.1) == Approx(1.520855023).margin(1e-10)); + REQUIRE(EllipIntSecond(1.11) == Approx(1.542332333).margin(1e-10)); + REQUIRE(EllipIntSecond(1.12) == Approx(1.564020437).margin(1e-10)); + REQUIRE(EllipIntSecond(1.13) == Approx(1.585921599).margin(1e-10)); + REQUIRE(EllipIntSecond(1.14) == Approx(1.608038107).margin(1e-10)); + REQUIRE(EllipIntSecond(1.15) == Approx(1.630372263).margin(1e-10)); + REQUIRE(EllipIntSecond(1.16) == Approx(1.652926391).margin(1e-10)); + REQUIRE(EllipIntSecond(1.17) == Approx(1.675702834).margin(1e-10)); + REQUIRE(EllipIntSecond(1.18) == Approx(1.698703953).margin(1e-10)); + REQUIRE(EllipIntSecond(1.19) == Approx(1.721932132).margin(1e-10)); + REQUIRE(EllipIntSecond(1.2) == Approx(1.745389773).margin(1e-10)); + REQUIRE(EllipIntSecond(1.21) == Approx(1.7690793).margin(1e-10)); + REQUIRE(EllipIntSecond(1.22) == Approx(1.793003155).margin(1e-10)); + REQUIRE(EllipIntSecond(1.23) == Approx(1.817163805).margin(1e-10)); + REQUIRE(EllipIntSecond(1.24) == Approx(1.841563737).margin(1e-10)); + REQUIRE(EllipIntSecond(1.25) == Approx(1.86620546).margin(1e-10)); + REQUIRE(EllipIntSecond(1.26) == Approx(1.891091505).margin(1e-10)); + REQUIRE(EllipIntSecond(1.27) == Approx(1.916224424).margin(1e-10)); + REQUIRE(EllipIntSecond(1.28) == Approx(1.941606796).margin(1e-10)); + REQUIRE(EllipIntSecond(1.29) == Approx(1.967241218).margin(1e-10)); + REQUIRE(EllipIntSecond(1.3) == Approx(1.993130314).margin(1e-10)); + REQUIRE(EllipIntSecond(1.31) == Approx(2.01927673).margin(1e-10)); + REQUIRE(EllipIntSecond(1.32) == Approx(2.045683138).margin(1e-10)); + REQUIRE(EllipIntSecond(1.33) == Approx(2.072352231).margin(1e-10)); + REQUIRE(EllipIntSecond(1.34) == Approx(2.09928673).margin(1e-10)); + REQUIRE(EllipIntSecond(1.35) == Approx(2.126489379).margin(1e-10)); + REQUIRE(EllipIntSecond(1.36) == Approx(2.153962948).margin(1e-10)); + REQUIRE(EllipIntSecond(1.37) == Approx(2.181710234).margin(1e-10)); + REQUIRE(EllipIntSecond(1.38) == Approx(2.209734056).margin(1e-10)); + REQUIRE(EllipIntSecond(1.39) == Approx(2.238037264).margin(1e-10)); + REQUIRE(EllipIntSecond(1.4) == Approx(2.266622732).margin(1e-10)); + REQUIRE(EllipIntSecond(1.41) == Approx(2.295493361).margin(1e-10)); + REQUIRE(EllipIntSecond(1.42) == Approx(2.324652079).margin(1e-10)); + REQUIRE(EllipIntSecond(1.43) == Approx(2.354101844).margin(1e-10)); + REQUIRE(EllipIntSecond(1.44) == Approx(2.383845639).margin(1e-10)); + REQUIRE(EllipIntSecond(1.45) == Approx(2.413886476).margin(1e-10)); + REQUIRE(EllipIntSecond(1.46) == Approx(2.444227397).margin(1e-10)); + REQUIRE(EllipIntSecond(1.47) == Approx(2.474871471).margin(1e-10)); + REQUIRE(EllipIntSecond(1.48) == Approx(2.505821798).margin(1e-10)); + REQUIRE(EllipIntSecond(1.49) == Approx(2.537081506).margin(1e-10)); + REQUIRE(EllipIntSecond(1.5) == Approx(2.568653755).margin(1e-10)); + REQUIRE(EllipIntSecond(1.51) == Approx(2.600541733).margin(1e-10)); + REQUIRE(EllipIntSecond(1.52) == Approx(2.63274866).margin(1e-10)); + REQUIRE(EllipIntSecond(1.53) == Approx(2.665277786).margin(1e-10)); + REQUIRE(EllipIntSecond(1.54) == Approx(2.698132394).margin(1e-10)); + REQUIRE(EllipIntSecond(1.55) == Approx(2.731315797).margin(1e-10)); + REQUIRE(EllipIntSecond(1.56) == Approx(2.764831342).margin(1e-10)); + REQUIRE(EllipIntSecond(1.57) == Approx(2.798682405).margin(1e-10)); + REQUIRE(EllipIntSecond(1.58) == Approx(2.832872398).margin(1e-10)); + REQUIRE(EllipIntSecond(1.59) == Approx(2.867404766).margin(1e-10)); + REQUIRE(EllipIntSecond(1.6) == Approx(2.902282985).margin(1e-10)); + REQUIRE(EllipIntSecond(1.61) == Approx(2.937510567).margin(1e-10)); + REQUIRE(EllipIntSecond(1.62) == Approx(2.973091058).margin(1e-10)); + REQUIRE(EllipIntSecond(1.63) == Approx(3.009028038).margin(1e-10)); + REQUIRE(EllipIntSecond(1.64) == Approx(3.045325123).margin(1e-10)); + REQUIRE(EllipIntSecond(1.65) == Approx(3.081985962).margin(1e-10)); + REQUIRE(EllipIntSecond(1.66) == Approx(3.119014242).margin(1e-10)); + REQUIRE(EllipIntSecond(1.67) == Approx(3.156413687).margin(1e-10)); + REQUIRE(EllipIntSecond(1.68) == Approx(3.194188055).margin(1e-10)); + REQUIRE(EllipIntSecond(1.69) == Approx(3.232341141).margin(1e-10)); + REQUIRE(EllipIntSecond(1.7) == Approx(3.27087678).margin(1e-10)); + REQUIRE(EllipIntSecond(1.71) == Approx(3.309798843).margin(1e-10)); + REQUIRE(EllipIntSecond(1.72) == Approx(3.349111238).margin(1e-10)); + REQUIRE(EllipIntSecond(1.73) == Approx(3.388817914).margin(1e-10)); + REQUIRE(EllipIntSecond(1.74) == Approx(3.428922856).margin(1e-10)); + REQUIRE(EllipIntSecond(1.75) == Approx(3.469430092).margin(1e-10)); + REQUIRE(EllipIntSecond(1.76) == Approx(3.510343687).margin(1e-10)); + REQUIRE(EllipIntSecond(1.77) == Approx(3.551667747).margin(1e-10)); + REQUIRE(EllipIntSecond(1.78) == Approx(3.593406418).margin(1e-10)); + REQUIRE(EllipIntSecond(1.79) == Approx(3.635563888).margin(1e-10)); + REQUIRE(EllipIntSecond(1.8) == Approx(3.678144387).margin(1e-10)); + REQUIRE(EllipIntSecond(1.81) == Approx(3.721152185).margin(1e-10)); + REQUIRE(EllipIntSecond(1.82) == Approx(3.764591596).margin(1e-10)); + REQUIRE(EllipIntSecond(1.83) == Approx(3.808466975).margin(1e-10)); + REQUIRE(EllipIntSecond(1.84) == Approx(3.852782723).margin(1e-10)); + REQUIRE(EllipIntSecond(1.85) == Approx(3.897543283).margin(1e-10)); + REQUIRE(EllipIntSecond(1.86) == Approx(3.942753141).margin(1e-10)); + REQUIRE(EllipIntSecond(1.87) == Approx(3.98841683).margin(1e-10)); + REQUIRE(EllipIntSecond(1.88) == Approx(4.034538926).margin(1e-10)); + REQUIRE(EllipIntSecond(1.89) == Approx(4.081124052).margin(1e-10)); + REQUIRE(EllipIntSecond(1.9) == Approx(4.128176876).margin(1e-10)); + REQUIRE(EllipIntSecond(1.91) == Approx(4.175702114).margin(1e-10)); + REQUIRE(EllipIntSecond(1.92) == Approx(4.223704527).margin(1e-10)); + REQUIRE(EllipIntSecond(1.93) == Approx(4.272188924).margin(1e-10)); + REQUIRE(EllipIntSecond(1.94) == Approx(4.321160163).margin(1e-10)); + REQUIRE(EllipIntSecond(1.95) == Approx(4.370623149).margin(1e-10)); + REQUIRE(EllipIntSecond(1.96) == Approx(4.420582838).margin(1e-10)); + REQUIRE(EllipIntSecond(1.97) == Approx(4.471044232).margin(1e-10)); + REQUIRE(EllipIntSecond(1.98) == Approx(4.522012386).margin(1e-10)); + REQUIRE(EllipIntSecond(1.99) == Approx(4.573492405).margin(1e-10)); + REQUIRE(EllipIntSecond(2.) == Approx(4.625489444).margin(1e-10)); + REQUIRE(EllipIntSecond(2.01) == Approx(4.678008709).margin(1e-10)); + REQUIRE(EllipIntSecond(2.02) == Approx(4.731055459).margin(1e-10)); + REQUIRE(EllipIntSecond(2.03) == Approx(4.784635007).margin(1e-10)); + REQUIRE(EllipIntSecond(2.04) == Approx(4.838752716).margin(1e-10)); + REQUIRE(EllipIntSecond(2.05) == Approx(4.893414005).margin(1e-10)); + REQUIRE(EllipIntSecond(2.06) == Approx(4.948624345).margin(1e-10)); + REQUIRE(EllipIntSecond(2.07) == Approx(5.004389264).margin(1e-10)); + REQUIRE(EllipIntSecond(2.08) == Approx(5.060714345).margin(1e-10)); + REQUIRE(EllipIntSecond(2.09) == Approx(5.117605225).margin(1e-10)); + REQUIRE(EllipIntSecond(2.1) == Approx(5.175067599).margin(1e-10)); + REQUIRE(EllipIntSecond(2.11) == Approx(5.233107218).margin(1e-10)); + REQUIRE(EllipIntSecond(2.12) == Approx(5.291729892).margin(1e-10)); + REQUIRE(EllipIntSecond(2.13) == Approx(5.350941488).margin(1e-10)); + REQUIRE(EllipIntSecond(2.14) == Approx(5.410747931).margin(1e-10)); + REQUIRE(EllipIntSecond(2.15) == Approx(5.471155208).margin(1e-10)); + REQUIRE(EllipIntSecond(2.16) == Approx(5.532169364).margin(1e-10)); + REQUIRE(EllipIntSecond(2.17) == Approx(5.593796504).margin(1e-10)); + REQUIRE(EllipIntSecond(2.18) == Approx(5.656042795).margin(1e-10)); + REQUIRE(EllipIntSecond(2.19) == Approx(5.718914467).margin(1e-10)); + REQUIRE(EllipIntSecond(2.2) == Approx(5.78241781).margin(1e-10)); + REQUIRE(EllipIntSecond(2.21) == Approx(5.846559179).margin(1e-10)); + REQUIRE(EllipIntSecond(2.22) == Approx(5.911344992).margin(1e-10)); + REQUIRE(EllipIntSecond(2.23) == Approx(5.976781731).margin(1e-10)); + REQUIRE(EllipIntSecond(2.24) == Approx(6.042875944).margin(1e-10)); + REQUIRE(EllipIntSecond(2.25) == Approx(6.109634243).margin(1e-10)); + REQUIRE(EllipIntSecond(2.26) == Approx(6.177063308).margin(1e-10)); + REQUIRE(EllipIntSecond(2.27) == Approx(6.245169884).margin(1e-10)); + REQUIRE(EllipIntSecond(2.28) == Approx(6.313960786).margin(1e-10)); + REQUIRE(EllipIntSecond(2.29) == Approx(6.383442896).margin(1e-10)); + REQUIRE(EllipIntSecond(2.3) == Approx(6.453623166).margin(1e-10)); + REQUIRE(EllipIntSecond(2.31) == Approx(6.524508615).margin(1e-10)); + REQUIRE(EllipIntSecond(2.32) == Approx(6.596106337).margin(1e-10)); + REQUIRE(EllipIntSecond(2.33) == Approx(6.668423492).margin(1e-10)); + REQUIRE(EllipIntSecond(2.34) == Approx(6.741467316).margin(1e-10)); + REQUIRE(EllipIntSecond(2.35) == Approx(6.815245115).margin(1e-10)); + REQUIRE(EllipIntSecond(2.36) == Approx(6.889764271).margin(1e-10)); + REQUIRE(EllipIntSecond(2.37) == Approx(6.965032237).margin(1e-10)); + REQUIRE(EllipIntSecond(2.38) == Approx(7.041056542).margin(1e-10)); + REQUIRE(EllipIntSecond(2.39) == Approx(7.117844791).margin(1e-10)); + REQUIRE(EllipIntSecond(2.4) == Approx(7.195404666).margin(1e-10)); + REQUIRE(EllipIntSecond(2.41) == Approx(7.273743925).margin(1e-10)); + REQUIRE(EllipIntSecond(2.42) == Approx(7.352870403).margin(1e-10)); + REQUIRE(EllipIntSecond(2.43) == Approx(7.432792015).margin(1e-10)); + REQUIRE(EllipIntSecond(2.44) == Approx(7.513516757).margin(1e-10)); + REQUIRE(EllipIntSecond(2.45) == Approx(7.595052701).margin(1e-10)); + REQUIRE(EllipIntSecond(2.46) == Approx(7.677408003).margin(1e-10)); + REQUIRE(EllipIntSecond(2.47) == Approx(7.760590902).margin(1e-10)); + REQUIRE(EllipIntSecond(2.48) == Approx(7.844609717).margin(1e-10)); + REQUIRE(EllipIntSecond(2.49) == Approx(7.929472851).margin(1e-10)); + REQUIRE(EllipIntSecond(2.5) == Approx(8.015188793).margin(1e-10)); + REQUIRE(EllipIntSecond(2.51) == Approx(8.101766116).margin(1e-10)); + REQUIRE(EllipIntSecond(2.52) == Approx(8.189213479).margin(1e-10)); + REQUIRE(EllipIntSecond(2.53) == Approx(8.277539628).margin(1e-10)); + REQUIRE(EllipIntSecond(2.54) == Approx(8.366753399).margin(1e-10)); + REQUIRE(EllipIntSecond(2.55) == Approx(8.456863713).margin(1e-10)); + REQUIRE(EllipIntSecond(2.56) == Approx(8.547879583).margin(1e-10)); + REQUIRE(EllipIntSecond(2.57) == Approx(8.639810112).margin(1e-10)); + REQUIRE(EllipIntSecond(2.58) == Approx(8.732664494).margin(1e-10)); + REQUIRE(EllipIntSecond(2.59) == Approx(8.826452017).margin(1e-10)); + REQUIRE(EllipIntSecond(2.6) == Approx(8.92118206).margin(1e-10)); + REQUIRE(EllipIntSecond(2.61) == Approx(9.016864097).margin(1e-10)); + REQUIRE(EllipIntSecond(2.62) == Approx(9.113507699).margin(1e-10)); + REQUIRE(EllipIntSecond(2.63) == Approx(9.21112253).margin(1e-10)); + REQUIRE(EllipIntSecond(2.64) == Approx(9.309718353).margin(1e-10)); + REQUIRE(EllipIntSecond(2.65) == Approx(9.409305028).margin(1e-10)); + REQUIRE(EllipIntSecond(2.66) == Approx(9.509892517).margin(1e-10)); + REQUIRE(EllipIntSecond(2.67) == Approx(9.611490878).margin(1e-10)); + REQUIRE(EllipIntSecond(2.68) == Approx(9.714110272).margin(1e-10)); + REQUIRE(EllipIntSecond(2.69) == Approx(9.817760962).margin(1e-10)); + REQUIRE(EllipIntSecond(2.7) == Approx(9.922453315).margin(1e-10)); + REQUIRE(EllipIntSecond(2.71) == Approx(10.0281978).margin(1e-10)); + REQUIRE(EllipIntSecond(2.72) == Approx(10.13500499).margin(1e-10)); + REQUIRE(EllipIntSecond(2.73) == Approx(10.24288558).margin(1e-10)); + REQUIRE(EllipIntSecond(2.74) == Approx(10.35185034).margin(1e-10)); + REQUIRE(EllipIntSecond(2.75) == Approx(10.46191017).margin(1e-10)); + REQUIRE(EllipIntSecond(2.76) == Approx(10.57307609).margin(1e-10)); + REQUIRE(EllipIntSecond(2.77) == Approx(10.68535921).margin(1e-10)); + REQUIRE(EllipIntSecond(2.78) == Approx(10.79877076).margin(1e-10)); + REQUIRE(EllipIntSecond(2.79) == Approx(10.91332208).margin(1e-10)); + REQUIRE(EllipIntSecond(2.8) == Approx(11.02902463).margin(1e-10)); + REQUIRE(EllipIntSecond(2.81) == Approx(11.14588997).margin(1e-10)); + REQUIRE(EllipIntSecond(2.82) == Approx(11.2639298).margin(1e-10)); + REQUIRE(EllipIntSecond(2.83) == Approx(11.38315592).margin(1e-10)); + REQUIRE(EllipIntSecond(2.84) == Approx(11.50358026).margin(1e-10)); + REQUIRE(EllipIntSecond(2.85) == Approx(11.62521484).margin(1e-10)); + REQUIRE(EllipIntSecond(2.86) == Approx(11.74807185).margin(1e-10)); + REQUIRE(EllipIntSecond(2.87) == Approx(11.87216357).margin(1e-10)); + REQUIRE(EllipIntSecond(2.88) == Approx(11.9975024).margin(1e-10)); + REQUIRE(EllipIntSecond(2.89) == Approx(12.12410089).margin(1e-10)); + REQUIRE(EllipIntSecond(2.9) == Approx(12.25197168).margin(1e-10)); + REQUIRE(EllipIntSecond(2.91) == Approx(12.38112758).margin(1e-10)); + REQUIRE(EllipIntSecond(2.92) == Approx(12.51158149).margin(1e-10)); + REQUIRE(EllipIntSecond(2.93) == Approx(12.64334646).margin(1e-10)); + REQUIRE(EllipIntSecond(2.94) == Approx(12.77643567).margin(1e-10)); + REQUIRE(EllipIntSecond(2.95) == Approx(12.91086243).margin(1e-10)); + REQUIRE(EllipIntSecond(2.96) == Approx(13.04664018).margin(1e-10)); + REQUIRE(EllipIntSecond(2.97) == Approx(13.18378249).margin(1e-10)); + REQUIRE(EllipIntSecond(2.98) == Approx(13.3223031).margin(1e-10)); + REQUIRE(EllipIntSecond(2.99) == Approx(13.46221583).margin(1e-10)); + REQUIRE(EllipIntSecond(3.) == Approx(13.6035347).margin(1e-10)); + REQUIRE(EllipIntSecond(3.01) == Approx(13.74627383).margin(1e-10)); + REQUIRE(EllipIntSecond(3.02) == Approx(13.89044749).margin(1e-10)); + REQUIRE(EllipIntSecond(3.03) == Approx(14.03607011).margin(1e-10)); + REQUIRE(EllipIntSecond(3.04) == Approx(14.18315624).margin(1e-10)); + REQUIRE(EllipIntSecond(3.05) == Approx(14.33172059).margin(1e-10)); + REQUIRE(EllipIntSecond(3.06) == Approx(14.48177803).margin(1e-10)); + REQUIRE(EllipIntSecond(3.07) == Approx(14.63334355).margin(1e-10)); + REQUIRE(EllipIntSecond(3.08) == Approx(14.78643232).margin(1e-10)); + REQUIRE(EllipIntSecond(3.09) == Approx(14.94105965).margin(1e-10)); + REQUIRE(EllipIntSecond(3.1) == Approx(15.09724099).margin(1e-10)); + REQUIRE(EllipIntSecond(3.11) == Approx(15.25499196).margin(1e-10)); + REQUIRE(EllipIntSecond(3.12) == Approx(15.41432835).margin(1e-10)); + REQUIRE(EllipIntSecond(3.13) == Approx(15.57526608).margin(1e-10)); + REQUIRE(EllipIntSecond(3.14) == Approx(15.73782125).margin(1e-10)); + REQUIRE(EllipIntSecond(3.15) == Approx(15.90201012).margin(1e-10)); + REQUIRE(EllipIntSecond(3.16) == Approx(16.0678491).margin(1e-10)); + REQUIRE(EllipIntSecond(3.17) == Approx(16.23535478).margin(1e-10)); + REQUIRE(EllipIntSecond(3.18) == Approx(16.40454391).margin(1e-10)); + REQUIRE(EllipIntSecond(3.19) == Approx(16.57543341).margin(1e-10)); + REQUIRE(EllipIntSecond(3.2) == Approx(16.74804036).margin(1e-10)); + REQUIRE(EllipIntSecond(3.21) == Approx(16.92238204).margin(1e-10)); + REQUIRE(EllipIntSecond(3.22) == Approx(17.09847587).margin(1e-10)); + REQUIRE(EllipIntSecond(3.23) == Approx(17.27633946).margin(1e-10)); + REQUIRE(EllipIntSecond(3.24) == Approx(17.4559906).margin(1e-10)); + REQUIRE(EllipIntSecond(3.25) == Approx(17.63744726).margin(1e-10)); + REQUIRE(EllipIntSecond(3.26) == Approx(17.82072758).margin(1e-10)); + REQUIRE(EllipIntSecond(3.27) == Approx(18.00584988).margin(1e-10)); + REQUIRE(EllipIntSecond(3.28) == Approx(18.1928327).margin(1e-10)); + REQUIRE(EllipIntSecond(3.29) == Approx(18.38169471).margin(1e-10)); + REQUIRE(EllipIntSecond(3.3) == Approx(18.57245481).margin(1e-10)); + REQUIRE(EllipIntSecond(3.31) == Approx(18.76513207).margin(1e-10)); + REQUIRE(EllipIntSecond(3.32) == Approx(18.95974576).margin(1e-10)); + REQUIRE(EllipIntSecond(3.33) == Approx(19.15631535).margin(1e-10)); + REQUIRE(EllipIntSecond(3.34) == Approx(19.35486049).margin(1e-10)); + REQUIRE(EllipIntSecond(3.35) == Approx(19.55540104).margin(1e-10)); + REQUIRE(EllipIntSecond(3.36) == Approx(19.75795704).margin(1e-10)); + REQUIRE(EllipIntSecond(3.37) == Approx(19.96254876).margin(1e-10)); + REQUIRE(EllipIntSecond(3.38) == Approx(20.16919665).margin(1e-10)); + REQUIRE(EllipIntSecond(3.39) == Approx(20.37792139).margin(1e-10)); + REQUIRE(EllipIntSecond(3.4) == Approx(20.58874384).margin(1e-10)); + REQUIRE(EllipIntSecond(3.41) == Approx(20.80168508).margin(1e-10)); + REQUIRE(EllipIntSecond(3.42) == Approx(21.01676642).margin(1e-10)); + REQUIRE(EllipIntSecond(3.43) == Approx(21.23400935).margin(1e-10)); + REQUIRE(EllipIntSecond(3.44) == Approx(21.4534356).margin(1e-10)); + REQUIRE(EllipIntSecond(3.45) == Approx(21.67506712).margin(1e-10)); + REQUIRE(EllipIntSecond(3.46) == Approx(21.89892607).margin(1e-10)); + REQUIRE(EllipIntSecond(3.47) == Approx(22.12503484).margin(1e-10)); + REQUIRE(EllipIntSecond(3.48) == Approx(22.35341603).margin(1e-10)); + REQUIRE(EllipIntSecond(3.49) == Approx(22.58409249).margin(1e-10)); + REQUIRE(EllipIntSecond(3.5) == Approx(22.81708728).margin(1e-10)); + REQUIRE(EllipIntSecond(3.51) == Approx(23.0524237).margin(1e-10)); + REQUIRE(EllipIntSecond(3.52) == Approx(23.29012529).margin(1e-10)); + REQUIRE(EllipIntSecond(3.53) == Approx(23.53021582).margin(1e-10)); + REQUIRE(EllipIntSecond(3.54) == Approx(23.77271929).margin(1e-10)); + REQUIRE(EllipIntSecond(3.55) == Approx(24.01765996).margin(1e-10)); + REQUIRE(EllipIntSecond(3.56) == Approx(24.26506232).margin(1e-10)); + REQUIRE(EllipIntSecond(3.57) == Approx(24.51495111).margin(1e-10)); + REQUIRE(EllipIntSecond(3.58) == Approx(24.76735133).margin(1e-10)); + REQUIRE(EllipIntSecond(3.59) == Approx(25.0222882).margin(1e-10)); + REQUIRE(EllipIntSecond(3.6) == Approx(25.27978723).margin(1e-10)); + REQUIRE(EllipIntSecond(3.61) == Approx(25.53987417).margin(1e-10)); + REQUIRE(EllipIntSecond(3.62) == Approx(25.80257502).margin(1e-10)); + REQUIRE(EllipIntSecond(3.63) == Approx(26.06791605).margin(1e-10)); + REQUIRE(EllipIntSecond(3.64) == Approx(26.33592381).margin(1e-10)); + REQUIRE(EllipIntSecond(3.65) == Approx(26.60662508).margin(1e-10)); + REQUIRE(EllipIntSecond(3.66) == Approx(26.88004694).margin(1e-10)); + REQUIRE(EllipIntSecond(3.67) == Approx(27.15621674).margin(1e-10)); + REQUIRE(EllipIntSecond(3.68) == Approx(27.43516209).margin(1e-10)); + REQUIRE(EllipIntSecond(3.69) == Approx(27.71691088).margin(1e-10)); + REQUIRE(EllipIntSecond(3.7) == Approx(28.0014913).margin(1e-10)); + REQUIRE(EllipIntSecond(3.71) == Approx(28.28893179).margin(1e-10)); + REQUIRE(EllipIntSecond(3.72) == Approx(28.5792611).margin(1e-10)); + REQUIRE(EllipIntSecond(3.73) == Approx(28.87250827).margin(1e-10)); + REQUIRE(EllipIntSecond(3.74) == Approx(29.16870262).margin(1e-10)); + REQUIRE(EllipIntSecond(3.75) == Approx(29.46787378).margin(1e-10)); + REQUIRE(EllipIntSecond(3.76) == Approx(29.77005165).margin(1e-10)); + REQUIRE(EllipIntSecond(3.77) == Approx(30.07526645).margin(1e-10)); + REQUIRE(EllipIntSecond(3.78) == Approx(30.38354872).margin(1e-10)); + REQUIRE(EllipIntSecond(3.79) == Approx(30.69492927).margin(1e-10)); + REQUIRE(EllipIntSecond(3.8) == Approx(31.00943925).margin(1e-10)); + REQUIRE(EllipIntSecond(3.81) == Approx(31.3271101).margin(1e-10)); + REQUIRE(EllipIntSecond(3.82) == Approx(31.64797359).margin(1e-10)); + REQUIRE(EllipIntSecond(3.83) == Approx(31.97206182).margin(1e-10)); + REQUIRE(EllipIntSecond(3.84) == Approx(32.29940719).margin(1e-10)); + REQUIRE(EllipIntSecond(3.85) == Approx(32.63004243).margin(1e-10)); + REQUIRE(EllipIntSecond(3.86) == Approx(32.9640006).margin(1e-10)); + REQUIRE(EllipIntSecond(3.87) == Approx(33.30131512).margin(1e-10)); + REQUIRE(EllipIntSecond(3.88) == Approx(33.6420197).margin(1e-10)); + REQUIRE(EllipIntSecond(3.89) == Approx(33.98614841).margin(1e-10)); + REQUIRE(EllipIntSecond(3.9) == Approx(34.33373567).margin(1e-10)); + REQUIRE(EllipIntSecond(3.91) == Approx(34.68481625).margin(1e-10)); + REQUIRE(EllipIntSecond(3.92) == Approx(35.03942524).margin(1e-10)); + REQUIRE(EllipIntSecond(3.93) == Approx(35.39759811).margin(1e-10)); + REQUIRE(EllipIntSecond(3.94) == Approx(35.75937067).margin(1e-10)); + REQUIRE(EllipIntSecond(3.95) == Approx(36.12477911).margin(1e-10)); + REQUIRE(EllipIntSecond(3.96) == Approx(36.49385997).margin(1e-10)); + REQUIRE(EllipIntSecond(3.97) == Approx(36.86665015).margin(1e-10)); + REQUIRE(EllipIntSecond(3.98) == Approx(37.24318693).margin(1e-10)); + REQUIRE(EllipIntSecond(3.99) == Approx(37.62350796).margin(1e-10)); + REQUIRE(EllipIntSecond(4.) == Approx(38.00765129).margin(1e-10)); + REQUIRE(EllipIntSecond(4.01) == Approx(38.39565532).margin(1e-10)); + REQUIRE(EllipIntSecond(4.02) == Approx(38.78755885).margin(1e-10)); + REQUIRE(EllipIntSecond(4.03) == Approx(39.18340108).margin(1e-10)); + REQUIRE(EllipIntSecond(4.04) == Approx(39.58322159).margin(1e-10)); + REQUIRE(EllipIntSecond(4.05) == Approx(39.98706036).margin(1e-10)); + REQUIRE(EllipIntSecond(4.06) == Approx(40.39495778).margin(1e-10)); + REQUIRE(EllipIntSecond(4.07) == Approx(40.80695463).margin(1e-10)); + REQUIRE(EllipIntSecond(4.08) == Approx(41.22309212).margin(1e-10)); + REQUIRE(EllipIntSecond(4.09) == Approx(41.64341186).margin(1e-10)); + REQUIRE(EllipIntSecond(4.1) == Approx(42.06795589).margin(1e-10)); + REQUIRE(EllipIntSecond(4.11) == Approx(42.49676665).margin(1e-10)); + REQUIRE(EllipIntSecond(4.12) == Approx(42.92988703).margin(1e-10)); + REQUIRE(EllipIntSecond(4.13) == Approx(43.36736034).margin(1e-10)); + REQUIRE(EllipIntSecond(4.14) == Approx(43.80923033).margin(1e-10)); + REQUIRE(EllipIntSecond(4.15) == Approx(44.25554119).margin(1e-10)); + REQUIRE(EllipIntSecond(4.16) == Approx(44.70633755).margin(1e-10)); + REQUIRE(EllipIntSecond(4.17) == Approx(45.16166448).margin(1e-10)); + REQUIRE(EllipIntSecond(4.18) == Approx(45.62156753).margin(1e-10)); + REQUIRE(EllipIntSecond(4.19) == Approx(46.08609267).margin(1e-10)); + REQUIRE(EllipIntSecond(4.2) == Approx(46.55528638).margin(1e-10)); + REQUIRE(EllipIntSecond(4.21) == Approx(47.02919555).margin(1e-10)); + REQUIRE(EllipIntSecond(4.22) == Approx(47.5078676).margin(1e-10)); + REQUIRE(EllipIntSecond(4.23) == Approx(47.99135037).margin(1e-10)); + REQUIRE(EllipIntSecond(4.24) == Approx(48.47969223).margin(1e-10)); + REQUIRE(EllipIntSecond(4.25) == Approx(48.97294201).margin(1e-10)); + REQUIRE(EllipIntSecond(4.26) == Approx(49.47114903).margin(1e-10)); + REQUIRE(EllipIntSecond(4.27) == Approx(49.97436311).margin(1e-10)); + REQUIRE(EllipIntSecond(4.28) == Approx(50.48263458).margin(1e-10)); + REQUIRE(EllipIntSecond(4.29) == Approx(50.99601425).margin(1e-10)); + REQUIRE(EllipIntSecond(4.3) == Approx(51.51455349).margin(1e-10)); + REQUIRE(EllipIntSecond(4.31) == Approx(52.03830412).margin(1e-10)); + REQUIRE(EllipIntSecond(4.32) == Approx(52.56731854).margin(1e-10)); + REQUIRE(EllipIntSecond(4.33) == Approx(53.10164964).margin(1e-10)); + REQUIRE(EllipIntSecond(4.34) == Approx(53.64135086).margin(1e-10)); + REQUIRE(EllipIntSecond(4.35) == Approx(54.18647616).margin(1e-10)); + REQUIRE(EllipIntSecond(4.36) == Approx(54.73708006).margin(1e-10)); + REQUIRE(EllipIntSecond(4.37) == Approx(55.29321763).margin(1e-10)); + REQUIRE(EllipIntSecond(4.38) == Approx(55.85494447).margin(1e-10)); + REQUIRE(EllipIntSecond(4.39) == Approx(56.42231676).margin(1e-10)); + REQUIRE(EllipIntSecond(4.4) == Approx(56.99539123).margin(1e-10)); + REQUIRE(EllipIntSecond(4.41) == Approx(57.5742252).margin(1e-10)); + REQUIRE(EllipIntSecond(4.42) == Approx(58.15887655).margin(1e-10)); + REQUIRE(EllipIntSecond(4.43) == Approx(58.74940374).margin(1e-10)); + REQUIRE(EllipIntSecond(4.44) == Approx(59.34586582).margin(1e-10)); + REQUIRE(EllipIntSecond(4.45) == Approx(59.94832245).margin(1e-10)); + REQUIRE(EllipIntSecond(4.46) == Approx(60.55683387).margin(1e-10)); + REQUIRE(EllipIntSecond(4.47) == Approx(61.17146093).margin(1e-10)); + REQUIRE(EllipIntSecond(4.48) == Approx(61.7922651).margin(1e-10)); + REQUIRE(EllipIntSecond(4.49) == Approx(62.41930845).margin(1e-10)); + REQUIRE(EllipIntSecond(4.5) == Approx(63.05265369).margin(1e-10)); + REQUIRE(EllipIntSecond(4.51) == Approx(63.69236415).margin(1e-10)); + REQUIRE(EllipIntSecond(4.52) == Approx(64.33850382).margin(1e-10)); + REQUIRE(EllipIntSecond(4.53) == Approx(64.99113729).margin(1e-10)); + REQUIRE(EllipIntSecond(4.54) == Approx(65.65032984).margin(1e-10)); + REQUIRE(EllipIntSecond(4.55) == Approx(66.31614738).margin(1e-10)); + REQUIRE(EllipIntSecond(4.56) == Approx(66.9886565).margin(1e-10)); + REQUIRE(EllipIntSecond(4.57) == Approx(67.66792446).margin(1e-10)); + REQUIRE(EllipIntSecond(4.58) == Approx(68.35401916).margin(1e-10)); + REQUIRE(EllipIntSecond(4.59) == Approx(69.04700924).margin(1e-10)); + REQUIRE(EllipIntSecond(4.6) == Approx(69.74696398).margin(1e-10)); + REQUIRE(EllipIntSecond(4.61) == Approx(70.45395338).margin(1e-10)); + REQUIRE(EllipIntSecond(4.62) == Approx(71.16804814).margin(1e-10)); + REQUIRE(EllipIntSecond(4.63) == Approx(71.88931967).margin(1e-10)); + REQUIRE(EllipIntSecond(4.64) == Approx(72.61784011).margin(1e-10)); + REQUIRE(EllipIntSecond(4.65) == Approx(73.35368229).margin(1e-10)); + REQUIRE(EllipIntSecond(4.66) == Approx(74.09691981).margin(1e-10)); + REQUIRE(EllipIntSecond(4.67) == Approx(74.847627).margin(1e-10)); + REQUIRE(EllipIntSecond(4.68) == Approx(75.60587891).margin(1e-10)); + REQUIRE(EllipIntSecond(4.69) == Approx(76.37175139).margin(1e-10)); + REQUIRE(EllipIntSecond(4.7) == Approx(77.14532101).margin(1e-10)); + REQUIRE(EllipIntSecond(4.71) == Approx(77.92666513).margin(1e-10)); + REQUIRE(EllipIntSecond(4.72) == Approx(78.71586189).margin(1e-10)); + REQUIRE(EllipIntSecond(4.73) == Approx(79.51299022).margin(1e-10)); + REQUIRE(EllipIntSecond(4.74) == Approx(80.31812981).margin(1e-10)); + REQUIRE(EllipIntSecond(4.75) == Approx(81.13136119).margin(1e-10)); + REQUIRE(EllipIntSecond(4.76) == Approx(81.95276569).margin(1e-10)); + REQUIRE(EllipIntSecond(4.77) == Approx(82.78242543).margin(1e-10)); + REQUIRE(EllipIntSecond(4.78) == Approx(83.6204234).margin(1e-10)); + REQUIRE(EllipIntSecond(4.79) == Approx(84.46684338).margin(1e-10)); + REQUIRE(EllipIntSecond(4.8) == Approx(85.32177003).margin(1e-10)); + REQUIRE(EllipIntSecond(4.81) == Approx(86.18528883).margin(1e-10)); + REQUIRE(EllipIntSecond(4.82) == Approx(87.05748614).margin(1e-10)); + REQUIRE(EllipIntSecond(4.83) == Approx(87.93844918).margin(1e-10)); + REQUIRE(EllipIntSecond(4.84) == Approx(88.82826605).margin(1e-10)); + REQUIRE(EllipIntSecond(4.85) == Approx(89.72702572).margin(1e-10)); + REQUIRE(EllipIntSecond(4.86) == Approx(90.63481808).margin(1e-10)); + REQUIRE(EllipIntSecond(4.87) == Approx(91.5517339).margin(1e-10)); + REQUIRE(EllipIntSecond(4.88) == Approx(92.47786488).margin(1e-10)); + REQUIRE(EllipIntSecond(4.89) == Approx(93.41330363).margin(1e-10)); + REQUIRE(EllipIntSecond(4.9) == Approx(94.35814369).margin(1e-10)); + REQUIRE(EllipIntSecond(4.91) == Approx(95.31247956).margin(1e-10)); + REQUIRE(EllipIntSecond(4.92) == Approx(96.27640666).margin(1e-10)); + REQUIRE(EllipIntSecond(4.93) == Approx(97.25002139).margin(1e-10)); + REQUIRE(EllipIntSecond(4.94) == Approx(98.23342111).margin(1e-10)); + REQUIRE(EllipIntSecond(4.95) == Approx(99.22670416).margin(1e-10)); + REQUIRE(EllipIntSecond(4.96) == Approx(100.2299699).margin(1e-10)); + REQUIRE(EllipIntSecond(4.97) == Approx(101.2433186).margin(1e-10)); + REQUIRE(EllipIntSecond(4.98) == Approx(102.2668516).margin(1e-10)); + REQUIRE(EllipIntSecond(4.99) == Approx(103.3006713).margin(1e-10)); + REQUIRE(EllipIntSecond(5.) == Approx(104.3448811).margin(1e-10)); + REQUIRE(EllipIntSecond(5.01) == Approx(105.3995853).margin(1e-10)); + REQUIRE(EllipIntSecond(5.02) == Approx(106.4648895).margin(1e-10)); + REQUIRE(EllipIntSecond(5.03) == Approx(107.5409002).margin(1e-10)); + REQUIRE(EllipIntSecond(5.04) == Approx(108.627725).margin(1e-10)); + REQUIRE(EllipIntSecond(5.05) == Approx(109.7254725).margin(1e-10)); + REQUIRE(EllipIntSecond(5.06) == Approx(110.8342526).margin(1e-10)); + REQUIRE(EllipIntSecond(5.07) == Approx(111.9541761).margin(1e-10)); + REQUIRE(EllipIntSecond(5.08) == Approx(113.085355).margin(1e-10)); + REQUIRE(EllipIntSecond(5.09) == Approx(114.2279025).margin(1e-10)); + REQUIRE(EllipIntSecond(5.1) == Approx(115.3819328).margin(1e-10)); + REQUIRE(EllipIntSecond(5.11) == Approx(116.5475612).margin(1e-10)); + REQUIRE(EllipIntSecond(5.12) == Approx(117.7249044).margin(1e-10)); + REQUIRE(EllipIntSecond(5.13) == Approx(118.9140802).margin(1e-10)); + REQUIRE(EllipIntSecond(5.14) == Approx(120.1152073).margin(1e-10)); + REQUIRE(EllipIntSecond(5.15) == Approx(121.328406).margin(1e-10)); + REQUIRE(EllipIntSecond(5.16) == Approx(122.5537975).margin(1e-10)); + REQUIRE(EllipIntSecond(5.17) == Approx(123.7915044).margin(1e-10)); + REQUIRE(EllipIntSecond(5.18) == Approx(125.0416504).margin(1e-10)); + REQUIRE(EllipIntSecond(5.19) == Approx(126.3043607).margin(1e-10)); + REQUIRE(EllipIntSecond(5.2) == Approx(127.5797613).margin(1e-10)); + REQUIRE(EllipIntSecond(5.21) == Approx(128.86798).margin(1e-10)); + REQUIRE(EllipIntSecond(5.22) == Approx(130.1691455).margin(1e-10)); + REQUIRE(EllipIntSecond(5.23) == Approx(131.4833879).margin(1e-10)); + REQUIRE(EllipIntSecond(5.24) == Approx(132.8108387).margin(1e-10)); + REQUIRE(EllipIntSecond(5.25) == Approx(134.1516306).margin(1e-10)); + REQUIRE(EllipIntSecond(5.26) == Approx(135.5058976).margin(1e-10)); + REQUIRE(EllipIntSecond(5.27) == Approx(136.8737753).margin(1e-10)); + REQUIRE(EllipIntSecond(5.28) == Approx(138.2554003).margin(1e-10)); + REQUIRE(EllipIntSecond(5.29) == Approx(139.650911).margin(1e-10)); + REQUIRE(EllipIntSecond(5.3) == Approx(141.0604467).margin(1e-10)); + REQUIRE(EllipIntSecond(5.31) == Approx(142.4841485).margin(1e-10)); + REQUIRE(EllipIntSecond(5.32) == Approx(143.9221588).margin(1e-10)); + REQUIRE(EllipIntSecond(5.33) == Approx(145.3746213).margin(1e-10)); + REQUIRE(EllipIntSecond(5.34) == Approx(146.8416813).margin(1e-10)); + REQUIRE(EllipIntSecond(5.35) == Approx(148.3234855).margin(1e-10)); + REQUIRE(EllipIntSecond(5.36) == Approx(149.820182).margin(1e-10)); + REQUIRE(EllipIntSecond(5.37) == Approx(151.3319206).margin(1e-10)); + REQUIRE(EllipIntSecond(5.38) == Approx(152.8588525).margin(1e-10)); + REQUIRE(EllipIntSecond(5.39) == Approx(154.4011303).margin(1e-10)); + REQUIRE(EllipIntSecond(5.4) == Approx(155.9589082).margin(1e-10)); + REQUIRE(EllipIntSecond(5.41) == Approx(157.532342).margin(1e-10)); + REQUIRE(EllipIntSecond(5.42) == Approx(159.1215891).margin(1e-10)); + REQUIRE(EllipIntSecond(5.43) == Approx(160.7268084).margin(1e-10)); + REQUIRE(EllipIntSecond(5.44) == Approx(162.3481605).margin(1e-10)); + REQUIRE(EllipIntSecond(5.45) == Approx(163.9858074).margin(1e-10)); + REQUIRE(EllipIntSecond(5.46) == Approx(165.6399129).margin(1e-10)); + REQUIRE(EllipIntSecond(5.47) == Approx(167.3106424).margin(1e-10)); + REQUIRE(EllipIntSecond(5.48) == Approx(168.9981631).margin(1e-10)); + REQUIRE(EllipIntSecond(5.49) == Approx(170.7026436).margin(1e-10)); + REQUIRE(EllipIntSecond(5.5) == Approx(172.4242545).margin(1e-10)); + REQUIRE(EllipIntSecond(5.51) == Approx(174.1631678).margin(1e-10)); + REQUIRE(EllipIntSecond(5.52) == Approx(175.9195575).margin(1e-10)); + REQUIRE(EllipIntSecond(5.53) == Approx(177.6935992).margin(1e-10)); + REQUIRE(EllipIntSecond(5.54) == Approx(179.4854703).margin(1e-10)); + REQUIRE(EllipIntSecond(5.55) == Approx(181.29535).margin(1e-10)); + REQUIRE(EllipIntSecond(5.56) == Approx(183.1234193).margin(1e-10)); + REQUIRE(EllipIntSecond(5.57) == Approx(184.9698611).margin(1e-10)); + REQUIRE(EllipIntSecond(5.58) == Approx(186.8348598).margin(1e-10)); + REQUIRE(EllipIntSecond(5.59) == Approx(188.7186021).margin(1e-10)); + REQUIRE(EllipIntSecond(5.6) == Approx(190.6212764).margin(1e-10)); + REQUIRE(EllipIntSecond(5.61) == Approx(192.5430728).margin(1e-10)); + REQUIRE(EllipIntSecond(5.62) == Approx(194.4841836).margin(1e-10)); + REQUIRE(EllipIntSecond(5.63) == Approx(196.4448029).margin(1e-10)); + REQUIRE(EllipIntSecond(5.64) == Approx(198.4251268).margin(1e-10)); + REQUIRE(EllipIntSecond(5.65) == Approx(200.4253532).margin(1e-10)); + REQUIRE(EllipIntSecond(5.66) == Approx(202.4456822).margin(1e-10)); + REQUIRE(EllipIntSecond(5.67) == Approx(204.4863159).margin(1e-10)); + REQUIRE(EllipIntSecond(5.68) == Approx(206.5474583).margin(1e-10)); + REQUIRE(EllipIntSecond(5.69) == Approx(208.6293155).margin(1e-10)); + REQUIRE(EllipIntSecond(5.7) == Approx(210.7320958).margin(1e-10)); + REQUIRE(EllipIntSecond(5.71) == Approx(212.8560093).margin(1e-10)); + REQUIRE(EllipIntSecond(5.72) == Approx(215.0012685).margin(1e-10)); + REQUIRE(EllipIntSecond(5.73) == Approx(217.1680879).margin(1e-10)); + REQUIRE(EllipIntSecond(5.74) == Approx(219.3566843).margin(1e-10)); + REQUIRE(EllipIntSecond(5.75) == Approx(221.5672764).margin(1e-10)); + REQUIRE(EllipIntSecond(5.76) == Approx(223.8000853).margin(1e-10)); + REQUIRE(EllipIntSecond(5.77) == Approx(226.0553343).margin(1e-10)); + REQUIRE(EllipIntSecond(5.78) == Approx(228.3332489).margin(1e-10)); + REQUIRE(EllipIntSecond(5.79) == Approx(230.634057).margin(1e-10)); + REQUIRE(EllipIntSecond(5.8) == Approx(232.9579885).margin(1e-10)); + REQUIRE(EllipIntSecond(5.81) == Approx(235.305276).margin(1e-10)); + REQUIRE(EllipIntSecond(5.82) == Approx(237.6761541).margin(1e-10)); + REQUIRE(EllipIntSecond(5.83) == Approx(240.0708599).margin(1e-10)); + REQUIRE(EllipIntSecond(5.84) == Approx(242.4896329).margin(1e-10)); + REQUIRE(EllipIntSecond(5.85) == Approx(244.932715).margin(1e-10)); + REQUIRE(EllipIntSecond(5.86) == Approx(247.4003504).margin(1e-10)); + REQUIRE(EllipIntSecond(5.87) == Approx(249.8927861).margin(1e-10)); + REQUIRE(EllipIntSecond(5.88) == Approx(252.4102711).margin(1e-10)); + REQUIRE(EllipIntSecond(5.89) == Approx(254.9530572).margin(1e-10)); + REQUIRE(EllipIntSecond(5.9) == Approx(257.5213988).margin(1e-10)); + REQUIRE(EllipIntSecond(5.91) == Approx(260.1155526).margin(1e-10)); + REQUIRE(EllipIntSecond(5.92) == Approx(262.7357782).margin(1e-10)); + REQUIRE(EllipIntSecond(5.93) == Approx(265.3823374).margin(1e-10)); + REQUIRE(EllipIntSecond(5.94) == Approx(268.055495).margin(1e-10)); + REQUIRE(EllipIntSecond(5.95) == Approx(270.7555182).margin(1e-10)); + REQUIRE(EllipIntSecond(5.96) == Approx(273.4826772).margin(1e-10)); + REQUIRE(EllipIntSecond(5.97) == Approx(276.2372445).margin(1e-10)); + REQUIRE(EllipIntSecond(5.98) == Approx(279.0194958).margin(1e-10)); + REQUIRE(EllipIntSecond(5.99) == Approx(281.8297091).margin(1e-10)); + REQUIRE(EllipIntSecond(6.) == Approx(284.6681655).margin(1e-10)); + REQUIRE(EllipIntSecond(6.01) == Approx(287.5351489).margin(1e-10)); + REQUIRE(EllipIntSecond(6.02) == Approx(290.4309459).margin(1e-10)); + REQUIRE(EllipIntSecond(6.03) == Approx(293.3558462).margin(1e-10)); + REQUIRE(EllipIntSecond(6.04) == Approx(296.3101422).margin(1e-10)); + REQUIRE(EllipIntSecond(6.05) == Approx(299.2941294).margin(1e-10)); + REQUIRE(EllipIntSecond(6.06) == Approx(302.3081062).margin(1e-10)); + REQUIRE(EllipIntSecond(6.07) == Approx(305.3523739).margin(1e-10)); + REQUIRE(EllipIntSecond(6.08) == Approx(308.427237).margin(1e-10)); + REQUIRE(EllipIntSecond(6.09) == Approx(311.5330031).margin(1e-10)); + REQUIRE(EllipIntSecond(6.1) == Approx(314.6699826).margin(1e-10)); + REQUIRE(EllipIntSecond(6.11) == Approx(317.8384892).margin(1e-10)); + REQUIRE(EllipIntSecond(6.12) == Approx(321.0388399).margin(1e-10)); + REQUIRE(EllipIntSecond(6.13) == Approx(324.2713546).margin(1e-10)); + REQUIRE(EllipIntSecond(6.14) == Approx(327.5363567).margin(1e-10)); + REQUIRE(EllipIntSecond(6.15) == Approx(330.8341725).margin(1e-10)); + REQUIRE(EllipIntSecond(6.16) == Approx(334.165132).margin(1e-10)); + REQUIRE(EllipIntSecond(6.17) == Approx(337.5295682).margin(1e-10)); + REQUIRE(EllipIntSecond(6.18) == Approx(340.9278175).margin(1e-10)); + REQUIRE(EllipIntSecond(6.19) == Approx(344.3602198).margin(1e-10)); + REQUIRE(EllipIntSecond(6.2) == Approx(347.8271183).margin(1e-10)); + REQUIRE(EllipIntSecond(6.21) == Approx(351.3288597).margin(1e-10)); + REQUIRE(EllipIntSecond(6.22) == Approx(354.8657942).margin(1e-10)); + REQUIRE(EllipIntSecond(6.23) == Approx(358.4382754).margin(1e-10)); + REQUIRE(EllipIntSecond(6.24) == Approx(362.0466608).margin(1e-10)); + REQUIRE(EllipIntSecond(6.25) == Approx(365.6913109).margin(1e-10)); + REQUIRE(EllipIntSecond(6.26) == Approx(369.3725905).margin(1e-10)); + REQUIRE(EllipIntSecond(6.27) == Approx(373.0908675).margin(1e-10)); + REQUIRE(EllipIntSecond(6.28) == Approx(376.8465138).margin(1e-10)); + REQUIRE(EllipIntSecond(6.29) == Approx(380.639905).margin(1e-10)); + REQUIRE(EllipIntSecond(6.3) == Approx(384.4714204).margin(1e-10)); + REQUIRE(EllipIntSecond(6.31) == Approx(388.3414431).margin(1e-10)); + REQUIRE(EllipIntSecond(6.32) == Approx(392.2503603).margin(1e-10)); + REQUIRE(EllipIntSecond(6.33) == Approx(396.1985627).margin(1e-10)); + REQUIRE(EllipIntSecond(6.34) == Approx(400.1864452).margin(1e-10)); + REQUIRE(EllipIntSecond(6.35) == Approx(404.2144066).margin(1e-10)); + REQUIRE(EllipIntSecond(6.36) == Approx(408.2828497).margin(1e-10)); + REQUIRE(EllipIntSecond(6.37) == Approx(412.3921813).margin(1e-10)); + REQUIRE(EllipIntSecond(6.38) == Approx(416.5428124).margin(1e-10)); + REQUIRE(EllipIntSecond(6.39) == Approx(420.735158).margin(1e-10)); + REQUIRE(EllipIntSecond(6.4) == Approx(424.9696374).margin(1e-10)); + REQUIRE(EllipIntSecond(6.41) == Approx(429.246674).margin(1e-10)); + REQUIRE(EllipIntSecond(6.42) == Approx(433.5666955).margin(1e-10)); + REQUIRE(EllipIntSecond(6.43) == Approx(437.930134).margin(1e-10)); + REQUIRE(EllipIntSecond(6.44) == Approx(442.3374258).margin(1e-10)); + REQUIRE(EllipIntSecond(6.45) == Approx(446.7890116).margin(1e-10)); + REQUIRE(EllipIntSecond(6.46) == Approx(451.2853366).margin(1e-10)); + REQUIRE(EllipIntSecond(6.47) == Approx(455.8268504).margin(1e-10)); + REQUIRE(EllipIntSecond(6.48) == Approx(460.4140071).margin(1e-10)); + REQUIRE(EllipIntSecond(6.49) == Approx(465.0472656).margin(1e-10)); + REQUIRE(EllipIntSecond(6.5) == Approx(469.7270891).margin(1e-10)); + REQUIRE(EllipIntSecond(6.51) == Approx(474.4539455).margin(1e-10)); + REQUIRE(EllipIntSecond(6.52) == Approx(479.2283077).margin(1e-10)); + REQUIRE(EllipIntSecond(6.53) == Approx(484.050653).margin(1e-10)); + REQUIRE(EllipIntSecond(6.54) == Approx(488.9214637).margin(1e-10)); + REQUIRE(EllipIntSecond(6.55) == Approx(493.8412269).margin(1e-10)); + REQUIRE(EllipIntSecond(6.56) == Approx(498.8104345).margin(1e-10)); + REQUIRE(EllipIntSecond(6.57) == Approx(503.8295835).margin(1e-10)); + REQUIRE(EllipIntSecond(6.58) == Approx(508.8991757).margin(1e-10)); + REQUIRE(EllipIntSecond(6.59) == Approx(514.0197182).margin(1e-10)); + REQUIRE(EllipIntSecond(6.6) == Approx(519.191723).margin(1e-10)); + REQUIRE(EllipIntSecond(6.61) == Approx(524.4157073).margin(1e-10)); + REQUIRE(EllipIntSecond(6.62) == Approx(529.6921936).margin(1e-10)); + REQUIRE(EllipIntSecond(6.63) == Approx(535.0217094).margin(1e-10)); + REQUIRE(EllipIntSecond(6.64) == Approx(540.4047877).margin(1e-10)); + REQUIRE(EllipIntSecond(6.65) == Approx(545.8419669).margin(1e-10)); + REQUIRE(EllipIntSecond(6.66) == Approx(551.3337906).margin(1e-10)); + REQUIRE(EllipIntSecond(6.67) == Approx(556.8808081).margin(1e-10)); + REQUIRE(EllipIntSecond(6.68) == Approx(562.483574).margin(1e-10)); + REQUIRE(EllipIntSecond(6.69) == Approx(568.1426486).margin(1e-10)); + REQUIRE(EllipIntSecond(6.7) == Approx(573.8585979).margin(1e-10)); + REQUIRE(EllipIntSecond(6.71) == Approx(579.6319935).margin(1e-10)); + REQUIRE(EllipIntSecond(6.72) == Approx(585.4634126).margin(1e-10)); + REQUIRE(EllipIntSecond(6.73) == Approx(591.3534385).margin(1e-10)); + REQUIRE(EllipIntSecond(6.74) == Approx(597.3026601).margin(1e-10)); + REQUIRE(EllipIntSecond(6.75) == Approx(603.3116724).margin(1e-10)); + REQUIRE(EllipIntSecond(6.76) == Approx(609.3810763).margin(1e-10)); + REQUIRE(EllipIntSecond(6.77) == Approx(615.5114787).margin(1e-10)); + REQUIRE(EllipIntSecond(6.78) == Approx(621.7034926).margin(1e-10)); + REQUIRE(EllipIntSecond(6.79) == Approx(627.9577373).margin(1e-10)); + REQUIRE(EllipIntSecond(6.8) == Approx(634.2748383).margin(1e-10)); + REQUIRE(EllipIntSecond(6.81) == Approx(640.6554271).margin(1e-10)); + REQUIRE(EllipIntSecond(6.82) == Approx(647.100142).margin(1e-10)); + REQUIRE(EllipIntSecond(6.83) == Approx(653.6096273).margin(1e-10)); + REQUIRE(EllipIntSecond(6.84) == Approx(660.184534).margin(1e-10)); + REQUIRE(EllipIntSecond(6.85) == Approx(666.8255196).margin(1e-10)); + REQUIRE(EllipIntSecond(6.86) == Approx(673.5332483).margin(1e-10)); + REQUIRE(EllipIntSecond(6.87) == Approx(680.3083907).margin(1e-10)); + REQUIRE(EllipIntSecond(6.88) == Approx(687.1516245).margin(1e-10)); + REQUIRE(EllipIntSecond(6.89) == Approx(694.0636338).margin(1e-10)); + REQUIRE(EllipIntSecond(6.9) == Approx(701.0451101).margin(1e-10)); + REQUIRE(EllipIntSecond(6.91) == Approx(708.0967513).margin(1e-10)); + REQUIRE(EllipIntSecond(6.92) == Approx(715.2192627).margin(1e-10)); + REQUIRE(EllipIntSecond(6.93) == Approx(722.4133566).margin(1e-10)); + REQUIRE(EllipIntSecond(6.94) == Approx(729.6797523).margin(1e-10)); + REQUIRE(EllipIntSecond(6.95) == Approx(737.0191765).margin(1e-10)); + REQUIRE(EllipIntSecond(6.96) == Approx(744.4323631).margin(1e-10)); + REQUIRE(EllipIntSecond(6.97) == Approx(751.9200535).margin(1e-10)); + REQUIRE(EllipIntSecond(6.98) == Approx(759.4829964).margin(1e-10)); + REQUIRE(EllipIntSecond(6.99) == Approx(767.1219482).margin(1e-10)); + REQUIRE(EllipIntSecond(7.) == Approx(774.8376727).margin(1e-10)); + REQUIRE(EllipIntSecond(7.01) == Approx(782.6309415).margin(1e-10)); + REQUIRE(EllipIntSecond(7.02) == Approx(790.502534).margin(1e-10)); + REQUIRE(EllipIntSecond(7.03) == Approx(798.4532373).margin(1e-10)); + REQUIRE(EllipIntSecond(7.04) == Approx(806.4838465).margin(1e-10)); + REQUIRE(EllipIntSecond(7.05) == Approx(814.5951647).margin(1e-10)); + REQUIRE(EllipIntSecond(7.06) == Approx(822.7880029).margin(1e-10)); + REQUIRE(EllipIntSecond(7.07) == Approx(831.0631806).margin(1e-10)); + REQUIRE(EllipIntSecond(7.08) == Approx(839.4215252).margin(1e-10)); + REQUIRE(EllipIntSecond(7.09) == Approx(847.8638725).margin(1e-10)); + REQUIRE(EllipIntSecond(7.1) == Approx(856.3910668).margin(1e-10)); + REQUIRE(EllipIntSecond(7.11) == Approx(865.0039609).margin(1e-10)); + REQUIRE(EllipIntSecond(7.12) == Approx(873.703416).margin(1e-10)); + REQUIRE(EllipIntSecond(7.13) == Approx(882.4903021).margin(1e-10)); + REQUIRE(EllipIntSecond(7.14) == Approx(891.3654978).margin(1e-10)); + REQUIRE(EllipIntSecond(7.15) == Approx(900.3298907).margin(1e-10)); + REQUIRE(EllipIntSecond(7.16) == Approx(909.3843773).margin(1e-10)); + REQUIRE(EllipIntSecond(7.17) == Approx(918.529863).margin(1e-10)); + REQUIRE(EllipIntSecond(7.18) == Approx(927.7672624).margin(1e-10)); + REQUIRE(EllipIntSecond(7.19) == Approx(937.0974991).margin(1e-10)); + REQUIRE(EllipIntSecond(7.2) == Approx(946.5215063).margin(1e-10)); + REQUIRE(EllipIntSecond(7.21) == Approx(956.0402264).margin(1e-10)); + REQUIRE(EllipIntSecond(7.22) == Approx(965.6546111).margin(1e-10)); + REQUIRE(EllipIntSecond(7.23) == Approx(975.3656221).margin(1e-10)); + REQUIRE(EllipIntSecond(7.24) == Approx(985.1742303).margin(1e-10)); + REQUIRE(EllipIntSecond(7.25) == Approx(995.0814167).margin(1e-10)); + REQUIRE(EllipIntSecond(7.26) == Approx(1005.088172).margin(1e-10)); + REQUIRE(EllipIntSecond(7.27) == Approx(1015.195497).margin(1e-10)); + REQUIRE(EllipIntSecond(7.28) == Approx(1025.404402).margin(1e-10)); + REQUIRE(EllipIntSecond(7.29) == Approx(1035.715908).margin(1e-10)); + REQUIRE(EllipIntSecond(7.3) == Approx(1046.131047).margin(1e-10)); + REQUIRE(EllipIntSecond(7.31) == Approx(1056.650859).margin(1e-10)); + REQUIRE(EllipIntSecond(7.32) == Approx(1067.276398).margin(1e-10)); + REQUIRE(EllipIntSecond(7.33) == Approx(1078.008725).margin(1e-10)); + REQUIRE(EllipIntSecond(7.34) == Approx(1088.848913).margin(1e-10)); + REQUIRE(EllipIntSecond(7.35) == Approx(1099.798048).margin(1e-10)); + REQUIRE(EllipIntSecond(7.36) == Approx(1110.857222).margin(1e-10)); + REQUIRE(EllipIntSecond(7.37) == Approx(1122.027544).margin(1e-10)); + REQUIRE(EllipIntSecond(7.38) == Approx(1133.310129).margin(1e-10)); + REQUIRE(EllipIntSecond(7.39) == Approx(1144.706106).margin(1e-10)); + REQUIRE(EllipIntSecond(7.4) == Approx(1156.216614).margin(1e-10)); + REQUIRE(EllipIntSecond(7.41) == Approx(1167.842805).margin(1e-10)); + REQUIRE(EllipIntSecond(7.42) == Approx(1179.585841).margin(1e-10)); + REQUIRE(EllipIntSecond(7.43) == Approx(1191.446897).margin(1e-10)); + REQUIRE(EllipIntSecond(7.44) == Approx(1203.427158).margin(1e-10)); + REQUIRE(EllipIntSecond(7.45) == Approx(1215.527823).margin(1e-10)); + REQUIRE(EllipIntSecond(7.46) == Approx(1227.750101).margin(1e-10)); + REQUIRE(EllipIntSecond(7.47) == Approx(1240.095216).margin(1e-10)); + REQUIRE(EllipIntSecond(7.48) == Approx(1252.5644).margin(1e-10)); + REQUIRE(EllipIntSecond(7.49) == Approx(1265.158903).margin(1e-10)); + REQUIRE(EllipIntSecond(7.5) == Approx(1277.879982).margin(1e-10)); + REQUIRE(EllipIntSecond(7.51) == Approx(1290.72891).margin(1e-10)); + REQUIRE(EllipIntSecond(7.52) == Approx(1303.706972).margin(1e-10)); + REQUIRE(EllipIntSecond(7.53) == Approx(1316.815466).margin(1e-10)); + REQUIRE(EllipIntSecond(7.54) == Approx(1330.055702).margin(1e-10)); + REQUIRE(EllipIntSecond(7.55) == Approx(1343.429005).margin(1e-10)); + REQUIRE(EllipIntSecond(7.56) == Approx(1356.936711).margin(1e-10)); + REQUIRE(EllipIntSecond(7.57) == Approx(1370.580173).margin(1e-10)); + REQUIRE(EllipIntSecond(7.58) == Approx(1384.360753).margin(1e-10)); + REQUIRE(EllipIntSecond(7.59) == Approx(1398.279831).margin(1e-10)); + REQUIRE(EllipIntSecond(7.6) == Approx(1412.338797).margin(1e-10)); + REQUIRE(EllipIntSecond(7.61) == Approx(1426.539059).margin(1e-10)); + REQUIRE(EllipIntSecond(7.62) == Approx(1440.882036).margin(1e-10)); + REQUIRE(EllipIntSecond(7.63) == Approx(1455.369162).margin(1e-10)); + REQUIRE(EllipIntSecond(7.64) == Approx(1470.001886).margin(1e-10)); + REQUIRE(EllipIntSecond(7.65) == Approx(1484.781671).margin(1e-10)); + REQUIRE(EllipIntSecond(7.66) == Approx(1499.709996).margin(1e-10)); + REQUIRE(EllipIntSecond(7.67) == Approx(1514.788352).margin(1e-10)); + REQUIRE(EllipIntSecond(7.68) == Approx(1530.018249).margin(1e-10)); + REQUIRE(EllipIntSecond(7.69) == Approx(1545.401209).margin(1e-10)); + REQUIRE(EllipIntSecond(7.7) == Approx(1560.93877).margin(1e-10)); + REQUIRE(EllipIntSecond(7.71) == Approx(1576.632486).margin(1e-10)); + REQUIRE(EllipIntSecond(7.72) == Approx(1592.483927).margin(1e-10)); + REQUIRE(EllipIntSecond(7.73) == Approx(1608.494677).margin(1e-10)); + REQUIRE(EllipIntSecond(7.74) == Approx(1624.666338).margin(1e-10)); + REQUIRE(EllipIntSecond(7.75) == Approx(1641.000527).margin(1e-10)); + REQUIRE(EllipIntSecond(7.76) == Approx(1657.498878).margin(1e-10)); + REQUIRE(EllipIntSecond(7.77) == Approx(1674.163039).margin(1e-10)); + REQUIRE(EllipIntSecond(7.78) == Approx(1690.994678).margin(1e-10)); + REQUIRE(EllipIntSecond(7.79) == Approx(1707.995478).margin(1e-10)); + REQUIRE(EllipIntSecond(7.8) == Approx(1725.167138).margin(1e-10)); + REQUIRE(EllipIntSecond(7.81) == Approx(1742.511377).margin(1e-10)); + REQUIRE(EllipIntSecond(7.82) == Approx(1760.029928).margin(1e-10)); + REQUIRE(EllipIntSecond(7.83) == Approx(1777.724544).margin(1e-10)); + REQUIRE(EllipIntSecond(7.84) == Approx(1795.596993).margin(1e-10)); + REQUIRE(EllipIntSecond(7.85) == Approx(1813.649064).margin(1e-10)); + REQUIRE(EllipIntSecond(7.86) == Approx(1831.882561).margin(1e-10)); + REQUIRE(EllipIntSecond(7.87) == Approx(1850.299307).margin(1e-10)); + REQUIRE(EllipIntSecond(7.88) == Approx(1868.901145).margin(1e-10)); + REQUIRE(EllipIntSecond(7.89) == Approx(1887.689935).margin(1e-10)); + REQUIRE(EllipIntSecond(7.9) == Approx(1906.667555).margin(1e-10)); + REQUIRE(EllipIntSecond(7.91) == Approx(1925.835903).margin(1e-10)); + REQUIRE(EllipIntSecond(7.92) == Approx(1945.196897).margin(1e-10)); + REQUIRE(EllipIntSecond(7.93) == Approx(1964.752471).margin(1e-10)); + REQUIRE(EllipIntSecond(7.94) == Approx(1984.504583).margin(1e-10)); + REQUIRE(EllipIntSecond(7.95) == Approx(2004.455206).margin(1e-10)); + REQUIRE(EllipIntSecond(7.96) == Approx(2024.606336).margin(1e-10)); + REQUIRE(EllipIntSecond(7.97) == Approx(2044.959989).margin(1e-10)); + REQUIRE(EllipIntSecond(7.98) == Approx(2065.518199).margin(1e-10)); + REQUIRE(EllipIntSecond(7.99) == Approx(2086.283023).margin(1e-10)); + REQUIRE(EllipIntSecond(8.) == Approx(2107.256537).margin(1e-10)); + REQUIRE(EllipIntSecond(8.01) == Approx(2128.440838).margin(1e-10)); + REQUIRE(EllipIntSecond(8.02) == Approx(2149.838045).margin(1e-10)); + REQUIRE(EllipIntSecond(8.03) == Approx(2171.450297).margin(1e-10)); + REQUIRE(EllipIntSecond(8.04) == Approx(2193.279756).margin(1e-10)); + REQUIRE(EllipIntSecond(8.05) == Approx(2215.328605).margin(1e-10)); + REQUIRE(EllipIntSecond(8.06) == Approx(2237.599048).margin(1e-10)); + REQUIRE(EllipIntSecond(8.07) == Approx(2260.093313).margin(1e-10)); + REQUIRE(EllipIntSecond(8.08) == Approx(2282.81365).margin(1e-10)); + REQUIRE(EllipIntSecond(8.09) == Approx(2305.762329).margin(1e-10)); + REQUIRE(EllipIntSecond(8.1) == Approx(2328.941646).margin(1e-10)); + REQUIRE(EllipIntSecond(8.11) == Approx(2352.35392).margin(1e-10)); + REQUIRE(EllipIntSecond(8.12) == Approx(2376.00149).margin(1e-10)); + REQUIRE(EllipIntSecond(8.13) == Approx(2399.886723).margin(1e-10)); + REQUIRE(EllipIntSecond(8.14) == Approx(2424.012006).margin(1e-10)); + REQUIRE(EllipIntSecond(8.15) == Approx(2448.379753).margin(1e-10)); + REQUIRE(EllipIntSecond(8.16) == Approx(2472.992399).margin(1e-10)); + REQUIRE(EllipIntSecond(8.17) == Approx(2497.852407).margin(1e-10)); + REQUIRE(EllipIntSecond(8.18) == Approx(2522.962262).margin(1e-10)); + REQUIRE(EllipIntSecond(8.19) == Approx(2548.324475).margin(1e-10)); + REQUIRE(EllipIntSecond(8.2) == Approx(2573.941582).margin(1e-10)); + REQUIRE(EllipIntSecond(8.21) == Approx(2599.816146).margin(1e-10)); + REQUIRE(EllipIntSecond(8.22) == Approx(2625.950753).margin(1e-10)); + REQUIRE(EllipIntSecond(8.23) == Approx(2652.348018).margin(1e-10)); + REQUIRE(EllipIntSecond(8.24) == Approx(2679.010579).margin(1e-10)); + REQUIRE(EllipIntSecond(8.25) == Approx(2705.941104).margin(1e-10)); + REQUIRE(EllipIntSecond(8.26) == Approx(2733.142285).margin(1e-10)); + REQUIRE(EllipIntSecond(8.27) == Approx(2760.616842).margin(1e-10)); + REQUIRE(EllipIntSecond(8.28) == Approx(2788.367524).margin(1e-10)); + REQUIRE(EllipIntSecond(8.29) == Approx(2816.397104).margin(1e-10)); + REQUIRE(EllipIntSecond(8.3) == Approx(2844.708386).margin(1e-10)); + REQUIRE(EllipIntSecond(8.31) == Approx(2873.304202).margin(1e-10)); + REQUIRE(EllipIntSecond(8.32) == Approx(2902.18741).margin(1e-10)); + REQUIRE(EllipIntSecond(8.33) == Approx(2931.360899).margin(1e-10)); + REQUIRE(EllipIntSecond(8.34) == Approx(2960.827586).margin(1e-10)); + REQUIRE(EllipIntSecond(8.35) == Approx(2990.590419).margin(1e-10)); + REQUIRE(EllipIntSecond(8.36) == Approx(3020.652373).margin(1e-10)); + REQUIRE(EllipIntSecond(8.37) == Approx(3051.016455).margin(1e-10)); + REQUIRE(EllipIntSecond(8.38) == Approx(3081.685701).margin(1e-10)); + REQUIRE(EllipIntSecond(8.39) == Approx(3112.663178).margin(1e-10)); + REQUIRE(EllipIntSecond(8.4) == Approx(3143.951984).margin(1e-10)); + REQUIRE(EllipIntSecond(8.41) == Approx(3175.555247).margin(1e-10)); + REQUIRE(EllipIntSecond(8.42) == Approx(3207.476129).margin(1e-10)); + REQUIRE(EllipIntSecond(8.43) == Approx(3239.71782).margin(1e-10)); + REQUIRE(EllipIntSecond(8.44) == Approx(3272.283547).margin(1e-10)); + REQUIRE(EllipIntSecond(8.45) == Approx(3305.176564).margin(1e-10)); + REQUIRE(EllipIntSecond(8.46) == Approx(3338.400161).margin(1e-10)); + REQUIRE(EllipIntSecond(8.47) == Approx(3371.957661).margin(1e-10)); + REQUIRE(EllipIntSecond(8.48) == Approx(3405.85242).margin(1e-10)); + REQUIRE(EllipIntSecond(8.49) == Approx(3440.087827).margin(1e-10)); + REQUIRE(EllipIntSecond(8.5) == Approx(3474.667305).margin(1e-10)); + REQUIRE(EllipIntSecond(8.51) == Approx(3509.594313).margin(1e-10)); + REQUIRE(EllipIntSecond(8.52) == Approx(3544.872343).margin(1e-10)); + REQUIRE(EllipIntSecond(8.53) == Approx(3580.504923).margin(1e-10)); + REQUIRE(EllipIntSecond(8.54) == Approx(3616.495616).margin(1e-10)); + REQUIRE(EllipIntSecond(8.55) == Approx(3652.848022).margin(1e-10)); + REQUIRE(EllipIntSecond(8.56) == Approx(3689.565776).margin(1e-10)); + REQUIRE(EllipIntSecond(8.57) == Approx(3726.652549).margin(1e-10)); + REQUIRE(EllipIntSecond(8.58) == Approx(3764.112051).margin(1e-10)); + REQUIRE(EllipIntSecond(8.59) == Approx(3801.948026).margin(1e-10)); + REQUIRE(EllipIntSecond(8.6) == Approx(3840.16426).margin(1e-10)); + REQUIRE(EllipIntSecond(8.61) == Approx(3878.764573).margin(1e-10)); + REQUIRE(EllipIntSecond(8.62) == Approx(3917.752826).margin(1e-10)); + REQUIRE(EllipIntSecond(8.63) == Approx(3957.132917).margin(1e-10)); + REQUIRE(EllipIntSecond(8.64) == Approx(3996.908785).margin(1e-10)); + REQUIRE(EllipIntSecond(8.65) == Approx(4037.084407).margin(1e-10)); + REQUIRE(EllipIntSecond(8.66) == Approx(4077.6638).margin(1e-10)); + REQUIRE(EllipIntSecond(8.67) == Approx(4118.651024).margin(1e-10)); + REQUIRE(EllipIntSecond(8.68) == Approx(4160.050175).margin(1e-10)); + REQUIRE(EllipIntSecond(8.69) == Approx(4201.865396).margin(1e-10)); + REQUIRE(EllipIntSecond(8.7) == Approx(4244.100866).margin(1e-10)); + REQUIRE(EllipIntSecond(8.71) == Approx(4286.760809).margin(1e-10)); + REQUIRE(EllipIntSecond(8.72) == Approx(4329.849492).margin(1e-10)); + REQUIRE(EllipIntSecond(8.73) == Approx(4373.371224).margin(1e-10)); + REQUIRE(EllipIntSecond(8.74) == Approx(4417.330356).margin(1e-10)); + REQUIRE(EllipIntSecond(8.75) == Approx(4461.731285).margin(1e-10)); + REQUIRE(EllipIntSecond(8.76) == Approx(4506.578451).margin(1e-10)); + REQUIRE(EllipIntSecond(8.77) == Approx(4551.876338).margin(1e-10)); + REQUIRE(EllipIntSecond(8.78) == Approx(4597.629476).margin(1e-10)); + REQUIRE(EllipIntSecond(8.79) == Approx(4643.842442).margin(1e-10)); + REQUIRE(EllipIntSecond(8.8) == Approx(4690.519855).margin(1e-10)); + REQUIRE(EllipIntSecond(8.81) == Approx(4737.666384).margin(1e-10)); + REQUIRE(EllipIntSecond(8.82) == Approx(4785.286743).margin(1e-10)); + REQUIRE(EllipIntSecond(8.83) == Approx(4833.385695).margin(1e-10)); + REQUIRE(EllipIntSecond(8.84) == Approx(4881.96805).margin(1e-10)); + REQUIRE(EllipIntSecond(8.85) == Approx(4931.038665).margin(1e-10)); + REQUIRE(EllipIntSecond(8.86) == Approx(4980.602449).margin(1e-10)); + REQUIRE(EllipIntSecond(8.87) == Approx(5030.664356).margin(1e-10)); + REQUIRE(EllipIntSecond(8.88) == Approx(5081.229394).margin(1e-10)); + REQUIRE(EllipIntSecond(8.89) == Approx(5132.302619).margin(1e-10)); + REQUIRE(EllipIntSecond(8.9) == Approx(5183.889139).margin(1e-10)); + REQUIRE(EllipIntSecond(8.91) == Approx(5235.994112).margin(1e-10)); + REQUIRE(EllipIntSecond(8.92) == Approx(5288.622748).margin(1e-10)); + REQUIRE(EllipIntSecond(8.93) == Approx(5341.780311).margin(1e-10)); + REQUIRE(EllipIntSecond(8.94) == Approx(5395.472117).margin(1e-10)); + REQUIRE(EllipIntSecond(8.95) == Approx(5449.703534).margin(1e-10)); + REQUIRE(EllipIntSecond(8.96) == Approx(5504.479985).margin(1e-10)); + REQUIRE(EllipIntSecond(8.97) == Approx(5559.80695).margin(1e-10)); + REQUIRE(EllipIntSecond(8.98) == Approx(5615.689959).margin(1e-10)); + REQUIRE(EllipIntSecond(8.99) == Approx(5672.134602).margin(1e-10)); + REQUIRE(EllipIntSecond(9.) == Approx(5729.146524).margin(1e-10)); + REQUIRE(EllipIntSecond(9.01) == Approx(5786.731424).margin(1e-10)); + REQUIRE(EllipIntSecond(9.02) == Approx(5844.895063).margin(1e-10)); + REQUIRE(EllipIntSecond(9.03) == Approx(5903.643255).margin(1e-10)); + REQUIRE(EllipIntSecond(9.04) == Approx(5962.981877).margin(1e-10)); + REQUIRE(EllipIntSecond(9.05) == Approx(6022.916862).margin(1e-10)); + REQUIRE(EllipIntSecond(9.06) == Approx(6083.454204).margin(1e-10)); + REQUIRE(EllipIntSecond(9.07) == Approx(6144.599956).margin(1e-10)); + REQUIRE(EllipIntSecond(9.08) == Approx(6206.360233).margin(1e-10)); + REQUIRE(EllipIntSecond(9.09) == Approx(6268.741211).margin(1e-10)); + REQUIRE(EllipIntSecond(9.1) == Approx(6331.749128).margin(1e-10)); + REQUIRE(EllipIntSecond(9.11) == Approx(6395.390285).margin(1e-10)); + REQUIRE(EllipIntSecond(9.12) == Approx(6459.671047).margin(1e-10)); + REQUIRE(EllipIntSecond(9.13) == Approx(6524.597841).margin(1e-10)); + REQUIRE(EllipIntSecond(9.14) == Approx(6590.17716).margin(1e-10)); + REQUIRE(EllipIntSecond(9.15) == Approx(6656.415563).margin(1e-10)); + REQUIRE(EllipIntSecond(9.16) == Approx(6723.319672).margin(1e-10)); + REQUIRE(EllipIntSecond(9.17) == Approx(6790.896179).margin(1e-10)); + REQUIRE(EllipIntSecond(9.18) == Approx(6859.151841).margin(1e-10)); + REQUIRE(EllipIntSecond(9.19) == Approx(6928.093484).margin(1e-10)); + REQUIRE(EllipIntSecond(9.2) == Approx(6997.728002).margin(1e-10)); + REQUIRE(EllipIntSecond(9.21) == Approx(7068.062358).margin(1e-10)); + REQUIRE(EllipIntSecond(9.22) == Approx(7139.103586).margin(1e-10)); + REQUIRE(EllipIntSecond(9.23) == Approx(7210.858791).margin(1e-10)); + REQUIRE(EllipIntSecond(9.24) == Approx(7283.335147).margin(1e-10)); + REQUIRE(EllipIntSecond(9.25) == Approx(7356.539903).margin(1e-10)); + REQUIRE(EllipIntSecond(9.26) == Approx(7430.480379).margin(1e-10)); + REQUIRE(EllipIntSecond(9.27) == Approx(7505.163969).margin(1e-10)); + REQUIRE(EllipIntSecond(9.28) == Approx(7580.598142).margin(1e-10)); + REQUIRE(EllipIntSecond(9.29) == Approx(7656.790441).margin(1e-10)); + REQUIRE(EllipIntSecond(9.3) == Approx(7733.748485).margin(1e-10)); + REQUIRE(EllipIntSecond(9.31) == Approx(7811.47997).margin(1e-10)); + REQUIRE(EllipIntSecond(9.32) == Approx(7889.99267).margin(1e-10)); + REQUIRE(EllipIntSecond(9.33) == Approx(7969.294435).margin(1e-10)); + REQUIRE(EllipIntSecond(9.34) == Approx(8049.393196).margin(1e-10)); + REQUIRE(EllipIntSecond(9.35) == Approx(8130.296964).margin(1e-10)); + REQUIRE(EllipIntSecond(9.36) == Approx(8212.013827).margin(1e-10)); + REQUIRE(EllipIntSecond(9.37) == Approx(8294.551959).margin(1e-10)); + REQUIRE(EllipIntSecond(9.38) == Approx(8377.919613).margin(1e-10)); + REQUIRE(EllipIntSecond(9.39) == Approx(8462.125126).margin(1e-10)); + REQUIRE(EllipIntSecond(9.4) == Approx(8547.176918).margin(1e-10)); + REQUIRE(EllipIntSecond(9.41) == Approx(8633.083495).margin(1e-10)); + REQUIRE(EllipIntSecond(9.42) == Approx(8719.853447).margin(1e-10)); + REQUIRE(EllipIntSecond(9.43) == Approx(8807.495452).margin(1e-10)); + REQUIRE(EllipIntSecond(9.44) == Approx(8896.018273).margin(1e-10)); + REQUIRE(EllipIntSecond(9.45) == Approx(8985.430764).margin(1e-10)); + REQUIRE(EllipIntSecond(9.46) == Approx(9075.741866).margin(1e-10)); + REQUIRE(EllipIntSecond(9.47) == Approx(9166.960608).margin(1e-10)); + REQUIRE(EllipIntSecond(9.48) == Approx(9259.096115).margin(1e-10)); + REQUIRE(EllipIntSecond(9.49) == Approx(9352.157599).margin(1e-10)); + REQUIRE(EllipIntSecond(9.5) == Approx(9446.154366).margin(1e-10)); + REQUIRE(EllipIntSecond(9.51) == Approx(9541.095816).margin(1e-10)); + REQUIRE(EllipIntSecond(9.52) == Approx(9636.991444).margin(1e-10)); + REQUIRE(EllipIntSecond(9.53) == Approx(9733.850839).margin(1e-10)); + REQUIRE(EllipIntSecond(9.54) == Approx(9831.683687).margin(1e-10)); + REQUIRE(EllipIntSecond(9.55) == Approx(9930.499772).margin(1e-10)); + REQUIRE(EllipIntSecond(9.56) == Approx(10030.30897).margin(1e-10)); + REQUIRE(EllipIntSecond(9.57) == Approx(10131.12128).margin(1e-10)); + REQUIRE(EllipIntSecond(9.58) == Approx(10232.94676).margin(1e-10)); + REQUIRE(EllipIntSecond(9.59) == Approx(10335.7956).margin(1e-10)); + REQUIRE(EllipIntSecond(9.6) == Approx(10439.6781).margin(1e-10)); + REQUIRE(EllipIntSecond(9.61) == Approx(10544.60463).margin(1e-10)); + REQUIRE(EllipIntSecond(9.62) == Approx(10650.58569).margin(1e-10)); + REQUIRE(EllipIntSecond(9.63) == Approx(10757.63187).margin(1e-10)); + REQUIRE(EllipIntSecond(9.64) == Approx(10865.75389).margin(1e-10)); + REQUIRE(EllipIntSecond(9.65) == Approx(10974.96255).margin(1e-10)); + REQUIRE(EllipIntSecond(9.66) == Approx(11085.26878).margin(1e-10)); + REQUIRE(EllipIntSecond(9.67) == Approx(11196.68361).margin(1e-10)); + REQUIRE(EllipIntSecond(9.68) == Approx(11309.21817).margin(1e-10)); + REQUIRE(EllipIntSecond(9.69) == Approx(11422.88372).margin(1e-10)); + REQUIRE(EllipIntSecond(9.7) == Approx(11537.69163).margin(1e-10)); + REQUIRE(EllipIntSecond(9.71) == Approx(11653.65338).margin(1e-10)); + REQUIRE(EllipIntSecond(9.72) == Approx(11770.78057).margin(1e-10)); + REQUIRE(EllipIntSecond(9.73) == Approx(11889.0849).margin(1e-10)); + REQUIRE(EllipIntSecond(9.74) == Approx(12008.57821).margin(1e-10)); + REQUIRE(EllipIntSecond(9.75) == Approx(12129.27245).margin(1e-10)); + REQUIRE(EllipIntSecond(9.76) == Approx(12251.17968).margin(1e-10)); + REQUIRE(EllipIntSecond(9.77) == Approx(12374.31211).margin(1e-10)); + REQUIRE(EllipIntSecond(9.78) == Approx(12498.68203).margin(1e-10)); + REQUIRE(EllipIntSecond(9.79) == Approx(12624.30189).margin(1e-10)); + REQUIRE(EllipIntSecond(9.8) == Approx(12751.18426).margin(1e-10)); + REQUIRE(EllipIntSecond(9.81) == Approx(12879.34181).margin(1e-10)); + REQUIRE(EllipIntSecond(9.82) == Approx(13008.78737).margin(1e-10)); + REQUIRE(EllipIntSecond(9.83) == Approx(13139.53388).margin(1e-10)); + REQUIRE(EllipIntSecond(9.84) == Approx(13271.59441).margin(1e-10)); + REQUIRE(EllipIntSecond(9.85) == Approx(13404.98217).margin(1e-10)); + REQUIRE(EllipIntSecond(9.86) == Approx(13539.7105).margin(1e-10)); + REQUIRE(EllipIntSecond(9.87) == Approx(13675.79288).margin(1e-10)); + REQUIRE(EllipIntSecond(9.88) == Approx(13813.2429).margin(1e-10)); + REQUIRE(EllipIntSecond(9.89) == Approx(13952.07432).margin(1e-10)); + REQUIRE(EllipIntSecond(9.9) == Approx(14092.30102).margin(1e-10)); + REQUIRE(EllipIntSecond(9.91) == Approx(14233.93702).margin(1e-10)); + REQUIRE(EllipIntSecond(9.92) == Approx(14376.99648).margin(1e-10)); + REQUIRE(EllipIntSecond(9.93) == Approx(14521.49372).margin(1e-10)); + REQUIRE(EllipIntSecond(9.94) == Approx(14667.44318).margin(1e-10)); + REQUIRE(EllipIntSecond(9.95) == Approx(14814.85946).margin(1e-10)); + REQUIRE(EllipIntSecond(9.96) == Approx(14963.75729).margin(1e-10)); + REQUIRE(EllipIntSecond(9.97) == Approx(15114.15157).margin(1e-10)); + REQUIRE(EllipIntSecond(9.98) == Approx(15266.05734).margin(1e-10)); + REQUIRE(EllipIntSecond(9.99) == Approx(15419.48979).margin(1e-10)); + REQUIRE(EllipIntSecond(10.) == Approx(15574.46426).margin(1e-10)); +} \ No newline at end of file diff --git a/tests/unittests/baryotests/CMakeLists.txt b/tests/unittests/baryotests/CMakeLists.txt index 3d752c96..7379bbba 100644 --- a/tests/unittests/baryotests/CMakeLists.txt +++ b/tests/unittests/baryotests/CMakeLists.txt @@ -1,11 +1,20 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later file(GLOB SOURCE_FILES "Test-*.cpp" CONFIURE_DEPENDS) add_executable(BaryoTests ${SOURCE_FILES}) -target_link_libraries(BaryoTests PRIVATE - Catch2::Catch2WithMain CatchEventListener Minimizer Models Utility TestCompares ThermalFunctions Baryo) +target_link_libraries( + BaryoTests + PRIVATE Catch2::Catch2WithMain + CatchEventListener + Minimizer + Models + Utility + TestCompares + ThermalFunctions + Baryo) target_compile_features(BaryoTests PUBLIC cxx_std_17) include(Catch) diff --git a/tests/unittests/baryotests/Test-baryo-c2hdm.cpp b/tests/unittests/baryotests/Test-baryo-c2hdm.cpp index 0f20528a..4549f503 100644 --- a/tests/unittests/baryotests/Test-baryo-c2hdm.cpp +++ b/tests/unittests/baryotests/Test-baryo-c2hdm.cpp @@ -93,8 +93,8 @@ void CheckFileForConfig(const std::string &filename, std::pair, int> config; try { - BSMPT::Baryo::CalculateEtaInterface etaInterface(std::vector(5, true), - 1); + BSMPT::Baryo::CalculateEtaInterface etaInterface( + std::vector(5, true), 1, BSMPT::GetSMConstants()); config = etaInterface.ReadConfigFile(filename); } catch (std::exception &e) @@ -132,9 +132,11 @@ const Compare_C2HDM Expected; TEST_CASE("Checking EWBG for C2HDM", "[c2hdm]") { + using namespace BSMPT; + const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::C2HDM); + ModelID::FChoose(ModelID::ModelIDs::C2HDM, SMConstants); modelPointer->initModel(example_point_C2HDM); const auto WhichMin = Minimizer::WhichMinimizerDefault; @@ -163,7 +165,7 @@ TEST_CASE("Checking EWBG for C2HDM", "[c2hdm]") auto config = std::pair, int>{std::vector(5, true), 1}; - Baryo::CalculateEtaInterface EtaInterface(config); + Baryo::CalculateEtaInterface EtaInterface(config, SMConstants); const double testVW = Expected.testVW; REQUIRE(EWPT.vc > EWPT.Tc); diff --git a/tools/ModelGeneration/sympy/SM.py b/tools/ModelGeneration/sympy/SM.py index 85a6396c..90ecc77e 100644 --- a/tools/ModelGeneration/sympy/SM.py +++ b/tools/ModelGeneration/sympy/SM.py @@ -88,7 +88,7 @@ VFLep += (EL[i] * PiLep[i, j] * ER[j]) * phi[1] VFLep = simplify(VFLep) -LepBase = NuL + ER + EL +LepBase = symbols('eL eR muL muR tauL tauR veL vmuL vtauL', real=True) # Generate Quark Potentials UL = symbols("uL cL tL", real=True) @@ -120,7 +120,6 @@ ) VQuark = simplify(VQuark[0, 0]) - # Generate the model toyModel = ModelGenerator.ModelGenerator( params, dparams, CTTadpoles, Higgsfields, VHiggs, zeroTempVEV, finiteTempVEV diff --git a/tools/cmake/BSMPTConfig.cmake.in b/tools/cmake/BSMPTConfig.cmake.in index 616e9560..18bac8e9 100644 --- a/tools/cmake/BSMPTConfig.cmake.in +++ b/tools/cmake/BSMPTConfig.cmake.in @@ -22,5 +22,9 @@ if(@NLopt_FOUND@) find_dependency(NLopt @NLopt_VERSION@) endif(@NLopt_FOUND@) +if(@nlohmann_json_FOUND@) + find_dependency(nlohmann_json @nlohmann_json_VERSION@) +endif() + # Add the targets file include("${CMAKE_CURRENT_LIST_DIR}/BSMPTTargets.cmake") diff --git a/tools/cmake/CMAES.cmake b/tools/cmake/CMAES.cmake index 3d77e156..99b34f8c 100644 --- a/tools/cmake/CMAES.cmake +++ b/tools/cmake/CMAES.cmake @@ -1,36 +1,33 @@ -find_package(OpenMP REQUIRED) +find_package(OpenMP QUIET) find_package(libcmaes 0.10 QUIET) - if(NOT libcmaes_FOUND) - set(BSMPT_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") - set(BSMPT_CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}") - set(BSMPT_CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}") - set(EXPORT_CMAES TRUE) - FetchContent_Declare( - libcmaes - GIT_REPOSITORY https://github.com/CMA-ES/libcmaes.git - GIT_TAG v0.10) - FetchContent_GetProperties(libcmaes) - if(NOT libcmaes_POPULATED) - option(LIBCMAES_BUILD_TESTS OFF) - option(LIBCMAES_BUILD_PYTHON OFF) - option(LIBCMAES_BUILD_EXAMPLES OFF) - FetchContent_Populate(libcmaes) - add_subdirectory(${libcmaes_SOURCE_DIR} ${libcmaes_BINARY_DIR}) - include (GenerateExportHeader) - generate_export_header (cmaes EXPORT_FILE_NAME ${libcmaes_SOURCE_DIR}/include/libcmaes/cmaes_export.h) - message(STATUS ${libcmaes_SOURCE_DIR}) - set(CodeCoverageExcludesFromOtherPkgs - ${CodeCoverageExcludesFromOtherPkgs} - "${libcmaes_SOURCE_DIR}/*" - ) - endif() - - - - set(libcmaes_FOUND TRUE) - else() - set(CodeCoverageExcludesFromOtherPkgs - ${CodeCoverageExcludesFromOtherPkgs} - "${libcmaes_ROOT_DIR}/*" - ) +if(NOT libcmaes_FOUND) + set(BSMPT_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + set(BSMPT_CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}") + set(BSMPT_CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}") + set(EXPORT_CMAES TRUE) + FetchContent_Declare( + libcmaes + GIT_REPOSITORY https://github.com/CMA-ES/libcmaes.git + GIT_TAG v0.10) + FetchContent_GetProperties(libcmaes) + if(NOT libcmaes_POPULATED) + option(LIBCMAES_BUILD_TESTS OFF) + option(LIBCMAES_BUILD_PYTHON OFF) + option(LIBCMAES_BUILD_EXAMPLES OFF) + option(LIBCMAES_USE_OPENMP OpenMP_FOUND) + FetchContent_Populate(libcmaes) + add_subdirectory(${libcmaes_SOURCE_DIR} ${libcmaes_BINARY_DIR}) + include(GenerateExportHeader) + generate_export_header( + cmaes EXPORT_FILE_NAME + ${libcmaes_SOURCE_DIR}/include/libcmaes/cmaes_export.h) + message(STATUS ${libcmaes_SOURCE_DIR}) + set(CodeCoverageExcludesFromOtherPkgs ${CodeCoverageExcludesFromOtherPkgs} + "${libcmaes_SOURCE_DIR}/*") endif() + + set(libcmaes_FOUND TRUE) +else() + set(CodeCoverageExcludesFromOtherPkgs ${CodeCoverageExcludesFromOtherPkgs} + "${libcmaes_ROOT_DIR}/*") +endif() diff --git a/tools/cmake/CodeCoverage.cmake b/tools/cmake/CodeCoverage.cmake index aef3d943..84cb99bb 100644 --- a/tools/cmake/CodeCoverage.cmake +++ b/tools/cmake/CodeCoverage.cmake @@ -1,134 +1,113 @@ -# Copyright (c) 2012 - 2017, Lars Bilke -# All rights reserved. +# Copyright (c) 2012 - 2017, Lars Bilke All rights reserved. # -# Redistribution and use in source and binary forms, with or without modification, -# are permitted provided that the following conditions are met: +# 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. +# list of conditions and the following disclaimer. +# +# 1. 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. +# +# 1. 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. # # CHANGES: # -# 2012-01-31, Lars Bilke -# - Enable Code Coverage +# 2012-01-31, Lars Bilke - Enable Code Coverage # -# 2013-09-17, Joakim Söderberg -# - Added support for Clang. -# - Some additional usage instructions. +# 2013-09-17, Joakim Söderberg - Added support for Clang. - Some additional +# usage instructions. # -# 2016-02-03, Lars Bilke -# - Refactored functions to use named parameters +# 2016-02-03, Lars Bilke - Refactored functions to use named parameters # -# 2017-06-02, Lars Bilke -# - Merged with modified version from github.com/ufz/ogs +# 2017-06-02, Lars Bilke - Merged with modified version from github.com/ufz/ogs # -# 2019-05-06, Anatolii Kurotych -# - Remove unnecessary --coverage flag +# 2019-05-06, Anatolii Kurotych - Remove unnecessary --coverage flag # -# 2019-12-13, FeRD (Frank Dana) -# - Deprecate COVERAGE_LCOVR_EXCLUDES and COVERAGE_GCOVR_EXCLUDES lists in favor -# of tool-agnostic COVERAGE_EXCLUDES variable, or EXCLUDE setup arguments. -# - CMake 3.4+: All excludes can be specified relative to BASE_DIRECTORY -# - All setup functions: accept BASE_DIRECTORY, EXCLUDE list -# - Set lcov basedir with -b argument -# - Add automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be -# overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().) -# - Delete output dir, .info file on 'make clean' -# - Remove Python detection, since version mismatches will break gcovr -# - Minor cleanup (lowercase function names, update examples...) +# 2019-12-13, FeRD (Frank Dana) - Deprecate COVERAGE_LCOVR_EXCLUDES and +# COVERAGE_GCOVR_EXCLUDES lists in favor of tool-agnostic COVERAGE_EXCLUDES +# variable, or EXCLUDE setup arguments. - CMake 3.4+: All excludes can be +# specified relative to BASE_DIRECTORY - All setup functions: accept +# BASE_DIRECTORY, EXCLUDE list - Set lcov basedir with -b argument - Add +# automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be +# overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().) - +# Delete output dir, .info file on 'make clean' - Remove Python detection, since +# version mismatches will break gcovr - Minor cleanup (lowercase function names, +# update examples...) # -# 2019-12-19, FeRD (Frank Dana) -# - Rename Lcov outputs, make filtered file canonical, fix cleanup for targets +# 2019-12-19, FeRD (Frank Dana) - Rename Lcov outputs, make filtered file +# canonical, fix cleanup for targets # -# 2020-01-19, Bob Apthorpe -# - Added gfortran support +# 2020-01-19, Bob Apthorpe - Added gfortran support # -# 2020-02-17, FeRD (Frank Dana) -# - Make all add_custom_target()s VERBATIM to auto-escape wildcard characters -# in EXCLUDEs, and remove manual escaping from gcovr targets +# 2020-02-17, FeRD (Frank Dana) - Make all add_custom_target()s VERBATIM to +# auto-escape wildcard characters in EXCLUDEs, and remove manual escaping from +# gcovr targets # -# 2021-01-19, Robin Mueller -# - Add CODE_COVERAGE_VERBOSE option which will allow to print out commands which are run -# - Added the option for users to set the GCOVR_ADDITIONAL_ARGS variable to supply additional -# flags to the gcovr command +# 2021-01-19, Robin Mueller - Add CODE_COVERAGE_VERBOSE option which will allow +# to print out commands which are run - Added the option for users to set the +# GCOVR_ADDITIONAL_ARGS variable to supply additional flags to the gcovr command # -# 2020-05-04, Mihchael Davis -# - Add -fprofile-abs-path to make gcno files contain absolute paths -# - Fix BASE_DIRECTORY not working when defined -# - Change BYPRODUCT from folder to index.html to stop ninja from complaining about double defines +# 2020-05-04, Mihchael Davis - Add -fprofile-abs-path to make gcno files contain +# absolute paths - Fix BASE_DIRECTORY not working when defined - Change +# BYPRODUCT from folder to index.html to stop ninja from complaining about +# double defines # -# 2021-05-10, Martin Stump -# - Check if the generator is multi-config before warning about non-Debug builds +# 2021-05-10, Martin Stump - Check if the generator is multi-config before +# warning about non-Debug builds # -# 2022-02-22, Marko Wehle -# - Change gcovr output from -o for --xml and --html output respectively. -# This will allow for Multiple Output Formats at the same time by making use of GCOVR_ADDITIONAL_ARGS, e.g. GCOVR_ADDITIONAL_ARGS "--txt". +# 2022-02-22, Marko Wehle - Change gcovr output from -o for --xml +# and --html output respectively. This will allow for +# Multiple Output Formats at the same time by making use of +# GCOVR_ADDITIONAL_ARGS, e.g. GCOVR_ADDITIONAL_ARGS "--txt". # # USAGE: # # 1. Copy this file into your cmake modules path. # -# 2. Add the following line to your CMakeLists.txt (best inside an if-condition -# using a CMake option() to enable it just optionally): -# include(CodeCoverage) +# 1. Add the following line to your CMakeLists.txt (best inside an if-condition +# using a CMake option() to enable it just optionally): include(CodeCoverage) # -# 3. Append necessary compiler flags for all supported source files: -# append_coverage_compiler_flags() -# Or for specific target: -# append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME) +# 1. Append necessary compiler flags for all supported source files: +# append_coverage_compiler_flags() Or for specific target: +# append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME) # # 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og # -# 4. If you need to exclude additional directories from the report, specify them -# using full paths in the COVERAGE_EXCLUDES variable before calling -# setup_target_for_coverage_*(). -# Example: -# set(COVERAGE_EXCLUDES -# '${PROJECT_SOURCE_DIR}/src/dir1/*' -# '/path/to/my/src/dir2/*') -# Or, use the EXCLUDE argument to setup_target_for_coverage_*(). -# Example: -# setup_target_for_coverage_lcov( -# NAME coverage -# EXECUTABLE testrunner -# EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" "/path/to/my/src/dir2/*") +# 1. If you need to exclude additional directories from the report, specify them +# using full paths in the COVERAGE_EXCLUDES variable before calling +# setup_target_for_coverage_*(). Example: set(COVERAGE_EXCLUDES +# '${PROJECT_SOURCE_DIR}/src/dir1/*' +# '/path/to/my/src/dir2/*') Or, use the EXCLUDE argument to +# setup_target_for_coverage_*(). Example: setup_target_for_coverage_lcov( NAME +# coverage EXECUTABLE testrunner EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" +# "/path/to/my/src/dir2/*") # # 4.a NOTE: With CMake 3.4+, COVERAGE_EXCLUDES or EXCLUDE can also be set -# relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR) -# Example: -# set(COVERAGE_EXCLUDES "dir1/*") -# setup_target_for_coverage_gcovr_html( -# NAME coverage -# EXECUTABLE testrunner -# BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src" -# EXCLUDE "dir2/*") +# relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR) Example: +# set(COVERAGE_EXCLUDES "dir1/*") setup_target_for_coverage_gcovr_html( NAME +# coverage EXECUTABLE testrunner BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src" +# EXCLUDE "dir2/*") # -# 5. Use the functions described below to create a custom make target which -# runs your test executable and produces a code coverage report. +# 1. Use the functions described below to create a custom make target which runs +# your test executable and produces a code coverage report. # -# 6. Build a Debug build: -# cmake -DCMAKE_BUILD_TYPE=Debug .. -# make -# make my_coverage_target +# 1. Build a Debug build: cmake -DCMAKE_BUILD_TYPE=Debug .. make make +# my_coverage_target # include(CMakeParseArguments) @@ -136,584 +115,653 @@ include(CMakeParseArguments) option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE) # Check prereqs -find_program( GCOV_PATH gcov ) -find_program( LCOV_PATH NAMES lcov lcov.bat lcov.exe lcov.perl) -find_program( FASTCOV_PATH NAMES fastcov fastcov.py ) -find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat ) -find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test) -find_program( CPPFILT_PATH NAMES c++filt ) +find_program(GCOV_PATH gcov) +find_program(LCOV_PATH NAMES lcov lcov.bat lcov.exe lcov.perl) +find_program(FASTCOV_PATH NAMES fastcov fastcov.py) +find_program(GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat) +find_program(GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test) +find_program(CPPFILT_PATH NAMES c++filt) if(NOT GCOV_PATH) - message(FATAL_ERROR "gcov not found! Aborting...") + message(FATAL_ERROR "gcov not found! Aborting...") endif() # NOT GCOV_PATH get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES) list(GET LANGUAGES 0 LANG) if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang") - if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3) - message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...") - endif() + if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3) + message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...") + endif() elseif(NOT CMAKE_COMPILER_IS_GNUCXX) - if("${CMAKE_Fortran_COMPILER_ID}" MATCHES "[Ff]lang") - # Do nothing; exit conditional without error if true - elseif("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU") - # Do nothing; exit conditional without error if true - else() - message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") - endif() + if("${CMAKE_Fortran_COMPILER_ID}" MATCHES "[Ff]lang") + # Do nothing; exit conditional without error if true + elseif("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU") + # Do nothing; exit conditional without error if true + else() + message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") + endif() endif() -set(COVERAGE_COMPILER_FLAGS "-g -fprofile-arcs -ftest-coverage" +set(COVERAGE_COMPILER_FLAGS + "-g -fprofile-arcs -ftest-coverage" CACHE INTERNAL "") if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)") - include(CheckCXXCompilerFlag) - check_cxx_compiler_flag(-fprofile-abs-path HAVE_fprofile_abs_path) - if(HAVE_fprofile_abs_path) - set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path") - endif() + include(CheckCXXCompilerFlag) + check_cxx_compiler_flag(-fprofile-abs-path HAVE_fprofile_abs_path) + if(HAVE_fprofile_abs_path) + set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path") + endif() endif() set(CMAKE_Fortran_FLAGS_COVERAGE ${COVERAGE_COMPILER_FLAGS} CACHE STRING "Flags used by the Fortran compiler during coverage builds." - FORCE ) + FORCE) set(CMAKE_CXX_FLAGS_COVERAGE ${COVERAGE_COMPILER_FLAGS} - CACHE STRING "Flags used by the C++ compiler during coverage builds." - FORCE ) + CACHE STRING "Flags used by the C++ compiler during coverage builds." FORCE) set(CMAKE_C_FLAGS_COVERAGE ${COVERAGE_COMPILER_FLAGS} - CACHE STRING "Flags used by the C compiler during coverage builds." - FORCE ) + CACHE STRING "Flags used by the C compiler during coverage builds." FORCE) set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "" CACHE STRING "Flags used for linking binaries during coverage builds." - FORCE ) + FORCE) set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "" - CACHE STRING "Flags used by the shared libraries linker during coverage builds." - FORCE ) + CACHE STRING + "Flags used by the shared libraries linker during coverage builds." + FORCE) mark_as_advanced( - CMAKE_Fortran_FLAGS_COVERAGE - CMAKE_CXX_FLAGS_COVERAGE - CMAKE_C_FLAGS_COVERAGE - CMAKE_EXE_LINKER_FLAGS_COVERAGE - CMAKE_SHARED_LINKER_FLAGS_COVERAGE ) + CMAKE_Fortran_FLAGS_COVERAGE CMAKE_CXX_FLAGS_COVERAGE CMAKE_C_FLAGS_COVERAGE + CMAKE_EXE_LINKER_FLAGS_COVERAGE CMAKE_SHARED_LINKER_FLAGS_COVERAGE) -get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL + PROPERTY GENERATOR_IS_MULTI_CONFIG) if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)) - message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading") + message( + WARNING + "Code coverage results with an optimised (non-Debug) build may be misleading" + ) endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG) -if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU") - link_libraries(gcov) +if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL + "GNU") + link_libraries(gcov) endif() -# Defines a target for running and collection code coverage information -# Builds dependencies, runs the given executable and outputs reports. -# NOTE! The executable should always have a ZERO as exit code otherwise -# the coverage generation will not complete. -# -# setup_target_for_coverage_lcov( -# NAME testrunner_coverage # New target name -# EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR -# DEPENDENCIES testrunner # Dependencies to build first -# BASE_DIRECTORY "../" # Base directory for report -# # (defaults to PROJECT_SOURCE_DIR) -# EXCLUDE "src/dir1/*" "src/dir2/*" # Patterns to exclude (can be relative -# # to BASE_DIRECTORY, with CMake 3.4+) -# NO_DEMANGLE # Don't demangle C++ symbols -# # even if c++filt is found -# ) +# Defines a target for running and collection code coverage information Builds +# dependencies, runs the given executable and outputs reports. NOTE! The +# executable should always have a ZERO as exit code otherwise the coverage +# generation will not complete. +# +# setup_target_for_coverage_lcov( NAME testrunner_coverage # +# New target name EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in +# PROJECT_BINARY_DIR DEPENDENCIES testrunner # Dependencies +# to build first BASE_DIRECTORY "../" # Base directory +# for report # (defaults to PROJECT_SOURCE_DIR) EXCLUDE "src/dir1/*" +# "src/dir2/*" # Patterns to exclude (can be relative # to +# BASE_DIRECTORY, with CMake 3.4+) NO_DEMANGLE # +# Don't demangle C++ symbols # even if c++filt is found ) function(setup_target_for_coverage_lcov) - set(options NO_DEMANGLE) - set(oneValueArgs BASE_DIRECTORY NAME) - set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES LCOV_ARGS GENHTML_ARGS) - cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - - if(NOT LCOV_PATH) - message(FATAL_ERROR "lcov not found! Aborting...") - endif() # NOT LCOV_PATH - - if(NOT GENHTML_PATH) - message(FATAL_ERROR "genhtml not found! Aborting...") - endif() # NOT GENHTML_PATH - - # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR - if(DEFINED Coverage_BASE_DIRECTORY) - get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE) - else() - set(BASEDIR ${PROJECT_SOURCE_DIR}) - endif() - - # Collect excludes (CMake 3.4+: Also compute absolute paths) - set(LCOV_EXCLUDES "") - foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_LCOV_EXCLUDES}) - if(CMAKE_VERSION VERSION_GREATER 3.4) - get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR}) - endif() - list(APPEND LCOV_EXCLUDES "${EXCLUDE}") - endforeach() - list(REMOVE_DUPLICATES LCOV_EXCLUDES) - - # Conditional arguments - if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE}) - set(GENHTML_EXTRA_ARGS "--demangle-cpp") - endif() - - # Setting up commands which will be run to generate coverage data. - # Cleanup lcov - set(LCOV_CLEAN_CMD - ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -directory . - -b ${BASEDIR} --zerocounters - ) - # Create baseline to make sure untouched files show up in the report - set(LCOV_BASELINE_CMD - ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -c -i -d . -b - ${BASEDIR} -o ${Coverage_NAME}.base - ) - # Run tests - set(LCOV_EXEC_TESTS_CMD - ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS} - ) - # Capturing lcov counters and generating report - set(LCOV_CAPTURE_CMD - ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --directory . -b - ${BASEDIR} --capture --output-file ${Coverage_NAME}.capture - ) - # add baseline counters - set(LCOV_BASELINE_COUNT_CMD - ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base - -a ${Coverage_NAME}.capture --output-file ${Coverage_NAME}.total - ) - # filter collected data to final coverage report - set(LCOV_FILTER_CMD - ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --remove - ${Coverage_NAME}.total ${LCOV_EXCLUDES} --output-file ${Coverage_NAME}.info - ) - # Generate HTML output - set(LCOV_GEN_HTML_CMD - ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS} -o - ${Coverage_NAME} ${Coverage_NAME}.info - ) - - - if(CODE_COVERAGE_VERBOSE) - message(STATUS "Executed command report") - message(STATUS "Command to clean up lcov: ") - string(REPLACE ";" " " LCOV_CLEAN_CMD_SPACED "${LCOV_CLEAN_CMD}") - message(STATUS "${LCOV_CLEAN_CMD_SPACED}") - - message(STATUS "Command to create baseline: ") - string(REPLACE ";" " " LCOV_BASELINE_CMD_SPACED "${LCOV_BASELINE_CMD}") - message(STATUS "${LCOV_BASELINE_CMD_SPACED}") - - message(STATUS "Command to run the tests: ") - string(REPLACE ";" " " LCOV_EXEC_TESTS_CMD_SPACED "${LCOV_EXEC_TESTS_CMD}") - message(STATUS "${LCOV_EXEC_TESTS_CMD_SPACED}") - - message(STATUS "Command to capture counters and generate report: ") - string(REPLACE ";" " " LCOV_CAPTURE_CMD_SPACED "${LCOV_CAPTURE_CMD}") - message(STATUS "${LCOV_CAPTURE_CMD_SPACED}") - - message(STATUS "Command to add baseline counters: ") - string(REPLACE ";" " " LCOV_BASELINE_COUNT_CMD_SPACED "${LCOV_BASELINE_COUNT_CMD}") - message(STATUS "${LCOV_BASELINE_COUNT_CMD_SPACED}") - - message(STATUS "Command to filter collected data: ") - string(REPLACE ";" " " LCOV_FILTER_CMD_SPACED "${LCOV_FILTER_CMD}") - message(STATUS "${LCOV_FILTER_CMD_SPACED}") - - message(STATUS "Command to generate lcov HTML output: ") - string(REPLACE ";" " " LCOV_GEN_HTML_CMD_SPACED "${LCOV_GEN_HTML_CMD}") - message(STATUS "${LCOV_GEN_HTML_CMD_SPACED}") + set(options NO_DEMANGLE) + set(oneValueArgs BASE_DIRECTORY NAME) + set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES LCOV_ARGS + GENHTML_ARGS) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" + "${multiValueArgs}" ${ARGN}) + + if(NOT LCOV_PATH) + message(FATAL_ERROR "lcov not found! Aborting...") + endif() # NOT LCOV_PATH + + if(NOT GENHTML_PATH) + message(FATAL_ERROR "genhtml not found! Aborting...") + endif() # NOT GENHTML_PATH + + # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR + if(DEFINED Coverage_BASE_DIRECTORY) + get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE) + else() + set(BASEDIR ${PROJECT_SOURCE_DIR}) + endif() + + # Collect excludes (CMake 3.4+: Also compute absolute paths) + set(LCOV_EXCLUDES "") + foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} + ${COVERAGE_LCOV_EXCLUDES}) + if(CMAKE_VERSION VERSION_GREATER 3.4) + get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR}) endif() - - # Setup target - add_custom_target(${Coverage_NAME} - COMMAND ${LCOV_CLEAN_CMD} - COMMAND ${LCOV_BASELINE_CMD} - COMMAND ${LCOV_EXEC_TESTS_CMD} - COMMAND ${LCOV_CAPTURE_CMD} - COMMAND ${LCOV_BASELINE_COUNT_CMD} - COMMAND ${LCOV_FILTER_CMD} - COMMAND ${LCOV_GEN_HTML_CMD} - - # Set output files as GENERATED (will be removed on 'make clean') - BYPRODUCTS - ${Coverage_NAME}.base - ${Coverage_NAME}.capture - ${Coverage_NAME}.total - ${Coverage_NAME}.info - ${Coverage_NAME}/index.html - WORKING_DIRECTORY ${PROJECT_BINARY_DIR} - DEPENDS ${Coverage_DEPENDENCIES} - VERBATIM # Protect arguments to commands - COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." - ) - - # Show where to find the lcov info report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ; - COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info." - ) - - # Show info where to find the report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ; - COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." - ) + list(APPEND LCOV_EXCLUDES "${EXCLUDE}") + endforeach() + list(REMOVE_DUPLICATES LCOV_EXCLUDES) + + # Conditional arguments + if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE}) + set(GENHTML_EXTRA_ARGS "--demangle-cpp") + endif() + + # Setting up commands which will be run to generate coverage data. Cleanup + # lcov + set(LCOV_CLEAN_CMD + ${LCOV_PATH} + ${Coverage_LCOV_ARGS} + --gcov-tool + ${GCOV_PATH} + -directory + . + -b + ${BASEDIR} + --zerocounters) + # Create baseline to make sure untouched files show up in the report + set(LCOV_BASELINE_CMD + ${LCOV_PATH} + ${Coverage_LCOV_ARGS} + --gcov-tool + ${GCOV_PATH} + -c + -i + -d + . + -b + ${BASEDIR} + -o + ${Coverage_NAME}.base) + # Run tests + set(LCOV_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}) + # Capturing lcov counters and generating report + set(LCOV_CAPTURE_CMD + ${LCOV_PATH} + ${Coverage_LCOV_ARGS} + --gcov-tool + ${GCOV_PATH} + --directory + . + -b + ${BASEDIR} + --capture + --output-file + ${Coverage_NAME}.capture) + # add baseline counters + set(LCOV_BASELINE_COUNT_CMD + ${LCOV_PATH} + ${Coverage_LCOV_ARGS} + --gcov-tool + ${GCOV_PATH} + -a + ${Coverage_NAME}.base + -a + ${Coverage_NAME}.capture + --output-file + ${Coverage_NAME}.total) + # filter collected data to final coverage report + set(LCOV_FILTER_CMD + ${LCOV_PATH} + ${Coverage_LCOV_ARGS} + --gcov-tool + ${GCOV_PATH} + --remove + ${Coverage_NAME}.total + ${LCOV_EXCLUDES} + --output-file + ${Coverage_NAME}.info) + # Generate HTML output + set(LCOV_GEN_HTML_CMD + ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS} -o + ${Coverage_NAME} ${Coverage_NAME}.info) + + if(CODE_COVERAGE_VERBOSE) + message(STATUS "Executed command report") + message(STATUS "Command to clean up lcov: ") + string(REPLACE ";" " " LCOV_CLEAN_CMD_SPACED "${LCOV_CLEAN_CMD}") + message(STATUS "${LCOV_CLEAN_CMD_SPACED}") + + message(STATUS "Command to create baseline: ") + string(REPLACE ";" " " LCOV_BASELINE_CMD_SPACED "${LCOV_BASELINE_CMD}") + message(STATUS "${LCOV_BASELINE_CMD_SPACED}") + + message(STATUS "Command to run the tests: ") + string(REPLACE ";" " " LCOV_EXEC_TESTS_CMD_SPACED "${LCOV_EXEC_TESTS_CMD}") + message(STATUS "${LCOV_EXEC_TESTS_CMD_SPACED}") + + message(STATUS "Command to capture counters and generate report: ") + string(REPLACE ";" " " LCOV_CAPTURE_CMD_SPACED "${LCOV_CAPTURE_CMD}") + message(STATUS "${LCOV_CAPTURE_CMD_SPACED}") + + message(STATUS "Command to add baseline counters: ") + string(REPLACE ";" " " LCOV_BASELINE_COUNT_CMD_SPACED + "${LCOV_BASELINE_COUNT_CMD}") + message(STATUS "${LCOV_BASELINE_COUNT_CMD_SPACED}") + + message(STATUS "Command to filter collected data: ") + string(REPLACE ";" " " LCOV_FILTER_CMD_SPACED "${LCOV_FILTER_CMD}") + message(STATUS "${LCOV_FILTER_CMD_SPACED}") + + message(STATUS "Command to generate lcov HTML output: ") + string(REPLACE ";" " " LCOV_GEN_HTML_CMD_SPACED "${LCOV_GEN_HTML_CMD}") + message(STATUS "${LCOV_GEN_HTML_CMD_SPACED}") + endif() + + # Setup target + add_custom_target( + ${Coverage_NAME} + COMMAND ${LCOV_CLEAN_CMD} + COMMAND ${LCOV_BASELINE_CMD} + COMMAND ${LCOV_EXEC_TESTS_CMD} + COMMAND ${LCOV_CAPTURE_CMD} + COMMAND ${LCOV_BASELINE_COUNT_CMD} + COMMAND ${LCOV_FILTER_CMD} + COMMAND ${LCOV_GEN_HTML_CMD} + # Set output files as GENERATED (will be removed on 'make clean') + BYPRODUCTS ${Coverage_NAME}.base ${Coverage_NAME}.capture + ${Coverage_NAME}.total ${Coverage_NAME}.info + ${Coverage_NAME}/index.html + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + VERBATIM # Protect arguments to commands + COMMENT + "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." + ) + + # Show where to find the lcov info report + add_custom_command( + TARGET ${Coverage_NAME} + POST_BUILD + COMMAND ; + COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info.") + + # Show info where to find the report + add_custom_command( + TARGET ${Coverage_NAME} + POST_BUILD + COMMAND ; + COMMENT + "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." + ) endfunction() # setup_target_for_coverage_lcov -# Defines a target for running and collection code coverage information -# Builds dependencies, runs the given executable and outputs reports. -# NOTE! The executable should always have a ZERO as exit code otherwise -# the coverage generation will not complete. -# -# setup_target_for_coverage_gcovr_xml( -# NAME ctest_coverage # New target name -# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR -# DEPENDENCIES executable_target # Dependencies to build first -# BASE_DIRECTORY "../" # Base directory for report -# # (defaults to PROJECT_SOURCE_DIR) -# EXCLUDE "src/dir1/*" "src/dir2/*" # Patterns to exclude (can be relative -# # to BASE_DIRECTORY, with CMake 3.4+) -# ) -# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the -# GCVOR command. +# Defines a target for running and collection code coverage information Builds +# dependencies, runs the given executable and outputs reports. NOTE! The +# executable should always have a ZERO as exit code otherwise the coverage +# generation will not complete. +# +# setup_target_for_coverage_gcovr_xml( NAME ctest_coverage # +# New target name EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in +# PROJECT_BINARY_DIR DEPENDENCIES executable_target # Dependencies to +# build first BASE_DIRECTORY "../" # Base directory for report +# # (defaults to PROJECT_SOURCE_DIR) EXCLUDE "src/dir1/*" "src/dir2/*" # +# Patterns to exclude (can be relative # to BASE_DIRECTORY, with CMake 3.4+) ) +# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags +# to the GCVOR command. function(setup_target_for_coverage_gcovr_xml) - set(options NONE) - set(oneValueArgs BASE_DIRECTORY NAME) - set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) - cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - - if(NOT GCOVR_PATH) - message(FATAL_ERROR "gcovr not found! Aborting...") - endif() # NOT GCOVR_PATH - - # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR - if(DEFINED Coverage_BASE_DIRECTORY) - get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE) - else() - set(BASEDIR ${PROJECT_SOURCE_DIR}) + set(options NONE) + set(oneValueArgs BASE_DIRECTORY NAME) + set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" + "${multiValueArgs}" ${ARGN}) + + if(NOT GCOVR_PATH) + message(FATAL_ERROR "gcovr not found! Aborting...") + endif() # NOT GCOVR_PATH + + # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR + if(DEFINED Coverage_BASE_DIRECTORY) + get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE) + else() + set(BASEDIR ${PROJECT_SOURCE_DIR}) + endif() + + # Collect excludes (CMake 3.4+: Also compute absolute paths) + set(GCOVR_EXCLUDES "") + foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} + ${COVERAGE_GCOVR_EXCLUDES}) + if(CMAKE_VERSION VERSION_GREATER 3.4) + get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR}) endif() - - # Collect excludes (CMake 3.4+: Also compute absolute paths) - set(GCOVR_EXCLUDES "") - foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES}) - if(CMAKE_VERSION VERSION_GREATER 3.4) - get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR}) - endif() - list(APPEND GCOVR_EXCLUDES "${EXCLUDE}") - endforeach() - list(REMOVE_DUPLICATES GCOVR_EXCLUDES) - - # Combine excludes to several -e arguments - set(GCOVR_EXCLUDE_ARGS "") - foreach(EXCLUDE ${GCOVR_EXCLUDES}) - list(APPEND GCOVR_EXCLUDE_ARGS "-e") - list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}") - endforeach() - - # Set up commands which will be run to generate coverage data - # Run tests - set(GCOVR_XML_EXEC_TESTS_CMD - ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS} - ) - # Running gcovr - set(GCOVR_XML_CMD - ${GCOVR_PATH} --xml ${Coverage_NAME}.xml -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS} - ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR} - ) - - if(CODE_COVERAGE_VERBOSE) - message(STATUS "Executed command report") - - message(STATUS "Command to run tests: ") - string(REPLACE ";" " " GCOVR_XML_EXEC_TESTS_CMD_SPACED "${GCOVR_XML_EXEC_TESTS_CMD}") - message(STATUS "${GCOVR_XML_EXEC_TESTS_CMD_SPACED}") - - message(STATUS "Command to generate gcovr XML coverage data: ") - string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}") - message(STATUS "${GCOVR_XML_CMD_SPACED}") - endif() - - add_custom_target(${Coverage_NAME} - COMMAND ${GCOVR_XML_EXEC_TESTS_CMD} - COMMAND ${GCOVR_XML_CMD} - - BYPRODUCTS ${Coverage_NAME}.xml - WORKING_DIRECTORY ${PROJECT_BINARY_DIR} - DEPENDS ${Coverage_DEPENDENCIES} - VERBATIM # Protect arguments to commands - COMMENT "Running gcovr to produce Cobertura code coverage report." - ) - - # Show info where to find the report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ; - COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml." - ) + list(APPEND GCOVR_EXCLUDES "${EXCLUDE}") + endforeach() + list(REMOVE_DUPLICATES GCOVR_EXCLUDES) + + # Combine excludes to several -e arguments + set(GCOVR_EXCLUDE_ARGS "") + foreach(EXCLUDE ${GCOVR_EXCLUDES}) + list(APPEND GCOVR_EXCLUDE_ARGS "-e") + list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}") + endforeach() + + # Set up commands which will be run to generate coverage data Run tests + set(GCOVR_XML_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} + ${Coverage_EXECUTABLE_ARGS}) + # Running gcovr + set(GCOVR_XML_CMD + ${GCOVR_PATH} + --xml + ${Coverage_NAME}.xml + -r + ${BASEDIR} + ${GCOVR_ADDITIONAL_ARGS} + ${GCOVR_EXCLUDE_ARGS} + --object-directory=${PROJECT_BINARY_DIR}) + + if(CODE_COVERAGE_VERBOSE) + message(STATUS "Executed command report") + + message(STATUS "Command to run tests: ") + string(REPLACE ";" " " GCOVR_XML_EXEC_TESTS_CMD_SPACED + "${GCOVR_XML_EXEC_TESTS_CMD}") + message(STATUS "${GCOVR_XML_EXEC_TESTS_CMD_SPACED}") + + message(STATUS "Command to generate gcovr XML coverage data: ") + string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}") + message(STATUS "${GCOVR_XML_CMD_SPACED}") + endif() + + add_custom_target( + ${Coverage_NAME} + COMMAND ${GCOVR_XML_EXEC_TESTS_CMD} + COMMAND ${GCOVR_XML_CMD} + BYPRODUCTS ${Coverage_NAME}.xml + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + VERBATIM # Protect arguments to commands + COMMENT "Running gcovr to produce Cobertura code coverage report.") + + # Show info where to find the report + add_custom_command( + TARGET ${Coverage_NAME} + POST_BUILD + COMMAND ; + COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml.") endfunction() # setup_target_for_coverage_gcovr_xml -# Defines a target for running and collection code coverage information -# Builds dependencies, runs the given executable and outputs reports. -# NOTE! The executable should always have a ZERO as exit code otherwise -# the coverage generation will not complete. -# -# setup_target_for_coverage_gcovr_html( -# NAME ctest_coverage # New target name -# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR -# DEPENDENCIES executable_target # Dependencies to build first -# BASE_DIRECTORY "../" # Base directory for report -# # (defaults to PROJECT_SOURCE_DIR) -# EXCLUDE "src/dir1/*" "src/dir2/*" # Patterns to exclude (can be relative -# # to BASE_DIRECTORY, with CMake 3.4+) -# ) -# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the -# GCVOR command. +# Defines a target for running and collection code coverage information Builds +# dependencies, runs the given executable and outputs reports. NOTE! The +# executable should always have a ZERO as exit code otherwise the coverage +# generation will not complete. +# +# setup_target_for_coverage_gcovr_html( NAME ctest_coverage # +# New target name EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in +# PROJECT_BINARY_DIR DEPENDENCIES executable_target # Dependencies to +# build first BASE_DIRECTORY "../" # Base directory for report +# # (defaults to PROJECT_SOURCE_DIR) EXCLUDE "src/dir1/*" "src/dir2/*" # +# Patterns to exclude (can be relative # to BASE_DIRECTORY, with CMake 3.4+) ) +# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags +# to the GCVOR command. function(setup_target_for_coverage_gcovr_html) - set(options NONE) - set(oneValueArgs BASE_DIRECTORY NAME) - set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) - cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - - if(NOT GCOVR_PATH) - message(FATAL_ERROR "gcovr not found! Aborting...") - endif() # NOT GCOVR_PATH - - # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR - if(DEFINED Coverage_BASE_DIRECTORY) - get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE) - else() - set(BASEDIR ${PROJECT_SOURCE_DIR}) + set(options NONE) + set(oneValueArgs BASE_DIRECTORY NAME) + set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" + "${multiValueArgs}" ${ARGN}) + + if(NOT GCOVR_PATH) + message(FATAL_ERROR "gcovr not found! Aborting...") + endif() # NOT GCOVR_PATH + + # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR + if(DEFINED Coverage_BASE_DIRECTORY) + get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE) + else() + set(BASEDIR ${PROJECT_SOURCE_DIR}) + endif() + + # Collect excludes (CMake 3.4+: Also compute absolute paths) + set(GCOVR_EXCLUDES "") + foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} + ${COVERAGE_GCOVR_EXCLUDES}) + if(CMAKE_VERSION VERSION_GREATER 3.4) + get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR}) endif() - - # Collect excludes (CMake 3.4+: Also compute absolute paths) - set(GCOVR_EXCLUDES "") - foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES}) - if(CMAKE_VERSION VERSION_GREATER 3.4) - get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR}) - endif() - list(APPEND GCOVR_EXCLUDES "${EXCLUDE}") - endforeach() - list(REMOVE_DUPLICATES GCOVR_EXCLUDES) - - # Combine excludes to several -e arguments - set(GCOVR_EXCLUDE_ARGS "") - foreach(EXCLUDE ${GCOVR_EXCLUDES}) - list(APPEND GCOVR_EXCLUDE_ARGS "-e") - list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}") - endforeach() - - # Set up commands which will be run to generate coverage data - # Run tests - set(GCOVR_HTML_EXEC_TESTS_CMD - ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS} - ) - # Create folder - set(GCOVR_HTML_FOLDER_CMD - ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME} - ) - # Running gcovr - set(GCOVR_HTML_CMD - ${GCOVR_PATH} --html ${Coverage_NAME}/index.html --html-details -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS} - ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR} - ) - - if(CODE_COVERAGE_VERBOSE) - message(STATUS "Executed command report") - - message(STATUS "Command to run tests: ") - string(REPLACE ";" " " GCOVR_HTML_EXEC_TESTS_CMD_SPACED "${GCOVR_HTML_EXEC_TESTS_CMD}") - message(STATUS "${GCOVR_HTML_EXEC_TESTS_CMD_SPACED}") - - message(STATUS "Command to create a folder: ") - string(REPLACE ";" " " GCOVR_HTML_FOLDER_CMD_SPACED "${GCOVR_HTML_FOLDER_CMD}") - message(STATUS "${GCOVR_HTML_FOLDER_CMD_SPACED}") - - message(STATUS "Command to generate gcovr HTML coverage data: ") - string(REPLACE ";" " " GCOVR_HTML_CMD_SPACED "${GCOVR_HTML_CMD}") - message(STATUS "${GCOVR_HTML_CMD_SPACED}") - endif() - - add_custom_target(${Coverage_NAME} - COMMAND ${GCOVR_HTML_EXEC_TESTS_CMD} - COMMAND ${GCOVR_HTML_FOLDER_CMD} - COMMAND ${GCOVR_HTML_CMD} - - BYPRODUCTS ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html # report directory - WORKING_DIRECTORY ${PROJECT_BINARY_DIR} - DEPENDS ${Coverage_DEPENDENCIES} - VERBATIM # Protect arguments to commands - COMMENT "Running gcovr to produce HTML code coverage report." - ) - - # Show info where to find the report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ; - COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." - ) + list(APPEND GCOVR_EXCLUDES "${EXCLUDE}") + endforeach() + list(REMOVE_DUPLICATES GCOVR_EXCLUDES) + + # Combine excludes to several -e arguments + set(GCOVR_EXCLUDE_ARGS "") + foreach(EXCLUDE ${GCOVR_EXCLUDES}) + list(APPEND GCOVR_EXCLUDE_ARGS "-e") + list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}") + endforeach() + + # Set up commands which will be run to generate coverage data Run tests + set(GCOVR_HTML_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} + ${Coverage_EXECUTABLE_ARGS}) + # Create folder + set(GCOVR_HTML_FOLDER_CMD ${CMAKE_COMMAND} -E make_directory + ${PROJECT_BINARY_DIR}/${Coverage_NAME}) + # Running gcovr + set(GCOVR_HTML_CMD + ${GCOVR_PATH} + --html + ${Coverage_NAME}/index.html + --html-details + -r + ${BASEDIR} + ${GCOVR_ADDITIONAL_ARGS} + ${GCOVR_EXCLUDE_ARGS} + --object-directory=${PROJECT_BINARY_DIR}) + + if(CODE_COVERAGE_VERBOSE) + message(STATUS "Executed command report") + + message(STATUS "Command to run tests: ") + string(REPLACE ";" " " GCOVR_HTML_EXEC_TESTS_CMD_SPACED + "${GCOVR_HTML_EXEC_TESTS_CMD}") + message(STATUS "${GCOVR_HTML_EXEC_TESTS_CMD_SPACED}") + + message(STATUS "Command to create a folder: ") + string(REPLACE ";" " " GCOVR_HTML_FOLDER_CMD_SPACED + "${GCOVR_HTML_FOLDER_CMD}") + message(STATUS "${GCOVR_HTML_FOLDER_CMD_SPACED}") + + message(STATUS "Command to generate gcovr HTML coverage data: ") + string(REPLACE ";" " " GCOVR_HTML_CMD_SPACED "${GCOVR_HTML_CMD}") + message(STATUS "${GCOVR_HTML_CMD_SPACED}") + endif() + + add_custom_target( + ${Coverage_NAME} + COMMAND ${GCOVR_HTML_EXEC_TESTS_CMD} + COMMAND ${GCOVR_HTML_FOLDER_CMD} + COMMAND ${GCOVR_HTML_CMD} + BYPRODUCTS ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html # report + # directory + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + VERBATIM # Protect arguments to commands + COMMENT "Running gcovr to produce HTML code coverage report.") + + # Show info where to find the report + add_custom_command( + TARGET ${Coverage_NAME} + POST_BUILD + COMMAND ; + COMMENT + "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." + ) endfunction() # setup_target_for_coverage_gcovr_html -# Defines a target for running and collection code coverage information -# Builds dependencies, runs the given executable and outputs reports. -# NOTE! The executable should always have a ZERO as exit code otherwise -# the coverage generation will not complete. -# -# setup_target_for_coverage_fastcov( -# NAME testrunner_coverage # New target name -# EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR -# DEPENDENCIES testrunner # Dependencies to build first -# BASE_DIRECTORY "../" # Base directory for report -# # (defaults to PROJECT_SOURCE_DIR) -# EXCLUDE "src/dir1/" "src/dir2/" # Patterns to exclude. -# NO_DEMANGLE # Don't demangle C++ symbols -# # even if c++filt is found -# SKIP_HTML # Don't create html report -# POST_CMD perl -i -pe s!${PROJECT_SOURCE_DIR}/!!g ctest_coverage.json # E.g. for stripping source dir from file paths -# ) +# Defines a target for running and collection code coverage information Builds +# dependencies, runs the given executable and outputs reports. NOTE! The +# executable should always have a ZERO as exit code otherwise the coverage +# generation will not complete. +# +# setup_target_for_coverage_fastcov( NAME testrunner_coverage # New target name +# EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR +# DEPENDENCIES testrunner # Dependencies to build first +# BASE_DIRECTORY "../" # Base directory for report # +# (defaults to PROJECT_SOURCE_DIR) EXCLUDE "src/dir1/" "src/dir2/" # Patterns to +# exclude. NO_DEMANGLE # Don't demangle C++ +# symbols # even if c++filt is found SKIP_HTML # Don't create html report +# POST_CMD perl -i -pe s!${PROJECT_SOURCE_DIR}/!!g ctest_coverage.json # E.g. +# for stripping source dir from file paths ) function(setup_target_for_coverage_fastcov) - set(options NO_DEMANGLE SKIP_HTML) - set(oneValueArgs BASE_DIRECTORY NAME) - set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES FASTCOV_ARGS GENHTML_ARGS POST_CMD) - cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - - if(NOT FASTCOV_PATH) - message(FATAL_ERROR "fastcov not found! Aborting...") - endif() - - if(NOT Coverage_SKIP_HTML AND NOT GENHTML_PATH) - message(FATAL_ERROR "genhtml not found! Aborting...") - endif() - - # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR - if(Coverage_BASE_DIRECTORY) - get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE) - else() - set(BASEDIR ${PROJECT_SOURCE_DIR}) - endif() - - # Collect excludes (Patterns, not paths, for fastcov) - set(FASTCOV_EXCLUDES "") - foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_FASTCOV_EXCLUDES}) - list(APPEND FASTCOV_EXCLUDES "${EXCLUDE}") - endforeach() - list(REMOVE_DUPLICATES FASTCOV_EXCLUDES) - - # Conditional arguments - if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE}) - set(GENHTML_EXTRA_ARGS "--demangle-cpp") - endif() - - # Set up commands which will be run to generate coverage data - set(FASTCOV_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}) - - set(FASTCOV_CAPTURE_CMD ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH} - --search-directory ${BASEDIR} - --process-gcno - --output ${Coverage_NAME}.json - --exclude ${FASTCOV_EXCLUDES} - --exclude ${FASTCOV_EXCLUDES} - ) - - set(FASTCOV_CONVERT_CMD ${FASTCOV_PATH} - -C ${Coverage_NAME}.json --lcov --output ${Coverage_NAME}.info - ) + set(options NO_DEMANGLE SKIP_HTML) + set(oneValueArgs BASE_DIRECTORY NAME) + set(multiValueArgs + EXCLUDE + EXECUTABLE + EXECUTABLE_ARGS + DEPENDENCIES + FASTCOV_ARGS + GENHTML_ARGS + POST_CMD) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" + "${multiValueArgs}" ${ARGN}) + + if(NOT FASTCOV_PATH) + message(FATAL_ERROR "fastcov not found! Aborting...") + endif() + + if(NOT Coverage_SKIP_HTML AND NOT GENHTML_PATH) + message(FATAL_ERROR "genhtml not found! Aborting...") + endif() + + # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR + if(Coverage_BASE_DIRECTORY) + get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE) + else() + set(BASEDIR ${PROJECT_SOURCE_DIR}) + endif() + + # Collect excludes (Patterns, not paths, for fastcov) + set(FASTCOV_EXCLUDES "") + foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} + ${COVERAGE_FASTCOV_EXCLUDES}) + list(APPEND FASTCOV_EXCLUDES "${EXCLUDE}") + endforeach() + list(REMOVE_DUPLICATES FASTCOV_EXCLUDES) + + # Conditional arguments + if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE}) + set(GENHTML_EXTRA_ARGS "--demangle-cpp") + endif() + + # Set up commands which will be run to generate coverage data + set(FASTCOV_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}) + + set(FASTCOV_CAPTURE_CMD + ${FASTCOV_PATH} + ${Coverage_FASTCOV_ARGS} + --gcov + ${GCOV_PATH} + --search-directory + ${BASEDIR} + --process-gcno + --output + ${Coverage_NAME}.json + --exclude + ${FASTCOV_EXCLUDES} + --exclude + ${FASTCOV_EXCLUDES}) + + set(FASTCOV_CONVERT_CMD ${FASTCOV_PATH} -C ${Coverage_NAME}.json --lcov + --output ${Coverage_NAME}.info) + + if(Coverage_SKIP_HTML) + set(FASTCOV_HTML_CMD ";") + else() + set(FASTCOV_HTML_CMD + ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS} -o + ${Coverage_NAME} ${Coverage_NAME}.info) + endif() + + set(FASTCOV_POST_CMD ";") + if(Coverage_POST_CMD) + set(FASTCOV_POST_CMD ${Coverage_POST_CMD}) + endif() + + if(CODE_COVERAGE_VERBOSE) + message( + STATUS "Code coverage commands for target ${Coverage_NAME} (fastcov):") + + message(" Running tests:") + string(REPLACE ";" " " FASTCOV_EXEC_TESTS_CMD_SPACED + "${FASTCOV_EXEC_TESTS_CMD}") + message(" ${FASTCOV_EXEC_TESTS_CMD_SPACED}") + + message(" Capturing fastcov counters and generating report:") + string(REPLACE ";" " " FASTCOV_CAPTURE_CMD_SPACED "${FASTCOV_CAPTURE_CMD}") + message(" ${FASTCOV_CAPTURE_CMD_SPACED}") + + message(" Converting fastcov .json to lcov .info:") + string(REPLACE ";" " " FASTCOV_CONVERT_CMD_SPACED "${FASTCOV_CONVERT_CMD}") + message(" ${FASTCOV_CONVERT_CMD_SPACED}") - if(Coverage_SKIP_HTML) - set(FASTCOV_HTML_CMD ";") - else() - set(FASTCOV_HTML_CMD ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS} - -o ${Coverage_NAME} ${Coverage_NAME}.info - ) + if(NOT Coverage_SKIP_HTML) + message(" Generating HTML report: ") + string(REPLACE ";" " " FASTCOV_HTML_CMD_SPACED "${FASTCOV_HTML_CMD}") + message(" ${FASTCOV_HTML_CMD_SPACED}") endif() - - set(FASTCOV_POST_CMD ";") if(Coverage_POST_CMD) - set(FASTCOV_POST_CMD ${Coverage_POST_CMD}) - endif() - - if(CODE_COVERAGE_VERBOSE) - message(STATUS "Code coverage commands for target ${Coverage_NAME} (fastcov):") - - message(" Running tests:") - string(REPLACE ";" " " FASTCOV_EXEC_TESTS_CMD_SPACED "${FASTCOV_EXEC_TESTS_CMD}") - message(" ${FASTCOV_EXEC_TESTS_CMD_SPACED}") - - message(" Capturing fastcov counters and generating report:") - string(REPLACE ";" " " FASTCOV_CAPTURE_CMD_SPACED "${FASTCOV_CAPTURE_CMD}") - message(" ${FASTCOV_CAPTURE_CMD_SPACED}") - - message(" Converting fastcov .json to lcov .info:") - string(REPLACE ";" " " FASTCOV_CONVERT_CMD_SPACED "${FASTCOV_CONVERT_CMD}") - message(" ${FASTCOV_CONVERT_CMD_SPACED}") - - if(NOT Coverage_SKIP_HTML) - message(" Generating HTML report: ") - string(REPLACE ";" " " FASTCOV_HTML_CMD_SPACED "${FASTCOV_HTML_CMD}") - message(" ${FASTCOV_HTML_CMD_SPACED}") - endif() - if(Coverage_POST_CMD) - message(" Running post command: ") - string(REPLACE ";" " " FASTCOV_POST_CMD_SPACED "${FASTCOV_POST_CMD}") - message(" ${FASTCOV_POST_CMD_SPACED}") - endif() - endif() - - # Setup target - add_custom_target(${Coverage_NAME} - - # Cleanup fastcov - COMMAND ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH} - --search-directory ${BASEDIR} - --zerocounters - - COMMAND ${FASTCOV_EXEC_TESTS_CMD} - COMMAND ${FASTCOV_CAPTURE_CMD} - COMMAND ${FASTCOV_CONVERT_CMD} - COMMAND ${FASTCOV_HTML_CMD} - COMMAND ${FASTCOV_POST_CMD} - - # Set output files as GENERATED (will be removed on 'make clean') - BYPRODUCTS - ${Coverage_NAME}.info - ${Coverage_NAME}.json - ${Coverage_NAME}/index.html # report directory - - WORKING_DIRECTORY ${PROJECT_BINARY_DIR} - DEPENDS ${Coverage_DEPENDENCIES} - VERBATIM # Protect arguments to commands - COMMENT "Resetting code coverage counters to zero. Processing code coverage counters and generating report." - ) - - set(INFO_MSG "fastcov code coverage info report saved in ${Coverage_NAME}.info and ${Coverage_NAME}.json.") - if(NOT Coverage_SKIP_HTML) - string(APPEND INFO_MSG " Open ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html in your browser to view the coverage report.") + message(" Running post command: ") + string(REPLACE ";" " " FASTCOV_POST_CMD_SPACED "${FASTCOV_POST_CMD}") + message(" ${FASTCOV_POST_CMD_SPACED}") endif() - # Show where to find the fastcov info report - add_custom_command(TARGET ${Coverage_NAME} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E echo ${INFO_MSG} + endif() + + # Setup target + add_custom_target( + ${Coverage_NAME} + # Cleanup fastcov + COMMAND ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH} + --search-directory ${BASEDIR} --zerocounters + COMMAND ${FASTCOV_EXEC_TESTS_CMD} + COMMAND ${FASTCOV_CAPTURE_CMD} + COMMAND ${FASTCOV_CONVERT_CMD} + COMMAND ${FASTCOV_HTML_CMD} + COMMAND ${FASTCOV_POST_CMD} + # Set output files as GENERATED (will be removed on 'make clean') + BYPRODUCTS ${Coverage_NAME}.info ${Coverage_NAME}.json + ${Coverage_NAME}/index.html # report directory + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + VERBATIM # Protect arguments to commands + COMMENT + "Resetting code coverage counters to zero. Processing code coverage counters and generating report." + ) + + set(INFO_MSG + "fastcov code coverage info report saved in ${Coverage_NAME}.info and ${Coverage_NAME}.json." + ) + if(NOT Coverage_SKIP_HTML) + string( + APPEND + INFO_MSG + " Open ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html in your browser to view the coverage report." ) + endif() + # Show where to find the fastcov info report + add_custom_command( + TARGET ${Coverage_NAME} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E echo ${INFO_MSG}) endfunction() # setup_target_for_coverage_fastcov function(append_coverage_compiler_flags) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE) - set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE) - message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}") + set(CMAKE_C_FLAGS + "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" + PARENT_SCOPE) + set(CMAKE_CXX_FLAGS + "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" + PARENT_SCOPE) + set(CMAKE_Fortran_FLAGS + "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" + PARENT_SCOPE) + message( + STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}") endfunction() # append_coverage_compiler_flags # Setup coverage for specific library function(append_coverage_compiler_flags_to_target name) - target_compile_options(${name} - PRIVATE ${COVERAGE_COMPILER_FLAGS}) + target_compile_options(${name} PRIVATE ${COVERAGE_COMPILER_FLAGS}) endfunction() diff --git a/tools/cmake/CompilerOptions.cmake b/tools/cmake/CompilerOptions.cmake index a19c700f..dd6822ce 100644 --- a/tools/cmake/CompilerOptions.cmake +++ b/tools/cmake/CompilerOptions.cmake @@ -1,110 +1,107 @@ -# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +# Müller # # SPDX-License-Identifier: GPL-3.0-or-later add_compile_options( - $<$:-DCOMPILEDEBUG=true> - $<$,$,$>:-pedantic> - $<$,$,$>:-Wall> - $<$,$,$>:-Wextra> - $<$,$,$>:-Wshadow> - $<$,$,$,$>>:-Wmissing-declarations> - $<$,$,$,$>>:-Wmissing-include-dirs> - $<$,$,$,$>>:-O3> - ) + $<$:-DCOMPILEDEBUG=true> + $<$,$,$>:-pedantic> + $<$,$,$>:-Wall> + $<$,$,$>:-Wextra> + $<$,$,$>:-Wshadow> + $<$,$,$,$>>:-Wmissing-declarations> + $<$,$,$,$>>:-Wmissing-include-dirs> + $<$,$,$,$>>:-O3> +) +if(BSMPTUseVectorization) + include(CheckCXXCompilerFlag) + check_cxx_compiler_flag("-march=native" _march_native_works) + check_cxx_compiler_flag("-xHost" _xhost_works) -if(BSMPT_USE_VECTORIZATION) - include(CheckCXXCompilerFlag) - - check_cxx_compiler_flag("-march=native" _march_native_works) - check_cxx_compiler_flag("-xHost" _xhost_works) - - if(_march_native_works) - message(STATUS "Using processor's vector instructions (-march=native compiler flag set)") - add_compile_options(-march=native) - elseif(_xhost_works) - message(STATUS "Using processor's vector instructions (-xHost compiler flag set)") - add_compile_options(-xHost) - else() - message(STATUS "No suitable compiler flag found for vectorization") - endif() -endif(BSMPT_USE_VECTORIZATION) - - add_compile_options( - $<$:/permissive-> - $<$,$>:/bigobj> - $<$:/w44101> - $<$,$>:/Ox> + if(_march_native_works) + message( + STATUS + "Using processor's vector instructions (-march=native compiler flag set)" ) + add_compile_options(-march=native) + elseif(_xhost_works) + message( + STATUS "Using processor's vector instructions (-xHost compiler flag set)") + add_compile_options(-xHost) + else() + message(STATUS "No suitable compiler flag found for vectorization") + endif() +endif(BSMPTUseVectorization) + +add_compile_options( + $<$:/permissive-> + $<$,$>:/bigobj> + $<$:/w44101> + $<$,$>:/Ox>) - list(APPEND MSVC_DISABLED_WARNINGS_LIST - "C4061" # enumerator 'identifier' in switch of enum 'enumeration' is not - # explicitly handled by a case label - # Disable this because it flags even when there is a default. - "C4068" - "C4100" # 'exarg' : unreferenced formal parameter - "C4127" # conditional expression is constant - "C4200" # nonstandard extension used : zero-sized array in - # struct/union. - "C4204" # nonstandard extension used: non-constant aggregate initializer - "C4221" # nonstandard extension used : 'identifier' : cannot be - # initialized using address of automatic variable - "C4242" # 'function' : conversion from 'int' to 'uint8_t', - # possible loss of data - "C4244" # 'function' : conversion from 'int' to 'uint8_t', - # possible loss of data - "C4245" # 'initializing' : conversion from 'long' to - # 'unsigned long', signed/unsigned mismatch - "C4267" # conversion from 'size_t' to 'int', possible loss of data - "C4355" - "C4371" # layout of class may have changed from a previous version of the - # compiler due to better packing of member '...' - "C4388" # signed/unsigned mismatch - "C4296" # '>=' : expression is always true - "C4350" # behavior change: 'std::_Wrap_alloc...' - "C4365" # '=' : conversion from 'size_t' to 'int', - # signed/unsigned mismatch - "C4389" # '!=' : signed/unsigned mismatch - "C4464" # relative include path contains '..' - "C4510" # 'argument' : default constructor could not be generated - "C4571" - "C4512" # 'argument' : assignment operator could not be generated - "C4514" # 'function': unreferenced inline function has been removed - "C4548" # expression before comma has no effect; expected expression with - # side-effect" caused by FD_* macros. - "C4610" # struct 'argument' can never be instantiated - user defined - # constructor required. - "C4619" - "C4623" # default constructor was implicitly defined as deleted - "C4625" # copy constructor could not be generated because a base class - # copy constructor is inaccessible or deleted - "C4626" # assignment operator could not be generated because a base class - # assignment operator is inaccessible or deleted - "C4643" - "C4668" # 'symbol' is not defined as a preprocessor macro, replacing with - # '0' for 'directives' - # Disable this because GTest uses it everywhere. - "C4706" # assignment within conditional expression - "C4710" # 'function': function not inlined - "C4711" # function 'function' selected for inline expansion - "C4800" # 'int' : forcing value to bool 'true' or 'false' - # (performance warning) - "C4820" # 'bytes' bytes padding added after construct 'member_name' - "C4868" - "C4996" - "C5026" # move constructor was implicitly defined as deleted - "C5027" # move assignment operator was implicitly defined as deleted - "C5031" - "C5039" - "C5045" - ) +list( + APPEND + MSVC_DISABLED_WARNINGS_LIST + "C4061" # enumerator 'identifier' in switch of enum 'enumeration' is not + # explicitly handled by a case label Disable this because it flags + # even when there is a default. + "C4068" + "C4100" # 'exarg' : unreferenced formal parameter + "C4127" # conditional expression is constant + "C4200" # nonstandard extension used : zero-sized array in struct/union. + "C4204" # nonstandard extension used: non-constant aggregate initializer + "C4221" # nonstandard extension used : 'identifier' : cannot be initialized + # using address of automatic variable + "C4242" # 'function' : conversion from 'int' to 'uint8_t', possible loss of + # data + "C4244" # 'function' : conversion from 'int' to 'uint8_t', possible loss of + # data + "C4245" # 'initializing' : conversion from 'long' to 'unsigned long', + # signed/unsigned mismatch + "C4267" # conversion from 'size_t' to 'int', possible loss of data + "C4355" + "C4371" # layout of class may have changed from a previous version of the + # compiler due to better packing of member '...' + "C4388" # signed/unsigned mismatch + "C4296" # '>=' : expression is always true + "C4350" # behavior change: 'std::_Wrap_alloc...' + "C4365" # '=' : conversion from 'size_t' to 'int', signed/unsigned mismatch + "C4389" # '!=' : signed/unsigned mismatch + "C4464" # relative include path contains '..' + "C4510" # 'argument' : default constructor could not be generated + "C4571" + "C4512" # 'argument' : assignment operator could not be generated + "C4514" # 'function': unreferenced inline function has been removed + "C4548" # expression before comma has no effect; expected expression with + # side-effect" caused by FD_* macros. + "C4610" # struct 'argument' can never be instantiated - user defined + # constructor required. + "C4619" + "C4623" # default constructor was implicitly defined as deleted + "C4625" # copy constructor could not be generated because a base class copy + # constructor is inaccessible or deleted + "C4626" # assignment operator could not be generated because a base class + # assignment operator is inaccessible or deleted + "C4643" + "C4668" # 'symbol' is not defined as a preprocessor macro, replacing with '0' + # for 'directives' Disable this because GTest uses it everywhere. + "C4706" # assignment within conditional expression + "C4710" # 'function': function not inlined + "C4711" # function 'function' selected for inline expansion + "C4800" # 'int' : forcing value to bool 'true' or 'false' (performance + # warning) + "C4820" # 'bytes' bytes padding added after construct 'member_name' + "C4868" + "C4996" + "C5026" # move constructor was implicitly defined as deleted + "C5027" # move assignment operator was implicitly defined as deleted + "C5031" + "C5039" + "C5045") - foreach(warning IN LISTS MSVC_DISABLED_WARNINGS_LIST) - string(REPLACE "C" "" warning_stripped - ${warning}) - add_compile_options( - $<$:-wd${warning_stripped}> - ) - endforeach() +foreach(warning IN LISTS MSVC_DISABLED_WARNINGS_LIST) + string(REPLACE "C" "" warning_stripped ${warning}) + add_compile_options($<$:-wd${warning_stripped}>) +endforeach() diff --git a/tools/cmake/LTO.cmake b/tools/cmake/LTO.cmake index ca68e047..32878dc3 100644 --- a/tools/cmake/LTO.cmake +++ b/tools/cmake/LTO.cmake @@ -2,252 +2,292 @@ # # Variable : ENABLE_LTO | Enable or disable LTO support for this build # -# find_lto(lang) -# - lang is C or CXX (the language to test LTO for) -# - call it after project() so that the compiler is already detected +# find_lto(lang) - lang is C or CXX (the language to test LTO for) - call it +# after project() so that the compiler is already detected # -# This will check for LTO support and create a target_enable_lto(target [debug,optimized,general]) macro. -# The 2nd parameter has the same meaning as in target_link_libraries, and is used to enable LTO only for those build configurations -# 'debug' is by default the Debug configuration, and 'optimized' all the other configurations +# This will check for LTO support and create a target_enable_lto(target +# [debug,optimized,general]) macro. The 2nd parameter has the same meaning as in +# target_link_libraries, and is used to enable LTO only for those build +# configurations 'debug' is by default the Debug configuration, and 'optimized' +# all the other configurations # # if ENABLE_LTO is set to false, an empty macro will be generated # # Then to enable LTO for your target use # -# target_enable_lto(mytarget general) +# target_enable_lto(mytarget general) # -# It is however recommended to use it only for non debug builds the following way : +# It is however recommended to use it only for non debug builds the following +# way : # -# target_enable_lto(mytarget optimized) +# target_enable_lto(mytarget optimized) # -# Note : For CMake versions < 3.9, target_link_library is used in it's non plain version. -# You will need to specify PUBLIC/PRIVATE/INTERFACE to all your other target_link_library calls for the target +# Note : For CMake versions < 3.9, target_link_library is used in it's non plain +# version. You will need to specify PUBLIC/PRIVATE/INTERFACE to all your other +# target_link_library calls for the target # -# WARNING for cmake versions older than 3.9 : -# This module will override CMAKE_AR CMAKE_RANLIB and CMAKE_NM by the gcc versions if found when building with gcc - +# WARNING for cmake versions older than 3.9 : This module will override CMAKE_AR +# CMAKE_RANLIB and CMAKE_NM by the gcc versions if found when building with gcc # License: # # Copyright (C) 2016 Lectem # -# Permission is hereby granted, free of charge, to any person -# obtaining a copy of this software and associated documentation files -# (the 'Software') deal in the Software without restriction, -# including without limitation the rights to use, copy, modify, merge, -# publish, distribute, sublicense, and/or sell copies of the Software, -# and to permit persons to whom the Software is furnished to do so, -# subject to the following conditions: +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the 'Software') deal in +# the Software without restriction, including without limitation the rights to +# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +# of the Software, and to permit persons to whom the Software is furnished to do +# so, subject to the following conditions: # -# The above copyright notice and this permission notice shall be -# included in all copies or substantial portions of the Software. +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. # -# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, -# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS -# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN -# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. - cmake_minimum_required(VERSION 3.1) option(ENABLE_LTO "enable link time optimization" ON) macro(find_lto lang) - if(ENABLE_LTO AND NOT LTO_${lang}_CHECKED) + if(ENABLE_LTO AND NOT LTO_${lang}_CHECKED) - #LTO support was added for clang/gcc in 3.9 - if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 3.9) - cmake_policy(SET CMP0054 NEW) + # LTO support was added for clang/gcc in 3.9 + if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 3.9) + cmake_policy(SET CMP0054 NEW) message(STATUS "Checking for LTO Compatibility") - # Since GCC 4.9 we need to use gcc-ar / gcc-ranlib / gcc-nm - if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") - if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_GCC_AR OR NOT CMAKE_GCC_RANLIB OR NOT CMAKE_GCC_NM) - find_program(CMAKE_GCC_AR NAMES - "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar" - "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar-${_version}" - DOC "gcc provided wrapper for ar which adds the --plugin option" - ) - find_program(CMAKE_GCC_RANLIB NAMES - "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib" - "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib-${_version}" - DOC "gcc provided wrapper for ranlib which adds the --plugin option" - ) - # Not needed, but at least stay coherent - find_program(CMAKE_GCC_NM NAMES - "${_CMAKE_TOOLCHAIN_PREFIX}gcc-nm" - "${_CMAKE_TOOLCHAIN_PREFIX}gcc-nm-${_version}" - DOC "gcc provided wrapper for nm which adds the --plugin option" - ) - mark_as_advanced(CMAKE_GCC_AR CMAKE_GCC_RANLIB CMAKE_GCC_NM) - set(CMAKE_LTO_AR ${CMAKE_GCC_AR}) - set(CMAKE_LTO_RANLIB ${CMAKE_GCC_RANLIB}) - set(CMAKE_LTO_NM ${CMAKE_GCC_NM}) - endif() - if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") - set(CMAKE_LTO_AR ${CMAKE_AR}) - set(CMAKE_LTO_RANLIB ${CMAKE_RANLIB}) - set(CMAKE_LTO_NM ${CMAKE_NM}) - endif() - - if(CMAKE_LTO_AR AND CMAKE_LTO_RANLIB) - set(__lto_flags -flto) - - if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4.7) - list(APPEND __lto_flags -fno-fat-lto-objects) - endif() - - if(NOT DEFINED CMAKE_${lang}_PASSED_LTO_TEST) - set(__output_dir "${CMAKE_PLATFORM_INFO_DIR}/LtoTest1${lang}") - file(MAKE_DIRECTORY "${__output_dir}") - set(__output_base "${__output_dir}/lto-test-${lang}") - - execute_process( - COMMAND ${CMAKE_COMMAND} -E echo "void foo() {}" - COMMAND ${CMAKE_${lang}_COMPILER} ${__lto_flags} -c -xc - - -o "${__output_base}.o" - RESULT_VARIABLE __result - ERROR_QUIET - OUTPUT_QUIET - ) - - if("${__result}" STREQUAL "0") - execute_process( - COMMAND ${CMAKE_LTO_AR} cr "${__output_base}.a" "${__output_base}.o" - RESULT_VARIABLE __result - ERROR_QUIET - OUTPUT_QUIET - ) - endif() - - if("${__result}" STREQUAL "0") - execute_process( - COMMAND ${CMAKE_LTO_RANLIB} "${__output_base}.a" - RESULT_VARIABLE __result - ERROR_QUIET - OUTPUT_QUIET - ) - endif() - - if("${__result}" STREQUAL "0") - execute_process( - COMMAND ${CMAKE_COMMAND} -E echo "void foo(); int main() {foo();}" - COMMAND ${CMAKE_${lang}_COMPILER} ${__lto_flags} -xc - - -x none "${__output_base}.a" -o "${__output_base}" - RESULT_VARIABLE __result - ERROR_QUIET - OUTPUT_QUIET - ) - endif() - - if("${__result}" STREQUAL "0") - set(__lto_found TRUE) - endif() - - set(CMAKE_${lang}_PASSED_LTO_TEST - ${__lto_found} CACHE INTERNAL - "If the compiler passed a simple LTO test compile") - endif() - if(CMAKE_${lang}_PASSED_LTO_TEST) - message(STATUS "Checking for LTO Compatibility - works") - set(LTO_${lang}_SUPPORT TRUE CACHE BOOL "Do we have LTO support ?") - set(LTO_COMPILE_FLAGS -flto CACHE STRING "Link Time Optimization compile flags") - set(LTO_LINK_FLAGS -flto CACHE STRING "Link Time Optimization link flags") - else() - message(STATUS "Checking for LTO Compatibility - not working") - endif() - - endif() - elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") - message(STATUS "Checking for LTO Compatibility - works (assumed for clang)") - set(LTO_${lang}_SUPPORT TRUE CACHE BOOL "Do we have LTO support ?") - set(LTO_COMPILE_FLAGS -flto CACHE STRING "Link Time Optimization compile flags") - set(LTO_LINK_FLAGS -flto CACHE STRING "Link Time Optimization link flags") - elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") - message(STATUS "Checking for LTO Compatibility - works") - set(LTO_${lang}_SUPPORT TRUE CACHE BOOL "Do we have LTO support ?") - set(LTO_COMPILE_FLAGS /GL CACHE STRING "Link Time Optimization compile flags") - set(LTO_LINK_FLAGS -LTCG:INCREMENTAL CACHE STRING "Link Time Optimization link flags") - else() - message(STATUS "Checking for LTO Compatibility - compiler not handled by module") - endif() - mark_as_advanced(LTO_${lang}_SUPPORT LTO_COMPILE_FLAGS LTO_LINK_FLAGS) + # Since GCC 4.9 we need to use gcc-ar / gcc-ranlib / gcc-nm + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES + "Clang") + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" + AND NOT CMAKE_GCC_AR + OR NOT CMAKE_GCC_RANLIB + OR NOT CMAKE_GCC_NM) + find_program( + CMAKE_GCC_AR + NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar" + "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar-${_version}" + DOC "gcc provided wrapper for ar which adds the --plugin option") + find_program( + CMAKE_GCC_RANLIB + NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib" + "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib-${_version}" + DOC "gcc provided wrapper for ranlib which adds the --plugin option" + ) + # Not needed, but at least stay coherent + find_program( + CMAKE_GCC_NM + NAMES "${_CMAKE_TOOLCHAIN_PREFIX}gcc-nm" + "${_CMAKE_TOOLCHAIN_PREFIX}gcc-nm-${_version}" + DOC "gcc provided wrapper for nm which adds the --plugin option") + mark_as_advanced(CMAKE_GCC_AR CMAKE_GCC_RANLIB CMAKE_GCC_NM) + set(CMAKE_LTO_AR ${CMAKE_GCC_AR}) + set(CMAKE_LTO_RANLIB ${CMAKE_GCC_RANLIB}) + set(CMAKE_LTO_NM ${CMAKE_GCC_NM}) + endif() + if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") + set(CMAKE_LTO_AR ${CMAKE_AR}) + set(CMAKE_LTO_RANLIB ${CMAKE_RANLIB}) + set(CMAKE_LTO_NM ${CMAKE_NM}) + endif() + if(CMAKE_LTO_AR AND CMAKE_LTO_RANLIB) + set(__lto_flags -flto) - set(LTO_${lang}_CHECKED TRUE CACHE INTERNAL "" ) + if(NOT CMAKE_${lang}_COMPILER_VERSION VERSION_LESS 4.7) + list(APPEND __lto_flags -fno-fat-lto-objects) + endif() + + if(NOT DEFINED CMAKE_${lang}_PASSED_LTO_TEST) + set(__output_dir "${CMAKE_PLATFORM_INFO_DIR}/LtoTest1${lang}") + file(MAKE_DIRECTORY "${__output_dir}") + set(__output_base "${__output_dir}/lto-test-${lang}") + + execute_process( + COMMAND ${CMAKE_COMMAND} -E echo "void foo() {}" + COMMAND ${CMAKE_${lang}_COMPILER} ${__lto_flags} -c -xc - -o + "${__output_base}.o" + RESULT_VARIABLE __result + ERROR_QUIET OUTPUT_QUIET) - if(CMAKE_GCC_AR AND CMAKE_GCC_RANLIB AND CMAKE_GCC_NM) - # THIS IS HACKY BUT THERE IS NO OTHER SOLUTION ATM - set(CMAKE_AR ${CMAKE_GCC_AR} CACHE FILEPATH "Forcing gcc-ar instead of ar" FORCE) - set(CMAKE_NM ${CMAKE_GCC_NM} CACHE FILEPATH "Forcing gcc-nm instead of nm" FORCE) - set(CMAKE_RANLIB ${CMAKE_GCC_RANLIB} CACHE FILEPATH "Forcing gcc-ranlib instead of ranlib" FORCE) + if("${__result}" STREQUAL "0") + execute_process( + COMMAND ${CMAKE_LTO_AR} cr "${__output_base}.a" + "${__output_base}.o" + RESULT_VARIABLE __result + ERROR_QUIET OUTPUT_QUIET) endif() - endif(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 3.9) - endif(ENABLE_LTO AND NOT LTO_${lang}_CHECKED) + if("${__result}" STREQUAL "0") + execute_process( + COMMAND ${CMAKE_LTO_RANLIB} "${__output_base}.a" + RESULT_VARIABLE __result + ERROR_QUIET OUTPUT_QUIET) + endif() - if(ENABLE_LTO) - #Special case for cmake older than 3.9, using a library for gcc/clang, but could setup the flags directly. - #Taking advantage of the [debug,optimized] parameter of target_link_libraries - if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 3.9) - if(LTO_${lang}_SUPPORT) - if(NOT TARGET __enable_lto_tgt) - add_library(__enable_lto_tgt INTERFACE) + if("${__result}" STREQUAL "0") + execute_process( + COMMAND ${CMAKE_COMMAND} -E echo + "void foo(); int main() {foo();}" + COMMAND ${CMAKE_${lang}_COMPILER} ${__lto_flags} -xc - -x none + "${__output_base}.a" -o "${__output_base}" + RESULT_VARIABLE __result + ERROR_QUIET OUTPUT_QUIET) endif() - target_compile_options(__enable_lto_tgt INTERFACE ${LTO_COMPILE_FLAGS}) - #this might not work for all platforms... in which case we'll have to set the link flags on the target directly - target_link_libraries(__enable_lto_tgt INTERFACE ${LTO_LINK_FLAGS} ) - macro(target_enable_lto _target _build_configuration) - if(${_build_configuration} STREQUAL "optimized" OR ${_build_configuration} STREQUAL "debug" ) - target_link_libraries(${_target} PRIVATE ${_build_configuration} __enable_lto_tgt) - else() - target_link_libraries(${_target} PRIVATE __enable_lto_tgt) - endif() - endmacro() - else() - #In old cmake versions, we can set INTERPROCEDURAL_OPTIMIZATION even if not supported by the compiler - #So if we didn't detect it, let cmake give it a try - set(__IPO_SUPPORTED TRUE) - endif() - else() - cmake_policy(SET CMP0069 NEW) - include(CheckIPOSupported) - # Optional IPO. Do not use IPO if it's not supported by compiler. - check_ipo_supported(RESULT __IPO_SUPPORTED OUTPUT output) - if(NOT __IPO_SUPPORTED) - message(STATUS "IPO is not supported or broken.") + + if("${__result}" STREQUAL "0") + set(__lto_found TRUE) + endif() + + set(CMAKE_${lang}_PASSED_LTO_TEST + ${__lto_found} + CACHE INTERNAL + "If the compiler passed a simple LTO test compile") + endif() + if(CMAKE_${lang}_PASSED_LTO_TEST) + message(STATUS "Checking for LTO Compatibility - works") + set(LTO_${lang}_SUPPORT + TRUE + CACHE BOOL "Do we have LTO support ?") + set(LTO_COMPILE_FLAGS + -flto + CACHE STRING "Link Time Optimization compile flags") + set(LTO_LINK_FLAGS + -flto + CACHE STRING "Link Time Optimization link flags") else() - message(STATUS "IPO is supported !") + message(STATUS "Checking for LTO Compatibility - not working") endif() + + endif() + elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + message( + STATUS "Checking for LTO Compatibility - works (assumed for clang)") + set(LTO_${lang}_SUPPORT + TRUE + CACHE BOOL "Do we have LTO support ?") + set(LTO_COMPILE_FLAGS + -flto + CACHE STRING "Link Time Optimization compile flags") + set(LTO_LINK_FLAGS + -flto + CACHE STRING "Link Time Optimization link flags") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") + message(STATUS "Checking for LTO Compatibility - works") + set(LTO_${lang}_SUPPORT + TRUE + CACHE BOOL "Do we have LTO support ?") + set(LTO_COMPILE_FLAGS + /GL + CACHE STRING "Link Time Optimization compile flags") + set(LTO_LINK_FLAGS + -LTCG:INCREMENTAL + CACHE STRING "Link Time Optimization link flags") + else() + message( + STATUS + "Checking for LTO Compatibility - compiler not handled by module") endif() - if(__IPO_SUPPORTED) + mark_as_advanced(LTO_${lang}_SUPPORT LTO_COMPILE_FLAGS LTO_LINK_FLAGS) + + set(LTO_${lang}_CHECKED + TRUE + CACHE INTERNAL "") + + if(CMAKE_GCC_AR + AND CMAKE_GCC_RANLIB + AND CMAKE_GCC_NM) + # THIS IS HACKY BUT THERE IS NO OTHER SOLUTION ATM + set(CMAKE_AR + ${CMAKE_GCC_AR} + CACHE FILEPATH "Forcing gcc-ar instead of ar" FORCE) + set(CMAKE_NM + ${CMAKE_GCC_NM} + CACHE FILEPATH "Forcing gcc-nm instead of nm" FORCE) + set(CMAKE_RANLIB + ${CMAKE_GCC_RANLIB} + CACHE FILEPATH "Forcing gcc-ranlib instead of ranlib" FORCE) + endif() + endif(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 3.9) + endif(ENABLE_LTO AND NOT LTO_${lang}_CHECKED) + + if(ENABLE_LTO) + # Special case for cmake older than 3.9, using a library for gcc/clang, but + # could setup the flags directly. Taking advantage of the [debug,optimized] + # parameter of target_link_libraries + if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_LESS 3.9) + if(LTO_${lang}_SUPPORT) + if(NOT TARGET __enable_lto_tgt) + add_library(__enable_lto_tgt INTERFACE) + endif() + target_compile_options(__enable_lto_tgt INTERFACE ${LTO_COMPILE_FLAGS}) + # this might not work for all platforms... in which case we'll have to + # set the link flags on the target directly + target_link_libraries(__enable_lto_tgt INTERFACE ${LTO_LINK_FLAGS}) macro(target_enable_lto _target _build_configuration) - if(NOT ${_build_configuration} STREQUAL "debug" ) - #enable for all configurations - set_target_properties(${_target} PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE) - endif() - if(${_build_configuration} STREQUAL "optimized" ) - #blacklist debug configurations - set(__enable_debug_lto FALSE) - else() - #enable only for debug configurations - set(__enable_debug_lto TRUE) - endif() - get_property(DEBUG_CONFIGURATIONS GLOBAL PROPERTY DEBUG_CONFIGURATIONS) - if(NOT DEBUG_CONFIGURATIONS) - set(DEBUG_CONFIGURATIONS DEBUG) # This is what is done by CMAKE internally... since DEBUG_CONFIGURATIONS is empty by default - endif() - foreach(config IN LISTS DEBUG_CONFIGURATIONS) - set_target_properties(${_target} PROPERTIES INTERPROCEDURAL_OPTIMIZATION_${config} ${__enable_debug_lto}) - endforeach() + if(${_build_configuration} STREQUAL "optimized" + OR ${_build_configuration} STREQUAL "debug") + target_link_libraries(${_target} PRIVATE ${_build_configuration} + __enable_lto_tgt) + else() + target_link_libraries(${_target} PRIVATE __enable_lto_tgt) + endif() endmacro() + else() + # In old cmake versions, we can set INTERPROCEDURAL_OPTIMIZATION even if + # not supported by the compiler So if we didn't detect it, let cmake + # give it a try + set(__IPO_SUPPORTED TRUE) + endif() + else() + cmake_policy(SET CMP0069 NEW) + include(CheckIPOSupported) + # Optional IPO. Do not use IPO if it's not supported by compiler. + check_ipo_supported(RESULT __IPO_SUPPORTED OUTPUT output) + if(NOT __IPO_SUPPORTED) + message(STATUS "IPO is not supported or broken.") + else() + message(STATUS "IPO is supported !") endif() endif() - if(NOT COMMAND target_enable_lto) - macro(target_enable_lto _target _build_configuration) - endmacro() + if(__IPO_SUPPORTED) + macro(target_enable_lto _target _build_configuration) + if(NOT ${_build_configuration} STREQUAL "debug") + # enable for all configurations + set_target_properties(${_target} + PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE) + endif() + if(${_build_configuration} STREQUAL "optimized") + # blacklist debug configurations + set(__enable_debug_lto FALSE) + else() + # enable only for debug configurations + set(__enable_debug_lto TRUE) + endif() + get_property(DEBUG_CONFIGURATIONS GLOBAL PROPERTY DEBUG_CONFIGURATIONS) + if(NOT DEBUG_CONFIGURATIONS) + set(DEBUG_CONFIGURATIONS DEBUG) # This is what is done by CMAKE + # internally... since + # DEBUG_CONFIGURATIONS is empty by + # default + endif() + foreach(config IN LISTS DEBUG_CONFIGURATIONS) + set_target_properties( + ${_target} PROPERTIES INTERPROCEDURAL_OPTIMIZATION_${config} + ${__enable_debug_lto}) + endforeach() + endmacro() endif() + endif() + if(NOT COMMAND target_enable_lto) + macro(target_enable_lto _target _build_configuration) + + endmacro() + endif() endmacro() diff --git a/tools/cmake/conan.cmake b/tools/cmake/conan.cmake deleted file mode 100644 index 208ce248..00000000 --- a/tools/cmake/conan.cmake +++ /dev/null @@ -1,909 +0,0 @@ -# The MIT License (MIT) - -# Copyright (c) 2018 JFrog - -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: - -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. - -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - - - -# This file comes from: https://github.com/conan-io/cmake-conan. Please refer -# to this repository for issues and documentation. - -# Its purpose is to wrap and launch Conan C/C++ Package Manager when cmake is called. -# It will take CMake current settings (os, compiler, compiler version, architecture) -# and translate them to conan settings for installing and retrieving dependencies. - -# It is intended to facilitate developers building projects that have conan dependencies, -# but it is only necessary on the end-user side. It is not necessary to create conan -# packages, in fact it shouldn't be use for that. Check the project documentation. - -# version: 0.18.0-dev - -include(CMakeParseArguments) - -function(_get_msvc_ide_version result) - set(${result} "" PARENT_SCOPE) - if(NOT MSVC_VERSION VERSION_LESS 1400 AND MSVC_VERSION VERSION_LESS 1500) - set(${result} 8 PARENT_SCOPE) - elseif(NOT MSVC_VERSION VERSION_LESS 1500 AND MSVC_VERSION VERSION_LESS 1600) - set(${result} 9 PARENT_SCOPE) - elseif(NOT MSVC_VERSION VERSION_LESS 1600 AND MSVC_VERSION VERSION_LESS 1700) - set(${result} 10 PARENT_SCOPE) - elseif(NOT MSVC_VERSION VERSION_LESS 1700 AND MSVC_VERSION VERSION_LESS 1800) - set(${result} 11 PARENT_SCOPE) - elseif(NOT MSVC_VERSION VERSION_LESS 1800 AND MSVC_VERSION VERSION_LESS 1900) - set(${result} 12 PARENT_SCOPE) - elseif(NOT MSVC_VERSION VERSION_LESS 1900 AND MSVC_VERSION VERSION_LESS 1910) - set(${result} 14 PARENT_SCOPE) - elseif(NOT MSVC_VERSION VERSION_LESS 1910 AND MSVC_VERSION VERSION_LESS 1920) - set(${result} 15 PARENT_SCOPE) - elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930) - set(${result} 16 PARENT_SCOPE) - elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940) - set(${result} 17 PARENT_SCOPE) - else() - message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]") - endif() -endfunction() - -macro(_conan_detect_build_type) - conan_parse_arguments(${ARGV}) - - if(ARGUMENTS_BUILD_TYPE) - set(_CONAN_SETTING_BUILD_TYPE ${ARGUMENTS_BUILD_TYPE}) - elseif(CMAKE_BUILD_TYPE) - set(_CONAN_SETTING_BUILD_TYPE ${CMAKE_BUILD_TYPE}) - else() - message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") - endif() - - string(TOUPPER ${_CONAN_SETTING_BUILD_TYPE} _CONAN_SETTING_BUILD_TYPE_UPPER) - if (_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "DEBUG") - set(_CONAN_SETTING_BUILD_TYPE "Debug") - elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELEASE") - set(_CONAN_SETTING_BUILD_TYPE "Release") - elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELWITHDEBINFO") - set(_CONAN_SETTING_BUILD_TYPE "RelWithDebInfo") - elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "MINSIZEREL") - set(_CONAN_SETTING_BUILD_TYPE "MinSizeRel") - endif() -endmacro() - -macro(_conan_check_system_name) - #handle -s os setting - if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic") - #use default conan os setting if CMAKE_SYSTEM_NAME is not defined - set(CONAN_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}) - if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") - set(CONAN_SYSTEM_NAME Macos) - endif() - if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX") - set(CONAN_SYSTEM_NAME Neutrino) - endif() - set(CONAN_SUPPORTED_PLATFORMS Windows Linux Macos Android iOS FreeBSD WindowsStore WindowsCE watchOS tvOS FreeBSD SunOS AIX Arduino Emscripten Neutrino) - list (FIND CONAN_SUPPORTED_PLATFORMS "${CONAN_SYSTEM_NAME}" _index) - if (${_index} GREATER -1) - #check if the cmake system is a conan supported one - set(_CONAN_SETTING_OS ${CONAN_SYSTEM_NAME}) - else() - message(FATAL_ERROR "cmake system ${CONAN_SYSTEM_NAME} is not supported by conan. Use one of ${CONAN_SUPPORTED_PLATFORMS}") - endif() - endif() -endmacro() - -macro(_conan_check_language) - get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES) - if (";${_languages};" MATCHES ";CXX;") - set(LANGUAGE CXX) - set(USING_CXX 1) - elseif (";${_languages};" MATCHES ";C;") - set(LANGUAGE C) - set(USING_CXX 0) - else () - message(FATAL_ERROR "Conan: Neither C or C++ was detected as a language for the project. Unabled to detect compiler version.") - endif() -endmacro() - -macro(_conan_detect_compiler) - - conan_parse_arguments(${ARGV}) - - if(ARGUMENTS_ARCH) - set(_CONAN_SETTING_ARCH ${ARGUMENTS_ARCH}) - endif() - - if(USING_CXX) - set(_CONAN_SETTING_COMPILER_CPPSTD ${CMAKE_CXX_STANDARD}) - endif() - - if (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL GNU) - # using GCC - # TODO: Handle other params - string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) - list(GET VERSION_LIST 0 MAJOR) - list(GET VERSION_LIST 1 MINOR) - set(COMPILER_VERSION ${MAJOR}.${MINOR}) - if(${MAJOR} GREATER 4) - set(COMPILER_VERSION ${MAJOR}) - endif() - set(_CONAN_SETTING_COMPILER gcc) - set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) - if (USING_CXX) - conan_cmake_detect_unix_libcxx(_LIBCXX) - set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) - endif () - elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Intel) - string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) - list(GET VERSION_LIST 0 MAJOR) - list(GET VERSION_LIST 1 MINOR) - set(COMPILER_VERSION ${MAJOR}.${MINOR}) - set(_CONAN_SETTING_COMPILER intel) - set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) - if (USING_CXX) - conan_cmake_detect_unix_libcxx(_LIBCXX) - set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) - endif () - elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL AppleClang) - # using AppleClang - string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) - list(GET VERSION_LIST 0 MAJOR) - list(GET VERSION_LIST 1 MINOR) - set(_CONAN_SETTING_COMPILER apple-clang) - set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) - if (USING_CXX) - conan_cmake_detect_unix_libcxx(_LIBCXX) - set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) - endif () - elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang) - string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) - list(GET VERSION_LIST 0 MAJOR) - list(GET VERSION_LIST 1 MINOR) - set(_CONAN_SETTING_COMPILER clang) - set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) - if(APPLE) - cmake_policy(GET CMP0025 APPLE_CLANG_POLICY) - if(NOT APPLE_CLANG_POLICY STREQUAL NEW) - message(STATUS "Conan: APPLE and Clang detected. Assuming apple-clang compiler. Set CMP0025 to avoid it") - set(_CONAN_SETTING_COMPILER apple-clang) - endif() - endif() - if(${_CONAN_SETTING_COMPILER} STREQUAL clang AND ${MAJOR} GREATER 7) - set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}) - endif() - if (USING_CXX) - conan_cmake_detect_unix_libcxx(_LIBCXX) - set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) - endif () - elseif(${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL MSVC) - set(_VISUAL "Visual Studio") - _get_msvc_ide_version(_VISUAL_VERSION) - if("${_VISUAL_VERSION}" STREQUAL "") - message(FATAL_ERROR "Conan: Visual Studio not recognized") - else() - set(_CONAN_SETTING_COMPILER ${_VISUAL}) - set(_CONAN_SETTING_COMPILER_VERSION ${_VISUAL_VERSION}) - endif() - - if(NOT _CONAN_SETTING_ARCH) - if (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "64") - set(_CONAN_SETTING_ARCH x86_64) - elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "^ARM") - message(STATUS "Conan: Using default ARM architecture from MSVC") - set(_CONAN_SETTING_ARCH armv6) - elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "86") - set(_CONAN_SETTING_ARCH x86) - else () - message(FATAL_ERROR "Conan: Unknown MSVC architecture [${MSVC_${LANGUAGE}_ARCHITECTURE_ID}]") - endif() - endif() - - conan_cmake_detect_vs_runtime(_vs_runtime ${ARGV}) - message(STATUS "Conan: Detected VS runtime: ${_vs_runtime}") - set(_CONAN_SETTING_COMPILER_RUNTIME ${_vs_runtime}) - - if (CMAKE_GENERATOR_TOOLSET) - set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) - elseif(CMAKE_VS_PLATFORM_TOOLSET AND (CMAKE_GENERATOR STREQUAL "Ninja")) - set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) - endif() - else() - message(FATAL_ERROR "Conan: compiler setup not recognized") - endif() - -endmacro() - -function(conan_cmake_settings result) - #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER}) - #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER_ID}) - #message(STATUS "VERSION " ${CMAKE_CXX_COMPILER_VERSION}) - #message(STATUS "FLAGS " ${CMAKE_LANG_FLAGS}) - #message(STATUS "LIB ARCH " ${CMAKE_CXX_LIBRARY_ARCHITECTURE}) - #message(STATUS "BUILD TYPE " ${CMAKE_BUILD_TYPE}) - #message(STATUS "GENERATOR " ${CMAKE_GENERATOR}) - #message(STATUS "GENERATOR WIN64 " ${CMAKE_CL_64}) - - message(STATUS "Conan: Automatic detection of conan settings from cmake") - - conan_parse_arguments(${ARGV}) - - _conan_detect_build_type(${ARGV}) - - _conan_check_system_name() - - _conan_check_language() - - _conan_detect_compiler(${ARGV}) - - # If profile is defined it is used - if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARGUMENTS_DEBUG_PROFILE) - set(_APPLIED_PROFILES ${ARGUMENTS_DEBUG_PROFILE}) - elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND ARGUMENTS_RELEASE_PROFILE) - set(_APPLIED_PROFILES ${ARGUMENTS_RELEASE_PROFILE}) - elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" AND ARGUMENTS_RELWITHDEBINFO_PROFILE) - set(_APPLIED_PROFILES ${ARGUMENTS_RELWITHDEBINFO_PROFILE}) - elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" AND ARGUMENTS_MINSIZEREL_PROFILE) - set(_APPLIED_PROFILES ${ARGUMENTS_MINSIZEREL_PROFILE}) - elseif(ARGUMENTS_PROFILE) - set(_APPLIED_PROFILES ${ARGUMENTS_PROFILE}) - endif() - - foreach(ARG ${_APPLIED_PROFILES}) - set(_SETTINGS ${_SETTINGS} -pr=${ARG}) - endforeach() - foreach(ARG ${ARGUMENTS_PROFILE_BUILD}) - conan_check(VERSION 1.24.0 REQUIRED DETECT_QUIET) - set(_SETTINGS ${_SETTINGS} -pr:b=${ARG}) - endforeach() - - if(NOT _SETTINGS OR ARGUMENTS_PROFILE_AUTO STREQUAL "ALL") - set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version - compiler.runtime compiler.libcxx compiler.toolset) - endif() - - # remove any manually specified settings from the autodetected settings - foreach(ARG ${ARGUMENTS_SETTINGS}) - string(REGEX MATCH "[^=]*" MANUAL_SETTING "${ARG}") - message(STATUS "Conan: ${MANUAL_SETTING} was added as an argument. Not using the autodetected one.") - list(REMOVE_ITEM ARGUMENTS_PROFILE_AUTO "${MANUAL_SETTING}") - endforeach() - - # Automatic from CMake - foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) - string(TOUPPER ${ARG} _arg_name) - string(REPLACE "." "_" _arg_name ${_arg_name}) - if(_CONAN_SETTING_${_arg_name}) - set(_SETTINGS ${_SETTINGS} -s ${ARG}=${_CONAN_SETTING_${_arg_name}}) - endif() - endforeach() - - foreach(ARG ${ARGUMENTS_SETTINGS}) - set(_SETTINGS ${_SETTINGS} -s ${ARG}) - endforeach() - - message(STATUS "Conan: Settings= ${_SETTINGS}") - - set(${result} ${_SETTINGS} PARENT_SCOPE) -endfunction() - - -function(conan_cmake_detect_unix_libcxx result) - # Take into account any -stdlib in compile options - get_directory_property(compile_options DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS) - string(GENEX_STRIP "${compile_options}" compile_options) - - # Take into account any _GLIBCXX_USE_CXX11_ABI in compile definitions - get_directory_property(defines DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS) - string(GENEX_STRIP "${defines}" defines) - - foreach(define ${defines}) - if(define MATCHES "_GLIBCXX_USE_CXX11_ABI") - if(define MATCHES "^-D") - set(compile_options ${compile_options} "${define}") - else() - set(compile_options ${compile_options} "-D${define}") - endif() - endif() - endforeach() - - # add additional compiler options ala cmRulePlaceholderExpander::ExpandRuleVariable - set(EXPAND_CXX_COMPILER ${CMAKE_CXX_COMPILER}) - if(CMAKE_CXX_COMPILER_ARG1) - # CMake splits CXX="foo bar baz" into CMAKE_CXX_COMPILER="foo", CMAKE_CXX_COMPILER_ARG1="bar baz" - # without this, ccache, winegcc, or other wrappers might lose all their arguments - separate_arguments(SPLIT_CXX_COMPILER_ARG1 NATIVE_COMMAND ${CMAKE_CXX_COMPILER_ARG1}) - list(APPEND EXPAND_CXX_COMPILER ${SPLIT_CXX_COMPILER_ARG1}) - endif() - - if(CMAKE_CXX_COMPILE_OPTIONS_TARGET AND CMAKE_CXX_COMPILER_TARGET) - # without --target= we may be calling the wrong underlying GCC - list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}") - endif() - - if(CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN AND CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN) - list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}") - endif() - - if(CMAKE_CXX_COMPILE_OPTIONS_SYSROOT) - # without --sysroot= we may find the wrong #include - if(CMAKE_SYSROOT_COMPILE) - list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT_COMPILE}") - elseif(CMAKE_SYSROOT) - list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}") - endif() - endif() - - separate_arguments(SPLIT_CXX_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS}) - - if(CMAKE_OSX_SYSROOT) - set(xcode_sysroot_option "--sysroot=${CMAKE_OSX_SYSROOT}") - endif() - - execute_process( - COMMAND ${CMAKE_COMMAND} -E echo "#include " - COMMAND ${EXPAND_CXX_COMPILER} ${SPLIT_CXX_FLAGS} -x c++ ${xcode_sysroot_option} ${compile_options} -E -dM - - OUTPUT_VARIABLE string_defines - ) - - if(string_defines MATCHES "#define __GLIBCXX__") - # Allow -D_GLIBCXX_USE_CXX11_ABI=ON/OFF as argument to cmake - if(DEFINED _GLIBCXX_USE_CXX11_ABI) - if(_GLIBCXX_USE_CXX11_ABI) - set(${result} libstdc++11 PARENT_SCOPE) - return() - else() - set(${result} libstdc++ PARENT_SCOPE) - return() - endif() - endif() - - if(string_defines MATCHES "#define _GLIBCXX_USE_CXX11_ABI 1\n") - set(${result} libstdc++11 PARENT_SCOPE) - else() - # Either the compiler is missing the define because it is old, and so - # it can't use the new abi, or the compiler was configured to use the - # old abi by the user or distro (e.g. devtoolset on RHEL/CentOS) - set(${result} libstdc++ PARENT_SCOPE) - endif() - else() - set(${result} libc++ PARENT_SCOPE) - endif() -endfunction() - -function(conan_cmake_detect_vs_runtime result) - - conan_parse_arguments(${ARGV}) - if(ARGUMENTS_BUILD_TYPE) - set(build_type "${ARGUMENTS_BUILD_TYPE}") - elseif(CMAKE_BUILD_TYPE) - set(build_type "${CMAKE_BUILD_TYPE}") - else() - message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") - endif() - - if(build_type) - string(TOUPPER "${build_type}" build_type) - endif() - set(variables CMAKE_CXX_FLAGS_${build_type} CMAKE_C_FLAGS_${build_type} CMAKE_CXX_FLAGS CMAKE_C_FLAGS) - foreach(variable ${variables}) - if(NOT "${${variable}}" STREQUAL "") - string(REPLACE " " ";" flags "${${variable}}") - foreach (flag ${flags}) - if("${flag}" STREQUAL "/MD" OR "${flag}" STREQUAL "/MDd" OR "${flag}" STREQUAL "/MT" OR "${flag}" STREQUAL "/MTd") - string(SUBSTRING "${flag}" 1 -1 runtime) - set(${result} "${runtime}" PARENT_SCOPE) - return() - endif() - endforeach() - endif() - endforeach() - if("${build_type}" STREQUAL "DEBUG") - set(${result} "MDd" PARENT_SCOPE) - else() - set(${result} "MD" PARENT_SCOPE) - endif() -endfunction() - -function(_collect_settings result) - set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version - compiler.runtime compiler.libcxx compiler.toolset - compiler.cppstd) - foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) - string(TOUPPER ${ARG} _arg_name) - string(REPLACE "." "_" _arg_name ${_arg_name}) - if(_CONAN_SETTING_${_arg_name}) - set(detected_setings ${detected_setings} ${ARG}=${_CONAN_SETTING_${_arg_name}}) - endif() - endforeach() - set(${result} ${detected_setings} PARENT_SCOPE) -endfunction() - -function(conan_cmake_autodetect detected_settings) - _conan_detect_build_type(${ARGV}) - _conan_check_system_name() - _conan_check_language() - _conan_detect_compiler(${ARGV}) - _collect_settings(collected_settings) - set(${detected_settings} ${collected_settings} PARENT_SCOPE) -endfunction() - -macro(conan_parse_arguments) - set(options BASIC_SETUP CMAKE_TARGETS UPDATE KEEP_RPATHS NO_LOAD NO_OUTPUT_DIRS OUTPUT_QUIET NO_IMPORTS SKIP_STD) - set(oneValueArgs CONANFILE ARCH BUILD_TYPE INSTALL_FOLDER CONAN_COMMAND) - set(multiValueArgs DEBUG_PROFILE RELEASE_PROFILE RELWITHDEBINFO_PROFILE MINSIZEREL_PROFILE - PROFILE REQUIRES OPTIONS IMPORTS SETTINGS BUILD ENV GENERATORS PROFILE_AUTO - INSTALL_ARGS CONFIGURATION_TYPES PROFILE_BUILD BUILD_REQUIRES) - cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) -endmacro() - -function(old_conan_cmake_install) - # Calls "conan install" - # Argument BUILD is equivalant to --build={missing, PkgName,...} or - # --build when argument is 'BUILD all' (which builds all packages from source) - # Argument CONAN_COMMAND, to specify the conan path, e.g. in case of running from source - # cmake does not identify conan as command, even if it is +x and it is in the path - conan_parse_arguments(${ARGV}) - - if(CONAN_CMAKE_MULTI) - set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake_multi) - else() - set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake) - endif() - - set(CONAN_BUILD_POLICY "") - foreach(ARG ${ARGUMENTS_BUILD}) - if(${ARG} STREQUAL "all") - set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build) - break() - else() - set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build=${ARG}) - endif() - endforeach() - if(ARGUMENTS_CONAN_COMMAND) - set(CONAN_CMD ${ARGUMENTS_CONAN_COMMAND}) - else() - conan_check(REQUIRED) - endif() - set(CONAN_OPTIONS "") - if(ARGUMENTS_CONANFILE) - if(IS_ABSOLUTE ${ARGUMENTS_CONANFILE}) - set(CONANFILE ${ARGUMENTS_CONANFILE}) - else() - set(CONANFILE ${CMAKE_CURRENT_SOURCE_DIR}/${ARGUMENTS_CONANFILE}) - endif() - else() - set(CONANFILE ".") - endif() - foreach(ARG ${ARGUMENTS_OPTIONS}) - set(CONAN_OPTIONS ${CONAN_OPTIONS} -o=${ARG}) - endforeach() - if(ARGUMENTS_UPDATE) - set(CONAN_INSTALL_UPDATE --update) - endif() - if(ARGUMENTS_NO_IMPORTS) - set(CONAN_INSTALL_NO_IMPORTS --no-imports) - endif() - set(CONAN_INSTALL_FOLDER "") - if(ARGUMENTS_INSTALL_FOLDER) - set(CONAN_INSTALL_FOLDER -if=${ARGUMENTS_INSTALL_FOLDER}) - endif() - foreach(ARG ${ARGUMENTS_GENERATORS}) - set(CONAN_GENERATORS ${CONAN_GENERATORS} -g=${ARG}) - endforeach() - foreach(ARG ${ARGUMENTS_ENV}) - set(CONAN_ENV_VARS ${CONAN_ENV_VARS} -e=${ARG}) - endforeach() - set(conan_args install ${CONANFILE} ${settings} ${CONAN_ENV_VARS} ${CONAN_GENERATORS} ${CONAN_BUILD_POLICY} ${CONAN_INSTALL_UPDATE} ${CONAN_INSTALL_NO_IMPORTS} ${CONAN_OPTIONS} ${CONAN_INSTALL_FOLDER} ${ARGUMENTS_INSTALL_ARGS}) - - string (REPLACE ";" " " _conan_args "${conan_args}") - message(STATUS "Conan executing: ${CONAN_CMD} ${_conan_args}") - - if(ARGUMENTS_OUTPUT_QUIET) - execute_process(COMMAND ${CONAN_CMD} ${conan_args} - RESULT_VARIABLE return_code - OUTPUT_VARIABLE conan_output - ERROR_VARIABLE conan_output - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) - else() - execute_process(COMMAND ${CONAN_CMD} ${conan_args} - RESULT_VARIABLE return_code - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) - endif() - - if(NOT "${return_code}" STREQUAL "0") - message(FATAL_ERROR "Conan install failed='${return_code}'") - endif() - -endfunction() - -function(conan_cmake_install) - if(DEFINED CONAN_COMMAND) - set(CONAN_CMD ${CONAN_COMMAND}) - else() - conan_check(REQUIRED) - endif() - - set(installOptions UPDATE NO_IMPORTS OUTPUT_QUIET ERROR_QUIET) - set(installOneValueArgs PATH_OR_REFERENCE REFERENCE REMOTE LOCKFILE LOCKFILE_OUT LOCKFILE_NODE_ID INSTALL_FOLDER) - set(installMultiValueArgs GENERATOR BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE - PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD) - cmake_parse_arguments(ARGS "${installOptions}" "${installOneValueArgs}" "${installMultiValueArgs}" ${ARGN}) - foreach(arg ${installOptions}) - if(ARGS_${arg}) - set(${arg} ${${arg}} ${ARGS_${arg}}) - endif() - endforeach() - foreach(arg ${installOneValueArgs}) - if(DEFINED ARGS_${arg}) - if("${arg}" STREQUAL "REMOTE") - set(flag "--remote") - elseif("${arg}" STREQUAL "LOCKFILE") - set(flag "--lockfile") - elseif("${arg}" STREQUAL "LOCKFILE_OUT") - set(flag "--lockfile-out") - elseif("${arg}" STREQUAL "LOCKFILE_NODE_ID") - set(flag "--lockfile-node-id") - elseif("${arg}" STREQUAL "INSTALL_FOLDER") - set(flag "--install-folder") - endif() - set(${arg} ${${arg}} ${flag} ${ARGS_${arg}}) - endif() - endforeach() - foreach(arg ${installMultiValueArgs}) - if(DEFINED ARGS_${arg}) - if("${arg}" STREQUAL "GENERATOR") - set(flag "--generator") - elseif("${arg}" STREQUAL "BUILD") - set(flag "--build") - elseif("${arg}" STREQUAL "ENV") - set(flag "--env") - elseif("${arg}" STREQUAL "ENV_HOST") - set(flag "--env:host") - elseif("${arg}" STREQUAL "ENV_BUILD") - set(flag "--env:build") - elseif("${arg}" STREQUAL "OPTIONS") - set(flag "--options") - elseif("${arg}" STREQUAL "OPTIONS_HOST") - set(flag "--options:host") - elseif("${arg}" STREQUAL "OPTIONS_BUILD") - set(flag "--options:build") - elseif("${arg}" STREQUAL "PROFILE") - set(flag "--profile") - elseif("${arg}" STREQUAL "PROFILE_HOST") - set(flag "--profile:host") - elseif("${arg}" STREQUAL "PROFILE_BUILD") - set(flag "--profile:build") - elseif("${arg}" STREQUAL "SETTINGS") - set(flag "--settings") - elseif("${arg}" STREQUAL "SETTINGS_HOST") - set(flag "--settings:host") - elseif("${arg}" STREQUAL "SETTINGS_BUILD") - set(flag "--settings:build") - endif() - list(LENGTH ARGS_${arg} numargs) - foreach(item ${ARGS_${arg}}) - if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD") - set(${arg} "--build") - break() - endif() - set(${arg} ${${arg}} ${flag} ${item}) - endforeach() - endif() - endforeach() - if(DEFINED UPDATE) - set(UPDATE --update) - endif() - if(DEFINED NO_IMPORTS) - set(NO_IMPORTS --no-imports) - endif() - set(install_args install ${PATH_OR_REFERENCE} ${REFERENCE} ${UPDATE} ${NO_IMPORTS} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} - ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} - ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD}) - - string(REPLACE ";" " " _install_args "${install_args}") - message(STATUS "Conan executing: ${CONAN_CMD} ${_install_args}") - - if(ARGS_OUTPUT_QUIET) - set(OUTPUT_OPT OUTPUT_QUIET) - endif() - if(ARGS_ERROR_QUIET) - set(ERROR_OPT ERROR_QUIET) - endif() - - execute_process(COMMAND ${CONAN_CMD} ${install_args} - RESULT_VARIABLE return_code - ${OUTPUT_OPT} - ${ERROR_OPT} - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) - - if(NOT "${return_code}" STREQUAL "0") - if (ARGS_ERROR_QUIET) - message(WARNING "Conan install failed='${return_code}'") - else() - message(FATAL_ERROR "Conan install failed='${return_code}'") - endif() - endif() - -endfunction() - -function(conan_cmake_setup_conanfile) - conan_parse_arguments(${ARGV}) - if(ARGUMENTS_CONANFILE) - get_filename_component(_CONANFILE_NAME ${ARGUMENTS_CONANFILE} NAME) - # configure_file will make sure cmake re-runs when conanfile is updated - configure_file(${ARGUMENTS_CONANFILE} ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk COPYONLY) - file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk) - else() - conan_cmake_generate_conanfile(ON ${ARGV}) - endif() -endfunction() - -function(conan_cmake_configure) - conan_cmake_generate_conanfile(OFF ${ARGV}) -endfunction() - -# Generate, writing in disk a conanfile.txt with the requires, options, and imports -# specified as arguments -# This will be considered as temporary file, generated in CMAKE_CURRENT_BINARY_DIR) -function(conan_cmake_generate_conanfile DEFAULT_GENERATOR) - - conan_parse_arguments(${ARGV}) - - set(_FN "${CMAKE_CURRENT_BINARY_DIR}/conanfile.txt") - file(WRITE ${_FN} "") - - if(DEFINED ARGUMENTS_REQUIRES) - file(APPEND ${_FN} "[requires]\n") - foreach(REQUIRE ${ARGUMENTS_REQUIRES}) - file(APPEND ${_FN} ${REQUIRE} "\n") - endforeach() - endif() - - if (DEFAULT_GENERATOR OR DEFINED ARGUMENTS_GENERATORS) - file(APPEND ${_FN} "[generators]\n") - if (DEFAULT_GENERATOR) - file(APPEND ${_FN} "cmake\n") - endif() - if (DEFINED ARGUMENTS_GENERATORS) - foreach(GENERATOR ${ARGUMENTS_GENERATORS}) - file(APPEND ${_FN} ${GENERATOR} "\n") - endforeach() - endif() - endif() - - if(DEFINED ARGUMENTS_BUILD_REQUIRES) - file(APPEND ${_FN} "[build_requires]\n") - foreach(BUILD_REQUIRE ${ARGUMENTS_BUILD_REQUIRES}) - file(APPEND ${_FN} ${BUILD_REQUIRE} "\n") - endforeach() - endif() - - if(DEFINED ARGUMENTS_IMPORTS) - file(APPEND ${_FN} "[imports]\n") - foreach(IMPORTS ${ARGUMENTS_IMPORTS}) - file(APPEND ${_FN} ${IMPORTS} "\n") - endforeach() - endif() - - if(DEFINED ARGUMENTS_OPTIONS) - file(APPEND ${_FN} "[options]\n") - foreach(OPTION ${ARGUMENTS_OPTIONS}) - file(APPEND ${_FN} ${OPTION} "\n") - endforeach() - endif() - -endfunction() - - -macro(conan_load_buildinfo) - if(CONAN_CMAKE_MULTI) - set(_CONANBUILDINFO conanbuildinfo_multi.cmake) - else() - set(_CONANBUILDINFO conanbuildinfo.cmake) - endif() - if(ARGUMENTS_INSTALL_FOLDER) - set(_CONANBUILDINFOFOLDER ${ARGUMENTS_INSTALL_FOLDER}) - else() - set(_CONANBUILDINFOFOLDER ${CMAKE_CURRENT_BINARY_DIR}) - endif() - # Checks for the existence of conanbuildinfo.cmake, and loads it - # important that it is macro, so variables defined at parent scope - if(EXISTS "${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}") - message(STATUS "Conan: Loading ${_CONANBUILDINFO}") - include(${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}) - else() - message(FATAL_ERROR "${_CONANBUILDINFO} doesn't exist in ${CMAKE_CURRENT_BINARY_DIR}") - endif() -endmacro() - - -macro(conan_cmake_run) - conan_parse_arguments(${ARGV}) - - if(ARGUMENTS_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES) - message(WARNING "CONFIGURATION_TYPES should only be specified for multi-configuration generators") - elseif(ARGUMENTS_CONFIGURATION_TYPES AND ARGUMENTS_BUILD_TYPE) - message(WARNING "CONFIGURATION_TYPES and BUILD_TYPE arguments should not be defined at the same time.") - endif() - - if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE AND NOT CONAN_EXPORTED - AND NOT ARGUMENTS_BUILD_TYPE) - set(CONAN_CMAKE_MULTI ON) - if (NOT ARGUMENTS_CONFIGURATION_TYPES) - set(ARGUMENTS_CONFIGURATION_TYPES "Release;Debug") - endif() - message(STATUS "Conan: Using cmake-multi generator") - else() - set(CONAN_CMAKE_MULTI OFF) - endif() - - if(NOT CONAN_EXPORTED) - conan_cmake_setup_conanfile(${ARGV}) - if(CONAN_CMAKE_MULTI) - foreach(CMAKE_BUILD_TYPE ${ARGUMENTS_CONFIGURATION_TYPES}) - set(ENV{CONAN_IMPORT_PATH} ${CMAKE_BUILD_TYPE}) - conan_cmake_settings(settings ${ARGV}) - old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) - endforeach() - set(CMAKE_BUILD_TYPE) - else() - conan_cmake_settings(settings ${ARGV}) - old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) - endif() - endif() - - if (NOT ARGUMENTS_NO_LOAD) - conan_load_buildinfo() - endif() - - if(ARGUMENTS_BASIC_SETUP) - foreach(_option CMAKE_TARGETS KEEP_RPATHS NO_OUTPUT_DIRS SKIP_STD) - if(ARGUMENTS_${_option}) - if(${_option} STREQUAL "CMAKE_TARGETS") - list(APPEND _setup_options "TARGETS") - else() - list(APPEND _setup_options ${_option}) - endif() - endif() - endforeach() - conan_basic_setup(${_setup_options}) - endif() -endmacro() - -macro(conan_check) - # Checks conan availability in PATH - # Arguments REQUIRED, DETECT_QUIET and VERSION are optional - # Example usage: - # conan_check(VERSION 1.0.0 REQUIRED) - set(options REQUIRED DETECT_QUIET) - set(oneValueArgs VERSION) - cmake_parse_arguments(CONAN "${options}" "${oneValueArgs}" "" ${ARGN}) - if(NOT CONAN_DETECT_QUIET) - message(STATUS "Conan: checking conan executable") - endif() - - find_program(CONAN_CMD conan) - if(NOT CONAN_CMD AND CONAN_REQUIRED) - message(FATAL_ERROR "Conan executable not found! Please install conan.") - endif() - if(NOT CONAN_DETECT_QUIET) - message(STATUS "Conan: Found program ${CONAN_CMD}") - endif() - execute_process(COMMAND ${CONAN_CMD} --version - RESULT_VARIABLE return_code - OUTPUT_VARIABLE CONAN_VERSION_OUTPUT - ERROR_VARIABLE CONAN_VERSION_OUTPUT) - - if(NOT "${return_code}" STREQUAL "0") - message(FATAL_ERROR "Conan --version failed='${return_code}'") - endif() - - if(NOT CONAN_DETECT_QUIET) - string(STRIP "${CONAN_VERSION_OUTPUT}" _CONAN_VERSION_OUTPUT) - message(STATUS "Conan: Version found ${_CONAN_VERSION_OUTPUT}") - endif() - - if(DEFINED CONAN_VERSION) - string(REGEX MATCH ".*Conan version ([0-9]+\\.[0-9]+\\.[0-9]+)" FOO - "${CONAN_VERSION_OUTPUT}") - if(${CMAKE_MATCH_1} VERSION_LESS ${CONAN_VERSION}) - message(FATAL_ERROR "Conan outdated. Installed: ${CMAKE_MATCH_1}, \ - required: ${CONAN_VERSION}. Consider updating via 'pip \ - install conan==${CONAN_VERSION}'.") - endif() - endif() -endmacro() - -function(conan_add_remote) - # Adds a remote - # Arguments URL and NAME are required, INDEX, COMMAND and VERIFY_SSL are optional - # Example usage: - # conan_add_remote(NAME bincrafters INDEX 1 - # URL https://api.bintray.com/conan/bincrafters/public-conan - # VERIFY_SSL True) - set(oneValueArgs URL NAME INDEX COMMAND VERIFY_SSL) - cmake_parse_arguments(CONAN "" "${oneValueArgs}" "" ${ARGN}) - - if(DEFINED CONAN_INDEX) - set(CONAN_INDEX_ARG "-i ${CONAN_INDEX}") - endif() - if(DEFINED CONAN_COMMAND) - set(CONAN_CMD ${CONAN_COMMAND}) - else() - conan_check(REQUIRED DETECT_QUIET) - endif() - set(CONAN_VERIFY_SSL_ARG "True") - if(DEFINED CONAN_VERIFY_SSL) - set(CONAN_VERIFY_SSL_ARG ${CONAN_VERIFY_SSL}) - endif() - message(STATUS "Conan: Adding ${CONAN_NAME} remote repository (${CONAN_URL}) verify ssl (${CONAN_VERIFY_SSL_ARG})") - execute_process(COMMAND ${CONAN_CMD} remote add ${CONAN_NAME} ${CONAN_INDEX_ARG} -f ${CONAN_URL} ${CONAN_VERIFY_SSL_ARG} - RESULT_VARIABLE return_code) - if(NOT "${return_code}" STREQUAL "0") - message(FATAL_ERROR "Conan remote failed='${return_code}'") - endif() -endfunction() - -macro(conan_config_install) - # install a full configuration from a local or remote zip file - # Argument ITEM is required, arguments TYPE, SOURCE, TARGET and VERIFY_SSL are optional - # Example usage: - # conan_config_install(ITEM https://github.com/conan-io/cmake-conan.git - # TYPE git SOURCE source-folder TARGET target-folder VERIFY_SSL false) - set(oneValueArgs ITEM TYPE SOURCE TARGET VERIFY_SSL) - set(multiValueArgs ARGS) - cmake_parse_arguments(CONAN "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - - find_program(CONAN_CMD conan) - if(NOT CONAN_CMD AND CONAN_REQUIRED) - message(FATAL_ERROR "Conan executable not found!") - endif() - - if(DEFINED CONAN_VERIFY_SSL) - set(CONAN_VERIFY_SSL_ARG "--verify-ssl=${CONAN_VERIFY_SSL}") - endif() - - if(DEFINED CONAN_TYPE) - set(CONAN_TYPE_ARG "--type=${CONAN_TYPE}") - endif() - - if(DEFINED CONAN_ARGS) - set(CONAN_ARGS_ARGS "--args=\"${CONAN_ARGS}\"") - endif() - - if(DEFINED CONAN_SOURCE) - set(CONAN_SOURCE_ARGS "--source-folder=${CONAN_SOURCE}") - endif() - - if(DEFINED CONAN_TARGET) - set(CONAN_TARGET_ARGS "--target-folder=${CONAN_TARGET}") - endif() - - set (CONAN_CONFIG_INSTALL_ARGS ${CONAN_VERIFY_SSL_ARG} - ${CONAN_TYPE_ARG} - ${CONAN_ARGS_ARGS} - ${CONAN_SOURCE_ARGS} - ${CONAN_TARGET_ARGS}) - - message(STATUS "Conan: Installing config from ${CONAN_ITEM}") - execute_process(COMMAND ${CONAN_CMD} config install ${CONAN_ITEM} ${CONAN_CONFIG_INSTALL_ARGS} - RESULT_VARIABLE return_code) - if(NOT "${return_code}" STREQUAL "0") - message(FATAL_ERROR "Conan config failed='${return_code}'") - endif() -endmacro()