diff --git a/.codecov.yaml b/.codecov.yaml index 53ba0463..d2882791 100644 --- a/.codecov.yaml +++ b/.codecov.yaml @@ -12,3 +12,7 @@ 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/**" diff --git a/.github/workflows/cpp-linter.yml b/.github/workflows/cpp-linter.yml index 587ecb43..50b092f2 100644 --- a/.github/workflows/cpp-linter.yml +++ b/.github/workflows/cpp-linter.yml @@ -13,17 +13,46 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: cpp-linter/cpp-linter-action@v2 - id: linter - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: - style: "file" - tidy-checks: '-*' - version: '14' + fetch-depth: 0 + ref: ${{ github.head_ref }} - - name: Fail fast?! - if: steps.linter.outputs.checks-failed > 0 + - 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: | - echo "Some files failed the linting checks!" - exit 1 + if [[ -z $(git status --porcelain --untracked-files=no) ]]; then echo "ChangesFound=False" >> $GITHUB_OUTPUT; else echo "ChangesFound=True" >> $GITHUB_OUTPUT; fi + + - name: setup git config + run: | + # 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/test.yml b/.github/workflows/test.yml index 27b5bef8..2a0e7159 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -6,9 +6,12 @@ name: Unit tests on: push: - branches: [ master ] + branches: + - master pull_request: - branches: [ master, develop ] + branches: + - master + - develop workflow_dispatch: diff --git a/.gitignore b/.gitignore index 6bab5ba3..f102b91a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,17 +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__/Build.cpython-310.pyc -__pycache__/Setup.cpython-310.pyc +__pycache__/* diff --git a/CMakeLists.txt b/CMakeLists.txt index b49b32a3..0cdfa84c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.23) project( BSMPT - VERSION 2.6.0 + VERSION 3.0.0 LANGUAGES C CXX DESCRIPTION "BSMPT - Beyond the Standard Model Phase Transitions : A C++ package for the computation of the EWPT in BSM models" @@ -139,7 +139,10 @@ if(EnableCoverage) "${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/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 @@ -156,6 +159,7 @@ endif(EnableCoverage) find_lto(CXX) add_subdirectory(src) +add_subdirectory(standalone) # -------------------------- export as cmake package -------------------------- if(PROJECT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) @@ -165,7 +169,7 @@ 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) diff --git a/README.md b/README.md index 2545c1c9..1d6a4824 100644 --- a/README.md +++ b/README.md @@ -4,14 +4,12 @@ SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas M SPDX-License-Identifier: GPL-3.0-or-later --> -Program: BSMPT version 2.6.0 +Program: BSMPT version 3.0.0 -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) +[![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/) @@ -20,25 +18,25 @@ Released by: Philipp Basler and Lisa Biermann and Margarete Mühlleitner and Jon [![Latest release](https://badgen.net/github/release/phbasler/bsmpt)](https://github.com/phbasler/bsmpt/releases) - -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,7 +57,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). +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). --- @@ -117,31 +115,35 @@ After compiling the code call `ctest --preset ${profile} -j` in the root folder ### 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`. @@ -150,97 +152,64 @@ 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. +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. -Additionally, 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 relative 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. +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. -For the following examples the C2HDM with the example/C2HDM_Input.dat file is used. -### 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: +In BSMPTv3, the following four executables are added: - ./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'. +### MinimaTracer +MinimaTracer tracks temperature-dependent local minima in a user-defined temperature interval. -For our example the command +### 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. - ./bin/BSMPT c2hdm example/C2HDM_Input.dat example/test_BSMPT.dat 2 2 +### CalcGW +CalcGW expands CalcTemps by the additional calculation of the gravitational waves spectra sourced by first-order phase transitions. -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. +### PotPlotter +PotPlotter calculates user-defined data grids that can be used for the visualization of multi-dimensional potential contours. -### 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. -It is called through the command +The following executables were released with BSMPTv1 and BSMPTv2: - ./bin/CalcCT Model Inputfile Outputfile LineStart LineEnd -For the C2HDM example this reads +### 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. - ./bin/CalcCT c2hdm example/C2HDM_Input.dat example/test_CalcCT.dat 2 2 +### 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. -which will generate the output file example/test_CalcCT.dat. This can be compared with the already available file example/C2HDM_Input.dat_CalcCT. +### CalcCT +CalcCT calculates the (finite) counterterms for the 'on-shell' renormalization scheme. ### 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 - - ./bin/NLOVEV c2hdm example/C2HDM_Input.dat example/test_NLOVEV.dat 2 2 - -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 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. -[DoxygenLink]: https://phbasler.github.io/BSMPT/documentation +[DoxygenLink]: https://phbasler.github.io/BSMPT/documentation \ No newline at end of file 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/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/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/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/Fluid_Type/gen_func_fluid.h b/include/BSMPT/baryo_calculation/Fluid_Type/gen_func_fluid.h index a942133d..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. 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..dabc42f9 --- /dev/null +++ b/include/BSMPT/bounce_solution/bounce_solution.h @@ -0,0 +1,550 @@ +// 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 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 \ No newline at end of file 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/Minimizer.h b/include/BSMPT/minimizer/Minimizer.h index 78461211..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, 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 540f956c..d2b50763 100644 --- a/include/BSMPT/models/ClassPotentialC2HDM.h +++ b/include/BSMPT/models/ClassPotentialC2HDM.h @@ -98,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/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 4051c7a5..80da9df5 100644 --- a/include/BSMPT/models/ClassPotentialRN2HDM.h +++ b/include/BSMPT/models/ClassPotentialN2HDM.h @@ -4,8 +4,8 @@ // // 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 @@ -19,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 + @@ -77,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(const ISMConstants &smConstants); - 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, @@ -139,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 324f6e75..4c791f3f 100644 --- a/include/BSMPT/models/ClassPotentialOrigin.h +++ b/include/BSMPT/models/ClassPotentialOrigin.h @@ -457,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 @@ -519,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 @@ -593,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 @@ -612,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 @@ -621,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 @@ -660,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 @@ -750,6 +802,7 @@ 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 @@ -759,6 +812,7 @@ class Class_Potential_Origin * skipped. */ 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/ClassPotentialSM.h b/include/BSMPT/models/ClassPotentialSM.h new file mode 100644 index 00000000..406e2be3 --- /dev/null +++ b/include/BSMPT/models/ClassPotentialSM.h @@ -0,0 +1,62 @@ +// 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 SM + */ + +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/IncludeAllModels.h b/include/BSMPT/models/IncludeAllModels.h index d710d278..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 @@ -33,9 +33,10 @@ enum class ModelIDs NotSet, C2HDM, R2HDM, - RN2HDM, + N2HDM, CXSM, CPINTHEDARK, + SM, // Here you start adding your models TEMPLATE, @@ -51,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}, }; @@ -103,4 +105,4 @@ void ShowInputError(); } // namespace BSMPT -//#endif /* INCLUDEALLMODELS_H_ */ +// #endif /* INCLUDEALLMODELS_H_ */ diff --git a/include/BSMPT/models/SMparam.h b/include/BSMPT/models/SMparam.h index 8605db8a..48c3fe71 100644 --- a/include/BSMPT/models/SMparam.h +++ b/include/BSMPT/models/SMparam.h @@ -213,6 +213,16 @@ struct ISMConstants * 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; }; /** @@ -226,7 +236,6 @@ const std::complex II(0, 1); * @return The SM Constants used by default in BSMPT */ 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 c9f6ee95..cdb4cfc1 100644 --- a/include/BSMPT/utility/Logger.h +++ b/include/BSMPT/utility/Logger.h @@ -29,9 +29,14 @@ enum class LoggingLevel None, Default, MinimizerDetailed, + MinTracerDetailed, + TransitionDetailed, + GWDetailed, + BounceDetailed, ProgDetailed, EWBGDetailed, - Debug + Debug, + Complete }; /** @@ -88,6 +93,10 @@ 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}}; }; @@ -125,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..c2add41f --- /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); + /** + * @brief print the current knots of the spline + * + */ + void print_path(); + /** + * @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 index 07136923..8f11d1b8 100644 --- a/include/BSMPT/utility/parser.h +++ b/include/BSMPT/utility/parser.h @@ -1,6 +1,13 @@ +// 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 @@ -27,11 +34,29 @@ 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 @@ -42,6 +67,23 @@ class parser 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". @@ -115,6 +157,7 @@ class parser std::string argument; std::string description; std::optional value; + std::string default_val = ""; }; struct KeyValue { @@ -128,8 +171,12 @@ class parser } }; + 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. 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 20c41e42..9939fd4a 100644 --- a/include/BSMPT/utility/utility.h +++ b/include/BSMPT/utility/utility.h @@ -7,7 +7,9 @@ #pragma once #include +#include #include +#include #include #include #include @@ -46,7 +48,48 @@ bool StringEndsWith(const std::string &str, const std::string &suffix); 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) @@ -67,6 +110,153 @@ 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 operator << overload for the model parameter */ diff --git a/manual/manual.pdf b/manual/manual.pdf deleted file mode 100644 index 2eae326b..00000000 Binary files a/manual/manual.pdf and /dev/null differ diff --git a/manual/manual_v1.pdf b/manual/manual_v1.pdf new file mode 100644 index 00000000..9f303833 Binary files /dev/null and b/manual/manual_v1.pdf differ diff --git a/manual/manual_v2.pdf b/manual/manual_v2.pdf new file mode 100644 index 00000000..75eb1cc3 Binary files /dev/null and b/manual/manual_v2.pdf differ diff --git a/sh/prepareData_C2HDM.py b/sh/prepareData_C2HDM.py old mode 100644 new mode 100755 index 6483ca81..b24f2744 --- a/sh/prepareData_C2HDM.py +++ b/sh/prepareData_C2HDM.py @@ -1,45 +1,42 @@ +#!/usr/bin/env python3 # SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller # # SPDX-License-Identifier: GPL-3.0-or-later import pandas as pd -import argparse +import sys -####### The parameters Type,Lambda1 to Lambda4,re_Lambda5,im_Lambda5, tanbeta and re_m12squared should have the label +####### The parameters Type, Lambda1 to Lambda4, re_Lambda5, im_Lambda5, tanbeta and re_m12squared should have the label ####### of the corresponding parameter. With Seperator you have to tell which seperator your data file ####### is using (e.g. , \t or space). Your InputFILE will then be saved to OutputFILE. -Seperator='\t' -InputFILE='../example/C2HDM_Input.dat' -OutputFILE='C2HDM_Ordered.dat' -Type='Type' -Lambda1='L1' -Lambda2='L2' -Lambda3='L3' -Lambda4='L4' -re_Lambda5='re_L5' -im_Lambda5='im_L5' -tanbeta='tbeta' -re_m12squared='re_m12sq' +def convert(InputFile, OutputFile): + print(f'Reading {InputFile}.') + print(f'Output is saved to {OutputFile}.') + HasIndexCol=False + Separator='\t' + Type='yuktype' + Lambda1='L1' + Lambda2='L2' + Lambda3='L3' + Lambda4='L4' + re_Lambda5='re_L5' + im_Lambda5='im_L5' + tanbeta='tbeta' + re_m12squared='re_m12sq' -def convert(IndexCol): - df=pd.DataFrame() - if IndexCol == 'False': - df=pd.read_table(InputFILE,index_col=False,sep=Seperator) - else: - df=pd.read_table(InputFILE,index_col=int(IndexCol),sep=Seperator) + with open(InputFile, 'r') as file: + df = pd.read_csv(file,index_col=HasIndexCol,sep=Separator) - frontcol=[Type,Lambda1,Lambda2,Lambda3,Lambda4,re_Lambda5,im_Lambda5,re_m12squared,tanbeta] + frontcol=[Type,Lambda1,Lambda2,Lambda3,Lambda4,re_Lambda5,im_Lambda5,re_m12squared,tanbeta] - Col = [c for c in frontcol if c in df] + [c for c in df if c not in frontcol] - df=df[Col] + Col = [c for c in frontcol if c in df] + [c for c in df if c not in frontcol] - df.to_csv(OutputFILE,index=False,sep='\t') + df = df[Col] -parser = argparse.ArgumentParser() -parser.add_argument('-i','--indexcol',help='Column which stores the index of your data', default='False') + with open(OutputFile, 'w') as file: + df.to_csv(file, index=False, sep='\t') if __name__ == "__main__": - args = parser.parse_args() - convert(args.indexcol) + convert(sys.argv[1], sys.argv[2]) diff --git a/sh/prepareData_CxSM.py b/sh/prepareData_CxSM.py new file mode 100755 index 00000000..2d22d770 --- /dev/null +++ b/sh/prepareData_CxSM.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller +# +# SPDX-License-Identifier: GPL-3.0-or-later + +import pandas as pd +import sys + +def convert(InputFile, OutputFile): + print(f'Reading {InputFile}.') + print(f'Output is saved to {OutputFile}.') + + with open(InputFile, 'r') as file: + df = pd.read_csv(file,index_col=False,sep='\t') + + v = 'v' + vs = 'vs' + va = 'va' + msq = 'msq' + lamb = 'lambda' + delta2 = 'delta2' + b2 = 'b2' + d2 = 'd2' + Reb1 = 'Reb1' + Imb1 = 'Imb1' + Rea1 = 'Rea1' + Ima1 = 'Ima1' + + NoImb1 = False + NoIma1 = False + + if Imb1 not in df: + Reb1 = 'b1' + print(f'Reb1 changed to {Reb1}.') + NoImb1 = True + if Ima1 not in df: + Rea1 = 'a1' + print(f'Rea1 changed to {Rea1}.') + NoIma1 = True + + frontcol=[v, vs, va, msq, lamb, delta2, b2, d2, Reb1, Imb1, Rea1, Ima1] + + for c in frontcol: + if c not in df: + df[c] = 0 + + Col = [c for c in frontcol if c in df] + [c for c in df if c not in frontcol] + + df = df[Col] + + if NoImb1: + df.rename(columns={Reb1:'Reb1'}, inplace=True) + if NoIma1: + df.rename(columns={Rea1:'Rea1'}, inplace=True) + + with open(OutputFile, 'w') as file: + df.to_csv(file, index=True, sep='\t')\ + +if __name__ == "__main__": + convert(sys.argv[1], sys.argv[2]) diff --git a/sh/prepareData_N2HDM.py b/sh/prepareData_N2HDM.py index 20ecbdfe..307b7be7 100644 --- a/sh/prepareData_N2HDM.py +++ b/sh/prepareData_N2HDM.py @@ -25,11 +25,10 @@ m12squared='p_m12sq' vs='p_vs' - def convert(IndexCol): df=pd.DataFrame() if IndexCol == 'False': - df=pd.read_table(InputFILE,index_col=False,sep=Seperator) + df=pd.read_table(InputFILE,index_col=False,sep=Seperator) else: df=pd.read_table(InputFILE,index_col=int(IndexCol),sep=Seperator) @@ -45,5 +44,4 @@ def convert(IndexCol): if __name__ == "__main__": args = parser.parse_args() - convert(args.indexcol) - + convert(args.indexcol) \ No newline at end of file diff --git a/sh/prepareData_R2HDM.py b/sh/prepareData_R2HDM.py old mode 100644 new mode 100755 index efccf1db..ff08ed6e --- a/sh/prepareData_R2HDM.py +++ b/sh/prepareData_R2HDM.py @@ -1,47 +1,40 @@ +#!/usr/bin/env python3 # SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller # # SPDX-License-Identifier: GPL-3.0-or-later import pandas as pd -import argparse +import sys -####### The parameters Type,Lambda1 to Lambda5, tanbeta and m12squared should have the label of the corresponding +####### The parameters Type, Lambda1 to Lambda5, tanbeta and m12squared should have the label of the corresponding ####### parameter. With Seperator you have to tell which seperator your data file ####### is using (e.g. , \t or space). Your InputFILE will then be saved to OutputFILE +def convert(InputFile, OutputFile): + print(f'Reading {InputFile}.') + print(f'Output is saved to {OutputFile}.') -Seperator='\t' -InputFILE='../example/R2HDM_Input.dat' -InputFILE='wI.csv' -OutputFILE='R2HDM_Ordered.dat' -Type='yuktype' -Lambda1='L1' -Lambda2='L2' -Lambda3='L3' -Lambda4='L4' -Lambda5='L5' -tanbeta='tbeta' -m12squared='m12sq' + HasIndexCol=False + Separator='\t' + Type='yuktype' + Lambda1='L1' + Lambda2='L2' + Lambda3='L3' + Lambda4='L4' + Lambda5='L5' + tanbeta='tbeta' + m12squared='m12sq' + with open(InputFile, 'r') as file: + df = pd.read_csv(file,index_col=HasIndexCol,sep=Separator) -def convert(IndexCol): - df=pd.DataFrame() - if IndexCol == 'False': - df=pd.read_table(InputFILE,index_col=False,sep=Seperator) - else: - df=pd.read_table(InputFILE,index_col=int(IndexCol),sep=Seperator) + frontcol=[Type,Lambda1,Lambda2,Lambda3,Lambda4,Lambda5,m12squared,tanbeta] - frontcol=[Type,Lambda1,Lambda2,Lambda3,Lambda4,Lambda5,m12squared,tanbeta] + Col = [c for c in frontcol if c in df] + [c for c in df if c not in frontcol] + df = df[Col] - Col = [c for c in frontcol if c in df] + [c for c in df if c not in frontcol] - df=df[Col] - - df.to_csv(OutputFILE,index=False,sep='\t') - -parser = argparse.ArgumentParser() -parser.add_argument('-i','--indexcol',help='Column which stores the index of your data', default='False') + with open(OutputFile, 'w') as file: + df.to_csv(file, index=False, sep='\t') if __name__ == "__main__": - args = parser.parse_args() - convert(args.indexcol) - + convert(sys.argv[1], sys.argv[2]) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 8c6aa646..259d250a 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -12,9 +12,16 @@ if(BSMPTCompileBaryo) endif(BSMPTCompileBaryo) add_subdirectory(ThermalFunctions) +add_subdirectory(minimum_tracer) +add_subdirectory(transition_tracer) +add_subdirectory(bounce_solution) +add_subdirectory(gravitational_waves) + # ==============================Utility================================== add_subdirectory(utility) +add_subdirectory(utility/asciiplotter) +add_subdirectory(utility/spline) # ==============================EXE====================================== @@ -42,6 +49,23 @@ add_executable(Test prog/Test.cpp) target_link_libraries(Test Minimizer Models Utility) target_compile_features(Test PUBLIC cxx_std_17) +add_executable(CalcGW prog/CalcGW.cpp) +target_link_libraries(CalcGW Utility GW MinimumTracer TransitionTracer) +target_compile_features(CalcGW PUBLIC cxx_std_14) + +add_executable(CalcTemps prog/CalcTemps.cpp) +target_link_libraries(CalcTemps Utility GW MinimumTracer TransitionTracer) +target_compile_features(CalcTemps PUBLIC cxx_std_14) + +add_executable(MinimaTracer prog/MinimaTracer.cpp) +target_link_libraries(MinimaTracer Minimizer Models Utility MinimumTracer + TransitionTracer) +target_compile_features(MinimaTracer PUBLIC cxx_std_14) + +add_executable(PotPlotter prog/PotPlotter.cpp) +target_link_libraries(PotPlotter Models Utility Minimizer MinimumTracer) +target_compile_features(PotPlotter PUBLIC cxx_std_14) + if(BSMPTCompileBaryo) add_executable(CalculateEWBG prog/CalculateEWBG.cpp) target_link_libraries(CalculateEWBG Minimizer Models Baryo Utility) diff --git a/src/Kfactors/KfactorsinterpolatedGSL.cpp b/src/Kfactors/KfactorsinterpolatedGSL.cpp index ee489859..ad7f203d 100644 --- a/src/Kfactors/KfactorsinterpolatedGSL.cpp +++ b/src/Kfactors/KfactorsinterpolatedGSL.cpp @@ -23,12 +23,6 @@ namespace BSMPT namespace Kfactors { -/** - * @brief GSLAcclType Type used by the interpolations of the Kfunctions - */ -using GSLAcclType = - std::unique_ptr; - 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 8c64a663..20022f62 100644 --- a/src/ThermalFunctions/CMakeLists.txt +++ b/src/ThermalFunctions/CMakeLists.txt @@ -7,10 +7,11 @@ 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) +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_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/baryo_calculation/Fluid_Type/gen_func_fluid.cpp b/src/baryo_calculation/Fluid_Type/gen_func_fluid.cpp index 773c729a..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, @@ -295,7 +287,6 @@ void Calc_eta::set_class(std::vector array_z_in, double Temp_in, double vw_in) { - Calc_eta::array_z = array_z_in; Calc_eta::array_nL = array_nL_in; Calc_eta::Temp = Temp_in; 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..58693217 --- /dev/null +++ b/src/bounce_solution/action_calculation.cpp @@ -0,0 +1,1786 @@ +// 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()); + return (ExactSolutionLin(l0, l / 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 <= -1e-3) + { + 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..44fdee89 --- /dev/null +++ b/src/bounce_solution/bounce_solution.cpp @@ -0,0 +1,1095 @@ +// 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(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; + + bool numerically_unstable = false; + + while (std::abs(T_up / T_down - 1) > 1e-8) + { + 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(IatT)); + + if (IatT < int_at_false_vac_frac) + { + T_up = T_middle; + } + else + { + T_down = T_middle; + } + + if (std::abs(T_up / T_down - 1) < 1e-8 and + not almost_the_same(int_at_false_vac_frac, IatT)) + { + numerically_unstable = true; + break; + } + } + if (not numerically_unstable) + { + res_Temp = T_middle; + } + } + 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 \ No newline at end of file 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/Minimizer.cpp b/src/minimizer/Minimizer.cpp index 58c0dcae..09989da6 100644 --- a/src/minimizer/Minimizer.cpp +++ b/src/minimizer/Minimizer.cpp @@ -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, @@ -264,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) 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..843ca1e7 --- /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) >= + 0)); // 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 699572a3..26ab76f8 100644 --- a/src/models/CMakeLists.txt +++ b/src/models/CMakeLists.txt @@ -11,8 +11,9 @@ set(header ${header_path}/ClassPotentialOrigin.h ${header_path}/ClassPotentialC2HDM.h ${header_path}/ClassPotentialR2HDM.h - ${header_path}/ClassPotentialRN2HDM.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) @@ -25,8 +26,9 @@ set(src ClassPotentialOrigin_deprecated.cpp ClassPotentialC2HDM.cpp ClassPotentialR2HDM.cpp - ClassPotentialRN2HDM.cpp + ClassPotentialN2HDM.cpp ClassPotentialCxSM.cpp + ClassPotentialSM.cpp ClassPotentialCPintheDark.cpp # Here you can add your new model ClassTemplate.cpp) diff --git a/src/models/ClassPotentialCxSM.cpp b/src/models/ClassPotentialCxSM.cpp index 7adba547..c5f5baa4 100644 --- a/src/models/ClassPotentialCxSM.cpp +++ b/src/models/ClassPotentialCxSM.cpp @@ -1293,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 98% rename from src/models/ClassPotentialRN2HDM.cpp rename to src/models/ClassPotentialN2HDM.cpp index 1a61bd50..2caed38e 100644 --- a/src/models/ClassPotentialRN2HDM.cpp +++ b/src/models/ClassPotentialN2HDM.cpp @@ -8,7 +8,7 @@ @file */ -#include +#include #include #include #include @@ -20,11 +20,11 @@ namespace BSMPT namespace Models { -Class_Potential_RN2HDM::Class_Potential_RN2HDM(const ISMConstants &smConstants) +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; @@ -54,7 +54,7 @@ Class_Potential_RN2HDM::Class_Potential_RN2HDM(const ISMConstants &smConstants) UseVCounterSimplified = false; } -Class_Potential_RN2HDM::~Class_Potential_RN2HDM() +Class_Potential_N2HDM::~Class_Potential_N2HDM() { // TODO Auto-generated destructor stub } @@ -63,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"); @@ -89,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"); @@ -110,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; @@ -149,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}"); @@ -160,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; @@ -219,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]; @@ -261,12 +260,7 @@ void Class_Potential_RN2HDM::set_gen(const std::vector &p) 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; @@ -432,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; @@ -619,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; @@ -778,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(); @@ -945,7 +939,7 @@ void Class_Potential_RN2HDM::TripleHiggsCouplings() } } -void Class_Potential_RN2HDM::SetCurvatureArrays() +void Class_Potential_N2HDM::SetCurvatureArrays() { initVectors(); @@ -3108,7 +3102,7 @@ void Class_Potential_RN2HDM::SetCurvatureArrays() SetCurvatureDone = true; } -bool Class_Potential_RN2HDM::CalculateDebyeSimplified() +bool Class_Potential_N2HDM::CalculateDebyeSimplified() { double cb = 0; @@ -3160,7 +3154,7 @@ bool Class_Potential_RN2HDM::CalculateDebyeSimplified() return true; } -bool Class_Potential_RN2HDM::CalculateDebyeGaugeSimplified() +bool Class_Potential_N2HDM::CalculateDebyeGaugeSimplified() { DebyeGauge[0][0] = 2 * SMConstants.C_g * SMConstants.C_g; DebyeGauge[1][1] = 2 * SMConstants.C_g * SMConstants.C_g; @@ -3171,7 +3165,7 @@ bool Class_Potential_RN2HDM::CalculateDebyeGaugeSimplified() } double -Class_Potential_RN2HDM::VTreeSimplified(const std::vector &v) const +Class_Potential_N2HDM::VTreeSimplified(const std::vector &v) const { (void)v; double res = 0; @@ -3180,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; @@ -3188,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 d0dd9030..271e7d05 100644 --- a/src/models/ClassPotentialOrigin.cpp +++ b/src/models/ClassPotentialOrigin.cpp @@ -3043,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) @@ -3118,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); } } @@ -3136,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) @@ -3198,22 +3198,22 @@ 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; } } @@ -3287,12 +3287,6 @@ void Class_Potential_Origin::CalculateDebye(bool forceCalculation) } } } - - 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() @@ -3395,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, @@ -3483,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 { 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/IncludeAllModels.cpp b/src/models/IncludeAllModels.cpp index 76cf1bde..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... @@ -35,14 +36,15 @@ std::unique_ptr FChoose(ModelIDs choice, using namespace Models; switch (choice) { + 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::RN2HDM: - return std::make_unique(smConstants); + case ModelIDs::N2HDM: + return std::make_unique(smConstants); break; case ModelIDs::CXSM: return std::make_unique(smConstants); break; case ModelIDs::CPINTHEDARK: diff --git a/src/prog/CalcCT.cpp b/src/prog/CalcCT.cpp index 50636b8f..b93e8157 100644 --- a/src/prog/CalcCT.cpp +++ b/src/prog/CalcCT.cpp @@ -131,7 +131,6 @@ CLIOptions::CLIOptions(const BSMPT::parser &argparser) bool CLIOptions::good() const { - if (Model == ModelID::ModelIDs::NotSet) { Logger::Write( 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/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/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 7c9418d5..87367e14 100644 --- a/src/prog/Test.cpp +++ b/src/prog/Test.cpp @@ -27,6 +27,7 @@ #include // for getline, string #include // for pair #include // for vector + using namespace std; using namespace BSMPT; 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..c8a38faa --- /dev/null +++ b/src/transition_tracer/transition_tracer.cpp @@ -0,0 +1,491 @@ +// 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; + + 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 6c6d969a..c1597309 100644 --- a/src/utility/CMakeLists.txt +++ b/src/utility/CMakeLists.txt @@ -1,7 +1,15 @@ +# 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 - ${header_path}/parser.h) -set(src utility.cpp Logger.cpp parser.cpp) +set(header + ${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) @@ -13,4 +21,5 @@ target_compile_features(Utility PUBLIC cxx_std_17) if(nlohmann_json_FOUND) target_link_libraries(Utility PRIVATE nlohmann_json::nlohmann_json) endif() -target_compile_features(Utility PUBLIC cxx_std_17) + +target_link_libraries(Utility PUBLIC ASCIIPlotter Spline) diff --git a/src/utility/Logger.cpp b/src/utility/Logger.cpp index 22c675ea..061282d5 100644 --- a/src/utility/Logger.cpp +++ b/src/utility/Logger.cpp @@ -20,14 +20,16 @@ namespace BSMPT { static std::map LoggingPrefixes{ - { - "logginglevel::default", - LoggingLevel::Default, - }, - {"logginglevel::debug", LoggingLevel::Debug}, - {"logginglevel::ewbgdetailed", LoggingLevel::EWBGDetailed}, - {"logginglevel::progdetailed", LoggingLevel::ProgDetailed}, - {"logginglevel::minimizerdetailed", LoggingLevel::MinimizerDetailed}}; + {"--logginglevel::default=", LoggingLevel::Default}, + {"--logginglevel::debug=", LoggingLevel::Debug}, + {"--logginglevel::ewbgdetailed=", LoggingLevel::EWBGDetailed}, + {"--logginglevel::progdetailed=", LoggingLevel::ProgDetailed}, + {"--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() { @@ -60,10 +62,21 @@ void SetLogger(const BSMPT::parser &argparser) 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(prefix); + 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 &) { @@ -91,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); + } } } 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..c10b36f4 --- /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) +{ + // 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() +{ + 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 index 8b029662..2f838bb4 100644 --- a/src/utility/parser.cpp +++ b/src/utility/parser.cpp @@ -1,3 +1,8 @@ +// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas +// Müller +// +// SPDX-License-Identifier: GPL-3.0-or-later + #include #include #include @@ -24,10 +29,14 @@ const char *parserException::what() const noexcept parser::parser() { - add_argument("logginglevel::disabled", "Disable the Logger.", false); + 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); @@ -39,9 +48,6 @@ parser::parser() "logginglevel::minimizerdetailed", "Turn on/off (true/false) the additional output of the minimizers.", false); - add_argument("logginglevel::default", - "Turn on/off (true/false) the default output.", - false); add_argument("json", "Use a json file to define the input instead of additional cli " @@ -49,6 +55,43 @@ parser::parser() 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", @@ -65,6 +108,36 @@ void parser::enable_minimizer_options() 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) @@ -74,6 +147,33 @@ void parser::add_argument(const std::string &argument, 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); @@ -84,6 +184,14 @@ void parser::add_argument(const std::string &argument, } } +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) @@ -146,21 +254,80 @@ void parser::print_help() const return; } mHelpAlreadyPrinted = true; - std::stringstream ss; + std::stringstream ss, ss_end; ss << mHeader << std::endl; - ss << "The required options are:" << std::endl; - for (const auto &[arg, options] : mRequiredArguments) + 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) { - (void)arg; - ss << "--" << options.argument << ":\t" << options.description << std::endl; + 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(); } - ss << "The optional arguments are:" << std::endl; - for (const auto &[arg, options] : mOptionalArguments) + else { - (void)arg; - ss << "--" << options.argument << ":\t" << options.description << std::endl; + 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()); } - Logger::Write(LoggingLevel::Default, ss.str()); } std::string parser::get_value_as_string(const std::string &argument) const 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 2045e63e..f340c6cf 100644 --- a/src/utility/utility.cpp +++ b/src/utility/utility.cpp @@ -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,6 +48,39 @@ 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; +} + bool StringEndsWith(const std::string &str, const std::string &suffix) { return str.size() >= suffix.size() and 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..1954a862 --- /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 *ClosestBounceActionInt; + std::cout << "Found a transitions with Tp =\t" + << bounce.GetPercolationTemp() << " GeV.\n"; + for (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/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 05404078..ac553036 100644 --- a/tests/GenerateTestCompares/CMakeLists.txt +++ b/tests/GenerateTestCompares/CMakeLists.txt @@ -3,9 +3,9 @@ # # SPDX-License-Identifier: GPL-3.0-or-later -set(header C2HDM.h R2HDM.h RN2HDM.h CPINTHEDARK.h CXSM.h) +set(header C2HDM.h R2HDM.h N2HDM.h CPINTHEDARK.h CXSM.h SM.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_17) 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/unittests/CMakeLists.txt b/tests/unittests/CMakeLists.txt index 8da16b23..c42dde89 100644 --- a/tests/unittests/CMakeLists.txt +++ b/tests/unittests/CMakeLists.txt @@ -12,10 +12,14 @@ target_link_libraries( PRIVATE Catch2::Catch2WithMain CatchEventListener Minimizer + MinimumTracer Models Utility TestCompares - ThermalFunctions) + ThermalFunctions + BounceSolution + TransitionTracer + GW) target_compile_features(GenericTests PUBLIC cxx_std_17) include(Catch) diff --git a/tests/unittests/Test-gw.cpp b/tests/unittests/Test-gw.cpp new file mode 100644 index 00000000..1a02baa5 --- /dev/null +++ b/tests/unittests/Test-gw.cpp @@ -0,0 +1,1015 @@ +// 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 + +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); +} \ No newline at end of file diff --git a/tests/unittests/Test-rn2hdm.cpp b/tests/unittests/Test-n2hdm.cpp similarity index 76% rename from tests/unittests/Test-rn2hdm.cpp rename to tests/unittests/Test-n2hdm.cpp index 3be1985d..e63e908b 100644 --- a/tests/unittests/Test-rn2hdm.cpp +++ b/tests/unittests/Test-n2hdm.cpp @@ -14,23 +14,23 @@ 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]") { @@ -38,7 +38,7 @@ TEST_CASE("Checking NLOVEV for N2HDM", "[n2hdm]") const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = ModelID::FChoose(Model, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + modelPointer->initModel(example_point_N2HDM); std::vector Check; auto sol = Minimizer::Minimize_gen_all(modelPointer, 0, @@ -59,7 +59,7 @@ TEST_CASE("Checking EWPT for N2HDM", "[n2hdm]") const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = ModelID::FChoose(Model, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + modelPointer->initModel(example_point_N2HDM); std::vector Check; auto EWPT = Minimizer::PTFinder_gen_all( modelPointer, 0, 300, Minimizer::WhichMinimizerDefault); @@ -93,8 +93,8 @@ 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, SMConstants); - 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); } @@ -104,8 +104,8 @@ 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, SMConstants); - 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); } @@ -117,8 +117,8 @@ TEST_CASE( using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - 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); } @@ -128,8 +128,8 @@ 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, SMConstants); - 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); } @@ -139,8 +139,8 @@ 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, SMConstants); - 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); } @@ -150,8 +150,8 @@ 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, SMConstants); - 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); @@ -162,8 +162,8 @@ 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, SMConstants); - 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); @@ -174,8 +174,8 @@ 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, SMConstants); - 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); } @@ -185,8 +185,8 @@ 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, SMConstants); - 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); } @@ -196,10 +196,10 @@ TEST_CASE("Checking VTreeSimplified for N2HDM", "[n2hdm]") using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); + 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); } @@ -214,10 +214,10 @@ TEST_CASE("Checking VCounterSimplified for N2HDM", "[n2hdm]") using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); + 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); } @@ -233,8 +233,8 @@ TEST_CASE("Checking first derivative of the sum of CT and CW in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - 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); } @@ -245,8 +245,8 @@ TEST_CASE("Checking second derivative of the sum of CT and CW in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - 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); } @@ -257,8 +257,8 @@ 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, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); modelPointer->Prepare_Triple(); modelPointer->TripleHiggsCouplings(); @@ -297,8 +297,8 @@ 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, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckCTNumber(*modelPointer)); } @@ -309,8 +309,8 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lij in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorScalarSecond( @@ -323,8 +323,8 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijk in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorScalarThird( @@ -337,8 +337,8 @@ TEST_CASE("Check symmetric properties of the scalar tensor Lijkl in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorScalarFourth( @@ -351,8 +351,8 @@ TEST_CASE("Check symmetric properties of the gauge tensor in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorGauge( @@ -365,8 +365,8 @@ TEST_CASE("Check symmetric properties of the Lepton tensor in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorLeptonsThird( @@ -379,8 +379,8 @@ TEST_CASE("Check symmetric properties of the mass Lepton tensor in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorLeptons( @@ -393,8 +393,8 @@ TEST_CASE("Check symmetric properties of the mass quark tensor in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - modelPointer->initModel(example_point_RN2HDM); + ModelID::FChoose(ModelID::ModelIDs::N2HDM, SMConstants); + modelPointer->initModel(example_point_N2HDM); REQUIRE(ModelTests::TestResults::Pass == ModelTests::CheckSymmetricTensorQuarks( @@ -407,8 +407,8 @@ TEST_CASE("Check symmetric properties of the quark tensor in the N2HDM", using namespace BSMPT; const auto SMConstants = GetSMConstants(); std::shared_ptr modelPointer = - ModelID::FChoose(ModelID::ModelIDs::RN2HDM, SMConstants); - 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-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..2ed22825 --- /dev/null +++ b/tests/unittests/Test-utility.cpp @@ -0,0 +1,81 @@ +// 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)); +} \ No newline at end of file