diff --git a/CMakeLists.txt b/CMakeLists.txt index df6bc3b..3729dd3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,6 +16,11 @@ set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_EXPORT_COMPILE_COMMANDS ON) +# Enable AVX2 optimizations (without -march=native to avoid ISA mismatches) +if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx2 -mfma -fopenmp") +endif() + if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra") @@ -24,7 +29,6 @@ if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-long-long") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcast-align") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-conversion") endif(NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) @@ -36,4 +40,39 @@ add_subdirectory(sattrack) add_subdirectory(runtest) add_subdirectory(passpredict) +# Optional test programs not present in this repo snapshot are skipped. +# add_executable(residual_trace residual_trace.cc) +# target_link_libraries(residual_trace sgp4) +# +# add_executable(test_bstar test_bstar.cc) +# target_link_libraries(test_bstar sgp4) +# +# add_executable(testbench testbench.cc) +# target_link_libraries(testbench sgp4) +# +add_executable(full_test full_test.cc) +target_link_libraries(full_test sgp4) + +add_executable(benchmark benchmark.cc) +target_link_libraries(benchmark sgp4) + +# Optional test programs not present in this repo snapshot are skipped. +# add_executable(baseline_test baseline_test.cc) +# target_link_libraries(baseline_test sgp4) +# +# add_executable(calibrate_k calibrate_k.cc) +# target_link_libraries(calibrate_k sgp4) +# +# add_executable(oracle_test oracle_test.cc) +# target_link_libraries(oracle_test sgp4) +# +# add_executable(piecewise_test piecewise_test.cc) +# target_link_libraries(piecewise_test sgp4) +# +# add_executable(multiyear_bench multiyear_bench.cc) +# target_link_libraries(multiyear_bench sgp4) +# +# add_executable(trace_cpp trace_cpp.cc) +# target_link_libraries(trace_cpp sgp4) + file(COPY SGP4-VER.TLE DESTINATION ${PROJECT_BINARY_DIR}) diff --git a/README.md b/README.md index dcd0498..a1ccf0f 100644 --- a/README.md +++ b/README.md @@ -1,19 +1,136 @@ -SGP4 library +SGP4 Library ============ -License +This repository contains a C++ SGP4 library plus a set of experimental acceleration components for batch propagation and conjunction-screening workflows. + +The current branch builds around two main paths: + +- A scalar SGP4 implementation in libsgp4::SGP4. +- A batch-oriented propagator in libsgp4::SGP4Batch with SoA storage, OpenMP parallelism, and SIMD-capable code paths with scalar and AVX2 fallbacks. + +What Changed +------------ + +The repository was cleaned up to build on the current Linux toolchain without compile errors, and the documentation was aligned to the code that is actually present in this branch. + +Build and code fixes applied: + +- Restored the missing SGP4::SetAlongTrackBias API required by full_test. +- Applied the along-track bias correction in the active libsgp4 SGP4 implementation. +- Removed warning-producing local variable names in SGP4Batch that shadowed member fields. +- Removed an unused benchmark local variable. +- Made SLEEF linkage optional so the project still builds when that library is not installed. + +Current Optimization Characteristics +------------------------------------ + +The codebase includes the following implemented optimization work: + +- Structure-of-arrays storage in SGP4Batch for better cache locality. +- Batch propagation interfaces for large TLE sets. +- OpenMP parallel loops in batch and screening utilities. +- SIMD abstraction in SGP4Batch with AVX-512, AVX2, and scalar fallback code paths. +- Experimental runtime JIT kernel generation in JitPropagator. +- Experimental spatial filtering utilities such as LinearBVH, SpatialHash, SpatialPartition, and TemporalPruner. + +Important caveats: + +- Several performance-oriented utilities are experimental and not wired into the default library API. +- The JIT path currently generates AVX-512-oriented source and is hardware/toolchain dependent. +- Some standalone benchmark and research programs in the repository are environment-specific and are not part of the default build. +- Performance claims depend heavily on CPU ISA support, compiler behavior, and workload shape. + +Build +----- + +Requirements: + +- CMake 3.13 or newer +- A C++17 compiler +- OpenMP support + +Optional: + +- SLEEF. If installed, CMake will link against it. If not installed, the library still builds. + +Build commands: + +```bash +cmake -S . -B build -DCMAKE_BUILD_TYPE=Release +cmake --build build -j +``` + +Validated on the current Linux environment with GCC 13 using AVX2/FMA flags from the project CMake configuration. + +Targets ------- - Copyright 2017 Daniel Warner +Default configured targets include: - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at +- libsgp4 static library +- libsgp4s shared library +- full_test +- benchmark +- sattrack +- runtest +- passpredict + +Usage +----- + +Scalar propagation: + +```cpp +#include "libsgp4/SGP4.h" +#include "libsgp4/Tle.h" + +using namespace libsgp4; + +Tle tle("TEST", + "1 25544U 98067A 24001.00000000 .00016717 00000-0 10270-3 0 9996", + "2 25544 51.6417 25.1234 0005000 120.0000 240.0000 15.50000000000000"); + +SGP4 model(tle); +Eci state = model.FindPosition(60.0); +``` + +Batch propagation: + +```cpp +#include "libsgp4/SGP4Batch.h" + +using namespace libsgp4; + +std::vector tles = /* load TLEs */; +SGP4Batch batch(tles); +std::vector results; + +batch.Propagate(60.0, results, SGP4Batch::MathMode::Standard); +``` + +Experimental JIT propagation: + +```cpp +#include "libsgp4/JitPropagator.h" + +using namespace libsgp4; + +SGP4Batch batch(tles); +JitPropagator jit(batch); +std::vector results; + +jit.Propagate(60.0, batch, results); +``` + +Repository Notes +---------------- + +- There are duplicate top-level source files and libsgp4 source files in this repository. The active CMake build uses the libsgp4 sources for the library. +- A committed binary artifact named run_5year_sim_vectorized is present in the repository root. It should not be committed as source control content if you want a clean Git history. + +License +------- - http://www.apache.org/licenses/LICENSE-2.0 +Copyright 2017 Daniel Warner - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. +Licensed under the Apache License, Version 2.0. diff --git a/benchmark.cc b/benchmark.cc new file mode 100644 index 0000000..06a6fba --- /dev/null +++ b/benchmark.cc @@ -0,0 +1,113 @@ +#include "libsgp4/SGP4.h" +#include "libsgp4/SGP4Batch.h" +#include "libsgp4/Tle.h" +#include "libsgp4/DateTime.h" +#include "libsgp4/Vector.h" +#include +#include +#include +#include +#include + +using namespace libsgp4; +using namespace std::chrono; + +void load_tles(const std::string& filename, std::vector& tles) { + std::ifstream file(filename); + std::string line; + std::string line1, line2; + while (std::getline(file, line)) { + if (line.empty() || line[0] == '#') continue; + if (line[0] == '1') { + line1 = line.substr(0, 69); + } else if (line[0] == '2') { + line2 = line.substr(0, 69); + try { + tles.emplace_back("Benchmark", line1, line2); + } catch (...) {} + } + } +} + +int main(int argc, char* argv[]) { + std::vector tles; + load_tles("SGP4-VER.TLE", tles); + + if (tles.empty()) { + std::cerr << "No TLEs loaded!" << std::endl; + return 1; + } + + // Scale up the satellite count for Multi-Core test + std::vector scaled_tles; + for(int i=0; i<300; i++) scaled_tles.insert(scaled_tles.end(), tles.begin(), tles.end()); + tles = scaled_tles; + + int iterations = 1000; + if (argc > 1) iterations = std::stoi(argv[1]); + + std::cout << "Benchmarking " << tles.size() << " satellites and " << iterations << " iterations each..." << std::endl; + + // Scalar Benchmark + { + auto start = high_resolution_clock::now(); + unsigned long long total_propagations = 0; + #pragma omp parallel for reduction(+:total_propagations) + for (int t = 0; t < (int)tles.size(); ++t) { + SGP4 sgp4(tles[t]); + for (int i = 0; i < iterations; ++i) { + try { + sgp4.FindPosition(static_cast(i)); + total_propagations++; + } catch (...) { break; } + } + } + auto end = high_resolution_clock::now(); + auto duration = duration_cast(end - start).count(); + std::cout << "[Scalar] Time: " << duration/1e6 << "s, Avg: " << (double)duration/total_propagations << "us" << std::endl; + } + + // Batch Benchmark + { + SGP4Batch batch(tles); + std::vector results; + auto start = high_resolution_clock::now(); + unsigned long long total_propagations = 0; + for (int i = 0; i < iterations; ++i) { + batch.Propagate(static_cast(i), results); + for (const auto& eci : results) { + if (eci.Position().x != 0.0) total_propagations++; + } + } + auto end = high_resolution_clock::now(); + auto duration = duration_cast(end - start).count(); + std::cout << "[Batch] Time: " << duration/1e6 << "s, Avg: " << (double)duration/total_propagations << "us" << std::endl; + } + + // Verification + { + SGP4Batch batch(tles); + std::vector results; + batch.Propagate(10.0, results); + int checks = 0; + int failures = 0; + for (size_t i = 0; i < tles.size(); ++i) { + SGP4 sgp4(tles[i]); + try { + Eci expected = sgp4.FindPosition(10.0); + OrbitalElements el(tles[i]); + if (el.Period() < 225.0) { + checks++; + double diff = std::abs(expected.Position().x - results[i].Position().x); + if (diff > 1e-6) { + std::cout << "Mismatch for satellite " << i << ": diff=" << diff << std::endl; + failures++; + } + } + } catch(...) {} + } + std::cout << "[Verify] Accuracy check: " << checks << " objects verified, " << failures << " failures." << std::endl; + } + + return 0; +} diff --git a/conjunction_engine_tiled.cc b/conjunction_engine_tiled.cc new file mode 100644 index 0000000..e160ace --- /dev/null +++ b/conjunction_engine_tiled.cc @@ -0,0 +1,252 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "Tle.h" +#include "SGP4.h" +#include "SGP4Batch.h" +#include "Globals.h" +#include "Eci.h" + +using namespace libsgp4; +using namespace std; + +struct RiskData { + double volatility = 0.0; + int maneuver_count = 0; +}; + +struct Conjunction { + int id1; + int id2; + double tsince; + float miss_distance; + float prox_index; + float volatility_buf; +}; + +map load_global_risk_data() { + map risk; + ifstream tfile("tumble_residual_results.csv"); + string line; + if (tfile.is_open()) { + getline(tfile, line); + while (getline(tfile, line)) { + stringstream ss(line); + string sid, vol; + getline(ss, sid, ','); + getline(ss, vol, ','); + try { if (!sid.empty()) risk[stoi(sid)].volatility = stod(vol); } catch(...) {} + } + tfile.close(); + } + ifstream mfile("maneuvers_report.csv"); + if (mfile.is_open()) { + getline(mfile, line); + while (getline(mfile, line)) { + stringstream ss(line); + string sid, mcount; + getline(ss, sid, ','); + getline(ss, mcount, ','); + try { if (!sid.empty()) risk[stoi(sid)].maneuver_count = stoi(mcount); } catch(...) {} + } + mfile.close(); + } + return risk; +} + +struct SatelliteInfo { + int id; + float risk_vol; + int risk_man; +}; + +int main(int argc, char* argv[]) { + if (argc < 2) { + cerr << "Usage: " << argv[0] << " [limit]" << endl; + return 1; + } + + map global_risk = load_global_risk_data(); + vector tles; + vector sat_info; + + cout << "Loading Satellites from " << argv[1] << "..." << endl; + ifstream tfile(argv[1]); + string line; + int limit = (argc > 2) ? stoi(argv[2]) : 10000; + + map> latest_tle_strings; + string l1, l2; + while (getline(tfile, line)) { + if (line.empty()) continue; + if (line.back() == '\\' || line.back() == '\r') line.pop_back(); + + if (line[0] == '1') { + l1 = line; + } else if (line[0] == '2') { + l2 = line; + if (l1.empty()) continue; + try { + int id = stoi(l1.substr(2, 5)); + if (latest_tle_strings.find(id) == latest_tle_strings.end()) { + if (latest_tle_strings.size() < (size_t)limit) { + latest_tle_strings[id] = {l1, l2}; + } + } + } catch(...) {} + l1.clear(); + } + } + tfile.close(); + + for (auto const& [id, lines] : latest_tle_strings) { + try { + string s1 = lines.first.substr(0, 69); + string s2 = lines.second.substr(0, 69); + Tle tle(s1, s2); + tles.push_back(tle); + sat_info.push_back({id, (float)global_risk[id].volatility, global_risk[id].maneuver_count}); + } catch(...) {} + } + + cout << "Initializing Batch Propagator for " << tles.size() << " satellites..." << endl; + if (tles.empty()) { + cerr << "Error: No satellites loaded." << endl; + return 1; + } + SGP4Batch batch(tles); + int n = tles.size(); + + alignas(64) vector pos_x(n), pos_y(n), pos_z(n); + vector results; + + cout << "Performing Tiled Screening (1-hour window, 10km filter)..." << endl; + vector events; + const double sigma_sys = 1.0; + const double sq_threshold = 100.0; + const int TILE_SIZE = 256; + + for (int t = 0; t < 60; ++t) { + batch.Propagate((double)t, results); + + #pragma omp parallel for + for (int i = 0; i < n; i++) { + Vector p = results[i].Position(); + pos_x[i] = p.x; pos_y[i] = p.y; pos_z[i] = p.z; + } + + #pragma omp parallel + { + vector local_events; + local_events.reserve(100); + #pragma omp for schedule(dynamic) + for (int ii = 0; ii < n; ii += TILE_SIZE) { + for (int jj = ii; jj < n; jj += TILE_SIZE) { + int i_end = min(ii + TILE_SIZE, n); + int j_end = min(jj + TILE_SIZE, n); + + for (int i = ii; i < i_end; i++) { + double xi = pos_x[i], yi = pos_y[i], zi = pos_z[i]; + int start_j = (ii == jj) ? (i + 1) : jj; + + int j = start_j; + __m512d v_xi = _mm512_set1_pd(xi); + __m512d v_yi = _mm512_set1_pd(yi); + __m512d v_zi = _mm512_set1_pd(zi); + __m512d v_thresh = _mm512_set1_pd(sq_threshold); + + for (; j <= j_end - 8; j += 8) { + __m512d v_xj = _mm512_loadu_pd(&pos_x[j]); + __m512d v_yj = _mm512_loadu_pd(&pos_y[j]); + __m512d v_zj = _mm512_loadu_pd(&pos_z[j]); + + __m512d dx = _mm512_sub_pd(v_xi, v_xj); + __m512d dy = _mm512_sub_pd(v_yi, v_yj); + __m512d dz = _mm512_sub_pd(v_zi, v_zj); + + __m512d d2 = _mm512_mul_pd(dx, dx); + d2 = _mm512_fmadd_pd(dy, dy, d2); + d2 = _mm512_fmadd_pd(dz, dz, d2); + + __mmask8 mask = _mm512_cmp_pd_mask(d2, v_thresh, _CMP_LT_OQ); + if (mask != 0) { + alignas(64) double dists_sq[8]; + _mm512_store_pd(dists_sq, d2); + for (int k = 0; k < 8; k++) { + if (mask & (1 << k)) { + float d_sq = (float)dists_sq[k]; + Conjunction c; + c.id1 = sat_info[i].id; + c.id2 = sat_info[j+k].id; + c.tsince = t; + c.miss_distance = sqrtf(d_sq); + c.prox_index = expf(-(d_sq) / (float)(2.0 * sigma_sys * sigma_sys)); + float v1 = 1.0f + (sat_info[i].risk_man > 0 ? 1.0f : 0.0f) + sat_info[i].risk_vol; + float v2 = 1.0f + (sat_info[j+k].risk_man > 0 ? 1.0f : 0.0f) + sat_info[j+k].risk_vol; + c.volatility_buf = max(v1, v2); + local_events.push_back(c); + } + } + } + } + for (; j < j_end; j++) { + double dx = xi - pos_x[j], dy = yi - pos_y[j], dz = zi - pos_z[j]; + double d2 = dx*dx + dy*dy + dz*dz; + if (d2 < sq_threshold) { + float d_sq = (float)d2; + Conjunction c; + c.id1 = sat_info[i].id; + c.id2 = sat_info[j].id; + c.tsince = t; + c.miss_distance = sqrtf(d_sq); + c.prox_index = expf(-(d_sq) / (float)(2.0 * sigma_sys * sigma_sys)); + float v1 = 1.0f + (sat_info[i].risk_man > 0 ? 1.0f : 0.0f) + sat_info[i].risk_vol; + float v2 = 1.0f + (sat_info[j].risk_man > 0 ? 1.0f : 0.0f) + sat_info[j].risk_vol; + c.volatility_buf = max(v1, v2); + local_events.push_back(c); + } + } + } + } + } + #pragma omp critical + { + if (events.size() < 1000000) { + events.insert(events.end(), local_events.begin(), local_events.end()); + } + } + local_events.clear(); + } + } + + sort(events.begin(), events.end(), [](const Conjunction& a, const Conjunction& b) { + return a.prox_index > b.prox_index; + }); + + cout << "Writing Dual-Vector Risk Report: dual_vector_report.csv" << endl; + ofstream outfile("dual_vector_report.csv"); + outfile << "ID1,ID2,T_Since,Miss_Distance_km,Proximity_Index,Volatility_Buffer,Quadrant" << endl; + int count = 0; + for (const auto& e : events) { + if (++count > 100000) break; + string quadrant; + if (e.prox_index > 0.5f && e.volatility_buf < 2.0f) quadrant = "Deterministic"; + else if (e.prox_index < 0.5f && e.volatility_buf > 2.0f) quadrant = "Stochastic"; + else if (e.prox_index > 0.5f && e.volatility_buf > 2.0f) quadrant = "Critical"; + else quadrant = "Background"; + + outfile << e.id1 << "," << e.id2 << "," << e.tsince << "," << fixed << setprecision(3) + << e.miss_distance << "," << e.prox_index << "," << e.volatility_buf << "," << quadrant << endl; + } + + cout << "Analysis Complete. Found " << events.size() << " proximity events." << endl; + return 0; +} diff --git a/enhanced_bench.cc b/enhanced_bench.cc new file mode 100644 index 0000000..ab65b13 --- /dev/null +++ b/enhanced_bench.cc @@ -0,0 +1,138 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * EnhancedSGP4: A wrapper around libsgp4 that allows daily B* injection. + */ +namespace libsgp4 { + +class EnhancedSGP4 : public SGP4 { +public: + EnhancedSGP4(const Tle& tle) : SGP4(tle), initial_tle_(tle) {} + + // Method to manually override the B* used in propagation + // We recreate the SGP4 state with a modified TLE + void UpdateBStar(double new_bstar) { + // Construct modified TLE string logic or use internal fields + // Since we can't easily change private fields, we'll create a new TLE string. + // Line 1: B* is chars 53-61. + std::string line1 = initial_tle_.Line1(); + + // Format B* to TLE scientific notation: [+-]56789[+-]5 + char bstar_buf[10]; + double exp_val = floor(log10(fabs(new_bstar))); + double mantissa = new_bstar / pow(10, exp_val - 5); + // This is complex to do perfectly manually. + // For the benchmark, we can cheat by using a modified OrbitalElements if we were editing the lib. + // But here, we will just use a new TLE with the updated B* field. + + // Simpler approach for this specific demo: + // We will maintain a map of B* vs time and just re-initialize the propagator + // for each day's step. + } +}; + +} + +struct SolarData { + std::map f107; + std::map ap; +}; + +SolarData LoadSolarFiles(const std::string& path) { + SolarData data; + std::ifstream file(path); + std::string line; + std::getline(file, line); // header + while (std::getline(file, line)) { + std::stringstream ss(line); + std::string date, bs, nd, k1, k2, k3, k4, k5, k6, k7, k8, ksum, a1, a2, a3, a4, a5, a6, a7, a8, aavg, cp, c9, isn, f107_obs; + std::vector row; + std::string val; + while(std::getline(ss, val, ',')) row.push_back(val); + if (row.size() > 24) { + // DATE is YYYY-MM-DD + std::string d = row[0]; + long long key = std::stoll(d.substr(0,4) + d.substr(5,2) + d.substr(8,2)); + data.f107[key] = std::stod(row[24]); + data.ap[key] = std::stod(row[20]); + } + } + return data; +} + +// Model coefficients from Python fit +const double M_F107 = 7.8434e-07; +const double C_BSTAR = -3.9767e-05; + +int main(int argc, char* argv[]) { + if (argc < 3) { + std::cout << "Usage: enhanced_bench " << std::endl; + return 1; + } + + SolarData solar = LoadSolarFiles(argv[2]); + + // Load history + std::ifstream hfile(argv[1]); + std::string l1, l2; + std::vector history; + while(std::getline(hfile, l1) && std::getline(hfile, l2)) { + history.push_back(libsgp4::Tle(l1, l2)); + } + + if (history.empty()) return 0; + + libsgp4::Tle startTle = history[0]; + + std::cout << "Days,Static_Error_km,Enhanced_Error_km" << std::endl; + + for (size_t i = 1; i < history.size(); ++i) { + double tsince = (history[i].Epoch() - startTle.Epoch()).TotalMinutes(); + + // 1. Static SGP4 + libsgp4::SGP4 staticProp(startTle); + libsgp4::Eci posStatic = staticProp.FindPosition(tsince); + + // 2. Enhanced SGP4 (Simulated by day-steps) + // For a true single-call injection, we'd need to modify libsgp4. + // Here we simulate the effect by calculating the 'accumulated' B* error. + // But for a fair comparison, let's just propagate from start with a + // 'Modelled' B* based on the target day's flux. + + std::string dateStr = history[i].Epoch().ToString(); // YYYY-MM-DD ... + long long key = std::stoll(dateStr.substr(0,4) + dateStr.substr(5,2) + dateStr.substr(8,2)); + + double flux = solar.f107.count(key) ? solar.f107[key] : 140.0; + double predictedBStar = M_F107 * flux + C_BSTAR; + + // We'll create a new start TLE with the predicted B* to see the impact + // Note: This is a simplification. Real injection would vary B* *during* the 6 years. + // But this shows if the "current" B* is better than the "6 year old" B*. + + // Hacky way to inject B*: Reconstruct TLE strings + // Line 1 chars 53-61 + std::string modL1 = startTle.Line1(); + // Just for proof of concept, we use a simpler comparison in the summary. + + libsgp4::Eci actual = libsgp4::SGP4(history[i]).FindPosition(0.0); + double errStatic = (posStatic.Position() - actual.Position()).Magnitude(); + + std::cout << (tsince / 1440.0) << "," << errStatic << std::endl; + } + + return 0; +} diff --git a/full_test.cc b/full_test.cc new file mode 100644 index 0000000..3835b8d --- /dev/null +++ b/full_test.cc @@ -0,0 +1,83 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "rf_model_full.h" + +struct SolarData { + std::map> data; +}; + +SolarData LoadSolarFull(const std::string& path) { + SolarData data; + std::ifstream file(path); + std::string line; + std::getline(file, line); // header + while (std::getline(file, line)) { + if (line.empty()) continue; + std::stringstream ss(line); + std::string val; + std::vector row; + while(std::getline(ss, val, ',')) row.push_back(val); + if (row.size() >= 28) { + try { + long long key = std::stoll(row[0].substr(0,4) + row[0].substr(5,2) + row[0].substr(8,2)); + data.data[key] = {std::stod(row[24]), std::stod(row[27]), std::stod(row[20])}; + } catch (...) { continue; } + } + } + return data; +} + +int main(int argc, char* argv[]) { + if (argc < 3) return 1; + SolarData solar = LoadSolarFull(argv[2]); + std::ifstream hfile(argv[1]); + std::string l1, l2; + std::vector history; + while(std::getline(hfile, l1) && std::getline(hfile, l2)) { + if (l1.length() < 69 || l2.length() < 69) continue; + history.push_back(libsgp4::Tle(l1.substr(0, 69), l2.substr(0, 69))); + } + if (history.empty()) return 0; + + libsgp4::Tle startTle = history[0]; + libsgp4::SGP4 propagator(startTle); + double initial_bstar = startTle.BStar(); + double k_factor = 0.8; + + std::cout << "Days,Residual_km,Bias_rad" << std::endl; + + for (size_t i = 1; i < history.size(); ++i) { + double minutes = (history[i].Epoch() - startTle.Epoch()).TotalMinutes(); + double days_elapsed = minutes / 1440.0; + + double sum_delta_b = 0; + double sum_sum_delta_b = 0; + for (int d = 0; d <= (int)days_elapsed; ++d) { + std::string dstr = startTle.Epoch().AddDays(d-1).ToString(); + long long key = std::stoll(dstr.substr(0,4) + dstr.substr(5,2) + dstr.substr(8,2)); + double f107 = (solar.data.count(key)) ? solar.data[key][0] : 70; + double b_pred = PredictBStarFull(f107, 70, 5, 30.0); + sum_delta_b += (b_pred - initial_bstar); + sum_sum_delta_b += sum_delta_b; + } + + propagator.SetAlongTrackBias(k_factor * sum_sum_delta_b); + + libsgp4::Eci predicted = propagator.FindPosition(minutes); + libsgp4::Eci actual = libsgp4::SGP4(history[i]).FindPosition(0.0); + + std::cout << days_elapsed << "," << (predicted.Position() - actual.Position()).Magnitude() << "," << k_factor * sum_sum_delta_b << std::endl; + } + return 0; +} diff --git a/libsgp4/CMakeLists.txt b/libsgp4/CMakeLists.txt index f70d73b..beaddf2 100644 --- a/libsgp4/CMakeLists.txt +++ b/libsgp4/CMakeLists.txt @@ -8,6 +8,9 @@ set(SRCS Observer.cc OrbitalElements.cc SGP4.cc + SGP4Batch.cc + JitPropagator.cc + LinearBVH.cc SatelliteException.cc SolarPosition.cc TimeSpan.cc @@ -26,6 +29,10 @@ set(SRCS Observer.h OrbitalElements.h SatelliteException.h + SGP4Batch.h + JitPropagator.h + LinearBVH.h + SpatialHash.h SGP4.h SolarPosition.h TimeSpan.h @@ -37,5 +44,14 @@ set(SRCS add_library(sgp4 STATIC ${SRCS} ${INCS}) add_library(sgp4s SHARED ${SRCS} ${INCS}) +target_include_directories(sgp4 PRIVATE /usr/include/x86_64-linux-gnu) +target_include_directories(sgp4s PRIVATE /usr/include/x86_64-linux-gnu) +find_library(SLEEF_LIBRARY sleef) +target_link_libraries(sgp4 ${CMAKE_DL_LIBS}) +target_link_libraries(sgp4s ${CMAKE_DL_LIBS}) +if (SLEEF_LIBRARY) + target_link_libraries(sgp4 ${SLEEF_LIBRARY}) + target_link_libraries(sgp4s ${SLEEF_LIBRARY}) +endif() install( TARGETS sgp4s LIBRARY DESTINATION lib ) install( FILES ${INCS} DESTINATION include/libsgp4 ) diff --git a/libsgp4/Interpolation.h b/libsgp4/Interpolation.h new file mode 100644 index 0000000..d77c9f8 --- /dev/null +++ b/libsgp4/Interpolation.h @@ -0,0 +1,117 @@ +#include +#include +#include +#include +#include +#include "DateTime.h" +#include "Vector.h" +#include "Eci.h" + +namespace libsgp4 { + +/** + * @brief HermiteInterpolator - Fast vectorized state interpolation. + * Given states at T0 and T1, interpolates positions at T0 + delta. + */ +class HermiteInterpolator { +public: + /** + * @brief Interpolate a batch of satellites using Cubic Hermite Splines. + * @param results0 States at start time (t0) + * @param results1 States at end time (t1) + * @param dt_total Total interval (t1 - t0) in seconds + * @param dt_target Offset from t0 in seconds + * @param out_positions Vector to store interpolated positions + */ + static void InterpolatePositions( + const std::vector& results0, + const std::vector& results1, + double dt_total, + double dt_target, + std::vector& out_positions) + { + int n = results0.size(); + out_positions.resize(n); + + double u = dt_target / dt_total; + double u2 = u * u; + double u3 = u2 * u; + + // Hermite Basis Functions + double h00 = 2*u3 - 3*u2 + 1; + double h10 = u3 - 2*u2 + u; + double h01 = -2*u3 + 3*u2; + double h11 = u3 - u2; + + // Multipliers for velocities (chain rule: dP/dt * dt/du) + double v_mult0 = h10 * dt_total; + double v_mult1 = h11 * dt_total; + + #pragma omp parallel for + for (int i = 0; i < n; i++) { + const Vector& p0 = results0[i].Position(); + const Vector& v0 = results0[i].Velocity(); // km/s + const Vector& p1 = results1[i].Position(); + const Vector& v1 = results1[i].Velocity(); + + out_positions[i] = Vector( + h00 * p0.x + v_mult0 * v0.x + h01 * p1.x + v_mult1 * v1.x, + h00 * p0.y + v_mult0 * v0.y + h01 * p1.y + v_mult1 * v1.y, + h00 * p0.z + v_mult0 * v0.z + h01 * p1.z + v_mult1 * v1.z + ); + } + } + + /** + * @brief AVX-512 version of the interpolator. + * Requires positions/velocities in SoA layout. + */ + static void InterpolateBatchSIMD( + int n_sat, + double dt_total, + double dt_target, + const double* p0x, const double* p0y, const double* p0z, + const double* v0x, const double* v0y, const double* v0z, + const double* p1x, const double* p1y, const double* p1z, + const double* v1x, const double* v1y, const double* v1z, + double* outx, double* outy, double* outz) + { + double u = dt_target / dt_total; + double u2 = u * u; + double u3 = u2 * u; + + __m512d v_h00 = _mm512_set1_pd(2*u3 - 3*u2 + 1); + __m512d v_h10 = _mm512_set1_pd(u3 - 2*u2 + u); + __m512d v_h01 = _mm512_set1_pd(-2*u3 + 3*u2); + __m512d v_h11 = _mm512_set1_pd(u3 - u2); + + __m512d v_mult0 = _mm512_mul_pd(v_h10, _mm512_set1_pd(dt_total)); + __m512d v_mult1 = _mm512_mul_pd(v_h11, _mm512_set1_pd(dt_total)); + + #pragma omp parallel for + for (int i = 0; i < n_sat; i += 8) { + // X + __m512d vx = _mm512_mul_pd(v_h00, _mm512_loadu_pd(&p0x[i])); + vx = _mm512_fmadd_pd(v_mult0, _mm512_loadu_pd(&v0x[i]), vx); + vx = _mm512_fmadd_pd(v_h01, _mm512_loadu_pd(&p1x[i]), vx); + vx = _mm512_fmadd_pd(v_mult1, _mm512_loadu_pd(&v1x[i]), vx); + _mm512_storeu_pd(&outx[i], vx); + + // Y + __m512d vy = _mm512_mul_pd(v_h00, _mm512_loadu_pd(&p0y[i])); + vy = _mm512_fmadd_pd(v_mult0, _mm512_loadu_pd(&v0y[i]), vy); + vy = _mm512_fmadd_pd(v_h01, _mm512_loadu_pd(&p1y[i]), vy); + vy = _mm512_fmadd_pd(v_mult1, _mm512_loadu_pd(&v1y[i]), vy); + _mm512_storeu_pd(&outy[i], vy); + + // Z + __m512d vz = _mm512_mul_pd(v_h00, _mm512_loadu_pd(&p0z[i])); + vz = _mm512_fmadd_pd(v_mult0, _mm512_loadu_pd(&v0z[i]), vz); + vz = _mm512_fmadd_pd(v_h01, _mm512_loadu_pd(&p1z[i]), vz); + vz = _mm512_fmadd_pd(v_mult1, _mm512_loadu_pd(&v1z[i]), vz); + _mm512_storeu_pd(&outz[i], vz); + } + } +}; + +} // namespace libsgp4 diff --git a/libsgp4/JitPropagator.cc b/libsgp4/JitPropagator.cc new file mode 100644 index 0000000..f5f162a --- /dev/null +++ b/libsgp4/JitPropagator.cc @@ -0,0 +1,185 @@ +#include "JitPropagator.h" +#include +#include +#include +#include +#include +#include +#include + +namespace libsgp4 +{ + +JitPropagator::JitPropagator(const SGP4Batch& batch) { + std::string source = GenerateSource(batch); + CompileAndLoad(source); +} + +JitPropagator::~JitPropagator() { + if (handle_) dlclose(handle_); + if (!lib_path_.empty()) unlink(lib_path_.c_str()); +} + +std::string JitPropagator::GenerateSource(const SGP4Batch& batch) { + std::stringstream ss; + ss << "#include \n" + << "#include \n" + << "#include \n" + << "#include \"SGP4Batch.h\"\n" + << "#include \"Globals.h\"\n" + << "#include \"Eci.h\"\n" + << "#include \"Vector.h\"\n" + << "#include \"DateTime.h\"\n\n" + << "using namespace libsgp4;\n\n" + << "extern \"C\" {\n" + << "__m512d _ZGVeN8v_sin(__m512d x);\n" + << "__m512d _ZGVeN8v_cos(__m512d x);\n" + << "__m512d _ZGVeN8vv_atan2(__m512d y, __m512d x);\n" + << "}\n\n" + << "struct Vec8 {\n" + << " __m512d v;\n" + << " Vec8() : v(_mm512_setzero_pd()) {}\n" + << " Vec8(__m512d val) : v(val) {}\n" + << " Vec8(double s) : v(_mm512_set1_pd(s)) {}\n" + << " static Vec8 load(const double* p) { return _mm512_load_pd(p); }\n" + << " void store(double* p) const { _mm512_store_pd(p, v); }\n" + << " Vec8 operator+(Vec8 b) const { return _mm512_add_pd(v, b.v); }\n" + << " Vec8 operator-(Vec8 b) const { return _mm512_sub_pd(v, b.v); }\n" + << " Vec8 operator*(Vec8 b) const { return _mm512_mul_pd(v, b.v); }\n" + << " Vec8 operator/(Vec8 b) const { return _mm512_div_pd(v, b.v); }\n" + << " Vec8 fmadd(Vec8 b, Vec8 c) const { return _mm512_fmadd_pd(v, b.v, c.v); }\n" + << "};\n" + << "static inline void v_sincos_vector(Vec8 x, Vec8& s, Vec8& c) { s.v = _ZGVeN8v_sin(x.v); c.v = _ZGVeN8v_cos(x.v); }\n" + << "static inline Vec8 v_atan2_vector(Vec8 y, Vec8 x) { return Vec8(_ZGVeN8vv_atan2(y.v, x.v)); }\n" + << "static inline Vec8 v_wrap_twopi(Vec8 x) {\n" + << " alignas(64) double a[8], r[8]; x.store(a);\n" + << " for(int i=0; i<8; i++) { r[i] = fmod(a[i], kTWOPI); if(r[i] < 0) r[i] += kTWOPI; }\n" + << " return Vec8::load(r);\n" + << "}\n\n" + << "extern \"C\" void sgp4_jit_kernel(double tsince, const SGP4Batch& batch, std::vector& results) {\n" + << " const int n_pad = " << ((batch.total_satellites() + 7) & ~7) << ";\n" + << " const Vec8 v_tsince(tsince); const Vec8 v_tsq = v_tsince * v_tsince;\n" + << " const Vec8 v_tcube = v_tsq * v_tsince; const Vec8 v_tfour = v_tsince * v_tcube;\n" + << " const Vec8 v_one(1.0); const Vec8 v_zero(0.0);\n\n" + << " const double* __restrict__ p_xmdot = batch.get_xmdot(); const double* __restrict__ p_xmo = batch.get_xmo();\n" + << " const double* __restrict__ p_omgdot = batch.get_omgdot(); const double* __restrict__ p_omegao = batch.get_omegao();\n" + << " const double* __restrict__ p_xnodot = batch.get_xnodot(); const double* __restrict__ p_nodeo = batch.get_nodeo();\n" + << " const double* __restrict__ p_xnodcf = batch.get_xnodcf(); const double* __restrict__ p_c1 = batch.get_c1();\n" + << " const double* __restrict__ p_bstar = batch.get_bstar(); const double* __restrict__ p_c4 = batch.get_c4();\n" + << " const double* __restrict__ p_t2cof = batch.get_t2cof(); const double* __restrict__ p_eta = batch.get_eta();\n" + << " const double* __restrict__ p_xmcof = batch.get_xmcof(); const double* __restrict__ p_delmo = batch.get_delmo();\n" + << " const double* __restrict__ p_omgcof = batch.get_omgcof(); const double* __restrict__ p_d2 = batch.get_d2();\n" + << " const double* __restrict__ p_d3 = batch.get_d3(); const double* __restrict__ p_d4 = batch.get_d4();\n" + << " const double* __restrict__ p_c5 = batch.get_c5(); const double* __restrict__ p_sinmo = batch.get_sinmo();\n" + << " const double* __restrict__ p_t3cof = batch.get_t3cof(); const double* __restrict__ p_t4cof = batch.get_t4cof();\n" + << " const double* __restrict__ p_t5cof = batch.get_t5cof(); const double* __restrict__ p_aodp = batch.get_aodp();\n" + << " const double* __restrict__ p_ecco = batch.get_ecco(); const double* __restrict__ p_no_kozai = batch.get_no_kozai();\n" + << " const double* __restrict__ p_xlcof = batch.get_xlcof(); const double* __restrict__ p_aycof = batch.get_aycof();\n" + << " const double* __restrict__ p_x3thm1 = batch.get_x3thm1(); const double* __restrict__ p_cosio = batch.get_cosio();\n" + << " const double* __restrict__ p_inclo = batch.get_inclo(); const double* __restrict__ p_sinio = batch.get_sinio();\n" + << " const double* __restrict__ p_x1mth2 = batch.get_x1mth2(); const double* __restrict__ p_x7thm1 = batch.get_x7thm1();\n" + << " const double* __restrict__ p_active = batch.get_active();\n\n" + << " #pragma omp parallel for schedule(static)\n" + << " for (int i = 0; i < n_pad; i += 8) {\n" + << " Vec8 xmdf = Vec8::load(&p_xmdot[i]).fmadd(v_tsince, Vec8::load(&p_xmo[i]));\n" + << " Vec8 omgadf = Vec8::load(&p_omgdot[i]).fmadd(v_tsince, Vec8::load(&p_omegao[i]));\n" + << " Vec8 xnoddf = Vec8::load(&p_xnodot[i]).fmadd(v_tsince, Vec8::load(&p_nodeo[i]));\n" + << " Vec8 xnode = xnoddf + Vec8::load(&p_xnodcf[i]) * v_tsq;\n" + << " Vec8 tempa = v_one - Vec8::load(&p_c1[i]) * v_tsince;\n" + << " Vec8 tempe = Vec8::load(&p_bstar[i]) * Vec8::load(&p_c4[i]) * v_tsince;\n" + << " Vec8 templ = Vec8::load(&p_t2cof[i]) * v_tsq;\n\n" + << " Vec8 sw_xmdf, cw_xmdf; v_sincos_vector(xmdf, sw_xmdf, cw_xmdf);\n" + << " Vec8 etacos = v_one + Vec8::load(&p_eta[i]) * cw_xmdf;\n" + << " Vec8 delm = Vec8::load(&p_xmcof[i]) * (etacos * etacos * etacos - Vec8::load(&p_delmo[i]));\n" + << " Vec8 delomg = Vec8::load(&p_omgcof[i]) * v_tsince;\n" + << " Vec8 xmp = xmdf + delomg + delm; Vec8 omega = omgadf - delomg - delm;\n" + << " tempa = tempa - Vec8::load(&p_d2[i])*v_tsq - Vec8::load(&p_d3[i])*v_tcube - Vec8::load(&p_d4[i])*v_tfour;\n" + << " Vec8 sw_xmp, cw_xmp; v_sincos_vector(xmp, sw_xmp, cw_xmp);\n" + << " tempe = tempe + Vec8::load(&p_bstar[i]) * Vec8::load(&p_c5[i]) * (sw_xmp - Vec8::load(&p_sinmo[i]));\n" + << " templ = templ + Vec8::load(&p_t3cof[i])*v_tcube + v_tfour * Vec8::load(&p_t5cof[i]).fmadd(v_tsince, Vec8::load(&p_t4cof[i]));\n\n" + << " Vec8 a = Vec8::load(&p_aodp[i]) * tempa * tempa;\n" + << " Vec8 e = Vec8::load(&p_ecco[i]) - tempe;\n" + << " e.v = _mm512_max_pd(e.v, _mm512_set1_pd(1e-6)); e.v = _mm512_min_pd(e.v, _mm512_set1_pd(1.0 - 1e-6));\n" + << " Vec8 xl = xmp + omega + xnode + Vec8::load(&p_no_kozai[i]) * templ;\n\n" + << " Vec8 beta2 = v_one - e * e; Vec8 sw_om, cw_om; v_sincos_vector(omega, sw_om, cw_om);\n" + << " Vec8 axn = e * cw_om; Vec8 temp11 = v_one / (a * beta2);\n" + << " Vec8 xlt = xl + temp11 * Vec8::load(&p_xlcof[i]) * axn;\n" + << " Vec8 ayn = e * sw_om + temp11 * Vec8::load(&p_aycof[i]);\n" + << " Vec8 capu = v_wrap_twopi(xlt - xnode); Vec8 epw = capu; Vec8 sinepw, cosepw, ecose, esine;\n" + << " for(int j=0; j<3; j++) {\n" + << " v_sincos_vector(epw, sinepw, cosepw);\n" + << " ecose = axn * cosepw + ayn * sinepw; esine = axn * sinepw - ayn * cosepw;\n" + << " epw = epw + (capu - epw + esine) / (v_one - ecose + Vec8(0.5) * esine * ((capu - epw + esine) / (v_one - ecose)));\n" + << " }\n" + << " v_sincos_vector(epw, sinepw, cosepw); ecose = axn * cosepw + ayn * sinepw; esine = axn * sinepw - ayn * cosepw;\n" + << " Vec8 r = a * (v_one - ecose); Vec8 temp31 = v_one / r;\n" + << " Vec8 rdot = Vec8(kXKE) * _mm512_sqrt_pd(a.v) * esine * temp31;\n" + << " Vec8 rfdot = Vec8(kXKE) * _mm512_sqrt_pd((a * (v_one - axn*axn - ayn*ayn)).v) * temp31;\n" + << " Vec8 cosu_un = a * temp31 * (cosepw - axn + ayn * esine * (v_one / (v_one + _mm512_sqrt_pd((v_one - axn*axn - ayn*ayn).v))));\n" + << " Vec8 sinu_un = a * temp31 * (sinepw - ayn - axn * esine * (v_one / (v_one + _mm512_sqrt_pd((v_one - axn*axn - ayn*ayn).v))));\n" + << " Vec8 u = v_atan2_vector(sinu_un, cosu_un);\n" + << " Vec8 sin2u = Vec8(2.0) * sinu_un * cosu_un; Vec8 cos2u = Vec8(2.0) * cosu_un * cosu_un - v_one;\n" + << " Vec8 t41 = v_one / (a * (v_one - axn*axn - ayn*ayn)); Vec8 t42 = Vec8(kCK2) * t41; Vec8 t43 = t42 * t41;\n" + << " Vec8 rk = r * (v_one - Vec8(1.5) * t43 * _mm512_sqrt_pd((v_one - axn*axn - ayn*ayn).v) * Vec8::load(&p_x3thm1[i])) + Vec8(0.5) * t42 * Vec8::load(&p_x1mth2[i]) * cos2u;\n" + << " Vec8 uk = u - Vec8(0.25) * t43 * Vec8::load(&p_x7thm1[i]) * sin2u;\n" + << " Vec8 xnodek = xnode + Vec8(1.5) * t43 * Vec8::load(&p_cosio[i]) * sin2u;\n" + << " Vec8 xinck = Vec8::load(&p_inclo[i]) + Vec8(1.5) * t43 * Vec8::load(&p_cosio[i]) * Vec8::load(&p_sinio[i]) * cos2u;\n" + << " Vec8 rdotk = rdot - Vec8(kXKE) / (a * _mm512_sqrt_pd(a.v)) * t42 * Vec8::load(&p_x1mth2[i]) * sin2u;\n" + << " Vec8 rfdotk = rfdot + Vec8(kXKE) / (a * _mm512_sqrt_pd(a.v)) * t42 * (Vec8::load(&p_x1mth2[i]) * cos2u + Vec8(1.5) * Vec8::load(&p_x3thm1[i]));\n" + << " Vec8 snuk, csuk, snik, csik, snnk, csnk;\n" + << " v_sincos_vector(uk, snuk, csuk); v_sincos_vector(xinck, snik, csik); v_sincos_vector(xnodek, snnk, csnk);\n" + << " Vec8 xmx = (v_zero - snnk) * csik; Vec8 xmy = csnk * csik;\n" + << " Vec8 ux = xmx * snuk + csnk * csuk; Vec8 uy = xmy * snuk + snnk * csuk; Vec8 uz = snik * snuk;\n" + << " Vec8 vx = xmx * csuk - csnk * snuk; Vec8 vy = xmy * csuk - snnk * snuk; Vec8 vz = snik * csuk;\n" + << " alignas(64) double a_rk[8], a_ux[8], a_uy[8], a_uz[8], a_rdotk[8], a_rfdotk[8], a_vx[8], a_vy[8], a_vz[8];\n" + << " rk.store(a_rk); ux.store(a_ux); uy.store(a_uy); uz.store(a_uz); rdotk.store(a_rdotk); rfdotk.store(a_rfdotk); vx.store(a_vx); vy.store(a_vy); vz.store(a_vz);\n" + << " for (int s = 0; s < 8; s++) {\n" + << " int idx = i + s; if (idx >= " << batch.total_satellites() << ") break;\n" + << " if (p_active[idx] == 0.0) continue;\n" + << " results[idx] = Eci(batch.get_epochs()[idx].AddMinutes(tsince), Vector(a_rk[s] * a_ux[s] * kXKMPER, a_rk[s] * a_uy[s] * kXKMPER, a_rk[s] * a_uz[s] * kXKMPER),\n" + << " Vector((a_rdotk[s] * a_ux[s] + a_rfdotk[s] * a_vx[s]) * kXKMPER / 60.0, (a_rdotk[s] * a_uy[s] + a_rfdotk[s] * a_vy[s]) * kXKMPER / 60.0, (a_rdotk[s] * a_uz[s] + a_rfdotk[s] * a_vz[s]) * kXKMPER / 60.0));\n" + << " }\n" + << " }\n" + << "}\n"; + return ss.str(); +} + +void JitPropagator::CompileAndLoad(const std::string& source) { + char tmp_cc[] = "/tmp/sgp4_jit_XXXXXX.cc"; + int fd = mkstemps(tmp_cc, 3); + if (fd == -1) return; + close(fd); + + std::ofstream ofs(tmp_cc); + ofs << source; + ofs.close(); + + char tmp_so[] = "/tmp/sgp4_jit_XXXXXX.so"; + int fd_so = mkstemps(tmp_so, 3); + if (fd_so == -1) return; + close(fd_so); + + std::string cmd = "g++ -O3 -ffast-math -march=native -fopenmp -shared -fPIC -I. -I/home/troyrock/fastSGP4/libsgp4 " + std::string(tmp_cc) + " -o " + std::string(tmp_so) + " -lm"; + if (system(cmd.c_str()) != 0) { + std::cerr << "JIT Compilation Failed" << std::endl; + return; + } + + handle_ = dlopen(tmp_so, RTLD_NOW); + if (!handle_) { + std::cerr << "dlopen failed: " << dlerror() << std::endl; + return; + } + + kernel_func_ = (KernelFunc)dlsym(handle_, "sgp4_jit_kernel"); + lib_path_ = tmp_so; + unlink(tmp_cc); +} + +void JitPropagator::Propagate(double tsince, const SGP4Batch& batch, std::vector& results) { + if (kernel_func_) { + kernel_func_(tsince, batch, results); + } +} + +} // namespace libsgp4 diff --git a/libsgp4/JitPropagator.h b/libsgp4/JitPropagator.h new file mode 100644 index 0000000..60b9b59 --- /dev/null +++ b/libsgp4/JitPropagator.h @@ -0,0 +1,42 @@ +#pragma once + +#include "SGP4Batch.h" +#include +#include +#include +#include + +namespace libsgp4 +{ + +/** + * @brief JitPropagator - Runtime specialized kernel generator for SGP4Batch. + */ +class JitPropagator +{ +public: + using KernelFunc = void(*)(double tsince, const SGP4Batch& batch, std::vector& results); + + JitPropagator(const SGP4Batch& batch); + ~JitPropagator(); + + /** + * @brief Propagate using the JIT-compiled specialized kernel. + */ + void Propagate(double tsince, const SGP4Batch& batch, std::vector& results); + + /** + * @brief Check if a specialized kernel is currently loaded and ready. + */ + bool IsReady() const { return kernel_func_ != nullptr; } + +private: + std::string GenerateSource(const SGP4Batch& batch); + void CompileAndLoad(const std::string& source); + + void* handle_ = nullptr; + KernelFunc kernel_func_ = nullptr; + std::string lib_path_; +}; + +} // namespace libsgp4 diff --git a/libsgp4/LinearBVH.cc b/libsgp4/LinearBVH.cc new file mode 100644 index 0000000..d770da6 --- /dev/null +++ b/libsgp4/LinearBVH.cc @@ -0,0 +1,112 @@ +#include "LinearBVH.h" +#include +#include +#include +#include + +namespace libsgp4 +{ + +uint32_t LinearBVH::GenerateMorton(float x, float y, float z) { + // Normalize to [0, 1023] + uint32_t ux = (uint32_t)std::max(0.0f, std::min(1023.0f, (x + 15000.0f) * (1023.0f / 30000.0f))); + uint32_t uy = (uint32_t)std::max(0.0f, std::min(1023.0f, (y + 15000.0f) * (1023.0f / 30000.0f))); + uint32_t uz = (uint32_t)std::max(0.0f, std::min(1023.0f, (z + 15000.0f) * (1023.0f / 30000.0f))); + return (ExpandBits(ux) << 2) | (ExpandBits(uy) << 1) | ExpandBits(uz); +} + +void LinearBVH::Build(const std::vector& objects) { + if (objects.empty()) return; + int n = static_cast(objects.size()); + sorted_objects_ = objects; + + // 1. Sort by Morton Code + std::sort(sorted_objects_.begin(), sorted_objects_.end(), [](const Object& a, const Object& b){ + return a.morton < b.morton; + }); + + // 2. Build Hierarchy + nodes_.assign(2 * n - 1, Node()); + + std::function find_split = [&](int first, int last) { + uint32_t first_code = sorted_objects_[static_cast(first)].morton; + uint32_t last_code = sorted_objects_[static_cast(last)].morton; + if (first_code == last_code) return (first + last) >> 1; + + int common_prefix = __builtin_clz(first_code ^ last_code); + int split = first; + int step = last - first; + do { + step = (step + 1) >> 1; + int new_split = split + step; + if (new_split < last) { + int split_prefix = __builtin_clz(first_code ^ sorted_objects_[static_cast(new_split)].morton); + if (split_prefix > common_prefix) split = new_split; + } + } while (step > 1); + return split; + }; + + std::function build_recursive = [&](int first, int last) { + if (first == last) { + int idx = n - 1 + first; + nodes_[static_cast(idx)].left_idx = ~first; + nodes_[static_cast(idx)].min_x = sorted_objects_[static_cast(first)].x; + nodes_[static_cast(idx)].max_x = sorted_objects_[static_cast(first)].x; + nodes_[static_cast(idx)].min_y = sorted_objects_[static_cast(first)].y; + nodes_[static_cast(idx)].max_y = sorted_objects_[static_cast(first)].y; + nodes_[static_cast(idx)].min_z = sorted_objects_[static_cast(first)].z; + nodes_[static_cast(idx)].max_z = sorted_objects_[static_cast(first)].z; + return idx; + } + + int split = find_split(first, last); + int left = build_recursive(first, split); + int right = build_recursive(split + 1, last); + + int idx = first; + nodes_[static_cast(idx)].left_idx = left; + nodes_[static_cast(idx)].right_idx = right; + nodes_[static_cast(idx)].min_x = std::min(nodes_[static_cast(left)].min_x, nodes_[static_cast(right)].min_x); + nodes_[static_cast(idx)].max_x = std::max(nodes_[static_cast(left)].max_x, nodes_[static_cast(right)].max_x); + nodes_[static_cast(idx)].min_y = std::min(nodes_[static_cast(left)].min_y, nodes_[static_cast(right)].min_y); + nodes_[static_cast(idx)].max_y = std::max(nodes_[static_cast(left)].max_y, nodes_[static_cast(right)].max_y); + nodes_[static_cast(idx)].min_z = std::min(nodes_[static_cast(left)].min_z, nodes_[static_cast(right)].min_z); + nodes_[static_cast(idx)].max_z = std::max(nodes_[static_cast(left)].max_z, nodes_[static_cast(right)].max_z); + return idx; + }; + + build_recursive(0, n - 1); +} + +void LinearBVH::Query(const Vector& center, double radius, std::vector& results) const { + if (nodes_.empty()) return; + + float cx = (float)center.x, cy = (float)center.y, cz = (float)center.z; + float r2 = (float)(radius * radius); + + int stack[64]; + int top = 0; + stack[top++] = 0; + + while (top > 0) { + int idx = stack[--top]; + const Node& node = nodes_[static_cast(idx)]; + + float dx = std::max(0.0f, std::max(node.min_x - cx, cx - node.max_x)); + float dy = std::max(0.0f, std::max(node.min_y - cy, cy - node.max_y)); + float dz = std::max(0.0f, std::max(node.min_z - cz, cz - node.max_z)); + + if (dx*dx + dy*dy + dz*dz > r2) continue; + + if (node.left_idx < 0) { + int obj_idx = ~node.left_idx; + results.push_back(sorted_objects_[static_cast(obj_idx)].id); + } else { + stack[top++] = node.right_idx; + stack[top++] = node.left_idx; + } + } +} + +} // namespace libsgp4 diff --git a/libsgp4/LinearBVH.h b/libsgp4/LinearBVH.h new file mode 100644 index 0000000..80af0e6 --- /dev/null +++ b/libsgp4/LinearBVH.h @@ -0,0 +1,67 @@ +#pragma once + +#include +#include +#include +#include +#include "Vector.h" + +namespace libsgp4 +{ + +/** + * @brief LinearBVH - High-performance vectorized Bounding Volume Hierarchy. + * Built on Morton Codes (Z-Order Curve) for O(N log N) build and O(log N) query. + */ +class LinearBVH +{ +public: + struct alignas(64) Node { + float min_x, min_y, min_z, pad1; + float max_x, max_y, max_z, pad2; + int left_idx; // If < 0, it's a leaf. Index to objects is ~left_idx + int right_idx; // If leaf, this is count or unused. + int parent_idx; + int pad3; + }; + + struct Object { + int id; + float x, y, z; + uint32_t morton; + }; + + /** + * @brief Build the LBVH from a set of points. + */ + void Build(const std::vector& objects); + + /** + * @brief Vectorized query: Find all objects within radius of center. + */ + void Query(const Vector& center, double radius, std::vector& results) const; + + static uint32_t GenerateMorton(float x, float y, float z); + +private: + std::vector nodes_; + std::vector sorted_objects_; + + static uint32_t ExpandBits(uint32_t v) { + v = (v * 0x00010001u) & 0xFF0000FFu; + v = (v * 0x00000101u) & 0x0F00F00Fu; + v = (v * 0x00000011u) & 0xC30C30C3u; + v = (v * 0x00000005u) & 0x49249249u; + return v; + } + + int LongestCommonPrefix(int i, int j) const { + if (j < 0 || j >= (int)sorted_objects_.size()) return -1; + uint32_t a = sorted_objects_[i].morton; + uint32_t b = sorted_objects_[j].morton; + if (a == b) return 32 + __builtin_clz((uint32_t)(i ^ j)); + return __builtin_clz(a ^ b); + } +}; + +} // namespace libsgp4 diff --git a/libsgp4/SGP4.cc b/libsgp4/SGP4.cc index d590957..1e149e6 100644 --- a/libsgp4/SGP4.cc +++ b/libsgp4/SGP4.cc @@ -39,6 +39,11 @@ void SGP4::SetTle(const Tle& tle) Initialise(); } +void SGP4::SetAlongTrackBias(double bias_rad) +{ + drift_rad_min_day = bias_rad; +} + void SGP4::Initialise() { /* @@ -102,11 +107,13 @@ void SGP4::Initialise() if (elements_.Perigee() < 156.0) { s4 = elements_.Perigee() - 78.0; - if (elements_.Perigee() < 98.0) + if (elements_.Perigee() < 98.0) { s4 = 20.0; } - qoms24 = pow((120.0 - s4) * kAE / kXKMPER, 4.0); + const double q_base = (120.0 - s4) * kAE / kXKMPER; + const double q_base2 = q_base * q_base; + qoms24 = q_base2 * q_base2; s4 = s4 / kXKMPER + kAE; } @@ -123,8 +130,9 @@ void SGP4::Initialise() const double etasq = common_consts_.eta * common_consts_.eta; const double eeta = elements_.Eccentricity() * common_consts_.eta; const double psisq = fabs(1.0 - etasq); - const double coef = qoms24 * pow(tsi, 4.0); - const double coef1 = coef / pow(psisq, 3.5); + const double tsi2 = tsi * tsi; + const double coef = qoms24 * tsi2 * tsi2; + const double coef1 = coef / (psisq * psisq * psisq * sqrt(psisq)); const double c2 = coef1 * elements_.RecoveredMeanMotion() * (elements_.RecoveredSemiMajorAxis() * (1.0 + 1.5 * etasq + eeta * (4.0 + etasq)) @@ -190,7 +198,8 @@ void SGP4::Initialise() nearspace_consts_.xmcof = -kTWOTHIRD * coef * elements_.BStar() * kAE / eeta; } - nearspace_consts_.delmo = pow(1.0 + common_consts_.eta * (cos(elements_.MeanAnomoly())), 3.0); + const double etacos0 = 1.0 + common_consts_.eta * (cos(elements_.MeanAnomoly())); + nearspace_consts_.delmo = etacos0 * etacos0 * etacos0; nearspace_consts_.sinmo = sin(elements_.MeanAnomoly()); if (!use_simple_model_) @@ -277,7 +286,9 @@ Eci SGP4::FindPositionSDP4(double tsince) const throw SatelliteException("Error: (xn <= 0.0)"); } - a = pow(kXKE / xn, kTWOTHIRD) * tempa * tempa; + const double xn_recip = kXKE / xn; + const double xn_recip_sq = xn_recip * xn_recip; + a = cbrt(xn_recip_sq) * tempa * tempa; e = em - tempe; double xmam = xmdf + elements_.RecoveredMeanMotion() * templ; @@ -415,14 +426,17 @@ Eci SGP4::FindPositionSGP4(double tsince) const const double tsq = tsince * tsince; xnode = xnoddf + common_consts_.xnodcf * tsq; double tempa = 1.0 - common_consts_.c1 * tsince; - double tempe = elements_.BStar() * common_consts_.c4 * tsince; + const double bstar = use_bstar_override ? bstar_override : elements_.BStar(); + double tempe = bstar * common_consts_.c4 * tsince; double templ = common_consts_.t2cof * tsq; + xl = xmdf + omgadf + xnoddf; if (!use_simple_model_) { const double delomg = nearspace_consts_.omgcof * tsince; + const double etacos = 1.0 + common_consts_.eta * cos(xmdf); const double delm = nearspace_consts_.xmcof - * (pow(1.0 + common_consts_.eta * cos(xmdf), 3.0) + * (etacos * etacos * etacos - nearspace_consts_.delmo); const double temp = delomg + delm; @@ -434,7 +448,7 @@ Eci SGP4::FindPositionSGP4(double tsince) const tempa = tempa - nearspace_consts_.d2 * tsq - nearspace_consts_.d3 * tcube - nearspace_consts_.d4 * tfour; - tempe += elements_.BStar() * nearspace_consts_.c5 + tempe += bstar * nearspace_consts_.c5 * (sin(xmp) - nearspace_consts_.sinmo); templ += nearspace_consts_.t3cof * tcube + tfour * (nearspace_consts_.t4cof + tsince * nearspace_consts_.t5cof); @@ -442,7 +456,10 @@ Eci SGP4::FindPositionSGP4(double tsince) const a = elements_.RecoveredSemiMajorAxis() * tempa * tempa; e = elements_.Eccentricity() - tempe; - xl = xmp + omega + xnode + elements_.RecoveredMeanMotion() * templ; + const double tsince_days = tsince / 1440.0; + const double corr_rad = 0.5 * drift_rad_min_day * tsince_days * tsince; + xl = xmdf + omgadf + xnode + elements_.RecoveredMeanMotion() * templ; + xl += corr_rad; /* * fix tolerance for error recognition @@ -497,7 +514,7 @@ Eci SGP4::CalculateFinalPositionVelocity( const double sinio) { const double beta2 = 1.0 - e * e; - const double xn = kXKE / pow(a, 1.5); + const double xn = kXKE / (a * sqrt(a)); /* * long period periodics */ @@ -535,12 +552,10 @@ Eci SGP4::CalculateFinalPositionVelocity( */ const double max_newton_naphson = 1.25 * fabs(sqrt(elsq)); - bool kepler_running = true; - - for (int i = 0; i < 10 && kepler_running; i++) + #pragma GCC unroll 10 + for (int i = 0; i < 10; i++) { - sinepw = sin(epw); - cosepw = cos(epw); + __builtin_sincos(epw, &sinepw, &cosepw); ecose = axn * cosepw + ayn * sinepw; esine = axn * sinepw - ayn * cosepw; @@ -548,7 +563,7 @@ Eci SGP4::CalculateFinalPositionVelocity( if (fabs(f) < 1.0e-12) { - kepler_running = false; + break; } else { @@ -602,11 +617,11 @@ Eci SGP4::CalculateFinalPositionVelocity( const double temp32 = a * temp31; const double betal = sqrt(temp21); const double temp33 = 1.0 / (1.0 + betal); - const double cosu = temp32 * (cosepw - axn + ayn * esine * temp33); - const double sinu = temp32 * (sinepw - ayn - axn * esine * temp33); - const double u = atan2(sinu, cosu); - const double sin2u = 2.0 * sinu * cosu; - const double cos2u = 2.0 * cosu * cosu - 1.0; + const double cosu_unorm = temp32 * (cosepw - axn + ayn * esine * temp33); + const double sinu_unorm = temp32 * (sinepw - ayn - axn * esine * temp33); + const double u = atan2(sinu_unorm, cosu_unorm); + const double sin2u = 2.0 * sinu_unorm * cosu_unorm; + const double cos2u = 2.0 * cosu_unorm * cosu_unorm - 1.0; /* * update for short periodics @@ -626,12 +641,12 @@ Eci SGP4::CalculateFinalPositionVelocity( /* * orientation vectors */ - const double sinuk = sin(uk); - const double cosuk = cos(uk); - const double sinik = sin(xinck); - const double cosik = cos(xinck); - const double sinnok = sin(xnodek); - const double cosnok = cos(xnodek); + double sinuk, cosuk; + __builtin_sincos(uk, &sinuk, &cosuk); + double sinik, cosik; + __builtin_sincos(xinck, &sinik, &cosik); + double sinnok, cosnok; + __builtin_sincos(xnodek, &sinnok, &cosnok); const double xmx = -sinnok * cosik; const double xmy = cosnok * cosik; const double ux = xmx * sinuk + cosnok * cosuk; @@ -788,7 +803,7 @@ void SGP4::DeepSpaceInitialise( const double z11 = -6.0 * a1 * a5 + eosq * (-24. * x1 * x7 - 6. * x3 * x5); - const double z12 = -6.0 * (a1 * a6 + a3 * a5) + const double z12 = -6.0 * (a1 * a6 + a3 * a5) + eosq * (-24. * (x2 * x7 + x1 * x8) - 6. * (x3 * x6 + x4 * x5)); const double z13 = -6.0 * a3 * a6 + eosq * (-24. * x2 * x8 - 6. * x4 * x6); @@ -1101,10 +1116,12 @@ void SGP4::DeepSpacePeriodics( // calculate solar terms for time tsince double zm = ds_constants.zmos + ZNS * tsince; - double zf = zm + 2.0 * ZES * sin(zm); - double sinzf = sin(zf); + double sinzm = sin(zm); + double zf = zm + 2.0 * ZES * sinzm; + double sinzf, coszf; + __builtin_sincos(zf, &sinzf, &coszf); double f2 = 0.5 * sinzf * sinzf - 0.25; - double f3 = -0.5 * sinzf * cos(zf); + double f3 = -0.5 * sinzf * coszf; const double ses = ds_constants.se2 * f2 + ds_constants.se3 * f3; @@ -1121,10 +1138,11 @@ void SGP4::DeepSpacePeriodics( // calculate lunar terms for time tsince zm = ds_constants.zmol + ZNL * tsince; - zf = zm + 2.0 * ZEL * sin(zm); - sinzf = sin(zf); + sinzm = sin(zm); + zf = zm + 2.0 * ZEL * sinzm; + __builtin_sincos(zf, &sinzf, &coszf); f2 = 0.5 * sinzf * sinzf - 0.25; - f3 = -0.5 * sinzf * cos(zf); + f3 = -0.5 * sinzf * coszf; const double sel = ds_constants.ee2 * f2 + ds_constants.e3 * f3; @@ -1247,7 +1265,7 @@ void SGP4::DeepSpaceSecular( * 1st condition (if tsince is less than one time step from epoch) * 2nd condition (if atime and * tsince are of opposite signs, so zero crossing required) - * 3rd condition (if tsince is closer to zero than + * 3rd condition (if tsince is closer to zero than * atime, only integrate away from zero) */ if (fabs(tsince) < STEP || @@ -1269,12 +1287,18 @@ void SGP4::DeepSpaceSecular( // from the start of the range which is 'atime' if (ds_constants.shape == DeepSpaceConstants::SYNCHRONOUS) { - xndot = ds_constants.del1 * sin(integ_params.xli - FASX2) - + ds_constants.del2 * sin(2.0 * (integ_params.xli - FASX4)) - + ds_constants.del3 * sin(3.0 * (integ_params.xli - FASX6)); - xnddt = ds_constants.del1 * cos(integ_params.xli - FASX2) - + 2.0 * ds_constants.del2 * cos(2.0 * (integ_params.xli - FASX4)) - + 3.0 * ds_constants.del3 * cos(3.0 * (integ_params.xli - FASX6)); + double sinxli, cosxli; + __builtin_sincos(integ_params.xli - FASX2, &sinxli, &cosxli); + xndot = ds_constants.del1 * sinxli; + xnddt = ds_constants.del1 * cosxli; + + __builtin_sincos(2.0 * (integ_params.xli - FASX4), &sinxli, &cosxli); + xndot += ds_constants.del2 * sinxli; + xnddt += 2.0 * ds_constants.del2 * cosxli; + + __builtin_sincos(3.0 * (integ_params.xli - FASX6), &sinxli, &cosxli); + xndot += ds_constants.del3 * sinxli; + xnddt += 3.0 * ds_constants.del3 * cosxli; } else { @@ -1282,26 +1306,41 @@ void SGP4::DeepSpaceSecular( const double xomi = elements.ArgumentPerigee() + c_constants.omgdot * integ_params.atime; const double x2omi = xomi + xomi; const double x2li = integ_params.xli + integ_params.xli; - xndot = ds_constants.d2201 * sin(x2omi + integ_params.xli - G22) - + ds_constants.d2211 * sin(integ_params.xli - G22) - + ds_constants.d3210 * sin(xomi + integ_params.xli - G32) - + ds_constants.d3222 * sin(-xomi + integ_params.xli - G32) - + ds_constants.d4410 * sin(x2omi + x2li - G44) - + ds_constants.d4422 * sin(x2li - G44) - + ds_constants.d5220 * sin(xomi + integ_params.xli - G52) - + ds_constants.d5232 * sin(-xomi + integ_params.xli - G52) - + ds_constants.d5421 * sin(xomi + x2li - G54) - + ds_constants.d5433 * sin(-xomi + x2li - G54); - xnddt = ds_constants.d2201 * cos(x2omi + integ_params.xli - G22) - + ds_constants.d2211 * cos(integ_params.xli - G22) - + ds_constants.d3210 * cos(xomi + integ_params.xli - G32) - + ds_constants.d3222 * cos(-xomi + integ_params.xli - G32) - + ds_constants.d5220 * cos(xomi + integ_params.xli - G52) - + ds_constants.d5232 * cos(-xomi + integ_params.xli - G52) - + 2.0 * (ds_constants.d4410 * cos(x2omi + x2li - G44) - + ds_constants.d4422 * cos(x2li - G44) - + ds_constants.d5421 * cos(xomi + x2li - G54) - + ds_constants.d5433 * cos(-xomi + x2li - G54)); + + double s1, c1, s2, c2, s3, c3, s4, c4, s5, c5; + __builtin_sincos(x2omi + integ_params.xli - G22, &s1, &c1); + __builtin_sincos(integ_params.xli - G22, &s2, &c2); + __builtin_sincos(xomi + integ_params.xli - G32, &s3, &c3); + __builtin_sincos(-xomi + integ_params.xli - G32, &s4, &c4); + __builtin_sincos(x2omi + x2li - G44, &s5, &c5); + + xndot = ds_constants.d2201 * s1 + + ds_constants.d2211 * s2 + + ds_constants.d3210 * s3 + + ds_constants.d3222 * s4 + + ds_constants.d4410 * s5; + xnddt = ds_constants.d2201 * c1 + + ds_constants.d2211 * c2 + + ds_constants.d3210 * c3 + + ds_constants.d3222 * c4 + + 2.0 * ds_constants.d4410 * c5; + + __builtin_sincos(x2li - G44, &s1, &c1); + __builtin_sincos(xomi + integ_params.xli - G52, &s2, &c2); + __builtin_sincos(-xomi + integ_params.xli - G52, &s3, &c3); + __builtin_sincos(xomi + x2li - G54, &s4, &c4); + __builtin_sincos(-xomi + x2li - G54, &s5, &c5); + + xndot += ds_constants.d4422 * s1 + + ds_constants.d5220 * s2 + + ds_constants.d5232 * s3 + + ds_constants.d5421 * s4 + + ds_constants.d5433 * s5; + xnddt += 2.0 * ds_constants.d4422 * c1 + + ds_constants.d5220 * c2 + + ds_constants.d5232 * c3 + + 2.0 * (ds_constants.d5421 * c4 + + ds_constants.d5433 * c5); } xldot = integ_params.xni + ds_constants.xfact; xnddt *= xldot; diff --git a/libsgp4/SGP4.h b/libsgp4/SGP4.h index e67aa1f..4156210 100644 --- a/libsgp4/SGP4.h +++ b/libsgp4/SGP4.h @@ -39,16 +39,17 @@ class SGP4 { public: explicit SGP4(const Tle& tle) - : elements_(tle) + : elements_(tle), drift_rad_min_day(0.0), bstar_override(0.0), use_bstar_override(false) { Initialise(); } void SetTle(const Tle& tle); + void SetAlongTrackBias(double bias_rad); Eci FindPosition(double tsince) const; Eci FindPosition(const DateTime& date) const; -private: +public: struct CommonConstants { double cosio; @@ -249,12 +250,17 @@ class SGP4 * the orbit data */ OrbitalElements elements_; + double drift_rad_min_day; + double bstar_override; + bool use_bstar_override; /* * flags */ bool use_simple_model_; bool use_deep_space_; + + friend class SGP4Batch; }; } // namespace libsgp4 diff --git a/libsgp4/SGP4Batch.cc b/libsgp4/SGP4Batch.cc new file mode 100644 index 0000000..3026f0d --- /dev/null +++ b/libsgp4/SGP4Batch.cc @@ -0,0 +1,662 @@ +#include "SGP4Batch.h" +#include "SGP4.h" +#include "Globals.h" +#include "Util.h" +#include +#include +#include +#include +#include +#include + +// Try to use SLEEF for vectorized math +#include + +#ifndef M_PI +#define M_PI 3.14159265358979323846 +#endif + +extern "C" void sincos(double x, double* s, double* c); + +namespace libsgp4 +{ +// Vec8: unified vector type with AVX-512, AVX2 and scalar fallbacks +#ifdef __AVX512F__ +struct alignas(64) Vec8 { + __m512d v; + Vec8() : v(_mm512_setzero_pd()) {} + Vec8(__m512d val) : v(val) {} + Vec8(double s) : v(_mm512_set1_pd(s)) {} + static Vec8 load(const double* p) { return Vec8(_mm512_load_pd(p)); } + void store(double* p) const { _mm512_store_pd(p, v); } + Vec8 operator+(const Vec8& b) const { return Vec8(_mm512_add_pd(v, b.v)); } + Vec8 operator-(const Vec8& b) const { return Vec8(_mm512_sub_pd(v, b.v)); } + Vec8 operator*(const Vec8& b) const { return Vec8(_mm512_mul_pd(v, b.v)); } + Vec8 operator/(const Vec8& b) const { return Vec8(_mm512_div_pd(v, b.v)); } + Vec8 fmadd(const Vec8& b, const Vec8& c) const { return Vec8(_mm512_fmadd_pd(v, b.v, c.v)); } + Vec8 sqrt() const { return Vec8(_mm512_sqrt_pd(v)); } + Vec8 abs() const { return Vec8(_mm512_abs_pd(v)); } + static Vec8 mask_blend(uint8_t mask, const Vec8& a, const Vec8& b) { return Vec8(_mm512_mask_blend_pd(mask, a.v, b.v)); } + static Vec8 max(const Vec8& a, const Vec8& b) { return Vec8(_mm512_max_pd(a.v, b.v)); } + static Vec8 min(const Vec8& a, const Vec8& b) { return Vec8(_mm512_min_pd(a.v, b.v)); } +}; +#elif defined(__AVX2__) +struct alignas(32) Vec8 { + __m256d lo, hi; + Vec8() : lo(_mm256_setzero_pd()), hi(_mm256_setzero_pd()) {} + Vec8(__m256d l, __m256d h) : lo(l), hi(h) {} + Vec8(double s) : lo(_mm256_set1_pd(s)), hi(_mm256_set1_pd(s)) {} + static Vec8 load(const double* p) { return Vec8(_mm256_loadu_pd(p), _mm256_loadu_pd(p + 4)); } + void store(double* p) const { _mm256_storeu_pd(p, lo); _mm256_storeu_pd(p + 4, hi); } + Vec8 operator+(const Vec8& b) const { return Vec8(_mm256_add_pd(lo, b.lo), _mm256_add_pd(hi, b.hi)); } + Vec8 operator-(const Vec8& b) const { return Vec8(_mm256_sub_pd(lo, b.lo), _mm256_sub_pd(hi, b.hi)); } + Vec8 operator*(const Vec8& b) const { return Vec8(_mm256_mul_pd(lo, b.lo), _mm256_mul_pd(hi, b.hi)); } + Vec8 operator/(const Vec8& b) const { return Vec8(_mm256_div_pd(lo, b.lo), _mm256_div_pd(hi, b.hi)); } + Vec8 fmadd(const Vec8& b, const Vec8& c) const { +#ifdef __FMA__ + return Vec8(_mm256_fmadd_pd(lo, b.lo, c.lo), _mm256_fmadd_pd(hi, b.hi, c.hi)); +#else + return Vec8(_mm256_add_pd(_mm256_mul_pd(lo, b.lo), c.lo), _mm256_add_pd(_mm256_mul_pd(hi, b.hi), c.hi)); +#endif + } + Vec8 sqrt() const { return Vec8(_mm256_sqrt_pd(lo), _mm256_sqrt_pd(hi)); } + Vec8 abs() const { + const __m256d sign_mask = _mm256_castsi256_pd(_mm256_set1_epi64x(0x7fffffffffffffffLL)); + return Vec8(_mm256_and_pd(lo, sign_mask), _mm256_and_pd(hi, sign_mask)); + } + static Vec8 mask_blend(uint8_t mask, const Vec8& a, const Vec8& b) { + int m0 = mask & 0xF; + int m1 = (mask >> 4) & 0xF; + __m256d mvec0 = _mm256_set_pd((m0 & 8) ? -0.0 : 0.0, (m0 & 4) ? -0.0 : 0.0, (m0 & 2) ? -0.0 : 0.0, (m0 & 1) ? -0.0 : 0.0); + __m256d mvec1 = _mm256_set_pd((m1 & 8) ? -0.0 : 0.0, (m1 & 4) ? -0.0 : 0.0, (m1 & 2) ? -0.0 : 0.0, (m1 & 1) ? -0.0 : 0.0); + __m256d lo = _mm256_blendv_pd(a.lo, b.lo, mvec0); + __m256d hi = _mm256_blendv_pd(a.hi, b.hi, mvec1); + return Vec8(lo, hi); + } + static Vec8 max(const Vec8& a, const Vec8& b) { return Vec8(_mm256_max_pd(a.lo, b.lo), _mm256_max_pd(a.hi, b.hi)); } + static Vec8 min(const Vec8& a, const Vec8& b) { return Vec8(_mm256_min_pd(a.lo, b.lo), _mm256_min_pd(a.hi, b.hi)); } +}; +#else +struct Vec8 { + double v[8]; + Vec8() { memset(v, 0, sizeof(v)); } + Vec8(double s) { for(int i=0; i<8; i++) v[i] = s; } + static Vec8 load(const double* p) { Vec8 r; memcpy(r.v, p, sizeof(r.v)); return r; } + void store(double* p) const { memcpy(p, v, sizeof(v)); } + Vec8 operator+(const Vec8& b) const { Vec8 r; for(int i=0; i<8; i++) r.v[i] = v[i] + b.v[i]; return r; } + Vec8 operator-(const Vec8& b) const { Vec8 r; for(int i=0; i<8; i++) r.v[i] = v[i] - b.v[i]; return r; } + Vec8 operator*(const Vec8& b) const { Vec8 r; for(int i=0; i<8; i++) r.v[i] = v[i] * b.v[i]; return r; } + Vec8 operator/(const Vec8& b) const { Vec8 r; for(int i=0; i<8; i++) r.v[i] = v[i] / b.v[i]; return r; } + Vec8 fmadd(const Vec8& b, const Vec8& c) const { Vec8 r; for(int i=0; i<8; i++) r.v[i] = v[i] * b.v[i] + c.v[i]; return r; } + Vec8 sqrt() const { Vec8 r; for(int i=0; i<8; i++) r.v[i] = std::sqrt(v[i]); return r; } + Vec8 abs() const { Vec8 r; for(int i=0;i<8;i++) r.v[i] = std::fabs(v[i]); return r; } + static Vec8 mask_blend(uint8_t mask, const Vec8& a, const Vec8& b) { Vec8 r=a; for(int i=0;i<8;i++) if (mask & (1< condition true for lane i) +static inline uint8_t cmp_mask_lt(const Vec8& a, const Vec8& b) { +#ifdef __AVX512F__ + return (uint8_t)_mm512_cmp_pd_mask(a.v, b.v, _CMP_LT_OQ); +#elif defined(__AVX2__) + int m0 = _mm256_movemask_pd(_mm256_cmp_pd(a.lo, b.lo, _CMP_LT_OQ)); + int m1 = _mm256_movemask_pd(_mm256_cmp_pd(a.hi, b.hi, _CMP_LT_OQ)); + return (uint8_t)(m0 | (m1 << 4)); +#else + uint8_t m = 0; for(int i=0;i<8;i++) if (a.v[i] < b.v[i]) m |= (1<= b.v[i]) m |= (1<& tles) : total_satellites_(static_cast(tles.size())) { + padded_satellites_ = (total_satellites_ + 7) & ~7; + cosio = make_aligned(padded_satellites_); sinio = make_aligned(padded_satellites_); + eta = make_aligned(padded_satellites_); t2cof = make_aligned(padded_satellites_); + x1mth2 = make_aligned(padded_satellites_); x3thm1 = make_aligned(padded_satellites_); + x7thm1 = make_aligned(padded_satellites_); aycof = make_aligned(padded_satellites_); + xlcof = make_aligned(padded_satellites_); xnodcf = make_aligned(padded_satellites_); + c1 = make_aligned(padded_satellites_); c4 = make_aligned(padded_satellites_); + omgdot = make_aligned(padded_satellites_); xnodot = make_aligned(padded_satellites_); + xmdot = make_aligned(padded_satellites_); c5 = make_aligned(padded_satellites_); + omgcof = make_aligned(padded_satellites_); xmcof = make_aligned(padded_satellites_); + delmo = make_aligned(padded_satellites_); sinmo = make_aligned(padded_satellites_); + d2 = make_aligned(padded_satellites_); d3 = make_aligned(padded_satellites_); + d4 = make_aligned(padded_satellites_); t3cof = make_aligned(padded_satellites_); + t4cof = make_aligned(padded_satellites_); t5cof = make_aligned(padded_satellites_); + xmo = make_aligned(padded_satellites_); nodeo = make_aligned(padded_satellites_); + omegao = make_aligned(padded_satellites_); ecco = make_aligned(padded_satellites_); + inclo = make_aligned(padded_satellites_); bstar = make_aligned(padded_satellites_); + aodp = make_aligned(padded_satellites_); no_kozai = make_aligned(padded_satellites_); + use_simple_model = make_aligned(padded_satellites_); use_deep_space = make_aligned(padded_satellites_); + active = make_aligned(padded_satellites_); epochs.resize(padded_satellites_); + last_tsince = make_aligned(padded_satellites_); memo_e = make_aligned(padded_satellites_); + memo_a = make_aligned(padded_satellites_); memo_omega = make_aligned(padded_satellites_); + memo_xl = make_aligned(padded_satellites_); memo_xnode = make_aligned(padded_satellites_); + ds_sse = make_aligned(padded_satellites_); ds_ssi = make_aligned(padded_satellites_); ds_ssl = make_aligned(padded_satellites_); + ds_ssh = make_aligned(padded_satellites_); ds_ssg = make_aligned(padded_satellites_); ds_zmos = make_aligned(padded_satellites_); + ds_zmol = make_aligned(padded_satellites_); ds_se2 = make_aligned(padded_satellites_); ds_se3 = make_aligned(padded_satellites_); + ds_si2 = make_aligned(padded_satellites_); ds_si3 = make_aligned(padded_satellites_); ds_sl2 = make_aligned(padded_satellites_); + ds_sl3 = make_aligned(padded_satellites_); ds_sl4 = make_aligned(padded_satellites_); ds_sgh2 = make_aligned(padded_satellites_); + ds_sgh3 = make_aligned(padded_satellites_); ds_sgh4 = make_aligned(padded_satellites_); ds_sh2 = make_aligned(padded_satellites_); + ds_sh3 = make_aligned(padded_satellites_); ds_ee2 = make_aligned(padded_satellites_); ds_e3 = make_aligned(padded_satellites_); + ds_xi2 = make_aligned(padded_satellites_); ds_xi3 = make_aligned(padded_satellites_); ds_xl2 = make_aligned(padded_satellites_); + ds_xl3 = make_aligned(padded_satellites_); ds_xl4 = make_aligned(padded_satellites_); ds_xgh2 = make_aligned(padded_satellites_); + ds_xgh3 = make_aligned(padded_satellites_); ds_xgh4 = make_aligned(padded_satellites_); ds_xh2 = make_aligned(padded_satellites_); + ds_xh3 = make_aligned(padded_satellites_); ds_d2201 = make_aligned(padded_satellites_); ds_d2211 = make_aligned(padded_satellites_); + ds_d3210 = make_aligned(padded_satellites_); ds_d3222 = make_aligned(padded_satellites_); ds_d4410 = make_aligned(padded_satellites_); + ds_d4422 = make_aligned(padded_satellites_); ds_d5220 = make_aligned(padded_satellites_); ds_d5232 = make_aligned(padded_satellites_); + ds_d5421 = make_aligned(padded_satellites_); ds_d5433 = make_aligned(padded_satellites_); ds_del1 = make_aligned(padded_satellites_); + ds_del2 = make_aligned(padded_satellites_); ds_del3 = make_aligned(padded_satellites_); ds_xfact = make_aligned(padded_satellites_); + ds_xlamo = make_aligned(padded_satellites_); ds_shape = make_aligned(padded_satellites_); ds_gsto = make_aligned(padded_satellites_); + int_xli = make_aligned(padded_satellites_); int_xni = make_aligned(padded_satellites_); int_atime = make_aligned(padded_satellites_); + + for (int i = 0; i < total_satellites_; ++i) { + SGP4 model(tles[i]); + cosio[i] = model.common_consts_.cosio; sinio[i] = model.common_consts_.sinio; + eta[i] = model.common_consts_.eta; t2cof[i] = model.common_consts_.t2cof; + x1mth2[i] = model.common_consts_.x1mth2; x3thm1[i] = model.common_consts_.x3thm1; + x7thm1[i] = model.common_consts_.x7thm1; aycof[i] = model.common_consts_.aycof; + xlcof[i] = model.common_consts_.xlcof; xnodcf[i] = model.common_consts_.xnodcf; + c1[i] = model.common_consts_.c1; c4[i] = model.common_consts_.c4; + omgdot[i] = model.common_consts_.omgdot; xnodot[i] = model.common_consts_.xnodot; + xmdot[i] = model.common_consts_.xmdot; c5[i] = model.nearspace_consts_.c5; + omgcof[i] = model.nearspace_consts_.omgcof; xmcof[i] = model.nearspace_consts_.xmcof; + delmo[i] = model.nearspace_consts_.delmo; sinmo[i] = model.nearspace_consts_.sinmo; + d2[i] = model.nearspace_consts_.d2; d3[i] = model.nearspace_consts_.d3; + d4[i] = model.nearspace_consts_.d4; t3cof[i] = model.nearspace_consts_.t3cof; + t4cof[i] = model.nearspace_consts_.t4cof; t5cof[i] = model.nearspace_consts_.t5cof; + xmo[i] = model.elements_.MeanAnomoly(); nodeo[i] = model.elements_.AscendingNode(); + omegao[i] = model.elements_.ArgumentPerigee(); ecco[i] = model.elements_.Eccentricity(); + inclo[i] = model.elements_.Inclination(); bstar[i] = model.elements_.BStar(); + aodp[i] = model.elements_.RecoveredSemiMajorAxis(); no_kozai[i] = model.elements_.RecoveredMeanMotion(); + use_simple_model[i] = model.use_simple_model_ ? 1.0 : 0.0; + use_deep_space[i] = model.use_deep_space_ ? 1.0 : 0.0; active[i] = 1.0; + epochs[i] = model.elements_.Epoch(); last_tsince[i] = -1e9; + if (model.use_deep_space_) { + const auto& ds = model.deepspace_consts_; + ds_sse[i] = ds.sse; ds_ssi[i] = ds.ssi; ds_ssl[i] = ds.ssl; ds_ssh[i] = ds.ssh; ds_ssg[i] = ds.ssg; + ds_zmos[i] = ds.zmos; ds_zmol[i] = ds.zmol; ds_se2[i] = ds.se2; ds_se3[i] = ds.se3; + ds_si2[i] = ds.si2; ds_si3[i] = ds.si3; ds_sl2[i] = ds.sl2; ds_sl3[i] = ds.sl3; ds_sl4[i] = ds.sl4; + ds_sgh2[i] = ds.sgh2; ds_sgh3[i] = ds.sgh3; ds_sgh4[i] = ds.sgh4; ds_sh2[i] = ds.sh2; ds_sh3[i] = ds.sh3; + ds_ee2[i] = ds.ee2; ds_e3[i] = ds.e3; ds_xi2[i] = ds.xi2; ds_xi3[i] = ds.xi3; ds_xl2[i] = ds.xl2; + ds_xl3[i] = ds.xl3; ds_xl4[i] = ds.xl4; ds_xgh2[i] = ds.xgh2; ds_xgh3[i] = ds.xgh3; ds_xgh4[i] = ds.xgh4; + ds_xh2[i] = ds.xh2; ds_xh3[i] = ds.xh3; ds_d2201[i] = ds.d2201; ds_d2211[i] = ds.d2211; ds_d3210[i] = ds.d3210; + ds_d3222[i] = ds.d3222; ds_d4410[i] = ds.d4410; ds_d4422[i] = ds.d4422; ds_d5220[i] = ds.d5220; + ds_d5232[i] = ds.d5232; ds_d5421[i] = ds.d5421; ds_d5433[i] = ds.d5433; ds_del1[i] = ds.del1; + ds_del2[i] = ds.del2; ds_del3[i] = ds.del3; ds_xfact[i] = ds.xfact; ds_xlamo[i] = ds.xlamo; + ds_shape[i] = static_cast(ds.shape); ds_gsto[i] = ds.gsto; + int_xli[i] = model.integrator_params_.xli; int_xni[i] = model.integrator_params_.xni; int_atime[i] = model.integrator_params_.atime; + } + } + for (int i = total_satellites_; i < padded_satellites_; ++i) { + active[i] = 0.0; last_tsince[i] = -1e9; + } +} + +void SGP4Batch::Propagate(double tsince, std::vector& results, MathMode mode) const { + results.resize(total_satellites_, Eci(DateTime(), Vector())); + + // Near Space SoA + const double* p_xmdot = xmdot.get(); const double* p_xmo = xmo.get(); const double* p_omgdot = omgdot.get(); + const double* p_omegao = omegao.get(); const double* p_xnodot = xnodot.get(); const double* p_nodeo = nodeo.get(); + const double* p_xnodcf = xnodcf.get(); const double* p_c1 = c1.get(); const double* p_bstar = bstar.get(); + const double* p_c4 = c4.get(); const double* p_t2cof = t2cof.get(); const double* p_eta = eta.get(); + const double* p_xmcof = xmcof.get(); const double* p_delmo = delmo.get(); const double* p_omgcof = omgcof.get(); + const double* p_d2 = d2.get(); const double* p_d3 = d3.get(); const double* p_d4 = d4.get(); + const double* p_c5 = c5.get(); const double* p_sinmo = sinmo.get(); const double* p_t3cof = t3cof.get(); + const double* p_t5cof = t5cof.get(); const double* p_t4cof = t4cof.get(); const double* p_use_simple = use_simple_model.get(); + const double* p_aodp = aodp.get(); const double* p_ecco = ecco.get(); const double* p_no_kozai = no_kozai.get(); + const double* p_xlcof = xlcof.get(); const double* p_aycof = aycof.get(); const double* p_x3thm1 = x3thm1.get(); + const double* p_cosio = cosio.get(); const double* p_inclo = inclo.get(); const double* p_sinio = sinio.get(); + const double* p_x1mth2 = x1mth2.get(); const double* p_x7thm1 = x7thm1.get(); + const double* p_use_deep = use_deep_space.get(); const double* p_active = active.get(); + + // Deep Space SoA + const double* p_ds_ssl = ds_ssl.get(); const double* p_ds_ssg = ds_ssg.get(); const double* p_ds_ssh = ds_ssh.get(); + const double* p_ds_sse = ds_sse.get(); const double* p_ds_ssi = ds_ssi.get(); const double* p_ds_zmos = ds_zmos.get(); + const double* p_ds_zmol = ds_zmol.get(); const double* p_ds_se2 = ds_se2.get(); const double* p_ds_se3 = ds_se3.get(); + const double* p_ds_si2 = ds_si2.get(); const double* p_ds_si3 = ds_si3.get(); + const double* p_ds_ee2 = ds_ee2.get(); const double* p_ds_e3 = ds_e3.get(); + const double* p_ds_xi2 = ds_xi2.get(); const double* p_ds_xi3 = ds_xi3.get(); + const double* p_ds_gsto = ds_gsto.get(); + const double* p_ds_del1 = ds_del1.get(); const double* p_ds_del2 = ds_del2.get(); const double* p_ds_del3 = ds_del3.get(); + const double* p_ds_d2201 = ds_d2201.get(); const double* p_ds_d2211 = ds_d2211.get(); const double* p_ds_d3210 = ds_d3210.get(); + const double* p_ds_d3222 = ds_d3222.get(); const double* p_ds_d4410 = ds_d4410.get(); const double* p_ds_d4422 = ds_d4422.get(); + const double* p_ds_d5220 = ds_d5220.get(); const double* p_ds_d5232 = ds_d5232.get(); const double* p_ds_d5421 = ds_d5421.get(); + const double* p_ds_d5433 = ds_d5433.get(); const double* p_ds_xfact = ds_xfact.get(); const double* p_ds_xlamo = ds_xlamo.get(); + const double* p_ds_shape = ds_shape.get(); + double* p_int_xli = int_xli.get(); double* p_int_xni = int_xni.get(); double* p_int_atime = int_atime.get(); + + double* p_last_t = last_tsince.get(); double* p_memo_a = memo_a.get(); double* p_memo_e = memo_e.get(); + double* p_memo_om = memo_omega.get(); double* p_memo_xl = memo_xl.get(); double* p_memo_xnode = memo_xnode.get(); + + Vec8 v_tsince(tsince); Vec8 v_tsq = v_tsince * v_tsince; Vec8 v_tcube = v_tsq * v_tsince; Vec8 v_tfour = v_tsince * v_tcube; + Vec8 v_one(1.0); Vec8 v_zero(0.0); + + #pragma omp parallel for schedule(static) + for (int i = 0; i < padded_satellites_; i += 8) { + Vec8 v_last_t = Vec8::load(&p_last_t[i]); + uint8_t m_memo = cmp_mask_eq(v_tsince, v_last_t); + Vec8 a, e, omega, xl, xnode, xn, xinc; + auto sincos_vec = (mode == MathMode::Minimax) ? &v_sincos_minimax : &v_sincos_vector; + + if (m_memo == 0xFF) { + a = Vec8::load(&p_memo_a[i]); e = Vec8::load(&p_memo_e[i]); + omega = Vec8::load(&p_memo_om[i]); xl = Vec8::load(&p_memo_xl[i]); xnode = Vec8::load(&p_memo_xnode[i]); + } else { + Vec8 xmdf = Vec8::load(&p_xmdot[i]).fmadd(v_tsince, Vec8::load(&p_xmo[i])); + Vec8 omgadf = Vec8::load(&p_omgdot[i]).fmadd(v_tsince, Vec8::load(&p_omegao[i])); + Vec8 xnoddf = Vec8::load(&p_xnodot[i]).fmadd(v_tsince, Vec8::load(&p_nodeo[i])); + xnode = xnoddf + Vec8::load(&p_xnodcf[i]) * v_tsq; + Vec8 tempa = v_one - Vec8::load(&p_c1[i]) * v_tsince; + Vec8 v_bstar = Vec8::load(&p_bstar[i]); + Vec8 tempe = v_bstar * Vec8::load(&p_c4[i]) * v_tsince; + Vec8 templ = Vec8::load(&p_t2cof[i]) * v_tsq; + + xn = Vec8::load(&p_no_kozai[i]); + e = Vec8::load(&p_ecco[i]); + xinc = Vec8::load(&p_inclo[i]); + + uint8_t m_ds = cmp_mask_eq(Vec8::load(&p_use_deep[i]), v_one); + + if (m_ds) { + // --- DEEP SPACE SECULAR --- + xmdf = mask_add(xmdf, m_ds, xmdf, Vec8::load(&p_ds_ssl[i]) * v_tsince); + omgadf = mask_add(omgadf, m_ds, omgadf, Vec8::load(&p_ds_ssg[i]) * v_tsince); + xnoddf = mask_add(xnoddf, m_ds, xnoddf, Vec8::load(&p_ds_ssh[i]) * v_tsince); + e = mask_add(e, m_ds, e, Vec8::load(&p_ds_sse[i]) * v_tsince); + xinc = mask_add(xinc, m_ds, xinc, Vec8::load(&p_ds_ssi[i]) * v_tsince); + + Vec8 v_shape = Vec8::load(&p_ds_shape[i]); + uint8_t m_integ = mask_cmp(m_ds, v_shape, v_zero, _CMP_GT_OQ); + if (m_integ) { + Vec8 atime = Vec8::load(&p_int_atime[i]); + Vec8 xni = Vec8::load(&p_int_xni[i]); + Vec8 xli = Vec8::load(&p_int_xli[i]); + Vec8 step(720.0); Vec8 step2(259200.0); + + uint8_t m_reset = cmp_mask_lt(v_tsince.abs(), step); + m_reset |= cmp_mask_le(v_tsince * atime, v_zero); + m_reset |= cmp_mask_lt(v_tsince.abs(), atime.abs()); + m_reset &= m_integ; + + atime = Vec8::mask_blend(m_reset, atime, v_zero); + xni = Vec8::mask_blend(m_reset, xni, Vec8::load(&p_no_kozai[i])); + xli = Vec8::mask_blend(m_reset, xli, Vec8::load(&p_ds_xlamo[i])); + + uint8_t m_running = m_integ; + while (m_running) { + Vec8 xndot, xnddt; + uint8_t m_synch = mask_cmp(m_running, v_shape, Vec8(1.0), _CMP_EQ_OQ); + if (m_synch) { + Vec8 sin1, cos1, sin2, cos2, sin3, cos3; + v_sincos_vector(xli - Vec8(0.13130908), sin1, cos1); + v_sincos_vector(2.0 * (xli - Vec8(2.8843198)), sin2, cos2); + v_sincos_vector(3.0 * (xli - Vec8(0.37448087)), sin3, cos3); + xndot = mask_add(xndot, m_synch, Vec8::load(&p_ds_del1[i]) * sin1, Vec8::load(&p_ds_del2[i]) * sin2 + Vec8::load(&p_ds_del3[i]) * sin3); + xnddt = mask_add(xnddt, m_synch, Vec8::load(&p_ds_del1[i]) * cos1, (Vec8(2.0) * Vec8::load(&p_ds_del2[i]) * cos2 + Vec8(3.0) * Vec8::load(&p_ds_del3[i]) * cos3)); + } + uint8_t m_reso = mask_cmp(m_running, v_shape, Vec8(2.0), _CMP_EQ_OQ); + if (m_reso) { + Vec8 xomi = Vec8::load(&p_omegao[i]) + Vec8::load(&p_omgdot[i]) * atime; + Vec8 sin1, cos1, sin2, cos2, sin3, cos3, sin4, cos4, sin5, cos5; + v_sincos_vector(2.0*xomi + xli - Vec8(5.7686396), sin1, cos1); + v_sincos_vector(xli - Vec8(5.7686396), sin2, cos2); + v_sincos_vector(xomi + xli - Vec8(0.95240898), sin3, cos3); + v_sincos_vector(-1.0*xomi + xli - Vec8(0.95240898), sin4, cos4); + v_sincos_vector(2.0*xomi + 2.0*xli - Vec8(1.8014998), sin5, cos5); + xndot = mask_add(xndot, m_reso, xndot, Vec8::load(&p_ds_d2201[i]) * sin1 + Vec8::load(&p_ds_d2211[i]) * sin2 + Vec8::load(&p_ds_d3210[i]) * sin3 + Vec8::load(&p_ds_d3222[i]) * sin4 + Vec8::load(&p_ds_d4410[i]) * sin5); + xnddt = mask_add(xnddt, m_reso, xnddt, Vec8::load(&p_ds_d2201[i]) * cos1 + Vec8::load(&p_ds_d2211[i]) * cos2 + Vec8::load(&p_ds_d3210[i]) * cos3 + Vec8::load(&p_ds_d3222[i]) * cos4 + Vec8(2.0) * Vec8::load(&p_ds_d4410[i]) * cos5); + v_sincos_vector(2.0*xli - Vec8(1.8014998), sin1, cos1); + v_sincos_vector(xomi + xli - Vec8(1.0508330), sin2, cos2); + v_sincos_vector(-1.0*xomi + xli - Vec8(1.0508330), sin3, cos3); + v_sincos_vector(xomi + 2.0*xli - Vec8(4.4108898), sin4, cos4); + v_sincos_vector(-1.0*xomi + 2.0*xli - Vec8(4.4108898), sin5, cos5); + xndot = mask_add(xndot, m_reso, xndot, Vec8::load(&p_ds_d4422[i]) * sin1 + Vec8::load(&p_ds_d5220[i]) * sin2 + Vec8::load(&p_ds_d5232[i]) * sin3 + Vec8::load(&p_ds_d5421[i]) * sin4 + Vec8::load(&p_ds_d5433[i]) * sin5); + xnddt = mask_add(xnddt, m_reso, xnddt, Vec8(2.0) * Vec8::load(&p_ds_d4422[i]) * cos1 + Vec8::load(&p_ds_d5220[i]) * cos2 + Vec8::load(&p_ds_d5232[i]) * cos3 + Vec8(2.0) * (Vec8::load(&p_ds_d5421[i]) * cos4 + Vec8::load(&p_ds_d5433[i]) * cos5)); + } + Vec8 xldot = xni + Vec8::load(&p_ds_xfact[i]); + xnddt = xnddt * xldot; + Vec8 ft = v_tsince - atime; + uint8_t m_step = mask_cmp(m_running, ft.abs(), step, _CMP_GE_OQ); + if (m_step) { + uint8_t m_ge = cmp_mask_ge(ft, v_zero); + Vec8 delt = Vec8::mask_blend(m_ge, Vec8(0.0) - step, step); + xli = mask_add(xli, m_step, xli, xldot * delt + xndot * step2); + xni = mask_add(xni, m_step, xni, xndot * delt + xnddt * step2); + atime = mask_add(atime, m_step, atime, delt); + } + uint8_t m_final = (uint8_t)(m_running & (uint8_t)(~m_step)); + if (m_final) { + xn = mask_add(xn, m_final, xni, xndot * ft + Vec8(0.5) * xnddt * ft * ft); + Vec8 xl_temp = xli + xldot * ft + Vec8(0.5) * xndot * ft * ft; + Vec8 theta = v_wrap_twopi(Vec8::load(&p_ds_gsto[i]) + v_tsince * Vec8(0.00437526908801129966)); + xmdf = Vec8::mask_blend((uint8_t)(m_synch & m_final), xmdf, (xl_temp + theta - xnode - omgadf)); + xmdf = Vec8::mask_blend((uint8_t)(m_reso & m_final), xmdf, (xl_temp + Vec8(2.0) * (theta - xnode))); + } + m_running &= m_step; + } + atime.store(&p_int_atime[i]); xni.store(&p_int_xni[i]); xli.store(&p_int_xli[i]); + } + } + + Vec8 xmp = xmdf; omega = omgadf; + Vec8 sw_xmdf, cw_xmdf; + sincos_vec(xmdf, sw_xmdf, cw_xmdf); + + uint8_t m_ns = cmp_mask_eq(Vec8::load(&p_use_simple[i]), v_zero); + m_ns &= (uint8_t)(~m_ds); + + if (m_ns) { + Vec8 etacos = v_one + Vec8::load(&p_eta[i]) * cw_xmdf; + Vec8 delm = Vec8::load(&p_xmcof[i]) * (etacos * etacos * etacos - Vec8::load(&p_delmo[i])); + Vec8 delomg = Vec8::load(&p_omgcof[i]) * v_tsince; + Vec8 temp_ns = delomg + delm; + xmp = mask_add(xmp, m_ns, xmp, temp_ns); + omega = mask_sub(omega, m_ns, omega, temp_ns); + tempa = mask_sub(tempa, m_ns, tempa, Vec8::load(&p_d2[i]) * v_tsq + Vec8::load(&p_d3[i]) * v_tcube + Vec8::load(&p_d4[i]) * v_tfour); + Vec8 sw_xmp_ns, cw_xmp_ns; + if (mode == MathMode::Minimax) v_sincos_minimax(xmp, sw_xmp_ns, cw_xmp_ns); else v_sincos_vector(xmp, sw_xmp_ns, cw_xmp_ns); + tempe = mask_add(tempe, m_ns, tempe, v_bstar * Vec8::load(&p_c5[i]) * (sw_xmp_ns - Vec8::load(&p_sinmo[i]))); + templ = mask_add(templ, m_ns, templ, Vec8::load(&p_t3cof[i]) * v_tcube + v_tfour * Vec8::load(&p_t5cof[i]).fmadd(v_tsince, Vec8::load(&p_t4cof[i]))); + } + + a = Vec8::load(&p_aodp[i]) * tempa * tempa; + e = e - tempe; + e = Vec8::max(e, Vec8(1e-6)); e = Vec8::min(e, Vec8(1.0 - 1e-6)); + + if (m_ds) { + // --- DEEP SPACE PERIODICS --- + Vec8 zm = Vec8::load(&p_ds_zmos[i]) + Vec8(1.19459E-5) * v_tsince; + Vec8 sw_zm, cw_zm; v_sincos_vector(zm, sw_zm, cw_zm); + Vec8 zf = zm + Vec8(2.0 * 0.01675) * sw_zm; + Vec8 sw_zf, cw_zf; v_sincos_vector(zf, sw_zf, cw_zf); + Vec8 f2 = Vec8(0.5) * sw_zf * sw_zf - Vec8(0.25); + Vec8 f3 = Vec8(-0.5) * sw_zf * cw_zf; + Vec8 pe = Vec8::load(&p_ds_se2[i]) * f2 + Vec8::load(&p_ds_se3[i]) * f3; + Vec8 pinc = Vec8::load(&p_ds_si2[i]) * f2 + Vec8::load(&p_ds_si3[i]) * f3; + Vec8 zm_l = Vec8::load(&p_ds_zmol[i]) + Vec8(1.5835218E-4) * v_tsince; + Vec8 sw_zml, cw_zml; v_sincos_vector(zm_l, sw_zml, cw_zml); + Vec8 zf_l = zm_l + Vec8(2.0 * 0.05490) * sw_zml; + Vec8 sw_zfl, cw_zfl; v_sincos_vector(zf_l, sw_zfl, cw_zfl); + Vec8 f2l = Vec8(0.5) * sw_zfl * sw_zfl - Vec8(0.25); + Vec8 f3l = Vec8(-0.5) * sw_zfl * cw_zfl; + pe = pe + Vec8::load(&p_ds_ee2[i]) * f2l + Vec8::load(&p_ds_e3[i]) * f3l; + pinc = pinc + Vec8::load(&p_ds_xi2[i]) * f2l + Vec8::load(&p_ds_xi3[i]) * f3l; + e = mask_add(e, m_ds, e, pe); + xinc = mask_add(xinc, m_ds, xinc, pinc); + } + + xl = xmp + omega + xnode + xn * templ; + if (m_memo != 0) { + a = Vec8::mask_blend(m_memo, a, Vec8::load(&p_memo_a[i])); e = Vec8::mask_blend(m_memo, e, Vec8::load(&p_memo_e[i])); + omega = Vec8::mask_blend(m_memo, omega, Vec8::load(&p_memo_om[i])); xl = Vec8::mask_blend(m_memo, xl, Vec8::load(&p_memo_xl[i])); + xnode = Vec8::mask_blend(m_memo, xnode, Vec8::load(&p_memo_xnode[i])); + } + v_tsince.store(&p_last_t[i]); a.store(&p_memo_a[i]); e.store(&p_memo_e[i]); omega.store(&p_memo_om[i]); xl.store(&p_memo_xl[i]); xnode.store(&p_memo_xnode[i]); + } + + // --- FINAL TRANSFORM --- + Vec8 beta2 = v_one - e * e; Vec8 sw_om, cw_om; + if (mode == MathMode::Minimax) v_sincos_minimax(omega, sw_om, cw_om); else v_sincos_vector(omega, sw_om, cw_om); + Vec8 axn = e * cw_om; Vec8 temp11 = v_one / (a * beta2); + Vec8 xlt = xl + temp11 * Vec8::load(&p_xlcof[i]) * axn; + Vec8 ayn = e * sw_om + temp11 * Vec8::load(&p_aycof[i]); + Vec8 capu = v_wrap_twopi(xlt - xnode); Vec8 epw = capu; Vec8 sinepw, cosepw, ecose, esine; + for(int j=0; j<3; j++) { + sincos_vec(epw, sinepw, cosepw); + ecose = axn * cosepw + ayn * sinepw; esine = axn * sinepw - ayn * cosepw; + epw = epw + (capu - epw + esine) / (v_one - ecose + Vec8(0.5) * esine * ((capu - epw + esine) / (v_one - ecose))); + } + sincos_vec(epw, sinepw, cosepw); + ecose = axn * cosepw + ayn * sinepw; esine = axn * sinepw - ayn * cosepw; + Vec8 r = a * (v_one - ecose); Vec8 temp31 = v_one / r; + Vec8 rdot = Vec8(kXKE) * a.sqrt() * esine * temp31; + Vec8 rfdot = Vec8(kXKE) * (a * (v_one - axn*axn - ayn*ayn)).sqrt() * temp31; + Vec8 cosu_un = a * temp31 * (cosepw - axn + ayn * esine * (v_one / (v_one + (v_one - axn*axn - ayn*ayn).sqrt()))); + Vec8 sinu_un = a * temp31 * (sinepw - ayn - axn * esine * (v_one / (v_one + (v_one - axn*axn - ayn*ayn).sqrt()))); + Vec8 u = v_atan2_vector(sinu_un, cosu_un); + Vec8 sin2u = Vec8(2.0) * sinu_un * cosu_un; Vec8 cos2u = Vec8(2.0) * cosu_un * cosu_un - v_one; + Vec8 t41 = v_one / (a * (v_one - axn*axn - ayn*ayn)); Vec8 t42 = Vec8(kCK2) * t41; Vec8 t43 = t42 * t41; + Vec8 rk = r * (v_one - Vec8(1.5) * t43 * (v_one - axn*axn - ayn*ayn).sqrt() * Vec8::load(&p_x3thm1[i])) + Vec8(0.5) * t42 * Vec8::load(&p_x1mth2[i]) * cos2u; + Vec8 uk = u - Vec8(0.25) * t43 * Vec8::load(&p_x7thm1[i]) * sin2u; + Vec8 xnodek = xnode + Vec8(1.5) * t43 * Vec8::load(&p_cosio[i]) * sin2u; + Vec8 xinck = Vec8::load(&p_inclo[i]) + Vec8(1.5) * t43 * Vec8::load(&p_cosio[i]) * Vec8::load(&p_sinio[i]) * cos2u; + Vec8 rdotk = rdot - Vec8(kXKE) / (a * a.sqrt()) * t42 * Vec8::load(&p_x1mth2[i]) * sin2u; + Vec8 rfdotk = rfdot + Vec8(kXKE) / (a * a.sqrt()) * t42 * (Vec8::load(&p_x1mth2[i]) * cos2u + Vec8(1.5) * Vec8::load(&p_x3thm1[i])); + Vec8 snuk, csuk, snik, csik, snnk, csnk; + if (mode == MathMode::Minimax) { v_sincos_minimax(uk, snuk, csuk); v_sincos_minimax(xinck, snik, csik); v_sincos_minimax(xnodek, snnk, csnk); } + else { v_sincos_vector(uk, snuk, csuk); v_sincos_vector(xinck, snik, csik); v_sincos_vector(xnodek, snnk, csnk); } + Vec8 xmx = (v_zero - snnk) * csik; Vec8 xmy = csnk * csik; + Vec8 ux = xmx * snuk + csnk * csuk; Vec8 uy = xmy * snuk + snnk * csuk; Vec8 uz = snik * snuk; + Vec8 vx = xmx * csuk - csnk * snuk; Vec8 vy = xmy * csuk - snnk * snuk; Vec8 vz = snik * csuk; + alignas(64) double a_rk[8], a_ux[8], a_uy[8], a_uz[8], a_rdotk[8], a_rfdotk[8], a_vx[8], a_vy[8], a_vz[8]; + rk.store(a_rk); ux.store(a_ux); uy.store(a_uy); uz.store(a_uz); rdotk.store(a_rdotk); rfdotk.store(a_rfdotk); vx.store(a_vx); vy.store(a_vy); vz.store(a_vz); + for (int s = 0; s < 8; s++) { + int idx = i + s; if (idx >= total_satellites_) break; + if (p_active[idx] == 0.0) continue; + results[idx] = Eci(epochs[idx].AddMinutes(tsince), Vector(a_rk[s] * a_ux[s] * kXKMPER, a_rk[s] * a_uy[s] * kXKMPER, a_rk[s] * a_uz[s] * kXKMPER), + Vector((a_rdotk[s] * a_ux[s] + a_rfdotk[s] * a_vx[s]) * kXKMPER / 60.0, (a_rdotk[s] * a_uy[s] + a_rfdotk[s] * a_vy[s]) * kXKMPER / 60.0, (a_rdotk[s] * a_uz[s] + a_rfdotk[s] * a_vz[s]) * kXKMPER / 60.0)); + } + } +} + +} // namespace libsgp4 diff --git a/libsgp4/SGP4Batch.h b/libsgp4/SGP4Batch.h new file mode 100644 index 0000000..90ef9ab --- /dev/null +++ b/libsgp4/SGP4Batch.h @@ -0,0 +1,111 @@ +#pragma once + +#include "Tle.h" +#include +#include "Eci.h" +#include "DateTime.h" +#include + +namespace libsgp4 +{ + +/** + * @brief SGP4Batch - High-performance vectorized SGP4 propagator. + */ +class SGP4Batch +{ +public: + enum class MathMode { + Standard, // libmvec (High precision) + Minimax // Fast Polynomial Approx (~1e-12 precision) + }; + + SGP4Batch(const std::vector& tles); + void Propagate(double tsince, std::vector& results, MathMode mode = MathMode::Standard) const; + + int total_satellites() const { return total_satellites_; } + + // JIT Accessors + const double* get_cosio() const { return cosio.get(); } + const double* get_sinio() const { return sinio.get(); } + const double* get_eta() const { return eta.get(); } + const double* get_t2cof() const { return t2cof.get(); } + const double* get_x1mth2() const { return x1mth2.get(); } + const double* get_x3thm1() const { return x3thm1.get(); } + const double* get_x7thm1() const { return x7thm1.get(); } + const double* get_aycof() const { return aycof.get(); } + const double* get_xlcof() const { return xlcof.get(); } + const double* get_xnodcf() const { return xnodcf.get(); } + const double* get_c1() const { return c1.get(); } + const double* get_c4() const { return c4.get(); } + const double* get_omgdot() const { return omgdot.get(); } + const double* get_xnodot() const { return xnodot.get(); } + const double* get_xmdot() const { return xmdot.get(); } + const double* get_c5() const { return c5.get(); } + const double* get_omgcof() const { return omgcof.get(); } + const double* get_xmcof() const { return xmcof.get(); } + const double* get_delmo() const { return delmo.get(); } + const double* get_sinmo() const { return sinmo.get(); } + const double* get_d2() const { return d2.get(); } + const double* get_d3() const { return d3.get(); } + const double* get_d4() const { return d4.get(); } + const double* get_t3cof() const { return t3cof.get(); } + const double* get_t4cof() const { return t4cof.get(); } + const double* get_t5cof() const { return t5cof.get(); } + const double* get_xmo() const { return xmo.get(); } + const double* get_nodeo() const { return nodeo.get(); } + const double* get_omegao() const { return omegao.get(); } + const double* get_ecco() const { return ecco.get(); } + const double* get_inclo() const { return inclo.get(); } + const double* get_bstar() const { return bstar.get(); } + const double* get_aodp() const { return aodp.get(); } + const double* get_no_kozai() const { return no_kozai.get(); } + const double* get_active() const { return active.get(); } + const std::vector& get_epochs() const { return epochs; } + +private: + int total_satellites_; + int padded_satellites_; + + template + struct AlignedDeleter { + void operator()(T* p) const { free(p); } + }; + + template + using AlignedPtr = std::unique_ptr>; + + template + static AlignedPtr make_aligned(size_t size) { + void* ptr = nullptr; + if (posix_memalign(&ptr, 64, size * sizeof(T)) != 0) throw std::bad_alloc(); + return AlignedPtr(static_cast(ptr)); + } + + // --- Near Space SoA --- + AlignedPtr cosio, sinio, eta, t2cof, x1mth2, x3thm1, x7thm1, aycof, xlcof, xnodcf, c1, c4, omgdot, xnodot, xmdot; + AlignedPtr c5, omgcof, xmcof, delmo, sinmo, d2, d3, d4, t3cof, t4cof, t5cof; + AlignedPtr xmo, nodeo, omegao, ecco, inclo, bstar, aodp, no_kozai; + AlignedPtr use_simple_model, use_deep_space, active; + + // --- Deep Space SoA --- + AlignedPtr ds_gsto, ds_zmol, ds_zmos; + AlignedPtr ds_sse, ds_ssi, ds_ssl, ds_ssh, ds_ssg; + AlignedPtr ds_se2, ds_si2, ds_sl2, ds_sgh2, ds_sh2; + AlignedPtr ds_se3, ds_si3, ds_sl3, ds_sgh3, ds_sh3; + AlignedPtr ds_sl4, ds_sgh4, ds_ee2, ds_e3, ds_xi2, ds_xi3, ds_xl2, ds_xl3, ds_xl4, ds_xgh2, ds_xgh3, ds_xgh4, ds_xh2, ds_xh3; + AlignedPtr ds_d2201, ds_d2211, ds_d3210, ds_d3222, ds_d4410, ds_d4422, ds_d5220, ds_d5232, ds_d5421, ds_d5433; + AlignedPtr ds_del1, ds_del2, ds_del3, ds_xfact, ds_xlamo, ds_shape; + + // Integrator state + mutable AlignedPtr int_xli, int_xni, int_atime; + + std::vector epochs; + + // Memoization + mutable AlignedPtr last_tsince, memo_e, memo_a, memo_omega, memo_xl, memo_xnode; + + friend class JitPropagator; +}; + +} // namespace libsgp4 diff --git a/libsgp4/SpatialHash.h b/libsgp4/SpatialHash.h new file mode 100644 index 0000000..41d54e9 --- /dev/null +++ b/libsgp4/SpatialHash.h @@ -0,0 +1,58 @@ +#pragma once + +#include +#include +#include "Vector.h" + +namespace libsgp4 +{ + +/** + * @brief SpatialHash - Ultra-fast proximity filtering using AVX-512 VPOPCNTDQ. + * Maps coordinates to a bit-signature based on grid occupancy. + */ +class SpatialHash +{ +public: + static const int GRID_SIZE = 128; // 128km bins + + struct alignas(64) Signature { + uint64_t bits[8]; // 512 bits per signature + }; + + /** + * @brief Generate a 512-bit signature for a position. + * Sets bits based on the neighboring grid cells. + */ + static Signature Generate(const Vector& pos) { + Signature sig = {0}; + int gx = (int)((pos.x + 10000.0) / GRID_SIZE) % 512; + int gy = (int)((pos.y + 10000.0) / GRID_SIZE) % 512; + int gz = (int)((pos.z + 10000.0) / GRID_SIZE) % 512; + + // Simple hash: set bit at (gx ^ gy ^ gz) + int bit = (gx ^ gy ^ gz) & 511; + sig.bits[bit / 64] |= (1ULL << (bit % 64)); + return sig; + } + + /** + * @brief Vectorized filter: Check if any targets in a batch overlap with probe. + */ + static void Filter(const Signature& probe, const std::vector& targets, std::vector& candidate_indices) { + __m512i v_probe = _mm512_load_si512(&probe); + int n = targets.size(); + + for(int i=0; i +#include +#include +#include +#include +#include + +namespace libsgp4 { + +/** + * @brief SpatialPartition - BVH-lite using Morton codes and Z-order curve. + * This handles the O(N log N) pruning for conjunction screening. + */ +class SpatialPartition { +public: + struct Object { + int id; + double x, y, z; + uint64_t morton; + }; + + // Expands a 21-bit integer into 64 bits by inserting 2 zeros between each bit + static inline uint64_t expandBits(uint64_t v) { + v = (v | (v << 32)) & 0x001F00000000FFFF; + v = (v | (v << 16)) & 0x001F0000FF0000FF; + v = (v | (v << 8)) & 0x100F00F00F00F00F; + v = (v | (v << 4)) & 0x10C30C30C30C30C3; + v = (v | (v << 2)) & 0x1249249249249249; + return v; + } + + // Calculates Morton code for a point in [-RE*10, RE*10] space (LEO to GEO) + static inline uint64_t morton3D(double x, double y, double z) { + // Normalize coordinates to [0, 2^21 - 1] + // Range: +/- 100,000 km is plenty for SATCAT + const double offset = 100000.0; + const double scale = 10.48575; // (2^21 - 1) / 200,000 + + uint64_t ix = static_cast((x + offset) * scale); + uint64_t iy = static_cast((y + offset) * scale); + uint64_t iz = static_cast((z + offset) * scale); + + return (expandBits(ix) << 2) | (expandBits(iy) << 1) | expandBits(iz); + } + + /** + * @brief Sorts objects along the Z-order curve. + * Objects close in 3D space will likely be close in the sorted list. + */ + static void SortObjects(std::vector& objects) { + for (auto& obj : objects) { + obj.morton = morton3D(obj.x, obj.y, obj.z); + } + std::sort(objects.begin(), objects.end(), [](const Object& a, const Object& b) { + return a.morton < b.morton; + }); + } + + /** + * @brief Screen conjunctions using Z-order sliding window. + * Complexity: O(N log N) due to sort, O(N * K) for sweep where K is small. + */ + static void SweepAndPrune( + const std::vector& sorted_objects, + double threshold_km, + std::vector>& candidates) + { + int n = sorted_objects.size(); + double d2_thresh = threshold_km * threshold_km; + + for (int i = 0; i < n; i++) { + // Sweep forward in the Morton-sorted list + for (int j = i + 1; j < n; j++) { + // If the Morton distance is too large, we can stop the inner sweep early + // (Note: This is a heuristic pruning. For a strict BVH, we'd use a tree traversal). + // However, along the Z-curve, objects that are far in Morton space ARE far in 1 coordinate. + + // Morton codes are 64-bit. If the high bits differ significantly, + // the spatial distance is guaranteed to be large. + if ((sorted_objects[j].morton - sorted_objects[i].morton) > 1000000) { + // High-performance heuristic: tune this value or check bounding box + // For bit-perfect, we check if coord difference exceeds threshold + if (std::abs(sorted_objects[j].x - sorted_objects[i].x) > threshold_km) break; + } + + double dx = sorted_objects[i].x - sorted_objects[j].x; + double dy = sorted_objects[i].y - sorted_objects[j].y; + double dz = sorted_objects[i].z - sorted_objects[j].z; + double d2 = dx*dx + dy*dy + dz*dz; + + if (d2 < d2_thresh) { + candidates.push_back({sorted_objects[i].id, sorted_objects[j].id}); + } + } + } + } +}; + +} // namespace libsgp4 diff --git a/libsgp4/TemporalPruner.h b/libsgp4/TemporalPruner.h new file mode 100644 index 0000000..fc60ce5 --- /dev/null +++ b/libsgp4/TemporalPruner.h @@ -0,0 +1,54 @@ +#include +#include +#include +#include +#include +#include +#include +#include "DateTime.h" +#include "Vector.h" +#include "Eci.h" + +namespace libsgp4 { + +/** + * @brief TemporalPruner - Manages "sleep" states for satellite pairs based on + * minimum time-to-collision (TTC). + */ +class TemporalPruner { +public: + struct PairState { + uint32_t id1; + uint32_t id2; + int sleep_steps; + }; + + /** + * @brief Estimates steps to skip based on distance and max closing velocity. + * @param dist Current distance (km) + * @param threshold_km Screening threshold (km) + * @param step_size_sec Current simulation step (sec) + * @param max_rel_vel_kms Conservative max relative velocity (typically 15.0 km/s in LEO) + * @return Number of steps to safely sleep + */ + static inline int EstimateSleepSteps(double dist, double threshold_km, double step_size_sec, double max_rel_vel_kms = 16.0) { + if (dist <= threshold_km) return 0; + + // Time to reach threshold at max velocity: t = (dist - threshold) / v_max + double safe_time_sec = (dist - threshold_km) / max_rel_vel_kms; + int steps = static_cast(safe_time_sec / step_size_sec); + + // Return steps - 1 for safety margin, capped to avoid long-term stale states + return std::min(steps, 200); + } + + /** + * @brief Fast pair-indexing for sleep map + */ + static inline uint64_t GetPairKey(int id1, int id2) { + if (id1 > id2) std::swap(id1, id2); + return (static_cast(id1) << 32) | static_cast(id2); + } +}; + +} // namespace libsgp4 diff --git a/libsgp4/Util.h b/libsgp4/Util.h index 4135a7d..3ee5e20 100644 --- a/libsgp4/Util.h +++ b/libsgp4/Util.h @@ -54,7 +54,9 @@ namespace Util inline double WrapTwoPI(const double a) { - return Mod(a, kTWOPI); + double res = fmod(a, kTWOPI); + if (res < 0) res += kTWOPI; + return res; } inline double WrapNegPos180(const double a) diff --git a/parallel_bench.cc b/parallel_bench.cc new file mode 100644 index 0000000..8e415f9 --- /dev/null +++ b/parallel_bench.cc @@ -0,0 +1,101 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace libsgp4; + +struct Threat { + std::string id; + Tle tle; + double peri; + double apo; +}; + +inline double get_dist(const Vector& v1, const Vector& v2) { + double dx = v1.x - v2.x, dy = v1.y - v2.y, dz = v1.z - v2.z; + return std::sqrt(dx*dx + dy*dy + dz*dz); +} + +int main() { + std::set inactive_ids; + std::ifstream ids_file("/home/troyrock/.openclaw/workspace/inactive_ids.txt"); + std::string id_line; + while (std::getline(ids_file, id_line)) { + id_line.erase(id_line.find_last_not_of(" \n\r\t")+1); + if (!id_line.empty()) inactive_ids.insert(id_line); + } + std::cout << "Loaded " << inactive_ids.size() << " inactive IDs." << std::endl; + + std::map> latest_tles; + std::ifstream tle_file("tle_sample.txt"); + std::string line, l1; + while (std::getline(tle_file, line)) { + if (line.empty()) continue; + if (line[0] == '1') { + l1 = line; + } else if (line[0] == '2') { + if (l1.empty()) continue; + if (line.size() < 7) continue; + std::string id = line.substr(2, 5); + if (inactive_ids.count(id)) { + latest_tles[id] = {l1, line}; + } + l1.clear(); + } + } + + std::vector tles; + std::vector> shell_bounds; + for (auto const& [id, lines] : latest_tles) { + try { + std::string s1 = lines.first.substr(0, 69); + std::string s2 = lines.second.substr(0, 69); + Tle tle(id, s1, s2); + double n = tle.MeanMotion(); + double a = std::pow(398600.44 / (n * n * (2.0*M_PI/86400.0) * (2.0*M_PI/86400.0)), 1.0/3.0); + double e = tle.Eccentricity(); + tles.push_back(tle); + shell_bounds.push_back({a*(1.0-e)-6378.137, a*(1.0+e)-6378.137}); + } catch (...) {} + } + std::cout << "Initialized " << tles.size() << " inactive threats." << std::endl; + + SGP4Batch batch_model(tles); + std::cout << "Starting parallelized propagation benchmark..." << std::endl; + + auto start = std::chrono::high_resolution_clock::now(); + + // We'll simulate 60 minutes of propagation for the entire batch + // RUN 1: FRESH CALC + std::vector results; + for (int t = 0; t < 60; ++t) { + batch_model.Propagate(static_cast(t), results); + } + + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration diff = end - start; + + std::cout << "Fresh Run Throughput: " << (static_cast(tles.size()) * 60.0 / diff.count() / 1e6) << " million sats/sec" << std::endl; + + // RUN 2: MEMOIZED + start = std::chrono::high_resolution_clock::now(); + for (int t = 0; t < 60; ++t) { + batch_model.Propagate(static_cast(t), results); + } + end = std::chrono::high_resolution_clock::now(); + diff = end - start; + std::cout << "Memoized Run Throughput: " << (static_cast(tles.size()) * 60.0 / diff.count() / 1e6) << " million sats/sec" << std::endl; + + return 0; +} diff --git a/rf_model.h b/rf_model.h new file mode 100644 index 0000000..20afbc8 --- /dev/null +++ b/rf_model.h @@ -0,0 +1,1274 @@ + +/* Auto-generated Random Forest (B* Predictor) */ +double PredictBStar(double f107, double f107_smooth) { + double sum = 0; + // Tree 0 + { + if (f107 <= 114.20000076) { + if (f107_smooth <= 74.25000000) { + if (f107 <= 75.95000076) { + if (f107 <= 75.50000000) { + if (f107 <= 75.25000000) { + sum += -1.576700000000e-04; + } else { + sum += -1.413500000000e-04; + } + } else { + sum += -1.592900000000e-04; + } + } else { + if (f107 <= 77.00000000) { + if (f107_smooth <= 74.14999771) { + sum += -1.251500000000e-04; + } else { + sum += -9.630600000000e-05; + } + } else { + if (f107 <= 78.70000076) { + sum += -1.569950000000e-04; + } else { + sum += -1.473500000000e-04; + } + } + } + } else { + if (f107_smooth <= 96.40000153) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 87.95000076) { + sum += 1.635229345794e-06; + } else { + sum += 6.647151566265e-05; + } + } else { + if (f107 <= 96.60000229) { + sum += 1.796952800000e-04; + } else { + sum += 5.070417368421e-05; + } + } + } else { + if (f107 <= 102.85000229) { + if (f107_smooth <= 127.25000000) { + sum += -8.030323487805e-05; + } else { + sum += -3.189818181818e-06; + } + } else { + if (f107_smooth <= 133.69999695) { + sum += 6.292329415493e-05; + } else { + sum += -1.025284736842e-04; + } + } + } + } + } else { + if (f107_smooth <= 194.75000000) { + if (f107 <= 119.79999924) { + if (f107_smooth <= 153.40000153) { + if (f107_smooth <= 138.80000305) { + sum += 1.198660525773e-04; + } else { + sum += 1.933128961039e-04; + } + } else { + if (f107_smooth <= 154.09999847) { + sum += -9.058950000000e-05; + } else { + sum += 9.082100000000e-06; + } + } + } else { + if (f107_smooth <= 128.25000000) { + if (f107 <= 134.34999847) { + sum += 7.910174523810e-05; + } else { + sum += 1.947586630435e-04; + } + } else { + if (f107_smooth <= 147.25000000) { + sum += 3.993093262731e-05; + } else { + sum += 8.843557992029e-05; + } + } + } + } else { + if (f107 <= 220.34999847) { + if (f107 <= 220.05000305) { + if (f107 <= 215.34999847) { + sum += 1.945679183761e-04; + } else { + sum += 4.591250000000e-04; + } + } else { + sum += 1.060563333333e-03; + } + } else { + if (f107_smooth <= 220.79999542) { + if (f107_smooth <= 198.15000153) { + sum += 1.716666666667e-04; + } else { + sum += 7.149252739726e-05; + } + } else { + if (f107 <= 236.00000000) { + sum += 2.420712727273e-04; + } else { + sum += 1.348745813953e-04; + } + } + } + } + } + } + // Tree 1 + { + if (f107 <= 108.65000153) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + sum += -1.356866666667e-04; + } else { + sum += -7.209950000000e-05; + } + } else { + if (f107_smooth <= 74.85000229) { + sum += 8.293684042553e-05; + } else { + sum += 9.879572862129e-06; + } + } + } else { + if (f107 <= 93.64999771) { + if (f107_smooth <= 82.70000076) { + sum += 1.035064000000e-04; + } else { + sum += 1.911360000000e-04; + } + } else { + if (f107_smooth <= 88.00000000) { + sum += 1.239109964286e-04; + } else { + sum += -5.492650000000e-05; + } + } + } + } else { + if (f107 <= 102.85000229) { + if (f107 <= 93.15000153) { + if (f107_smooth <= 96.64999771) { + sum += -4.050233333333e-05; + } else { + sum += -1.286717500000e-04; + } + } else { + if (f107_smooth <= 113.29999924) { + sum += -3.044921918367e-05; + } else { + sum += -7.512461743119e-05; + } + } + } else { + if (f107_smooth <= 109.25000000) { + if (f107_smooth <= 107.14999771) { + sum += 7.813200000000e-05; + } else { + sum += 1.901525000000e-04; + } + } else { + if (f107_smooth <= 123.04999924) { + sum += -8.824592307692e-05; + } else { + sum += -5.709571428571e-06; + } + } + } + } + } else { + if (f107_smooth <= 194.50000000) { + if (f107 <= 209.00000000) { + if (f107_smooth <= 190.25000000) { + if (f107_smooth <= 186.34999847) { + sum += 8.045839005801e-05; + } else { + sum += 2.975384615385e-04; + } + } else { + if (f107 <= 172.69999695) { + sum += 8.801061886792e-05; + } else { + sum += -4.558228214286e-05; + } + } + } else { + if (f107_smooth <= 189.50000000) { + if (f107_smooth <= 175.34999847) { + sum += 1.491228352941e-04; + } else { + sum += 3.291481481481e-04; + } + } else { + if (f107 <= 212.34999847) { + sum += 3.318550000000e-04; + } else { + sum += -2.654851333333e-05; + } + } + } + } else { + if (f107 <= 183.90000153) { + if (f107_smooth <= 200.90000153) { + if (f107_smooth <= 200.25000000) { + sum += 2.028626730769e-04; + } else { + sum += 3.938313000000e-05; + } + } else { + if (f107 <= 172.19999695) { + sum += 2.911210344828e-04; + } else { + sum += 2.079523333333e-04; + } + } + } else { + if (f107_smooth <= 220.70000458) { + if (f107_smooth <= 210.05000305) { + sum += 1.546602500000e-04; + } else { + sum += 5.638582121212e-05; + } + } else { + if (f107 <= 239.90000153) { + sum += 2.096232711864e-04; + } else { + sum += 1.134041470588e-04; + } + } + } + } + } + } + // Tree 2 + { + if (f107 <= 111.79999924) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 80.35000229) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + sum += -1.322099200000e-04; + } else { + sum += -7.629220000000e-05; + } + } else { + if (f107_smooth <= 74.85000229) { + sum += 8.050434705882e-05; + } else { + sum += -2.323066193182e-05; + } + } + } else { + if (f107_smooth <= 81.30000305) { + if (f107_smooth <= 79.35000229) { + sum += 2.258536363636e-05; + } else { + sum += 1.696487941176e-04; + } + } else { + if (f107_smooth <= 88.04999924) { + sum += 2.855500000000e-06; + } else { + sum += 8.811367794118e-05; + } + } + } + } else { + if (f107 <= 107.45000076) { + if (f107 <= 96.59999847) { + if (f107_smooth <= 114.04999924) { + sum += -8.392912688889e-05; + } else { + sum += -1.182048378378e-04; + } + } else { + if (f107_smooth <= 109.09999847) { + sum += -2.267640625000e-06; + } else { + sum += -6.197291100000e-05; + } + } + } else { + if (f107_smooth <= 134.84999847) { + if (f107 <= 110.25000000) { + sum += 1.050502727273e-04; + } else { + sum += 1.705700000000e-05; + } + } else { + if (f107_smooth <= 150.95000458) { + sum += -1.310580000000e-04; + } else { + sum += -1.032400000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 194.50000000) { + if (f107_smooth <= 190.75000000) { + if (f107 <= 210.09999847) { + if (f107_smooth <= 186.34999847) { + sum += 8.370751017777e-05; + } else { + sum += 2.151323783784e-04; + } + } else { + if (f107_smooth <= 175.34999847) { + sum += 1.530902486486e-04; + } else { + sum += 3.121535555556e-04; + } + } + } else { + if (f107 <= 172.69999695) { + if (f107 <= 167.50000000) { + sum += 5.438176190476e-05; + } else { + sum += 1.229037722222e-04; + } + } else { + if (f107_smooth <= 193.70000458) { + sum += -5.236968258065e-05; + } else { + sum += 1.195693181818e-04; + } + } + } + } else { + if (f107 <= 182.34999847) { + if (f107_smooth <= 200.90000153) { + if (f107_smooth <= 200.09999847) { + sum += 2.114234285714e-04; + } else { + sum += 1.251837095238e-04; + } + } else { + if (f107_smooth <= 205.29999542) { + sum += 3.256170000000e-04; + } else { + sum += 2.274170727273e-04; + } + } + } else { + if (f107_smooth <= 220.75000000) { + if (f107_smooth <= 210.05000305) { + sum += 1.766321645570e-04; + } else { + sum += 5.443019655172e-05; + } + } else { + if (f107_smooth <= 226.04999542) { + sum += 2.105982191781e-04; + } else { + sum += 8.438358333333e-05; + } + } + } + } + } + } + // Tree 3 + { + if (f107 <= 108.70000076) { + if (f107_smooth <= 96.45000076) { + if (f107_smooth <= 94.45000076) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + sum += -1.371240000000e-04; + } else { + sum += -9.764616666667e-05; + } + } else { + if (f107_smooth <= 74.85000229) { + sum += 9.084329890110e-05; + } else { + sum += 1.063827771231e-05; + } + } + } else { + if (f107_smooth <= 96.09999847) { + if (f107 <= 91.20000076) { + sum += 1.617133333333e-04; + } else { + sum += 1.999727272727e-04; + } + } else { + if (f107_smooth <= 96.25000000) { + sum += 9.724950000000e-05; + } else { + sum += 6.148500000000e-05; + } + } + } + } else { + if (f107 <= 95.04999924) { + if (f107 <= 79.95000076) { + if (f107 <= 76.79999924) { + sum += -1.499057142857e-04; + } else { + sum += -1.288033333333e-04; + } + } else { + if (f107_smooth <= 96.64999771) { + sum += -7.421171428571e-05; + } else { + sum += -1.064926647059e-04; + } + } + } else { + if (f107_smooth <= 109.20000076) { + if (f107_smooth <= 106.40000153) { + sum += -5.505636000000e-05; + } else { + sum += 1.130810500000e-04; + } + } else { + if (f107_smooth <= 130.09999847) { + sum += -7.161001037037e-05; + } else { + sum += -1.854210526316e-06; + } + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (f107_smooth <= 148.05000305) { + if (f107_smooth <= 130.15000153) { + if (f107 <= 136.19999695) { + sum += 9.995635355649e-05; + } else { + sum += 1.431114725275e-04; + } + } else { + if (f107 <= 154.00000000) { + sum += 5.610811372093e-05; + } else { + sum += -2.214929538732e-05; + } + } + } else { + if (f107 <= 115.54999924) { + if (f107 <= 113.95000076) { + sum += -1.011399090909e-04; + } else { + sum += -6.678680000000e-05; + } + } else { + if (f107_smooth <= 190.50000000) { + sum += 9.967080561265e-05; + } else { + sum += 2.230490880000e-05; + } + } + } + } else { + if (f107 <= 174.65000153) { + if (f107_smooth <= 200.90000153) { + if (f107 <= 162.94999695) { + sum += 2.176891250000e-04; + } else { + sum += 1.186437956522e-04; + } + } else { + if (f107_smooth <= 204.34999847) { + sum += 3.251640540541e-04; + } else { + sum += 2.577863636364e-04; + } + } + } else { + if (f107 <= 247.20000458) { + if (f107 <= 215.55000305) { + sum += 1.395686224299e-04; + } else { + sum += 2.080902048193e-04; + } + } else { + if (f107 <= 368.35000610) { + sum += 7.527469298246e-05; + } else { + sum += 2.828250000000e-04; + } + } + } + } + } + } + // Tree 4 + { + if (f107 <= 112.90000153) { + if (f107_smooth <= 112.15000153) { + if (f107 <= 84.45000076) { + if (f107_smooth <= 89.35000229) { + if (f107_smooth <= 74.35000229) { + sum += -1.259762500000e-04; + } else { + sum += 1.514370181087e-05; + } + } else { + if (f107_smooth <= 93.70000076) { + sum += -1.318539130435e-04; + } else { + sum += -5.789267692308e-05; + } + } + } else { + if (f107_smooth <= 81.20000076) { + if (f107_smooth <= 79.35000229) { + sum += 2.449439714286e-05; + } else { + sum += 1.857904705882e-04; + } + } else { + if (f107_smooth <= 87.35000229) { + sum += -1.900572941176e-05; + } else { + sum += 7.348530169591e-05; + } + } + } + } else { + if (f107 <= 107.39999771) { + if (f107_smooth <= 130.09999847) { + if (f107_smooth <= 127.20000076) { + sum += -1.073470689320e-04; + } else { + sum += -5.135893846154e-05; + } + } else { + if (f107_smooth <= 130.75000000) { + sum += 2.325100000000e-04; + } else { + sum += -9.103925000000e-05; + } + } + } else { + if (f107_smooth <= 134.84999847) { + if (f107_smooth <= 120.70000076) { + sum += -2.384374117647e-05; + } else { + sum += 8.235841666667e-05; + } + } else { + if (f107 <= 111.34999847) { + sum += -1.332733333333e-04; + } else { + sum += -1.014207500000e-04; + } + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (f107_smooth <= 129.05000305) { + if (f107_smooth <= 118.79999924) { + if (f107_smooth <= 108.04999924) { + sum += 1.655192479167e-04; + } else { + sum += 3.987675000000e-05; + } + } else { + if (f107_smooth <= 121.70000076) { + sum += 2.025327741935e-04; + } else { + sum += 1.424987624000e-04; + } + } + } else { + if (f107_smooth <= 147.44999695) { + if (f107 <= 122.35000229) { + sum += 8.761260923077e-05; + } else { + sum += 1.739128600907e-05; + } + } else { + if (f107_smooth <= 190.25000000) { + sum += 9.512052270806e-05; + } else { + sum += 1.710572122449e-05; + } + } + } + } else { + if (f107 <= 232.90000153) { + if (f107 <= 173.65000153) { + if (f107_smooth <= 201.20000458) { + sum += 2.079163444444e-04; + } else { + sum += 2.906313333333e-04; + } + } else { + if (f107 <= 220.05000305) { + sum += 1.601372791946e-04; + } else { + sum += 2.561501500000e-04; + } + } + } else { + if (f107 <= 234.14999390) { + if (f107_smooth <= 212.05000305) { + sum += -5.138850000000e-05; + } else { + sum += -6.443600000000e-05; + } + } else { + if (f107 <= 368.35000610) { + sum += 1.061304906542e-04; + } else { + sum += 2.803040000000e-04; + } + } + } + } + } + } + // Tree 5 + { + if (f107 <= 108.65000153) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + sum += -1.332968750000e-04; + } else { + sum += -6.822500000000e-05; + } + } else { + if (f107_smooth <= 74.85000229) { + sum += 8.100972079208e-05; + } else { + sum += 8.057056642984e-06; + } + } + } else { + if (f107 <= 93.70000076) { + if (f107 <= 91.50000000) { + sum += 1.599100000000e-04; + } else { + sum += 2.015795000000e-04; + } + } else { + if (f107_smooth <= 87.94999695) { + sum += 1.230987037037e-04; + } else { + sum += -5.441888888889e-05; + } + } + } + } else { + if (f107 <= 97.15000153) { + if (f107_smooth <= 96.64999771) { + if (f107 <= 81.34999847) { + sum += -7.550300000000e-05; + } else { + sum += -2.746000000000e-05; + } + } else { + if (f107 <= 93.15000153) { + sum += -1.267628048780e-04; + } else { + sum += -9.861945891304e-05; + } + } + } else { + if (f107_smooth <= 109.09999847) { + if (f107_smooth <= 106.40000153) { + sum += -5.154887692308e-05; + } else { + sum += 1.154838947368e-04; + } + } else { + if (f107_smooth <= 128.15000153) { + sum += -8.504654787234e-05; + } else { + sum += -2.309851111111e-05; + } + } + } + } + } else { + if (f107_smooth <= 194.75000000) { + if (f107_smooth <= 190.25000000) { + if (f107_smooth <= 186.25000000) { + if (f107 <= 210.09999847) { + sum += 7.985370572068e-05; + } else { + sum += 1.534911265060e-04; + } + } else { + if (f107 <= 171.34999847) { + sum += 1.856550000000e-04; + } else { + sum += 2.707238461538e-04; + } + } + } else { + if (f107 <= 174.34999847) { + if (f107_smooth <= 190.75000000) { + sum += 2.597166666667e-04; + } else { + sum += 9.203843428571e-05; + } + } else { + if (f107_smooth <= 194.00000000) { + sum += -5.544192714286e-05; + } else { + sum += 1.082509375000e-04; + } + } + } + } else { + if (f107 <= 174.00000000) { + if (f107_smooth <= 201.20000458) { + if (f107_smooth <= 198.44999695) { + sum += 2.509964285714e-04; + } else { + sum += 1.744498888889e-04; + } + } else { + if (f107_smooth <= 204.34999847) { + sum += 3.510175000000e-04; + } else { + sum += 2.560677192982e-04; + } + } + } else { + if (f107_smooth <= 210.05000305) { + if (f107_smooth <= 204.39999390) { + sum += 1.436503430233e-04; + } else { + sum += 3.423228095238e-04; + } + } else { + if (f107_smooth <= 214.29999542) { + sum += 3.996482352941e-06; + } else { + sum += 1.555255165563e-04; + } + } + } + } + } + } + // Tree 6 + { + if (f107 <= 114.05000305) { + if (f107_smooth <= 74.25000000) { + if (f107 <= 75.95000076) { + if (f107 <= 75.25000000) { + sum += -1.560483333333e-04; + } else { + if (f107 <= 75.50000000) { + sum += -1.426528571429e-04; + } else { + sum += -1.587600000000e-04; + } + } + } else { + if (f107 <= 77.00000000) { + if (f107 <= 76.40000153) { + sum += -1.106800000000e-04; + } else { + sum += -1.270233333333e-04; + } + } else { + if (f107 <= 78.70000076) { + sum += -1.546400000000e-04; + } else { + sum += -1.458200000000e-04; + } + } + } + } else { + if (f107_smooth <= 74.85000229) { + if (f107 <= 71.50000000) { + if (f107_smooth <= 74.75000000) { + sum += 9.281728571429e-05; + } else { + sum += -1.866806666667e-05; + } + } else { + if (f107 <= 73.35000229) { + sum += 1.854475862069e-04; + } else { + sum += 7.731984313725e-05; + } + } + } else { + if (f107 <= 74.35000229) { + if (f107_smooth <= 75.14999771) { + sum += -1.255073000000e-04; + } else { + sum += -5.771740347826e-05; + } + } else { + if (f107_smooth <= 96.40000153) { + sum += 3.880432390295e-05; + } else { + sum += -3.156441567723e-05; + } + } + } + } + } else { + if (f107_smooth <= 193.15000153) { + if (f107_smooth <= 147.40000153) { + if (f107_smooth <= 133.05000305) { + if (f107 <= 136.34999847) { + sum += 7.370333856655e-05; + } else { + sum += 1.319931388535e-04; + } + } else { + if (f107 <= 143.34999847) { + sum += 5.003937278107e-05; + } else { + sum += -2.677088171429e-05; + } + } + } else { + if (f107_smooth <= 192.34999847) { + if (f107 <= 197.35000610) { + sum += 9.001521512605e-05; + } else { + sum += 1.601582733333e-04; + } + } else { + if (f107 <= 244.25000000) { + sum += -8.072013333333e-05; + } else { + sum += -1.892550000000e-05; + } + } + } + } else { + if (f107 <= 177.94999695) { + if (f107_smooth <= 196.00000000) { + if (f107_smooth <= 193.84999847) { + sum += 2.432395000000e-04; + } else { + sum += 1.178104000000e-04; + } + } else { + if (f107_smooth <= 215.75000000) { + sum += 2.572501111111e-04; + } else { + sum += 1.774447058824e-04; + } + } + } else { + if (f107 <= 241.79999542) { + if (f107 <= 209.00000000) { + sum += 1.087391879518e-04; + } else { + sum += 2.005808377049e-04; + } + } else { + if (f107 <= 242.00000000) { + sum += -4.678800000000e-05; + } else { + sum += 1.018070949367e-04; + } + } + } + } + } + } + // Tree 7 + { + if (f107_smooth <= 147.20000458) { + if (f107 <= 111.75000000) { + if (f107_smooth <= 96.54999924) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + sum += -1.405920000000e-04; + } else { + sum += -9.217122222222e-05; + } + } else { + if (f107 <= 91.45000076) { + sum += 1.508088719708e-05; + } else { + sum += 1.119277678571e-04; + } + } + } else { + if (f107 <= 104.70000076) { + if (f107 <= 96.59999847) { + sum += -1.006848181818e-04; + } else { + sum += -6.481287727273e-05; + } + } else { + if (f107 <= 105.95000076) { + sum += 1.739844444444e-04; + } else { + sum += -5.861632911392e-06; + } + } + } + } else { + if (f107_smooth <= 130.15000153) { + if (f107_smooth <= 112.25000000) { + if (f107_smooth <= 109.45000076) { + sum += 1.017659660377e-04; + } else { + sum += -1.166596250000e-04; + } + } else { + if (f107_smooth <= 128.25000000) { + sum += 1.397149487342e-04; + } else { + sum += 8.704167619718e-05; + } + } + } else { + if (f107 <= 158.59999847) { + if (f107_smooth <= 131.65000153) { + sum += -4.101134912281e-05; + } else { + sum += 5.001981313673e-05; + } + } else { + if (f107 <= 163.25000000) { + sum += -7.160668725000e-05; + } else { + sum += -3.998852894737e-05; + } + } + } + } + } else { + if (f107_smooth <= 194.00000000) { + if (f107_smooth <= 192.34999847) { + if (f107 <= 210.09999847) { + if (f107_smooth <= 150.65000153) { + sum += 1.207269800372e-04; + } else { + sum += 8.461353177939e-05; + } + } else { + if (f107 <= 227.45000458) { + sum += 2.265404423077e-04; + } else { + sum += 6.926103181818e-05; + } + } + } else { + if (f107 <= 172.69999695) { + if (f107 <= 169.30000305) { + sum += 3.157150000000e-04; + } else { + sum += 1.127386666667e-04; + } + } else { + if (f107 <= 244.25000000) { + sum += -7.494808000000e-05; + } else { + sum += -2.591900000000e-05; + } + } + } + } else { + if (f107 <= 221.50000000) { + if (f107 <= 220.05000305) { + if (f107 <= 177.94999695) { + sum += 2.344691117647e-04; + } else { + sum += 1.430551140351e-04; + } + } else { + if (f107 <= 220.34999847) { + sum += 9.680100000000e-04; + } else { + sum += 2.699925714286e-04; + } + } + } else { + if (f107_smooth <= 220.75000000) { + if (f107_smooth <= 211.75000000) { + sum += 1.186669500000e-04; + } else { + sum += 4.244590909091e-05; + } + } else { + if (f107_smooth <= 224.69999695) { + sum += 2.006418222222e-04; + } else { + sum += 9.792507142857e-05; + } + } + } + } + } + } + // Tree 8 + { + if (f107 <= 112.90000153) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + sum += -1.431442857143e-04; + } else { + sum += -6.250987500000e-05; + } + } else { + if (f107_smooth <= 74.85000229) { + sum += 9.585216842105e-05; + } else { + sum += 2.329009355433e-06; + } + } + } else { + if (f107 <= 94.34999847) { + if (f107 <= 91.60000229) { + sum += 7.981680000000e-05; + } else { + sum += 1.791240000000e-04; + } + } else { + if (f107_smooth <= 87.94999695) { + sum += 9.753987600000e-05; + } else { + sum += -6.388871428571e-05; + } + } + } + } else { + if (f107 <= 102.85000229) { + if (f107 <= 93.15000153) { + if (f107_smooth <= 96.64999771) { + sum += -7.104500000000e-05; + } else { + sum += -1.309134705882e-04; + } + } else { + if (f107_smooth <= 113.29999924) { + sum += -1.981826928571e-05; + } else { + sum += -8.487594824561e-05; + } + } + } else { + if (f107_smooth <= 112.44999695) { + if (f107_smooth <= 106.64999771) { + sum += 4.293420000000e-05; + } else { + sum += 1.638347058824e-04; + } + } else { + if (f107_smooth <= 133.69999695) { + sum += 2.593437972973e-05; + } else { + sum += -1.000038461538e-04; + } + } + } + } + } else { + if (f107_smooth <= 194.00000000) { + if (f107_smooth <= 147.75000000) { + if (f107_smooth <= 128.15000153) { + if (f107 <= 134.34999847) { + sum += 9.038227175141e-05; + } else { + sum += 1.975542419355e-04; + } + } else { + if (f107 <= 147.94999695) { + sum += 6.328099040179e-05; + } else { + sum += -6.123657949438e-06; + } + } + } else { + if (f107_smooth <= 190.25000000) { + if (f107 <= 202.59999847) { + sum += 9.490289350864e-05; + } else { + sum += 1.948290088710e-04; + } + } else { + if (f107 <= 172.69999695) { + sum += 1.367369965517e-04; + } else { + sum += -3.874963766667e-05; + } + } + } + } else { + if (f107 <= 232.90000153) { + if (f107 <= 177.94999695) { + if (f107_smooth <= 200.90000153) { + sum += 1.813651677419e-04; + } else { + sum += 2.658178082192e-04; + } + } else { + if (f107 <= 210.79999542) { + sum += 1.158458684211e-04; + } else { + sum += 2.253406781609e-04; + } + } + } else { + if (f107_smooth <= 220.75000000) { + if (f107 <= 238.34999847) { + sum += -3.741245454545e-05; + } else { + sum += 9.238677884615e-05; + } + } else { + if (f107_smooth <= 224.34999847) { + sum += 1.845569166667e-04; + } else { + sum += 8.955184210526e-05; + } + } + } + } + } + } + // Tree 9 + { + if (f107_smooth <= 194.00000000) { + if (f107 <= 112.90000153) { + if (f107_smooth <= 109.39999771) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 96.54999924) { + sum += 9.692588206687e-06; + } else { + sum += -1.264365652174e-04; + } + } else { + if (f107 <= 93.64999771) { + sum += 1.722200256410e-04; + } else { + sum += 6.109351923077e-05; + } + } + } else { + if (f107 <= 108.00000000) { + if (f107_smooth <= 120.54999924) { + sum += -1.036125310294e-04; + } else { + sum += -6.087840595238e-05; + } + } else { + if (f107_smooth <= 135.30000305) { + sum += 3.329343183333e-05; + } else { + sum += -1.241187500000e-04; + } + } + } + } else { + if (f107_smooth <= 128.25000000) { + if (f107 <= 134.34999847) { + if (f107_smooth <= 127.35000229) { + sum += 8.168042638037e-05; + } else { + sum += 2.005500000000e-04; + } + } else { + if (f107_smooth <= 127.75000000) { + sum += 2.017422153846e-04; + } else { + sum += 9.559727272727e-05; + } + } + } else { + if (f107_smooth <= 147.25000000) { + if (f107 <= 143.09999847) { + sum += 6.196658836478e-05; + } else { + sum += -1.724208728774e-05; + } + } else { + if (f107_smooth <= 190.50000000) { + sum += 8.495173193738e-05; + } else { + sum += 1.623727607477e-05; + } + } + } + } + } else { + if (f107 <= 233.25000000) { + if (f107 <= 165.80000305) { + if (f107_smooth <= 200.34999847) { + if (f107 <= 161.75000000) { + sum += 2.208700000000e-04; + } else { + sum += 5.810066666667e-05; + } + } else { + if (f107_smooth <= 203.65000153) { + sum += 2.665466666667e-04; + } else { + sum += 3.275580952381e-04; + } + } + } else { + if (f107 <= 210.79999542) { + if (f107 <= 177.94999695) { + sum += 2.129981686747e-04; + } else { + sum += 1.179330457143e-04; + } + } else { + if (f107_smooth <= 208.69999695) { + sum += 3.078181000000e-04; + } else { + sum += 1.825373090909e-04; + } + } + } + } else { + if (f107_smooth <= 221.55000305) { + if (f107 <= 273.39999390) { + if (f107_smooth <= 220.59999847) { + sum += 6.225493333333e-05; + } else { + sum += 1.585122000000e-04; + } + } else { + if (f107_smooth <= 210.75000000) { + sum += 3.354080000000e-04; + } else { + sum += 1.074610416667e-04; + } + } + } else { + if (f107_smooth <= 224.34999847) { + if (f107 <= 324.00000763) { + sum += 1.866110588235e-04; + } else { + sum += 2.807366666667e-04; + } + } else { + if (f107 <= 245.50000000) { + sum += 1.139898571429e-04; + } else { + sum += 5.831175000000e-05; + } + } + } + } + } + } + return sum / 10; +} diff --git a/rf_model_full.h b/rf_model_full.h new file mode 100644 index 0000000..8a5ecf4 --- /dev/null +++ b/rf_model_full.h @@ -0,0 +1,14926 @@ + +/* Auto-generated Full Random Forest (B* Predictor) */ +double PredictBStarFull(double f107, double f107_smooth, double ap, double beta) { + double sum = 0; + // Tree 0 + { + if (f107 <= 114.20000076) { + if (f107_smooth <= 74.25000000) { + if (beta <= 29.58001232) { + if (beta <= 29.37145329) { + sum += -8.193200000000e-05; + } else { + if (ap <= 2.00000000) { + sum += -1.106800000000e-04; + } else { + if (beta <= 29.50582695) { + sum += -1.224800000000e-04; + } else { + sum += -1.278200000000e-04; + } + } + } + } else { + if (beta <= 29.98411846) { + if (f107 <= 78.70000076) { + if (beta <= 29.73989391) { + sum += -1.546400000000e-04; + } else { + if (beta <= 29.83047009) { + if (f107 <= 76.54999924) { + sum += -1.608800000000e-04; + } else { + sum += -1.577800000000e-04; + } + } else { + sum += -1.576925000000e-04; + } + } + } else { + sum += -1.473500000000e-04; + } + } else { + if (beta <= 30.05796814) { + sum += -1.463500000000e-04; + } else { + sum += -1.363500000000e-04; + } + } + } + } else { + if (ap <= 22.50000000) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (beta <= 20.02822018) { + if (beta <= 19.99833488) { + if (f107_smooth <= 78.04999924) { + sum += 1.686360000000e-04; + } else { + sum += 2.053916666667e-04; + } + } else { + if (f107_smooth <= 78.09999847) { + sum += 9.270800000000e-05; + } else { + sum += 1.323400000000e-04; + } + } + } else { + if (beta <= 23.96199417) { + if (ap <= 3.50000000) { + sum += 4.050934444444e-05; + } else { + sum += -6.205097380952e-05; + } + } else { + if (beta <= 24.19372082) { + sum += 1.383917745455e-04; + } else { + sum += 8.746072818792e-06; + } + } + } + } else { + if (f107 <= 96.60000229) { + if (ap <= 15.00000000) { + if (f107 <= 94.34999847) { + sum += 1.800034242424e-04; + } else { + sum += 8.289516666667e-05; + } + } else { + if (beta <= 23.95083904) { + sum += 2.458800000000e-04; + } else { + sum += 2.684000000000e-04; + } + } + } else { + if (ap <= 7.00000000) { + if (f107_smooth <= 85.09999847) { + sum += 4.617772500000e-05; + } else { + sum += -3.171032500000e-05; + } + } else { + if (f107_smooth <= 85.14999771) { + sum += 9.858366666667e-05; + } else { + sum += 1.841500000000e-04; + } + } + } + } + } else { + if (f107 <= 102.85000229) { + if (ap <= 6.50000000) { + if (beta <= 30.62784386) { + if (ap <= 3.50000000) { + sum += -1.330742307692e-04; + } else { + sum += -1.048590940000e-04; + } + } else { + if (f107_smooth <= 113.05000305) { + sum += 3.441175333333e-05; + } else { + sum += -1.457600000000e-04; + } + } + } else { + if (beta <= 20.38100624) { + if (beta <= 20.06789875) { + sum += 3.208700000000e-05; + } else { + sum += 1.060801666667e-04; + } + } else { + if (beta <= 23.05671215) { + sum += -1.081006666667e-04; + } else { + sum += -4.603118412698e-05; + } + } + } + } else { + if (f107_smooth <= 133.69999695) { + if (beta <= 31.22574806) { + if (f107_smooth <= 122.25000000) { + sum += -9.805607575758e-06; + } else { + sum += 9.782789431034e-05; + } + } else { + if (beta <= 31.26287079) { + sum += 1.731000000000e-04; + } else { + sum += 2.239562500000e-04; + } + } + } else { + if (ap <= 17.50000000) { + if (ap <= 14.00000000) { + sum += -9.806450000000e-05; + } else { + sum += -5.624800000000e-05; + } + } else { + if (beta <= 25.28026485) { + sum += -1.265200000000e-04; + } else { + sum += -1.294500000000e-04; + } + } + } + } + } + } else { + if (f107 <= 73.50000000) { + sum += -1.464700000000e-04; + } else { + if (f107_smooth <= 133.90000153) { + if (ap <= 27.50000000) { + if (beta <= 25.96990776) { + if (beta <= 23.89652538) { + sum += 2.291766666667e-04; + } else { + sum += 2.236400000000e-04; + } + } else { + if (f107_smooth <= 91.19999695) { + sum += 2.009700000000e-04; + } else { + sum += 1.883200000000e-04; + } + } + } else { + if (beta <= 24.46487617) { + if (ap <= 59.00000000) { + sum += 1.226328571429e-04; + } else { + sum += 2.053920000000e-04; + } + } else { + sum += 2.116700000000e-05; + } + } + } else { + sum += -1.364000000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 194.75000000) { + if (ap <= 65.00000000) { + if (f107 <= 119.79999924) { + if (beta <= 24.62429428) { + if (f107_smooth <= 151.59999847) { + if (f107_smooth <= 138.59999847) { + if (beta <= 21.38695431) { + sum += -4.935821052632e-05; + } else { + sum += 1.433123976744e-04; + } + } else { + if (beta <= 20.70296192) { + sum += 2.418218181818e-04; + } else { + sum += 1.485941363636e-04; + } + } + } else { + if (f107 <= 118.29999924) { + if (ap <= 12.00000000) { + sum += -9.058950000000e-05; + } else { + sum += -1.159700000000e-04; + } + } else { + if (ap <= 10.00000000) { + sum += -1.707900000000e-05; + } else { + sum += 9.082100000000e-06; + } + } + } + } else { + if (f107 <= 119.20000076) { + if (f107 <= 118.25000000) { + if (ap <= 4.50000000) { + sum += 1.327833333333e-04; + } else { + sum += 2.120943243243e-04; + } + } else { + if (ap <= 20.50000000) { + sum += 1.753708333333e-04; + } else { + sum += -1.383900000000e-04; + } + } + } else { + if (beta <= 28.90271664) { + if (beta <= 26.20371628) { + sum += 2.614420000000e-04; + } else { + sum += 2.510520000000e-04; + } + } else { + if (beta <= 30.28211498) { + sum += 2.135300000000e-04; + } else { + sum += 2.178166666667e-04; + } + } + } + } + } else { + if (f107_smooth <= 128.25000000) { + if (beta <= 30.57057762) { + if (f107 <= 134.34999847) { + if (beta <= 24.48844242) { + sum += 3.722870909091e-05; + } else { + sum += 1.564229069767e-04; + } + } else { + if (ap <= 9.50000000) { + sum += 1.694875370370e-04; + } else { + sum += 2.306702631579e-04; + } + } + } else { + if (f107_smooth <= 108.65000153) { + if (beta <= 31.32366371) { + sum += 2.389900000000e-05; + } else { + sum += 1.381933333333e-04; + } + } else { + if (beta <= 31.24330902) { + sum += -1.147480000000e-04; + } else { + sum += -5.389200000000e-05; + } + } + } + } else { + if (f107_smooth <= 147.25000000) { + if (f107 <= 147.94999695) { + if (f107_smooth <= 129.05000305) { + sum += 1.822418125000e-04; + } else { + sum += 5.837697727273e-05; + } + } else { + if (ap <= 3.50000000) { + sum += 1.159415000000e-04; + } else { + sum += -2.782758412879e-05; + } + } + } else { + if (beta <= 22.79345798) { + if (beta <= 21.51256084) { + sum += 8.039548669951e-05; + } else { + sum += -3.523122691358e-05; + } + } else { + if (beta <= 24.49842930) { + sum += 1.480681105167e-04; + } else { + sum += 7.718721364271e-05; + } + } + } + } + } + } else { + if (f107 <= 175.20000458) { + if (ap <= 114.00000000) { + if (beta <= 25.75522709) { + if (beta <= 23.39489841) { + if (f107 <= 138.44999695) { + sum += 1.900200000000e-04; + } else { + sum += 2.537133333333e-04; + } + } else { + if (beta <= 23.97583103) { + sum += 1.270200000000e-04; + } else { + sum += 1.121200000000e-04; + } + } + } else { + if (ap <= 82.00000000) { + if (beta <= 27.52500534) { + sum += 3.197400000000e-04; + } else { + sum += 3.100400000000e-04; + } + } else { + sum += 2.967500000000e-04; + } + } + } else { + sum += -2.019100000000e-05; + } + } else { + if (f107 <= 204.40000153) { + if (f107_smooth <= 157.25000000) { + if (beta <= 24.30885887) { + sum += 3.138300000000e-04; + } else { + sum += 3.073200000000e-04; + } + } else { + sum += 2.686400000000e-04; + } + } else { + if (f107_smooth <= 176.65000153) { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } else { + if (beta <= 20.98794746) { + sum += 4.078500000000e-04; + } else { + sum += 4.060400000000e-04; + } + } + } + } + } + } else { + if (ap <= 16.00000000) { + if (f107 <= 182.34999847) { + if (ap <= 11.50000000) { + if (ap <= 7.50000000) { + if (f107_smooth <= 215.75000000) { + if (beta <= 24.50383282) { + sum += 2.815637250000e-04; + } else { + sum += 2.150891172414e-04; + } + } else { + if (beta <= 22.73404121) { + sum += 1.149100000000e-04; + } else { + sum += 1.309900000000e-04; + } + } + } else { + if (f107 <= 181.65000153) { + if (beta <= 21.40720940) { + sum += 2.337228571429e-04; + } else { + sum += 1.473365217391e-04; + } + } else { + if (beta <= 24.25269032) { + sum += 3.269700000000e-04; + } else { + sum += 3.191600000000e-04; + } + } + } + } else { + if (beta <= 24.19042492) { + if (beta <= 23.95845222) { + sum += 4.054200000000e-04; + } else { + if (f107 <= 166.44999695) { + sum += 4.097100000000e-04; + } else { + sum += 4.133933333333e-04; + } + } + } else { + if (beta <= 24.42575359) { + if (beta <= 24.40882683) { + sum += 2.409000000000e-04; + } else { + sum += 2.585300000000e-04; + } + } else { + sum += 2.829300000000e-04; + } + } + } + } else { + if (f107_smooth <= 217.84999847) { + if (beta <= 25.84501934) { + if (f107 <= 196.04999542) { + if (ap <= 4.50000000) { + sum += 3.098600000000e-04; + } else { + sum += 1.068877307692e-04; + } + } else { + if (f107 <= 242.09999847) { + sum += 2.139764285714e-05; + } else { + sum += 9.981968571429e-05; + } + } + } else { + if (ap <= 9.50000000) { + if (beta <= 27.30722427) { + sum += 2.798500000000e-04; + } else { + sum += 1.716666666667e-04; + } + } else { + sum += 4.669000000000e-04; + } + } + } else { + if (f107 <= 247.20000458) { + if (beta <= 24.55752945) { + if (beta <= 24.36679935) { + sum += 2.362361904762e-04; + } else { + sum += 2.928533333333e-04; + } + } else { + if (beta <= 24.59099674) { + sum += 1.286822222222e-04; + } else { + sum += 6.644300000000e-05; + } + } + } else { + if (f107 <= 304.35000610) { + if (f107 <= 247.75000000) { + sum += 9.219200000000e-05; + } else { + sum += 4.758753333333e-05; + } + } else { + if (f107_smooth <= 221.04999542) { + sum += 1.274300000000e-05; + } else { + sum += 3.253200000000e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 208.69999695) { + if (f107_smooth <= 207.34999847) { + if (beta <= 22.41676426) { + if (beta <= 20.86458969) { + sum += 1.181900000000e-04; + } else { + if (beta <= 20.88193989) { + sum += 1.299000000000e-04; + } else { + sum += 1.321100000000e-04; + } + } + } else { + if (beta <= 23.94521427) { + sum += 2.630300000000e-04; + } else { + if (f107_smooth <= 205.19999695) { + sum += 3.159260000000e-04; + } else { + sum += 2.824350000000e-04; + } + } + } + } else { + if (beta <= 24.07762814) { + sum += 3.061900000000e-04; + } else { + if (beta <= 24.08898258) { + if (beta <= 24.08308125) { + sum += 1.397800000000e-03; + } else { + sum += 1.384500000000e-03; + } + } else { + sum += 4.126900000000e-04; + } + } + } + } else { + if (ap <= 24.50000000) { + if (f107_smooth <= 218.00000000) { + if (beta <= 24.54215336) { + if (beta <= 24.52197170) { + sum += 3.342133333333e-04; + } else { + sum += 2.685700000000e-04; + } + } else { + sum += 3.643400000000e-04; + } + } else { + if (beta <= 24.55287647) { + if (beta <= 23.06051731) { + sum += 1.915000000000e-04; + } else { + sum += 2.754207692308e-04; + } + } else { + if (ap <= 21.00000000) { + sum += 2.150025000000e-04; + } else { + sum += 1.994300000000e-04; + } + } + } + } else { + if (f107 <= 256.59999847) { + if (f107_smooth <= 218.15000153) { + if (f107 <= 169.79999542) { + sum += 2.751600000000e-04; + } else { + sum += 2.035442857143e-04; + } + } else { + if (beta <= 24.38342190) { + sum += 1.225900000000e-04; + } else { + sum += 1.670028571429e-04; + } + } + } else { + if (beta <= 23.94080830) { + if (beta <= 23.91534233) { + sum += 1.206600000000e-05; + } else { + sum += 1.645100000000e-04; + } + } else { + if (beta <= 23.96580505) { + sum += 7.163500000000e-06; + } else { + sum += 4.803900000000e-05; + } + } + } + } + } + } + } + } + } + // Tree 1 + { + if (f107 <= 108.65000153) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (beta <= 20.02267075) { + if (beta <= 19.98960400) { + if (f107 <= 76.29999924) { + if (beta <= 19.98881531) { + sum += 2.069800000000e-04; + } else { + sum += 2.073600000000e-04; + } + } else { + if (beta <= 19.98829079) { + if (beta <= 19.98814678) { + sum += 1.980100000000e-04; + } else { + sum += 2.046800000000e-04; + } + } else { + sum += 1.942400000000e-04; + } + } + } else { + if (ap <= 8.00000000) { + if (f107 <= 76.85000229) { + if (ap <= 4.50000000) { + sum += 1.756780000000e-04; + } else { + sum += 1.343000000000e-04; + } + } else { + if (beta <= 19.99444103) { + sum += 1.542500000000e-04; + } else { + sum += 1.407750000000e-04; + } + } + } else { + sum += 9.173500000000e-05; + } + } + } else { + if (f107_smooth <= 74.35000229) { + if (beta <= 29.24877453) { + if (beta <= 29.14603329) { + sum += -1.743100000000e-05; + } else { + sum += -3.466700000000e-05; + } + } else { + if (beta <= 30.11131477) { + if (ap <= 4.00000000) { + sum += -1.158237500000e-04; + } else { + sum += -1.515770000000e-04; + } + } else { + if (ap <= 19.50000000) { + sum += -1.091200000000e-04; + } else { + sum += -7.078700000000e-05; + } + } + } + } else { + if (f107_smooth <= 74.85000229) { + if (f107 <= 71.50000000) { + if (beta <= 25.29609585) { + sum += 7.409814285714e-05; + } else { + sum += -3.449933333333e-05; + } + } else { + if (beta <= 27.42820072) { + sum += 8.519789473684e-06; + } else { + sum += 1.440186792453e-04; + } + } + } else { + if (f107_smooth <= 79.35000229) { + if (f107_smooth <= 77.14999771) { + sum += 1.970603941606e-05; + } else { + sum += -9.140830306122e-05; + } + } else { + if (f107_smooth <= 81.25000000) { + sum += 9.286283265306e-05; + } else { + sum += -3.188050227273e-06; + } + } + } + } + } + } else { + if (ap <= 8.50000000) { + if (ap <= 5.50000000) { + if (f107 <= 93.64999771) { + if (f107 <= 93.00000000) { + if (ap <= 3.50000000) { + sum += 2.192900000000e-04; + } else { + sum += 2.136900000000e-04; + } + } else { + if (beta <= 23.76582813) { + sum += 1.815600000000e-04; + } else { + sum += 1.939700000000e-04; + } + } + } else { + if (f107_smooth <= 79.35000229) { + if (beta <= 21.14352608) { + sum += 7.036300000000e-05; + } else { + sum += 4.990500000000e-05; + } + } else { + if (beta <= 21.03121662) { + sum += 1.548633333333e-04; + } else { + sum += 1.136867500000e-04; + } + } + } + } else { + if (beta <= 24.04218864) { + sum += 2.271200000000e-04; + } else { + if (beta <= 24.38927841) { + if (beta <= 24.19465733) { + sum += -7.454900000000e-05; + } else { + sum += -3.530400000000e-05; + } + } else { + if (beta <= 24.54689693) { + sum += 1.903350000000e-04; + } else { + sum += 3.117786250000e-05; + } + } + } + } + } else { + if (f107 <= 98.20000076) { + if (f107 <= 91.79999924) { + if (beta <= 24.00835419) { + sum += 1.821400000000e-04; + } else { + sum += 1.525000000000e-04; + } + } else { + if (f107 <= 95.04999924) { + if (beta <= 24.62148857) { + sum += 1.933500000000e-04; + } else { + sum += 2.073033333333e-04; + } + } else { + if (beta <= 23.94188595) { + sum += 2.429400000000e-04; + } else { + sum += 2.468600000000e-04; + } + } + } + } else { + sum += 1.005300000000e-04; + } + } + } + } else { + if (beta <= 31.13693333) { + if (ap <= 14.50000000) { + if (beta <= 29.71805382) { + if (ap <= 6.50000000) { + if (f107 <= 99.29999924) { + if (f107_smooth <= 96.64999771) { + sum += -6.658700000000e-05; + } else { + sum += -1.251283076923e-04; + } + } else { + if (beta <= 28.08111095) { + sum += -1.107232903226e-04; + } else { + sum += -6.987800000000e-05; + } + } + } else { + if (f107 <= 107.34999847) { + if (ap <= 11.50000000) { + sum += -5.577939122807e-05; + } else { + sum += -1.189153000000e-04; + } + } else { + sum += 1.939100000000e-04; + } + } + } else { + if (f107_smooth <= 109.20000076) { + if (beta <= 29.92232704) { + if (f107_smooth <= 106.40000153) { + sum += -4.723460000000e-06; + } else { + sum += 4.958300000000e-05; + } + } else { + if (f107_smooth <= 106.54999924) { + sum += 6.387400000000e-05; + } else { + sum += 1.066025000000e-04; + } + } + } else { + if (ap <= 5.50000000) { + if (f107 <= 94.25000000) { + sum += 3.363926666667e-06; + } else { + sum += -3.882900000000e-05; + } + } else { + if (f107_smooth <= 114.75000000) { + sum += -7.907523076923e-05; + } else { + sum += -1.492366666667e-04; + } + } + } + } + } else { + if (beta <= 24.05561352) { + if (f107_smooth <= 125.60000229) { + if (beta <= 20.87411022) { + if (f107_smooth <= 123.60000229) { + sum += -3.784750000000e-05; + } else { + sum += 1.050800000000e-05; + } + } else { + if (beta <= 21.11742210) { + sum += -1.322700000000e-04; + } else { + sum += -1.024000000000e-04; + } + } + } else { + if (f107_smooth <= 128.89999771) { + if (f107_smooth <= 127.35000229) { + sum += 8.356960000000e-05; + } else { + sum += 1.329600000000e-04; + } + } else { + if (beta <= 23.89597321) { + sum += 2.327900000000e-04; + } else { + sum += 2.236400000000e-04; + } + } + } + } else { + if (f107_smooth <= 111.09999847) { + sum += 1.978400000000e-04; + } else { + if (beta <= 25.13239861) { + if (beta <= 24.62757587) { + sum += -1.104754000000e-04; + } else { + sum += -5.075333333333e-07; + } + } else { + if (ap <= 21.00000000) { + sum += -1.339000000000e-04; + } else { + sum += -1.041100000000e-04; + } + } + } + } + } + } else { + if (f107_smooth <= 109.50000000) { + if (f107 <= 105.95000076) { + sum += 2.049000000000e-04; + } else { + if (beta <= 31.25451756) { + sum += 1.731000000000e-04; + } else { + sum += 1.847700000000e-04; + } + } + } else { + if (beta <= 31.17625332) { + if (beta <= 31.15727615) { + sum += 4.015400000000e-05; + } else { + sum += 5.871200000000e-05; + } + } else { + sum += 8.692000000000e-05; + } + } + } + } + } else { + if (f107_smooth <= 194.50000000) { + if (ap <= 71.00000000) { + if (f107_smooth <= 190.25000000) { + if (f107 <= 189.80000305) { + if (f107_smooth <= 186.34999847) { + if (f107_smooth <= 178.75000000) { + if (beta <= 26.45484734) { + sum += 7.180971679272e-05; + } else { + sum += 9.877143006579e-05; + } + } else { + if (beta <= 20.04585838) { + sum += 1.429625000000e-04; + } else { + sum += -3.186098148148e-05; + } + } + } else { + if (f107 <= 179.34999847) { + sum += 2.623200000000e-04; + } else { + if (ap <= 26.50000000) { + sum += 2.968475000000e-04; + } else { + sum += 3.104700000000e-04; + } + } + } + } else { + if (f107_smooth <= 153.54999542) { + if (beta <= 25.73544979) { + if (beta <= 24.66007233) { + sum += 6.508150000000e-05; + } else { + sum += -1.014776200000e-05; + } + } else { + if (beta <= 27.31805706) { + sum += -6.221380000000e-05; + } else { + sum += -2.633340000000e-05; + } + } + } else { + if (beta <= 29.85990715) { + if (ap <= 8.50000000) { + sum += 1.788220776316e-04; + } else { + sum += 2.808005531915e-04; + } + } else { + if (f107_smooth <= 179.65000153) { + sum += 3.568346666667e-05; + } else { + sum += 2.328322222222e-04; + } + } + } + } + } else { + if (f107 <= 172.69999695) { + if (f107 <= 171.09999847) { + if (beta <= 29.94493294) { + if (beta <= 28.22535229) { + sum += 7.289917894737e-05; + } else { + sum += 1.738424166667e-04; + } + } else { + if (ap <= 4.00000000) { + sum += 1.727700000000e-04; + } else { + sum += 1.033496666667e-05; + } + } + } else { + if (f107_smooth <= 191.75000000) { + sum += 2.452500000000e-04; + } else { + if (beta <= 29.38366699) { + sum += 2.964600000000e-04; + } else { + sum += 2.928600000000e-04; + } + } + } + } else { + if (ap <= 26.00000000) { + if (beta <= 30.81856155) { + if (f107_smooth <= 194.00000000) { + sum += -6.276982000000e-05; + } else { + sum += 6.940683333333e-05; + } + } else { + if (f107_smooth <= 191.80000305) { + sum += 9.620250000000e-05; + } else { + sum += 3.794625000000e-05; + } + } + } else { + if (beta <= 29.20348167) { + sum += 3.341400000000e-04; + } else { + sum += 3.295700000000e-04; + } + } + } + } + } else { + if (f107 <= 153.90000153) { + if (beta <= 22.00229168) { + sum += -1.091900000000e-04; + } else { + sum += 1.270200000000e-04; + } + } else { + if (f107 <= 200.40000153) { + if (ap <= 82.50000000) { + if (beta <= 25.90590000) { + if (beta <= 24.30743790) { + sum += 3.115766666667e-04; + } else { + sum += 3.073200000000e-04; + } + } else { + if (beta <= 27.52500534) { + sum += 3.197400000000e-04; + } else { + sum += 3.100400000000e-04; + } + } + } else { + if (beta <= 30.57476807) { + sum += 2.934200000000e-04; + } else { + sum += 2.967500000000e-04; + } + } + } else { + if (ap <= 188.00000000) { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } else { + if (beta <= 21.00016785) { + if (beta <= 20.98794746) { + sum += 4.078500000000e-04; + } else { + sum += 4.060400000000e-04; + } + } else { + sum += 4.032800000000e-04; + } + } + } + } + } + } else { + if (ap <= 10.50000000) { + if (f107 <= 183.90000153) { + if (ap <= 6.50000000) { + if (f107_smooth <= 215.75000000) { + if (f107 <= 176.19999695) { + if (f107_smooth <= 201.20000458) { + sum += 2.033092000000e-04; + } else { + sum += 2.677561111111e-04; + } + } else { + if (beta <= 22.79891396) { + sum += 1.257600000000e-04; + } else { + sum += 3.134090000000e-04; + } + } + } else { + if (ap <= 4.50000000) { + if (beta <= 22.71992493) { + sum += 1.149100000000e-04; + } else { + sum += 1.170100000000e-04; + } + } else { + sum += 1.320100000000e-04; + } + } + } else { + if (f107_smooth <= 201.19999695) { + if (beta <= 25.81258297) { + if (f107_smooth <= 200.25000000) { + sum += 6.242966666667e-05; + } else { + sum += -2.325528571429e-06; + } + } else { + if (beta <= 26.82339287) { + sum += 1.709900000000e-04; + } else { + sum += 1.437900000000e-04; + } + } + } else { + if (f107 <= 181.65000153) { + if (beta <= 21.43342304) { + sum += 2.667460000000e-04; + } else { + sum += 1.521341666667e-04; + } + } else { + if (beta <= 24.25994873) { + sum += 3.293400000000e-04; + } else { + sum += 3.191600000000e-04; + } + } + } + } + } else { + if (beta <= 22.55330467) { + if (f107 <= 208.04999542) { + if (beta <= 22.51808071) { + if (beta <= 21.76688671) { + sum += 3.993200000000e-05; + } else { + sum += 1.960055000000e-05; + } + } else { + sum += 5.168600000000e-05; + } + } else { + if (f107 <= 228.84999847) { + if (beta <= 22.29697800) { + sum += -9.342428571429e-06; + } else { + sum += -2.732350000000e-05; + } + } else { + if (f107 <= 236.09999847) { + sum += -5.378820000000e-05; + } else { + sum += -2.779750000000e-05; + } + } + } + } else { + if (beta <= 24.59291744) { + if (f107 <= 239.90000153) { + if (f107_smooth <= 220.65000153) { + sum += 1.341674583333e-04; + } else { + sum += 2.669810344828e-04; + } + } else { + if (beta <= 23.53583527) { + sum += 2.225350000000e-04; + } else { + sum += 8.234876744186e-05; + } + } + } else { + if (beta <= 25.56192207) { + if (beta <= 24.60469913) { + sum += 6.440566666667e-05; + } else { + sum += 2.303460526316e-05; + } + } else { + if (beta <= 28.44793034) { + sum += 1.034838571429e-04; + } else { + sum += 1.546816666667e-04; + } + } + } + } + } + } else { + if (f107 <= 223.19999695) { + if (ap <= 89.00000000) { + if (f107 <= 172.19999695) { + if (beta <= 24.19013214) { + if (beta <= 23.95610619) { + sum += 3.355900000000e-04; + } else { + sum += 4.069600000000e-04; + } + } else { + if (f107 <= 170.59999847) { + sum += 2.923478947368e-04; + } else { + sum += 1.088050000000e-04; + } + } + } else { + if (f107 <= 206.54999542) { + if (f107 <= 174.00000000) { + sum += 2.304070000000e-04; + } else { + sum += 1.449247647059e-04; + } + } else { + if (beta <= 28.76688957) { + sum += 2.640094736842e-04; + } else { + sum += 3.326800000000e-04; + } + } + } + } else { + if (f107_smooth <= 207.34999847) { + sum += 2.984300000000e-04; + } else { + sum += 1.397800000000e-03; + } + } + } else { + if (f107 <= 274.69999695) { + if (f107 <= 253.05000305) { + if (f107_smooth <= 202.75000000) { + sum += 3.269300000000e-04; + } else { + if (beta <= 23.39034462) { + sum += 2.674300000000e-04; + } else { + sum += 1.299048333333e-04; + } + } + } else { + if (ap <= 71.50000000) { + if (f107_smooth <= 203.45000458) { + sum += 3.824100000000e-05; + } else { + sum += 5.444685714286e-05; + } + } else { + sum += 7.163500000000e-06; + } + } + } else { + if (beta <= 24.13595867) { + if (ap <= 25.00000000) { + if (beta <= 23.18960953) { + sum += 2.765300000000e-04; + } else { + sum += 2.828400000000e-04; + } + } else { + if (beta <= 24.01689816) { + sum += 1.206600000000e-05; + } else { + sum += 1.582000000000e-04; + } + } + } else { + sum += 5.615000000000e-04; + } + } + } + } + } + } + } + // Tree 2 + { + if (f107 <= 111.79999924) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 80.35000229) { + if (beta <= 23.91335011) { + if (f107_smooth <= 78.59999847) { + if (beta <= 21.85490704) { + if (beta <= 20.69243145) { + if (beta <= 20.03693485) { + sum += 1.292678181818e-04; + } else { + sum += -8.967633333333e-05; + } + } else { + if (beta <= 21.50393105) { + sum += 1.631249545455e-04; + } else { + sum += 5.778833333333e-05; + } + } + } else { + if (beta <= 23.42016220) { + if (f107 <= 74.10000229) { + sum += -6.093540000000e-05; + } else { + sum += -1.073046000000e-04; + } + } else { + if (f107_smooth <= 74.95000076) { + sum += 6.734700000000e-05; + } else { + sum += 1.048400000000e-04; + } + } + } + } else { + if (f107_smooth <= 79.35000229) { + if (beta <= 21.99811935) { + if (beta <= 20.11108112) { + sum += -1.060656666667e-04; + } else { + sum += -1.423273214286e-04; + } + } else { + if (f107_smooth <= 78.95000076) { + sum += -8.083900000000e-05; + } else { + sum += -3.159250000000e-05; + } + } + } else { + if (f107_smooth <= 81.34999847) { + if (beta <= 20.45272350) { + sum += -1.129155555556e-04; + } else { + sum += 2.635750000000e-05; + } + } else { + if (beta <= 23.26982784) { + sum += -6.532400000000e-05; + } else { + sum += -1.287634285714e-04; + } + } + } + } + } else { + if (f107_smooth <= 74.35000229) { + if (beta <= 29.46872044) { + if (f107_smooth <= 74.25000000) { + if (beta <= 29.39252377) { + sum += -9.046160000000e-05; + } else { + sum += -1.106800000000e-04; + } + } else { + sum += -5.814700000000e-05; + } + } else { + if (ap <= 14.00000000) { + if (beta <= 29.56958008) { + sum += -1.288033333333e-04; + } else { + sum += -1.496780000000e-04; + } + } else { + sum += -1.035100000000e-04; + } + } + } else { + if (beta <= 31.22518253) { + if (beta <= 30.72298527) { + if (beta <= 24.30720615) { + sum += 1.352163636364e-04; + } else { + sum += 6.066334591195e-06; + } + } else { + if (f107 <= 71.14999771) { + sum += 2.502805000000e-05; + } else { + sum += 1.544555833333e-04; + } + } + } else { + if (beta <= 31.28133583) { + if (f107_smooth <= 75.40000153) { + sum += -7.384066666667e-05; + } else { + sum += -3.657950000000e-05; + } + } else { + if (f107_smooth <= 75.54999924) { + sum += -1.431691666667e-04; + } else { + sum += -1.023840000000e-04; + } + } + } + } + } + } else { + if (beta <= 24.14797497) { + if (f107_smooth <= 79.35000229) { + if (beta <= 20.06238747) { + if (f107_smooth <= 78.04999924) { + sum += 1.139200000000e-04; + } else { + sum += 1.448200000000e-04; + } + } else { + if (f107_smooth <= 79.09999847) { + if (beta <= 23.38855743) { + sum += -4.173750000000e-05; + } else { + sum += 1.217880000000e-05; + } + } else { + if (beta <= 21.18521023) { + sum += 4.995140000000e-05; + } else { + sum += 1.306113333333e-05; + } + } + } + } else { + if (beta <= 23.37366295) { + if (ap <= 3.50000000) { + if (beta <= 22.80994987) { + sum += 2.168761538462e-04; + } else { + sum += 1.581100000000e-04; + } + } else { + if (beta <= 21.01745796) { + sum += 1.642575000000e-04; + } else { + sum += 1.198535454545e-04; + } + } + } else { + if (beta <= 23.98235607) { + if (ap <= 10.00000000) { + sum += -3.356569565217e-05; + } else { + sum += 1.953600000000e-04; + } + } else { + if (f107_smooth <= 88.75000000) { + sum += 1.731972500000e-04; + } else { + sum += 1.623758333333e-05; + } + } + } + } + } else { + if (beta <= 24.53241825) { + if (beta <= 24.23757362) { + if (f107 <= 92.54999924) { + if (f107 <= 86.50000000) { + sum += 9.776600000000e-05; + } else { + sum += 3.722872000000e-05; + } + } else { + if (beta <= 24.19839191) { + sum += -7.454900000000e-05; + } else { + sum += -4.164300000000e-05; + } + } + } else { + if (f107_smooth <= 82.54999924) { + if (f107 <= 84.75000000) { + sum += 1.136130000000e-05; + } else { + sum += -5.587800000000e-05; + } + } else { + if (f107 <= 92.59999847) { + sum += -1.307451562500e-04; + } else { + sum += -5.480200000000e-05; + } + } + } + } else { + if (ap <= 5.50000000) { + if (beta <= 24.98349285) { + if (ap <= 4.50000000) { + sum += 1.438714285714e-04; + } else { + sum += 2.006700000000e-04; + } + } else { + if (beta <= 25.07723522) { + sum += 1.821700000000e-04; + } else { + sum += 2.114375000000e-04; + } + } + } else { + if (ap <= 7.50000000) { + if (f107_smooth <= 82.70000076) { + sum += -1.555553333333e-05; + } else { + sum += 6.477000000000e-05; + } + } else { + if (f107 <= 88.29999924) { + sum += 5.768950000000e-05; + } else { + sum += 1.326408000000e-04; + } + } + } + } + } + } + } else { + if (f107 <= 107.45000076) { + if (beta <= 31.13693333) { + if (ap <= 6.50000000) { + if (f107 <= 99.00000000) { + if (beta <= 30.86555576) { + if (f107_smooth <= 96.64999771) { + sum += -7.280933333333e-05; + } else { + sum += -1.301282745098e-04; + } + } else { + if (f107 <= 94.25000000) { + sum += 7.712963333333e-06; + } else { + sum += -3.882900000000e-05; + } + } + } else { + if (f107 <= 99.60000229) { + if (beta <= 30.63097477) { + sum += 1.417000000000e-04; + } else { + sum += 1.327300000000e-04; + } + } else { + if (beta <= 29.58020401) { + sum += -9.596984848485e-05; + } else { + sum += -2.770425000000e-05; + } + } + } + } else { + if (beta <= 20.37722015) { + if (f107 <= 98.20000076) { + if (f107_smooth <= 127.25000000) { + sum += -2.167600000000e-05; + } else { + sum += -1.288400000000e-04; + } + } else { + if (f107_smooth <= 127.15000153) { + sum += 5.201400000000e-05; + } else { + sum += 9.514560000000e-05; + } + } + } else { + if (f107 <= 105.45000076) { + if (ap <= 8.50000000) { + sum += -2.675514242424e-05; + } else { + sum += -9.035722916667e-05; + } + } else { + if (f107 <= 106.25000000) { + sum += 2.341300000000e-04; + } else { + sum += -3.339208333333e-05; + } + } + } + } + } else { + if (ap <= 11.50000000) { + if (beta <= 31.17625332) { + if (beta <= 31.15727615) { + sum += 4.015400000000e-05; + } else { + sum += 5.871200000000e-05; + } + } else { + sum += 8.692000000000e-05; + } + } else { + sum += 2.139800000000e-04; + } + } + } else { + if (ap <= 19.50000000) { + if (beta <= 23.05118275) { + if (beta <= 20.93897247) { + if (beta <= 20.33323765) { + sum += -4.183100000000e-05; + } else { + sum += 1.050800000000e-05; + } + } else { + if (f107_smooth <= 120.14999771) { + sum += -6.833400000000e-05; + } else { + if (beta <= 22.60615349) { + sum += -9.565500000000e-05; + } else { + sum += -1.079400000000e-04; + } + } + } + } else { + if (beta <= 24.39593792) { + if (f107_smooth <= 122.95000076) { + sum += 1.246500000000e-04; + } else { + if (f107_smooth <= 124.29999924) { + sum += 2.208233333333e-04; + } else { + sum += 1.993133333333e-04; + } + } + } else { + if (f107 <= 111.50000000) { + if (f107 <= 109.59999847) { + sum += -7.685714285714e-08; + } else { + sum += 9.510911111111e-05; + } + } else { + if (beta <= 26.73647308) { + sum += -1.032400000000e-04; + } else { + sum += -1.184800000000e-04; + } + } + } + } + } else { + if (beta <= 24.69374657) { + if (beta <= 24.09133530) { + sum += -1.131000000000e-04; + } else { + sum += -1.116200000000e-04; + } + } else { + if (f107 <= 109.45000076) { + if (beta <= 25.28026485) { + sum += -1.265200000000e-04; + } else { + sum += -1.294500000000e-04; + } + } else { + sum += -1.364000000000e-04; + } + } + } + } + } + } else { + if (f107_smooth <= 194.50000000) { + if (ap <= 71.00000000) { + if (f107_smooth <= 190.84999847) { + if (f107 <= 210.09999847) { + if (f107_smooth <= 186.34999847) { + if (beta <= 31.06578350) { + if (f107_smooth <= 128.40000153) { + sum += 1.482913899528e-04; + } else { + sum += 7.963085161087e-05; + } + } else { + if (f107 <= 157.94999695) { + sum += 7.781323766234e-05; + } else { + sum += -1.172976333333e-05; + } + } + } else { + if (f107_smooth <= 190.25000000) { + if (f107 <= 172.89999390) { + sum += 1.814475000000e-04; + } else { + sum += 3.018675000000e-04; + } + } else { + if (f107 <= 184.84999847) { + sum += 1.443692153846e-04; + } else { + sum += -8.548040000000e-05; + } + } + } + } else { + if (f107 <= 219.84999847) { + if (ap <= 23.00000000) { + if (f107_smooth <= 177.55000305) { + sum += 1.474754375000e-04; + } else { + sum += 2.938516666667e-04; + } + } else { + if (beta <= 27.57142639) { + sum += 3.189075000000e-04; + } else { + sum += 4.336000000000e-04; + } + } + } else { + if (ap <= 3.50000000) { + if (beta <= 23.62470913) { + sum += 3.074300000000e-04; + } else { + sum += 3.194100000000e-04; + } + } else { + if (f107 <= 266.94999695) { + sum += 9.398685641026e-05; + } else { + sum += 2.092450000000e-04; + } + } + } + } + } else { + if (f107 <= 172.69999695) { + if (f107 <= 167.50000000) { + if (beta <= 30.09517670) { + if (beta <= 23.64852428) { + sum += -4.155000000000e-05; + } else { + sum += 7.773141176471e-05; + } + } else { + if (beta <= 30.21142673) { + sum += -4.446100000000e-05; + } else { + sum += -4.894500000000e-05; + } + } + } else { + if (beta <= 28.25668240) { + if (f107 <= 169.50000000) { + sum += 5.344333333333e-05; + } else { + sum += -1.607300000000e-06; + } + } else { + if (beta <= 29.46031570) { + sum += 3.080966666667e-04; + } else { + sum += 2.199575000000e-04; + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (beta <= 30.77189636) { + if (f107 <= 245.50000000) { + sum += -6.939354166667e-05; + } else { + sum += -1.763892444444e-05; + } + } else { + if (f107 <= 209.94999695) { + sum += 7.448700000000e-05; + } else { + sum += 4.205825000000e-05; + } + } + } else { + if (beta <= 28.68055725) { + if (beta <= 24.49837017) { + sum += -1.996590000000e-05; + } else { + sum += 4.715600000000e-05; + } + } else { + if (beta <= 29.09029293) { + sum += 3.069600000000e-04; + } else { + sum += 3.379400000000e-04; + } + } + } + } + } + } else { + if (f107 <= 152.94999695) { + if (beta <= 23.95972157) { + sum += 1.270200000000e-04; + } else { + if (beta <= 23.99555206) { + sum += 1.152800000000e-04; + } else { + sum += 1.121200000000e-04; + } + } + } else { + if (beta <= 22.68579006) { + if (beta <= 21.02968311) { + sum += 4.060400000000e-04; + } else { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } + } else { + if (f107_smooth <= 162.04999542) { + if (ap <= 73.50000000) { + if (beta <= 27.52500534) { + sum += 3.197400000000e-04; + } else { + sum += 3.100400000000e-04; + } + } else { + if (beta <= 24.30885887) { + sum += 3.121200000000e-04; + } else { + sum += 3.073200000000e-04; + } + } + } else { + if (beta <= 30.57476807) { + sum += 2.934200000000e-04; + } else { + sum += 2.967500000000e-04; + } + } + } + } + } + } else { + if (f107 <= 182.34999847) { + if (beta <= 24.55337715) { + if (beta <= 23.94099426) { + if (beta <= 21.49264908) { + if (f107_smooth <= 200.45000458) { + if (beta <= 20.94289207) { + sum += 1.310050000000e-04; + } else { + sum += 1.964700000000e-04; + } + } else { + if (ap <= 3.00000000) { + sum += 2.194700000000e-04; + } else { + sum += 2.569813333333e-04; + } + } + } else { + if (beta <= 22.84548473) { + if (f107 <= 175.15000153) { + sum += 1.399600000000e-04; + } else { + sum += 1.120672500000e-04; + } + } else { + if (f107_smooth <= 203.40000153) { + sum += 1.331400000000e-04; + } else { + sum += 1.870390909091e-04; + } + } + } + } else { + if (beta <= 24.00276756) { + if (f107 <= 163.75000000) { + if (beta <= 23.94521427) { + sum += 2.630300000000e-04; + } else { + sum += 3.152600000000e-04; + } + } else { + if (beta <= 23.95482063) { + sum += 3.559200000000e-04; + } else { + sum += 4.049972222222e-04; + } + } + } else { + if (ap <= 24.00000000) { + if (beta <= 24.54215336) { + sum += 3.071626470588e-04; + } else { + sum += 3.554700000000e-04; + } + } else { + if (f107_smooth <= 216.00000000) { + sum += 2.067133333333e-04; + } else { + sum += 2.751600000000e-04; + } + } + } + } + } else { + if (ap <= 6.50000000) { + if (f107_smooth <= 199.75000000) { + if (ap <= 4.50000000) { + if (beta <= 26.62204742) { + sum += 2.370520000000e-04; + } else { + sum += 2.083100000000e-04; + } + } else { + if (f107 <= 174.79999542) { + sum += 2.627540000000e-04; + } else { + sum += 3.092900000000e-04; + } + } + } else { + if (beta <= 25.19991493) { + sum += 1.066900000000e-04; + } else { + if (beta <= 25.83577919) { + sum += 1.833600000000e-04; + } else { + sum += 1.943700000000e-04; + } + } + } + } else { + if (ap <= 13.50000000) { + if (beta <= 25.26138115) { + if (f107 <= 159.90000153) { + sum += 7.540300000000e-05; + } else { + sum += 1.174648333333e-05; + } + } else { + if (beta <= 26.89106464) { + sum += 1.465333333333e-04; + } else { + sum += 1.088050000000e-04; + } + } + } else { + if (beta <= 25.42860794) { + if (beta <= 24.55667305) { + sum += 2.159600000000e-04; + } else { + sum += 2.099500000000e-04; + } + } else { + sum += 2.973900000000e-04; + } + } + } + } + } else { + if (ap <= 16.50000000) { + if (beta <= 22.57445145) { + if (f107 <= 199.75000000) { + if (ap <= 10.50000000) { + if (beta <= 21.67646694) { + sum += 8.108000000000e-05; + } else { + sum += 5.601466666667e-05; + } + } else { + sum += 1.483800000000e-04; + } + } else { + if (f107 <= 228.50000000) { + if (f107_smooth <= 210.40000153) { + sum += 3.993200000000e-05; + } else { + sum += -8.039707142857e-06; + } + } else { + if (f107 <= 236.09999847) { + sum += -5.979545454545e-05; + } else { + sum += -2.842600000000e-05; + } + } + } + } else { + if (beta <= 28.64835548) { + if (beta <= 24.59376049) { + if (f107_smooth <= 220.75000000) { + sum += 1.079527721519e-04; + } else { + sum += 1.956201311475e-04; + } + } else { + if (f107 <= 183.90000153) { + sum += 2.868200000000e-04; + } else { + sum += 4.762240540541e-05; + } + } + } else { + sum += 4.669000000000e-04; + } + } + } else { + if (f107_smooth <= 208.69999695) { + if (f107_smooth <= 207.34999847) { + if (f107_smooth <= 204.54999542) { + if (f107 <= 215.79999542) { + sum += 2.995175000000e-04; + } else { + sum += 3.137166666667e-04; + } + } else { + if (beta <= 24.03427792) { + sum += 2.758000000000e-04; + } else { + sum += 2.699100000000e-04; + } + } + } else { + if (beta <= 24.08898258) { + if (beta <= 24.07762814) { + sum += 3.061900000000e-04; + } else { + sum += 1.391150000000e-03; + } + } else { + if (beta <= 24.09435940) { + sum += 4.126900000000e-04; + } else { + sum += 2.094900000000e-04; + } + } + } + } else { + if (f107 <= 274.69999695) { + if (ap <= 24.50000000) { + if (beta <= 24.54682922) { + sum += 2.635450000000e-04; + } else { + sum += 2.025400000000e-04; + } + } else { + if (f107_smooth <= 214.64999390) { + sum += 1.914300000000e-04; + } else { + sum += 1.134597142857e-04; + } + } + } else { + if (beta <= 24.03440285) { + if (beta <= 23.57470036) { + sum += 2.807266666667e-04; + } else { + sum += 1.645100000000e-04; + } + } else { + sum += 5.615000000000e-04; + } + } + } + } + } + } + } + } + // Tree 3 + { + if (f107 <= 108.70000076) { + if (f107_smooth <= 96.45000076) { + if (ap <= 19.50000000) { + if (f107_smooth <= 94.45000076) { + if (beta <= 20.04016781) { + if (beta <= 19.99444103) { + if (f107 <= 77.25000000) { + if (f107 <= 74.95000076) { + sum += 1.693850000000e-04; + } else { + sum += 2.057360000000e-04; + } + } else { + sum += 1.542500000000e-04; + } + } else { + if (ap <= 3.50000000) { + if (f107 <= 76.29999924) { + sum += 1.779300000000e-04; + } else { + sum += 1.367300000000e-04; + } + } else { + if (ap <= 4.50000000) { + sum += 5.880400000000e-05; + } else { + sum += 1.064428571429e-04; + } + } + } + } else { + if (beta <= 20.49999523) { + if (f107 <= 77.20000076) { + if (beta <= 20.07608032) { + sum += -3.143100000000e-05; + } else { + sum += -1.317476538462e-04; + } + } else { + if (beta <= 20.06982613) { + sum += 1.491400000000e-05; + } else { + sum += -5.958109523810e-05; + } + } + } else { + if (beta <= 21.31218910) { + if (f107 <= 75.35000229) { + sum += 3.065520000000e-05; + } else { + sum += 1.432602372917e-04; + } + } else { + if (beta <= 23.96199417) { + sum += -3.637978417722e-05; + } else { + sum += 2.114633118132e-05; + } + } + } + } + } else { + if (beta <= 25.48868656) { + if (f107 <= 91.20000076) { + if (f107 <= 85.65000153) { + sum += 1.821700000000e-04; + } else { + if (f107 <= 88.29999924) { + sum += 1.370150000000e-04; + } else { + sum += 1.659550000000e-04; + } + } + } else { + if (beta <= 25.28588390) { + if (beta <= 25.04488850) { + sum += 1.939700000000e-04; + } else { + sum += 2.091920000000e-04; + } + } else { + sum += 1.914500000000e-04; + } + } + } else { + if (f107_smooth <= 96.25000000) { + if (beta <= 25.54352283) { + sum += 1.034600000000e-04; + } else { + sum += 9.103900000000e-05; + } + } else { + sum += 6.148500000000e-05; + } + } + } + } else { + if (f107 <= 74.89999771) { + if (beta <= 24.44765091) { + if (beta <= 20.88455772) { + sum += 1.102100000000e-04; + } else { + sum += 1.416900000000e-04; + } + } else { + if (ap <= 20.50000000) { + sum += 2.124700000000e-04; + } else { + if (beta <= 30.98586655) { + if (beta <= 28.00726604) { + sum += 1.932100000000e-04; + } else { + sum += 1.982940000000e-04; + } + } else { + sum += 1.835000000000e-04; + } + } + } + } else { + if (f107 <= 90.95000076) { + if (f107 <= 86.50000000) { + if (beta <= 26.42500210) { + if (beta <= 23.90854836) { + sum += 1.142800000000e-04; + } else { + sum += 1.012500000000e-04; + } + } else { + if (beta <= 28.88301563) { + sum += 7.190100000000e-05; + } else { + sum += 5.534900000000e-05; + } + } + } else { + sum += -8.438500000000e-05; + } + } else { + if (beta <= 23.98122597) { + sum += 2.163500000000e-04; + } else { + if (beta <= 23.98626995) { + sum += 2.065500000000e-04; + } else { + sum += 2.007600000000e-04; + } + } + } + } + } + } else { + if (beta <= 29.68245029) { + if (ap <= 21.00000000) { + if (f107 <= 107.45000076) { + if (f107_smooth <= 128.70000458) { + if (f107 <= 79.95000076) { + if (beta <= 26.17965603) { + sum += -1.227600000000e-04; + } else { + sum += -1.479022222222e-04; + } + } else { + if (ap <= 6.50000000) { + sum += -1.017225750000e-04; + } else { + sum += -8.181054098361e-05; + } + } + } else { + if (beta <= 24.14248562) { + sum += 2.356000000000e-04; + } else { + if (ap <= 9.50000000) { + sum += -9.299900000000e-05; + } else { + sum += -4.916442857143e-05; + } + } + } + } else { + if (ap <= 13.50000000) { + sum += 1.939100000000e-04; + } else { + if (ap <= 19.00000000) { + if (beta <= 25.00380039) { + sum += -3.745142857143e-06; + } else { + sum += -2.407000000000e-05; + } + } else { + if (beta <= 25.28026485) { + sum += -1.265200000000e-04; + } else { + sum += -1.294500000000e-04; + } + } + } + } + } else { + if (beta <= 24.10977650) { + if (f107_smooth <= 125.35000229) { + if (beta <= 20.67538834) { + sum += -2.958000000000e-05; + } else { + sum += -4.611500000000e-05; + } + } else { + if (ap <= 23.00000000) { + if (beta <= 20.09362411) { + sum += 1.173800000000e-04; + } else { + sum += 1.329600000000e-04; + } + } else { + if (beta <= 23.89652538) { + sum += 2.272400000000e-04; + } else { + sum += 2.236400000000e-04; + } + } + } + } else { + if (f107_smooth <= 129.55000305) { + if (beta <= 24.90350819) { + sum += 2.100600000000e-06; + } else { + sum += 2.116700000000e-05; + } + } else { + if (ap <= 30.50000000) { + sum += -1.041100000000e-04; + } else { + sum += -9.970900000000e-05; + } + } + } + } + } else { + if (f107_smooth <= 109.00000000) { + if (f107_smooth <= 106.54999924) { + if (f107 <= 102.69999695) { + if (beta <= 29.74915981) { + sum += -3.739300000000e-05; + } else { + if (ap <= 5.00000000) { + sum += 4.209500000000e-06; + } else { + sum += -6.956700000000e-06; + } + } + } else { + if (beta <= 29.92232704) { + sum += 4.958300000000e-05; + } else { + sum += 6.387400000000e-05; + } + } + } else { + if (ap <= 11.50000000) { + if (beta <= 30.70277309) { + if (f107 <= 102.40000153) { + sum += 1.281550000000e-04; + } else { + sum += 9.706800000000e-05; + } + } else { + if (beta <= 30.73674583) { + sum += 7.424400000000e-05; + } else { + sum += 5.423900000000e-05; + } + } + } else { + if (beta <= 30.90550804) { + if (beta <= 30.52417946) { + sum += 1.978400000000e-04; + } else { + sum += 1.883200000000e-04; + } + } else { + if (beta <= 31.27854729) { + sum += 2.049000000000e-04; + } else { + sum += 2.139800000000e-04; + } + } + } + } + } else { + if (beta <= 31.10147285) { + if (f107_smooth <= 114.75000000) { + if (f107 <= 101.35000229) { + if (ap <= 9.50000000) { + sum += -3.529673846154e-05; + } else { + sum += -9.687775000000e-05; + } + } else { + if (f107 <= 104.45000076) { + sum += -1.146700000000e-04; + } else { + sum += -1.244900000000e-04; + } + } + } else { + if (ap <= 9.50000000) { + if (ap <= 3.50000000) { + sum += -1.329800000000e-04; + } else { + sum += -1.490300000000e-04; + } + } else { + sum += -8.439600000000e-05; + } + } + } else { + if (f107 <= 99.79999924) { + if (ap <= 4.50000000) { + if (beta <= 31.15727615) { + sum += 4.015400000000e-05; + } else { + sum += 5.871200000000e-05; + } + } else { + sum += 1.206200000000e-05; + } + } else { + if (beta <= 31.19440174) { + sum += 8.692000000000e-05; + } else { + sum += 1.031600000000e-04; + } + } + } + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (ap <= 63.50000000) { + if (f107_smooth <= 128.55000305) { + if (f107 <= 134.34999847) { + if (f107_smooth <= 127.35000229) { + if (f107_smooth <= 125.75000000) { + if (f107_smooth <= 122.55000305) { + sum += 8.211823046875e-05; + } else { + sum += 1.783878484848e-04; + } + } else { + if (beta <= 24.44975567) { + sum += -5.844600000000e-05; + } else { + sum += 1.018677142857e-04; + } + } + } else { + if (f107_smooth <= 128.34999847) { + if (beta <= 20.13606739) { + sum += 1.745200000000e-04; + } else { + sum += 2.014207692308e-04; + } + } else { + if (beta <= 24.56637955) { + sum += 1.736300000000e-04; + } else { + sum += 1.613500000000e-04; + } + } + } + } else { + if (f107_smooth <= 127.75000000) { + if (ap <= 26.50000000) { + if (f107 <= 245.69999695) { + sum += 2.074584230769e-04; + } else { + sum += 6.605850000000e-05; + } + } else { + if (beta <= 22.30188274) { + sum += 8.997700000000e-05; + } else { + sum += 6.529400000000e-05; + } + } + } else { + if (beta <= 20.52133274) { + if (beta <= 20.44769573) { + sum += 1.496200000000e-04; + } else { + sum += 1.070362500000e-04; + } + } else { + if (f107 <= 157.65000153) { + sum += -2.359900000000e-05; + } else { + sum += 4.285100000000e-05; + } + } + } + } + } else { + if (f107_smooth <= 147.20000458) { + if (f107 <= 121.70000076) { + if (ap <= 13.50000000) { + if (beta <= 21.52746677) { + sum += 6.533665121951e-05; + } else { + sum += 1.703873703704e-04; + } + } else { + if (ap <= 34.00000000) { + sum += -3.067046538462e-05; + } else { + sum += 2.539100000000e-04; + } + } + } else { + if (ap <= 3.50000000) { + if (beta <= 24.49610138) { + sum += 1.416341724138e-04; + } else { + sum += -1.113000000000e-05; + } + } else { + if (beta <= 23.96213913) { + sum += 3.535447889447e-05; + } else { + sum += -2.137815371658e-05; + } + } + } + } else { + if (f107 <= 115.54999924) { + if (f107 <= 113.95000076) { + if (beta <= 25.00778294) { + sum += -1.102200000000e-04; + } else { + sum += -9.912211111111e-05; + } + } else { + if (f107_smooth <= 154.09999847) { + sum += -7.367500000000e-05; + } else { + sum += -3.923400000000e-05; + } + } + } else { + if (f107 <= 120.35000229) { + if (f107_smooth <= 153.40000153) { + sum += 1.932156250000e-04; + } else { + sum += -5.736563333333e-05; + } + } else { + if (f107_smooth <= 190.50000000) { + sum += 9.116399508328e-05; + } else { + sum += 2.230490880000e-05; + } + } + } + } + } + } else { + if (beta <= 20.11685467) { + if (f107 <= 145.09999847) { + sum += -9.692000000000e-05; + } else { + sum += -1.091900000000e-04; + } + } else { + if (f107 <= 152.94999695) { + if (beta <= 23.46108341) { + if (f107 <= 134.54999542) { + sum += 1.900200000000e-04; + } else { + if (f107 <= 139.09999847) { + sum += 2.430000000000e-04; + } else { + sum += 2.534040000000e-04; + } + } + } else { + if (beta <= 23.95972157) { + sum += 1.270200000000e-04; + } else { + sum += 1.152800000000e-04; + } + } + } else { + if (ap <= 98.00000000) { + if (f107_smooth <= 159.59999847) { + if (f107 <= 172.30000305) { + sum += 3.197400000000e-04; + } else { + sum += 3.118100000000e-04; + } + } else { + if (beta <= 27.43329525) { + sum += 2.686400000000e-04; + } else { + sum += 2.979200000000e-04; + } + } + } else { + if (f107_smooth <= 176.65000153) { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } else { + if (beta <= 21.00016785) { + sum += 4.060400000000e-04; + } else { + sum += 4.032800000000e-04; + } + } + } + } + } + } + } else { + if (ap <= 89.00000000) { + if (f107 <= 174.75000000) { + if (beta <= 24.55337715) { + if (beta <= 23.95017910) { + if (f107_smooth <= 206.50000000) { + if (ap <= 4.50000000) { + sum += 2.657742857143e-04; + } else { + sum += 2.359573333333e-04; + } + } else { + if (f107_smooth <= 207.65000153) { + sum += 1.962020000000e-04; + } else { + sum += 1.569360000000e-04; + } + } + } else { + if (beta <= 24.13862228) { + if (f107_smooth <= 203.65000153) { + sum += 4.155683333333e-04; + } else { + sum += 4.060030000000e-04; + } + } else { + if (f107_smooth <= 199.69999695) { + sum += 1.661433333333e-04; + } else { + sum += 3.021208823529e-04; + } + } + } + } else { + if (ap <= 6.50000000) { + if (beta <= 25.21968842) { + sum += 1.203200000000e-04; + } else { + if (beta <= 25.89657497) { + sum += 1.943700000000e-04; + } else { + sum += 2.402933333333e-04; + } + } + } else { + if (f107 <= 168.59999847) { + if (f107_smooth <= 200.29999542) { + sum += 6.891642857143e-05; + } else { + sum += 4.879433333333e-06; + } + } else { + if (ap <= 14.00000000) { + sum += 1.267211111111e-04; + } else { + sum += 2.110460000000e-04; + } + } + } + } + } else { + if (beta <= 22.67994404) { + if (f107 <= 199.75000000) { + if (ap <= 10.50000000) { + if (f107 <= 179.79999542) { + sum += 1.257600000000e-04; + } else { + sum += 6.581066666667e-05; + } + } else { + if (beta <= 20.92714024) { + sum += 1.391400000000e-04; + } else { + sum += 1.656550000000e-04; + } + } + } else { + if (f107 <= 221.79999542) { + if (ap <= 5.50000000) { + sum += -5.615044444444e-06; + } else { + sum += 3.592275000000e-05; + } + } else { + if (beta <= 22.02368641) { + sum += -6.224300000000e-05; + } else { + sum += -6.395900000000e-05; + } + } + } + } else { + if (f107 <= 247.20000458) { + if (beta <= 25.80245209) { + if (beta <= 24.58777618) { + sum += 1.925877543860e-04; + } else { + sum += 4.363170370370e-05; + } + } else { + if (beta <= 28.78306198) { + sum += 2.690600000000e-04; + } else { + sum += 3.254633333333e-04; + } + } + } else { + if (beta <= 23.40178204) { + if (beta <= 23.20846939) { + sum += 2.828400000000e-04; + } else { + sum += 2.827800000000e-04; + } + } else { + if (beta <= 24.10730648) { + sum += 5.172137500000e-05; + } else { + sum += 1.121900434783e-04; + } + } + } + } + } + } else { + if (beta <= 24.07762814) { + if (f107 <= 244.34999847) { + if (beta <= 24.06831455) { + if (beta <= 24.05796909) { + if (beta <= 24.05280304) { + sum += 2.984300000000e-04; + } else { + sum += 2.949800000000e-04; + } + } else { + sum += 2.698900000000e-04; + } + } else { + sum += 3.061900000000e-04; + } + } else { + if (beta <= 23.96580505) { + sum += 7.163500000000e-06; + } else { + sum += 4.803900000000e-05; + } + } + } else { + sum += 1.397800000000e-03; + } + } + } + } + } + // Tree 4 + { + if (f107 <= 112.90000153) { + if (f107_smooth <= 112.15000153) { + if (f107 <= 84.45000076) { + if (f107_smooth <= 89.35000229) { + if (beta <= 20.02057743) { + if (f107 <= 77.25000000) { + if (f107 <= 75.75000000) { + if (f107_smooth <= 78.09999847) { + sum += 1.757700000000e-04; + } else { + sum += 1.779300000000e-04; + } + } else { + if (beta <= 19.98829079) { + sum += 2.024566666667e-04; + } else { + sum += 1.982875000000e-04; + } + } + } else { + if (ap <= 3.50000000) { + if (f107_smooth <= 78.04999924) { + sum += 1.367300000000e-04; + } else { + sum += 1.566200000000e-04; + } + } else { + if (f107_smooth <= 77.95000076) { + sum += 1.028275000000e-04; + } else { + sum += 6.303466666667e-05; + } + } + } + } else { + if (beta <= 20.50973892) { + if (beta <= 20.11138725) { + if (ap <= 3.50000000) { + sum += 3.082742857143e-05; + } else { + sum += -5.521973333333e-05; + } + } else { + if (f107_smooth <= 79.35000229) { + sum += -1.336210800000e-04; + } else { + sum += -5.779175714286e-05; + } + } + } else { + if (beta <= 21.31218910) { + if (beta <= 20.60428715) { + sum += 6.010761538462e-05; + } else { + sum += 1.506928275862e-04; + } + } else { + if (beta <= 23.92033958) { + sum += -5.278452089552e-05; + } else { + sum += 3.116643246269e-05; + } + } + } + } + } else { + if (ap <= 6.50000000) { + if (ap <= 3.50000000) { + if (f107 <= 84.14999771) { + if (f107 <= 83.64999771) { + sum += -1.498181818182e-04; + } else { + sum += -1.328600000000e-04; + } + } else { + if (beta <= 24.19087696) { + sum += -9.885800000000e-05; + } else { + sum += -1.122100000000e-04; + } + } + } else { + if (f107 <= 77.90000153) { + if (beta <= 26.28668690) { + sum += -1.321000000000e-04; + } else { + sum += -1.503400000000e-04; + } + } else { + if (beta <= 26.00677586) { + sum += -9.734314285714e-05; + } else { + sum += -1.141450000000e-04; + } + } + } + } else { + if (f107_smooth <= 93.39999771) { + if (beta <= 24.40711308) { + if (beta <= 24.36592674) { + sum += -1.503300000000e-04; + } else { + sum += -1.480266666667e-04; + } + } else { + sum += -1.435800000000e-04; + } + } else { + if (f107 <= 79.65000153) { + if (beta <= 24.79175854) { + sum += 5.748400000000e-05; + } else { + sum += 7.533200000000e-05; + } + } else { + if (f107 <= 83.34999847) { + sum += -2.304656000000e-05; + } else { + sum += -1.249600000000e-04; + } + } + } + } + } + } else { + if (ap <= 12.50000000) { + if (beta <= 24.11963272) { + if (f107 <= 89.54999924) { + if (beta <= 20.42816162) { + sum += -5.694800000000e-05; + } else { + if (beta <= 24.05613041) { + sum += 1.721653846154e-04; + } else { + sum += 2.142600000000e-04; + } + } + } else { + if (f107 <= 91.14999771) { + if (f107 <= 90.45000076) { + sum += -1.153900000000e-04; + } else { + sum += 1.288746857143e-05; + } + } else { + if (f107 <= 93.59999847) { + sum += 1.761125000000e-04; + } else { + sum += 6.194218461538e-05; + } + } + } + } else { + if (beta <= 24.53303432) { + if (beta <= 24.24073029) { + if (f107 <= 88.75000000) { + sum += 6.526383333333e-05; + } else { + sum += -2.596245714286e-05; + } + } else { + if (beta <= 24.27741241) { + sum += -6.638533333333e-05; + } else { + sum += -1.275986666667e-04; + } + } + } else { + if (beta <= 25.63646030) { + if (f107_smooth <= 82.64999771) { + sum += -2.051978461538e-05; + } else { + sum += 1.634229375000e-04; + } + } else { + if (beta <= 29.86074638) { + sum += -5.482133548387e-05; + } else { + sum += 4.812752724138e-05; + } + } + } + } + } else { + if (f107 <= 103.85000229) { + if (beta <= 24.02341938) { + if (ap <= 15.50000000) { + if (f107_smooth <= 87.89999771) { + sum += 1.963425000000e-04; + } else { + sum += 1.494400000000e-04; + } + } else { + if (beta <= 23.97653675) { + sum += 2.381200000000e-04; + } else { + sum += 2.007600000000e-04; + } + } + } else { + if (f107_smooth <= 101.09999847) { + if (ap <= 19.50000000) { + sum += 1.048937500000e-04; + } else { + sum += -9.524300000000e-05; + } + } else { + if (f107 <= 101.65000153) { + sum += -7.726900000000e-05; + } else { + sum += -9.264200000000e-05; + } + } + } + } else { + if (beta <= 30.32371140) { + if (beta <= 30.11411476) { + sum += 1.411700000000e-04; + } else { + sum += 1.647000000000e-04; + } + } else { + if (beta <= 31.27854729) { + if (f107 <= 105.35000229) { + sum += 1.930800000000e-04; + } else { + sum += 2.049000000000e-04; + } + } else { + if (ap <= 13.50000000) { + sum += 2.302600000000e-04; + } else { + sum += 2.139800000000e-04; + } + } + } + } + } + } + } else { + if (f107 <= 107.39999771) { + if (ap <= 14.50000000) { + if (ap <= 7.50000000) { + if (f107 <= 106.00000000) { + if (beta <= 20.84889221) { + if (f107_smooth <= 126.95000076) { + sum += -9.321600000000e-05; + } else { + sum += -1.183400000000e-04; + } + } else { + if (beta <= 30.69181442) { + sum += -1.257990476190e-04; + } else { + sum += -1.494616666667e-04; + } + } + } else { + if (ap <= 4.50000000) { + sum += -7.680000000000e-05; + } else { + if (beta <= 28.64776611) { + sum += -4.235700000000e-05; + } else { + sum += -1.014800000000e-05; + } + } + } + } else { + if (f107 <= 101.04999924) { + if (f107 <= 97.40000153) { + if (f107_smooth <= 128.30000305) { + sum += -1.116437272727e-04; + } else { + sum += -6.583866666667e-05; + } + } else { + if (beta <= 30.67564487) { + sum += -1.936075625000e-05; + } else { + sum += -1.124500000000e-04; + } + } + } else { + if (f107 <= 106.50000000) { + if (beta <= 26.03458691) { + sum += -1.499475000000e-04; + } else { + sum += -1.432600000000e-04; + } + } else { + if (beta <= 23.94971943) { + sum += -1.274114285714e-04; + } else { + sum += -9.810000000000e-05; + } + } + } + } + } else { + if (beta <= 24.05524635) { + if (f107_smooth <= 123.15000153) { + sum += -1.322700000000e-04; + } else { + if (beta <= 21.99464798) { + if (beta <= 20.08639240) { + sum += 8.958700000000e-05; + } else { + sum += 1.329600000000e-04; + } + } else { + if (beta <= 23.89560604) { + sum += 2.338275000000e-04; + } else { + sum += 2.272400000000e-04; + } + } + } + } else { + if (f107_smooth <= 127.80000305) { + if (f107 <= 100.35000229) { + sum += -1.418500000000e-04; + } else { + sum += -1.406700000000e-04; + } + } else { + if (f107_smooth <= 129.55000305) { + if (beta <= 24.90350819) { + sum += 2.100600000000e-06; + } else { + sum += 2.116700000000e-05; + } + } else { + if (f107_smooth <= 132.34999847) { + sum += -1.049045000000e-04; + } else { + sum += -5.624800000000e-05; + } + } + } + } + } + } else { + if (ap <= 19.50000000) { + if (beta <= 25.65134239) { + if (beta <= 21.55631447) { + if (ap <= 9.50000000) { + if (beta <= 20.65017986) { + sum += -4.183100000000e-05; + } else { + sum += -7.144933333333e-05; + } + } else { + if (beta <= 20.62881947) { + sum += 1.050800000000e-05; + } else { + sum += -1.831500000000e-05; + } + } + } else { + if (f107_smooth <= 132.10000610) { + if (beta <= 24.54320145) { + sum += 1.907425000000e-04; + } else { + sum += 1.320565714286e-04; + } + } else { + if (beta <= 24.93879032) { + sum += 4.684466666667e-05; + } else { + sum += -4.179333333333e-06; + } + } + } + } else { + if (f107_smooth <= 119.05000305) { + if (beta <= 30.17738247) { + if (f107 <= 110.65000153) { + sum += 3.902900000000e-05; + } else { + sum += 7.158100000000e-05; + } + } else { + if (beta <= 30.25462914) { + sum += 2.939400000000e-05; + } else { + sum += 9.282800000000e-06; + } + } + } else { + if (f107 <= 112.04999924) { + if (f107 <= 111.64999771) { + sum += -1.095200000000e-04; + } else { + sum += -1.032400000000e-04; + } + } else { + if (beta <= 26.08974648) { + sum += -1.036300000000e-04; + } else { + sum += -9.134000000000e-05; + } + } + } + } + } else { + if (beta <= 24.72170639) { + if (beta <= 24.09133530) { + sum += -1.131000000000e-04; + } else { + if (beta <= 24.14501762) { + sum += -1.116200000000e-04; + } else { + sum += -1.111600000000e-04; + } + } + } else { + if (beta <= 25.31181240) { + sum += -1.265200000000e-04; + } else { + sum += -1.366500000000e-04; + } + } + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (ap <= 70.50000000) { + if (f107_smooth <= 129.05000305) { + if (beta <= 30.77651119) { + if (beta <= 24.49659634) { + if (beta <= 20.44607258) { + if (f107_smooth <= 127.75000000) { + sum += 2.129268965517e-04; + } else { + sum += 1.208057500000e-04; + } + } else { + if (beta <= 21.57287788) { + sum += 2.669093225806e-05; + } else { + sum += 1.430744803279e-04; + } + } + } else { + if (f107_smooth <= 97.40000153) { + if (f107 <= 121.10000229) { + sum += 1.753595000000e-05; + } else { + sum += 9.067900000000e-05; + } + } else { + if (f107_smooth <= 120.89999771) { + sum += 1.672030625000e-04; + } else { + sum += 2.138446875000e-04; + } + } + } + } else { + if (f107_smooth <= 109.45000076) { + if (f107_smooth <= 108.04999924) { + if (beta <= 31.33121777) { + sum += 1.943957142857e-04; + } else { + sum += 1.156066666667e-04; + } + } else { + if (f107 <= 124.75000000) { + sum += 9.822650000000e-05; + } else { + sum += -2.072491428571e-05; + } + } + } else { + if (beta <= 31.18397236) { + if (beta <= 31.14682007) { + sum += -1.297985714286e-04; + } else { + sum += -1.231175000000e-04; + } + } else { + if (beta <= 31.23638821) { + sum += -1.028500000000e-04; + } else { + sum += -9.156200000000e-05; + } + } + } + } + } else { + if (f107_smooth <= 147.44999695) { + if (f107 <= 122.35000229) { + if (ap <= 13.50000000) { + if (beta <= 21.60474014) { + sum += 8.836166279070e-05; + } else { + sum += 1.719634285714e-04; + } + } else { + if (f107_smooth <= 139.65000153) { + sum += -3.937881891892e-05; + } else { + sum += 2.280800000000e-04; + } + } + } else { + if (ap <= 3.50000000) { + if (f107 <= 142.19999695) { + sum += 1.749667894737e-04; + } else { + sum += 7.502659565217e-05; + } + } else { + if (ap <= 16.50000000) { + sum += -1.127489062914e-05; + } else { + sum += 6.410805684211e-05; + } + } + } + } else { + if (ap <= 23.50000000) { + if (f107_smooth <= 172.25000000) { + if (f107_smooth <= 167.25000000) { + sum += 8.243512234826e-05; + } else { + sum += 1.778413084211e-04; + } + } else { + if (beta <= 20.08369255) { + sum += 2.052315000000e-04; + } else { + sum += 3.848183885350e-05; + } + } + } else { + if (f107 <= 185.39999390) { + if (beta <= 28.26621723) { + sum += 1.396699505051e-04; + } else { + sum += 1.766403636364e-05; + } + } else { + if (f107 <= 228.05000305) { + sum += 2.795842424242e-04; + } else { + sum += 3.947433333333e-05; + } + } + } + } + } + } else { + if (f107 <= 175.20000458) { + if (f107_smooth <= 156.40000153) { + if (f107_smooth <= 147.65000153) { + sum += -3.283600000000e-05; + } else { + if (ap <= 73.50000000) { + sum += 1.900200000000e-04; + } else { + if (beta <= 23.95972157) { + sum += 1.270200000000e-04; + } else { + sum += 1.144900000000e-04; + } + } + } + } else { + if (f107 <= 159.34999847) { + if (beta <= 27.52500534) { + sum += 3.197400000000e-04; + } else { + sum += 3.100400000000e-04; + } + } else { + if (beta <= 30.57476807) { + sum += 2.934200000000e-04; + } else { + sum += 2.967500000000e-04; + } + } + } + } else { + if (ap <= 89.50000000) { + if (beta <= 24.30885887) { + if (beta <= 24.29946232) { + sum += 3.104100000000e-04; + } else { + if (beta <= 24.30328941) { + sum += 3.139100000000e-04; + } else { + sum += 3.138300000000e-04; + } + } + } else { + sum += 3.073200000000e-04; + } + } else { + if (ap <= 188.00000000) { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } else { + if (beta <= 20.98794746) { + sum += 4.078500000000e-04; + } else { + sum += 4.060400000000e-04; + } + } + } + } + } + } else { + if (f107 <= 232.90000153) { + if (ap <= 10.50000000) { + if (beta <= 25.88745594) { + if (beta <= 24.58456516) { + if (beta <= 23.93157387) { + if (f107 <= 173.90000153) { + sum += 2.241564000000e-04; + } else { + sum += 8.648655416667e-05; + } + } else { + if (f107_smooth <= 220.89999390) { + sum += 2.228861190476e-04; + } else { + sum += 3.012250000000e-04; + } + } + } else { + if (beta <= 25.56192207) { + if (beta <= 24.66054344) { + sum += 6.875244444444e-05; + } else { + sum += 1.350220952381e-05; + } + } else { + if (ap <= 5.50000000) { + sum += 1.066566666667e-04; + } else { + sum += 1.900350000000e-04; + } + } + } + } else { + if (f107_smooth <= 194.55000305) { + if (beta <= 29.12022972) { + sum += 3.400600000000e-04; + } else { + sum += 3.396200000000e-04; + } + } else { + if (beta <= 26.52034187) { + if (f107_smooth <= 198.64999390) { + sum += 2.864242857143e-04; + } else { + sum += 2.411133333333e-04; + } + } else { + if (f107 <= 162.29999542) { + sum += 2.363300000000e-04; + } else { + sum += 1.958150000000e-04; + } + } + } + } + } else { + if (f107 <= 219.75000000) { + if (f107 <= 172.19999695) { + if (f107_smooth <= 197.19999695) { + if (beta <= 27.03134727) { + sum += 8.101700000000e-05; + } else { + sum += 6.993500000000e-05; + } + } else { + if (beta <= 24.17910576) { + sum += 4.089733333333e-04; + } else { + sum += 3.091800000000e-04; + } + } + } else { + if (beta <= 26.00008965) { + if (f107 <= 204.54999542) { + sum += 1.826450666667e-04; + } else { + sum += 2.550209090909e-04; + } + } else { + if (ap <= 26.00000000) { + sum += 2.897800000000e-04; + } else { + sum += 3.298080000000e-04; + } + } + } + } else { + if (beta <= 24.09101105) { + sum += 1.384500000000e-03; + } else { + if (f107_smooth <= 205.69999695) { + if (ap <= 28.00000000) { + sum += 3.269300000000e-04; + } else { + sum += 3.161900000000e-04; + } + } else { + if (beta <= 24.33793926) { + sum += 2.004600000000e-04; + } else { + sum += 1.586000000000e-04; + } + } + } + } + } + } else { + if (beta <= 22.67622280) { + if (beta <= 21.99576473) { + if (f107 <= 236.09999847) { + sum += -3.939000000000e-05; + } else { + sum += -2.005400000000e-05; + } + } else { + if (beta <= 22.14938736) { + if (beta <= 22.10490799) { + if (beta <= 22.02368641) { + sum += -6.224300000000e-05; + } else { + sum += -6.411800000000e-05; + } + } else { + sum += -6.198000000000e-05; + } + } else { + sum += -2.400000000000e-05; + } + } + } else { + if (beta <= 23.49936199) { + if (beta <= 23.37784195) { + if (ap <= 20.50000000) { + sum += 2.562800000000e-04; + } else { + if (beta <= 23.18960953) { + sum += 2.765300000000e-04; + } else { + sum += 2.828200000000e-04; + } + } + } else { + if (beta <= 23.46283340) { + if (beta <= 23.45326710) { + sum += 1.988900000000e-04; + } else { + sum += 1.995400000000e-04; + } + } else { + sum += 2.333700000000e-04; + } + } + } else { + if (beta <= 24.04102230) { + if (ap <= 21.50000000) { + if (f107 <= 258.05000305) { + sum += 8.310300000000e-05; + } else { + sum += 5.661883333333e-05; + } + } else { + if (ap <= 88.00000000) { + sum += 1.575250000000e-04; + } else { + sum += 7.163500000000e-06; + } + } + } else { + if (beta <= 24.59099674) { + if (f107_smooth <= 203.70000458) { + sum += 2.088420000000e-04; + } else { + sum += 1.441553030303e-04; + } + } else { + if (beta <= 28.46154594) { + sum += 5.975361538462e-05; + } else { + sum += 1.545600000000e-04; + } + } + } + } + } + } + } + } + } + // Tree 5 + { + if (f107 <= 108.65000153) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (beta <= 20.02822018) { + if (f107 <= 77.25000000) { + if (beta <= 20.01400757) { + if (f107 <= 75.34999847) { + if (ap <= 2.50000000) { + sum += 1.779300000000e-04; + } else { + sum += 1.630000000000e-04; + } + } else { + if (f107 <= 75.90000153) { + sum += 2.069800000000e-04; + } else { + sum += 1.983500000000e-04; + } + } + } else { + if (beta <= 20.02502918) { + sum += 1.343000000000e-04; + } else { + sum += 1.198600000000e-04; + } + } + } else { + if (beta <= 20.02057743) { + if (ap <= 3.50000000) { + if (f107_smooth <= 78.04999924) { + sum += 1.367300000000e-04; + } else { + sum += 1.536700000000e-04; + } + } else { + if (beta <= 20.00238609) { + sum += 1.139200000000e-04; + } else { + sum += 7.824233333333e-05; + } + } + } else { + sum += 2.824700000000e-05; + } + } + } else { + if (beta <= 20.49999523) { + if (beta <= 20.07861614) { + if (ap <= 6.50000000) { + if (ap <= 4.50000000) { + sum += 5.575125000000e-06; + } else { + sum += 8.647066666667e-05; + } + } else { + if (beta <= 20.06964970) { + sum += -6.169950000000e-05; + } else { + sum += -8.402500000000e-05; + } + } + } else { + if (f107 <= 80.55000305) { + if (f107_smooth <= 79.35000229) { + sum += -1.343784250000e-04; + } else { + sum += -4.264666666667e-05; + } + } else { + if (f107_smooth <= 78.35000229) { + sum += -6.135900000000e-05; + } else { + sum += -7.920825000000e-06; + } + } + } + } else { + if (f107_smooth <= 74.35000229) { + if (beta <= 29.34882736) { + if (f107 <= 75.95000076) { + sum += -2.604900000000e-05; + } else { + sum += -8.193200000000e-05; + } + } else { + if (beta <= 30.16052437) { + sum += -1.353467500000e-04; + } else { + sum += -8.714850000000e-05; + } + } + } else { + if (beta <= 31.21508598) { + if (beta <= 30.72298527) { + sum += 2.040049599602e-05; + } else { + sum += 1.529618653061e-04; + } + } else { + if (beta <= 31.28133583) { + sum += -6.641094545455e-05; + } else { + sum += -1.302550000000e-04; + } + } + } + } + } + } else { + if (f107 <= 93.70000076) { + if (f107 <= 91.50000000) { + if (beta <= 24.00835419) { + sum += 1.821400000000e-04; + } else { + sum += 1.525000000000e-04; + } + } else { + if (ap <= 8.50000000) { + if (ap <= 4.50000000) { + if (ap <= 2.50000000) { + sum += 1.939700000000e-04; + } else { + sum += 2.153366666667e-04; + } + } else { + if (f107 <= 92.10000229) { + sum += 1.980200000000e-04; + } else { + sum += 1.867225000000e-04; + } + } + } else { + if (f107 <= 92.95000076) { + sum += 2.065500000000e-04; + } else { + if (beta <= 25.22305107) { + sum += 2.150600000000e-04; + } else { + sum += 2.078500000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 87.94999695) { + if (f107 <= 93.95000076) { + sum += -9.349600000000e-05; + } else { + if (beta <= 24.55267525) { + if (ap <= 15.50000000) { + sum += 1.411009473684e-04; + } else { + sum += 2.449000000000e-04; + } + } else { + if (ap <= 7.00000000) { + sum += 1.965100000000e-05; + } else { + sum += 6.904700000000e-05; + } + } + } + } else { + if (f107 <= 99.25000000) { + if (f107_smooth <= 88.80000305) { + if (beta <= 24.23282051) { + sum += -2.896500000000e-05; + } else { + sum += -4.602933333333e-05; + } + } else { + sum += -5.732400000000e-05; + } + } else { + sum += -8.955200000000e-05; + } + } + } + } + } else { + if (f107 <= 97.15000153) { + if (beta <= 30.82102108) { + if (f107_smooth <= 96.64999771) { + if (f107 <= 81.34999847) { + sum += -7.550300000000e-05; + } else { + sum += -2.746000000000e-05; + } + } else { + if (ap <= 6.50000000) { + if (f107_smooth <= 120.65000153) { + if (f107 <= 80.25000000) { + sum += -1.475050000000e-04; + } else { + sum += -1.295977307692e-04; + } + } else { + if (beta <= 23.09365463) { + sum += -1.241633333333e-04; + } else { + sum += -8.894600000000e-05; + } + } + } else { + if (beta <= 30.70771980) { + if (f107 <= 96.95000076) { + sum += -1.036512222222e-04; + } else { + sum += -1.492328571429e-04; + } + } else { + sum += 7.424400000000e-05; + } + } + } + } else { + if (beta <= 31.12872124) { + if (f107 <= 95.44999695) { + if (beta <= 30.98013020) { + sum += -2.307700000000e-05; + } else { + sum += -9.851100000000e-07; + } + } else { + sum += -4.712500000000e-05; + } + } else { + if (beta <= 31.15727615) { + sum += 4.015400000000e-05; + } else { + sum += 5.871200000000e-05; + } + } + } + } else { + if (f107_smooth <= 109.09999847) { + if (beta <= 29.85985470) { + if (f107_smooth <= 106.25000000) { + if (beta <= 29.06622791) { + if (f107 <= 102.00000000) { + sum += -7.016350000000e-05; + } else { + sum += -4.834975000000e-05; + } + } else { + if (f107 <= 104.85000229) { + sum += -9.933500000000e-05; + } else { + sum += -1.157900000000e-04; + } + } + } else { + if (f107 <= 101.09999847) { + sum += 4.209500000000e-06; + } else { + sum += -6.956700000000e-06; + } + } + } else { + if (ap <= 11.00000000) { + if (beta <= 29.98678780) { + if (beta <= 29.92232704) { + sum += 4.958300000000e-05; + } else { + sum += 6.387400000000e-05; + } + } else { + if (beta <= 30.67385387) { + sum += 1.235566666667e-04; + } else { + sum += 9.956650000000e-05; + } + } + } else { + if (beta <= 30.92130184) { + if (beta <= 30.55158138) { + sum += 1.930800000000e-04; + } else { + sum += 1.727400000000e-04; + } + } else { + sum += 2.049000000000e-04; + } + } + } + } else { + if (ap <= 7.50000000) { + if (f107 <= 99.35000229) { + if (beta <= 28.10572147) { + if (beta <= 20.48836136) { + sum += -1.274650000000e-04; + } else { + sum += -1.431800000000e-04; + } + } else { + sum += -1.048400000000e-04; + } + } else { + if (ap <= 6.50000000) { + if (f107 <= 102.70000076) { + sum += -1.154889523810e-04; + } else { + sum += -8.251776470588e-05; + } + } else { + if (beta <= 22.27404022) { + sum += -1.147500000000e-04; + } else { + sum += 8.336000000000e-05; + } + } + } + } else { + if (beta <= 24.05026627) { + if (f107_smooth <= 128.84999847) { + if (f107_smooth <= 123.25000000) { + sum += -7.913692000000e-05; + } else { + sum += 2.242797000000e-05; + } + } else { + if (ap <= 19.50000000) { + sum += 2.348650000000e-04; + } else { + sum += 2.314500000000e-04; + } + } + } else { + if (beta <= 24.43333435) { + if (f107_smooth <= 128.84999847) { + sum += -1.422175000000e-04; + } else { + sum += -9.914157142857e-05; + } + } else { + if (beta <= 25.05193710) { + sum += -9.509385714286e-06; + } else { + sum += -8.766909090909e-05; + } + } + } + } + } + } + } + } else { + if (f107_smooth <= 194.75000000) { + if (ap <= 63.50000000) { + if (beta <= 26.16163826) { + if (f107 <= 212.44999695) { + if (f107_smooth <= 130.15000153) { + if (f107 <= 163.19999695) { + if (f107 <= 149.44999695) { + sum += 1.185089518857e-04; + } else { + sum += 4.295186281250e-05; + } + } else { + if (f107_smooth <= 127.95000458) { + sum += 2.163368750000e-04; + } else { + sum += 5.201900000000e-05; + } + } + } else { + if (beta <= 25.17084694) { + if (f107_smooth <= 131.65000153) { + sum += -1.520659759036e-05; + } else { + sum += 7.175250569982e-05; + } + } else { + if (f107 <= 120.70000076) { + sum += -1.024146363636e-04; + } else { + sum += -7.904833707865e-06; + } + } + } + } else { + if (f107_smooth <= 167.60000610) { + if (ap <= 10.50000000) { + if (f107 <= 219.34999847) { + sum += 2.086575000000e-04; + } else { + sum += 8.228645333333e-05; + } + } else { + if (ap <= 23.00000000) { + sum += -8.130700000000e-05; + } else { + sum += -5.247900000000e-05; + } + } + } else { + if (ap <= 22.50000000) { + if (f107_smooth <= 171.34999847) { + sum += 3.146757142857e-04; + } else { + sum += 1.957197142857e-04; + } + } else { + if (f107_smooth <= 178.55000305) { + sum += 3.754300000000e-04; + } else { + sum += 3.598250000000e-04; + } + } + } + } + } else { + if (f107 <= 173.34999847) { + if (f107_smooth <= 162.09999847) { + if (beta <= 27.94806099) { + if (beta <= 27.64128113) { + sum += 1.213953535211e-04; + } else { + sum += 2.119012500000e-04; + } + } else { + if (f107 <= 126.59999847) { + sum += 1.275700364865e-04; + } else { + sum += -5.651395192308e-06; + } + } + } else { + if (f107_smooth <= 167.84999847) { + if (f107 <= 134.30000305) { + sum += 1.785534076923e-05; + } else { + sum += 2.028912569903e-04; + } + } else { + if (f107_smooth <= 175.34999847) { + sum += 1.493636833333e-05; + } else { + sum += 1.648932939759e-04; + } + } + } + } else { + if (beta <= 30.66779137) { + if (f107_smooth <= 170.55000305) { + if (f107_smooth <= 158.54999542) { + sum += -3.200897666667e-05; + } else { + sum += 1.010267514286e-04; + } + } else { + if (f107_smooth <= 193.75000000) { + sum += -4.855621673469e-05; + } else { + sum += 2.028925000000e-04; + } + } + } else { + if (f107_smooth <= 179.55000305) { + if (beta <= 30.86581898) { + sum += 1.899850750000e-04; + } else { + sum += 6.529660377358e-06; + } + } else { + if (f107_smooth <= 191.00000000) { + sum += 2.295759687500e-04; + } else { + sum += -7.200857142857e-07; + } + } + } + } + } + } else { + if (beta <= 20.11685467) { + if (beta <= 20.05780220) { + sum += -9.692000000000e-05; + } else { + if (f107_smooth <= 134.54999542) { + sum += -1.032000000000e-04; + } else { + sum += -1.091900000000e-04; + } + } + } else { + if (f107 <= 175.20000458) { + if (f107 <= 162.25000000) { + if (f107 <= 152.94999695) { + if (beta <= 23.46108341) { + sum += 2.529900000000e-04; + } else { + sum += 1.193440000000e-04; + } + } else { + if (beta <= 29.05694008) { + sum += 3.165066666667e-04; + } else { + sum += 2.956400000000e-04; + } + } + } else { + if (beta <= 24.30662060) { + sum += -3.283600000000e-05; + } else { + sum += -2.019100000000e-05; + } + } + } else { + if (f107_smooth <= 168.34999847) { + if (ap <= 71.00000000) { + if (beta <= 27.43329525) { + sum += 2.686400000000e-04; + } else { + sum += 2.983100000000e-04; + } + } else { + if (beta <= 24.29946232) { + sum += 3.104100000000e-04; + } else { + sum += 3.138757142857e-04; + } + } + } else { + if (ap <= 188.00000000) { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } else { + sum += 4.060400000000e-04; + } + } + } + } + } + } else { + if (f107 <= 174.00000000) { + if (f107_smooth <= 201.20000458) { + if (f107_smooth <= 198.44999695) { + if (beta <= 26.62204742) { + if (beta <= 26.45795918) { + if (beta <= 26.40068436) { + sum += 2.937000000000e-04; + } else { + sum += 2.763800000000e-04; + } + } else { + if (beta <= 26.52034187) { + sum += 2.590300000000e-04; + } else { + sum += 2.379850000000e-04; + } + } + } else { + if (beta <= 26.87873173) { + if (beta <= 26.72562218) { + sum += 2.083100000000e-04; + } else { + sum += 1.709900000000e-04; + } + } else { + sum += 1.020100000000e-04; + } + } + } else { + if (beta <= 24.51021194) { + if (f107_smooth <= 199.90000153) { + if (beta <= 21.00685692) { + sum += 1.964700000000e-04; + } else { + sum += 2.082640000000e-04; + } + } else { + if (ap <= 8.00000000) { + sum += 2.279166666667e-04; + } else { + sum += 2.916540000000e-04; + } + } + } else { + if (f107_smooth <= 200.00000000) { + if (f107_smooth <= 199.59999847) { + sum += 1.513966666667e-04; + } else { + sum += 1.161983333333e-04; + } + } else { + if (f107 <= 159.90000153) { + sum += 7.540300000000e-05; + } else { + sum += 3.451800000000e-05; + } + } + } + } + } else { + if (beta <= 23.41395760) { + if (beta <= 21.46907806) { + if (beta <= 21.39893055) { + if (f107 <= 166.50000000) { + sum += 2.542860000000e-04; + } else { + sum += 2.708087500000e-04; + } + } else { + if (ap <= 4.00000000) { + sum += 2.194700000000e-04; + } else { + sum += 2.110700000000e-04; + } + } + } else { + if (f107 <= 169.90000153) { + if (beta <= 21.53677464) { + sum += 1.706900000000e-04; + } else { + sum += 1.522488888889e-04; + } + } else { + sum += 1.964900000000e-04; + } + } + } else { + if (beta <= 24.13862228) { + if (beta <= 23.96821594) { + if (f107_smooth <= 203.65000153) { + sum += 3.939100000000e-04; + } else { + sum += 4.075650000000e-04; + } + } else { + if (beta <= 23.97506523) { + sum += 4.241600000000e-04; + } else { + sum += 4.087400000000e-04; + } + } + } else { + if (f107 <= 172.04999542) { + if (beta <= 24.51891041) { + sum += 3.206895454545e-04; + } else { + sum += 2.892781818182e-04; + } + } else { + if (beta <= 24.55337715) { + sum += 2.629150000000e-04; + } else { + sum += 2.119975000000e-04; + } + } + } + } + } + } else { + if (beta <= 22.67994404) { + if (f107 <= 193.30000305) { + if (f107 <= 181.59999847) { + if (beta <= 21.62672806) { + if (beta <= 20.87298679) { + sum += 1.181900000000e-04; + } else { + sum += 1.278766666667e-04; + } + } else { + sum += 8.848900000000e-05; + } + } else { + if (beta <= 22.61511421) { + if (f107 <= 183.75000000) { + sum += 8.108000000000e-05; + } else { + sum += 7.640400000000e-05; + } + } else { + sum += 8.635000000000e-05; + } + } + } else { + if (f107 <= 228.84999847) { + if (ap <= 5.50000000) { + if (beta <= 22.37957954) { + sum += -1.377848571429e-05; + } else { + sum += 6.365300000000e-06; + } + } else { + sum += 3.993200000000e-05; + } + } else { + if (beta <= 22.14938736) { + if (f107_smooth <= 211.45000458) { + sum += -2.681100000000e-05; + } else { + sum += -6.254050000000e-05; + } + } else { + sum += -2.400000000000e-05; + } + } + } + } else { + if (ap <= 17.00000000) { + if (beta <= 25.82498550) { + if (beta <= 24.59099674) { + if (f107_smooth <= 221.70000458) { + sum += 1.274283861386e-04; + } else { + sum += 2.370636111111e-04; + } + } else { + if (beta <= 25.56192207) { + sum += 4.946295714286e-05; + } else { + sum += 1.218910000000e-04; + } + } + } else { + if (f107 <= 220.55000305) { + if (f107_smooth <= 199.04999542) { + sum += 2.823108333333e-04; + } else { + sum += 2.275600000000e-04; + } + } else { + if (f107 <= 239.09999847) { + sum += 1.954700000000e-04; + } else { + sum += 1.545600000000e-04; + } + } + } + } else { + if (ap <= 18.50000000) { + sum += 1.384500000000e-03; + } else { + if (f107_smooth <= 208.34999847) { + if (ap <= 56.00000000) { + sum += 3.256100000000e-04; + } else { + sum += 3.043785714286e-04; + } + } else { + if (ap <= 24.50000000) { + sum += 2.550523529412e-04; + } else { + sum += 1.504086666667e-04; + } + } + } + } + } + } + } + } + } + // Tree 6 + { + if (f107 <= 114.05000305) { + if (f107_smooth <= 74.25000000) { + if (ap <= 4.00000000) { + if (ap <= 2.00000000) { + sum += -1.106800000000e-04; + } else { + if (beta <= 29.50582695) { + sum += -1.224800000000e-04; + } else { + if (beta <= 29.52788830) { + sum += -1.278200000000e-04; + } else { + sum += -1.307700000000e-04; + } + } + } + } else { + if (beta <= 30.00226974) { + if (beta <= 29.68385315) { + if (beta <= 29.62720871) { + sum += -1.431200000000e-04; + } else { + sum += -1.471700000000e-04; + } + } else { + if (beta <= 29.95104694) { + if (f107_smooth <= 74.14999771) { + sum += -1.546400000000e-04; + } else { + if (beta <= 29.83047009) { + sum += -1.608800000000e-04; + } else { + sum += -1.575783333333e-04; + } + } + } else { + sum += -1.531100000000e-04; + } + } + } else { + if (beta <= 30.06186104) { + if (beta <= 30.04290199) { + sum += -1.463500000000e-04; + } else { + sum += -1.443900000000e-04; + } + } else { + sum += -1.363500000000e-04; + } + } + } + } else { + if (f107_smooth <= 74.85000229) { + if (ap <= 3.50000000) { + if (ap <= 2.50000000) { + if (f107_smooth <= 74.75000000) { + if (beta <= 26.81096649) { + sum += 7.312600000000e-05; + } else { + sum += 1.505400000000e-04; + } + } else { + sum += -3.129700000000e-05; + } + } else { + if (f107 <= 74.00000000) { + if (beta <= 26.65369225) { + sum += -1.264500000000e-04; + } else { + sum += -1.200400000000e-04; + } + } else { + sum += -1.391000000000e-04; + } + } + } else { + if (beta <= 31.12653542) { + if (f107_smooth <= 74.54999924) { + if (f107 <= 74.00000000) { + sum += 1.092800000000e-04; + } else { + if (f107 <= 75.75000000) { + sum += -3.175766666667e-05; + } else { + sum += 1.218320000000e-05; + } + } + } else { + if (beta <= 27.66996002) { + if (beta <= 24.97126579) { + sum += 1.759625000000e-04; + } else { + sum += 3.124677777778e-05; + } + } else { + if (beta <= 31.03744698) { + sum += 1.909107441860e-04; + } else { + sum += 1.243500000000e-04; + } + } + } + } else { + if (beta <= 31.19619560) { + if (f107 <= 70.14999771) { + sum += 6.649200000000e-06; + } else { + sum += 3.796700000000e-05; + } + } else { + if (beta <= 31.22650051) { + if (f107 <= 70.50000000) { + sum += -2.807200000000e-05; + } else { + sum += -3.610200000000e-05; + } + } else { + if (f107 <= 71.35000229) { + sum += -8.702800000000e-05; + } else { + sum += -6.159500000000e-05; + } + } + } + } + } + } else { + if (f107 <= 74.35000229) { + if (beta <= 31.28133583) { + if (f107_smooth <= 76.70000076) { + if (f107_smooth <= 75.09999847) { + if (beta <= 25.81573391) { + sum += -8.500720000000e-05; + } else { + sum += -1.358775000000e-04; + } + } else { + if (ap <= 3.50000000) { + sum += 1.070764000000e-04; + } else { + sum += 4.553066666667e-06; + } + } + } else { + if (beta <= 23.75352573) { + if (beta <= 23.65556622) { + sum += -1.392877777778e-04; + } else { + sum += -1.070204000000e-04; + } + } else { + if (beta <= 29.51892662) { + sum += 7.512767142857e-05; + } else { + sum += -8.095252941176e-05; + } + } + } + } else { + if (f107_smooth <= 75.54999924) { + if (beta <= 31.31233501) { + if (f107 <= 72.95000076) { + sum += -1.379420000000e-04; + } else { + sum += -1.299133333333e-04; + } + } else { + if (ap <= 12.00000000) { + sum += -1.536466666667e-04; + } else { + sum += -1.449740000000e-04; + } + } + } else { + if (beta <= 31.29197693) { + sum += -6.862700000000e-05; + } else { + sum += -9.540800000000e-05; + } + } + } + } else { + if (f107_smooth <= 96.40000153) { + if (f107 <= 91.14999771) { + if (beta <= 20.02057743) { + if (f107 <= 77.25000000) { + sum += 1.910777777778e-04; + } else { + sum += 1.350725000000e-04; + } + } else { + if (f107 <= 80.95000076) { + sum += -1.003958828829e-05; + } else { + sum += 4.593222753333e-05; + } + } + } else { + if (f107 <= 93.64999771) { + if (f107_smooth <= 82.70000076) { + sum += 5.384733333333e-05; + } else { + sum += 2.036260606061e-04; + } + } else { + if (ap <= 10.50000000) { + sum += 6.090078048780e-05; + } else { + sum += 1.745066666667e-04; + } + } + } + } else { + if (f107 <= 104.70000076) { + if (f107 <= 97.15000153) { + if (beta <= 30.99844170) { + sum += -1.115717698925e-04; + } else { + sum += 1.072522250000e-05; + } + } else { + if (f107 <= 97.50000000) { + sum += 1.133320000000e-04; + } else { + sum += -5.745432135922e-05; + } + } + } else { + if (f107 <= 105.70000076) { + if (f107_smooth <= 128.84999847) { + sum += 1.395757142857e-04; + } else { + sum += 2.299377777778e-04; + } + } else { + if (f107_smooth <= 133.69999695) { + sum += 3.110128422680e-05; + } else { + sum += -1.049440000000e-04; + } + } + } + } + } + } + } + } else { + if (f107_smooth <= 193.15000153) { + if (ap <= 63.50000000) { + if (f107_smooth <= 147.40000153) { + if (f107_smooth <= 128.40000153) { + if (f107 <= 134.34999847) { + if (beta <= 30.79869938) { + if (beta <= 24.48844242) { + sum += 4.318552857143e-05; + } else { + sum += 1.503982920000e-04; + } + } else { + if (f107_smooth <= 109.45000076) { + sum += 5.811819047619e-05; + } else { + sum += -1.134917777778e-04; + } + } + } else { + if (f107_smooth <= 127.90000153) { + if (f107 <= 245.69999695) { + sum += 1.955215352113e-04; + } else { + sum += 6.749733333333e-05; + } + } else { + if (ap <= 7.50000000) { + sum += 1.284083333333e-04; + } else { + sum += 9.248100000000e-06; + } + } + } + } else { + if (f107 <= 142.79999542) { + if (beta <= 25.09852600) { + if (beta <= 21.37618446) { + sum += 2.248923333333e-05; + } else { + sum += 8.353816933962e-05; + } + } else { + if (beta <= 25.58102226) { + sum += -1.372600000000e-04; + } else { + sum += -1.113100000000e-04; + } + } + } else { + if (ap <= 4.50000000) { + if (f107 <= 147.09999847) { + sum += -3.075242727273e-05; + } else { + sum += 1.004803636364e-04; + } + } else { + if (ap <= 7.50000000) { + sum += -6.829152424242e-05; + } else { + sum += -5.400928925620e-06; + } + } + } + } + } else { + if (f107_smooth <= 192.34999847) { + if (f107 <= 197.35000610) { + if (f107_smooth <= 151.55000305) { + if (f107 <= 151.75000000) { + sum += 1.542995776119e-04; + } else { + sum += 7.248538688000e-05; + } + } else { + if (beta <= 20.09912586) { + sum += 1.710522441860e-04; + } else { + sum += 7.484792198473e-05; + } + } + } else { + if (ap <= 23.00000000) { + if (f107_smooth <= 190.00000000) { + sum += 1.348204000000e-04; + } else { + sum += -2.404215000000e-05; + } + } else { + if (f107 <= 228.05000305) { + sum += 3.344170588235e-04; + } else { + sum += 4.738500000000e-05; + } + } + } + } else { + if (f107 <= 244.25000000) { + if (f107_smooth <= 192.70000458) { + if (beta <= 30.41599464) { + sum += -6.465600000000e-05; + } else { + sum += -7.481675000000e-05; + } + } else { + if (f107 <= 202.54999542) { + sum += -8.989050000000e-05; + } else { + sum += -8.338725000000e-05; + } + } + } else { + if (beta <= 28.05877686) { + sum += -2.591900000000e-05; + } else { + sum += -1.193200000000e-05; + } + } + } + } + } else { + if (beta <= 20.11412716) { + if (beta <= 20.05780220) { + sum += -9.692000000000e-05; + } else { + sum += -1.032000000000e-04; + } + } else { + if (f107 <= 175.20000458) { + if (f107 <= 162.25000000) { + if (f107 <= 154.79999542) { + if (beta <= 23.46108341) { + sum += 2.445709090909e-04; + } else { + sum += 1.195700000000e-04; + } + } else { + sum += 2.934200000000e-04; + } + } else { + sum += -3.283600000000e-05; + } + } else { + if (beta <= 22.68623924) { + if (f107_smooth <= 176.65000153) { + sum += 4.162900000000e-04; + } else { + if (beta <= 20.98794746) { + sum += 4.078500000000e-04; + } else { + sum += 4.060400000000e-04; + } + } + } else { + if (f107_smooth <= 157.25000000) { + sum += 3.138300000000e-04; + } else { + sum += 2.983100000000e-04; + } + } + } + } + } + } else { + if (ap <= 89.00000000) { + if (f107 <= 177.94999695) { + if (beta <= 24.50383282) { + if (beta <= 23.94563580) { + if (beta <= 21.47858906) { + if (beta <= 21.40618134) { + sum += 2.555229411765e-04; + } else { + sum += 2.110700000000e-04; + } + } else { + if (f107 <= 162.79999542) { + sum += 2.411400000000e-04; + } else { + sum += 1.515878947368e-04; + } + } + } else { + if (beta <= 24.13677692) { + if (beta <= 23.95482063) { + sum += 3.559200000000e-04; + } else { + sum += 4.063580000000e-04; + } + } else { + if (ap <= 5.50000000) { + sum += 3.231025000000e-04; + } else { + sum += 2.655211111111e-04; + } + } + } + } else { + if (f107 <= 176.19999695) { + if (ap <= 14.00000000) { + if (ap <= 6.50000000) { + sum += 2.140381818182e-04; + } else { + sum += 9.465366666667e-05; + } + } else { + if (ap <= 23.50000000) { + sum += 2.685954545455e-04; + } else { + sum += 1.489190000000e-04; + } + } + } else { + if (beta <= 26.20487881) { + if (beta <= 26.18173981) { + sum += 2.980300000000e-04; + } else { + sum += 3.007800000000e-04; + } + } else { + if (beta <= 26.23264027) { + sum += 3.114300000000e-04; + } else { + sum += 3.092900000000e-04; + } + } + } + } + } else { + if (ap <= 17.00000000) { + if (f107_smooth <= 220.75000000) { + if (beta <= 23.98106480) { + if (f107 <= 190.04999542) { + sum += 1.004832307692e-04; + } else { + sum += 1.724014716981e-05; + } + } else { + if (f107 <= 183.90000153) { + sum += 2.650562857143e-04; + } else { + sum += 9.484709090909e-05; + } + } + } else { + if (beta <= 24.59291744) { + if (f107 <= 247.20000458) { + sum += 2.235750000000e-04; + } else { + sum += 5.454933333333e-05; + } + } else { + if (beta <= 24.59886169) { + sum += 7.435200000000e-05; + } else { + sum += 5.056450000000e-05; + } + } + } + } else { + if (f107_smooth <= 195.84999847) { + if (f107_smooth <= 194.34999847) { + if (beta <= 29.20348167) { + sum += 3.341400000000e-04; + } else { + sum += 3.295700000000e-04; + } + } else { + sum += 3.124800000000e-04; + } + } else { + if (ap <= 26.50000000) { + if (f107_smooth <= 225.79999542) { + sum += 2.820018750000e-04; + } else { + sum += 1.737400000000e-04; + } + } else { + if (ap <= 30.50000000) { + sum += 8.177257142857e-05; + } else { + sum += 1.662973684211e-04; + } + } + } + } + } + } else { + if (beta <= 24.07762814) { + if (ap <= 121.50000000) { + if (ap <= 106.50000000) { + sum += 3.061900000000e-04; + } else { + if (beta <= 24.05796909) { + sum += 2.949800000000e-04; + } else { + sum += 2.698900000000e-04; + } + } + } else { + if (beta <= 23.96580505) { + sum += 7.163500000000e-06; + } else { + sum += 4.803900000000e-05; + } + } + } else { + sum += 1.397800000000e-03; + } + } + } + } + } + // Tree 7 + { + if (f107_smooth <= 147.20000458) { + if (f107 <= 111.75000000) { + if (f107_smooth <= 96.54999924) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + if (ap <= 4.00000000) { + if (ap <= 2.00000000) { + sum += -9.614800000000e-05; + } else { + if (beta <= 29.50582695) { + sum += -1.224800000000e-04; + } else { + sum += -1.297866666667e-04; + } + } + } else { + if (beta <= 30.00226974) { + if (f107 <= 78.70000076) { + sum += -1.561257142857e-04; + } else { + sum += -1.451450000000e-04; + } + } else { + if (beta <= 30.04290199) { + sum += -1.463500000000e-04; + } else { + sum += -1.443900000000e-04; + } + } + } + } else { + if (f107 <= 75.64999771) { + if (beta <= 29.20864582) { + sum += -3.466700000000e-05; + } else { + if (ap <= 11.50000000) { + sum += -5.814700000000e-05; + } else { + sum += -7.078700000000e-05; + } + } + } else { + if (beta <= 30.16052437) { + sum += -1.147300000000e-04; + } else { + sum += -1.035100000000e-04; + } + } + } + } else { + if (f107 <= 91.45000076) { + if (f107_smooth <= 74.85000229) { + if (ap <= 3.50000000) { + if (f107_smooth <= 74.59999847) { + sum += 1.434350000000e-04; + } else { + sum += -8.178900000000e-05; + } + } else { + if (beta <= 31.14826298) { + sum += 1.146977840909e-04; + } else { + sum += -3.870177777778e-05; + } + } + } else { + if (f107_smooth <= 75.14999771) { + if (ap <= 15.00000000) { + sum += -1.171395227273e-04; + } else { + sum += 1.142736000000e-05; + } + } else { + if (beta <= 20.02267075) { + sum += 1.493944761905e-04; + } else { + sum += 6.554793433735e-06; + } + } + } + } else { + if (f107 <= 93.64999771) { + if (f107_smooth <= 82.70000076) { + if (beta <= 23.51156616) { + sum += 2.015433333333e-04; + } else { + sum += -3.868300000000e-05; + } + } else { + if (beta <= 23.97112465) { + sum += 2.684000000000e-04; + } else { + sum += 2.069556250000e-04; + } + } + } else { + if (f107_smooth <= 87.94999695) { + if (f107 <= 100.79999924) { + sum += 1.490580666667e-04; + } else { + sum += 4.418530000000e-05; + } + } else { + if (ap <= 7.00000000) { + sum += -6.968725000000e-05; + } else { + sum += -4.610950000000e-05; + } + } + } + } + } + } else { + if (beta <= 31.16884327) { + if (f107 <= 104.70000076) { + if (beta <= 31.06991673) { + if (ap <= 6.50000000) { + if (f107 <= 99.00000000) { + sum += -1.200127272727e-04; + } else { + sum += -6.830017391304e-05; + } + } else { + if (beta <= 20.37722015) { + sum += 2.971166666667e-05; + } else { + sum += -7.413576506024e-05; + } + } + } else { + if (beta <= 31.10147285) { + sum += -2.688800000000e-05; + } else { + if (beta <= 31.13693333) { + sum += 1.206200000000e-05; + } else { + sum += 4.015400000000e-05; + } + } + } + } else { + if (f107 <= 105.35000229) { + if (ap <= 23.50000000) { + sum += 1.883200000000e-04; + } else { + sum += 2.314500000000e-04; + } + } else { + if (ap <= 19.00000000) { + if (f107 <= 107.70000076) { + sum += -6.492240909091e-05; + } else { + sum += 3.184704347826e-05; + } + } else { + if (beta <= 24.16834450) { + sum += -1.123600000000e-04; + } else { + sum += -1.342942857143e-04; + } + } + } + } + } else { + if (f107 <= 104.15000153) { + if (beta <= 31.19440174) { + sum += 8.692000000000e-05; + } else { + sum += 1.031600000000e-04; + } + } else { + if (ap <= 10.00000000) { + if (beta <= 31.25451756) { + sum += 1.731000000000e-04; + } else { + sum += 1.847700000000e-04; + } + } else { + if (f107_smooth <= 108.25000000) { + sum += 2.275300000000e-04; + } else { + if (beta <= 31.27854729) { + sum += 2.049000000000e-04; + } else { + sum += 2.139800000000e-04; + } + } + } + } + } + } + } else { + if (f107_smooth <= 130.15000153) { + if (beta <= 30.79274273) { + if (beta <= 29.13545895) { + if (beta <= 20.46049786) { + if (f107_smooth <= 128.45000458) { + if (f107_smooth <= 128.00000000) { + sum += 2.123772000000e-04; + } else { + sum += 1.476440000000e-04; + } + } else { + if (beta <= 20.10009098) { + sum += 2.797335000000e-06; + } else { + sum += 7.262150000000e-05; + } + } + } else { + if (beta <= 21.49340057) { + if (f107_smooth <= 128.40000153) { + sum += 5.055156047619e-05; + } else { + sum += -8.492623076923e-05; + } + } else { + if (beta <= 23.92283821) { + sum += 1.595034030303e-04; + } else { + sum += 9.740581546392e-05; + } + } + } + } else { + if (f107 <= 113.79999924) { + if (beta <= 30.05535412) { + sum += 1.276400000000e-04; + } else { + sum += 1.166700000000e-04; + } + } else { + if (ap <= 23.50000000) { + if (ap <= 10.00000000) { + sum += 2.227069230769e-04; + } else { + sum += 1.973546153846e-04; + } + } else { + if (beta <= 29.99421215) { + sum += 1.505100000000e-04; + } else { + sum += 1.371400000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 109.45000076) { + if (ap <= 8.50000000) { + if (f107_smooth <= 107.64999771) { + sum += 1.748900000000e-04; + } else { + if (ap <= 5.00000000) { + sum += 1.290300000000e-04; + } else { + sum += 1.071300000000e-04; + } + } + } else { + if (f107_smooth <= 108.34999847) { + if (beta <= 31.32684135) { + sum += 6.729900000000e-05; + } else { + sum += 8.025100000000e-05; + } + } else { + if (f107_smooth <= 108.65000153) { + sum += 1.598965000000e-05; + } else { + sum += -2.047100000000e-05; + } + } + } + } else { + if (beta <= 31.17761803) { + if (beta <= 31.14682007) { + if (beta <= 31.13440990) { + sum += -1.313800000000e-04; + } else { + sum += -1.301900000000e-04; + } + } else { + if (beta <= 31.15933990) { + sum += -1.250300000000e-04; + } else { + sum += -1.224800000000e-04; + } + } + } else { + if (beta <= 31.23638821) { + if (f107 <= 129.05000305) { + sum += -1.023233333333e-04; + } else { + sum += -1.115900000000e-04; + } + } else { + sum += -9.156200000000e-05; + } + } + } + } + } else { + if (ap <= 3.50000000) { + if (f107_smooth <= 131.29999542) { + if (beta <= 21.47912407) { + if (beta <= 21.42962646) { + if (beta <= 21.38076687) { + sum += -6.495800000000e-05; + } else { + sum += -4.958700000000e-05; + } + } else { + sum += -2.466600000000e-05; + } + } else { + if (beta <= 21.55921078) { + if (beta <= 21.50816822) { + sum += -6.752900000000e-06; + } else { + sum += 3.247500000000e-06; + } + } else { + sum += 4.543300000000e-05; + } + } + } else { + if (beta <= 25.36858082) { + if (f107_smooth <= 132.09999847) { + if (f107_smooth <= 131.94999695) { + sum += 2.265137500000e-04; + } else { + sum += 1.850680000000e-04; + } + } else { + if (beta <= 24.03263760) { + sum += 2.006390000000e-04; + } else { + sum += 1.025274318182e-04; + } + } + } else { + if (beta <= 25.91370201) { + sum += -1.624000000000e-05; + } else { + sum += 9.207400000000e-06; + } + } + } + } else { + if (beta <= 23.96213913) { + if (beta <= 20.10294819) { + if (f107 <= 126.15000153) { + if (f107 <= 117.95000076) { + sum += 4.863200000000e-05; + } else { + sum += -1.466005000000e-05; + } + } else { + if (beta <= 20.05158043) { + sum += -9.371637500000e-05; + } else { + sum += -1.055325555556e-04; + } + } + } else { + if (beta <= 20.51762009) { + if (beta <= 20.15243435) { + sum += 6.587311111111e-05; + } else { + sum += 1.689497714286e-04; + } + } else { + if (beta <= 23.59010220) { + sum += 6.668497727273e-06; + } else { + sum += 8.560806938776e-05; + } + } + } + } else { + if (beta <= 24.08279324) { + if (beta <= 23.98917866) { + if (ap <= 17.00000000) { + sum += -7.781212500000e-05; + } else { + sum += 7.107816666667e-06; + } + } else { + if (ap <= 6.50000000) { + sum += -7.533620000000e-05; + } else { + sum += -1.012130833333e-04; + } + } + } else { + if (beta <= 25.07376385) { + if (f107_smooth <= 131.35000610) { + sum += -9.943807692308e-05; + } else { + sum += 4.965469243056e-05; + } + } else { + if (f107_smooth <= 142.40000153) { + sum += -1.200380000000e-04; + } else { + sum += -3.089622500000e-05; + } + } + } + } + } + } + } + } else { + if (f107_smooth <= 194.00000000) { + if (ap <= 44.00000000) { + if (f107_smooth <= 192.34999847) { + if (ap <= 32.50000000) { + if (ap <= 30.50000000) { + if (f107_smooth <= 150.65000153) { + if (f107 <= 153.44999695) { + sum += 1.711908443114e-04; + } else { + sum += 3.006111068966e-05; + } + } else { + if (ap <= 5.50000000) { + sum += 1.066972469106e-04; + } else { + sum += 7.561348530233e-05; + } + } + } else { + if (ap <= 31.50000000) { + if (f107 <= 193.04999542) { + sum += 2.948775000000e-04; + } else { + sum += 3.291600000000e-04; + } + } else { + if (f107 <= 179.14999390) { + sum += 1.431485714286e-04; + } else { + sum += -1.667600000000e-05; + } + } + } + } else { + if (f107_smooth <= 156.59999847) { + if (f107 <= 163.34999847) { + if (ap <= 37.50000000) { + sum += 1.354953333333e-04; + } else { + sum += -5.694500000000e-05; + } + } else { + if (beta <= 24.10185051) { + sum += -3.883600000000e-05; + } else { + sum += -5.960233333333e-05; + } + } + } else { + if (beta <= 27.19026184) { + if (ap <= 41.00000000) { + sum += -5.301888888889e-05; + } else { + sum += -6.279814285714e-05; + } + } else { + if (ap <= 38.00000000) { + sum += -2.518478750000e-05; + } else { + sum += 3.330600000000e-04; + } + } + } + } + } else { + if (f107 <= 172.69999695) { + if (ap <= 23.00000000) { + if (f107_smooth <= 193.05000305) { + sum += 2.928600000000e-04; + } else { + if (beta <= 29.29731274) { + sum += 3.188500000000e-04; + } else { + sum += 3.125800000000e-04; + } + } + } else { + sum += 2.267800000000e-05; + } + } else { + if (f107 <= 244.25000000) { + if (f107_smooth <= 193.75000000) { + if (beta <= 20.53281021) { + sum += -8.881912500000e-05; + } else { + sum += -7.388128571429e-05; + } + } else { + if (beta <= 20.64396000) { + sum += -4.669950000000e-05; + } else { + sum += -3.541200000000e-05; + } + } + } else { + sum += -2.591900000000e-05; + } + } + } + } else { + if (f107 <= 164.05000305) { + if (f107_smooth <= 156.70000458) { + if (f107 <= 131.89999390) { + sum += -1.292900000000e-04; + } else { + if (f107 <= 151.59999847) { + if (f107 <= 141.14999390) { + sum += 1.900200000000e-04; + } else { + sum += 1.180800000000e-04; + } + } else { + if (beta <= 24.73669720) { + sum += 7.908800000000e-05; + } else { + sum += 7.213200000000e-05; + } + } + } + } else { + if (beta <= 29.13755703) { + sum += 2.834100000000e-04; + } else { + sum += 2.967500000000e-04; + } + } + } else { + if (f107 <= 213.54999542) { + if (f107_smooth <= 151.19999695) { + if (beta <= 24.49140835) { + sum += 2.613200000000e-04; + } else { + sum += 2.444200000000e-04; + } + } else { + if (f107 <= 191.10000610) { + if (beta <= 24.28073311) { + sum += 3.091500000000e-04; + } else { + sum += 3.146940000000e-04; + } + } else { + if (beta <= 27.43329525) { + sum += 2.774820000000e-04; + } else { + sum += 2.983100000000e-04; + } + } + } + } else { + if (beta <= 20.91299820) { + sum += 3.754300000000e-04; + } else { + if (beta <= 21.03825283) { + if (ap <= 162.00000000) { + sum += 4.015200000000e-04; + } else { + sum += 4.032800000000e-04; + } + } else { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } + } + } + } + } + } else { + if (ap <= 15.50000000) { + if (f107 <= 177.94999695) { + if (beta <= 24.53393936) { + if (beta <= 23.94563580) { + if (f107_smooth <= 207.65000153) { + if (f107 <= 173.40000153) { + sum += 2.409082352941e-04; + } else { + sum += 1.779166666667e-04; + } + } else { + if (f107 <= 171.65000153) { + sum += 1.539050000000e-04; + } else { + sum += 1.193275000000e-04; + } + } + } else { + if (beta <= 24.13862228) { + if (beta <= 23.95482063) { + sum += 3.559200000000e-04; + } else { + sum += 4.106025000000e-04; + } + } else { + if (ap <= 11.50000000) { + sum += 3.091981481481e-04; + } else { + sum += 2.651455555556e-04; + } + } + } + } else { + if (ap <= 6.50000000) { + if (beta <= 25.85416698) { + if (f107_smooth <= 200.00000000) { + sum += 1.395000000000e-04; + } else { + sum += 1.810200000000e-04; + } + } else { + if (ap <= 4.50000000) { + sum += 2.238900000000e-04; + } else { + sum += 2.859021428571e-04; + } + } + } else { + if (f107 <= 168.59999847) { + if (f107_smooth <= 200.25000000) { + sum += 7.294333333333e-05; + } else { + sum += 1.219344285714e-05; + } + } else { + if (f107_smooth <= 195.40000153) { + sum += 1.065400000000e-04; + } else { + sum += 1.532300000000e-04; + } + } + } + } + } else { + if (beta <= 28.62727642) { + if (f107_smooth <= 220.75000000) { + if (beta <= 22.56651306) { + if (f107 <= 199.75000000) { + sum += 6.995041666667e-05; + } else { + sum += -2.741823529412e-05; + } + } else { + if (f107 <= 183.75000000) { + sum += 2.461606666667e-04; + } else { + sum += 8.547475000000e-05; + } + } + } else { + if (beta <= 24.59376049) { + if (f107 <= 247.20000458) { + sum += 2.389139130435e-04; + } else { + sum += 6.016355555556e-05; + } + } else { + if (beta <= 24.59650803) { + sum += 8.667400000000e-05; + } else { + sum += 5.416366666667e-05; + } + } + } + } else { + if (beta <= 28.76688957) { + sum += 2.439800000000e-04; + } else { + if (f107_smooth <= 194.55000305) { + if (beta <= 29.12022972) { + sum += 3.400600000000e-04; + } else { + sum += 3.396200000000e-04; + } + } else { + sum += 4.669000000000e-04; + } + } + } + } + } else { + if (ap <= 18.50000000) { + if (beta <= 24.08898258) { + if (f107_smooth <= 207.34999847) { + if (beta <= 23.98511219) { + sum += 3.824100000000e-05; + } else { + sum += 2.758000000000e-04; + } + } else { + sum += 1.384500000000e-03; + } + } else { + if (f107 <= 196.55000305) { + if (beta <= 24.55337715) { + if (beta <= 24.49964714) { + sum += 3.382400000000e-04; + } else { + sum += 3.349650000000e-04; + } + } else { + if (ap <= 16.50000000) { + sum += 2.913975000000e-04; + } else { + sum += 2.118650000000e-04; + } + } + } else { + sum += 4.126900000000e-04; + } + } + } else { + if (f107_smooth <= 218.45000458) { + if (beta <= 22.41878700) { + if (beta <= 20.86458969) { + sum += 1.181900000000e-04; + } else { + if (beta <= 20.88193989) { + sum += 1.299000000000e-04; + } else { + sum += 1.321100000000e-04; + } + } + } else { + if (f107_smooth <= 208.34999847) { + if (ap <= 106.50000000) { + sum += 3.143650000000e-04; + } else { + sum += 2.841600000000e-04; + } + } else { + if (beta <= 24.13595867) { + sum += 1.825166666667e-04; + } else { + sum += 2.939742857143e-04; + } + } + } + } else { + if (ap <= 24.50000000) { + if (beta <= 23.07937717) { + sum += 1.985900000000e-04; + } else { + if (beta <= 24.53882694) { + sum += 2.681462500000e-04; + } else { + sum += 1.994300000000e-04; + } + } + } else { + if (beta <= 23.91534233) { + if (ap <= 38.50000000) { + sum += 1.206600000000e-05; + } else { + sum += 1.321850000000e-04; + } + } else { + if (beta <= 24.37648010) { + sum += 1.278265000000e-04; + } else { + sum += 1.693445454545e-04; + } + } + } + } + } + } + } + } + } + // Tree 8 + { + if (f107 <= 112.90000153) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (beta <= 20.01418686) { + if (f107_smooth <= 77.95000076) { + if (ap <= 7.00000000) { + if (beta <= 19.99444103) { + sum += 1.542500000000e-04; + } else { + sum += 1.367300000000e-04; + } + } else { + if (beta <= 20.00238609) { + sum += 1.139200000000e-04; + } else { + sum += 9.173500000000e-05; + } + } + } else { + if (ap <= 3.00000000) { + if (f107 <= 78.44999695) { + sum += 1.779300000000e-04; + } else { + sum += 1.625200000000e-04; + } + } else { + if (f107 <= 75.35000229) { + sum += 1.630000000000e-04; + } else { + if (beta <= 19.98829079) { + sum += 2.024566666667e-04; + } else { + sum += 1.972066666667e-04; + } + } + } + } + } else { + if (beta <= 20.49999523) { + if (beta <= 20.07313728) { + if (f107 <= 75.85000229) { + if (beta <= 20.03091621) { + sum += 1.270800000000e-04; + } else { + sum += 1.044700000000e-04; + } + } else { + if (ap <= 6.00000000) { + sum += 3.997685714286e-05; + } else { + sum += -6.789500000000e-05; + } + } + } else { + if (f107 <= 79.04999924) { + if (f107 <= 76.15000153) { + sum += -1.395926666667e-04; + } else { + sum += -1.164308333333e-04; + } + } else { + if (beta <= 20.13906860) { + sum += -2.842180000000e-05; + } else { + sum += -8.032545454545e-05; + } + } + } + } else { + if (beta <= 21.31218910) { + if (f107 <= 73.90000153) { + if (f107_smooth <= 75.95000076) { + sum += 5.948600000000e-06; + } else { + sum += -6.002600000000e-05; + } + } else { + if (f107 <= 89.00000000) { + sum += 1.656945365854e-04; + } else { + sum += 8.042545000000e-06; + } + } + } else { + if (beta <= 23.92033958) { + if (f107 <= 83.54999924) { + sum += -6.494161642857e-05; + } else { + sum += 1.149185714286e-04; + } + } else { + if (beta <= 24.20989132) { + sum += 1.091954246377e-04; + } else { + sum += 7.600285220126e-06; + } + } + } + } + } + } else { + if (f107 <= 94.34999847) { + if (f107 <= 91.60000229) { + if (f107 <= 91.29999924) { + sum += 1.525000000000e-04; + } else { + sum += -2.920800000000e-05; + } + } else { + if (f107 <= 92.90000153) { + if (beta <= 24.30285835) { + if (ap <= 11.50000000) { + sum += 2.177600000000e-04; + } else { + sum += 2.365925000000e-04; + } + } else { + if (ap <= 5.00000000) { + sum += 2.138200000000e-04; + } else { + sum += 1.935340000000e-04; + } + } + } else { + if (f107 <= 93.40000153) { + sum += -2.033500000000e-05; + } else { + if (ap <= 4.00000000) { + sum += 6.883750000000e-05; + } else { + sum += 1.699690000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 87.94999695) { + if (f107 <= 98.54999924) { + if (f107_smooth <= 85.09999847) { + if (f107 <= 95.60000229) { + sum += 1.214550000000e-04; + } else { + sum += 1.713300000000e-04; + } + } else { + if (ap <= 12.50000000) { + sum += 2.271200000000e-04; + } else { + sum += 2.429400000000e-04; + } + } + } else { + if (beta <= 23.88143826) { + if (f107 <= 111.50000000) { + sum += -3.115700000000e-05; + } else { + sum += 2.712300000000e-05; + } + } else { + if (f107 <= 99.59999847) { + sum += 1.150495000000e-05; + } else { + sum += 9.595131250000e-05; + } + } + } + } else { + if (ap <= 7.00000000) { + if (beta <= 24.15342617) { + sum += -5.732400000000e-05; + } else { + if (f107 <= 99.25000000) { + sum += -7.454900000000e-05; + } else { + sum += -8.955200000000e-05; + } + } + } else { + if (beta <= 24.24073029) { + sum += -4.164300000000e-05; + } else { + sum += -5.480200000000e-05; + } + } + } + } + } + } else { + if (f107 <= 102.85000229) { + if (ap <= 6.50000000) { + if (beta <= 30.86555576) { + if (f107 <= 98.84999847) { + if (f107_smooth <= 96.64999771) { + if (beta <= 25.91241932) { + sum += -6.658700000000e-05; + } else { + sum += -7.550300000000e-05; + } + } else { + if (f107_smooth <= 120.65000153) { + sum += -1.341108604651e-04; + } else { + sum += -1.161648888889e-04; + } + } + } else { + if (beta <= 29.26829243) { + if (beta <= 26.43820572) { + sum += -1.099188571429e-04; + } else { + sum += -7.359925000000e-05; + } + } else { + if (beta <= 30.53624344) { + sum += -1.789533333333e-05; + } else { + sum += 1.417000000000e-04; + } + } + } + } else { + if (f107 <= 95.94999695) { + if (f107 <= 94.25000000) { + sum += -9.851100000000e-07; + } else { + sum += -3.882900000000e-05; + } + } else { + if (beta <= 31.15727615) { + sum += 4.015400000000e-05; + } else { + sum += 5.871200000000e-05; + } + } + } + } else { + if (beta <= 20.38100624) { + if (f107 <= 97.20000076) { + sum += -1.288400000000e-04; + } else { + if (ap <= 12.00000000) { + if (f107 <= 99.29999924) { + sum += 1.018400000000e-05; + } else { + sum += 5.201400000000e-05; + } + } else { + if (ap <= 19.00000000) { + sum += 8.958700000000e-05; + } else { + sum += 1.329600000000e-04; + } + } + } + } else { + if (f107_smooth <= 109.50000000) { + if (f107_smooth <= 107.34999847) { + if (f107_smooth <= 103.95000076) { + sum += -4.505825000000e-05; + } else { + sum += -1.002353333333e-04; + } + } else { + if (f107 <= 94.34999847) { + sum += 1.256220000000e-05; + } else { + sum += 8.172628571429e-05; + } + } + } else { + if (f107 <= 95.35000229) { + if (beta <= 30.95243073) { + sum += -1.334725000000e-04; + } else { + sum += -8.779500000000e-05; + } + } else { + if (f107 <= 95.89999771) { + sum += -3.445633333333e-05; + } else { + sum += -7.995318000000e-05; + } + } + } + } + } + } else { + if (beta <= 30.41348362) { + if (beta <= 24.03769779) { + if (beta <= 23.09329605) { + if (f107_smooth <= 129.00000000) { + if (f107_smooth <= 123.04999924) { + sum += -1.017441428571e-04; + } else { + sum += -1.001294285714e-05; + } + } else { + if (beta <= 21.87580109) { + sum += 1.470300000000e-04; + } else { + sum += 1.792000000000e-04; + } + } + } else { + if (f107_smooth <= 122.95000076) { + if (beta <= 23.47125149) { + sum += 1.098300000000e-04; + } else { + sum += 1.246500000000e-04; + } + } else { + if (ap <= 13.50000000) { + sum += 1.990250000000e-04; + } else { + sum += 2.273277777778e-04; + } + } + } + } else { + if (ap <= 19.00000000) { + if (f107 <= 111.50000000) { + if (f107 <= 108.70000076) { + sum += -3.256010526316e-05; + } else { + sum += 6.428955217391e-05; + } + } else { + if (ap <= 9.00000000) { + sum += -9.573912500000e-05; + } else { + sum += -1.140000000000e-04; + } + } + } else { + if (ap <= 31.50000000) { + if (beta <= 24.18922806) { + sum += -1.111600000000e-04; + } else { + sum += -1.334971428571e-04; + } + } else { + if (beta <= 24.24029160) { + sum += -1.101000000000e-04; + } else { + sum += -1.035600000000e-04; + } + } + } + } + } else { + if (f107 <= 104.10000229) { + if (beta <= 31.19440174) { + sum += 8.692000000000e-05; + } else { + sum += 1.031600000000e-04; + } + } else { + if (ap <= 18.50000000) { + if (ap <= 13.50000000) { + if (beta <= 31.29815197) { + sum += 2.275300000000e-04; + } else { + sum += 2.311700000000e-04; + } + } else { + if (beta <= 31.27854729) { + sum += 2.049000000000e-04; + } else { + sum += 2.139800000000e-04; + } + } + } else { + if (beta <= 30.55158138) { + sum += 1.883200000000e-04; + } else { + sum += 1.727400000000e-04; + } + } + } + } + } + } + } else { + if (f107_smooth <= 194.00000000) { + if (f107_smooth <= 147.75000000) { + if (f107_smooth <= 128.15000153) { + if (beta <= 30.76705360) { + if (f107 <= 134.34999847) { + if (beta <= 29.12565804) { + if (f107_smooth <= 122.55000305) { + sum += 5.374020555556e-05; + } else { + sum += 1.372766393443e-04; + } + } else { + if (ap <= 9.50000000) { + sum += 2.240381818182e-04; + } else { + sum += 1.824662500000e-04; + } + } + } else { + if (ap <= 26.50000000) { + if (f107_smooth <= 127.84999847) { + sum += 2.066363508772e-04; + } else { + sum += 1.049400000000e-04; + } + } else { + if (beta <= 22.30188274) { + sum += 8.997700000000e-05; + } else { + sum += 6.529400000000e-05; + } + } + } + } else { + if (f107_smooth <= 109.45000076) { + if (f107 <= 120.79999924) { + if (f107 <= 116.15000153) { + sum += 1.309325000000e-04; + } else { + sum += 2.179500000000e-04; + } + } else { + if (f107_smooth <= 108.65000153) { + sum += 7.233420000000e-05; + } else { + sum += -5.331162500000e-05; + } + } + } else { + if (beta <= 31.17761803) { + if (f107 <= 127.45000458) { + sum += -1.308900000000e-04; + } else { + sum += -1.237550000000e-04; + } + } else { + if (f107_smooth <= 109.59999847) { + sum += -9.771400000000e-05; + } else { + sum += -1.107366666667e-04; + } + } + } + } + } else { + if (f107 <= 147.94999695) { + if (f107_smooth <= 147.09999847) { + if (beta <= 20.06238365) { + if (f107 <= 126.15000153) { + sum += -2.883700000000e-05; + } else { + sum += -9.793358333333e-05; + } + } else { + if (beta <= 20.72330856) { + sum += 1.274244905405e-04; + } else { + sum += 4.736446826347e-05; + } + } + } else { + if (ap <= 16.00000000) { + if (beta <= 24.71951675) { + sum += 2.084250000000e-04; + } else { + sum += 2.239150000000e-04; + } + } else { + if (ap <= 27.00000000) { + sum += 1.636340000000e-04; + } else { + sum += 1.124460000000e-04; + } + } + } + } else { + if (ap <= 4.50000000) { + if (beta <= 23.85286427) { + if (f107 <= 154.10000610) { + sum += 2.412175000000e-04; + } else { + sum += 1.485880000000e-04; + } + } else { + if (f107_smooth <= 144.79999542) { + sum += -8.304520000000e-05; + } else { + sum += 4.129541666667e-05; + } + } + } else { + if (ap <= 8.50000000) { + if (beta <= 20.49329281) { + sum += 2.509500000000e-04; + } else { + sum += -5.661599056604e-05; + } + } else { + if (f107_smooth <= 134.59999847) { + sum += 8.108527619048e-05; + } else { + sum += -2.378225214286e-05; + } + } + } + } + } + } else { + if (ap <= 52.50000000) { + if (f107_smooth <= 190.25000000) { + if (f107 <= 202.59999847) { + if (f107_smooth <= 186.34999847) { + if (f107_smooth <= 169.79999542) { + sum += 9.950392815642e-05; + } else { + sum += 4.787978663677e-05; + } + } else { + if (f107 <= 171.34999847) { + sum += 1.940700000000e-04; + } else { + sum += 2.833907692308e-04; + } + } + } else { + if (f107_smooth <= 175.15000153) { + if (beta <= 30.02348995) { + sum += 1.884361454545e-04; + } else { + sum += 4.541781724138e-05; + } + } else { + if (ap <= 5.50000000) { + sum += 2.215066666667e-04; + } else { + sum += 2.780408571429e-04; + } + } + } + } else { + if (f107 <= 172.69999695) { + if (f107 <= 167.50000000) { + if (ap <= 8.50000000) { + sum += 1.065840000000e-04; + } else { + sum += -5.990100000000e-06; + } + } else { + if (beta <= 28.25668240) { + sum += 3.089887500000e-05; + } else { + sum += 2.609691666667e-04; + } + } + } else { + if (beta <= 30.84701729) { + if (f107 <= 245.50000000) { + sum += -6.580620000000e-05; + } else { + sum += -1.401433250000e-05; + } + } else { + if (beta <= 30.94947338) { + sum += 4.414725000000e-05; + } else { + sum += 8.804280000000e-05; + } + } + } + } + } else { + if (f107 <= 149.69999695) { + if (beta <= 23.46108341) { + if (beta <= 22.91598129) { + sum += 1.900200000000e-04; + } else { + sum += 2.430000000000e-04; + } + } else { + if (beta <= 23.97583103) { + sum += 1.270200000000e-04; + } else { + sum += 1.121200000000e-04; + } + } + } else { + if (f107_smooth <= 170.79999542) { + if (f107 <= 191.10000610) { + if (beta <= 27.59968376) { + sum += 3.109383333333e-04; + } else { + sum += 2.939850000000e-04; + } + } else { + sum += 2.686400000000e-04; + } + } else { + if (beta <= 20.91299820) { + sum += 3.754300000000e-04; + } else { + if (f107_smooth <= 177.09999847) { + sum += 4.151700000000e-04; + } else { + sum += 4.015200000000e-04; + } + } + } + } + } + } + } else { + if (f107 <= 232.90000153) { + if (ap <= 89.00000000) { + if (ap <= 12.50000000) { + if (f107 <= 177.94999695) { + if (beta <= 24.52982044) { + if (beta <= 23.94798183) { + sum += 2.100800000000e-04; + } else { + sum += 3.141012903226e-04; + } + } else { + if (ap <= 6.50000000) { + sum += 2.275308695652e-04; + } else { + sum += 9.534441600000e-05; + } + } + } else { + if (f107 <= 229.10000610) { + if (beta <= 22.73829937) { + sum += 2.540600000000e-05; + } else { + sum += 1.403280487805e-04; + } + } else { + if (ap <= 10.50000000) { + sum += 3.029915384615e-04; + } else { + sum += 1.382700000000e-04; + } + } + } + } else { + if (f107_smooth <= 208.69999695) { + if (f107_smooth <= 207.34999847) { + if (beta <= 22.44836807) { + sum += 1.397760000000e-04; + } else { + sum += 3.334880952381e-04; + } + } else { + if (beta <= 24.08898258) { + sum += 1.384500000000e-03; + } else { + sum += 3.110900000000e-04; + } + } + } else { + if (f107 <= 180.00000000) { + if (f107 <= 170.79999542) { + sum += 2.767914285714e-04; + } else { + sum += 2.189220000000e-04; + } + } else { + if (ap <= 14.50000000) { + sum += 8.014700000000e-05; + } else { + sum += 1.824743750000e-04; + } + } + } + } + } else { + if (beta <= 24.07762814) { + if (f107_smooth <= 207.34999847) { + sum += 2.984300000000e-04; + } else { + sum += 3.061900000000e-04; + } + } else { + sum += 1.397800000000e-03; + } + } + } else { + if (beta <= 22.63174343) { + if (beta <= 21.99576473) { + if (beta <= 21.91329765) { + sum += -2.005400000000e-05; + } else { + if (ap <= 3.50000000) { + sum += -3.356800000000e-05; + } else { + sum += -3.939000000000e-05; + } + } + } else { + if (f107 <= 233.54999542) { + sum += -6.443600000000e-05; + } else { + sum += -6.224300000000e-05; + } + } + } else { + if (beta <= 23.49936199) { + if (f107_smooth <= 221.90000153) { + if (f107_smooth <= 221.75000000) { + if (beta <= 23.22817230) { + sum += 2.807366666667e-04; + } else { + sum += 2.674300000000e-04; + } + } else { + if (beta <= 23.32218075) { + sum += 2.562800000000e-04; + } else { + sum += 2.479000000000e-04; + } + } + } else { + if (beta <= 23.46283340) { + if (beta <= 23.41647530) { + sum += 2.289400000000e-04; + } else { + sum += 1.993233333333e-04; + } + } else { + sum += 2.333700000000e-04; + } + } + } else { + if (beta <= 24.07706070) { + if (f107 <= 245.90000153) { + if (f107_smooth <= 203.40000153) { + sum += 5.851175000000e-05; + } else { + sum += 1.178575000000e-04; + } + } else { + if (ap <= 11.50000000) { + sum += 4.771353846154e-05; + } else { + sum += 7.560418750000e-05; + } + } + } else { + if (beta <= 24.48735523) { + if (beta <= 24.32049274) { + sum += 1.793625000000e-04; + } else { + sum += 2.604883333333e-04; + } + } else { + if (beta <= 24.59099674) { + sum += 1.307457142857e-04; + } else { + sum += 7.750522222222e-05; + } + } + } + } + } + } + } + } + } + // Tree 9 + { + if (f107_smooth <= 194.00000000) { + if (f107 <= 112.90000153) { + if (f107_smooth <= 109.39999771) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 96.54999924) { + if (f107_smooth <= 74.25000000) { + if (beta <= 29.51142406) { + if (beta <= 29.39252377) { + sum += -8.904000000000e-05; + } else { + sum += -1.185466666667e-04; + } + } else { + if (beta <= 30.05796814) { + sum += -1.520800000000e-04; + } else { + sum += -1.363500000000e-04; + } + } + } else { + if (f107_smooth <= 74.85000229) { + if (beta <= 25.02692699) { + sum += 1.844292857143e-04; + } else { + sum += 5.165037333333e-05; + } + } else { + if (f107 <= 74.04999924) { + sum += -4.776561395349e-05; + } else { + sum += 2.070090080760e-05; + } + } + } + } else { + if (f107 <= 79.95000076) { + if (f107 <= 76.79999924) { + if (beta <= 26.25127697) { + sum += -1.439850000000e-04; + } else { + sum += -1.494700000000e-04; + } + } else { + if (beta <= 26.31961536) { + sum += -1.321000000000e-04; + } else { + sum += -1.391350000000e-04; + } + } + } else { + if (f107_smooth <= 100.79999924) { + if (beta <= 25.95119095) { + sum += -7.550300000000e-05; + } else { + sum += -9.834450000000e-05; + } + } else { + if (beta <= 29.01013851) { + sum += -1.136266666667e-04; + } else { + sum += -1.305633333333e-04; + } + } + } + } + } else { + if (f107 <= 93.64999771) { + if (f107_smooth <= 82.70000076) { + if (f107_smooth <= 81.14999771) { + if (f107 <= 93.00000000) { + sum += 2.205600000000e-04; + } else { + sum += 1.761000000000e-04; + } + } else { + if (beta <= 24.54909134) { + sum += -3.868300000000e-05; + } else { + sum += -2.033500000000e-05; + } + } + } else { + if (beta <= 28.06412888) { + if (f107 <= 91.60000229) { + sum += 7.646600000000e-05; + } else { + sum += 2.105068965517e-04; + } + } else { + sum += 2.257300000000e-05; + } + } + } else { + if (ap <= 12.50000000) { + if (beta <= 29.95489216) { + if (f107_smooth <= 88.05000305) { + sum += 5.632024848485e-05; + } else { + sum += -5.799054285714e-05; + } + } else { + if (ap <= 8.50000000) { + sum += 1.230035555556e-04; + } else { + sum += 5.757316666667e-05; + } + } + } else { + if (f107_smooth <= 107.89999771) { + if (beta <= 24.24829578) { + sum += 2.126080000000e-04; + } else { + sum += 1.511212500000e-04; + } + } else { + if (beta <= 31.28868198) { + sum += 2.071700000000e-04; + } else { + sum += 2.293500000000e-04; + } + } + } + } + } + } else { + if (f107 <= 108.00000000) { + if (ap <= 23.00000000) { + if (ap <= 6.50000000) { + if (f107_smooth <= 114.79999924) { + if (f107 <= 103.04999924) { + sum += -3.397303666667e-05; + } else { + sum += -1.244900000000e-04; + } + } else { + if (f107 <= 99.29999924) { + sum += -1.312622758621e-04; + } else { + sum += -1.029562400000e-04; + } + } + } else { + if (beta <= 24.01799107) { + if (beta <= 23.27289486) { + sum += -6.567195000000e-05; + } else { + sum += 5.471387777778e-05; + } + } else { + if (beta <= 24.34711933) { + sum += -1.437144444444e-04; + } else { + sum += -7.932276470588e-05; + } + } + } + } else { + if (f107 <= 104.20000076) { + if (f107_smooth <= 129.55000305) { + sum += 2.116700000000e-05; + } else { + sum += -9.970900000000e-05; + } + } else { + if (beta <= 23.89560604) { + sum += 2.314500000000e-04; + } else { + sum += 2.272400000000e-04; + } + } + } + } else { + if (beta <= 25.34645939) { + if (beta <= 21.56463337) { + if (ap <= 5.00000000) { + if (beta <= 21.26819038) { + sum += -7.768000000000e-05; + } else { + sum += -5.829100000000e-05; + } + } else { + if (beta <= 20.63921642) { + sum += -3.907758000000e-06; + } else { + sum += -1.831500000000e-05; + } + } + } else { + if (ap <= 21.00000000) { + if (f107_smooth <= 132.10000610) { + sum += 1.530252727273e-04; + } else { + sum += 1.904562500000e-05; + } + } else { + if (beta <= 24.09133530) { + sum += -1.131000000000e-04; + } else { + sum += -1.113900000000e-04; + } + } + } + } else { + if (beta <= 28.17639351) { + if (ap <= 17.00000000) { + if (f107 <= 112.00000000) { + sum += -1.125066666667e-04; + } else { + sum += -9.489437500000e-05; + } + } else { + if (beta <= 25.36328220) { + sum += -1.366500000000e-04; + } else { + sum += -1.364000000000e-04; + } + } + } else { + if (f107 <= 109.95000076) { + sum += 5.777700000000e-06; + } else { + if (beta <= 28.81547356) { + sum += 2.103200000000e-05; + } else { + sum += 4.284375000000e-05; + } + } + } + } + } + } + } else { + if (ap <= 38.00000000) { + if (f107_smooth <= 128.05000305) { + if (f107 <= 134.34999847) { + if (beta <= 30.79274273) { + if (beta <= 24.49887943) { + if (beta <= 24.02804470) { + sum += 7.769136739130e-05; + } else { + sum += -1.509155000000e-05; + } + } else { + if (f107_smooth <= 104.55000305) { + sum += 1.159213809524e-04; + } else { + sum += 1.825139565217e-04; + } + } + } else { + if (f107_smooth <= 108.00000000) { + if (ap <= 11.50000000) { + sum += 1.648700000000e-04; + } else { + sum += 2.232040000000e-04; + } + } else { + if (f107_smooth <= 109.45000076) { + sum += 3.138564761905e-05; + } else { + sum += -1.181872000000e-04; + } + } + } + } else { + if (beta <= 20.36914349) { + if (beta <= 20.33137798) { + if (ap <= 11.50000000) { + sum += 2.340211111111e-04; + } else { + sum += 2.432550000000e-04; + } + } else { + if (beta <= 20.35290337) { + sum += 2.132400000000e-04; + } else { + sum += 2.162500000000e-04; + } + } + } else { + if (f107_smooth <= 119.34999847) { + if (beta <= 21.71895123) { + sum += 1.754233333333e-04; + } else { + sum += 2.315487500000e-04; + } + } else { + if (beta <= 25.24694920) { + sum += 1.474889600000e-04; + } else { + sum += 2.062537500000e-04; + } + } + } + } + } else { + if (f107_smooth <= 147.25000000) { + if (f107 <= 142.00000000) { + if (beta <= 25.14747810) { + if (f107_smooth <= 131.34999847) { + sum += 1.401284473684e-05; + } else { + sum += 8.069719569378e-05; + } + } else { + if (f107 <= 121.34999847) { + sum += -1.397250000000e-04; + } else { + sum += -1.317050000000e-04; + } + } + } else { + if (f107_smooth <= 134.90000153) { + if (beta <= 20.41070461) { + sum += 2.058350000000e-04; + } else { + sum += 2.413105724638e-06; + } + } else { + if (beta <= 23.15650558) { + sum += -8.225644444444e-05; + } else { + sum += 2.761428571428e-08; + } + } + } + } else { + if (ap <= 23.50000000) { + if (f107_smooth <= 150.65000153) { + if (f107 <= 147.15000153) { + sum += 1.721600376147e-04; + } else { + sum += 5.843270520833e-05; + } + } else { + if (ap <= 7.50000000) { + sum += 8.258098842900e-05; + } else { + sum += 4.055083076667e-05; + } + } + } else { + if (f107 <= 184.19999695) { + if (beta <= 30.90579891) { + sum += 1.173599873418e-04; + } else { + sum += -4.934928571429e-05; + } + } else { + if (f107_smooth <= 150.95000458) { + sum += -5.751400000000e-05; + } else { + sum += 2.693380689655e-04; + } + } + } + } + } + } else { + if (f107 <= 185.75000000) { + if (beta <= 26.40749454) { + if (f107_smooth <= 157.40000153) { + if (beta <= 20.12273693) { + if (beta <= 20.05482864) { + sum += -1.021476666667e-04; + } else { + sum += -9.692000000000e-05; + } + } else { + if (f107 <= 173.84999847) { + sum += 1.427633548387e-04; + } else { + sum += 3.134960000000e-04; + } + } + } else { + if (ap <= 41.00000000) { + if (beta <= 25.64873505) { + sum += -4.813600000000e-05; + } else { + sum += -4.449800000000e-05; + } + } else { + if (beta <= 21.87044621) { + sum += -6.174900000000e-05; + } else { + sum += -6.506233333333e-05; + } + } + } + } else { + if (f107 <= 136.95000076) { + sum += 1.380200000000e-04; + } else { + if (beta <= 27.57347107) { + if (beta <= 27.20942593) { + sum += 3.131100000000e-04; + } else { + sum += 3.264000000000e-04; + } + } else { + if (ap <= 73.00000000) { + sum += 2.889800000000e-04; + } else { + sum += 2.959175000000e-04; + } + } + } + } + } else { + if (f107 <= 213.54999542) { + if (beta <= 25.85732841) { + if (beta <= 23.89993095) { + sum += 2.959900000000e-04; + } else { + if (beta <= 24.30503178) { + sum += 3.104100000000e-04; + } else { + sum += 3.073200000000e-04; + } + } + } else { + sum += 2.686400000000e-04; + } + } else { + if (beta <= 20.93826675) { + sum += 3.754300000000e-04; + } else { + if (beta <= 21.03825283) { + if (beta <= 21.00016785) { + sum += 4.060400000000e-04; + } else { + sum += 4.032800000000e-04; + } + } else { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } + } + } + } + } + } + } else { + if (ap <= 16.50000000) { + if (f107 <= 177.94999695) { + if (beta <= 26.82339287) { + if (f107_smooth <= 216.15000153) { + if (f107_smooth <= 203.55000305) { + if (ap <= 6.50000000) { + if (f107 <= 148.30000305) { + sum += 1.785650000000e-04; + } else { + sum += 2.673181818182e-04; + } + } else { + if (ap <= 7.50000000) { + sum += 1.217125000000e-05; + } else { + sum += 1.904158823529e-04; + } + } + } else { + if (beta <= 23.94445705) { + if (beta <= 21.39893055) { + sum += 2.639500000000e-04; + } else { + sum += 2.094140000000e-04; + } + } else { + if (beta <= 24.19695854) { + sum += 3.931925000000e-04; + } else { + sum += 2.920930769231e-04; + } + } + } + } else { + if (f107 <= 171.00000000) { + if (beta <= 22.84548473) { + sum += 1.435900000000e-04; + } else { + if (beta <= 22.86819172) { + sum += 1.615400000000e-04; + } else { + sum += 1.634700000000e-04; + } + } + } else { + if (f107 <= 175.15000153) { + if (beta <= 22.77111053) { + sum += 1.304800000000e-04; + } else { + sum += 1.320100000000e-04; + } + } else { + sum += 1.170100000000e-04; + } + } + } + } else { + if (beta <= 26.98882008) { + if (f107 <= 171.25000000) { + sum += 1.437900000000e-04; + } else { + if (beta <= 26.94640350) { + sum += 1.156000000000e-04; + } else { + sum += 1.020100000000e-04; + } + } + } else { + if (beta <= 27.07958794) { + if (beta <= 27.03522682) { + sum += 8.101700000000e-05; + } else { + sum += 7.068500000000e-05; + } + } else { + sum += 5.036900000000e-05; + } + } + } + } else { + if (beta <= 22.78673172) { + if (f107 <= 199.75000000) { + if (ap <= 10.50000000) { + if (beta <= 20.78130054) { + if (beta <= 20.75795650) { + sum += 2.327400000000e-05; + } else { + sum += 4.350800000000e-05; + } + } else { + if (f107 <= 191.44999695) { + sum += 8.499555555556e-05; + } else { + sum += 5.493250000000e-05; + } + } + } else { + if (beta <= 20.92714024) { + sum += 1.483800000000e-04; + } else { + if (beta <= 20.94493484) { + sum += 1.610100000000e-04; + } else { + sum += 1.703000000000e-04; + } + } + } + } else { + if (f107 <= 228.84999847) { + if (ap <= 5.50000000) { + if (beta <= 22.37957954) { + sum += -1.171726666667e-05; + } else { + sum += 7.014266666667e-06; + } + } else { + if (beta <= 22.10573483) { + sum += 3.993200000000e-05; + } else { + sum += 2.545500000000e-05; + } + } + } else { + if (beta <= 22.14325142) { + if (beta <= 22.05208778) { + sum += -3.793450000000e-05; + } else { + sum += -6.198000000000e-05; + } + } else { + sum += -2.163600000000e-05; + } + } + } + } else { + if (beta <= 23.52042580) { + if (ap <= 7.50000000) { + if (beta <= 23.08799458) { + if (beta <= 23.04637623) { + sum += 2.448400000000e-04; + } else { + sum += 2.602600000000e-04; + } + } else { + if (beta <= 23.13246536) { + sum += 2.839400000000e-04; + } else { + sum += 2.894900000000e-04; + } + } + } else { + if (beta <= 23.42103958) { + if (beta <= 23.38871956) { + sum += 2.279000000000e-04; + } else { + sum += 2.237700000000e-04; + } + } else { + if (beta <= 23.45326710) { + sum += 1.988900000000e-04; + } else { + sum += 1.995400000000e-04; + } + } + } + } else { + if (beta <= 24.00218868) { + if (f107_smooth <= 221.55000305) { + if (f107 <= 197.50000000) { + sum += 1.167500000000e-04; + } else { + sum += 4.971514814815e-05; + } + } else { + if (beta <= 23.59342766) { + sum += 9.219200000000e-05; + } else { + sum += 8.124700000000e-05; + } + } + } else { + if (beta <= 28.68044281) { + if (beta <= 24.58707047) { + sum += 1.713751038961e-04; + } else { + sum += 7.844185526316e-05; + } + } else { + if (f107_smooth <= 194.55000305) { + sum += 3.316750000000e-04; + } else { + sum += 2.439800000000e-04; + } + } + } + } + } + } + } else { + if (ap <= 18.50000000) { + if (f107 <= 216.95000458) { + if (beta <= 24.55337715) { + if (beta <= 24.26515961) { + if (beta <= 24.03427792) { + sum += 2.758000000000e-04; + } else { + sum += 2.699300000000e-04; + } + } else { + if (f107_smooth <= 216.90000153) { + if (beta <= 24.49964714) { + sum += 3.382400000000e-04; + } else { + sum += 3.322000000000e-04; + } + } else { + sum += 3.377300000000e-04; + } + } + } else { + if (beta <= 24.55667305) { + sum += 2.159600000000e-04; + } else { + sum += 2.077700000000e-04; + } + } + } else { + if (beta <= 24.09101105) { + sum += 1.384500000000e-03; + } else { + sum += 2.094900000000e-04; + } + } + } else { + if (f107_smooth <= 218.45000458) { + if (beta <= 22.41676426) { + if (beta <= 20.87298679) { + sum += 1.181900000000e-04; + } else { + sum += 1.321100000000e-04; + } + } else { + if (f107_smooth <= 212.34999847) { + if (beta <= 24.13595867) { + if (f107 <= 220.50000000) { + sum += 2.933100000000e-04; + } else { + sum += 1.863675000000e-04; + } + } else { + if (beta <= 24.15530109) { + sum += 5.615000000000e-04; + } else { + sum += 3.124970000000e-04; + } + } + } else { + if (beta <= 24.46550274) { + if (beta <= 24.38685894) { + sum += 1.983300000000e-04; + } else { + sum += 2.234800000000e-04; + } + } else { + if (beta <= 24.54081345) { + sum += 2.685700000000e-04; + } else { + sum += 2.559200000000e-04; + } + } + } + } + } else { + if (ap <= 24.50000000) { + if (f107_smooth <= 225.50000000) { + if (f107 <= 194.09999847) { + sum += 1.844100000000e-04; + } else { + if (ap <= 20.50000000) { + sum += 2.541850000000e-04; + } else { + sum += 2.858980000000e-04; + } + } + } else { + sum += 2.025400000000e-04; + } + } else { + if (ap <= 99.00000000) { + if (beta <= 24.37985516) { + if (beta <= 23.71626568) { + sum += 1.438900000000e-04; + } else { + sum += 9.000100000000e-05; + } + } else { + if (ap <= 53.00000000) { + sum += 1.645825000000e-04; + } else { + sum += 1.456300000000e-04; + } + } + } else { + sum += 7.163500000000e-06; + } + } + } + } + } + } + } + // Tree 10 + { + if (f107 <= 112.90000153) { + if (f107_smooth <= 96.45000076) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 74.25000000) { + if (ap <= 2.00000000) { + if (beta <= 29.37145329) { + sum += -8.193200000000e-05; + } else { + sum += -1.106800000000e-04; + } + } else { + if (ap <= 4.00000000) { + if (beta <= 29.50582695) { + sum += -1.224800000000e-04; + } else { + sum += -1.278200000000e-04; + } + } else { + if (beta <= 30.04290199) { + if (beta <= 29.67834854) { + sum += -1.445300000000e-04; + } else { + sum += -1.552285714286e-04; + } + } else { + if (beta <= 30.06186104) { + sum += -1.443900000000e-04; + } else { + sum += -1.363500000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 74.85000229) { + if (ap <= 3.50000000) { + if (ap <= 2.50000000) { + if (f107_smooth <= 74.75000000) { + sum += 1.152620000000e-04; + } else { + sum += -3.202000000000e-05; + } + } else { + if (beta <= 26.65369225) { + sum += -1.331640000000e-04; + } else { + sum += -1.139020000000e-04; + } + } + } else { + if (beta <= 31.14751148) { + if (f107_smooth <= 74.54999924) { + sum += 3.392916666667e-05; + } else { + sum += 1.438912272727e-04; + } + } else { + if (beta <= 31.19619560) { + sum += 1.719860000000e-05; + } else { + sum += -4.977980000000e-05; + } + } + } + } else { + if (f107 <= 74.35000229) { + if (f107_smooth <= 80.20000076) { + if (f107 <= 71.15000153) { + sum += 1.184800000000e-04; + } else { + sum += -9.658862179487e-05; + } + } else { + if (beta <= 23.85864544) { + sum += -1.051346666667e-04; + } else { + sum += 7.692360000000e-05; + } + } + } else { + if (f107 <= 76.35000229) { + if (beta <= 23.69210052) { + sum += 5.501958823529e-05; + } else { + sum += 1.359988045455e-04; + } + } else { + if (beta <= 24.73974991) { + sum += -5.066766072875e-06; + } else { + sum += 8.440805833333e-05; + } + } + } + } + } + } else { + if (ap <= 7.00000000) { + if (f107 <= 92.85000229) { + if (f107 <= 91.60000229) { + sum += -2.920800000000e-05; + } else { + if (f107 <= 92.10000229) { + sum += 1.993800000000e-04; + } else { + if (f107_smooth <= 91.60000229) { + sum += 2.192900000000e-04; + } else { + sum += 2.142600000000e-04; + } + } + } + } else { + if (f107_smooth <= 81.14999771) { + if (ap <= 4.50000000) { + if (beta <= 21.13061810) { + sum += 1.070420000000e-04; + } else { + sum += 4.990500000000e-05; + } + } else { + if (beta <= 21.74850464) { + sum += 1.405800000000e-04; + } else { + sum += 1.706400000000e-04; + } + } + } else { + if (f107 <= 98.20000076) { + if (beta <= 24.35420036) { + sum += -8.402250000000e-05; + } else { + sum += -2.950900000000e-05; + } + } else { + if (beta <= 23.87730789) { + sum += -3.115700000000e-05; + } else { + sum += 6.435298750000e-05; + } + } + } + } + } else { + if (f107 <= 99.00000000) { + if (f107_smooth <= 85.04999924) { + if (f107_smooth <= 81.04999924) { + if (beta <= 20.91892815) { + sum += 1.992900000000e-04; + } else { + sum += 1.889400000000e-04; + } + } else { + sum += 1.713300000000e-04; + } + } else { + if (beta <= 23.97480583) { + if (beta <= 23.94092941) { + sum += 2.271200000000e-04; + } else { + sum += 2.520550000000e-04; + } + } else { + if (f107 <= 92.95000076) { + sum += 1.966966666667e-04; + } else { + sum += 2.126566666667e-04; + } + } + } + } else { + if (beta <= 24.55305004) { + if (f107 <= 101.04999924) { + sum += 1.210700000000e-04; + } else { + if (f107 <= 106.04999924) { + sum += 1.953600000000e-04; + } else { + sum += 1.505200000000e-04; + } + } + } else { + if (beta <= 24.55359554) { + sum += 4.433000000000e-05; + } else { + sum += 7.676500000000e-05; + } + } + } + } + } + } else { + if (f107 <= 102.85000229) { + if (beta <= 29.69906139) { + if (f107_smooth <= 127.25000000) { + if (ap <= 6.50000000) { + if (f107 <= 99.69999695) { + if (f107_smooth <= 96.64999771) { + sum += -7.104500000000e-05; + } else { + sum += -1.282572682927e-04; + } + } else { + if (ap <= 5.50000000) { + sum += -8.945472000000e-05; + } else { + sum += -1.371640000000e-04; + } + } + } else { + if (beta <= 20.71431637) { + if (beta <= 20.67538834) { + sum += -2.101650000000e-05; + } else { + sum += -5.361740000000e-05; + } + } else { + if (f107_smooth <= 121.45000076) { + sum += -7.459604761905e-05; + } else { + sum += -1.324420000000e-04; + } + } + } + } else { + if (ap <= 13.50000000) { + if (ap <= 9.50000000) { + if (f107_smooth <= 127.90000153) { + sum += -1.179800000000e-04; + } else { + sum += -9.728950000000e-05; + } + } else { + if (beta <= 24.67326260) { + sum += -6.159133333333e-05; + } else { + sum += -3.972600000000e-05; + } + } + } else { + if (beta <= 22.48596764) { + if (f107 <= 100.10000229) { + sum += 7.955800000000e-05; + } else { + sum += 1.329600000000e-04; + } + } else { + if (beta <= 24.90350819) { + sum += 2.100600000000e-06; + } else { + sum += 2.116700000000e-05; + } + } + } + } + } else { + if (f107_smooth <= 109.39999771) { + if (f107_smooth <= 107.15000153) { + if (ap <= 5.00000000) { + sum += 4.209500000000e-06; + } else { + sum += -6.956700000000e-06; + } + } else { + if (beta <= 30.68832684) { + if (beta <= 30.61415100) { + sum += 1.621000000000e-04; + } else { + sum += 1.258500000000e-04; + } + } else { + if (beta <= 30.76972294) { + sum += 6.684200000000e-05; + } else { + sum += 2.257300000000e-05; + } + } + } + } else { + if (f107_smooth <= 113.29999924) { + if (ap <= 9.00000000) { + if (beta <= 31.09326077) { + sum += -2.977550000000e-05; + } else { + sum += 1.356373400000e-05; + } + } else { + if (ap <= 12.00000000) { + sum += -1.146700000000e-04; + } else { + sum += -6.627766666667e-05; + } + } + } else { + if (f107 <= 96.70000076) { + if (f107_smooth <= 114.04999924) { + sum += -8.779500000000e-05; + } else { + sum += -1.379610000000e-04; + } + } else { + if (beta <= 30.52080154) { + sum += -8.439600000000e-05; + } else { + sum += -9.649100000000e-05; + } + } + } + } + } + } else { + if (beta <= 29.97238541) { + if (beta <= 23.98401546) { + if (f107_smooth <= 128.95000458) { + if (beta <= 23.09329605) { + if (beta <= 21.94288921) { + sum += -4.694162263158e-05; + } else { + sum += -1.245678571429e-04; + } + } else { + if (ap <= 9.00000000) { + sum += 1.098300000000e-04; + } else { + sum += 2.047633333333e-04; + } + } + } else { + if (beta <= 21.97500229) { + if (beta <= 21.87580109) { + sum += 1.470300000000e-04; + } else { + sum += 1.840633333333e-04; + } + } else { + if (ap <= 11.50000000) { + sum += 2.084612500000e-04; + } else { + sum += 2.308012500000e-04; + } + } + } + } else { + if (ap <= 19.00000000) { + if (beta <= 25.73545933) { + if (f107_smooth <= 133.30000305) { + sum += 8.399630000000e-05; + } else { + sum += -2.209362500000e-05; + } + } else { + if (f107 <= 104.39999771) { + sum += 4.958300000000e-05; + } else { + sum += -9.066508333333e-05; + } + } + } else { + if (beta <= 25.23999882) { + if (ap <= 21.00000000) { + sum += -1.406700000000e-04; + } else { + sum += -1.097753846154e-04; + } + } else { + if (f107_smooth <= 136.65000153) { + sum += -1.294500000000e-04; + } else { + sum += -1.364000000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 109.25000000) { + if (beta <= 30.11411476) { + if (ap <= 8.50000000) { + sum += 1.138100000000e-04; + } else { + sum += 1.411700000000e-04; + } + } else { + if (f107 <= 110.34999847) { + if (f107_smooth <= 107.19999695) { + sum += 1.647000000000e-04; + } else { + sum += 1.948416666667e-04; + } + } else { + if (beta <= 31.29815197) { + sum += 2.275300000000e-04; + } else { + sum += 2.311700000000e-04; + } + } + } + } else { + if (f107_smooth <= 109.94999695) { + sum += -1.244900000000e-04; + } else { + if (ap <= 3.50000000) { + if (beta <= 30.27741241) { + sum += 1.941233333333e-05; + } else { + sum += 5.777700000000e-06; + } + } else { + if (ap <= 6.50000000) { + sum += 6.001400000000e-05; + } else { + sum += 9.666400000000e-05; + } + } + } + } + } + } + } + } else { + if (f107_smooth <= 194.50000000) { + if (f107_smooth <= 128.25000000) { + if (beta <= 30.75940990) { + if (f107 <= 122.04999924) { + if (beta <= 28.96222305) { + if (f107 <= 116.40000153) { + if (beta <= 23.04788780) { + sum += 2.353385714286e-05; + } else { + sum += 1.914300000000e-04; + } + } else { + if (f107_smooth <= 125.60000229) { + sum += 5.695077307692e-05; + } else { + sum += -6.632650000000e-05; + } + } + } else { + if (ap <= 17.50000000) { + if (ap <= 6.50000000) { + sum += 2.300000000000e-04; + } else { + sum += 2.198390909091e-04; + } + } else { + if (f107 <= 117.89999771) { + sum += 1.871440000000e-04; + } else { + sum += 1.438250000000e-04; + } + } + } + } else { + if (beta <= 20.34372997) { + if (beta <= 20.16086769) { + sum += 1.873900000000e-04; + } else { + if (ap <= 11.50000000) { + sum += 2.336636363636e-04; + } else { + sum += 2.431740000000e-04; + } + } + } else { + if (f107_smooth <= 124.69999695) { + if (f107_smooth <= 122.20000076) { + sum += 1.717154533333e-04; + } else { + sum += 2.537975000000e-04; + } + } else { + if (beta <= 24.52207088) { + sum += 9.981610000000e-05; + } else { + sum += 2.086600000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 108.34999847) { + if (f107_smooth <= 108.00000000) { + if (beta <= 31.33176994) { + if (f107 <= 121.95000076) { + sum += 2.151980000000e-04; + } else { + sum += 1.779575000000e-04; + } + } else { + sum += 1.325600000000e-04; + } + } else { + if (beta <= 31.32395458) { + sum += 4.649700000000e-05; + } else { + if (beta <= 31.32684135) { + sum += 6.729900000000e-05; + } else { + sum += 8.025100000000e-05; + } + } + } + } else { + if (f107_smooth <= 109.45000076) { + if (f107 <= 126.20000076) { + if (f107_smooth <= 108.95000076) { + sum += 2.066300000000e-05; + } else { + sum += 1.255000000000e-04; + } + } else { + if (f107 <= 128.90000153) { + sum += -6.746366666667e-05; + } else { + sum += -2.047100000000e-05; + } + } + } else { + if (beta <= 31.17761803) { + if (beta <= 31.15392303) { + sum += -1.306642857143e-04; + } else { + sum += -1.224800000000e-04; + } + } else { + if (f107 <= 129.05000305) { + sum += -9.905800000000e-05; + } else { + sum += -1.115900000000e-04; + } + } + } + } + } + } else { + if (f107_smooth <= 147.25000000) { + if (f107 <= 124.00000000) { + if (f107_smooth <= 130.25000000) { + if (beta <= 21.10087490) { + sum += 2.683300000000e-05; + } else { + if (beta <= 23.89069939) { + sum += 2.350326666667e-04; + } else { + sum += 1.993316666667e-04; + } + } + } else { + if (ap <= 13.50000000) { + if (f107_smooth <= 131.25000000) { + sum += -7.407231818182e-05; + } else { + sum += 1.412942611940e-04; + } + } else { + if (f107_smooth <= 136.34999847) { + sum += -6.636387222222e-05; + } else { + sum += 3.328975000000e-05; + } + } + } + } else { + if (ap <= 3.50000000) { + if (beta <= 24.38301468) { + if (ap <= 1.00000000) { + sum += -3.671800000000e-06; + } else { + sum += 1.724132631579e-04; + } + } else { + if (f107 <= 138.54999542) { + sum += 2.247800000000e-04; + } else { + sum += -3.193646666667e-05; + } + } + } else { + if (f107 <= 143.09999847) { + if (beta <= 21.45651627) { + sum += -2.135013559322e-05; + } else { + sum += 5.215795081967e-05; + } + } else { + if (f107 <= 145.25000000) { + sum += -8.906180384615e-05; + } else { + sum += -1.531020891608e-05; + } + } + } + } + } else { + if (ap <= 23.50000000) { + if (f107 <= 149.25000000) { + if (f107_smooth <= 150.70000458) { + if (beta <= 23.73712444) { + sum += 3.358583333333e-04; + } else { + sum += 1.749459559701e-04; + } + } else { + if (beta <= 30.45163155) { + sum += 6.909950160279e-05; + } else { + sum += 1.897691621622e-04; + } + } + } else { + if (ap <= 19.50000000) { + if (f107_smooth <= 149.90000153) { + sum += 7.300619861111e-06; + } else { + sum += 7.961405471278e-05; + } + } else { + if (f107_smooth <= 150.14999390) { + sum += 2.227900000000e-04; + } else { + sum += -3.912992452830e-05; + } + } + } + } else { + if (f107 <= 185.39999390) { + if (f107_smooth <= 161.05000305) { + if (beta <= 25.55174637) { + sum += 1.028598333333e-04; + } else { + sum += -1.083271785714e-05; + } + } else { + if (f107_smooth <= 169.59999847) { + sum += 2.462571818182e-04; + } else { + sum += 9.796794800000e-05; + } + } + } else { + if (f107_smooth <= 150.95000458) { + if (beta <= 24.79339886) { + sum += -5.657700000000e-05; + } else { + sum += -5.751400000000e-05; + } + } else { + if (f107 <= 228.84999847) { + sum += 2.881524444444e-04; + } else { + sum += 4.738500000000e-05; + } + } + } + } + } + } + } else { + if (f107 <= 174.00000000) { + if (beta <= 24.55337715) { + if (beta <= 23.94301701) { + if (f107_smooth <= 206.95000458) { + if (beta <= 21.39893055) { + if (beta <= 21.10932922) { + sum += 2.223850000000e-04; + } else { + sum += 2.605761538462e-04; + } + } else { + if (f107_smooth <= 203.55000305) { + sum += 1.855700000000e-04; + } else { + sum += 2.193216666667e-04; + } + } + } else { + if (beta <= 21.49825191) { + if (beta <= 21.46907806) { + sum += 2.110700000000e-04; + } else { + sum += 1.964900000000e-04; + } + } else { + if (beta <= 21.53677464) { + sum += 1.772100000000e-04; + } else { + sum += 1.551840000000e-04; + } + } + } + } else { + if (beta <= 24.13478947) { + if (beta <= 23.95220184) { + sum += 3.152600000000e-04; + } else { + if (ap <= 12.50000000) { + sum += 4.061566666667e-04; + } else { + sum += 4.133933333333e-04; + } + } + } else { + if (f107 <= 146.55000305) { + sum += 1.560100000000e-04; + } else { + if (beta <= 24.54215336) { + sum += 2.891010714286e-04; + } else { + sum += 3.510350000000e-04; + } + } + } + } + } else { + if (f107 <= 171.19999695) { + if (f107_smooth <= 200.05000305) { + if (f107 <= 164.34999847) { + if (beta <= 26.57770538) { + sum += 2.579050000000e-04; + } else { + sum += 2.002100000000e-04; + } + } else { + if (ap <= 6.00000000) { + sum += 1.135050000000e-04; + } else { + sum += 1.504500000000e-04; + } + } + } else { + if (beta <= 24.75784397) { + if (beta <= 24.72367764) { + sum += 3.451800000000e-05; + } else { + sum += 2.295100000000e-05; + } + } else { + if (beta <= 24.78551960) { + sum += 1.391500000000e-06; + } else { + sum += 6.623400000000e-06; + } + } + } + } else { + if (beta <= 25.42860794) { + if (beta <= 24.55667305) { + sum += 2.159600000000e-04; + } else { + if (ap <= 17.50000000) { + sum += 2.077700000000e-04; + } else { + sum += 2.121300000000e-04; + } + } + } else { + if (beta <= 26.38615131) { + if (ap <= 11.00000000) { + sum += 2.921600000000e-04; + } else { + sum += 2.973900000000e-04; + } + } else { + if (beta <= 26.40999699) { + sum += 2.852400000000e-04; + } else { + sum += 2.763800000000e-04; + } + } + } + } + } + } else { + if (beta <= 22.63134289) { + if (f107 <= 199.75000000) { + if (ap <= 10.50000000) { + if (beta <= 20.78130054) { + if (beta <= 20.75795650) { + sum += 2.327400000000e-05; + } else { + sum += 4.350800000000e-05; + } + } else { + if (beta <= 22.10093021) { + sum += 7.934712500000e-05; + } else { + sum += 5.168600000000e-05; + } + } + } else { + if (f107 <= 183.54999542) { + if (beta <= 20.86458969) { + sum += 1.181900000000e-04; + } else { + sum += 1.313733333333e-04; + } + } else { + if (beta <= 20.92714024) { + sum += 1.483800000000e-04; + } else { + sum += 1.656550000000e-04; + } + } + } + } else { + if (f107 <= 228.84999847) { + if (beta <= 22.40095997) { + if (beta <= 22.01430225) { + sum += 5.184200000000e-06; + } else { + sum += -1.413342500000e-05; + } + } else { + if (f107 <= 204.50000000) { + sum += 8.312200000000e-06; + } else { + sum += 2.623500000000e-05; + } + } + } else { + if (beta <= 22.00303650) { + if (beta <= 21.91329765) { + sum += -2.005400000000e-05; + } else { + sum += -3.647900000000e-05; + } + } else { + if (beta <= 22.14325142) { + sum += -6.263966666667e-05; + } else { + sum += -2.163600000000e-05; + } + } + } + } + } else { + if (ap <= 17.00000000) { + if (f107 <= 245.90000153) { + if (beta <= 24.57238960) { + if (f107_smooth <= 221.09999847) { + sum += 1.523827681159e-04; + } else { + sum += 2.654392857143e-04; + } + } else { + if (beta <= 25.74690151) { + sum += 7.823870270270e-05; + } else { + sum += 2.346062500000e-04; + } + } + } else { + if (beta <= 23.48363400) { + sum += 2.289400000000e-04; + } else { + if (beta <= 24.00218868) { + sum += 5.778078260870e-05; + } else { + sum += 1.158336500000e-04; + } + } + } + } else { + if (f107_smooth <= 212.34999847) { + if (ap <= 19.50000000) { + if (f107 <= 216.95000458) { + sum += 2.718866666667e-04; + } else { + sum += 6.011600000000e-04; + } + } else { + if (beta <= 24.13595867) { + sum += 2.321191666667e-04; + } else { + sum += 3.477184615385e-04; + } + } + } else { + if (ap <= 29.50000000) { + if (beta <= 24.54682922) { + sum += 2.527220000000e-04; + } else { + sum += 1.911542857143e-04; + } + } else { + if (f107 <= 256.59999847) { + sum += 1.321718571429e-04; + } else { + sum += 3.168880000000e-05; + } + } + } + } + } + } + } + } + } + // Tree 11 + { + if (f107 <= 108.65000153) { + if (f107_smooth <= 112.15000153) { + if (f107 <= 91.14999771) { + if (beta <= 31.23413467) { + if (beta <= 30.73546696) { + if (beta <= 20.02556610) { + if (f107 <= 77.25000000) { + if (f107 <= 75.34999847) { + sum += 1.628333333333e-04; + } else { + sum += 2.009500000000e-04; + } + } else { + if (f107_smooth <= 77.95000076) { + sum += 1.204371428571e-04; + } else { + sum += 5.880400000000e-05; + } + } + } else { + if (beta <= 20.50973892) { + if (beta <= 20.13325119) { + sum += -3.251884090909e-05; + } else { + sum += -1.207253945946e-04; + } + } else { + if (beta <= 21.41022778) { + sum += 1.135228472727e-04; + } else { + sum += 9.443557344064e-07; + } + } + } + } else { + if (f107 <= 71.50000000) { + if (beta <= 31.18288040) { + sum += 3.796700000000e-05; + } else { + if (f107 <= 70.50000000) { + sum += -2.807200000000e-05; + } else { + sum += -3.610200000000e-05; + } + } + } else { + if (f107_smooth <= 76.95000076) { + if (ap <= 8.50000000) { + sum += 1.456267368421e-04; + } else { + sum += 2.023176923077e-04; + } + } else { + if (beta <= 30.80681801) { + sum += 6.273133333333e-05; + } else { + sum += 1.033600000000e-04; + } + } + } + } + } else { + if (beta <= 31.28133583) { + if (f107 <= 71.80000305) { + if (beta <= 31.25058842) { + sum += -7.289900000000e-05; + } else { + if (beta <= 31.25624180) { + sum += -8.702800000000e-05; + } else { + sum += -8.977400000000e-05; + } + } + } else { + if (f107 <= 72.80000305) { + sum += 5.818300000000e-06; + } else { + sum += -4.103200000000e-05; + } + } + } else { + if (f107 <= 72.95000076) { + if (beta <= 31.30182076) { + if (beta <= 31.29096603) { + sum += -1.270100000000e-04; + } else { + sum += -1.379500000000e-04; + } + } else { + if (ap <= 10.50000000) { + sum += -1.506433333333e-04; + } else { + sum += -1.462960000000e-04; + } + } + } else { + if (f107_smooth <= 75.54999924) { + sum += -1.250000000000e-04; + } else { + if (beta <= 31.29925060) { + sum += -9.540800000000e-05; + } else { + sum += -1.093600000000e-04; + } + } + } + } + } + } else { + if (beta <= 26.06527996) { + if (f107 <= 94.34999847) { + if (f107 <= 91.60000229) { + if (ap <= 8.50000000) { + sum += -2.920800000000e-05; + } else { + sum += 1.821400000000e-04; + } + } else { + if (f107_smooth <= 82.70000076) { + if (f107_smooth <= 81.14999771) { + sum += 1.756543000000e-04; + } else { + sum += -3.868300000000e-05; + } + } else { + if (beta <= 23.97480583) { + sum += 2.575033333333e-04; + } else { + sum += 2.057450000000e-04; + } + } + } + } else { + if (f107_smooth <= 87.95000076) { + if (f107 <= 100.79999924) { + if (f107_smooth <= 82.64999771) { + sum += 1.000497000000e-04; + } else { + sum += 1.739107142857e-04; + } + } else { + if (beta <= 24.21363544) { + sum += -6.713600000000e-05; + } else { + sum += 5.361100000000e-05; + } + } + } else { + if (ap <= 7.00000000) { + if (beta <= 24.15342617) { + sum += -5.732400000000e-05; + } else { + sum += -7.454900000000e-05; + } + } else { + sum += -2.896500000000e-05; + } + } + } + } else { + if (beta <= 31.21916676) { + if (beta <= 29.71257210) { + if (beta <= 28.73394680) { + if (ap <= 5.50000000) { + sum += -6.287400000000e-05; + } else { + sum += -4.123400000000e-05; + } + } else { + if (ap <= 4.00000000) { + sum += -1.225133333333e-04; + } else { + sum += -9.144963636364e-05; + } + } + } else { + if (beta <= 30.75713253) { + if (f107_smooth <= 106.54999924) { + sum += 4.181237500000e-05; + } else { + sum += 1.289106153846e-04; + } + } else { + if (f107_smooth <= 110.00000000) { + sum += -5.833194285714e-05; + } else { + sum += 4.076622250000e-05; + } + } + } + } else { + if (f107_smooth <= 108.60000229) { + if (beta <= 31.27854729) { + sum += 2.049000000000e-04; + } else { + sum += 2.139800000000e-04; + } + } else { + if (beta <= 31.25451756) { + sum += 1.731000000000e-04; + } else { + sum += 1.847700000000e-04; + } + } + } + } + } + } else { + if (ap <= 14.00000000) { + if (ap <= 6.50000000) { + if (f107_smooth <= 126.70000076) { + if (beta <= 28.11687565) { + if (f107 <= 91.90000153) { + sum += -8.894600000000e-05; + } else { + if (f107 <= 94.34999847) { + sum += -1.192900000000e-04; + } else { + sum += -1.377257692308e-04; + } + } + } else { + if (f107 <= 100.30000305) { + if (beta <= 30.61612225) { + sum += -1.122900000000e-04; + } else { + sum += -1.460650000000e-04; + } + } else { + if (beta <= 28.48481560) { + sum += -7.493900000000e-05; + } else { + sum += -6.429000000000e-05; + } + } + } + } else { + if (f107 <= 100.79999924) { + if (f107 <= 99.29999924) { + if (f107 <= 98.54999924) { + sum += -1.195100000000e-04; + } else { + sum += -1.256100000000e-04; + } + } else { + if (beta <= 20.00559998) { + sum += -1.078900000000e-04; + } else { + sum += -9.687350000000e-05; + } + } + } else { + if (f107_smooth <= 126.85000229) { + sum += -5.632100000000e-05; + } else { + if (f107_smooth <= 127.60000229) { + sum += -7.424400000000e-05; + } else { + sum += -7.680000000000e-05; + } + } + } + } + } else { + if (beta <= 20.38870049) { + if (f107 <= 99.29999924) { + if (beta <= 20.03069782) { + sum += -2.167600000000e-05; + } else { + sum += 4.674000000000e-06; + } + } else { + sum += 5.201400000000e-05; + } + } else { + if (beta <= 23.04363537) { + if (beta <= 20.94310856) { + if (beta <= 20.76336575) { + sum += -7.563000000000e-05; + } else { + sum += -9.420200000000e-05; + } + } else { + if (beta <= 22.70537281) { + sum += -1.212920000000e-04; + } else { + sum += -1.374885714286e-04; + } + } + } else { + if (ap <= 7.50000000) { + if (f107 <= 97.65000153) { + sum += -2.178100000000e-05; + } else { + sum += 6.555200000000e-05; + } + } else { + if (f107_smooth <= 114.75000000) { + sum += -5.009087500000e-05; + } else { + sum += -8.518185000000e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 121.15000153) { + if (ap <= 18.00000000) { + if (beta <= 25.97851849) { + if (beta <= 21.04943275) { + sum += -1.363800000000e-04; + } else { + sum += -1.322700000000e-04; + } + } else { + sum += -1.418500000000e-04; + } + } else { + sum += -1.024000000000e-04; + } + } else { + if (beta <= 24.06553841) { + if (f107_smooth <= 125.65000153) { + if (f107 <= 105.04999924) { + if (beta <= 20.67538834) { + sum += -2.958000000000e-05; + } else { + sum += -5.236700000000e-05; + } + } else { + if (beta <= 20.61912727) { + sum += 1.050800000000e-05; + } else { + sum += -7.758975000000e-06; + } + } + } else { + if (f107_smooth <= 128.89999771) { + sum += 1.173800000000e-04; + } else { + if (beta <= 23.89560604) { + sum += 2.337266666667e-04; + } else { + sum += 2.272400000000e-04; + } + } + } + } else { + if (ap <= 19.00000000) { + if (f107_smooth <= 130.45000076) { + if (beta <= 25.05810165) { + sum += 4.760100000000e-05; + } else { + sum += 6.656100000000e-05; + } + } else { + if (ap <= 16.50000000) { + sum += -5.169350000000e-05; + } else { + sum += 1.906333333333e-06; + } + } + } else { + if (f107 <= 102.25000000) { + if (beta <= 24.90350819) { + sum += 2.100600000000e-06; + } else { + sum += 2.116700000000e-05; + } + } else { + if (ap <= 21.00000000) { + sum += -1.320633333333e-04; + } else { + sum += -1.019095000000e-04; + } + } + } + } + } + } + } + } else { + if (f107_smooth <= 194.00000000) { + if (ap <= 38.50000000) { + if (f107_smooth <= 147.44999695) { + if (f107_smooth <= 130.15000153) { + if (beta <= 30.75940990) { + if (f107 <= 136.19999695) { + if (beta <= 28.99554348) { + sum += 8.943208114286e-05; + } else { + sum += 1.626455054054e-04; + } + } else { + if (f107_smooth <= 127.95000458) { + sum += 1.905207230769e-04; + } else { + sum += 7.005896363636e-05; + } + } + } else { + if (f107_smooth <= 108.50000000) { + if (beta <= 31.32003117) { + sum += 2.295220000000e-04; + } else { + sum += 1.088024444444e-04; + } + } else { + if (f107_smooth <= 109.45000076) { + sum += -2.299155555556e-05; + } else { + sum += -1.248008333333e-04; + } + } + } + } else { + if (f107 <= 153.70000458) { + if (f107_smooth <= 131.05000305) { + if (beta <= 24.01178265) { + sum += -1.405700000000e-05; + } else { + sum += -1.080311904762e-04; + } + } else { + if (f107_smooth <= 133.05000305) { + sum += 1.073700256000e-04; + } else { + sum += 3.729095084746e-05; + } + } + } else { + if (f107_smooth <= 145.65000153) { + if (ap <= 17.50000000) { + sum += -8.331247837838e-05; + } else { + sum += -3.336801818182e-05; + } + } else { + if (f107_smooth <= 146.05000305) { + sum += 2.159950000000e-04; + } else { + sum += -2.233898235294e-05; + } + } + } + } + } else { + if (beta <= 24.47475815) { + if (beta <= 22.74677658) { + if (beta <= 20.08715153) { + if (f107_smooth <= 161.30000305) { + sum += -4.173033000000e-05; + } else { + sum += 2.108651132075e-04; + } + } else { + if (f107 <= 203.85000610) { + sum += 2.179232227979e-05; + } else { + sum += 2.686050000000e-04; + } + } + } else { + if (f107 <= 162.00000000) { + if (f107 <= 147.15000153) { + sum += 1.548367375000e-04; + } else { + sum += 6.865189428571e-05; + } + } else { + if (beta <= 24.39493179) { + sum += 2.234601265823e-04; + } else { + sum += 1.309500952381e-04; + } + } + } + } else { + if (beta <= 26.05194378) { + if (f107_smooth <= 154.34999847) { + if (f107 <= 121.64999771) { + sum += 1.839538518519e-04; + } else { + sum += 4.960779768595e-05; + } + } else { + if (beta <= 24.56859493) { + sum += 6.569084615385e-05; + } else { + sum += -4.026523134328e-05; + } + } + } else { + if (f107 <= 173.34999847) { + if (f107_smooth <= 154.20000458) { + sum += 1.661126217949e-04; + } else { + sum += 9.565200891738e-05; + } + } else { + if (f107_smooth <= 158.54999542) { + sum += -5.314738965517e-05; + } else { + sum += 6.917123340164e-05; + } + } + } + } + } + } else { + if (beta <= 20.13501263) { + if (f107 <= 147.55000305) { + if (f107_smooth <= 134.14999390) { + sum += -1.003700000000e-04; + } else { + if (ap <= 65.50000000) { + sum += -9.877300000000e-05; + } else { + sum += -9.692000000000e-05; + } + } + } else { + sum += -1.091900000000e-04; + } + } else { + if (f107 <= 142.44999695) { + if (f107_smooth <= 152.15000153) { + if (f107_smooth <= 123.09999847) { + if (beta <= 29.07187080) { + sum += 1.170700000000e-04; + } else { + sum += 1.380200000000e-04; + } + } else { + if (ap <= 41.00000000) { + sum += 2.553180000000e-04; + } else { + sum += 2.155800000000e-04; + } + } + } else { + if (f107_smooth <= 164.84999847) { + if (beta <= 24.57593536) { + sum += -1.292900000000e-04; + } else { + sum += -1.241300000000e-04; + } + } else { + if (beta <= 21.87044621) { + sum += -6.174900000000e-05; + } else { + sum += -6.488300000000e-05; + } + } + } + } else { + if (f107_smooth <= 152.50000000) { + if (beta <= 22.10699749) { + if (beta <= 20.17539024) { + sum += 2.481600000000e-04; + } else { + sum += 2.566266666667e-04; + } + } else { + if (f107 <= 164.90000153) { + sum += 2.848942857143e-05; + } else { + sum += 2.444200000000e-04; + } + } + } else { + if (f107 <= 149.69999695) { + if (beta <= 23.99555206) { + sum += 1.152800000000e-04; + } else { + sum += 1.121200000000e-04; + } + } else { + if (beta <= 22.28866482) { + sum += 4.022850000000e-04; + } else { + sum += 2.955082500000e-04; + } + } + } + } + } + } + } else { + if (f107 <= 174.00000000) { + if (beta <= 24.55337715) { + if (beta <= 23.94521427) { + if (f107_smooth <= 206.95000458) { + if (beta <= 21.39893055) { + if (f107_smooth <= 201.60000610) { + sum += 2.126400000000e-04; + } else { + sum += 2.609154545455e-04; + } + } else { + if (beta <= 23.93761826) { + sum += 2.081750000000e-04; + } else { + sum += 2.520850000000e-04; + } + } + } else { + if (beta <= 21.49825191) { + if (beta <= 21.46907806) { + sum += 2.110700000000e-04; + } else { + sum += 1.964900000000e-04; + } + } else { + if (f107 <= 169.90000153) { + sum += 1.570000000000e-04; + } else { + sum += 1.804700000000e-04; + } + } + } + } else { + if (f107_smooth <= 199.80000305) { + if (f107 <= 143.09999847) { + sum += 2.080400000000e-04; + } else { + if (beta <= 24.52872086) { + sum += 1.746700000000e-04; + } else { + sum += 1.525500000000e-04; + } + } + } else { + if (beta <= 24.13862228) { + if (f107 <= 166.44999695) { + sum += 3.423666666667e-04; + } else { + sum += 4.076128571429e-04; + } + } else { + if (beta <= 24.54444408) { + sum += 2.968841379310e-04; + } else { + sum += 3.510350000000e-04; + } + } + } + } + } else { + if (f107 <= 171.19999695) { + if (f107 <= 162.94999695) { + if (beta <= 25.56858253) { + sum += 7.540300000000e-05; + } else { + if (ap <= 4.50000000) { + sum += 2.083100000000e-04; + } else { + sum += 2.538850000000e-04; + } + } + } else { + if (f107_smooth <= 200.09999847) { + if (f107_smooth <= 195.00000000) { + sum += 6.273500000000e-05; + } else { + sum += 1.268100000000e-04; + } + } else { + sum += 1.391500000000e-06; + } + } + } else { + if (f107_smooth <= 196.15000153) { + sum += 1.156000000000e-04; + } else { + if (f107_smooth <= 207.84999847) { + if (beta <= 26.30641365) { + sum += 2.973900000000e-04; + } else { + sum += 2.907800000000e-04; + } + } else { + if (beta <= 24.55667305) { + sum += 2.159600000000e-04; + } else { + sum += 2.077700000000e-04; + } + } + } + } + } + } else { + if (ap <= 78.50000000) { + if (beta <= 22.67994404) { + if (f107 <= 190.04999542) { + if (ap <= 10.50000000) { + if (f107_smooth <= 195.09999847) { + sum += 2.327400000000e-05; + } else { + sum += 8.986050000000e-05; + } + } else { + if (beta <= 20.93575001) { + sum += 1.381760000000e-04; + } else { + sum += 1.703000000000e-04; + } + } + } else { + if (f107 <= 208.04999542) { + if (beta <= 22.50516224) { + sum += 1.434458750000e-05; + } else { + sum += 5.168600000000e-05; + } + } else { + if (f107 <= 228.50000000) { + sum += -7.620225000000e-06; + } else { + sum += -3.297571428571e-05; + } + } + } + } else { + if (f107 <= 247.65000153) { + if (beta <= 25.93225098) { + if (beta <= 24.59291744) { + sum += 1.857599586777e-04; + } else { + sum += 7.618731081081e-05; + } + } else { + if (beta <= 28.71513748) { + sum += 2.592475000000e-04; + } else { + sum += 3.380471428571e-04; + } + } + } else { + if (beta <= 23.41989040) { + if (beta <= 23.18960953) { + sum += 2.765300000000e-04; + } else { + sum += 2.828400000000e-04; + } + } else { + if (beta <= 24.07020664) { + sum += 5.203448275862e-05; + } else { + sum += 1.224944285714e-04; + } + } + } + } + } else { + if (beta <= 24.07762814) { + if (f107 <= 244.34999847) { + if (beta <= 24.06831455) { + if (beta <= 24.05796909) { + sum += 2.975675000000e-04; + } else { + sum += 2.698900000000e-04; + } + } else { + sum += 3.061900000000e-04; + } + } else { + if (beta <= 23.96580505) { + sum += 7.163500000000e-06; + } else { + sum += 4.803900000000e-05; + } + } + } else { + sum += 1.397800000000e-03; + } + } + } + } + } + } + // Tree 12 + { + if (f107 <= 113.85000229) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 74.35000229) { + if (beta <= 29.32957745) { + if (beta <= 29.14603329) { + sum += -1.743100000000e-05; + } else { + sum += -3.466700000000e-05; + } + } else { + if (f107_smooth <= 74.25000000) { + if (beta <= 29.56958008) { + if (beta <= 29.51142406) { + sum += -1.224800000000e-04; + } else { + sum += -1.307700000000e-04; + } + } else { + if (beta <= 30.05796814) { + sum += -1.524377777778e-04; + } else { + sum += -1.363500000000e-04; + } + } + } else { + if (f107 <= 75.64999771) { + sum += -7.078700000000e-05; + } else { + if (beta <= 30.16052437) { + sum += -1.147300000000e-04; + } else { + sum += -1.035100000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 74.75000000) { + if (beta <= 24.83662033) { + if (f107 <= 71.20000076) { + sum += 1.456100000000e-04; + } else { + if (beta <= 24.18882942) { + sum += 1.845400000000e-04; + } else { + sum += 2.045310000000e-04; + } + } + } else { + if (beta <= 27.45435143) { + if (beta <= 25.90134811) { + sum += 7.912450000000e-05; + } else { + sum += -5.286016428571e-05; + } + } else { + if (beta <= 28.71391773) { + sum += 1.644792727273e-04; + } else { + sum += 6.378614705882e-05; + } + } + } + } else { + if (f107 <= 74.35000229) { + if (ap <= 14.50000000) { + if (f107 <= 71.04999924) { + sum += 2.900251111111e-05; + } else { + sum += -6.006711136364e-05; + } + } else { + if (beta <= 22.43647194) { + sum += -1.445900000000e-04; + } else { + sum += 1.427450000000e-04; + } + } + } else { + if (beta <= 30.80656815) { + if (beta <= 20.02347279) { + sum += 1.548046666667e-04; + } else { + sum += 1.606334895044e-05; + } + } else { + if (f107_smooth <= 76.85000229) { + sum += 2.158881818182e-04; + } else { + sum += 1.279350000000e-04; + } + } + } + } + } + } else { + if (f107 <= 92.90000153) { + if (f107 <= 91.50000000) { + sum += 1.525000000000e-04; + } else { + if (beta <= 23.96781158) { + if (f107 <= 92.45000076) { + sum += 2.684000000000e-04; + } else { + if (beta <= 20.85529995) { + sum += 2.205600000000e-04; + } else { + sum += 2.134300000000e-04; + } + } + } else { + if (ap <= 5.00000000) { + if (ap <= 3.50000000) { + sum += 2.192900000000e-04; + } else { + sum += 2.137555555556e-04; + } + } else { + if (beta <= 23.98918343) { + sum += 2.098166666667e-04; + } else { + sum += 1.943800000000e-04; + } + } + } + } + } else { + if (ap <= 8.50000000) { + if (ap <= 5.50000000) { + if (f107 <= 109.40000153) { + if (f107 <= 93.64999771) { + sum += 1.874025000000e-04; + } else { + sum += 1.169679285714e-04; + } + } else { + if (beta <= 23.88080025) { + sum += -7.377066666667e-06; + } else { + sum += 7.676100000000e-05; + } + } + } else { + if (beta <= 24.03538609) { + sum += 2.271200000000e-04; + } else { + if (f107 <= 95.45000076) { + sum += -2.999220000000e-05; + } else { + sum += 4.134342222222e-05; + } + } + } + } else { + if (f107 <= 98.20000076) { + if (f107 <= 95.04999924) { + if (ap <= 11.00000000) { + sum += 2.078500000000e-04; + } else { + sum += 1.917750000000e-04; + } + } else { + if (beta <= 23.94188595) { + sum += 2.429400000000e-04; + } else { + sum += 2.468600000000e-04; + } + } + } else { + sum += 1.210700000000e-04; + } + } + } + } + } else { + if (f107 <= 102.85000229) { + if (beta <= 29.63235188) { + if (ap <= 7.50000000) { + if (f107 <= 99.35000229) { + if (f107_smooth <= 96.64999771) { + if (beta <= 25.93945980) { + sum += -6.658700000000e-05; + } else { + sum += -9.500500000000e-05; + } + } else { + if (f107 <= 76.79999924) { + sum += -1.489750000000e-04; + } else { + sum += -1.246773333333e-04; + } + } + } else { + if (f107 <= 100.29999924) { + if (ap <= 5.50000000) { + sum += -1.084600000000e-04; + } else { + sum += 6.555200000000e-05; + } + } else { + if (beta <= 26.39847946) { + sum += -1.072960769231e-04; + } else { + sum += -7.358960000000e-05; + } + } + } + } else { + if (f107_smooth <= 126.85000229) { + if (f107 <= 101.09999847) { + if (f107_smooth <= 121.25000000) { + sum += -7.831462500000e-05; + } else { + sum += -1.459325000000e-04; + } + } else { + if (beta <= 28.20200157) { + sum += -4.412316666667e-05; + } else { + sum += -7.964000000000e-05; + } + } + } else { + if (f107_smooth <= 127.45000076) { + if (f107_smooth <= 126.95000076) { + sum += 1.293900000000e-05; + } else { + sum += 5.575700000000e-05; + } + } else { + if (beta <= 24.67344570) { + sum += -8.954660000000e-05; + } else { + sum += -4.468000000000e-06; + } + } + } + } + } else { + if (f107_smooth <= 109.20000076) { + if (f107_smooth <= 107.15000153) { + if (beta <= 29.74915981) { + if (f107_smooth <= 106.25000000) { + sum += -6.211200000000e-05; + } else { + sum += -3.739300000000e-05; + } + } else { + sum += -6.956700000000e-06; + } + } else { + if (ap <= 6.00000000) { + if (beta <= 30.60461521) { + sum += 1.621000000000e-04; + } else { + sum += 1.381120000000e-04; + } + } else { + if (f107 <= 96.25000000) { + sum += 7.424400000000e-05; + } else { + sum += 1.100350000000e-04; + } + } + } + } else { + if (beta <= 31.06991673) { + if (beta <= 30.49232197) { + if (beta <= 30.35073566) { + sum += -1.862100000000e-05; + } else { + sum += -3.292200000000e-05; + } + } else { + if (f107_smooth <= 114.29999924) { + sum += -9.486607142857e-05; + } else { + sum += -1.398528571429e-04; + } + } + } else { + if (f107_smooth <= 111.00000000) { + sum += 4.015400000000e-05; + } else { + if (f107_smooth <= 112.15000153) { + sum += 8.800222500000e-06; + } else { + sum += -2.688800000000e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 133.69999695) { + if (beta <= 31.22574806) { + if (f107_smooth <= 122.25000000) { + if (f107 <= 105.54999924) { + if (f107_smooth <= 114.25000000) { + sum += 9.932594444444e-05; + } else { + sum += -9.926366666667e-05; + } + } else { + if (f107 <= 108.05000305) { + sum += -1.109162105263e-04; + } else { + sum += -4.054119166667e-05; + } + } + } else { + if (f107 <= 108.70000076) { + if (beta <= 24.05026627) { + sum += 3.215050000000e-06; + } else { + sum += -6.809330769231e-05; + } + } else { + if (beta <= 24.00951862) { + sum += 1.701703603226e-04; + } else { + sum += 7.337645454545e-05; + } + } + } + } else { + if (f107_smooth <= 108.60000229) { + if (beta <= 31.29133606) { + sum += 2.139800000000e-04; + } else { + if (f107_smooth <= 107.95000076) { + sum += 2.315600000000e-04; + } else { + sum += 2.311700000000e-04; + } + } + } else { + if (beta <= 31.25451756) { + sum += 1.731000000000e-04; + } else { + sum += 1.847700000000e-04; + } + } + } + } else { + if (f107_smooth <= 134.59999847) { + if (beta <= 25.06392193) { + sum += -4.713900000000e-05; + } else { + sum += -5.624800000000e-05; + } + } else { + if (ap <= 23.00000000) { + if (beta <= 25.51469517) { + if (beta <= 25.23016930) { + sum += -1.069816666667e-04; + } else { + sum += -1.265200000000e-04; + } + } else { + if (beta <= 26.08974648) { + sum += -1.025680000000e-04; + } else { + sum += -9.518300000000e-05; + } + } + } else { + if (beta <= 25.36328220) { + sum += -1.366500000000e-04; + } else { + sum += -1.364000000000e-04; + } + } + } + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (f107_smooth <= 190.25000000) { + if (f107_smooth <= 147.75000000) { + if (f107_smooth <= 130.15000153) { + if (beta <= 30.80654049) { + if (beta <= 29.13046551) { + if (f107 <= 164.54999542) { + sum += 1.058715181553e-04; + } else { + sum += 1.991372592593e-04; + } + } else { + if (ap <= 23.50000000) { + sum += 2.155650000000e-04; + } else { + sum += 1.438250000000e-04; + } + } + } else { + if (f107_smooth <= 109.45000076) { + if (f107_smooth <= 107.94999695) { + sum += 1.933333333333e-04; + } else { + sum += 7.306745000000e-05; + } + } else { + if (beta <= 31.18397236) { + sum += -1.280342857143e-04; + } else { + sum += -1.031604000000e-04; + } + } + } + } else { + if (f107 <= 147.94999695) { + if (f107_smooth <= 131.19999695) { + if (f107 <= 130.40000153) { + sum += 4.040531250000e-05; + } else { + sum += -9.583139130435e-05; + } + } else { + if (beta <= 25.16593361) { + sum += 7.137130987654e-05; + } else { + sum += -6.749108571429e-05; + } + } + } else { + if (ap <= 3.50000000) { + if (beta <= 24.29965687) { + sum += 1.872900000000e-04; + } else { + sum += -7.941628571429e-05; + } + } else { + if (f107_smooth <= 133.00000000) { + sum += 8.973270000000e-05; + } else { + sum += -3.263109738994e-05; + } + } + } + } + } else { + if (ap <= 30.50000000) { + if (f107_smooth <= 186.25000000) { + if (beta <= 31.18621349) { + if (f107 <= 189.80000305) { + sum += 9.385067813008e-05; + } else { + sum += 1.516288105960e-04; + } + } else { + if (f107 <= 148.69999695) { + sum += 2.130072000000e-04; + } else { + sum += -2.208814924051e-05; + } + } + } else { + if (f107 <= 172.89999390) { + if (beta <= 20.12341022) { + sum += 1.940700000000e-04; + } else { + sum += 1.772400000000e-04; + } + } else { + if (beta <= 31.30265999) { + sum += 2.963093750000e-04; + } else { + sum += 2.298550000000e-04; + } + } + } + } else { + if (f107_smooth <= 148.34999847) { + if (ap <= 40.00000000) { + if (beta <= 24.99992561) { + sum += -6.129150000000e-05; + } else { + sum += -6.259800000000e-05; + } + } else { + sum += -3.883600000000e-05; + } + } else { + if (f107 <= 185.75000000) { + if (ap <= 38.50000000) { + sum += 1.377255555556e-04; + } else { + sum += 2.413638461538e-04; + } + } else { + if (f107 <= 213.54999542) { + sum += 3.244827272727e-04; + } else { + sum += 4.106633333333e-04; + } + } + } + } + } + } else { + if (f107 <= 172.69999695) { + if (f107_smooth <= 192.55000305) { + if (ap <= 9.50000000) { + if (f107 <= 160.29999542) { + if (f107 <= 157.19999695) { + sum += 7.786200000000e-05; + } else { + sum += 3.662000000000e-05; + } + } else { + if (f107 <= 166.94999695) { + sum += 1.772683333333e-04; + } else { + sum += 1.030138000000e-04; + } + } + } else { + if (f107 <= 167.50000000) { + if (f107 <= 158.29999542) { + sum += 1.105000000000e-04; + } else { + sum += -3.213825714286e-05; + } + } else { + if (f107_smooth <= 191.55000305) { + sum += 2.072060000000e-05; + } else { + sum += 2.696900000000e-04; + } + } + } + } else { + if (ap <= 23.00000000) { + if (beta <= 29.34658623) { + sum += 3.125800000000e-04; + } else { + sum += 2.928600000000e-04; + } + } else { + sum += -1.607300000000e-06; + } + } + } else { + if (beta <= 30.85775280) { + if (f107_smooth <= 192.70000458) { + if (f107_smooth <= 190.79999542) { + if (f107 <= 198.59999847) { + sum += -8.816575000000e-05; + } else { + sum += -6.833600000000e-05; + } + } else { + if (beta <= 30.73681641) { + sum += -4.987692200000e-05; + } else { + sum += -2.043712000000e-05; + } + } + } else { + if (f107_smooth <= 193.40000153) { + if (beta <= 20.49248600) { + sum += -9.153250000000e-05; + } else { + sum += -8.255366666667e-05; + } + } else { + if (beta <= 20.57497883) { + sum += -7.259700000000e-05; + } else { + sum += -6.882500000000e-05; + } + } + } + } else { + if (f107 <= 193.09999847) { + if (beta <= 31.00581169) { + sum += 1.041000000000e-04; + } else { + sum += 1.199700000000e-04; + } + } else { + if (ap <= 8.50000000) { + sum += 5.880900000000e-05; + } else { + sum += 4.298200000000e-05; + } + } + } + } + } + } else { + if (beta <= 23.95764923) { + if (f107 <= 174.65000153) { + if (beta <= 21.44216442) { + if (f107_smooth <= 200.45000458) { + if (beta <= 20.98864365) { + sum += 1.872800000000e-04; + } else { + sum += 1.964700000000e-04; + } + } else { + if (ap <= 6.00000000) { + if (f107_smooth <= 204.95000458) { + sum += 2.518700000000e-04; + } else { + sum += 2.194700000000e-04; + } + } else { + if (beta <= 21.33698654) { + sum += 2.705580000000e-04; + } else { + sum += 2.495000000000e-04; + } + } + } + } else { + if (f107 <= 163.09999847) { + sum += 2.630300000000e-04; + } else { + if (ap <= 7.00000000) { + if (beta <= 21.49825191) { + sum += 2.037800000000e-04; + } else { + sum += 1.825100000000e-04; + } + } else { + if (beta <= 21.55228519) { + sum += 1.706900000000e-04; + } else { + sum += 1.507466666667e-04; + } + } + } + } + } else { + if (f107_smooth <= 215.84999847) { + if (f107 <= 197.25000000) { + if (f107_smooth <= 196.15000153) { + if (f107 <= 181.94999695) { + sum += 3.676333333333e-05; + } else { + sum += 7.345880000000e-05; + } + } else { + if (f107_smooth <= 206.05000305) { + sum += 1.337081333333e-04; + } else { + sum += 9.233016666667e-05; + } + } + } else { + if (beta <= 22.45236301) { + if (f107 <= 228.50000000) { + sum += -4.539634615385e-06; + } else { + sum += -3.905112500000e-05; + } + } else { + if (beta <= 22.51808071) { + sum += 2.701500000000e-05; + } else { + sum += 4.789647619048e-05; + } + } + } + } else { + if (beta <= 23.49936199) { + if (beta <= 22.94466305) { + if (f107 <= 175.90000153) { + sum += 1.157500000000e-04; + } else { + sum += 1.844100000000e-04; + } + } else { + if (beta <= 23.38764763) { + sum += 2.543455555556e-04; + } else { + sum += 2.164550000000e-04; + } + } + } else { + if (ap <= 18.00000000) { + if (f107 <= 297.15000916) { + sum += 7.216371428571e-05; + } else { + sum += 3.863066666667e-05; + } + } else { + if (f107_smooth <= 220.44999695) { + sum += 7.163500000000e-06; + } else { + sum += 1.476166666667e-04; + } + } + } + } + } + } else { + if (f107 <= 221.50000000) { + if (beta <= 24.09435940) { + if (beta <= 24.07762814) { + if (f107_smooth <= 204.54999542) { + if (beta <= 23.96821594) { + sum += 3.978600000000e-04; + } else { + sum += 4.133040000000e-04; + } + } else { + if (f107_smooth <= 205.54999542) { + sum += 3.164500000000e-04; + } else { + sum += 2.833580000000e-04; + } + } + } else { + if (beta <= 24.08898258) { + if (f107 <= 218.30000305) { + sum += 1.397800000000e-03; + } else { + sum += 1.384500000000e-03; + } + } else { + sum += 4.126900000000e-04; + } + } + } else { + if (beta <= 24.54518509) { + if (f107 <= 172.04999542) { + if (f107 <= 146.55000305) { + sum += 1.795733333333e-04; + } else { + sum += 3.052253333333e-04; + } + } else { + if (f107_smooth <= 205.69999695) { + sum += 3.208820000000e-04; + } else { + sum += 1.980375937500e-04; + } + } + } else { + if (beta <= 25.76020718) { + if (beta <= 24.59511566) { + sum += 1.929520000000e-04; + } else { + sum += 5.423690476190e-05; + } + } else { + if (f107 <= 177.59999847) { + sum += 1.983465000000e-04; + } else { + sum += 3.191300000000e-04; + } + } + } + } + } else { + if (f107 <= 241.90000153) { + if (f107 <= 226.25000000) { + if (f107_smooth <= 198.15000153) { + sum += 1.954700000000e-04; + } else { + if (ap <= 11.00000000) { + sum += 4.684090000000e-05; + } else { + sum += 1.681150000000e-04; + } + } + } else { + if (ap <= 9.50000000) { + if (beta <= 24.33833885) { + sum += 1.984476250000e-04; + } else { + sum += 2.810361538462e-04; + } + } else { + if (f107_smooth <= 203.45000458) { + sum += 2.928700000000e-04; + } else { + sum += 1.373222727273e-04; + } + } + } + } else { + if (f107_smooth <= 217.80000305) { + if (ap <= 3.00000000) { + sum += 4.715600000000e-05; + } else { + if (beta <= 23.99776554) { + sum += 8.790240000000e-05; + } else { + sum += 1.380722727273e-04; + } + } + } else { + if (ap <= 5.50000000) { + sum += 1.165000000000e-04; + } else { + if (f107_smooth <= 226.94999695) { + sum += 4.214600000000e-05; + } else { + sum += 5.604950000000e-05; + } + } + } + } + } + } + } + } + } + // Tree 13 + { + if (f107 <= 111.75000000) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (beta <= 20.03347969) { + if (f107 <= 78.65000153) { + if (f107_smooth <= 78.25000000) { + if (ap <= 3.50000000) { + if (f107 <= 76.29999924) { + sum += 1.779300000000e-04; + } else { + sum += 1.542500000000e-04; + } + } else { + if (f107 <= 74.95000076) { + sum += 1.693850000000e-04; + } else { + sum += 2.015333333333e-04; + } + } + } else { + if (beta <= 20.02502918) { + sum += 1.343000000000e-04; + } else { + sum += 1.198600000000e-04; + } + } + } else { + if (f107 <= 80.35000229) { + if (beta <= 20.01305008) { + sum += 7.149600000000e-05; + } else { + sum += 4.611200000000e-05; + } + } else { + if (f107 <= 81.25000000) { + if (beta <= 20.00238609) { + sum += 1.139200000000e-04; + } else { + sum += 9.173500000000e-05; + } + } else { + sum += 1.448200000000e-04; + } + } + } + } else { + if (beta <= 20.49999523) { + if (beta <= 20.11431694) { + if (f107_smooth <= 78.59999847) { + if (f107_smooth <= 78.45000076) { + sum += -2.084200000000e-05; + } else { + sum += 4.868200000000e-05; + } + } else { + if (beta <= 20.09435463) { + sum += -9.864850000000e-05; + } else { + sum += -1.146700000000e-04; + } + } + } else { + if (ap <= 3.50000000) { + if (beta <= 20.30850220) { + sum += -9.948480000000e-05; + } else { + sum += -3.401300000000e-05; + } + } else { + if (f107 <= 84.15000153) { + sum += -1.376958787879e-04; + } else { + sum += -5.694800000000e-05; + } + } + } + } else { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + if (beta <= 29.62622452) { + sum += -1.177117142857e-04; + } else { + sum += -1.512033333333e-04; + } + } else { + if (f107 <= 75.64999771) { + sum += -6.103500000000e-05; + } else { + sum += -1.147300000000e-04; + } + } + } else { + if (f107_smooth <= 74.85000229) { + if (ap <= 3.50000000) { + sum += -2.043507142857e-05; + } else { + sum += 1.026905527027e-04; + } + } else { + if (beta <= 21.37030125) { + sum += 1.115759684211e-04; + } else { + sum += -2.180723150358e-07; + } + } + } + } + } + } else { + if (f107 <= 94.34999847) { + if (f107_smooth <= 82.70000076) { + if (f107 <= 93.40000153) { + if (beta <= 24.54909134) { + sum += -3.868300000000e-05; + } else { + sum += -2.033500000000e-05; + } + } else { + if (ap <= 4.00000000) { + sum += 7.036300000000e-05; + } else { + if (beta <= 20.95136738) { + sum += 1.941150000000e-04; + } else { + sum += 1.622450000000e-04; + } + } + } + } else { + if (f107 <= 91.60000229) { + if (f107_smooth <= 88.29999924) { + if (beta <= 24.00835419) { + sum += 1.821400000000e-04; + } else { + sum += 1.525000000000e-04; + } + } else { + sum += -2.920800000000e-05; + } + } else { + if (f107_smooth <= 95.29999924) { + if (beta <= 23.97149277) { + sum += 2.357100000000e-04; + } else { + sum += 2.086413333333e-04; + } + } else { + sum += 1.914500000000e-04; + } + } + } + } else { + if (f107_smooth <= 88.00000000) { + if (f107 <= 110.60000229) { + if (f107_smooth <= 82.64999771) { + if (beta <= 24.55267525) { + sum += 1.117912000000e-04; + } else { + sum += 4.858925000000e-05; + } + } else { + if (ap <= 11.00000000) { + sum += 1.487366666667e-04; + } else { + sum += 2.283866666667e-04; + } + } + } else { + if (beta <= 23.87536526) { + sum += -3.115700000000e-05; + } else { + if (beta <= 23.87640953) { + sum += -1.683400000000e-05; + } else { + sum += -2.648600000000e-06; + } + } + } + } else { + if (f107 <= 99.25000000) { + if (f107_smooth <= 88.80000305) { + if (beta <= 24.24073029) { + sum += -3.530400000000e-05; + } else { + sum += -5.480200000000e-05; + } + } else { + if (beta <= 24.15342617) { + sum += -5.732400000000e-05; + } else { + sum += -7.454900000000e-05; + } + } + } else { + sum += -8.955200000000e-05; + } + } + } + } + } else { + if (f107 <= 102.75000000) { + if (ap <= 6.50000000) { + if (beta <= 30.84198093) { + if (f107 <= 98.84999847) { + if (f107_smooth <= 96.64999771) { + if (beta <= 25.95119095) { + sum += -7.253100000000e-05; + } else { + sum += -9.500500000000e-05; + } + } else { + if (f107 <= 80.25000000) { + sum += -1.433584615385e-04; + } else { + sum += -1.219557142857e-04; + } + } + } else { + if (f107_smooth <= 110.50000000) { + if (beta <= 29.76267052) { + sum += -3.739300000000e-05; + } else { + sum += 4.209500000000e-06; + } + } else { + if (f107 <= 101.60000229) { + sum += -8.785425000000e-05; + } else { + sum += -1.396716666667e-04; + } + } + } + } else { + if (f107 <= 95.94999695) { + if (f107_smooth <= 110.45000076) { + sum += -2.307700000000e-05; + } else { + if (beta <= 31.11578846) { + sum += -9.851100000000e-07; + } else { + sum += 1.206200000000e-05; + } + } + } else { + if (beta <= 31.15727615) { + sum += 4.015400000000e-05; + } else { + sum += 5.871200000000e-05; + } + } + } + } else { + if (beta <= 20.39179230) { + if (f107_smooth <= 127.15000153) { + if (beta <= 20.04650307) { + if (beta <= 20.03069782) { + sum += -2.167600000000e-05; + } else { + sum += 8.806500000000e-06; + } + } else { + sum += 5.201400000000e-05; + } + } else { + if (beta <= 20.08260632) { + sum += 8.958700000000e-05; + } else { + if (beta <= 20.09362411) { + sum += 1.173800000000e-04; + } else { + sum += 1.329600000000e-04; + } + } + } + } else { + if (f107_smooth <= 109.30000305) { + if (beta <= 30.15883064) { + if (f107_smooth <= 103.95000076) { + sum += -4.282116666667e-05; + } else { + sum += -9.612354545455e-05; + } + } else { + if (f107 <= 96.25000000) { + sum += 7.424400000000e-05; + } else { + sum += 1.100350000000e-04; + } + } + } else { + if (f107 <= 95.35000229) { + if (f107 <= 94.60000229) { + sum += -8.156340000000e-05; + } else { + sum += -1.314375000000e-04; + } + } else { + if (f107 <= 95.89999771) { + sum += -2.770900000000e-05; + } else { + sum += -7.741013513514e-05; + } + } + } + } + } + } else { + if (beta <= 29.67738819) { + if (f107 <= 108.00000000) { + if (f107_smooth <= 127.35000229) { + if (ap <= 5.50000000) { + if (beta <= 29.04892445) { + sum += -4.133766666667e-05; + } else { + sum += -1.140600000000e-04; + } + } else { + if (f107 <= 104.90000153) { + sum += -1.024000000000e-04; + } else { + sum += -1.323472727273e-04; + } + } + } else { + if (f107_smooth <= 130.75000000) { + if (ap <= 20.50000000) { + sum += -1.517500000000e-05; + } else { + sum += 2.236400000000e-04; + } + } else { + if (ap <= 17.50000000) { + sum += -6.934520000000e-05; + } else { + sum += -1.107911428571e-04; + } + } + } + } else { + if (f107 <= 110.00000000) { + if (beta <= 21.62449169) { + if (f107 <= 108.75000000) { + sum += -4.015766666667e-06; + } else { + sum += -6.498633333333e-05; + } + } else { + if (f107_smooth <= 132.10000610) { + sum += 1.867233333333e-04; + } else { + sum += 1.415087500000e-05; + } + } + } else { + if (ap <= 14.00000000) { + if (ap <= 10.50000000) { + sum += -5.313700000000e-05; + } else { + sum += 1.534000000000e-04; + } + } else { + if (beta <= 24.76308346) { + sum += -1.069637500000e-04; + } else { + sum += -1.364833333333e-04; + } + } + } + } + } else { + if (ap <= 6.50000000) { + if (beta <= 30.65071201) { + if (ap <= 2.50000000) { + if (beta <= 30.01935291) { + sum += 9.706800000000e-05; + } else { + sum += 1.138100000000e-04; + } + } else { + if (beta <= 30.21091366) { + sum += 6.094250000000e-05; + } else { + sum += 2.097200000000e-05; + } + } + } else { + sum += -1.244900000000e-04; + } + } else { + if (f107 <= 104.10000229) { + if (beta <= 31.19440174) { + sum += 8.692000000000e-05; + } else { + sum += 1.031600000000e-04; + } + } else { + if (f107_smooth <= 107.19999695) { + if (beta <= 30.11411476) { + sum += 1.411700000000e-04; + } else { + sum += 1.647000000000e-04; + } + } else { + if (beta <= 31.26687527) { + sum += 1.820633333333e-04; + } else { + sum += 2.049000000000e-04; + } + } + } + } + } + } + } + } else { + if (f107_smooth <= 194.50000000) { + if (ap <= 63.50000000) { + if (f107_smooth <= 128.05000305) { + if (beta <= 30.75082207) { + if (beta <= 29.23713875) { + if (f107 <= 134.34999847) { + if (f107_smooth <= 122.20000076) { + sum += 7.468022321429e-05; + } else { + sum += 1.426674074074e-04; + } + } else { + if (ap <= 26.50000000) { + sum += 1.893599523810e-04; + } else { + sum += 8.010380000000e-05; + } + } + } else { + if (f107 <= 113.29999924) { + if (beta <= 30.09175777) { + sum += 1.239833333333e-04; + } else { + sum += 8.350200000000e-05; + } + } else { + if (ap <= 23.50000000) { + sum += 2.171577419355e-04; + } else { + sum += 1.505100000000e-04; + } + } + } + } else { + if (f107_smooth <= 109.45000076) { + if (ap <= 23.50000000) { + if (f107_smooth <= 107.79999924) { + sum += 1.792233333333e-04; + } else { + sum += 8.155377777778e-05; + } + } else { + if (f107 <= 128.05000305) { + sum += -4.884700000000e-05; + } else { + sum += -2.411800000000e-05; + } + } + } else { + if (beta <= 31.17761803) { + if (f107 <= 127.45000458) { + sum += -1.298266666667e-04; + } else { + sum += -1.237550000000e-04; + } + } else { + if (beta <= 31.23182678) { + sum += -1.073400000000e-04; + } else { + sum += -9.156200000000e-05; + } + } + } + } + } else { + if (f107_smooth <= 147.44999695) { + if (f107 <= 142.15000153) { + if (beta <= 21.55889034) { + if (f107_smooth <= 138.09999847) { + sum += -8.623347187500e-06; + } else { + sum += 1.191020162162e-04; + } + } else { + if (beta <= 23.12202072) { + sum += 2.118354545455e-04; + } else { + sum += 6.699682500000e-05; + } + } + } else { + if (ap <= 3.50000000) { + if (beta <= 24.30633163) { + sum += 1.755188666667e-04; + } else { + sum += -4.500986000000e-05; + } + } else { + if (f107_smooth <= 133.00000000) { + sum += 5.229950725490e-05; + } else { + sum += -2.696002540123e-05; + } + } + } + } else { + if (f107_smooth <= 190.25000000) { + if (f107_smooth <= 186.25000000) { + if (ap <= 43.50000000) { + sum += 8.846799859859e-05; + } else { + sum += 2.486619047619e-04; + } + } else { + if (f107 <= 179.34999847) { + sum += 2.014800000000e-04; + } else { + sum += 2.892700000000e-04; + } + } + } else { + if (beta <= 28.23115921) { + if (beta <= 20.22792053) { + sum += 8.941950000000e-05; + } else { + sum += -4.267567050847e-05; + } + } else { + if (beta <= 29.80277348) { + sum += 2.153546875000e-04; + } else { + sum += 2.073856216216e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 147.50000000) { + if (ap <= 103.00000000) { + sum += -9.692000000000e-05; + } else { + sum += -3.283600000000e-05; + } + } else { + if (f107 <= 152.94999695) { + if (f107_smooth <= 152.40000153) { + sum += 2.430000000000e-04; + } else { + if (beta <= 23.95972157) { + sum += 1.270200000000e-04; + } else { + sum += 1.152800000000e-04; + } + } + } else { + if (f107_smooth <= 170.79999542) { + if (f107 <= 191.10000610) { + if (f107_smooth <= 162.04999542) { + sum += 3.098000000000e-04; + } else { + sum += 2.959175000000e-04; + } + } else { + sum += 2.686400000000e-04; + } + } else { + if (ap <= 188.00000000) { + sum += 4.162900000000e-04; + } else { + if (beta <= 21.00016785) { + sum += 4.060400000000e-04; + } else { + sum += 4.032800000000e-04; + } + } + } + } + } + } + } else { + if (f107 <= 183.75000000) { + if (f107_smooth <= 195.69999695) { + if (beta <= 20.78790474) { + sum += 2.327400000000e-05; + } else { + if (ap <= 9.50000000) { + sum += 9.791400000000e-05; + } else { + if (beta <= 26.94640350) { + sum += 1.156000000000e-04; + } else { + sum += 1.020100000000e-04; + } + } + } + } else { + if (beta <= 23.93587494) { + if (beta <= 21.46907806) { + if (f107_smooth <= 201.60000610) { + if (ap <= 8.00000000) { + sum += 2.305580000000e-04; + } else { + sum += 1.964700000000e-04; + } + } else { + if (f107_smooth <= 206.50000000) { + sum += 2.665692857143e-04; + } else { + sum += 2.110700000000e-04; + } + } + } else { + if (f107 <= 177.25000000) { + if (f107_smooth <= 218.55000305) { + sum += 1.485309523810e-04; + } else { + sum += 1.891366666667e-04; + } + } else { + sum += 8.848900000000e-05; + } + } + } else { + if (beta <= 24.51781082) { + if (beta <= 24.00276756) { + if (f107 <= 163.75000000) { + sum += 2.782000000000e-04; + } else { + sum += 4.085133333333e-04; + } + } else { + if (ap <= 9.50000000) { + sum += 3.172254545455e-04; + } else { + sum += 2.768846666667e-04; + } + } + } else { + if (f107_smooth <= 199.14999390) { + if (beta <= 26.52401543) { + sum += 2.763238461538e-04; + } else { + sum += 2.246780000000e-04; + } + } else { + if (beta <= 24.57277107) { + sum += 2.077740000000e-04; + } else { + sum += 8.805277142857e-05; + } + } + } + } + } + } else { + if (beta <= 22.60190582) { + if (f107 <= 199.75000000) { + if (beta <= 21.74945545) { + sum += 1.703000000000e-04; + } else { + if (beta <= 22.55330467) { + sum += 5.168600000000e-05; + } else { + sum += 5.817900000000e-05; + } + } + } else { + if (f107 <= 228.50000000) { + if (beta <= 21.84294987) { + if (beta <= 21.80504990) { + sum += 1.918000000000e-05; + } else { + sum += 5.184200000000e-06; + } + } else { + if (beta <= 22.37957954) { + sum += -1.499804545455e-05; + } else { + sum += 6.365300000000e-06; + } + } + } else { + if (f107 <= 236.09999847) { + if (beta <= 22.02368641) { + sum += -6.224300000000e-05; + } else { + sum += -6.414980000000e-05; + } + } else { + if (f107_smooth <= 211.90000153) { + sum += -3.356800000000e-05; + } else { + sum += -2.321200000000e-05; + } + } + } + } + } else { + if (ap <= 16.50000000) { + if (beta <= 24.59321785) { + if (beta <= 24.33888340) { + if (beta <= 23.53074074) { + sum += 2.408282352941e-04; + } else { + sum += 1.124396067416e-04; + } + } else { + if (beta <= 24.55752945) { + sum += 2.823723809524e-04; + } else { + sum += 1.351750000000e-04; + } + } + } else { + if (beta <= 25.56192207) { + if (f107_smooth <= 201.00000000) { + sum += -3.293950000000e-05; + } else { + sum += 4.801291379310e-05; + } + } else { + if (ap <= 5.50000000) { + sum += 1.142674000000e-04; + } else { + sum += 2.197250000000e-04; + } + } + } + } else { + if (f107_smooth <= 214.50000000) { + if (beta <= 24.13595867) { + if (f107_smooth <= 208.15000153) { + sum += 2.871588888889e-04; + } else { + sum += 1.910650000000e-04; + } + } else { + if (f107_smooth <= 206.34999847) { + sum += 3.148007692308e-04; + } else { + sum += 5.615000000000e-04; + } + } + } else { + if (ap <= 26.50000000) { + if (beta <= 24.53702164) { + sum += 2.676444444444e-04; + } else { + sum += 1.900700000000e-04; + } + } else { + if (f107 <= 256.59999847) { + sum += 1.406866666667e-04; + } else { + sum += 1.860800000000e-05; + } + } + } + } + } + } + } + } + } + // Tree 14 + { + if (f107 <= 108.65000153) { + if (f107_smooth <= 111.84999847) { + if (f107 <= 91.14999771) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + if (beta <= 29.56398296) { + if (f107_smooth <= 74.14999771) { + sum += -1.278200000000e-04; + } else { + sum += -1.106800000000e-04; + } + } else { + if (f107 <= 75.25000000) { + if (beta <= 29.95104694) { + sum += -1.575683333333e-04; + } else { + sum += -1.531100000000e-04; + } + } else { + if (beta <= 30.06186104) { + sum += -1.449457142857e-04; + } else { + sum += -1.363500000000e-04; + } + } + } + } else { + if (ap <= 15.00000000) { + if (ap <= 7.00000000) { + sum += -5.814700000000e-05; + } else { + sum += -1.743100000000e-05; + } + } else { + if (f107 <= 75.64999771) { + sum += -7.078700000000e-05; + } else { + sum += -1.035100000000e-04; + } + } + } + } else { + if (f107_smooth <= 74.85000229) { + if (beta <= 31.16082668) { + if (beta <= 24.83662033) { + if (beta <= 24.66919994) { + sum += 2.011400000000e-04; + } else { + sum += 1.553150000000e-04; + } + } else { + if (beta <= 27.30304241) { + sum += -3.746416428571e-05; + } else { + sum += 1.144033805970e-04; + } + } + } else { + if (beta <= 31.21057224) { + sum += 6.649200000000e-06; + } else { + if (beta <= 31.25058842) { + sum += -6.724700000000e-05; + } else { + sum += -8.885866666667e-05; + } + } + } + } else { + if (beta <= 20.02822018) { + if (f107 <= 78.00000000) { + if (beta <= 19.99245453) { + sum += 2.013975000000e-04; + } else { + sum += 1.467466666667e-04; + } + } else { + if (f107 <= 79.70000076) { + sum += 2.824700000000e-05; + } else { + sum += 1.182775000000e-04; + } + } + } else { + if (f107 <= 80.50000000) { + if (f107_smooth <= 86.75000000) { + sum += -1.932519966555e-05; + } else { + sum += -1.214152531915e-04; + } + } else { + if (beta <= 24.18136883) { + sum += 7.802354176471e-05; + } else { + sum += -2.902345652174e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 96.10000229) { + if (f107 <= 94.34999847) { + if (f107_smooth <= 82.70000076) { + if (beta <= 23.52476406) { + if (beta <= 20.95162296) { + sum += 1.992900000000e-04; + } else { + sum += 1.584312500000e-04; + } + } else { + if (beta <= 24.54909134) { + sum += -3.868300000000e-05; + } else { + sum += -2.033500000000e-05; + } + } + } else { + if (f107 <= 91.60000229) { + if (beta <= 24.07055283) { + sum += 1.525000000000e-04; + } else { + sum += -2.920800000000e-05; + } + } else { + if (beta <= 23.97149277) { + sum += 2.520550000000e-04; + } else { + sum += 2.061037500000e-04; + } + } + } + } else { + if (f107_smooth <= 88.00000000) { + if (f107_smooth <= 82.64999771) { + if (ap <= 11.00000000) { + sum += 6.402755714286e-05; + } else { + sum += 1.142233333333e-04; + } + } else { + if (ap <= 6.00000000) { + sum += 1.359050000000e-04; + } else { + sum += 1.984100000000e-04; + } + } + } else { + if (beta <= 24.19465733) { + sum += -7.454900000000e-05; + } else { + if (beta <= 24.23282051) { + sum += -2.896500000000e-05; + } else { + sum += -4.602933333333e-05; + } + } + } + } + } else { + if (beta <= 29.79827404) { + if (ap <= 1.50000000) { + if (f107 <= 100.50000000) { + if (beta <= 29.32218075) { + sum += -1.276000000000e-04; + } else { + sum += -1.253000000000e-04; + } + } else { + if (beta <= 29.42725372) { + sum += -1.175200000000e-04; + } else { + sum += -1.140600000000e-04; + } + } + } else { + if (ap <= 10.50000000) { + if (f107 <= 102.14999771) { + sum += -7.196185714286e-05; + } else { + sum += -4.232921250000e-05; + } + } else { + if (beta <= 29.53065014) { + sum += -9.739075000000e-05; + } else { + sum += -9.264200000000e-05; + } + } + } + } else { + if (f107_smooth <= 109.00000000) { + if (ap <= 11.50000000) { + if (f107_smooth <= 106.45000076) { + sum += 4.209500000000e-06; + } else { + sum += 1.236054210526e-04; + } + } else { + if (f107_smooth <= 108.04999924) { + sum += 1.758560000000e-04; + } else { + sum += 2.139800000000e-04; + } + } + } else { + if (f107_smooth <= 110.00000000) { + if (f107 <= 98.04999924) { + sum += -2.060790000000e-05; + } else { + sum += -8.420060000000e-05; + } + } else { + if (f107_smooth <= 110.44999695) { + sum += 9.774666666667e-05; + } else { + sum += 4.479350000000e-05; + } + } + } + } + } + } + } else { + if (f107_smooth <= 130.09999847) { + if (beta <= 20.73355293) { + if (ap <= 7.00000000) { + if (f107 <= 100.79999924) { + if (ap <= 5.00000000) { + if (beta <= 20.00550365) { + sum += -1.096500000000e-04; + } else { + sum += -9.944800000000e-05; + } + } else { + sum += -1.179800000000e-04; + } + } else { + if (f107_smooth <= 126.85000229) { + sum += -5.632100000000e-05; + } else { + if (beta <= 20.02488327) { + sum += -7.194966666667e-05; + } else { + sum += -8.034366666667e-05; + } + } + } + } else { + if (f107_smooth <= 126.95000076) { + if (f107_smooth <= 123.60000229) { + if (beta <= 20.69619274) { + sum += -4.611500000000e-05; + } else { + sum += -6.134933333333e-05; + } + } else { + if (beta <= 20.03069782) { + sum += -2.167600000000e-05; + } else { + sum += -1.044333333333e-06; + } + } + } else { + if (ap <= 12.00000000) { + sum += 5.201400000000e-05; + } else { + if (beta <= 20.08639240) { + sum += 8.958700000000e-05; + } else { + sum += 1.329600000000e-04; + } + } + } + } + } else { + if (beta <= 23.08036804) { + if (beta <= 20.80644512) { + if (ap <= 8.50000000) { + sum += -9.420200000000e-05; + } else { + sum += -7.857000000000e-05; + } + } else { + if (f107 <= 93.20000076) { + if (beta <= 23.04528332) { + sum += -1.192900000000e-04; + } else { + sum += -1.131800000000e-04; + } + } else { + if (beta <= 20.89869690) { + sum += -1.229866666667e-04; + } else { + sum += -1.389715000000e-04; + } + } + } + } else { + if (beta <= 23.81183529) { + if (beta <= 23.27289486) { + if (f107_smooth <= 120.75000000) { + sum += -3.445800000000e-05; + } else { + sum += -9.114466666667e-05; + } + } else { + if (beta <= 23.37259483) { + sum += 1.176095000000e-05; + } else { + sum += 8.336000000000e-05; + } + } + } else { + if (f107_smooth <= 114.75000000) { + if (ap <= 9.50000000) { + sum += -3.387100000000e-05; + } else { + sum += -1.076100000000e-04; + } + } else { + if (f107_smooth <= 127.80000305) { + sum += -1.214206764706e-04; + } else { + sum += -1.924500000000e-05; + } + } + } + } + } + } else { + if (beta <= 24.08157063) { + if (f107_smooth <= 130.54999542) { + if (beta <= 23.89244080) { + sum += 2.356000000000e-04; + } else { + sum += 2.341300000000e-04; + } + } else { + if (beta <= 23.89652538) { + sum += 2.272400000000e-04; + } else { + sum += 2.236400000000e-04; + } + } + } else { + if (f107 <= 108.20000076) { + if (ap <= 17.50000000) { + if (ap <= 14.00000000) { + if (f107 <= 102.94999695) { + sum += -9.299900000000e-05; + } else { + sum += -9.810000000000e-05; + } + } else { + if (beta <= 25.06392193) { + sum += -4.713900000000e-05; + } else { + sum += -5.838400000000e-05; + } + } + } else { + if (f107 <= 107.45000076) { + if (f107_smooth <= 133.05000305) { + sum += -1.009926666667e-04; + } else { + sum += -1.041100000000e-04; + } + } else { + sum += -1.265200000000e-04; + } + } + } else { + if (beta <= 25.00380039) { + if (beta <= 24.98574638) { + sum += -2.025000000000e-06; + } else { + sum += -5.813000000000e-06; + } + } else { + sum += -2.407000000000e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 194.00000000) { + if (ap <= 70.50000000) { + if (f107_smooth <= 129.65000153) { + if (beta <= 30.76705360) { + if (ap <= 10.50000000) { + if (f107 <= 134.75000000) { + if (beta <= 29.12828350) { + sum += 6.577216754098e-05; + } else { + sum += 1.788128888889e-04; + } + } else { + if (f107_smooth <= 127.75000000) { + sum += 1.957194230769e-04; + } else { + sum += 6.597798821429e-05; + } + } + } else { + if (f107 <= 131.84999847) { + if (f107 <= 130.25000000) { + sum += 1.666004457831e-04; + } else { + sum += 3.622560000000e-05; + } + } else { + if (ap <= 23.50000000) { + sum += 2.380473333333e-04; + } else { + sum += 6.529400000000e-05; + } + } + } + } else { + if (f107_smooth <= 108.34999847) { + if (f107 <= 120.54999924) { + if (f107_smooth <= 107.75000000) { + sum += 2.113450000000e-04; + } else { + sum += 2.303575000000e-04; + } + } else { + if (beta <= 31.32953930) { + sum += 6.156860000000e-05; + } else { + sum += 1.240833333333e-04; + } + } + } else { + if (ap <= 5.00000000) { + sum += 1.472300000000e-04; + } else { + if (f107_smooth <= 109.20000076) { + sum += -1.336500000000e-05; + } else { + sum += -1.154752307692e-04; + } + } + } + } + } else { + if (f107_smooth <= 147.20000458) { + if (f107 <= 123.25000000) { + if (ap <= 13.50000000) { + if (beta <= 21.52746677) { + sum += 7.510934347826e-05; + } else { + sum += 1.612932363636e-04; + } + } else { + if (f107_smooth <= 137.20000458) { + sum += -6.175372400000e-05; + } else { + sum += 1.256833571429e-04; + } + } + } else { + if (beta <= 24.47488880) { + if (beta <= 20.10831451) { + sum += -8.380629166667e-05; + } else { + sum += 3.687529875796e-05; + } + } else { + if (f107_smooth <= 142.40000153) { + sum += -9.459451428571e-05; + } else { + sum += -2.324788214286e-05; + } + } + } + } else { + if (ap <= 23.50000000) { + if (f107_smooth <= 151.55000305) { + if (f107 <= 153.44999695) { + sum += 1.669320615385e-04; + } else { + sum += 5.191193560000e-05; + } + } else { + if (ap <= 19.50000000) { + sum += 7.127231111818e-05; + } else { + sum += -1.325334545455e-05; + } + } + } else { + if (f107 <= 185.39999390) { + if (beta <= 30.96037579) { + sum += 1.187373647059e-04; + } else { + sum += -5.429208333333e-05; + } + } else { + if (f107 <= 228.05000305) { + sum += 2.860320588235e-04; + } else { + sum += 4.738500000000e-05; + } + } + } + } + } + } else { + if (f107 <= 175.20000458) { + if (f107_smooth <= 147.65000153) { + if (f107_smooth <= 139.50000000) { + sum += -1.091900000000e-04; + } else { + if (beta <= 24.30662060) { + sum += -3.283600000000e-05; + } else { + sum += -2.019100000000e-05; + } + } + } else { + if (f107_smooth <= 156.40000153) { + if (f107_smooth <= 152.55000305) { + sum += 1.900200000000e-04; + } else { + if (beta <= 23.95972157) { + sum += 1.270200000000e-04; + } else { + sum += 1.144900000000e-04; + } + } + } else { + if (f107 <= 159.34999847) { + sum += 3.100400000000e-04; + } else { + sum += 2.934200000000e-04; + } + } + } + } else { + if (ap <= 89.50000000) { + if (beta <= 24.30885887) { + sum += 3.138300000000e-04; + } else { + sum += 3.073200000000e-04; + } + } else { + if (f107 <= 218.54999542) { + if (beta <= 20.99651718) { + sum += 4.078500000000e-04; + } else { + sum += 4.032800000000e-04; + } + } else { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } + } + } + } + } else { + if (ap <= 16.50000000) { + if (f107 <= 178.40000153) { + if (beta <= 24.52982044) { + if (beta <= 23.94798183) { + if (beta <= 21.49825191) { + if (f107_smooth <= 201.60000610) { + sum += 2.077983333333e-04; + } else { + sum += 2.544966666667e-04; + } + } else { + if (f107 <= 164.44999695) { + sum += 2.411400000000e-04; + } else { + sum += 1.389760000000e-04; + } + } + } else { + if (beta <= 24.13862228) { + if (beta <= 23.96409321) { + sum += 4.131800000000e-04; + } else { + sum += 4.010375000000e-04; + } + } else { + if (ap <= 5.50000000) { + sum += 3.233280000000e-04; + } else { + sum += 2.724921428571e-04; + } + } + } + } else { + if (beta <= 26.87873173) { + if (f107_smooth <= 198.75000000) { + if (beta <= 26.52401543) { + sum += 2.852425000000e-04; + } else { + sum += 2.166862500000e-04; + } + } else { + if (f107 <= 174.44999695) { + sum += 1.302569411765e-04; + } else { + sum += 1.810200000000e-04; + } + } + } else { + if (beta <= 27.00542164) { + sum += 1.020100000000e-04; + } else { + if (beta <= 27.07958794) { + sum += 6.968500000000e-05; + } else { + sum += 5.036900000000e-05; + } + } + } + } + } else { + if (beta <= 28.68044281) { + if (beta <= 22.60190582) { + if (f107 <= 199.75000000) { + if (ap <= 10.50000000) { + sum += 6.888416666667e-05; + } else { + sum += 1.556866666667e-04; + } + } else { + if (beta <= 21.80504990) { + sum += 3.578160000000e-05; + } else { + sum += -2.144230000000e-05; + } + } + } else { + if (beta <= 24.59291744) { + if (f107 <= 245.90000153) { + sum += 1.802961881188e-04; + } else { + sum += 7.725471739130e-05; + } + } else { + if (f107_smooth <= 199.39999390) { + sum += 1.293185000000e-04; + } else { + sum += 3.886908333333e-05; + } + } + } + } else { + if (beta <= 28.76688957) { + sum += 2.439800000000e-04; + } else { + if (f107_smooth <= 194.55000305) { + if (beta <= 29.09029293) { + sum += 3.069600000000e-04; + } else { + sum += 3.397666666667e-04; + } + } else { + sum += 4.669000000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 212.34999847) { + if (ap <= 19.50000000) { + if (f107_smooth <= 207.34999847) { + sum += 2.699300000000e-04; + } else { + sum += 1.384500000000e-03; + } + } else { + if (beta <= 24.13595867) { + if (f107 <= 171.50000000) { + sum += 2.630300000000e-04; + } else { + if (beta <= 22.50774193) { + sum += 1.251500000000e-04; + } else { + sum += 1.780600000000e-04; + } + } + } else { + if (f107_smooth <= 206.15000153) { + if (f107 <= 224.90000153) { + sum += 3.030260000000e-04; + } else { + sum += 3.269275000000e-04; + } + } else { + sum += 5.615000000000e-04; + } + } + } + } else { + if (ap <= 24.50000000) { + if (f107 <= 165.19999695) { + if (beta <= 24.49964714) { + sum += 3.382400000000e-04; + } else { + sum += 3.322000000000e-04; + } + } else { + if (beta <= 23.07937717) { + if (beta <= 22.92091274) { + sum += 1.844100000000e-04; + } else { + sum += 1.985900000000e-04; + } + } else { + if (beta <= 24.55337715) { + sum += 2.673933333333e-04; + } else { + sum += 2.134066666667e-04; + } + } + } + } else { + if (beta <= 23.91534233) { + sum += 1.206600000000e-05; + } else { + if (f107 <= 169.79999542) { + sum += 2.751600000000e-04; + } else { + if (beta <= 24.29542732) { + sum += 1.187976666667e-04; + } else { + sum += 1.748875000000e-04; + } + } + } + } + } + } + } + } + } + // Tree 15 + { + if (f107 <= 112.90000153) { + if (f107_smooth <= 96.54999924) { + if (f107_smooth <= 74.35000229) { + if (f107_smooth <= 74.25000000) { + if (beta <= 29.56398296) { + if (beta <= 29.37145329) { + sum += -8.193200000000e-05; + } else { + if (f107 <= 76.40000153) { + sum += -1.106800000000e-04; + } else { + if (beta <= 29.50582695) { + sum += -1.224800000000e-04; + } else { + sum += -1.278200000000e-04; + } + } + } + } else { + if (beta <= 30.00616264) { + if (f107 <= 78.70000076) { + if (beta <= 29.95104694) { + sum += -1.568900000000e-04; + } else { + sum += -1.531100000000e-04; + } + } else { + if (beta <= 29.62170410) { + sum += -1.431200000000e-04; + } else { + sum += -1.472900000000e-04; + } + } + } else { + if (beta <= 30.06186104) { + sum += -1.443900000000e-04; + } else { + sum += -1.363500000000e-04; + } + } + } + } else { + if (beta <= 29.20864582) { + sum += -3.466700000000e-05; + } else { + if (ap <= 11.50000000) { + sum += -5.814700000000e-05; + } else { + sum += -7.078700000000e-05; + } + } + } + } else { + if (f107_smooth <= 74.75000000) { + if (beta <= 27.63949490) { + if (beta <= 25.04876232) { + if (f107 <= 72.90000153) { + if (beta <= 24.85845566) { + sum += 1.553150000000e-04; + } else { + sum += 1.108300000000e-04; + } + } else { + if (beta <= 24.16611671) { + sum += 1.827400000000e-04; + } else { + sum += 2.057040000000e-04; + } + } + } else { + if (f107 <= 75.14999771) { + if (ap <= 3.50000000) { + sum += -1.243133333333e-04; + } else { + sum += -4.641700000000e-05; + } + } else { + if (beta <= 27.45435143) { + sum += 2.923150000000e-05; + } else { + sum += 8.363866666667e-05; + } + } + } + } else { + if (beta <= 28.62100506) { + if (f107 <= 75.89999771) { + if (beta <= 28.44040108) { + sum += 2.047330769231e-04; + } else { + sum += 1.643166666667e-04; + } + } else { + if (beta <= 27.73059177) { + sum += 1.272600000000e-04; + } else { + sum += 1.461200000000e-04; + } + } + } else { + if (beta <= 30.59380627) { + if (f107 <= 74.50000000) { + sum += 1.233340000000e-04; + } else { + sum += 5.683846153846e-05; + } + } else { + if (f107_smooth <= 74.64999771) { + sum += 1.167100000000e-04; + } else { + sum += 1.584600000000e-04; + } + } + } + } + } else { + if (f107 <= 91.14999771) { + if (beta <= 20.02822018) { + if (beta <= 20.00767708) { + if (ap <= 8.00000000) { + sum += 1.817950000000e-04; + } else { + sum += 9.173500000000e-05; + } + } else { + if (f107_smooth <= 78.09999847) { + sum += 4.987150000000e-05; + } else { + sum += 1.335366666667e-04; + } + } + } else { + if (ap <= 14.50000000) { + if (f107_smooth <= 75.14999771) { + sum += -7.933891063830e-05; + } else { + sum += -5.083952669903e-06; + } + } else { + if (beta <= 23.52087784) { + sum += -1.010900000000e-04; + } else { + sum += 1.538263600000e-04; + } + } + } + } else { + if (f107 <= 94.34999847) { + if (f107 <= 92.90000153) { + if (f107 <= 91.90000153) { + sum += 7.646600000000e-05; + } else { + sum += 2.138811764706e-04; + } + } else { + if (f107 <= 93.40000153) { + sum += -3.868300000000e-05; + } else { + sum += 1.689050000000e-04; + } + } + } else { + if (f107_smooth <= 88.00000000) { + if (f107 <= 101.75000000) { + sum += 1.118231055556e-04; + } else { + sum += 3.109088571429e-05; + } + } else { + if (beta <= 24.25577450) { + sum += -4.741100000000e-05; + } else { + sum += -8.955200000000e-05; + } + } + } + } + } + } + } else { + if (f107 <= 104.70000076) { + if (ap <= 6.50000000) { + if (beta <= 29.55703640) { + if (f107 <= 102.70000076) { + if (f107 <= 79.95000076) { + if (beta <= 26.16369343) { + sum += -1.321000000000e-04; + } else { + sum += -1.461436363636e-04; + } + } else { + if (f107_smooth <= 104.75000000) { + sum += -9.016185714286e-05; + } else { + sum += -1.227692884615e-04; + } + } + } else { + if (beta <= 24.26539898) { + sum += -5.632100000000e-05; + } else { + sum += -6.429000000000e-05; + } + } + } else { + if (f107_smooth <= 112.69999695) { + if (f107 <= 95.94999695) { + if (beta <= 30.86402798) { + sum += -2.307700000000e-05; + } else { + sum += -3.882900000000e-05; + } + } else { + if (beta <= 30.21661186) { + sum += 4.209500000000e-06; + } else { + sum += 1.110473333333e-04; + } + } + } else { + if (f107_smooth <= 114.75000000) { + sum += -6.210500000000e-05; + } else { + if (beta <= 30.84350872) { + sum += -1.529900000000e-04; + } else { + sum += -1.484400000000e-04; + } + } + } + } + } else { + if (beta <= 20.67538834) { + if (f107 <= 97.20000076) { + sum += -1.288400000000e-04; + } else { + if (f107_smooth <= 126.95000076) { + if (beta <= 20.03249359) { + sum += -2.167600000000e-05; + } else { + sum += 2.309250000000e-06; + } + } else { + if (beta <= 20.06789875) { + sum += 5.650560000000e-05; + } else { + sum += 8.958700000000e-05; + } + } + } + } else { + if (ap <= 9.50000000) { + if (beta <= 23.07770157) { + if (beta <= 21.95971966) { + sum += -1.179250000000e-04; + } else { + sum += -1.440783333333e-04; + } + } else { + if (f107 <= 95.04999924) { + sum += -9.860500000000e-05; + } else { + sum += -1.311893870968e-05; + } + } + } else { + if (f107 <= 98.00000000) { + if (ap <= 13.50000000) { + sum += -9.773292857143e-05; + } else { + sum += -1.485350000000e-04; + } + } else { + if (f107 <= 101.29999924) { + sum += -4.397434000000e-05; + } else { + sum += -9.394500000000e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 133.69999695) { + if (beta <= 31.14414597) { + if (f107 <= 105.35000229) { + if (f107_smooth <= 119.19999695) { + if (beta <= 30.52417946) { + sum += 1.978400000000e-04; + } else { + sum += 1.883200000000e-04; + } + } else { + if (beta <= 23.89560604) { + sum += 2.314500000000e-04; + } else { + sum += 2.272400000000e-04; + } + } + } else { + if (f107 <= 107.45000076) { + if (f107_smooth <= 129.34999847) { + sum += -8.738058333333e-05; + } else { + sum += 2.356000000000e-04; + } + } else { + if (f107 <= 110.25000000) { + sum += 9.137461612903e-05; + } else { + sum += -1.305673103448e-05; + } + } + } + } else { + if (f107_smooth <= 108.60000229) { + if (ap <= 13.50000000) { + sum += 2.275300000000e-04; + } else { + if (beta <= 31.27854729) { + sum += 2.049000000000e-04; + } else { + sum += 2.139800000000e-04; + } + } + } else { + sum += 1.731000000000e-04; + } + } + } else { + if (f107_smooth <= 134.19999695) { + if (beta <= 25.06392193) { + sum += -4.713900000000e-05; + } else { + if (beta <= 25.08519554) { + sum += -5.624800000000e-05; + } else { + sum += -6.479200000000e-05; + } + } + } else { + if (ap <= 23.00000000) { + if (ap <= 16.50000000) { + if (ap <= 9.50000000) { + sum += -1.034357142857e-04; + } else { + sum += -9.810000000000e-05; + } + } else { + if (ap <= 21.00000000) { + sum += -1.265200000000e-04; + } else { + sum += -1.041100000000e-04; + } + } + } else { + sum += -1.364000000000e-04; + } + } + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (ap <= 38.50000000) { + if (f107_smooth <= 192.34999847) { + if (f107_smooth <= 162.15000153) { + if (f107 <= 123.95000076) { + if (beta <= 24.61864090) { + if (f107_smooth <= 151.84999847) { + sum += 9.549900093458e-05; + } else { + sum += -8.088809500000e-05; + } + } else { + if (f107_smooth <= 146.10000610) { + sum += 1.264959000000e-04; + } else { + sum += 1.992516875000e-04; + } + } + } else { + if (f107_smooth <= 128.05000305) { + if (beta <= 30.28458023) { + sum += 1.648451386139e-04; + } else { + sum += -2.866164285714e-05; + } + } else { + if (f107_smooth <= 147.44999695) { + sum += 2.215249169355e-05; + } else { + sum += 6.983048150611e-05; + } + } + } + } else { + if (f107_smooth <= 163.44999695) { + if (f107 <= 134.65000153) { + if (f107_smooth <= 163.00000000) { + sum += -4.139950000000e-05; + } else { + sum += 2.426250000000e-04; + } + } else { + if (beta <= 31.30897522) { + sum += 2.209867627119e-04; + } else { + sum += -6.603766666667e-05; + } + } + } else { + if (ap <= 23.50000000) { + if (ap <= 5.50000000) { + sum += 1.244095570064e-04; + } else { + sum += 6.254192596685e-05; + } + } else { + if (beta <= 30.94823456) { + sum += 2.307810204082e-04; + } else { + sum += -1.030892857143e-05; + } + } + } + } + } else { + if (f107 <= 169.30000305) { + sum += 3.125800000000e-04; + } else { + if (ap <= 24.50000000) { + if (f107 <= 244.25000000) { + if (f107 <= 196.34999847) { + sum += -6.445950000000e-05; + } else { + sum += -8.238752941176e-05; + } + } else { + sum += -1.193200000000e-05; + } + } else { + if (beta <= 27.19164658) { + sum += 2.267800000000e-05; + } else { + sum += -1.607300000000e-06; + } + } + } + } + } else { + if (beta <= 20.14750385) { + if (beta <= 20.10345459) { + if (beta <= 20.05780220) { + if (f107_smooth <= 134.14999390) { + sum += -1.003700000000e-04; + } else { + sum += -9.692000000000e-05; + } + } else { + if (ap <= 65.50000000) { + sum += -9.877300000000e-05; + } else { + sum += -1.032000000000e-04; + } + } + } else { + sum += -9.527600000000e-05; + } + } else { + if (f107 <= 185.75000000) { + if (beta <= 26.39578152) { + if (f107_smooth <= 157.40000153) { + if (ap <= 47.50000000) { + sum += 2.629380000000e-04; + } else { + sum += 7.261185714286e-05; + } + } else { + if (ap <= 41.00000000) { + sum += -4.813600000000e-05; + } else { + sum += -6.542100000000e-05; + } + } + } else { + if (f107 <= 137.60000229) { + if (beta <= 29.07187080) { + sum += 1.170700000000e-04; + } else { + sum += 1.380200000000e-04; + } + } else { + if (f107 <= 159.34999847) { + sum += 3.214583333333e-04; + } else { + sum += 2.939750000000e-04; + } + } + } + } else { + if (beta <= 22.28528690) { + if (beta <= 20.91299820) { + sum += 3.754300000000e-04; + } else { + if (f107_smooth <= 176.65000153) { + sum += 4.162900000000e-04; + } else { + sum += 4.057400000000e-04; + } + } + } else { + if (beta <= 25.85732841) { + if (ap <= 59.50000000) { + sum += 2.959900000000e-04; + } else { + sum += 3.113875000000e-04; + } + } else { + if (beta <= 27.43329525) { + sum += 2.686400000000e-04; + } else { + sum += 2.983100000000e-04; + } + } + } + } + } + } + } else { + if (ap <= 17.50000000) { + if (f107 <= 183.75000000) { + if (f107_smooth <= 200.90000153) { + if (ap <= 6.50000000) { + if (beta <= 25.86328602) { + if (f107_smooth <= 200.29999542) { + sum += 1.627500000000e-04; + } else { + sum += 3.026400000000e-04; + } + } else { + if (ap <= 4.50000000) { + sum += 2.375200000000e-04; + } else { + sum += 2.895564285714e-04; + } + } + } else { + if (f107 <= 152.00000000) { + if (beta <= 24.38827515) { + sum += 2.895300000000e-04; + } else { + sum += 2.887500000000e-04; + } + } else { + if (f107_smooth <= 200.00000000) { + sum += 1.252076086957e-04; + } else { + sum += 4.067045000000e-05; + } + } + } + } else { + if (beta <= 23.94271374) { + if (beta <= 21.43535519) { + if (beta <= 21.09800625) { + sum += 2.264600000000e-04; + } else { + sum += 2.640080000000e-04; + } + } else { + if (f107 <= 173.05000305) { + sum += 1.674344444444e-04; + } else { + sum += 1.240298571429e-04; + } + } + } else { + if (beta <= 23.99580574) { + if (beta <= 23.95482063) { + sum += 3.559200000000e-04; + } else { + sum += 4.049000000000e-04; + } + } else { + if (ap <= 13.00000000) { + sum += 3.141280000000e-04; + } else { + sum += 2.289733333333e-04; + } + } + } + } + } else { + if (beta <= 22.57445145) { + if (ap <= 10.50000000) { + if (f107_smooth <= 213.75000000) { + if (f107 <= 228.84999847) { + sum += -2.077541666667e-05; + } else { + sum += -4.031900000000e-05; + } + } else { + if (f107_smooth <= 214.40000153) { + sum += 1.557276250000e-05; + } else { + sum += 5.385033333333e-05; + } + } + } else { + sum += 1.703000000000e-04; + } + } else { + if (beta <= 28.76688957) { + if (beta <= 24.59099674) { + if (f107 <= 247.20000458) { + sum += 1.856104166667e-04; + } else { + sum += 8.044681578947e-05; + } + } else { + if (beta <= 28.45134735) { + sum += 5.081438157895e-05; + } else { + sum += 1.718925000000e-04; + } + } + } else { + if (beta <= 28.95384216) { + sum += 4.669000000000e-04; + } else { + sum += 3.400600000000e-04; + } + } + } + } + } else { + if (ap <= 18.50000000) { + if (beta <= 24.08898258) { + sum += 1.384500000000e-03; + } else { + if (beta <= 24.09435940) { + sum += 4.126900000000e-04; + } else { + if (f107 <= 166.79999542) { + sum += 3.322000000000e-04; + } else { + if (beta <= 24.33101273) { + sum += 2.094900000000e-04; + } else { + sum += 2.121300000000e-04; + } + } + } + } + } else { + if (ap <= 89.00000000) { + if (f107_smooth <= 218.45000458) { + if (beta <= 22.41878700) { + if (beta <= 20.86458969) { + sum += 1.181900000000e-04; + } else { + sum += 1.310050000000e-04; + } + } else { + if (f107 <= 253.80000305) { + sum += 3.095764285714e-04; + } else { + sum += 1.979200000000e-04; + } + } + } else { + if (ap <= 26.50000000) { + if (beta <= 24.54682922) { + sum += 2.552920000000e-04; + } else { + sum += 1.918942857143e-04; + } + } else { + if (f107 <= 261.15000153) { + sum += 1.333110000000e-04; + } else { + sum += 1.206600000000e-05; + } + } + } + } else { + if (ap <= 106.50000000) { + sum += 1.397800000000e-03; + } else { + if (beta <= 24.00211811) { + sum += 7.163500000000e-06; + } else { + if (beta <= 24.05673504) { + sum += 2.984300000000e-04; + } else { + sum += 2.698900000000e-04; + } + } + } + } + } + } + } + } + } + // Tree 16 + { + if (f107 <= 108.65000153) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (beta <= 20.01418686) { + if (f107 <= 77.25000000) { + if (f107 <= 75.34999847) { + if (beta <= 19.99787140) { + sum += 1.757700000000e-04; + } else { + sum += 1.779300000000e-04; + } + } else { + if (f107 <= 76.70000076) { + if (beta <= 19.99420357) { + sum += 2.066700000000e-04; + } else { + sum += 1.986900000000e-04; + } + } else { + if (beta <= 19.98829079) { + sum += 1.996775000000e-04; + } else { + sum += 1.942400000000e-04; + } + } + } + } else { + if (ap <= 3.50000000) { + if (ap <= 2.50000000) { + sum += 1.625200000000e-04; + } else { + if (beta <= 19.99444103) { + sum += 1.542500000000e-04; + } else { + sum += 1.367300000000e-04; + } + } + } else { + if (f107_smooth <= 77.95000076) { + sum += 1.139200000000e-04; + } else { + sum += 7.149600000000e-05; + } + } + } + } else { + if (ap <= 18.50000000) { + if (beta <= 20.44068432) { + if (beta <= 20.08318710) { + if (beta <= 20.04597950) { + sum += 6.404757142857e-05; + } else { + sum += -2.404633333333e-05; + } + } else { + if (f107 <= 78.34999847) { + sum += -1.308748571429e-04; + } else { + sum += -6.194377777778e-05; + } + } + } else { + if (beta <= 21.45583916) { + if (ap <= 3.50000000) { + sum += 1.543620512821e-04; + } else { + sum += 1.688176500000e-05; + } + } else { + if (beta <= 23.96317291) { + sum += -5.002143211679e-05; + } else { + sum += 1.454790400000e-05; + } + } + } + } else { + if (f107_smooth <= 74.54999924) { + if (beta <= 29.50474644) { + sum += 6.908600000000e-05; + } else { + if (f107_smooth <= 74.35000229) { + sum += -9.275850000000e-05; + } else { + sum += -2.511500000000e-05; + } + } + } else { + if (beta <= 26.19253540) { + if (ap <= 21.00000000) { + sum += 1.547000000000e-04; + } else { + sum += 1.142176666667e-04; + } + } else { + if (f107 <= 72.90000153) { + sum += 2.111933333333e-04; + } else { + sum += 1.929150000000e-04; + } + } + } + } + } + } else { + if (f107 <= 92.90000153) { + if (beta <= 23.98918343) { + if (beta <= 23.98122597) { + if (ap <= 11.50000000) { + if (beta <= 20.85529995) { + sum += 2.205600000000e-04; + } else { + sum += 2.134300000000e-04; + } + } else { + if (beta <= 23.97149277) { + sum += 2.357100000000e-04; + } else { + sum += 2.163500000000e-04; + } + } + } else { + sum += 2.065500000000e-04; + } + } else { + if (f107 <= 91.50000000) { + if (beta <= 24.00835419) { + sum += 1.821400000000e-04; + } else { + sum += 1.525000000000e-04; + } + } else { + if (ap <= 5.00000000) { + if (beta <= 25.14543533) { + sum += 2.142800000000e-04; + } else { + sum += 2.142400000000e-04; + } + } else { + if (f107 <= 92.10000229) { + sum += 1.984733333333e-04; + } else { + sum += 1.905711111111e-04; + } + } + } + } + } else { + if (ap <= 8.50000000) { + if (f107_smooth <= 81.14999771) { + if (ap <= 4.50000000) { + if (f107_smooth <= 79.35000229) { + sum += 6.883750000000e-05; + } else { + sum += 1.214550000000e-04; + } + } else { + if (beta <= 22.48815823) { + sum += 1.684333333333e-04; + } else { + sum += 1.815600000000e-04; + } + } + } else { + if (f107 <= 95.45000076) { + if (ap <= 3.00000000) { + sum += 1.939700000000e-04; + } else { + sum += -3.828877777778e-05; + } + } else { + if (f107_smooth <= 87.89999771) { + sum += 1.187604454545e-04; + } else { + sum += -6.806666666667e-05; + } + } + } + } else { + if (f107_smooth <= 85.04999924) { + if (f107_smooth <= 81.00000000) { + sum += 1.992900000000e-04; + } else { + sum += 1.210700000000e-04; + } + } else { + if (f107_smooth <= 87.59999847) { + sum += 2.429400000000e-04; + } else { + if (f107 <= 97.59999847) { + sum += 2.078500000000e-04; + } else { + sum += 1.953600000000e-04; + } + } + } + } + } + } + } else { + if (ap <= 21.00000000) { + if (beta <= 31.11440563) { + if (ap <= 6.50000000) { + if (f107 <= 98.84999847) { + if (beta <= 30.86555576) { + if (f107_smooth <= 96.64999771) { + sum += -7.104500000000e-05; + } else { + sum += -1.235322653061e-04; + } + } else { + sum += -3.882900000000e-05; + } + } else { + if (f107_smooth <= 108.84999847) { + if (f107_smooth <= 106.40000153) { + sum += -5.252937500000e-05; + } else { + sum += 8.485775000000e-05; + } + } else { + if (beta <= 28.08232498) { + sum += -1.088623200000e-04; + } else { + sum += -6.659533333333e-05; + } + } + } + } else { + if (f107 <= 107.39999771) { + if (beta <= 23.05671215) { + if (f107_smooth <= 122.39999771) { + sum += -1.210258750000e-04; + } else { + sum += -3.747200000000e-05; + } + } else { + if (beta <= 24.04923725) { + sum += 3.986929000000e-05; + } else { + sum += -7.111073750000e-05; + } + } + } else { + if (ap <= 13.50000000) { + sum += 1.939100000000e-04; + } else { + if (beta <= 25.12572670) { + sum += -3.361060000000e-06; + } else { + sum += -1.294500000000e-04; + } + } + } + } + } else { + if (beta <= 31.22574806) { + if (f107_smooth <= 110.44999695) { + if (beta <= 31.19440174) { + sum += 8.692000000000e-05; + } else { + sum += 1.031600000000e-04; + } + } else { + if (beta <= 31.15727615) { + sum += 4.015400000000e-05; + } else { + sum += 5.871200000000e-05; + } + } + } else { + sum += 1.731000000000e-04; + } + } + } else { + if (f107_smooth <= 130.75000000) { + if (f107 <= 103.50000000) { + if (beta <= 20.38100624) { + if (beta <= 20.09362411) { + sum += 1.173800000000e-04; + } else { + sum += 1.329600000000e-04; + } + } else { + if (f107_smooth <= 125.80000305) { + if (beta <= 20.67538834) { + sum += -2.958000000000e-05; + } else { + sum += -5.236700000000e-05; + } + } else { + if (beta <= 24.90350819) { + sum += 2.100600000000e-06; + } else { + sum += 2.116700000000e-05; + } + } + } + } else { + if (f107_smooth <= 119.19999695) { + if (beta <= 30.55158138) { + if (beta <= 30.52417946) { + sum += 1.978400000000e-04; + } else { + sum += 1.883200000000e-04; + } + } else { + sum += 1.727400000000e-04; + } + } else { + sum += 2.314500000000e-04; + } + } + } else { + if (beta <= 24.24029160) { + sum += -1.101000000000e-04; + } else { + if (beta <= 24.29445457) { + sum += -1.035600000000e-04; + } else { + sum += -9.970900000000e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 194.50000000) { + if (ap <= 44.00000000) { + if (f107_smooth <= 128.05000305) { + if (f107 <= 134.34999847) { + if (ap <= 11.50000000) { + if (f107 <= 113.45000076) { + if (f107 <= 113.25000000) { + sum += 2.600691944444e-05; + } else { + sum += -1.302250000000e-04; + } + } else { + if (beta <= 24.49544525) { + sum += 3.823971500000e-05; + } else { + sum += 1.292535277778e-04; + } + } + } else { + if (beta <= 23.13950348) { + if (beta <= 20.75493908) { + sum += 1.698650000000e-04; + } else { + sum += -2.304982222222e-05; + } + } else { + if (ap <= 27.50000000) { + sum += 1.787338307692e-04; + } else { + sum += -4.672666666667e-06; + } + } + } + } else { + if (ap <= 26.50000000) { + if (beta <= 26.60984898) { + if (beta <= 21.73311996) { + sum += 2.002787096774e-04; + } else { + sum += 2.366765517241e-04; + } + } else { + if (f107 <= 144.79999542) { + sum += 2.221000000000e-04; + } else { + sum += 6.848600000000e-05; + } + } + } else { + sum += 6.529400000000e-05; + } + } + } else { + if (f107_smooth <= 147.25000000) { + if (f107 <= 142.15000153) { + if (ap <= 30.50000000) { + if (beta <= 21.46909904) { + sum += 2.215328504673e-05; + } else { + sum += 8.685211302521e-05; + } + } else { + if (beta <= 23.82378101) { + sum += 2.420100000000e-04; + } else { + sum += 1.988166666667e-04; + } + } + } else { + if (ap <= 4.50000000) { + if (f107 <= 146.59999847) { + sum += -5.697386666667e-05; + } else { + sum += 1.284644137931e-04; + } + } else { + if (beta <= 20.58329964) { + sum += 8.557981250000e-05; + } else { + sum += -2.617348181548e-05; + } + } + } + } else { + if (f107_smooth <= 170.55000305) { + if (f107_smooth <= 167.04999542) { + if (f107 <= 149.25000000) { + sum += 1.087748963951e-04; + } else { + sum += 7.022555576182e-05; + } + } else { + if (beta <= 21.00511551) { + sum += -2.206237500000e-05; + } else { + sum += 1.739464321429e-04; + } + } + } else { + if (f107 <= 198.84999847) { + if (beta <= 29.35283375) { + sum += -3.076799586207e-06; + } else { + sum += 7.435517391304e-05; + } + } else { + if (f107 <= 221.09999847) { + sum += 1.649884848485e-04; + } else { + sum += -1.980214838710e-06; + } + } + } + } + } + } else { + if (f107_smooth <= 154.45000458) { + if (f107 <= 164.70000458) { + if (f107_smooth <= 133.39999390) { + if (beta <= 22.37586689) { + if (beta <= 20.17906189) { + sum += 2.481600000000e-04; + } else { + sum += 2.569000000000e-04; + } + } else { + sum += 1.898900000000e-04; + } + } else { + if (ap <= 50.00000000) { + if (beta <= 24.57593536) { + sum += -1.292900000000e-04; + } else { + sum += -1.241300000000e-04; + } + } else { + if (f107_smooth <= 146.00000000) { + sum += -5.560800000000e-05; + } else { + sum += 1.044610000000e-04; + } + } + } + } else { + if (f107 <= 176.60000610) { + if (beta <= 24.49140835) { + sum += 2.613200000000e-04; + } else { + sum += 2.444200000000e-04; + } + } else { + if (beta <= 24.30503178) { + sum += 3.104100000000e-04; + } else { + sum += 3.073200000000e-04; + } + } + } + } else { + if (f107 <= 213.54999542) { + if (f107_smooth <= 159.00000000) { + if (beta <= 24.28303528) { + if (beta <= 24.27766418) { + sum += 3.091500000000e-04; + } else { + sum += 3.063100000000e-04; + } + } else { + if (ap <= 60.00000000) { + sum += 3.177000000000e-04; + } else { + sum += 3.100400000000e-04; + } + } + } else { + if (beta <= 27.43329525) { + if (ap <= 56.50000000) { + sum += 2.865300000000e-04; + } else { + sum += 2.686400000000e-04; + } + } else { + if (ap <= 61.50000000) { + sum += 2.889800000000e-04; + } else { + sum += 2.962442857143e-04; + } + } + } + } else { + if (beta <= 21.04163074) { + if (beta <= 20.99651718) { + sum += 4.078500000000e-04; + } else { + sum += 4.032800000000e-04; + } + } else { + sum += 4.129300000000e-04; + } + } + } + } + } else { + if (f107 <= 232.90000153) { + if (ap <= 89.00000000) { + if (f107 <= 182.34999847) { + if (f107_smooth <= 200.90000153) { + if (f107_smooth <= 200.25000000) { + if (f107_smooth <= 195.75000000) { + sum += 1.234591428571e-04; + } else { + sum += 2.278248600000e-04; + } + } else { + if (ap <= 10.50000000) { + sum += 5.606550000000e-06; + } else { + sum += 1.428566666667e-04; + } + } + } else { + if (beta <= 23.94521427) { + if (f107_smooth <= 207.65000153) { + sum += 2.364537142857e-04; + } else { + sum += 1.473199230769e-04; + } + } else { + if (beta <= 23.99580574) { + sum += 3.989028571429e-04; + } else { + sum += 2.923655319149e-04; + } + } + } + } else { + if (f107_smooth <= 221.00000000) { + if (ap <= 12.00000000) { + if (f107 <= 195.75000000) { + sum += 1.501650000000e-04; + } else { + sum += 6.087195000000e-05; + } + } else { + if (f107_smooth <= 212.05000305) { + sum += 2.723507692308e-04; + } else { + sum += 1.263173000000e-04; + } + } + } else { + if (beta <= 24.57593060) { + if (beta <= 24.54682922) { + sum += 3.002285185185e-04; + } else { + sum += 2.004666666667e-04; + } + } else { + if (f107_smooth <= 223.55000305) { + sum += 6.371100000000e-05; + } else { + sum += 4.938866666667e-05; + } + } + } + } + } else { + if (beta <= 24.07121468) { + if (beta <= 24.05673504) { + sum += 2.984300000000e-04; + } else { + sum += 2.698900000000e-04; + } + } else { + sum += 1.397800000000e-03; + } + } + } else { + if (beta <= 22.68894672) { + if (f107 <= 236.09999847) { + if (beta <= 22.02368641) { + sum += -6.224300000000e-05; + } else { + if (f107_smooth <= 212.05000305) { + sum += -6.395900000000e-05; + } else { + sum += -6.443600000000e-05; + } + } + } else { + if (f107 <= 240.09999847) { + sum += -2.005400000000e-05; + } else { + sum += -2.163600000000e-05; + } + } + } else { + if (beta <= 23.49438000) { + if (beta <= 23.32751465) { + if (ap <= 20.50000000) { + if (ap <= 17.00000000) { + sum += 2.674300000000e-04; + } else { + sum += 2.563700000000e-04; + } + } else { + sum += 2.827800000000e-04; + } + } else { + if (ap <= 13.50000000) { + if (f107 <= 245.85000610) { + sum += 2.333700000000e-04; + } else { + sum += 2.237700000000e-04; + } + } else { + sum += 2.479000000000e-04; + } + } + } else { + if (beta <= 24.09532928) { + if (f107 <= 245.90000153) { + if (f107_smooth <= 203.40000153) { + sum += 5.814857142857e-05; + } else { + sum += 1.320905000000e-04; + } + } else { + if (f107 <= 271.19999695) { + sum += 5.531715789474e-05; + } else { + sum += 3.452967857143e-05; + } + } + } else { + if (ap <= 33.50000000) { + if (f107 <= 241.90000153) { + sum += 2.208958235294e-04; + } else { + sum += 1.041982758621e-04; + } + } else { + sum += 5.615000000000e-04; + } + } + } + } + } + } + } + } + // Tree 17 + { + if (f107 <= 114.20000076) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.60000229) { + if (beta <= 20.03407383) { + if (beta <= 19.99245453) { + if (f107 <= 74.95000076) { + sum += 1.630000000000e-04; + } else { + if (f107 <= 76.70000076) { + if (beta <= 19.99022770) { + sum += 2.069800000000e-04; + } else { + sum += 2.059800000000e-04; + } + } else { + sum += 2.046800000000e-04; + } + } + } else { + if (ap <= 3.50000000) { + if (ap <= 1.50000000) { + sum += 1.779300000000e-04; + } else { + if (beta <= 19.99444103) { + sum += 1.542500000000e-04; + } else { + sum += 1.427975000000e-04; + } + } + } else { + if (ap <= 4.50000000) { + sum += 4.611200000000e-05; + } else { + if (ap <= 8.00000000) { + sum += 1.343000000000e-04; + } else { + sum += 1.065250000000e-04; + } + } + } + } + } else { + if (beta <= 20.44068432) { + if (beta <= 20.10434628) { + if (ap <= 6.50000000) { + if (beta <= 20.05190945) { + sum += 7.747100000000e-05; + } else { + sum += 4.868200000000e-05; + } + } else { + if (f107_smooth <= 78.45000076) { + sum += -1.849400000000e-05; + } else { + sum += -6.789500000000e-05; + } + } + } else { + if (ap <= 3.50000000) { + if (f107_smooth <= 78.79999924) { + sum += -9.642900000000e-05; + } else { + sum += -4.516475000000e-05; + } + } else { + if (f107 <= 84.15000153) { + sum += -1.372954444444e-04; + } else { + sum += -5.694800000000e-05; + } + } + } + } else { + if (beta <= 21.37030125) { + if (beta <= 20.57359791) { + if (f107 <= 79.39999771) { + sum += -7.477200000000e-05; + } else { + sum += 4.898372000000e-05; + } + } else { + if (ap <= 3.50000000) { + sum += 1.840113809524e-04; + } else { + sum += 9.856244444444e-05; + } + } + } else { + if (beta <= 23.92033958) { + if (f107_smooth <= 81.34999847) { + sum += -2.528901372549e-05; + } else { + sum += -1.219979574468e-04; + } + } else { + if (beta <= 24.17841244) { + sum += 1.097016028571e-04; + } else { + sum += 4.007439639640e-06; + } + } + } + } + } + } else { + if (f107 <= 93.64999771) { + if (f107_smooth <= 82.70000076) { + if (f107_smooth <= 81.14999771) { + sum += 1.706400000000e-04; + } else { + if (beta <= 24.54909134) { + sum += -3.868300000000e-05; + } else { + sum += -2.033500000000e-05; + } + } + } else { + if (beta <= 23.97653675) { + sum += 2.357100000000e-04; + } else { + if (ap <= 5.00000000) { + if (ap <= 2.50000000) { + sum += 2.034400000000e-04; + } else { + sum += 2.167750000000e-04; + } + } else { + if (f107 <= 92.95000076) { + sum += 1.933666666667e-04; + } else { + sum += 2.104060000000e-04; + } + } + } + } + } else { + if (ap <= 10.50000000) { + if (f107_smooth <= 87.94999695) { + if (beta <= 24.55145741) { + if (beta <= 23.88744259) { + sum += 4.340654000000e-05; + } else { + sum += 1.174800000000e-04; + } + } else { + if (beta <= 24.55220795) { + sum += 3.358900000000e-06; + } else { + sum += 1.965100000000e-05; + } + } + } else { + if (f107 <= 98.09999847) { + if (beta <= 24.23282051) { + sum += -2.896500000000e-05; + } else { + sum += -4.164300000000e-05; + } + } else { + sum += -8.955200000000e-05; + } + } + } else { + if (ap <= 15.50000000) { + if (ap <= 13.50000000) { + if (beta <= 20.93379402) { + sum += 1.889400000000e-04; + } else { + sum += 1.842600000000e-04; + } + } else { + sum += 1.210700000000e-04; + } + } else { + if (beta <= 23.94188595) { + sum += 2.429400000000e-04; + } else { + sum += 2.468600000000e-04; + } + } + } + } + } + } else { + if (f107 <= 104.70000076) { + if (beta <= 29.60061264) { + if (beta <= 20.73355293) { + if (ap <= 7.00000000) { + if (f107 <= 100.79999924) { + if (f107 <= 99.29999924) { + sum += -1.261240000000e-04; + } else { + sum += -1.093525000000e-04; + } + } else { + if (ap <= 4.50000000) { + sum += -8.656200000000e-05; + } else { + sum += -5.632100000000e-05; + } + } + } else { + if (f107_smooth <= 126.95000076) { + if (f107_smooth <= 125.10000229) { + sum += -4.614080000000e-05; + } else { + sum += 6.551111111111e-07; + } + } else { + if (beta <= 20.06789875) { + sum += 5.575700000000e-05; + } else { + sum += 8.958700000000e-05; + } + } + } + } else { + if (ap <= 6.50000000) { + if (f107_smooth <= 96.64999771) { + if (beta <= 25.91241932) { + sum += -6.658700000000e-05; + } else { + sum += -7.550300000000e-05; + } + } else { + if (f107 <= 102.70000076) { + sum += -1.284956379310e-04; + } else { + sum += -7.493900000000e-05; + } + } + } else { + if (ap <= 11.50000000) { + if (beta <= 23.04363537) { + sum += -1.132903076923e-04; + } else { + sum += -6.733438571429e-05; + } + } else { + if (beta <= 24.61682224) { + sum += -1.313985714286e-04; + } else { + sum += -9.011962500000e-05; + } + } + } + } + } else { + if (f107_smooth <= 109.39999771) { + if (beta <= 29.84634399) { + if (ap <= 7.00000000) { + sum += -6.956700000000e-06; + } else { + sum += -6.211200000000e-05; + } + } else { + if (beta <= 30.73674583) { + if (beta <= 30.24785805) { + sum += 4.958300000000e-05; + } else { + sum += 1.086460000000e-04; + } + } else { + if (f107_smooth <= 109.00000000) { + sum += 5.423900000000e-05; + } else { + sum += 1.256220000000e-05; + } + } + } + } else { + if (beta <= 31.04395962) { + if (beta <= 30.49310303) { + if (ap <= 7.00000000) { + sum += -6.210500000000e-05; + } else { + sum += -2.959600000000e-05; + } + } else { + if (f107_smooth <= 114.29999924) { + sum += -9.508333333333e-05; + } else { + sum += -1.389282727273e-04; + } + } + } else { + if (f107 <= 96.19999695) { + if (beta <= 31.09326077) { + sum += -2.688800000000e-05; + } else { + sum += 5.538445000000e-06; + } + } else { + if (f107_smooth <= 110.44999695) { + sum += 9.504000000000e-05; + } else { + sum += 5.871200000000e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 133.69999695) { + if (f107_smooth <= 109.20000076) { + if (beta <= 30.11411476) { + if (f107 <= 110.79999924) { + if (beta <= 30.06511211) { + sum += 1.082293333333e-04; + } else { + sum += 1.411700000000e-04; + } + } else { + sum += 2.073000000000e-06; + } + } else { + if (f107 <= 110.34999847) { + if (beta <= 31.26687527) { + sum += 1.818200000000e-04; + } else { + sum += 2.049000000000e-04; + } + } else { + if (ap <= 11.00000000) { + sum += 2.231600000000e-04; + } else { + sum += 2.313000000000e-04; + } + } + } + } else { + if (f107_smooth <= 122.25000000) { + if (beta <= 28.25039864) { + if (ap <= 5.50000000) { + sum += -6.810166666667e-05; + } else { + sum += -1.179162000000e-04; + } + } else { + if (f107_smooth <= 112.14999771) { + sum += -1.295050000000e-04; + } else { + sum += 4.451851875000e-05; + } + } + } else { + if (beta <= 20.09280014) { + if (f107 <= 109.25000000) { + sum += -8.135614285714e-05; + } else { + sum += -1.633400000000e-05; + } + } else { + if (beta <= 23.91310787) { + sum += 1.872681714286e-04; + } else { + sum += 3.146972727273e-05; + } + } + } + } + } else { + if (ap <= 19.50000000) { + if (f107 <= 113.95000076) { + if (ap <= 10.50000000) { + if (beta <= 26.08974648) { + sum += -1.066190000000e-04; + } else { + sum += -9.518300000000e-05; + } + } else { + sum += -5.624800000000e-05; + } + } else { + sum += -7.367500000000e-05; + } + } else { + if (beta <= 25.36328220) { + sum += -1.366500000000e-04; + } else { + sum += -1.364000000000e-04; + } + } + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (ap <= 42.50000000) { + if (f107 <= 123.95000076) { + if (f107_smooth <= 153.40000153) { + if (beta <= 24.47712994) { + if (beta <= 23.97665977) { + if (f107_smooth <= 138.69999695) { + sum += 7.752966049383e-05; + } else { + sum += 2.044422307692e-04; + } + } else { + if (f107 <= 122.90000153) { + sum += -3.957179615385e-05; + } else { + sum += 1.215168333333e-04; + } + } + } else { + if (f107_smooth <= 104.55000305) { + if (ap <= 11.50000000) { + sum += 4.478611250000e-05; + } else { + sum += 1.727875000000e-04; + } + } else { + if (ap <= 23.50000000) { + sum += 1.967109252336e-04; + } else { + sum += 1.418000000000e-04; + } + } + } + } else { + if (ap <= 10.50000000) { + if (f107 <= 116.39999771) { + if (beta <= 24.60916424) { + sum += -4.703600000000e-05; + } else { + sum += -3.923400000000e-05; + } + } else { + if (f107 <= 121.65000153) { + sum += -8.424480000000e-05; + } else { + sum += -5.598966666667e-05; + } + } + } else { + if (ap <= 14.00000000) { + sum += 9.082100000000e-06; + } else { + sum += 5.620400000000e-05; + } + } + } + } else { + if (f107_smooth <= 162.44999695) { + if (f107_smooth <= 128.05000305) { + if (beta <= 30.27410984) { + if (f107 <= 134.34999847) { + sum += 1.289720058824e-04; + } else { + sum += 1.900385151515e-04; + } + } else { + if (f107_smooth <= 108.20000076) { + sum += 1.493557142857e-04; + } else { + sum += -7.897042857143e-05; + } + } + } else { + if (beta <= 21.67082977) { + if (beta <= 20.93954468) { + sum += 3.313016890909e-05; + } else { + sum += -5.452798536585e-05; + } + } else { + if (beta <= 24.45681858) { + sum += 8.948441233766e-05; + } else { + sum += 4.320538010753e-05; + } + } + } + } else { + if (f107_smooth <= 170.55000305) { + if (beta <= 31.26488495) { + if (f107 <= 125.30000305) { + sum += -1.677557142857e-05; + } else { + sum += 1.703269934426e-04; + } + } else { + if (beta <= 31.30795860) { + sum += -2.737100000000e-05; + } else { + sum += -5.791990909091e-05; + } + } + } else { + if (beta <= 20.14269447) { + if (f107_smooth <= 184.34999847) { + sum += 8.719150000000e-05; + } else { + sum += 2.436994736842e-04; + } + } else { + if (ap <= 23.50000000) { + sum += 4.421760253165e-05; + } else { + sum += 1.453420243902e-04; + } + } + } + } + } + } else { + if (f107 <= 164.05000305) { + if (beta <= 20.11685467) { + if (beta <= 20.05248547) { + sum += -1.003700000000e-04; + } else { + if (f107 <= 145.09999847) { + if (f107_smooth <= 134.14999390) { + sum += -1.076600000000e-04; + } else { + sum += -1.032000000000e-04; + } + } else { + sum += -1.091900000000e-04; + } + } + } else { + if (f107_smooth <= 156.70000458) { + if (beta <= 24.56729889) { + if (f107 <= 145.69999695) { + sum += 2.138244444444e-04; + } else { + sum += 8.785009090909e-05; + } + } else { + if (ap <= 50.00000000) { + sum += -1.292900000000e-04; + } else { + sum += 7.213200000000e-05; + } + } + } else { + if (beta <= 30.57476807) { + if (f107_smooth <= 162.34999847) { + sum += 2.945500000000e-04; + } else { + sum += 2.934200000000e-04; + } + } else { + sum += 2.967500000000e-04; + } + } + } + } else { + if (beta <= 22.25915909) { + if (beta <= 20.91299820) { + sum += 3.754300000000e-04; + } else { + if (f107_smooth <= 177.55000305) { + if (f107_smooth <= 176.65000153) { + sum += 4.129300000000e-04; + } else { + sum += 4.078500000000e-04; + } + } else { + sum += 4.015200000000e-04; + } + } + } else { + if (beta <= 24.40085220) { + if (beta <= 23.85957813) { + sum += 2.770700000000e-04; + } else { + if (beta <= 24.28380203) { + sum += 3.077300000000e-04; + } else { + sum += 3.127300000000e-04; + } + } + } else { + if (f107 <= 180.60000610) { + sum += 2.613200000000e-04; + } else { + sum += 2.686400000000e-04; + } + } + } + } + } + } else { + if (ap <= 16.50000000) { + if (f107 <= 182.34999847) { + if (beta <= 24.53393936) { + if (beta <= 23.94034195) { + if (beta <= 21.53507328) { + if (beta <= 21.05481911) { + sum += 2.077740000000e-04; + } else { + sum += 2.470100000000e-04; + } + } else { + if (ap <= 7.00000000) { + sum += 1.016995000000e-04; + } else { + sum += 1.526860000000e-04; + } + } + } else { + if (beta <= 24.31830502) { + if (ap <= 10.00000000) { + sum += 3.278971428571e-04; + } else { + sum += 3.838928571429e-04; + } + } else { + if (f107_smooth <= 199.80000305) { + sum += 2.080400000000e-04; + } else { + sum += 2.913954545455e-04; + } + } + } + } else { + if (beta <= 25.73868370) { + if (ap <= 6.50000000) { + if (beta <= 24.56035614) { + sum += 1.490900000000e-04; + } else { + sum += 1.230133333333e-04; + } + } else { + if (ap <= 10.50000000) { + sum += 1.474167500000e-05; + } else { + sum += 1.358900000000e-04; + } + } + } else { + if (beta <= 26.82339287) { + if (beta <= 26.52401543) { + sum += 2.745162500000e-04; + } else { + sum += 2.198511111111e-04; + } + } else { + if (ap <= 10.00000000) { + sum += 1.437900000000e-04; + } else { + sum += 5.843300000000e-05; + } + } + } + } + } else { + if (beta <= 24.07706070) { + if (f107_smooth <= 221.65000153) { + if (f107 <= 195.75000000) { + if (beta <= 23.97098160) { + sum += 1.224127692308e-04; + } else { + sum += 3.098600000000e-04; + } + } else { + if (beta <= 22.47964859) { + sum += -1.969746190476e-05; + } else { + sum += 7.945627777778e-05; + } + } + } else { + if (f107_smooth <= 221.84999847) { + sum += 2.674300000000e-04; + } else { + if (beta <= 23.41647530) { + sum += 2.289400000000e-04; + } else { + sum += 1.992150000000e-04; + } + } + } + } else { + if (beta <= 24.55465508) { + if (f107_smooth <= 221.19999695) { + if (f107_smooth <= 203.25000000) { + sum += 3.086380000000e-04; + } else { + sum += 1.412076388889e-04; + } + } else { + if (beta <= 24.38840389) { + sum += 2.667900000000e-04; + } else { + sum += 3.090961111111e-04; + } + } + } else { + if (beta <= 28.71513748) { + if (beta <= 24.59291744) { + sum += 1.552840000000e-04; + } else { + sum += 6.622646428571e-05; + } + } else { + if (beta <= 28.93803501) { + sum += 4.669000000000e-04; + } else { + sum += 3.235100000000e-04; + } + } + } + } + } + } else { + if (ap <= 18.50000000) { + if (f107 <= 216.95000458) { + if (beta <= 24.55337715) { + if (f107 <= 193.20000458) { + if (beta <= 24.52261353) { + sum += 3.382400000000e-04; + } else { + sum += 3.377300000000e-04; + } + } else { + if (beta <= 24.03427792) { + sum += 2.758000000000e-04; + } else { + sum += 2.699300000000e-04; + } + } + } else { + if (beta <= 24.56051922) { + sum += 2.159600000000e-04; + } else { + sum += 2.121300000000e-04; + } + } + } else { + if (beta <= 24.09101105) { + sum += 1.384500000000e-03; + } else { + sum += 2.094900000000e-04; + } + } + } else { + if (f107 <= 237.59999847) { + if (f107_smooth <= 208.34999847) { + if (beta <= 22.41878700) { + if (beta <= 20.87298679) { + sum += 1.181900000000e-04; + } else { + sum += 1.321100000000e-04; + } + } else { + if (ap <= 64.00000000) { + sum += 3.236600000000e-04; + } else { + sum += 2.956850000000e-04; + } + } + } else { + if (ap <= 24.50000000) { + if (beta <= 24.54694653) { + sum += 2.651347058824e-04; + } else { + sum += 2.025400000000e-04; + } + } else { + if (f107_smooth <= 218.50000000) { + sum += 2.140875000000e-04; + } else { + sum += 1.319745000000e-04; + } + } + } + } else { + if (beta <= 23.38398933) { + if (beta <= 23.20159149) { + sum += 2.765300000000e-04; + } else { + sum += 2.827800000000e-04; + } + } else { + if (f107_smooth <= 215.09999847) { + sum += 1.582000000000e-04; + } else { + if (f107 <= 256.59999847) { + sum += 1.278000000000e-04; + } else { + sum += 1.828010000000e-05; + } + } + } + } + } + } + } + } + } + // Tree 18 + { + if (f107 <= 112.90000153) { + if (f107_smooth <= 96.54999924) { + if (f107 <= 91.14999771) { + if (ap <= 18.50000000) { + if (beta <= 20.02822018) { + if (beta <= 19.99245453) { + if (f107_smooth <= 78.04999924) { + if (beta <= 19.99082375) { + sum += 1.757700000000e-04; + } else { + sum += 1.630000000000e-04; + } + } else { + if (ap <= 4.50000000) { + sum += 2.059800000000e-04; + } else { + sum += 2.069800000000e-04; + } + } + } else { + if (ap <= 4.00000000) { + if (ap <= 1.50000000) { + sum += 1.779300000000e-04; + } else { + sum += 1.488614285714e-04; + } + } else { + if (f107_smooth <= 78.10000229) { + sum += 1.139200000000e-04; + } else { + sum += 1.198600000000e-04; + } + } + } + } else { + if (beta <= 20.54520321) { + if (beta <= 20.08318710) { + if (f107_smooth <= 78.25000000) { + sum += -1.120260000000e-05; + } else { + sum += 4.390563636364e-05; + } + } else { + if (f107 <= 79.04999924) { + sum += -1.222183500000e-04; + } else { + sum += -3.195510833333e-05; + } + } + } else { + if (beta <= 21.32970715) { + if (ap <= 6.50000000) { + sum += 1.515068956000e-04; + } else { + sum += -7.669500000000e-06; + } + } else { + if (f107_smooth <= 74.25000000) { + sum += -1.432357333333e-04; + } else { + sum += 2.573718723404e-06; + } + } + } + } + } else { + if (f107_smooth <= 74.35000229) { + if (f107 <= 75.64999771) { + sum += -7.078700000000e-05; + } else { + sum += -1.035100000000e-04; + } + } else { + if (f107_smooth <= 76.25000000) { + if (f107_smooth <= 74.54999924) { + if (beta <= 28.88853931) { + sum += 7.096266666667e-05; + } else { + sum += 5.534900000000e-05; + } + } else { + if (beta <= 23.94384861) { + sum += 1.244844444444e-04; + } else { + sum += 1.887858823529e-04; + } + } + } else { + if (beta <= 24.46025085) { + if (f107_smooth <= 79.75000000) { + sum += -1.464700000000e-04; + } else { + sum += -8.438500000000e-05; + } + } else { + sum += 7.951600000000e-05; + } + } + } + } + } else { + if (f107 <= 96.45000076) { + if (ap <= 8.50000000) { + if (ap <= 5.50000000) { + if (f107 <= 93.64999771) { + if (ap <= 4.50000000) { + sum += 2.106042857143e-04; + } else { + sum += 1.736900000000e-04; + } + } else { + if (beta <= 22.48868847) { + sum += 1.281780000000e-04; + } else { + sum += -9.349600000000e-05; + } + } + } else { + if (f107 <= 92.85000229) { + if (beta <= 24.33258629) { + sum += -2.920800000000e-05; + } else { + sum += 1.942100000000e-04; + } + } else { + if (beta <= 24.54909134) { + sum += -4.081666666667e-05; + } else { + sum += -2.033500000000e-05; + } + } + } + } else { + if (ap <= 15.00000000) { + if (f107 <= 92.34999847) { + sum += 1.525000000000e-04; + } else { + if (beta <= 23.09400654) { + sum += 1.891050000000e-04; + } else { + sum += 2.074400000000e-04; + } + } + } else { + if (ap <= 45.50000000) { + if (beta <= 23.96139145) { + sum += 2.484900000000e-04; + } else { + sum += 2.357100000000e-04; + } + } else { + if (beta <= 23.98626995) { + sum += 2.065500000000e-04; + } else { + sum += 2.007600000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 87.94999695) { + if (beta <= 23.88080025) { + if (beta <= 23.87473202) { + sum += -6.713600000000e-05; + } else { + if (beta <= 23.87640953) { + sum += -1.683400000000e-05; + } else { + sum += -2.648600000000e-06; + } + } + } else { + if (f107 <= 99.59999847) { + sum += 1.965100000000e-05; + } else { + if (f107 <= 100.79999924) { + sum += 1.230085714286e-04; + } else { + sum += 8.187150000000e-05; + } + } + } + } else { + if (beta <= 24.15342617) { + sum += -5.732400000000e-05; + } else { + if (f107 <= 99.25000000) { + sum += -7.454900000000e-05; + } else { + sum += -8.955200000000e-05; + } + } + } + } + } + } else { + if (f107 <= 104.59999847) { + if (f107 <= 96.59999847) { + if (beta <= 30.98696804) { + if (ap <= 6.50000000) { + if (f107_smooth <= 96.64999771) { + if (beta <= 25.95119095) { + sum += -6.955900000000e-05; + } else { + sum += -9.500500000000e-05; + } + } else { + if (beta <= 30.86555576) { + sum += -1.249891489362e-04; + } else { + sum += -3.882900000000e-05; + } + } + } else { + if (beta <= 30.70771980) { + if (beta <= 26.97475433) { + sum += -7.006070000000e-05; + } else { + sum += -1.128285384615e-04; + } + } else { + if (beta <= 30.84255028) { + sum += 4.840850000000e-05; + } else { + sum += -1.418500000000e-04; + } + } + } + } else { + if (ap <= 6.50000000) { + sum += 1.206200000000e-05; + } else { + sum += -2.688800000000e-05; + } + } + } else { + if (beta <= 29.68245029) { + if (ap <= 7.50000000) { + if (f107_smooth <= 121.60000229) { + if (f107_smooth <= 120.50000000) { + sum += -8.898446666667e-05; + } else { + sum += 8.336000000000e-05; + } + } else { + if (f107_smooth <= 126.70000076) { + sum += -1.395254545455e-04; + } else { + sum += -9.431587500000e-05; + } + } + } else { + if (beta <= 20.37722015) { + if (f107 <= 98.20000076) { + sum += 1.018400000000e-05; + } else { + sum += 9.653525000000e-05; + } + } else { + if (ap <= 11.50000000) { + sum += -5.109088125000e-05; + } else { + sum += -8.836177500000e-05; + } + } + } + } else { + if (ap <= 9.50000000) { + if (beta <= 30.51941967) { + if (f107 <= 99.15000153) { + sum += -6.210500000000e-05; + } else { + sum += -1.234380000000e-05; + } + } else { + if (f107_smooth <= 108.25000000) { + sum += 1.553000000000e-04; + } else { + sum += 8.316200000000e-05; + } + } + } else { + if (beta <= 30.95342827) { + if (f107 <= 98.90000153) { + sum += -9.044350000000e-05; + } else { + sum += -7.453550000000e-05; + } + } else { + if (ap <= 10.50000000) { + sum += -1.146700000000e-04; + } else { + sum += -1.172900000000e-04; + } + } + } + } + } + } else { + if (f107 <= 105.54999924) { + if (beta <= 30.27470875) { + if (beta <= 24.05026627) { + if (f107_smooth <= 130.54999542) { + sum += 2.356000000000e-04; + } else { + sum += 2.314500000000e-04; + } + } else { + if (f107_smooth <= 116.95000076) { + if (beta <= 30.01935291) { + sum += 9.706800000000e-05; + } else { + sum += 1.138100000000e-04; + } + } else { + sum += -1.296900000000e-04; + } + } + } else { + if (beta <= 30.92130184) { + if (beta <= 30.55158138) { + if (beta <= 30.52417946) { + sum += 1.978400000000e-04; + } else { + sum += 1.883200000000e-04; + } + } else { + sum += 1.727400000000e-04; + } + } else { + sum += 2.049000000000e-04; + } + } + } else { + if (beta <= 31.14414597) { + if (f107 <= 108.00000000) { + if (beta <= 25.13438797) { + if (ap <= 16.00000000) { + sum += -7.158912500000e-05; + } else { + sum += 5.708100000000e-05; + } + } else { + if (ap <= 5.50000000) { + sum += -6.969750000000e-05; + } else { + sum += -1.237450000000e-04; + } + } + } else { + if (f107 <= 110.25000000) { + if (beta <= 21.62449169) { + sum += -5.142866666667e-05; + } else { + sum += 1.312885882353e-04; + } + } else { + if (f107_smooth <= 130.19999695) { + sum += 3.630888888889e-07; + } else { + sum += -1.073114285714e-04; + } + } + } + } else { + if (f107_smooth <= 108.45000076) { + sum += 2.311700000000e-04; + } else { + if (beta <= 31.25451756) { + sum += 1.731000000000e-04; + } else { + sum += 1.847700000000e-04; + } + } + } + } + } + } + } else { + if (f107_smooth <= 194.79999542) { + if (ap <= 63.50000000) { + if (f107_smooth <= 128.25000000) { + if (beta <= 30.76705360) { + if (f107 <= 130.65000153) { + if (beta <= 24.47965336) { + if (beta <= 24.00551987) { + sum += 1.044035952381e-04; + } else { + sum += -4.693404761905e-05; + } + } else { + if (f107_smooth <= 97.40000153) { + sum += 4.595398333333e-05; + } else { + sum += 1.647858673469e-04; + } + } + } else { + if (f107 <= 245.69999695) { + if (f107_smooth <= 127.90000153) { + sum += 2.037350819672e-04; + } else { + sum += 9.785000000000e-05; + } + } else { + if (beta <= 24.47684002) { + sum += 6.174200000000e-05; + } else { + sum += 7.037500000000e-05; + } + } + } + } else { + if (f107_smooth <= 109.45000076) { + if (f107_smooth <= 108.00000000) { + if (beta <= 31.33176994) { + sum += 2.009785714286e-04; + } else { + sum += 1.325600000000e-04; + } + } else { + if (f107 <= 125.04999924) { + sum += 7.919700000000e-05; + } else { + sum += -3.542500000000e-05; + } + } + } else { + if (beta <= 31.17761803) { + if (f107 <= 127.45000458) { + sum += -1.312666666667e-04; + } else { + sum += -1.224800000000e-04; + } + } else { + if (f107_smooth <= 109.59999847) { + sum += -1.019400000000e-04; + } else { + sum += -1.115900000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 162.05000305) { + if (f107 <= 121.50000000) { + if (beta <= 24.37543583) { + if (beta <= 23.97665977) { + sum += 1.222583187500e-04; + } else { + sum += -4.461437692308e-05; + } + } else { + if (f107_smooth <= 153.40000153) { + sum += 1.919165243902e-04; + } else { + sum += -6.643000000000e-05; + } + } + } else { + if (beta <= 20.13107395) { + if (f107_smooth <= 133.29999542) { + sum += 5.480072727273e-05; + } else { + sum += -6.087957777778e-05; + } + } else { + if (beta <= 24.49542141) { + sum += 7.110947041291e-05; + } else { + sum += 3.678417406028e-05; + } + } + } + } else { + if (ap <= 25.00000000) { + if (f107_smooth <= 172.25000000) { + if (f107 <= 134.30000305) { + sum += -9.206899142857e-06; + } else { + sum += 1.422213086806e-04; + } + } else { + if (beta <= 20.07201862) { + sum += 2.467656000000e-04; + } else { + sum += 4.488634471299e-05; + } + } + } else { + if (f107 <= 184.19999695) { + if (f107 <= 166.94999695) { + sum += 2.468598823529e-04; + } else { + sum += 3.556445294118e-05; + } + } else { + if (beta <= 29.70754147) { + sum += 3.218248148148e-04; + } else { + sum += 4.342966666667e-05; + } + } + } + } + } + } else { + if (beta <= 20.11685467) { + if (f107_smooth <= 134.54999542) { + sum += -9.692000000000e-05; + } else { + sum += -1.091900000000e-04; + } + } else { + if (f107_smooth <= 156.40000153) { + if (ap <= 74.50000000) { + if (f107 <= 134.54999542) { + sum += 1.900200000000e-04; + } else { + if (f107_smooth <= 152.34999847) { + sum += 2.512520000000e-04; + } else { + sum += 3.138300000000e-04; + } + } + } else { + if (beta <= 24.13876152) { + sum += 1.152800000000e-04; + } else { + sum += -3.283600000000e-05; + } + } + } else { + if (beta <= 24.28665829) { + if (beta <= 21.04163074) { + if (beta <= 21.00016785) { + sum += 4.072466666667e-04; + } else { + sum += 4.032800000000e-04; + } + } else { + sum += 4.129300000000e-04; + } + } else { + if (ap <= 82.00000000) { + if (beta <= 27.52500534) { + sum += 3.197400000000e-04; + } else { + sum += 3.100400000000e-04; + } + } else { + if (beta <= 30.57476807) { + sum += 2.934200000000e-04; + } else { + sum += 2.967500000000e-04; + } + } + } + } + } + } + } else { + if (f107 <= 173.65000153) { + if (beta <= 24.54518509) { + if (beta <= 23.94445705) { + if (beta <= 21.47858906) { + if (f107_smooth <= 206.15000153) { + if (f107_smooth <= 201.60000610) { + sum += 2.279166666667e-04; + } else { + sum += 2.629700000000e-04; + } + } else { + if (f107 <= 168.65000153) { + sum += 2.194700000000e-04; + } else { + sum += 2.110700000000e-04; + } + } + } else { + if (f107_smooth <= 207.65000153) { + if (beta <= 23.93469620) { + sum += 1.838700000000e-04; + } else { + sum += 2.138300000000e-04; + } + } else { + if (beta <= 21.53677464) { + sum += 1.706900000000e-04; + } else { + sum += 1.533100000000e-04; + } + } + } + } else { + if (beta <= 24.14323807) { + if (beta <= 23.95610619) { + sum += 3.559200000000e-04; + } else { + if (beta <= 23.98509693) { + sum += 4.143650000000e-04; + } else { + sum += 4.021800000000e-04; + } + } + } else { + if (f107_smooth <= 199.80000305) { + if (f107 <= 143.09999847) { + sum += 2.080400000000e-04; + } else { + sum += 1.746700000000e-04; + } + } else { + if (ap <= 12.50000000) { + sum += 3.045825000000e-04; + } else { + sum += 2.517833333333e-04; + } + } + } + } + } else { + if (f107_smooth <= 199.59999847) { + if (beta <= 26.74975014) { + if (f107 <= 168.09999847) { + if (f107 <= 153.40000153) { + sum += 1.490900000000e-04; + } else { + sum += 2.283783333333e-04; + } + } else { + if (beta <= 26.30641365) { + sum += 2.973900000000e-04; + } else { + sum += 2.894000000000e-04; + } + } + } else { + if (beta <= 26.82339287) { + sum += 1.709900000000e-04; + } else { + if (f107_smooth <= 195.40000153) { + sum += 1.156000000000e-04; + } else { + sum += 1.413833333333e-04; + } + } + } + } else { + if (beta <= 24.66054344) { + if (ap <= 10.50000000) { + if (beta <= 24.60111237) { + sum += 1.243600000000e-04; + } else { + sum += 1.066900000000e-04; + } + } else { + sum += 2.159600000000e-04; + } + } else { + if (beta <= 24.76857185) { + if (beta <= 24.72367764) { + sum += 3.451800000000e-05; + } else { + sum += 2.295100000000e-05; + } + } else { + sum += 6.623400000000e-06; + } + } + } + } + } else { + if (ap <= 17.00000000) { + if (beta <= 22.67994404) { + if (f107 <= 199.75000000) { + if (ap <= 9.50000000) { + if (f107 <= 180.34999847) { + sum += 1.071245000000e-04; + } else { + sum += 7.320162500000e-05; + } + } else { + if (f107_smooth <= 199.15000153) { + sum += 1.483800000000e-04; + } else { + sum += 1.918750000000e-04; + } + } + } else { + if (f107 <= 208.04999542) { + if (f107 <= 203.30000305) { + sum += -7.040075000000e-06; + } else { + sum += 2.483885714286e-05; + } + } else { + if (beta <= 22.14325142) { + sum += -5.765400000000e-05; + } else { + sum += -2.440200000000e-05; + } + } + } + } else { + if (f107_smooth <= 199.29999542) { + if (ap <= 9.50000000) { + if (beta <= 27.42408848) { + sum += 2.917500000000e-04; + } else { + sum += 1.954700000000e-04; + } + } else { + sum += 4.669000000000e-04; + } + } else { + if (beta <= 24.59237480) { + if (beta <= 24.33888340) { + sum += 1.290934568966e-04; + } else { + sum += 2.444675862069e-04; + } + } else { + if (beta <= 25.56951141) { + sum += 4.017481666667e-05; + } else { + sum += 1.515910000000e-04; + } + } + } + } + } else { + if (beta <= 24.00769424) { + if (ap <= 25.00000000) { + if (ap <= 20.50000000) { + sum += 2.563700000000e-04; + } else { + if (beta <= 23.20159149) { + sum += 2.765300000000e-04; + } else { + sum += 2.827800000000e-04; + } + } + } else { + if (f107 <= 256.59999847) { + if (beta <= 20.86458969) { + sum += 1.181900000000e-04; + } else { + sum += 1.312057142857e-04; + } + } else { + if (beta <= 23.96580505) { + sum += 9.614750000000e-06; + } else { + sum += 4.803900000000e-05; + } + } + } + } else { + if (ap <= 89.00000000) { + if (f107_smooth <= 212.34999847) { + if (beta <= 24.13595867) { + sum += 2.749085714286e-04; + } else { + sum += 3.544914285714e-04; + } + } else { + if (beta <= 24.54863453) { + sum += 2.667775000000e-04; + } else { + sum += 1.699111111111e-04; + } + } + } else { + if (beta <= 24.07121468) { + if (beta <= 24.05796909) { + sum += 2.961300000000e-04; + } else { + sum += 2.698900000000e-04; + } + } else { + sum += 1.397800000000e-03; + } + } + } + } + } + } + } + } + // Tree 19 + { + if (f107 <= 108.65000153) { + if (f107_smooth <= 96.54999924) { + if (f107_smooth <= 74.25000000) { + if (ap <= 2.00000000) { + if (beta <= 29.37145329) { + sum += -8.193200000000e-05; + } else { + sum += -1.106800000000e-04; + } + } else { + if (beta <= 29.56958008) { + if (beta <= 29.52788830) { + sum += -1.278200000000e-04; + } else { + sum += -1.307700000000e-04; + } + } else { + if (beta <= 30.00616264) { + if (f107_smooth <= 74.14999771) { + if (beta <= 29.62170410) { + sum += -1.431200000000e-04; + } else { + sum += -1.472300000000e-04; + } + } else { + if (beta <= 29.95104694) { + sum += -1.589671428571e-04; + } else { + sum += -1.531100000000e-04; + } + } + } else { + if (beta <= 30.06186104) { + sum += -1.443900000000e-04; + } else { + sum += -1.363500000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 74.75000000) { + if (f107 <= 75.54999924) { + if (ap <= 3.50000000) { + if (ap <= 2.50000000) { + if (beta <= 26.78782654) { + sum += 9.197800000000e-05; + } else { + sum += 1.532500000000e-04; + } + } else { + if (beta <= 26.68285751) { + sum += -1.264500000000e-04; + } else { + sum += -1.098100000000e-04; + } + } + } else { + if (ap <= 6.50000000) { + if (f107 <= 71.20000076) { + sum += 8.168266666667e-05; + } else { + sum += 2.014695454545e-04; + } + } else { + if (f107_smooth <= 74.64999771) { + sum += 6.166428571429e-05; + } else { + sum += 1.896566666667e-04; + } + } + } + } else { + if (f107_smooth <= 74.54999924) { + if (f107 <= 75.75000000) { + if (ap <= 7.00000000) { + sum += -5.814700000000e-05; + } else { + sum += -3.466700000000e-05; + } + } else { + if (f107_smooth <= 74.45000076) { + sum += 2.214966666667e-05; + } else { + sum += -2.766500000000e-06; + } + } + } else { + if (beta <= 30.55960941) { + if (beta <= 30.50208950) { + sum += 5.097800000000e-05; + } else { + sum += 7.227200000000e-05; + } + } else { + sum += 1.048200000000e-04; + } + } + } + } else { + if (f107 <= 74.35000229) { + if (f107_smooth <= 74.85000229) { + if (f107 <= 71.50000000) { + if (f107 <= 70.94999695) { + sum += 3.013755000000e-05; + } else { + sum += -5.754337500000e-05; + } + } else { + if (beta <= 31.05550766) { + sum += 1.894850000000e-04; + } else { + sum += 1.112100000000e-04; + } + } + } else { + if (f107 <= 71.15000153) { + if (f107_smooth <= 77.35000229) { + sum += 1.061979230769e-04; + } else { + sum += -1.392840000000e-04; + } + } else { + if (f107_smooth <= 79.55000305) { + sum += -9.283945795455e-05; + } else { + sum += 1.096322608696e-05; + } + } + } + } else { + if (f107_smooth <= 94.45000076) { + if (beta <= 30.73546696) { + if (beta <= 20.02267075) { + sum += 1.534010526316e-04; + } else { + sum += 1.684496663978e-05; + } + } else { + if (f107_smooth <= 76.79999924) { + sum += 2.078500000000e-04; + } else { + sum += 8.248320000000e-05; + } + } + } else { + if (f107_smooth <= 96.09999847) { + if (f107 <= 91.20000076) { + sum += 1.553206250000e-04; + } else { + sum += 2.075920000000e-04; + } + } else { + if (f107 <= 87.34999847) { + sum += 7.349760000000e-05; + } else { + sum += -1.175000000000e-06; + } + } + } + } + } + } + } else { + if (f107 <= 104.70000076) { + if (beta <= 29.63171864) { + if (ap <= 6.50000000) { + if (f107_smooth <= 96.64999771) { + if (beta <= 25.95119095) { + if (beta <= 25.91241932) { + sum += -6.658700000000e-05; + } else { + sum += -7.550300000000e-05; + } + } else { + sum += -9.500500000000e-05; + } + } else { + if (f107 <= 99.29999924) { + if (beta <= 28.06469154) { + sum += -1.336820512821e-04; + } else { + sum += -1.186216666667e-04; + } + } else { + if (f107 <= 101.90000153) { + sum += -9.444129411765e-05; + } else { + sum += -1.378775000000e-04; + } + } + } + } else { + if (beta <= 20.38100624) { + if (ap <= 15.50000000) { + if (f107_smooth <= 127.25000000) { + sum += 4.674000000000e-06; + } else { + sum += -1.288400000000e-04; + } + } else { + sum += 1.329600000000e-04; + } + } else { + if (beta <= 23.04363537) { + if (beta <= 20.78776360) { + sum += -6.244981818182e-05; + } else { + sum += -1.255830000000e-04; + } + } else { + if (beta <= 23.80542946) { + sum += -2.425033333333e-06; + } else { + sum += -8.790662500000e-05; + } + } + } + } + } else { + if (f107_smooth <= 112.45000076) { + if (ap <= 9.50000000) { + if (ap <= 7.50000000) { + if (f107 <= 95.94999695) { + sum += -8.088285000000e-06; + } else { + sum += 3.327366363636e-05; + } + } else { + if (beta <= 30.70277309) { + sum += 1.082033333333e-04; + } else { + sum += 7.424400000000e-05; + } + } + } else { + if (beta <= 30.93204212) { + sum += -6.078200000000e-05; + } else { + if (beta <= 30.98063564) { + sum += -8.828900000000e-05; + } else { + sum += -1.146700000000e-04; + } + } + } + } else { + if (beta <= 30.56081104) { + if (beta <= 30.45158768) { + if (beta <= 30.36752033) { + sum += -1.862100000000e-05; + } else { + sum += -4.290000000000e-05; + } + } else { + sum += -8.439600000000e-05; + } + } else { + if (beta <= 30.94692230) { + if (beta <= 30.66780758) { + sum += -1.310850000000e-04; + } else { + sum += -1.478700000000e-04; + } + } else { + if (f107_smooth <= 113.84999847) { + sum += -8.779500000000e-05; + } else { + sum += -1.076100000000e-04; + } + } + } + } + } + } else { + if (f107_smooth <= 113.95000076) { + if (f107_smooth <= 107.14999771) { + sum += 9.706800000000e-05; + } else { + if (beta <= 31.26687527) { + if (beta <= 30.55158138) { + if (beta <= 30.52417946) { + sum += 1.978400000000e-04; + } else { + sum += 1.883200000000e-04; + } + } else { + if (beta <= 31.25451756) { + sum += 1.729200000000e-04; + } else { + sum += 1.847700000000e-04; + } + } + } else { + if (beta <= 31.27854729) { + sum += 2.049000000000e-04; + } else { + sum += 2.139800000000e-04; + } + } + } + } else { + if (f107 <= 105.54999924) { + if (f107_smooth <= 128.84999847) { + if (beta <= 24.22727489) { + sum += -1.406700000000e-04; + } else { + sum += -1.431500000000e-04; + } + } else { + if (f107_smooth <= 130.54999542) { + if (beta <= 23.89244080) { + sum += 2.356000000000e-04; + } else { + sum += 2.341300000000e-04; + } + } else { + sum += 2.236400000000e-04; + } + } + } else { + if (ap <= 14.00000000) { + if (f107_smooth <= 119.20000076) { + if (beta <= 28.67645645) { + sum += -3.384600000000e-05; + } else { + sum += -1.014800000000e-05; + } + } else { + if (f107_smooth <= 125.25000000) { + sum += -1.306842857143e-04; + } else { + sum += -9.276550000000e-05; + } + } + } else { + if (beta <= 25.06223869) { + if (f107 <= 107.59999847) { + sum += 4.760100000000e-05; + } else { + sum += -6.197333333333e-08; + } + } else { + if (f107 <= 107.50000000) { + sum += -6.479200000000e-05; + } else { + sum += -1.294500000000e-04; + } + } + } + } + } + } + } + } else { + if (f107_smooth <= 193.70000458) { + if (ap <= 71.00000000) { + if (f107_smooth <= 147.25000000) { + if (f107_smooth <= 130.15000153) { + if (ap <= 9.50000000) { + if (f107 <= 113.45000076) { + if (f107_smooth <= 120.70000076) { + sum += -1.547626562500e-05; + } else { + sum += 1.433963750000e-04; + } + } else { + if (f107_smooth <= 128.15000153) { + sum += 1.296006178344e-04; + } else { + sum += 2.587696311111e-05; + } + } + } else { + if (f107 <= 136.19999695) { + if (ap <= 10.50000000) { + sum += 1.106469230769e-05; + } else { + sum += 1.467647462264e-04; + } + } else { + if (f107 <= 143.85000610) { + sum += 2.309938888889e-04; + } else { + sum += 1.602322500000e-04; + } + } + } + } else { + if (f107 <= 158.40000153) { + if (f107_smooth <= 131.65000153) { + if (f107 <= 109.85000229) { + sum += 2.047166666667e-04; + } else { + sum += -5.766916875000e-05; + } + } else { + if (f107_smooth <= 133.05000305) { + sum += 1.105215666667e-04; + } else { + sum += 2.643440400000e-05; + } + } + } else { + if (ap <= 3.50000000) { + sum += 9.099800000000e-05; + } else { + if (f107 <= 200.39999390) { + sum += -7.287163678571e-05; + } else { + sum += -3.602720000000e-05; + } + } + } + } + } else { + if (f107_smooth <= 190.25000000) { + if (f107_smooth <= 186.25000000) { + if (f107 <= 189.65000153) { + if (f107_smooth <= 169.59999847) { + sum += 1.010278125114e-04; + } else { + sum += 2.685203221622e-05; + } + } else { + if (beta <= 24.27477169) { + sum += 2.242367983333e-04; + } else { + sum += 1.006059569892e-04; + } + } + } else { + if (f107 <= 171.34999847) { + if (beta <= 20.12341022) { + sum += 1.940700000000e-04; + } else { + sum += 1.772400000000e-04; + } + } else { + if (ap <= 4.50000000) { + sum += 2.145225000000e-04; + } else { + sum += 2.816682608696e-04; + } + } + } + } else { + if (f107 <= 174.34999847) { + if (f107_smooth <= 192.70000458) { + if (beta <= 30.69218826) { + sum += 8.980969375000e-05; + } else { + sum += 2.445540000000e-04; + } + } else { + if (ap <= 23.00000000) { + sum += 3.072000000000e-04; + } else { + sum += -1.607300000000e-06; + } + } + } else { + if (beta <= 30.82075024) { + if (f107 <= 229.45000458) { + sum += -7.718940000000e-05; + } else { + sum += -3.717490428571e-05; + } + } else { + if (f107 <= 209.94999695) { + sum += 9.406425000000e-05; + } else { + sum += 3.580250000000e-05; + } + } + } + } + } + } else { + if (f107_smooth <= 149.15000153) { + sum += -3.283600000000e-05; + } else { + if (f107_smooth <= 170.79999542) { + if (f107_smooth <= 162.04999542) { + if (ap <= 73.50000000) { + sum += 3.100400000000e-04; + } else { + if (beta <= 24.30088329) { + sum += 3.104100000000e-04; + } else { + sum += 3.138300000000e-04; + } + } + } else { + sum += 2.934200000000e-04; + } + } else { + if (beta <= 21.03825283) { + if (beta <= 21.00016785) { + if (beta <= 20.98794746) { + sum += 4.078500000000e-04; + } else { + sum += 4.060400000000e-04; + } + } else { + sum += 4.032800000000e-04; + } + } else { + if (beta <= 21.07114601) { + sum += 4.162900000000e-04; + } else { + sum += 4.129300000000e-04; + } + } + } + } + } + } else { + if (ap <= 15.50000000) { + if (f107 <= 182.34999847) { + if (beta <= 24.51781082) { + if (beta <= 23.94563580) { + if (beta <= 20.86476135) { + sum += 2.327400000000e-05; + } else { + if (beta <= 21.46907806) { + sum += 2.380842105263e-04; + } else { + sum += 1.620778260870e-04; + } + } + } else { + if (beta <= 24.12225342) { + if (beta <= 23.95482063) { + sum += 3.559200000000e-04; + } else { + sum += 4.020612500000e-04; + } + } else { + if (ap <= 9.50000000) { + sum += 3.195621428571e-04; + } else { + sum += 2.738935000000e-04; + } + } + } + } else { + if (f107_smooth <= 199.75000000) { + if (beta <= 26.74975014) { + if (f107 <= 177.59999847) { + sum += 2.253170000000e-04; + } else { + sum += 3.036166666667e-04; + } + } else { + if (f107_smooth <= 195.40000153) { + sum += 6.758266666667e-05; + } else { + sum += 1.586660000000e-04; + } + } + } else { + if (f107_smooth <= 200.25000000) { + if (ap <= 5.50000000) { + sum += 1.164840000000e-04; + } else { + sum += 7.540300000000e-05; + } + } else { + if (f107_smooth <= 200.54999542) { + sum += 1.143520909091e-05; + } else { + sum += 1.358900000000e-04; + } + } + } + } + } else { + if (f107_smooth <= 220.75000000) { + if (beta <= 28.68044281) { + if (beta <= 23.98106480) { + if (f107 <= 190.04999542) { + sum += 1.178566666667e-04; + } else { + sum += 2.175151463415e-05; + } + } else { + if (beta <= 24.27844238) { + sum += 1.405395384615e-04; + } else { + sum += 7.577504444444e-05; + } + } + } else { + if (beta <= 28.76688957) { + sum += 2.439800000000e-04; + } else { + if (beta <= 28.95384216) { + sum += 4.669000000000e-04; + } else { + sum += 3.399133333333e-04; + } + } + } + } else { + if (beta <= 24.55259895) { + if (f107 <= 247.20000458) { + if (beta <= 24.34261894) { + sum += 2.080653333333e-04; + } else { + sum += 2.945683333333e-04; + } + } else { + if (f107 <= 286.60000610) { + sum += 7.332600000000e-05; + } else { + sum += 4.275100000000e-05; + } + } + } else { + if (beta <= 24.58558273) { + if (beta <= 24.57238960) { + sum += 1.562500000000e-04; + } else { + sum += 1.397000000000e-04; + } + } else { + if (beta <= 24.59650803) { + sum += 8.169733333333e-05; + } else { + sum += 5.826128571429e-05; + } + } + } + } + } + } else { + if (ap <= 18.50000000) { + if (f107 <= 216.95000458) { + if (f107 <= 166.79999542) { + if (beta <= 24.49964714) { + sum += 3.382400000000e-04; + } else { + sum += 3.322000000000e-04; + } + } else { + if (f107_smooth <= 212.19999695) { + if (beta <= 25.16401196) { + sum += 2.728650000000e-04; + } else { + sum += 2.973900000000e-04; + } + } else { + if (f107_smooth <= 218.40000153) { + sum += 2.159600000000e-04; + } else { + sum += 2.121300000000e-04; + } + } + } + } else { + if (beta <= 24.09101105) { + sum += 1.384500000000e-03; + } else { + sum += 2.094900000000e-04; + } + } + } else { + if (beta <= 24.13595867) { + if (ap <= 121.50000000) { + if (ap <= 88.00000000) { + if (ap <= 26.50000000) { + sum += 2.584271428571e-04; + } else { + sum += 1.607850000000e-04; + } + } else { + if (beta <= 24.05796909) { + sum += 2.958425000000e-04; + } else { + sum += 2.698900000000e-04; + } + } + } else { + sum += 7.163500000000e-06; + } + } else { + if (beta <= 24.15530109) { + sum += 5.615000000000e-04; + } else { + if (f107_smooth <= 208.89999390) { + if (ap <= 23.00000000) { + sum += 2.995175000000e-04; + } else { + sum += 3.270990000000e-04; + } + } else { + if (ap <= 26.50000000) { + sum += 2.658440000000e-04; + } else { + sum += 1.694320000000e-04; + } + } + } + } + } + } + } + } + } + return sum / 20; +} diff --git a/run_5year_sim_vectorized.cc b/run_5year_sim_vectorized.cc new file mode 100644 index 0000000..79e00c9 --- /dev/null +++ b/run_5year_sim_vectorized.cc @@ -0,0 +1,117 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "libsgp4/Tle.h" +#include "libsgp4/SGP4.h" +#include "libsgp4/SGP4Batch.h" +#include "libsgp4/JitPropagator.h" +#include "libsgp4/LinearBVH.h" +#include "libsgp4/SpatialHash.h" +#include "libsgp4/Interpolation.h" +#include "libsgp4/SpatialPartition.h" +#include "libsgp4/TemporalPruner.h" +#include "libsgp4/Globals.h" +#include "libsgp4/Eci.h" +#include "libsgp4/DateTime.h" + +using namespace libsgp4; +using namespace std; + +const double SIGMA_KM = 1.5; +const double COARSE_THRESHOLD_KM = 200.0; +const double FINE_THRESHOLD_KM = 50.0; +const double MAX_REL_VEL_KMS = 16.0; + +Tle create_probe_tle(double alt, double inc, double raan) { + double MU = 398600.4418; double RE = 6378.137; + double a = RE + alt; double n_rad_sec = sqrt(MU / pow(a, 3)); + double n_rev_day = n_rad_sec * 86400.0 / (2.0 * kPI); + char l1[75], l2[75]; + sprintf(l1, "1 99999U 20001A 20001.00000000 .00000000 00000-0 00000-0 0 9990"); + sprintf(l2, "2 99999 %8.4f %8.4f 0000001 %8.4f %8.4f %11.8f 00", inc, raan, 0.0, 0.0, n_rev_day); + return Tle(string(l1).substr(0,69), string(l2).substr(0,69)); +} + +int main(int argc, char* argv[]) { + if (argc < 2) { cerr << "Usage: " << argv[0] << " [limit]" << endl; return 1; } + + double target_alt = 751.0; double target_inc = 37.0; double target_raan = 0.0; + DateTime sim_time(2024, 1, 1); DateTime end_time(2024, 1, 5); + + ifstream infile(argv[1]); + int limit = (argc > 2) ? stoi(argv[2]) : 5000; + + cout << "Starting Frontier-Optimized JIT Simulation..." << endl; + // ... (Satellite loading logic assumed ...) + + while (sim_time < end_time) { + // Load active satellites... + vector active_tles; // ... + if (active_tles.empty()) { sim_time = sim_time.AddDays(1); continue; } + + SGP4Batch batch(active_tles); + JitPropagator jit(batch); + SGP4 probe_prop(create_probe_tle(target_alt, target_inc, target_raan)); + int n = active_tles.size(); + + // Pre-allocate scratch buffers once per day to avoid repeated heap allocations + std::vector res_coarse; + res_coarse.reserve(n); + std::vector t_sigs(n); + std::vector candidates_hash; + candidates_hash.reserve(1024); + LinearBVH bvh; + std::vector bvh_objs; + bvh_objs.reserve(n); + std::vector final_candidates; + final_candidates.reserve(1024); + + for (int s = 0; s < 86400; s += 30) { + DateTime t = sim_time.AddSeconds(s); + Vector p_pos = probe_prop.FindPosition((t - sim_time).TotalMinutes()).Position(); + SpatialHash::Signature p_sig = SpatialHash::Generate(p_pos); + + // 1. Coarse Pass (Adaptive Precision: Minimax) + res_coarse.clear(); + batch.Propagate((t - sim_time).TotalMinutes(), res_coarse, SGP4Batch::MathMode::Minimax); + + // 2. Spatial Hash Filtering (AVX-512 VPOPCNTDQ / TEST-MASK) + candidates_hash.clear(); + for(int i=0; i res_fine; + jit.Propagate((t - sim_time).TotalMinutes(), batch, res_fine); + + for (int idx : final_candidates) { + // Precise hazard check using res_fine[idx]... + } + } + sim_time = sim_time.AddDays(1); + } + return 0; +} diff --git a/validation_bench.cc b/validation_bench.cc new file mode 100644 index 0000000..46eae68 --- /dev/null +++ b/validation_bench.cc @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +#include +#include + +using namespace libsgp4; + +int main() { + std::string l1 = "1 18960U 88022A 20001.30746459 .00000074 00000-0 16196-4 0 9998"; + std::string l2 = "2 18960 99.0194 66.6961 0011855 238.9327 121.1118 14.13525141129339"; + Tle tle("18960", l1, l2); + SGP4 model(tle); + + double nodeo = model.elements_.AscendingNode(); + double inclo = model.elements_.Inclination(); + double omgo = model.elements_.ArgumentPerigee(); + double mo = model.elements_.MeanAnomoly(); + double r = model.elements_.RecoveredSemiMajorAxis(); + + double snn = sin(nodeo), csn = cos(nodeo); + double sni = sin(inclo), csi = cos(inclo); + + double u = omgo + mo; + double snu = sin(u), csu = cos(u); + + // Orientation vectors from SGP4.cc (580+) + double xmx = -snn * csi; + double xmy = csn * csi; + double ux = xmx * snu + csn * csu; + double uy = xmy * snu + snn * csu; + double uz = sni * snu; + + std::cout << "Original UX: " << ux << " UY: " << uy << " UZ: " << uz << std::endl; + + // Position using full rotation Rz(node)*Rx(inc)*Rz(argp) = [r*cos(u), r*sin(u), 0] + // My previous "manual" rotation Rz(node)*Rx(inc)*Rz(u) from [1, 0, 0] matched this. + + // What if inclination is reversed? + double ux_r = csn * csu - snn * csi * snu; + double uy_r = snn * csu + csn * csi * snu; + double uz_r = sni * snu; + std::cout << "ux_r: " << ux_r << " uy_r: " << uy_r << " uz_r: " << uz_r << std::endl; + + // What if Z is swapped with Y? + // What if the matrix is Rz(node) * Ry(inc)? + // Or Rx(inc) * Rz(node)? + + Vector p0 = model.FindPosition(0).Position(); + double r0 = sqrt(p0.x*p0.x + p0.y*p0.y + p0.z*p0.z); + std::cout << "Scalar: " << p0.x / r0 << " " << p0.y / r0 << " " << p0.z / r0 << std::endl; + + return 0; +} diff --git a/verify_accuracy.cc b/verify_accuracy.cc new file mode 100644 index 0000000..ba74056 --- /dev/null +++ b/verify_accuracy.cc @@ -0,0 +1,103 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "Tle.h" +#include "SGP4.h" +#include "SGP4Batch.h" +#include "Globals.h" +#include "Eci.h" +#include "DateTime.h" + +using namespace libsgp4; +using namespace std; + +struct SatState { + string id; + string l1, l2; +}; + +int main(int argc, char* argv[]) { + vector test_sats = { + {"ISS (LEO)", + "1 25544U 98067A 24001.01267188 .00016541 00000-0 29758-3 0 5694", + "2 25544 51.6422 68.6294 0003347 343.4617 78.0593 15.49961425432470"}, + {"GPS (MEO)", + "1 43637U 18078A 24001.44203794 .00000031 00000-0 00000+0 0 9990", + "2 43637 55.3371 53.5134 0003463 269.9676 90.0076 2.00557457 37777"}, + {"GOES 16 (GEO)", + "1 41866U 16071A 24001.40149023 .00000084 00000-0 00000+0 0 9994", + "2 41866 0.0242 101.4390 0001043 273.7380 344.6041 1.00273295 25958"} + }; + + cout << left << setw(15) << "Object" << setw(15) << "Mode" << setw(15) << "Time (min)" + << setw(20) << "Standard Pos (km)" << setw(15) << "Error (m)" << endl; + cout << string(85, '-') << endl; + + for (const auto& s : test_sats) { + Tle tle(s.l1, s.l2); + SGP4 model(tle); + + vector tles = {tle}; + SGP4Batch batch(tles); + vector results_std, results_fast; + + double test_times[] = {0.0, 1000.0, 10000.0}; + for (double tsince : test_times) { + batch.Propagate(tsince, results_std, SGP4Batch::MathMode::Standard); + batch.Propagate(tsince, results_fast, SGP4Batch::MathMode::Minimax); + + // Standard Reference (Single Object) + Vector std_pos = model.FindPosition(tsince).Position(); + + // Batch Standard (SIMD Vector Math) + Vector batch_std = results_std[0].Position(); + + // Batch Fast (Custom Minimax) + Vector batch_fast = results_fast[0].Position(); + + double err_std = (std_pos - batch_std).Magnitude(); + double err_fast = (std_pos - batch_fast).Magnitude(); + + cout << left << setw(15) << s.id << setw(15) << "Standard" << setw(15) << tsince + << fixed << setprecision(2) << setw(20) << std_pos.Magnitude() + << scientific << setprecision(4) << err_std * 1000.0 << endl; + cout << left << setw(15) << "" << setw(15) << "Minimax" << setw(15) << tsince + << fixed << setprecision(2) << setw(20) << batch_fast.Magnitude() + << scientific << setprecision(4) << err_fast * 1000.0 << endl; + } + cout << endl; + } + + // Performance Test + vector many_tles; + for(int i=0; i<10000; i++) many_tles.push_back(Tle(test_sats[0].l1, test_sats[0].l2)); + SGP4Batch perf_batch(many_tles); + vector res; + + // Warmup + for(int t=0; t<10; t++) perf_batch.Propagate(t, res, SGP4Batch::MathMode::Standard); + + auto start = chrono::high_resolution_clock::now(); + for(int t=0; t<100; t++) perf_batch.Propagate(t, res, SGP4Batch::MathMode::Standard); + auto end = chrono::high_resolution_clock::now(); + double time_std = chrono::duration(end-start).count(); + + start = chrono::high_resolution_clock::now(); + for(int t=0; t<100; t++) perf_batch.Propagate(t, res, SGP4Batch::MathMode::Minimax); + end = chrono::high_resolution_clock::now(); + double time_fast = chrono::duration(end-start).count(); + + cout << "Throughput Comparison (10k objects, 100 iterations):" << endl; + cout << "Standard (libmvec): " << (1000000.0 / time_std / 1e6) << " million sats/sec" << endl; + cout << "Minimax (Custom): " << (1000000.0 / time_fast / 1e6) << " million sats/sec" << endl; + + return 0; +}