From 1b6e6a6bac33cd1218cae352f992c0ec77939c0f Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 23 Jul 2019 15:44:39 +0800 Subject: [PATCH 01/87] Example for Jack. Creating sink branch. --- src/standalone/simulation.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 2fac549..fb487be 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -242,6 +242,7 @@ run_simulation(void) // 2. Mass of the particle // (3. Velocity of the particle) // These can be used for calculating he gravitational field. + // acIntegrate(dt); //TODO_SINK acAdvect_sink_particle() From cd7f6f7939fd79b8105ba09aad45f50292fb140b Mon Sep 17 00:00:00 2001 From: Tzu-Chun Hsu Date: Wed, 24 Jul 2019 10:20:13 +0800 Subject: [PATCH 02/87] "Hello world!", my first commit. --- src/standalone/simulation.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index fb487be..8bf51cb 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -242,7 +242,7 @@ run_simulation(void) // 2. Mass of the particle // (3. Velocity of the particle) // These can be used for calculating he gravitational field. - // + // This is my first comment! by Jack acIntegrate(dt); //TODO_SINK acAdvect_sink_particle() From 58a3f483899f76391c472d26c3501745d5bd740b Mon Sep 17 00:00:00 2001 From: JackHsu Date: Wed, 24 Jul 2019 11:01:26 +0800 Subject: [PATCH 03/87] Second ever commits! --- src/standalone/simulation.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 8bf51cb..af68b2d 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -243,6 +243,7 @@ run_simulation(void) // (3. Velocity of the particle) // These can be used for calculating he gravitational field. // This is my first comment! by Jack + // This is my second comment! by Jack acIntegrate(dt); //TODO_SINK acAdvect_sink_particle() From 9d625688acde48f34fd5024dd9942af20def6574 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Fri, 26 Jul 2019 16:22:04 +0800 Subject: [PATCH 04/87] Apparently my edit this time was unsuccessful, tons of error messeages showed up when I ran "make -j" command in working directory. However this commit is mainly for education purposes, it's so that Miikka (main) and others can see what I changed easily and can use as teaching reference. --- acc/mhd_solver/stencil_defines.h | 6 ++++++ src/standalone/simulation.cc | 8 ++++++++ 2 files changed, 14 insertions(+) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index 0ab07c2..d684c4e 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -72,6 +72,12 @@ FUNC(AC_star_pos_y),\ FUNC(AC_star_pos_z),\ FUNC(AC_M_star),\ + /* properties of sink particle*/\ + FUNC(AC_sink_pos_x),\ + FUNC(AC_sink_pos_y),\ + FUNC(AC_sink_pos_z),\ + FUNC(AC_M_sink),\ + //The above is function for sink particle, not sure if it's supposed to be here but just a try /* Run params */\ FUNC(AC_cdt), \ FUNC(AC_cdtv), \ diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index c6842dc..bbafa71 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -88,6 +88,14 @@ write_mesh_info(const AcMeshInfo* config) fprintf(infotxt, "real AC_cs2_sound %e \n", (double)config->real_params[AC_cs2_sound]); fprintf(infotxt, "real AC_cv_sound %e \n", (double)config->real_params[AC_cv_sound]); + //Here I'm still trying to copy the structure of the code above, and see if this will work for sink particle. + //I haven't fully undertand what these lines do but I'll read up on them soon. This is still yet experimental. + // Sink particle + fprintf(infotext, "real AC_sink_pos_x %i \n", config->real_params[AC_sink_pos_x]); + fprintf(infotext, "real AC_sink_pos_y %i \n", config->real_params[AC_sink_pos_y]); + fprintf(infotext, "real AC_sink_pos_z %i \n", config->real_params[AC_sink_pos_z]); + fprintf(infotext, "real AC_M_sink %e \n", (double)config->real_params[AC_M_sink]); + fclose(infotxt); } From 89e6f8673f30fa50c13c1b8246958ddb273065aa Mon Sep 17 00:00:00 2001 From: JackHsu Date: Fri, 26 Jul 2019 16:53:39 +0800 Subject: [PATCH 05/87] Made corrections to some formatting issues. --- acc/mhd_solver/stencil_defines.h | 3 +- src/standalone/simulation.cc | 50 ++++++++++++++++---------------- 2 files changed, 26 insertions(+), 27 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index d684c4e..37cc9e5 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -73,11 +73,10 @@ FUNC(AC_star_pos_z),\ FUNC(AC_M_star),\ /* properties of sink particle*/\ - FUNC(AC_sink_pos_x),\ + FUNC(AC_sink_pos_x),\ FUNC(AC_sink_pos_y),\ FUNC(AC_sink_pos_z),\ FUNC(AC_M_sink),\ - //The above is function for sink particle, not sure if it's supposed to be here but just a try /* Run params */\ FUNC(AC_cdt), \ FUNC(AC_cdtv), \ diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index bbafa71..6a6bef9 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -57,44 +57,44 @@ write_mesh_info(const AcMeshInfo* config) infotxt = fopen("mesh_info.list", "w"); // Total grid dimensions - fprintf(infotxt, "int AC_mx %i \n", config->int_params[AC_mx]); - fprintf(infotxt, "int AC_my %i \n", config->int_params[AC_my]); - fprintf(infotxt, "int AC_mz %i \n", config->int_params[AC_mz]); + fprintf(infotxt, "int AC_mx %i \n", config->int_params[AC_mx]); + fprintf(infotxt, "int AC_my %i \n", config->int_params[AC_my]); + fprintf(infotxt, "int AC_mz %i \n", config->int_params[AC_mz]); // Bounds for the computational domain, i.e. nx_min <= i < nx_max - fprintf(infotxt, "int AC_nx_min %i \n", config->int_params[AC_nx_min]); - fprintf(infotxt, "int AC_nx_max %i \n", config->int_params[AC_nx_max]); - fprintf(infotxt, "int AC_ny_min %i \n", config->int_params[AC_ny_min]); - fprintf(infotxt, "int AC_ny_max %i \n", config->int_params[AC_ny_max]); - fprintf(infotxt, "int AC_nz_min %i \n", config->int_params[AC_nz_min]); - fprintf(infotxt, "int AC_nz_max %i \n", config->int_params[AC_nz_max]); + fprintf(infotxt, "int AC_nx_min %i \n", config->int_params[AC_nx_min]); + fprintf(infotxt, "int AC_nx_max %i \n", config->int_params[AC_nx_max]); + fprintf(infotxt, "int AC_ny_min %i \n", config->int_params[AC_ny_min]); + fprintf(infotxt, "int AC_ny_max %i \n", config->int_params[AC_ny_max]); + fprintf(infotxt, "int AC_nz_min %i \n", config->int_params[AC_nz_min]); + fprintf(infotxt, "int AC_nz_max %i \n", config->int_params[AC_nz_max]); // Spacing - fprintf(infotxt, "real AC_dsx %e \n", (double)config->real_params[AC_dsx]); - fprintf(infotxt, "real AC_dsy %e \n", (double)config->real_params[AC_dsy]); - fprintf(infotxt, "real AC_dsz %e \n", (double)config->real_params[AC_dsz]); - fprintf(infotxt, "real AC_inv_dsx %e \n", (double)config->real_params[AC_inv_dsx]); - fprintf(infotxt, "real AC_inv_dsy %e \n", (double)config->real_params[AC_inv_dsy]); - fprintf(infotxt, "real AC_inv_dsz %e \n", (double)config->real_params[AC_inv_dsz]); - fprintf(infotxt, "real AC_dsmin %e \n", (double)config->real_params[AC_dsmin]); + fprintf(infotxt, "real AC_dsx %e \n", (double)config->real_params[AC_dsx]); + fprintf(infotxt, "real AC_dsy %e \n", (double)config->real_params[AC_dsy]); + fprintf(infotxt, "real AC_dsz %e \n", (double)config->real_params[AC_dsz]); + fprintf(infotxt, "real AC_inv_dsx %e \n", (double)config->real_params[AC_inv_dsx]); + fprintf(infotxt, "real AC_inv_dsy %e \n", (double)config->real_params[AC_inv_dsy]); + fprintf(infotxt, "real AC_inv_dsz %e \n", (double)config->real_params[AC_inv_dsz]); + fprintf(infotxt, "real AC_dsmin %e \n", (double)config->real_params[AC_dsmin]); /* Additional helper params */ // Int helpers - fprintf(infotxt, "int AC_mxy %i \n", config->int_params[AC_mxy]); - fprintf(infotxt, "int AC_nxy %i \n", config->int_params[AC_nxy]); - fprintf(infotxt, "int AC_nxyz %i \n", config->int_params[AC_nxyz]); + fprintf(infotxt, "int AC_mxy %i \n", config->int_params[AC_mxy]); + fprintf(infotxt, "int AC_nxy %i \n", config->int_params[AC_nxy]); + fprintf(infotxt, "int AC_nxyz %i \n", config->int_params[AC_nxyz]); // Real helpers - fprintf(infotxt, "real AC_cs2_sound %e \n", (double)config->real_params[AC_cs2_sound]); - fprintf(infotxt, "real AC_cv_sound %e \n", (double)config->real_params[AC_cv_sound]); + fprintf(infotxt, "real AC_cs2_sound %e \n", (double)config->real_params[AC_cs2_sound]); + fprintf(infotxt, "real AC_cv_sound %e \n", (double)config->real_params[AC_cv_sound]); //Here I'm still trying to copy the structure of the code above, and see if this will work for sink particle. //I haven't fully undertand what these lines do but I'll read up on them soon. This is still yet experimental. // Sink particle - fprintf(infotext, "real AC_sink_pos_x %i \n", config->real_params[AC_sink_pos_x]); - fprintf(infotext, "real AC_sink_pos_y %i \n", config->real_params[AC_sink_pos_y]); - fprintf(infotext, "real AC_sink_pos_z %i \n", config->real_params[AC_sink_pos_z]); - fprintf(infotext, "real AC_M_sink %e \n", (double)config->real_params[AC_M_sink]); + fprintf(infotxt, "real AC_sink_pos_x %e \n", (double)config->real_params[AC_sink_pos_x]); + fprintf(infotxt, "real AC_sink_pos_y %e \n", (double)config->real_params[AC_sink_pos_y]); + fprintf(infotxt, "real AC_sink_pos_z %e \n", (double)config->real_params[AC_sink_pos_z]); + fprintf(infotxt, "real AC_M_sink %e \n", (double)config->real_params[AC_M_sink]); fclose(infotxt); } From d1ca196ccd528bf578b98ce7d0df830b2297965e Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 29 Jul 2019 13:18:24 +0800 Subject: [PATCH 06/87] Added declaration of constants for sink particle. Still in the process of understanding how values are passed, but I've realized how physical equations are defined in stencil_process.sps and in principle I can replicate that for sink particle(which will mostly be gravity). --- acc/mhd_solver/stencil_process.sps | 15 +++++++++++++-- src/standalone/simulation.cc | 2 +- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index eb0fc0c..77e55a4 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -21,8 +21,11 @@ uniform int nz_min; uniform int nx; uniform int ny; uniform int nz; - - +uniform Scalar AC_sink_pos_x; +uniform Scalar AC_sink_pos_y; +uniform Scalar AC_sink_pos_z; +uniform Scalar AC_M_sink; +//Added declaration for constants used for sink particle. Vector value(in Vector uu) @@ -57,6 +60,14 @@ continuity(in Vector uu, in Scalar lnrho) { - divergence(uu); } +//#if SINK +//Here I'm more or less copying the format of the LENTROPY module below +//Vector +//gravity(in Vector xx, in Vector yy, in Vector zz) { + //Here I need to define how gravity works for sink particle, probably based on the distance to the sink particle and its mass. + //Then apply Newton's equation for force, and also remember to consider xyz directions. +//} + #if LENTROPY Vector momentum(in Vector uu, in Scalar lnrho, in Scalar ss, in Vector aa) { diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 6a6bef9..1b553d5 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -94,7 +94,7 @@ write_mesh_info(const AcMeshInfo* config) fprintf(infotxt, "real AC_sink_pos_x %e \n", (double)config->real_params[AC_sink_pos_x]); fprintf(infotxt, "real AC_sink_pos_y %e \n", (double)config->real_params[AC_sink_pos_y]); fprintf(infotxt, "real AC_sink_pos_z %e \n", (double)config->real_params[AC_sink_pos_z]); - fprintf(infotxt, "real AC_M_sink %e \n", (double)config->real_params[AC_M_sink]); + fprintf(infotxt, "real AC_M_sink %e \n", (double)config->real_params[AC_M_sink]); fclose(infotxt); } From 820132cfe9229de026b2f0c8e7187e82b604b9ec Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 29 Jul 2019 17:53:04 +0800 Subject: [PATCH 07/87] I attemped to write a complete LSINK module. Haven't tested how it works but just serve as a save point. --- acc/mhd_solver/stencil_defines.h | 1 + acc/mhd_solver/stencil_process.sps | 25 +++++++++++++++++-------- 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index 37cc9e5..c807401 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -32,6 +32,7 @@ #define LTEMPERATURE (0) #define LFORCING (0) #define LUPWD (0) +#define LSINK (1) #define AC_THERMAL_CONDUCTIVITY (AcReal(0.001)) // TODO: make an actual config parameter diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 77e55a4..9cf7aa6 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -4,7 +4,7 @@ uniform Scalar nu_visc; uniform Scalar cp_sound; uniform Scalar cv_sound; uniform Scalar mu0; -uniform Scalar eta; +unicalar eta; uniform Scalar gamma; uniform Scalar zeta; @@ -60,13 +60,22 @@ continuity(in Vector uu, in Scalar lnrho) { - divergence(uu); } -//#if SINK -//Here I'm more or less copying the format of the LENTROPY module below -//Vector -//gravity(in Vector xx, in Vector yy, in Vector zz) { - //Here I need to define how gravity works for sink particle, probably based on the distance to the sink particle and its mass. - //Then apply Newton's equation for force, and also remember to consider xyz directions. -//} +#if LSINK + +Vector +gravity() { + vector force_gravity; + const int3 grid_pos = (int3){threadIdx.x + blockIdx.x * blockDim.x + start.x, + threadIdx.y + blockIdx.y * blockDim.y + start.y, + threadIdx.z + blockIdx.z * blockDim.z + start.z}; + const sink_mass = DCONST(AC_M_sink); + const sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), + DCONST_REAL(AC_sink_pos_y), + DCONST_REAL(AC_sink_pos_z)}; + const distance = dlength_vec(grid_pos - sink_pos); + force_gravity = (6.67e-8 * sink_mass) / (distance * distance); + return force_gravity; +}//first attempt to do a self-containing LSINK module #if LENTROPY Vector From e7a2734ab6d3e3b0f2e15ff83f1d11d1c0ec3080 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 29 Jul 2019 18:06:57 +0800 Subject: [PATCH 08/87] reparied a delection I did by mistake. --- acc/mhd_solver/stencil_process.sps | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 9cf7aa6..574734f 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -4,7 +4,7 @@ uniform Scalar nu_visc; uniform Scalar cp_sound; uniform Scalar cv_sound; uniform Scalar mu0; -unicalar eta; +uniform Scalar eta; uniform Scalar gamma; uniform Scalar zeta; From 0acf52d1b49a8c44e4991953cf915721629fd061 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 30 Jul 2019 11:47:18 +0800 Subject: [PATCH 09/87] Fixed some syntax errors and changed LGRAVITY to LSINK. Will test if this works later. --- acc/mhd_solver/stencil_process.sps | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 574734f..2cd6633 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -65,14 +65,14 @@ continuity(in Vector uu, in Scalar lnrho) { Vector gravity() { vector force_gravity; - const int3 grid_pos = (int3){threadIdx.x + blockIdx.x * blockDim.x + start.x, - threadIdx.y + blockIdx.y * blockDim.y + start.y, - threadIdx.z + blockIdx.z * blockDim.z + start.z}; - const sink_mass = DCONST(AC_M_sink); - const sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), + const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, + (globalVertexIdx.y - ny_min) * dsy, + (globalVertexIdx.z - nz_min) * dsz}; + const Scalar sink_mass = DCONST(AC_M_sink); + const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), DCONST_REAL(AC_sink_pos_y), DCONST_REAL(AC_sink_pos_z)}; - const distance = dlength_vec(grid_pos - sink_pos); + const Scalar distance = length_vec(grid_pos - sink_pos); force_gravity = (6.67e-8 * sink_mass) / (distance * distance); return force_gravity; }//first attempt to do a self-containing LSINK module @@ -115,8 +115,8 @@ momentum(in Vector uu, in Scalar lnrho, in Scalar tt) { (laplace_vec(uu) + Scalar(1. / 3.) * gradient_of_divergence(uu) + Scalar(2.) * mul(S, gradient(lnrho))) + zeta * gradient_of_divergence(uu); - #if LGRAVITY - mom = mom - (Vector){0, 0, -10.0}; + #if LSINK + mom = mom - (Vector){force_gravity}; #endif return mom; @@ -136,8 +136,8 @@ momentum(in Vector uu, in Scalar lnrho) { (laplace_vec(uu) + Scalar(1. / 3.) * gradient_of_divergence(uu) + Scalar(2.) * mul(S, gradient(lnrho))) + zeta * gradient_of_divergence(uu); - #if LGRAVITY - mom = mom - (Vector){0, 0, -10.0}; + #if LSINK + mom = mom - (Vector){force_gravity}; #endif return mom; @@ -181,8 +181,6 @@ heat_conduction( in Scalar ss, in Scalar lnrho) { (gamma - AcReal(1.)) * laplace(lnrho); const Vector second_term = gamma * inv_cp_sound * gradient(ss) + (gamma - AcReal(1.)) * gradient(lnrho); - const Vector third_term = gamma * (inv_cp_sound * gradient(ss) + - gradient(lnrho)) + grad_ln_chi; const Scalar chi = AC_THERMAL_CONDUCTIVITY / (exp(value(lnrho)) * cp_sound); return cp_sound * chi * (first_term + dot(second_term, third_term)); From a6dcee2381679def5471838191df2a70d4b431ce Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 30 Jul 2019 11:50:20 +0800 Subject: [PATCH 10/87] Forgot to use lengh() instead of dlength_vec(). --- acc/mhd_solver/stencil_process.sps | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 2cd6633..4b8bae9 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -72,7 +72,7 @@ gravity() { const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), DCONST_REAL(AC_sink_pos_y), DCONST_REAL(AC_sink_pos_z)}; - const Scalar distance = length_vec(grid_pos - sink_pos); + const Scalar distance = length(grid_pos - sink_pos); force_gravity = (6.67e-8 * sink_mass) / (distance * distance); return force_gravity; }//first attempt to do a self-containing LSINK module From 34573d7d63593932cd7933755f9ee94790c470f4 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 30 Jul 2019 13:32:44 +0800 Subject: [PATCH 11/87] Corrected acciden removal. --- acc/mhd_solver/stencil_process.sps | 3 +++ 1 file changed, 3 insertions(+) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 4b8bae9..a9e9747 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -181,6 +181,9 @@ heat_conduction( in Scalar ss, in Scalar lnrho) { (gamma - AcReal(1.)) * laplace(lnrho); const Vector second_term = gamma * inv_cp_sound * gradient(ss) + (gamma - AcReal(1.)) * gradient(lnrho); + const Vector third_term = gamma * (inv_cp_sound * gradient(ss) + + gradient(lnrho)) + grad_ln_chi; + const Scalar chi = AC_THERMAL_CONDUCTIVITY / (exp(value(lnrho)) * cp_sound); return cp_sound * chi * (first_term + dot(second_term, third_term)); From a410143c10038ff5d6e41f676534cdfcb08dee16 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Wed, 31 Jul 2019 10:11:57 +0800 Subject: [PATCH 12/87] Wrote down JPs suggestion for later use. --- doc/manual/sink_particle.md | 85 +++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) diff --git a/doc/manual/sink_particle.md b/doc/manual/sink_particle.md index eb86610..0b6b9e1 100644 --- a/doc/manual/sink_particle.md +++ b/doc/manual/sink_particle.md @@ -81,3 +81,88 @@ Make is possible for the particle to accrete momentum in addition to mass, and t Create sink particles dynamically and allow the presence of multiple sinks. +Suggestion writen by JP: + +``` +add to acc/mhd_solver/stencil_defines.h: + // Scalar mass + #define AC_FOR_USER_REAL_PARAM_TYPES(FUNC) \ + ... + ... + FUNC(AC_sink_particle_mass), + + // Vector position + // NOTE: This makes an AcReal3 constant parameter + // This is a completely new type that has not yet been + // tested. Accessible from the DSL with + // DCONST_REAL3(AC_sink_particle_pos) + #define AC_FOR_USER_REAL3_PARAM_TYPES(FUNC) \ + ... + ... + FUNC(AC_sink_particle_pos), + + // Vertex buffer for accretion + #define AC_FOR_VTXBUF_HANDLES(FUNC) \ + ... + FUNC(VTXBUF_ACCRETION), + + +acc/mhd_solver/stencil_process.sps: + + Scalar + your_accretion_function(int3 globalVertexIdx) + { + Scalar mass = DCONST_REAL(AC_sink_particle_mass); + Vector pos0 = DCONST_REAL3(AC_sink_particle_pos); + Vector pos1 = (Vector){ (globalVertexIdx.x - nx_min) * dsx), ...}; + + return *accretion from the current cell at globalVertexIdx* + } + + // This should have a global scope + out Scalar out_accretion = VTXBUF_ACCRETION; + + Kernel void + solve(Scalar dt) { + + ... + ... + + out_accretion = your_accretion_function(globalVertexIdx); + } + + +src/standalone/model/host_accretion.cc: <- new file + #include "astaroth.h" + + void + updateAccretion(AcMeshInfo* info) + { + AcReal previous_mass = info->real_params[AC_sink_particle_mass]; + AcReal accreted_mass = acReduceScal(RTYPE_SUM, VTXBUF_ACCRETION); + // Note: RTYPE_SUM does not yet exist (but is easy to add) + + AcReal mass = previous_mass + accreted_mass; + info->real_params[AC_sink_particle_mass] = mass; // Save for the next iteration + acLoadDeviceConstant(AC_sink_particle_mass, mass); // Load to the GPUs + } + + +src/standalone/simulation.cc: + + #include "model/host_accretion.h" + + int + run_simulation(void) + { + ... + + while (simulation_running) { + ... + ... + + updateAccretion(&mesh_info); + } + } +``` + From 5390d68d7c5226112f94b603b845b5e1159e7316 Mon Sep 17 00:00:00 2001 From: jpekkila Date: Mon, 29 Jul 2019 15:21:15 +0300 Subject: [PATCH 13/87] ac_mkbuilddir.sh did not stop if the directory specified by the user did not exist. This lead to messing up the base astaroth directory with temporary cmake files. Added -p flag to mkdir to create parent directories if necessary to avoid this --- scripts/ac_mkbuilddir.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/ac_mkbuilddir.sh b/scripts/ac_mkbuilddir.sh index eac417e..2874168 100755 --- a/scripts/ac_mkbuilddir.sh +++ b/scripts/ac_mkbuilddir.sh @@ -61,7 +61,7 @@ done echo "Creating build directory: ${BUILD_DIR}" -mkdir ${BUILD_DIR} +mkdir -p ${BUILD_DIR} cd ${BUILD_DIR} From 4e44f3a872c3ed17735c6414dd77fb948784f9b1 Mon Sep 17 00:00:00 2001 From: jpekkila Date: Mon, 29 Jul 2019 15:35:17 +0300 Subject: [PATCH 14/87] The previous commit to ac_mkbuilddir.sh was not enough. Added a line that makes the script to stop if any of the commands fail to avoid cluttering the base astaroth directory. In my case the issue was permission denied when trying to create a project directory in /MYSCRATCH (system root directory) instead of MYSCRATCH (astaroth/MYSCRATCH) --- scripts/ac_mkbuilddir.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scripts/ac_mkbuilddir.sh b/scripts/ac_mkbuilddir.sh index 2874168..da5bc1a 100755 --- a/scripts/ac_mkbuilddir.sh +++ b/scripts/ac_mkbuilddir.sh @@ -5,6 +5,8 @@ then exit 1 fi +# Exit if any of the following commands fail +set -e TIARA_SETUP_DEFAULT="" DOUBLE_DEFAULT="OFF" From f7bd84af468d516af7960dcb1383a2bb92f8870f Mon Sep 17 00:00:00 2001 From: jpekkila Date: Tue, 30 Jul 2019 09:10:06 +0000 Subject: [PATCH 15/87] Added macros for getting int3 and AcReal3 device constants from within kernels (and DSL). --- src/core/device.cu | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/core/device.cu b/src/core/device.cu index 7b624e3..005d02f 100644 --- a/src/core/device.cu +++ b/src/core/device.cu @@ -43,7 +43,9 @@ __constant__ AcMeshInfo d_mesh_info; __constant__ int3 d_multigpu_offset; __constant__ Grid globalGrid; #define DCONST_INT(X) (d_mesh_info.int_params[X]) +#define DCONST_INT3(X) (d_mesh_info.int3_params[X]) #define DCONST_REAL(X) (d_mesh_info.real_params[X]) +#define DCONST_REAL3(X) (d_mesh_info.real3_params[X]) #define DEVICE_VTXBUF_IDX(i, j, k) ((i) + (j)*DCONST_INT(AC_mx) + (k)*DCONST_INT(AC_mxy)) #define DEVICE_1D_COMPDOMAIN_IDX(i, j, k) ((i) + (j)*DCONST_INT(AC_nx) + (k)*DCONST_INT(AC_nxy)) #include "kernels/kernels.cuh" From 15ad7182dba2ecc5662b89bf6f8b495f7c5f7f54 Mon Sep 17 00:00:00 2001 From: jpekkila Date: Tue, 30 Jul 2019 14:28:18 +0300 Subject: [PATCH 16/87] Added sum reduction. NOTE: Scalar sum does not pass the automated test but vector sum does. I couldn't see anything wrong with the code itself and I strongly suspect that the failures are caused by loss of precision due to summing a huge amount of numbers of different magnitudes. However I'm not yet completely sure. Something like the Kahan summation algorithm might be useful if the errors are really caused by fp arithmetic. --- include/astaroth_defines.h | 9 +++- src/core/astaroth.cu | 3 +- src/core/kernels/kernels.cuh | 8 ++++ src/standalone/model/model_reduce.cc | 66 ++++++++++++++-------------- 4 files changed, 50 insertions(+), 36 deletions(-) diff --git a/include/astaroth_defines.h b/include/astaroth_defines.h index ac9804b..240ed86 100644 --- a/include/astaroth_defines.h +++ b/include/astaroth_defines.h @@ -77,7 +77,14 @@ typedef struct { typedef enum { AC_SUCCESS = 0, AC_FAILURE = 1 } AcResult; -typedef enum { RTYPE_MAX, RTYPE_MIN, RTYPE_RMS, RTYPE_RMS_EXP, NUM_REDUCTION_TYPES } ReductionType; +typedef enum { + RTYPE_MAX, + RTYPE_MIN, + RTYPE_RMS, + RTYPE_RMS_EXP, + RTYPE_SUM, + NUM_REDUCTION_TYPES +} ReductionType; typedef enum { STREAM_DEFAULT, diff --git a/src/core/astaroth.cu b/src/core/astaroth.cu index fadf4c0..9abc010 100644 --- a/src/core/astaroth.cu +++ b/src/core/astaroth.cu @@ -474,7 +474,7 @@ simple_final_reduce_scal(const ReductionType& rtype, const AcReal* results, cons else if (rtype == RTYPE_MIN) { res = min(res, results[i]); } - else if (rtype == RTYPE_RMS || rtype == RTYPE_RMS_EXP) { + else if (rtype == RTYPE_RMS || rtype == RTYPE_RMS_EXP || rtype == RTYPE_SUM) { res = sum(res, results[i]); } else { @@ -486,7 +486,6 @@ simple_final_reduce_scal(const ReductionType& rtype, const AcReal* results, cons const AcReal inv_n = AcReal(1.) / (grid.n.x * grid.n.y * grid.n.z); res = sqrt(inv_n * res); } - return res; } diff --git a/src/core/kernels/kernels.cuh b/src/core/kernels/kernels.cuh index 8977d07..52b48f6 100644 --- a/src/core/kernels/kernels.cuh +++ b/src/core/kernels/kernels.cuh @@ -893,6 +893,10 @@ reduce_scal(const cudaStream_t stream, const ReductionType rtype, const int3& st kernel_filter<<>>(vtxbuf, start, end, scratchpad); kernel_reduce<<>>(scratchpad, num_elems); kernel_reduce_block<<<1, 1, 0, stream>>>(scratchpad, bpg_reduce, tpb_reduce, reduce_result); + } else if (rtype == RTYPE_SUM) { + kernel_filter<<>>(vtxbuf, start, end, scratchpad); + kernel_reduce<<>>(scratchpad, num_elems); + kernel_reduce_block<<<1, 1, 0, stream>>>(scratchpad, bpg_reduce, tpb_reduce, reduce_result); } else { ERROR("Unrecognized rtype"); } @@ -944,6 +948,10 @@ reduce_vec(const cudaStream_t stream, const ReductionType rtype, const int3& sta kernel_filter_vec<<>>(vtxbuf0, vtxbuf1, vtxbuf2, start, end, scratchpad); kernel_reduce<<>>(scratchpad, num_elems); kernel_reduce_block<<<1, 1, 0, stream>>>(scratchpad, bpg_reduce, tpb_reduce, reduce_result); + } else if (rtype == RTYPE_SUM) { + kernel_filter_vec<<>>(vtxbuf0, vtxbuf1, vtxbuf2, start, end, scratchpad); + kernel_reduce<<>>(scratchpad, num_elems); + kernel_reduce_block<<<1, 1, 0, stream>>>(scratchpad, bpg_reduce, tpb_reduce, reduce_result); } else { ERROR("Unrecognized rtype"); } diff --git a/src/standalone/model/model_reduce.cc b/src/standalone/model/model_reduce.cc index 6d48c4b..ae092c9 100644 --- a/src/standalone/model/model_reduce.cc +++ b/src/standalone/model/model_reduce.cc @@ -68,8 +68,7 @@ exp_squared(const ModelScalar& a, const ModelScalar& b, const ModelScalar& c) { // clang-format on ModelScalar -model_reduce_scal(const ModelMesh& mesh, const ReductionType& rtype, - const VertexBufferHandle& a) +model_reduce_scal(const ModelMesh& mesh, const ReductionType& rtype, const VertexBufferHandle& a) { ReduceInitialScalFunc reduce_initial; ReduceFunc reduce; @@ -95,30 +94,31 @@ model_reduce_scal(const ModelMesh& mesh, const ReductionType& rtype, reduce = sum; solve_mean = true; break; + case RTYPE_SUM: + reduce_initial = length; + reduce = sum; + break; default: ERROR("Unrecognized RTYPE"); } - const int initial_idx = acVertexBufferIdx( - mesh.info.int_params[AC_nx_min], mesh.info.int_params[AC_ny_min], - mesh.info.int_params[AC_nz_min], mesh.info); + const int initial_idx = acVertexBufferIdx(mesh.info.int_params[AC_nx_min], + mesh.info.int_params[AC_ny_min], + mesh.info.int_params[AC_nz_min], mesh.info); ModelScalar res; if (rtype == RTYPE_MAX || rtype == RTYPE_MIN) res = reduce_initial(mesh.vertex_buffer[a][initial_idx]); else - res = .0f; + res = 0; - for (int k = mesh.info.int_params[AC_nz_min]; - k < mesh.info.int_params[AC_nz_max]; ++k) { - for (int j = mesh.info.int_params[AC_ny_min]; - j < mesh.info.int_params[AC_ny_max]; ++j) { - for (int i = mesh.info.int_params[AC_nx_min]; - i < mesh.info.int_params[AC_nx_max]; ++i) { + for (int k = mesh.info.int_params[AC_nz_min]; k < mesh.info.int_params[AC_nz_max]; ++k) { + for (int j = mesh.info.int_params[AC_ny_min]; j < mesh.info.int_params[AC_ny_max]; ++j) { + for (int i = mesh.info.int_params[AC_nx_min]; i < mesh.info.int_params[AC_nx_max]; + ++i) { const int idx = acVertexBufferIdx(i, j, k, mesh.info); - const ModelScalar curr_val = reduce_initial( - mesh.vertex_buffer[a][idx]); - res = reduce(res, curr_val); + const ModelScalar curr_val = reduce_initial(mesh.vertex_buffer[a][idx]); + res = reduce(res, curr_val); } } } @@ -133,9 +133,8 @@ model_reduce_scal(const ModelMesh& mesh, const ReductionType& rtype, } ModelScalar -model_reduce_vec(const ModelMesh& mesh, const ReductionType& rtype, - const VertexBufferHandle& a, const VertexBufferHandle& b, - const VertexBufferHandle& c) +model_reduce_vec(const ModelMesh& mesh, const ReductionType& rtype, const VertexBufferHandle& a, + const VertexBufferHandle& b, const VertexBufferHandle& c) { // ModelScalar (*reduce_initial)(ModelScalar, ModelScalar, ModelScalar); ReduceInitialVecFunc reduce_initial; @@ -162,33 +161,34 @@ model_reduce_vec(const ModelMesh& mesh, const ReductionType& rtype, reduce = sum; solve_mean = true; break; + case RTYPE_SUM: + reduce_initial = length; + reduce = sum; + break; default: ERROR("Unrecognized RTYPE"); } - const int initial_idx = acVertexBufferIdx( - mesh.info.int_params[AC_nx_min], mesh.info.int_params[AC_ny_min], - mesh.info.int_params[AC_nz_min], mesh.info); + const int initial_idx = acVertexBufferIdx(mesh.info.int_params[AC_nx_min], + mesh.info.int_params[AC_ny_min], + mesh.info.int_params[AC_nz_min], mesh.info); ModelScalar res; if (rtype == RTYPE_MAX || rtype == RTYPE_MIN) - res = reduce_initial(mesh.vertex_buffer[a][initial_idx], - mesh.vertex_buffer[b][initial_idx], + res = reduce_initial(mesh.vertex_buffer[a][initial_idx], mesh.vertex_buffer[b][initial_idx], mesh.vertex_buffer[c][initial_idx]); else res = 0; - for (int k = mesh.info.int_params[AC_nz_min]; - k < mesh.info.int_params[AC_nz_max]; k++) { - for (int j = mesh.info.int_params[AC_ny_min]; - j < mesh.info.int_params[AC_ny_max]; j++) { - for (int i = mesh.info.int_params[AC_nx_min]; - i < mesh.info.int_params[AC_nx_max]; i++) { + for (int k = mesh.info.int_params[AC_nz_min]; k < mesh.info.int_params[AC_nz_max]; k++) { + for (int j = mesh.info.int_params[AC_ny_min]; j < mesh.info.int_params[AC_ny_max]; j++) { + for (int i = mesh.info.int_params[AC_nx_min]; i < mesh.info.int_params[AC_nx_max]; + i++) { const int idx = acVertexBufferIdx(i, j, k, mesh.info); - const ModelScalar curr_val = reduce_initial( - mesh.vertex_buffer[a][idx], mesh.vertex_buffer[b][idx], - mesh.vertex_buffer[c][idx]); - res = reduce(res, curr_val); + const ModelScalar curr_val = reduce_initial(mesh.vertex_buffer[a][idx], + mesh.vertex_buffer[b][idx], + mesh.vertex_buffer[c][idx]); + res = reduce(res, curr_val); } } } From 5361ee570689806d1dc021e7e85a56e880d9d260 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 30 Jul 2019 13:46:05 +0800 Subject: [PATCH 17/87] Fixed gravitational force inputs. --- acc/mhd_solver/stencil_process.sps | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index a9e9747..8684adc 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -61,9 +61,9 @@ continuity(in Vector uu, in Scalar lnrho) { } #if LSINK - +//first attempt to do a self-containing LSINK module Vector -gravity() { +sink_gravity() { vector force_gravity; const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, (globalVertexIdx.y - ny_min) * dsy, @@ -75,7 +75,7 @@ gravity() { const Scalar distance = length(grid_pos - sink_pos); force_gravity = (6.67e-8 * sink_mass) / (distance * distance); return force_gravity; -}//first attempt to do a self-containing LSINK module +} #if LENTROPY Vector @@ -98,6 +98,9 @@ momentum(in Vector uu, in Scalar lnrho, in Scalar ss, in Vector aa) { + Scalar(2.) * mul(S, gradient(lnrho)) ) + zeta * gradient_of_divergence(uu); + #if LSINK + mom = mom + sink_gravity(); + #endif return mom; } #elif LTEMPERATURE @@ -116,7 +119,7 @@ momentum(in Vector uu, in Scalar lnrho, in Scalar tt) { Scalar(2.) * mul(S, gradient(lnrho))) + zeta * gradient_of_divergence(uu); #if LSINK - mom = mom - (Vector){force_gravity}; + mom = mom + sink_gravity(); #endif return mom; @@ -135,10 +138,10 @@ momentum(in Vector uu, in Scalar lnrho) { nu_visc * (laplace_vec(uu) + Scalar(1. / 3.) * gradient_of_divergence(uu) + Scalar(2.) * mul(S, gradient(lnrho))) + zeta * gradient_of_divergence(uu); - - #if LSINK - mom = mom - (Vector){force_gravity}; - #endif + + #if LSINK + mom = mom + sink_gravity(); + #endif return mom; } From 24a56044f08a925840c5f50020c415e1012b64b6 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Wed, 31 Jul 2019 16:57:44 +0800 Subject: [PATCH 18/87] Fixed gravitating particle. --- acc/mhd_solver/stencil_process.sps | 55 +++++++++++++++++------------- 1 file changed, 31 insertions(+), 24 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 8684adc..a4970b5 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -21,10 +21,6 @@ uniform int nz_min; uniform int nx; uniform int ny; uniform int nz; -uniform Scalar AC_sink_pos_x; -uniform Scalar AC_sink_pos_y; -uniform Scalar AC_sink_pos_z; -uniform Scalar AC_M_sink; //Added declaration for constants used for sink particle. Vector @@ -63,23 +59,28 @@ continuity(in Vector uu, in Scalar lnrho) { #if LSINK //first attempt to do a self-containing LSINK module Vector -sink_gravity() { - vector force_gravity; +sink_gravity(int3 globalVertexIdx){ + Vector force_gravity; const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, (globalVertexIdx.y - ny_min) * dsy, (globalVertexIdx.z - nz_min) * dsz}; - const Scalar sink_mass = DCONST(AC_M_sink); + const Scalar sink_mass = DCONST_REAL(AC_M_sink); const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), DCONST_REAL(AC_sink_pos_y), DCONST_REAL(AC_sink_pos_z)}; const Scalar distance = length(grid_pos - sink_pos); - force_gravity = (6.67e-8 * sink_mass) / (distance * distance); + const Scalar gravity_magnitude = (Scalar(0.01) * sink_mass) / (distance * distance); + const Vector direction = (Vector){(sink_pos.x - grid_pos.x) / distance, + (sink_pos.y - grid_pos.y) / distance, + (sink_pos.z - grid_pos.z) / distance}; + force_gravity = gravity_magnitude * direction; return force_gravity; } +#endif #if LENTROPY Vector -momentum(in Vector uu, in Scalar lnrho, in Scalar ss, in Vector aa) { +momentum(int3 globalVertexIdx, in Vector uu, in Scalar lnrho, in Scalar ss, in Vector aa) { const Matrix S = stress_tensor(uu); const Scalar cs2 = cs2_sound * exp(gamma * value(ss) / cp_sound + (gamma - 1) * (value(lnrho) - lnrho0)); const Vector j = (Scalar(1.) / mu0) * (gradient_of_divergence(aa) - laplace_vec(aa)); // Current density @@ -97,15 +98,17 @@ momentum(in Vector uu, in Scalar lnrho, in Scalar ss, in Vector aa) { + Scalar(1. / 3.) * gradient_of_divergence(uu) + Scalar(2.) * mul(S, gradient(lnrho)) ) - + zeta * gradient_of_divergence(uu); + + zeta * gradient_of_divergence(uu) #if LSINK - mom = mom + sink_gravity(); + + sink_gravity(globalVertexIdx); + #else + ; #endif return mom; } #elif LTEMPERATURE Vector -momentum(in Vector uu, in Scalar lnrho, in Scalar tt) { +momentum(int3 globalVertexIdx, in Vector uu, in Scalar lnrho, in Scalar tt) { Vector mom; const Matrix S = stress_tensor(uu); @@ -116,17 +119,19 @@ momentum(in Vector uu, in Scalar lnrho, in Scalar tt) { pressure_term + nu_visc * (laplace_vec(uu) + Scalar(1. / 3.) * gradient_of_divergence(uu) + - Scalar(2.) * mul(S, gradient(lnrho))) + zeta * gradient_of_divergence(uu); + Scalar(2.) * mul(S, gradient(lnrho))) + zeta * gradient_of_divergence(uu) - #if LSINK - mom = mom + sink_gravity(); - #endif + #if LSINK + + sink_gravity(globalVertexIdx); + #else + ; + #endif return mom; } #else Vector -momentum(in Vector uu, in Scalar lnrho) { +momentum(int3 globalVertexIdx, in Vector uu, in Scalar lnrho) { Vector mom; const Matrix S = stress_tensor(uu); @@ -137,11 +142,13 @@ momentum(in Vector uu, in Scalar lnrho) { cs2_sound * gradient(lnrho) + nu_visc * (laplace_vec(uu) + Scalar(1. / 3.) * gradient_of_divergence(uu) + - Scalar(2.) * mul(S, gradient(lnrho))) + zeta * gradient_of_divergence(uu); + Scalar(2.) * mul(S, gradient(lnrho))) + zeta * gradient_of_divergence(uu) - #if LSINK - mom = mom + sink_gravity(); - #endif + #if LSINK + + sink_gravity(globalVertexIdx); + #else + ; + #endif return mom; } @@ -339,13 +346,13 @@ solve(Scalar dt) { #endif #if LENTROPY - out_uu = rk3(out_uu, uu, momentum(uu, lnrho, ss, aa), dt); + out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, ss, aa), dt); out_ss = rk3(out_ss, ss, entropy(ss, uu, lnrho, aa), dt); #elif LTEMPERATURE - out_uu = rk3(out_uu, uu, momentum(uu, lnrho, tt), dt); + out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, tt), dt); out_tt = rk3(out_tt, tt, heat_transfer(uu, lnrho, tt), dt); #else - out_uu = rk3(out_uu, uu, momentum(uu, lnrho), dt); + out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho), dt); #endif #if LFORCING From d5a3d896aaf3d83e81e7e08c094380d142be38b4 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 1 Aug 2019 13:36:05 +0800 Subject: [PATCH 19/87] Fixed astaroth.conf. --- config/astaroth.conf | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/config/astaroth.conf b/config/astaroth.conf index 41b7e51..7235811 100644 --- a/config/astaroth.conf +++ b/config/astaroth.conf @@ -49,6 +49,12 @@ AC_gamma = 0.5 AC_lnT0 = 1.2 AC_lnrho0 = 1.3 +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 0.0 +AC_sink_pos_z = 0.0 +AC_M_sink = 1.0 + /* * ============================================================================= * Initial conditions From 718a275bcf132f1e0efe4d0bfec070839739604c Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Thu, 1 Aug 2019 14:12:21 +0800 Subject: [PATCH 20/87] Proiper softening factor --- acc/mhd_solver/stencil_process.sps | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index a4970b5..0d47dad 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -69,7 +69,8 @@ sink_gravity(int3 globalVertexIdx){ DCONST_REAL(AC_sink_pos_y), DCONST_REAL(AC_sink_pos_z)}; const Scalar distance = length(grid_pos - sink_pos); - const Scalar gravity_magnitude = (Scalar(0.01) * sink_mass) / (distance * distance); + const Scalar soft = 0.12; + const Scalar gravity_magnitude = (Scalar(0.01) * sink_mass) / pow(((distance * distance) + soft*soft), 1.5); const Vector direction = (Vector){(sink_pos.x - grid_pos.x) / distance, (sink_pos.y - grid_pos.y) / distance, (sink_pos.z - grid_pos.z) / distance}; From 29d6a9b00afb484ad04bd6292c71776e9ff78ec1 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 1 Aug 2019 16:33:58 +0800 Subject: [PATCH 21/87] Fixed scaling for sink particle, and added softening factor. --- acc/mhd_solver/stencil_defines.h | 3 ++- acc/mhd_solver/stencil_process.sps | 5 ++--- config/astaroth.conf | 6 ++++++ src/standalone/config_loader.cc | 6 ++---- src/standalone/simulation.cc | 3 +++ 5 files changed, 15 insertions(+), 8 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index c807401..ed67f5f 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -78,6 +78,7 @@ FUNC(AC_sink_pos_y),\ FUNC(AC_sink_pos_z),\ FUNC(AC_M_sink),\ + FUNC(AC_soft),\ /* Run params */\ FUNC(AC_cdt), \ FUNC(AC_cdtv), \ @@ -120,7 +121,7 @@ FUNC(AC_ff_hel_imz),\ /* Additional helper params */\ /* (deduced from other params do not set these directly!) */\ - FUNC(AC_G_CONST),\ + FUNC(AC_G_const),\ FUNC(AC_GM_star),\ FUNC(AC_sq2GM_star),\ FUNC(AC_cs2_sound), \ diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 0d47dad..6ac6e4f 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -21,7 +21,6 @@ uniform int nz_min; uniform int nx; uniform int ny; uniform int nz; -//Added declaration for constants used for sink particle. Vector value(in Vector uu) @@ -69,8 +68,8 @@ sink_gravity(int3 globalVertexIdx){ DCONST_REAL(AC_sink_pos_y), DCONST_REAL(AC_sink_pos_z)}; const Scalar distance = length(grid_pos - sink_pos); - const Scalar soft = 0.12; - const Scalar gravity_magnitude = (Scalar(0.01) * sink_mass) / pow(((distance * distance) + soft*soft), 1.5); + const Scalar soft = DCONST_REAL(AC_soft); + const Scalar gravity_magnitude = (AC_G_const * sink_mass) / pow(((distance * distance) + soft*soft), 1.5); const Vector direction = (Vector){(sink_pos.x - grid_pos.x) / distance, (sink_pos.y - grid_pos.y) / distance, (sink_pos.z - grid_pos.z) / distance}; diff --git a/config/astaroth.conf b/config/astaroth.conf index 7235811..747b8e9 100644 --- a/config/astaroth.conf +++ b/config/astaroth.conf @@ -54,6 +54,12 @@ AC_sink_pos_x = 3.14 AC_sink_pos_y = 0.0 AC_sink_pos_z = 0.0 AC_M_sink = 1.0 +AC_soft = 0.12 + +// Physical properties of the domain +AC_unit_velocity = 1.0 +AC_unit_density = 1.0 +AC_unit_length = 1.0 /* * ============================================================================= diff --git a/src/standalone/config_loader.cc b/src/standalone/config_loader.cc index 7a0a509..f3d7aa3 100644 --- a/src/standalone/config_loader.cc +++ b/src/standalone/config_loader.cc @@ -137,19 +137,17 @@ update_config(AcMeshInfo* config) 6.674e-8); // g/cm3/s GGS definition //TODO define in a separate module AcReal M_sun = AcReal(1.989e33); // g solar mass - config->real_params[AC_M_star] = config->real_params[AC_M_star] * M_sun / + config->real_params[AC_M_sink] = config->real_params[AC_M_sink] * M_sun / ((config->real_params[AC_unit_length] * config->real_params[AC_unit_length] * config->real_params[AC_unit_length]) * config->real_params[AC_unit_density]); - config->real_params[AC_G_CONST] = G_CONST_CGS / ((config->real_params[AC_unit_velocity] * + config->real_params[AC_G_const] = G_CONST_CGS / ((config->real_params[AC_unit_velocity] * config->real_params[AC_unit_velocity]) / (config->real_params[AC_unit_density] * config->real_params[AC_unit_length])); - config->real_params[AC_GM_star] = config->real_params[AC_M_star] * - config->real_params[AC_G_CONST]; config->real_params[AC_sq2GM_star] = AcReal(sqrt(AcReal(2) * config->real_params[AC_GM_star])); #if VERBOSE_PRINTING // Defined in astaroth.h diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 1b553d5..ff131f5 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -95,6 +95,9 @@ write_mesh_info(const AcMeshInfo* config) fprintf(infotxt, "real AC_sink_pos_y %e \n", (double)config->real_params[AC_sink_pos_y]); fprintf(infotxt, "real AC_sink_pos_z %e \n", (double)config->real_params[AC_sink_pos_z]); fprintf(infotxt, "real AC_M_sink %e \n", (double)config->real_params[AC_M_sink]); + fprintf(infotxt, "real AC_soft %e \n", (double)config->real_params[AC_soft]); + + fprintf(infotxt, "real AC_G_const %e \n", (double)config->real_params[AC_G_const]); fclose(infotxt); } From e1b34480fc9625bd25898dd65b3f663046121468 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Thu, 1 Aug 2019 17:25:14 +0800 Subject: [PATCH 22/87] Default sink position at [pi, pi, pi] for clarity. --- config/astaroth.conf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/config/astaroth.conf b/config/astaroth.conf index 747b8e9..7c19a64 100644 --- a/config/astaroth.conf +++ b/config/astaroth.conf @@ -51,8 +51,8 @@ AC_lnrho0 = 1.3 // Sink Particle AC_sink_pos_x = 3.14 -AC_sink_pos_y = 0.0 -AC_sink_pos_z = 0.0 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 AC_M_sink = 1.0 AC_soft = 0.12 From 6927ddff5ae77264de02d0de8eb8c0a4c9331b61 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Thu, 1 Aug 2019 17:57:21 +0800 Subject: [PATCH 23/87] Correct an obscure bug. --- acc/mhd_solver/stencil_defines.h | 1 + src/standalone/config_loader.cc | 10 +++++----- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index ed67f5f..dbd632e 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -78,6 +78,7 @@ FUNC(AC_sink_pos_y),\ FUNC(AC_sink_pos_z),\ FUNC(AC_M_sink),\ + FUNC(AC_M_sink_Msun),\ FUNC(AC_soft),\ /* Run params */\ FUNC(AC_cdt), \ diff --git a/src/standalone/config_loader.cc b/src/standalone/config_loader.cc index f3d7aa3..abda35a 100644 --- a/src/standalone/config_loader.cc +++ b/src/standalone/config_loader.cc @@ -137,11 +137,11 @@ update_config(AcMeshInfo* config) 6.674e-8); // g/cm3/s GGS definition //TODO define in a separate module AcReal M_sun = AcReal(1.989e33); // g solar mass - config->real_params[AC_M_sink] = config->real_params[AC_M_sink] * M_sun / - ((config->real_params[AC_unit_length] * - config->real_params[AC_unit_length] * - config->real_params[AC_unit_length]) * - config->real_params[AC_unit_density]); + config->real_params[AC_M_sink_Msun] = config->real_params[AC_M_sink] * M_sun / + ((config->real_params[AC_unit_length] * + config->real_params[AC_unit_length] * + config->real_params[AC_unit_length]) * + config->real_params[AC_unit_density]); config->real_params[AC_G_const] = G_CONST_CGS / ((config->real_params[AC_unit_velocity] * config->real_params[AC_unit_velocity]) / From 99d80f7175af3beb128632a9f2700cbfa4330dbf Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Thu, 1 Aug 2019 18:06:57 +0800 Subject: [PATCH 24/87] Renaming for bug correction. Use now AC_M_sink_Msun in astaroth.conf instead of AC_M_sink! --- config/astaroth.conf | 2 +- src/standalone/config_loader.cc | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/config/astaroth.conf b/config/astaroth.conf index 7c19a64..b06a4da 100644 --- a/config/astaroth.conf +++ b/config/astaroth.conf @@ -53,7 +53,7 @@ AC_lnrho0 = 1.3 AC_sink_pos_x = 3.14 AC_sink_pos_y = 3.14 AC_sink_pos_z = 3.14 -AC_M_sink = 1.0 +AC_M_sink_Msun = 1.0 AC_soft = 0.12 // Physical properties of the domain diff --git a/src/standalone/config_loader.cc b/src/standalone/config_loader.cc index abda35a..e7885a3 100644 --- a/src/standalone/config_loader.cc +++ b/src/standalone/config_loader.cc @@ -137,11 +137,11 @@ update_config(AcMeshInfo* config) 6.674e-8); // g/cm3/s GGS definition //TODO define in a separate module AcReal M_sun = AcReal(1.989e33); // g solar mass - config->real_params[AC_M_sink_Msun] = config->real_params[AC_M_sink] * M_sun / - ((config->real_params[AC_unit_length] * - config->real_params[AC_unit_length] * - config->real_params[AC_unit_length]) * - config->real_params[AC_unit_density]); + config->real_params[AC_M_sink] = config->real_params[AC_M_sink_Msun] * M_sun / + ((config->real_params[AC_unit_length] * + config->real_params[AC_unit_length] * + config->real_params[AC_unit_length]) * + config->real_params[AC_unit_density]); config->real_params[AC_G_const] = G_CONST_CGS / ((config->real_params[AC_unit_velocity] * config->real_params[AC_unit_velocity]) / From 3c87fe0b48be5baebb1260916e5f358a6c5a1f61 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Fri, 2 Aug 2019 13:48:09 +0800 Subject: [PATCH 25/87] Added unit_mass --- acc/mhd_solver/stencil_defines.h | 1 + src/standalone/config_loader.cc | 18 +++++++++++++----- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index dbd632e..ebec464 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -123,6 +123,7 @@ /* Additional helper params */\ /* (deduced from other params do not set these directly!) */\ FUNC(AC_G_const),\ + FUNC(AC_unit_mass),\ FUNC(AC_GM_star),\ FUNC(AC_sq2GM_star),\ FUNC(AC_cs2_sound), \ diff --git a/src/standalone/config_loader.cc b/src/standalone/config_loader.cc index e7885a3..0d6085b 100644 --- a/src/standalone/config_loader.cc +++ b/src/standalone/config_loader.cc @@ -137,11 +137,19 @@ update_config(AcMeshInfo* config) 6.674e-8); // g/cm3/s GGS definition //TODO define in a separate module AcReal M_sun = AcReal(1.989e33); // g solar mass - config->real_params[AC_M_sink] = config->real_params[AC_M_sink_Msun] * M_sun / - ((config->real_params[AC_unit_length] * - config->real_params[AC_unit_length] * - config->real_params[AC_unit_length]) * - config->real_params[AC_unit_density]); + + config->real_params[AC_unit_mass] = (config->real_params[AC_unit_length] * + config->real_params[AC_unit_length] * + config->real_params[AC_unit_length]) * + config->real_params[AC_unit_density]; + + + + + + + config->real_params[AC_M_sink] = config->real_params[AC_M_sink_Msun] * M_sun / + config->real_params[AC_unit_mass]; config->real_params[AC_G_const] = G_CONST_CGS / ((config->real_params[AC_unit_velocity] * config->real_params[AC_unit_velocity]) / From 239e8b4d3ef045c0d78a68465235fc0f2b5635a7 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Fri, 2 Aug 2019 17:31:49 +0800 Subject: [PATCH 26/87] Can set the density for intitial condition from astaroth.conf. --- src/standalone/model/host_memory.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index 5cda923..19c75f2 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -564,6 +564,7 @@ acmesh_init_to(const InitType& init_type, AcMesh* mesh) } case INIT_TYPE_GAUSSIAN_RADIAL_EXPL: acmesh_clear(mesh); + vertex_buffer_set(VTXBUF_LNRHO, mesh->info.real_params[AC_ampl_lnrho], mesh); // acmesh_init_to(INIT_TYPE_RANDOM, mesh); gaussian_radial_explosion(mesh); From ad53a0b5f0187d8a53292b42e873237c68634e70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miikka=20V=C3=A4is=C3=A4l=C3=A4?= Date: Mon, 5 Aug 2019 05:24:59 +0000 Subject: [PATCH 27/87] sink_particle.md edited online with Bitbucket Comments on JP's accretion suggestions. --- doc/manual/sink_particle.md | 27 +++++++++++++++++++++------ 1 file changed, 21 insertions(+), 6 deletions(-) diff --git a/doc/manual/sink_particle.md b/doc/manual/sink_particle.md index 0b6b9e1..0b7f11b 100644 --- a/doc/manual/sink_particle.md +++ b/doc/manual/sink_particle.md @@ -81,10 +81,11 @@ Make is possible for the particle to accrete momentum in addition to mass, and t Create sink particles dynamically and allow the presence of multiple sinks. -Suggestion writen by JP: +### Suggestion writen by JP: + +Add to ```acc/mhd_solver/stencil_defines.h```: ``` -add to acc/mhd_solver/stencil_defines.h: // Scalar mass #define AC_FOR_USER_REAL_PARAM_TYPES(FUNC) \ ... @@ -100,14 +101,19 @@ add to acc/mhd_solver/stencil_defines.h: ... ... FUNC(AC_sink_particle_pos), +``` +Currently we do not do it like that as AcReal3 constant parameter. However, would be good thing to implement eventually. +``` // Vertex buffer for accretion #define AC_FOR_VTXBUF_HANDLES(FUNC) \ ... FUNC(VTXBUF_ACCRETION), +``` +Add to ```acc/mhd_solver/stencil_process.sps```: -acc/mhd_solver/stencil_process.sps: +``` Scalar your_accretion_function(int3 globalVertexIdx) @@ -118,6 +124,10 @@ acc/mhd_solver/stencil_process.sps: return *accretion from the current cell at globalVertexIdx* } + +``` +This step will require that we calculate the acctetion as **mass** in a grid cell volume. This is to eventually take an advantage of nonunifrorm grid. OIOn that way we do not need to worry about it in the collective operation stage. +``` // This should have a global scope out Scalar out_accretion = VTXBUF_ACCRETION; @@ -130,9 +140,12 @@ acc/mhd_solver/stencil_process.sps: out_accretion = your_accretion_function(globalVertexIdx); } +``` +Important to note that we need to take into account the reduction of density with other equations of motion. Or apply analogous style to forcing. +Create new file ```src/standalone/model/host_accretion.cc```: -src/standalone/model/host_accretion.cc: <- new file +``` #include "astaroth.h" void @@ -146,10 +159,12 @@ src/standalone/model/host_accretion.cc: <- new file info->real_params[AC_sink_particle_mass] = mass; // Save for the next iteration acLoadDeviceConstant(AC_sink_particle_mass, mass); // Load to the GPUs } +``` +We assume that acReduceScal will sum up the mass in the accretion buffer. +Call from```src/standalone/simulation.cc```: -src/standalone/simulation.cc: - +``` #include "model/host_accretion.h" int From fa99b86601815b66c30e1244de5a994ff4982824 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 5 Aug 2019 14:26:32 +0800 Subject: [PATCH 28/87] Added a stable astaroth.conf template for testing. --- .../python/jupyter/notebook_example.ipynb | 236 ++++++++++++++++-- 1 file changed, 222 insertions(+), 14 deletions(-) diff --git a/analysis/python/jupyter/notebook_example.ipynb b/analysis/python/jupyter/notebook_example.ipynb index f7e4956..5bd2729 100644 --- a/analysis/python/jupyter/notebook_example.ipynb +++ b/analysis/python/jupyter/notebook_example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -20,22 +20,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "meshdir = \"/scratch/data/mvaisala/forcingtest/\"\n", + "meshdir = \"/scratch/data/tchsu/sink_double/\"\n", "#meshdir = \"/scratch/data/mvaisala/normaltest/\"" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/scratch/data/tchsu/sink_double/VTXBUF_LNRHO_1000.mesh\n", + "/scratch/data/tchsu/sink_double/VTXBUF_ENTROPY_1000.mesh\n", + "/scratch/data/tchsu/sink_double/VTXBUF_UUX_1000.mesh\n", + "/scratch/data/tchsu/sink_double/VTXBUF_UUY_1000.mesh\n", + "/scratch/data/tchsu/sink_double/VTXBUF_UUZ_1000.mesh\n", + "/scratch/data/tchsu/sink_double/VTXBUF_AX_1000.mesh\n", + "/scratch/data/tchsu/sink_double/VTXBUF_AY_1000.mesh\n", + "/scratch/data/tchsu/sink_double/VTXBUF_AZ_1000.mesh\n" + ] + } + ], "source": [ "#imesh = 30000\n", - "imesh = 100\n", + "imesh = 1000\n", "mesh = ad.read.Mesh(imesh, fdir=meshdir)" ] }, @@ -48,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -64,11 +79,122 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "vis.slices.plot_3(mesh, uu_tot, title = r'$\\|u\\|$')\n", "vis.slices.plot_3(mesh, mesh.uu[0], title = r'$u_x$')\n", @@ -89,18 +215,100 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HERE ARE ALL KEYS FOR TS DATA:\n", + "dict_keys(['step', 't_step', 'dt', 'uutot_min', 'uutot_rms', 'uutot_max', 'lnrho_min', 'lnrho_rms', 'lnrho_max', 'uux_min', 'uux_rms', 'uux_max', 'uuy_min', 'uuy_rms', 'uuy_max', 'uuz_min', 'uuz_rms', 'uuz_max', 'aax_min', 'aax_rms', 'aax_max', 'aay_min', 'aay_rms', 'aay_max', 'aaz_min', 'aaz_rms', 'aaz_max', 'ss_min', 'ss_rms', 'ss_max'])\n" + ] + } + ], "source": [ "ts = ad.read.TimeSeries(fdir=meshdir)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "vis.lineplot.plot_ts(ts, lnrho=1, uutot=1, uux=1, uuy=1, uuz=1, ss=1)" ] @@ -122,7 +330,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.7.3" } }, "nbformat": 4, From 0491f83e8bf670fb94072d87fbce747ddb5681ea Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 5 Aug 2019 14:38:46 +0800 Subject: [PATCH 29/87] Added the correct file this time. --- config/templates/sinktest.conf | 72 ++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 config/templates/sinktest.conf diff --git a/config/templates/sinktest.conf b/config/templates/sinktest.conf new file mode 100644 index 0000000..674f178 --- /dev/null +++ b/config/templates/sinktest.conf @@ -0,0 +1,72 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 128 +AC_ny = 128 +AC_nz = 128 + +AC_dsx = 0.04908738521 +AC_dsy = 0.04908738521 +AC_dsz = 0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 1001 +AC_save_steps = 1 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-3 +AC_cs_sound = 1.0 +AC_zeta = 0.01 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-5 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-6 +AC_soft = 0.36 + +// Physical properties of the domain +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3 +AC_unit_density = 3e-22 +AC_unit_length = 1.5e17 + +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 0.0 From 5f89b698ffed2b3cd37d703e6caf6504373d1348 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 5 Aug 2019 14:41:30 +0800 Subject: [PATCH 30/87] Emptied the notebook output. --- .../python/jupyter/notebook_example.ipynb | 230 +----------------- 1 file changed, 11 insertions(+), 219 deletions(-) diff --git a/analysis/python/jupyter/notebook_example.ipynb b/analysis/python/jupyter/notebook_example.ipynb index 5bd2729..7595462 100644 --- a/analysis/python/jupyter/notebook_example.ipynb +++ b/analysis/python/jupyter/notebook_example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -30,24 +30,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/scratch/data/tchsu/sink_double/VTXBUF_LNRHO_1000.mesh\n", - "/scratch/data/tchsu/sink_double/VTXBUF_ENTROPY_1000.mesh\n", - "/scratch/data/tchsu/sink_double/VTXBUF_UUX_1000.mesh\n", - "/scratch/data/tchsu/sink_double/VTXBUF_UUY_1000.mesh\n", - "/scratch/data/tchsu/sink_double/VTXBUF_UUZ_1000.mesh\n", - "/scratch/data/tchsu/sink_double/VTXBUF_AX_1000.mesh\n", - "/scratch/data/tchsu/sink_double/VTXBUF_AY_1000.mesh\n", - "/scratch/data/tchsu/sink_double/VTXBUF_AZ_1000.mesh\n" - ] - } - ], + "outputs": [], "source": [ "#imesh = 30000\n", "imesh = 1000\n", @@ -63,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -79,122 +64,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "vis.slices.plot_3(mesh, uu_tot, title = r'$\\|u\\|$')\n", "vis.slices.plot_3(mesh, mesh.uu[0], title = r'$u_x$')\n", @@ -215,100 +89,18 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HERE ARE ALL KEYS FOR TS DATA:\n", - "dict_keys(['step', 't_step', 'dt', 'uutot_min', 'uutot_rms', 'uutot_max', 'lnrho_min', 'lnrho_rms', 'lnrho_max', 'uux_min', 'uux_rms', 'uux_max', 'uuy_min', 'uuy_rms', 'uuy_max', 'uuz_min', 'uuz_rms', 'uuz_max', 'aax_min', 'aax_rms', 'aax_max', 'aay_min', 'aay_rms', 'aay_max', 'aaz_min', 'aaz_rms', 'aaz_max', 'ss_min', 'ss_rms', 'ss_max'])\n" - ] - } - ], + "outputs": [], "source": [ "ts = ad.read.TimeSeries(fdir=meshdir)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "vis.lineplot.plot_ts(ts, lnrho=1, uutot=1, uux=1, uuy=1, uuz=1, ss=1)" ] From 1bc07618d648d349819fdaff18035a85e525642e Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 5 Aug 2019 16:33:59 +0800 Subject: [PATCH 31/87] Added VTXBUF_ACCRETION. --- acc/mhd_solver/stencil_defines.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index ebec464..bd6e43c 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -143,6 +143,8 @@ #if LENTROPY #define AC_FOR_VTXBUF_HANDLES(FUNC) \ FUNC(VTXBUF_LNRHO), \ + /*Added vertex buffer for sink. TODO: Invoke smarter.*/\ + FUNC(VTXBUF_ACCRETION), \ FUNC(VTXBUF_UUX), \ FUNC(VTXBUF_UUY), \ FUNC(VTXBUF_UUZ), \ @@ -153,6 +155,8 @@ #elif LMAGNETIC #define AC_FOR_VTXBUF_HANDLES(FUNC) \ FUNC(VTXBUF_LNRHO), \ + /*Added vertex buffer for sink. TODO: Invoke smarter.*/\ + FUNC(VTXBUF_ACCRETION), \ FUNC(VTXBUF_UUX), \ FUNC(VTXBUF_UUY), \ FUNC(VTXBUF_UUZ), \ @@ -162,6 +166,8 @@ #elif LHYDRO #define AC_FOR_VTXBUF_HANDLES(FUNC) \ FUNC(VTXBUF_LNRHO), \ + /*Added vertex buffer for sink. TODO: Invoke smarter.*/\ + FUNC(VTXBUF_ACCRETION), \ FUNC(VTXBUF_UUX), \ FUNC(VTXBUF_UUY), \ FUNC(VTXBUF_UUZ), From 632819764eb964650d2da02bf6d582829c4923f3 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 6 Aug 2019 11:47:55 +0800 Subject: [PATCH 32/87] Some intuitions about accretion process. Also defined as a module. --- acc/mhd_solver/stencil_defines.h | 1 + acc/mhd_solver/stencil_process.sps | 23 +++++++++++++++++++---- 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index bd6e43c..d37eeba 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -33,6 +33,7 @@ #define LFORCING (0) #define LUPWD (0) #define LSINK (1) +#define LACCRETION(1) #define AC_THERMAL_CONDUCTIVITY (AcReal(0.001)) // TODO: make an actual config parameter diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 6ac6e4f..ea82ca5 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -56,7 +56,6 @@ continuity(in Vector uu, in Scalar lnrho) { } #if LSINK -//first attempt to do a self-containing LSINK module Vector sink_gravity(int3 globalVertexIdx){ Vector force_gravity; @@ -65,8 +64,8 @@ sink_gravity(int3 globalVertexIdx){ (globalVertexIdx.z - nz_min) * dsz}; const Scalar sink_mass = DCONST_REAL(AC_M_sink); const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), - DCONST_REAL(AC_sink_pos_y), - DCONST_REAL(AC_sink_pos_z)}; + DCONST_REAL(AC_sink_pos_y), + DCONST_REAL(AC_sink_pos_z)}; const Scalar distance = length(grid_pos - sink_pos); const Scalar soft = DCONST_REAL(AC_soft); const Scalar gravity_magnitude = (AC_G_const * sink_mass) / pow(((distance * distance) + soft*soft), 1.5); @@ -77,7 +76,23 @@ sink_gravity(int3 globalVertexIdx){ return force_gravity; } #endif - +// Now this is more of a suedo-code, just write out some intuitions. +#if LACCRETION +Scalar +mass_accrection(int3 globalVertexIdx){ + Scalar mass = (Scalar){() + Scalar Jeans_length = pow(((3.14 * cv_sound * cv_sound) / (AC_G_const * lnrho), 0.5)); + Scalar Truelove_Jeans_lnrho = ((3.14) * Jeans_length * Jeans_length * cv2_sound) / (AC_G_const * dsx * dsy * dsz); + const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), + DCONST_REAL(AC_sink_pos_y), + DCONST_REAL(AC_sink_pos_z)}; + const Scalar sink_mass = DCONST_REAL(AC_M_sink); + if (lnrho >= Truelove_Jeans_lnrho) + { + sink_mass = sink_mass + (Truelove_Jeans_lnrho * (dsx * dsy * dsz)) + } + return sink_mass; +} #if LENTROPY Vector momentum(int3 globalVertexIdx, in Vector uu, in Scalar lnrho, in Scalar ss, in Vector aa) { From aebf4f11aeebc148a8cda12227686be889d3c90a Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 6 Aug 2019 16:17:11 +0800 Subject: [PATCH 33/87] Added function for truelove-density, and took out the unecessary use of switch on-off module for accretion. --- acc/mhd_solver/stencil_defines.h | 1 - acc/mhd_solver/stencil_process.sps | 35 ++++++++++++++++++------------ 2 files changed, 21 insertions(+), 15 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index d37eeba..bd6e43c 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -33,7 +33,6 @@ #define LFORCING (0) #define LUPWD (0) #define LSINK (1) -#define LACCRETION(1) #define AC_THERMAL_CONDUCTIVITY (AcReal(0.001)) // TODO: make an actual config parameter diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index ea82ca5..6f469cc 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -76,23 +76,30 @@ sink_gravity(int3 globalVertexIdx){ return force_gravity; } #endif + + + // Now this is more of a suedo-code, just write out some intuitions. -#if LACCRETION +#if LSINK Scalar -mass_accrection(int3 globalVertexIdx){ - Scalar mass = (Scalar){() - Scalar Jeans_length = pow(((3.14 * cv_sound * cv_sound) / (AC_G_const * lnrho), 0.5)); - Scalar Truelove_Jeans_lnrho = ((3.14) * Jeans_length * Jeans_length * cv2_sound) / (AC_G_const * dsx * dsy * dsz); - const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), - DCONST_REAL(AC_sink_pos_y), - DCONST_REAL(AC_sink_pos_z)}; - const Scalar sink_mass = DCONST_REAL(AC_M_sink); - if (lnrho >= Truelove_Jeans_lnrho) - { - sink_mass = sink_mass + (Truelove_Jeans_lnrho * (dsx * dsy * dsz)) - } - return sink_mass; +truelove_density(in Scalar lnrho){ + const Scalar rho = exp(lnrho); + const Scalar Jeans_length_squared = (M_PI * cs2_sound) / (AC_G_const * rho); + const Scalar TJ_rho = ((M_PI) * ((dsx * dsx) / Jeans_length_squared) * cs2_sound) / (AC_G_const * dsx * dsx); + + + Scalar accrection_rho = rho - TJ_rho; + if (accrection_rho < 0){ + accrection_rho = Scalar(0); + } + + return accretion_rho; } +#endif +//TODO: basic structure of this part is as follows +// update_accretion_buffer() <--> accretion_profile() <--> truelove_density() + + #if LENTROPY Vector momentum(int3 globalVertexIdx, in Vector uu, in Scalar lnrho, in Scalar ss, in Vector aa) { From 2a26b58c385b193d932801a80d708da6fbe1555e Mon Sep 17 00:00:00 2001 From: JackHsu Date: Wed, 7 Aug 2019 11:21:24 +0800 Subject: [PATCH 34/87] Attempted to add accretion_profile function, and made it adjustable within astaroth.conf --- acc/mhd_solver/stencil_process.sps | 32 +++++++++++++++++++++++++++++- config/astaroth.conf | 4 ++++ 2 files changed, 35 insertions(+), 1 deletion(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 4fa2e5b..1bbf9ff 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -90,10 +90,40 @@ truelove_density(in Scalar lnrho){ Scalar accrection_rho = rho - TJ_rho; if (accrection_rho < 0){ - accrection_rho = Scalar(0); + accrection_rho = Scalar(0); } return accretion_rho; +} + + +accretion_profile(int3 globalVertexIdx){ + const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, + (globalVertexIdx.y - ny_min) * dsy, + (globalVertexIdx.z - nz_min) * dsz}; + const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), + DCONST_REAL(AC_sink_pos_y), + DCONST_REAL(AC_sink_pos_z)}; + // Here I'm trying to make the accretion profile adjustable within astaroth.conf, i.e., making it possible to + // choose how many "cells" around the sink particle we want to accrete mass from. + const Scalar profile = DCONST_REAL(AC_accretion_range) * dsx; + if ((grid_pos - sink_pos) <= profile){ + + } +// I'm still trying to figure out what to put in if statement when the cell is within the range we set +// and what should this kernel return. + return +} + + +update_accretion_buffer(){ + + + + + + + } #endif //TODO: basic structure of this part is as follows diff --git a/config/astaroth.conf b/config/astaroth.conf index b41d7dc..4a127db 100644 --- a/config/astaroth.conf +++ b/config/astaroth.conf @@ -56,6 +56,10 @@ AC_sink_pos_z = 3.14 AC_M_sink_Msun = 1.0 AC_soft = 0.12 +// Accretion Parameters +// profile_range is multiple of dsx +AC_profile_range = 2.0 + // Physical properties of the domain AC_unit_velocity = 1.0 AC_unit_density = 1.0 From 3adec853df85f0b155d90d14539249948840124c Mon Sep 17 00:00:00 2001 From: JackHsu Date: Wed, 7 Aug 2019 13:59:12 +0800 Subject: [PATCH 35/87] made changed to accretion_profile function, still not fully finished but close. --- acc/mhd_solver/stencil_process.sps | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 1bbf9ff..384ecc9 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -79,7 +79,6 @@ sink_gravity(int3 globalVertexIdx){ -// Now this is more of a suedo-code, just write out some intuitions. #if LSINK Scalar truelove_density(in Scalar lnrho){ @@ -90,7 +89,7 @@ truelove_density(in Scalar lnrho){ Scalar accrection_rho = rho - TJ_rho; if (accrection_rho < 0){ - accrection_rho = Scalar(0); + accrection_rho = Scalar(0); } return accretion_rho; @@ -98,21 +97,21 @@ truelove_density(in Scalar lnrho){ accretion_profile(int3 globalVertexIdx){ + // ONE QUESTION: do I need to define grid_pos, sink_pos and distance again + // if the sink_gravity kernel will also be called once LSINK swtich is on? Seems redundant. const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, (globalVertexIdx.y - ny_min) * dsy, (globalVertexIdx.z - nz_min) * dsz}; const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), DCONST_REAL(AC_sink_pos_y), DCONST_REAL(AC_sink_pos_z)}; - // Here I'm trying to make the accretion profile adjustable within astaroth.conf, i.e., making it possible to - // choose how many "cells" around the sink particle we want to accrete mass from. - const Scalar profile = DCONST_REAL(AC_accretion_range) * dsx; - if ((grid_pos - sink_pos) <= profile){ - + const Scalar profile_range = DCONST_REAL(AC_accretion_range) * dsx; + const Scalar accretion_distance = length(grid_pos - sink_pos); + if ((accretion_distance) <= profile_range){ + // calculate accretion according to chosen criterion for the grid cell. + accretion = accretion_rho * dsx * dsy * dsz; } -// I'm still trying to figure out what to put in if statement when the cell is within the range we set -// and what should this kernel return. - return + return accretion;// the returned value is effectively mass, doesn't seem right since MIIKKA said mass will be summed up in vertex buffer. But I'll keep it as it untill we discuss this. } From 2f14bb2a30c2fe5043744fc2d443c2a5ce03cc4d Mon Sep 17 00:00:00 2001 From: JackHsu Date: Wed, 7 Aug 2019 17:14:26 +0800 Subject: [PATCH 36/87] Finished accretion_profile function and started a draft of update_accretion_buffer. --- acc/mhd_solver/stencil_process.sps | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 384ecc9..f54cc75 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -85,7 +85,7 @@ truelove_density(in Scalar lnrho){ const Scalar rho = exp(lnrho); const Scalar Jeans_length_squared = (M_PI * cs2_sound) / (AC_G_const * rho); const Scalar TJ_rho = ((M_PI) * ((dsx * dsx) / Jeans_length_squared) * cs2_sound) / (AC_G_const * dsx * dsx); - + //TODO: dsx will cancel out, deal with it later for optimization. Scalar accrection_rho = rho - TJ_rho; if (accrection_rho < 0){ @@ -96,8 +96,8 @@ truelove_density(in Scalar lnrho){ } -accretion_profile(int3 globalVertexIdx){ - // ONE QUESTION: do I need to define grid_pos, sink_pos and distance again +accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ + // QUESTION: do I need to define grid_pos, sink_pos and distance again // if the sink_gravity kernel will also be called once LSINK swtich is on? Seems redundant. const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, (globalVertexIdx.y - ny_min) * dsy, @@ -105,17 +105,22 @@ accretion_profile(int3 globalVertexIdx){ const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), DCONST_REAL(AC_sink_pos_y), DCONST_REAL(AC_sink_pos_z)}; - const Scalar profile_range = DCONST_REAL(AC_accretion_range) * dsx; + const Scalar profile_range = DCONST_REAL(AC_accretion_range); const Scalar accretion_distance = length(grid_pos - sink_pos); if ((accretion_distance) <= profile_range){ // calculate accretion according to chosen criterion for the grid cell. - accretion = accretion_rho * dsx * dsy * dsz; + accretion = truelove_density(lnrho); + } else { + accretion = Scalar(0.0); } return accretion;// the returned value is effectively mass, doesn't seem right since MIIKKA said mass will be summed up in vertex buffer. But I'll keep it as it untill we discuss this. } update_accretion_buffer(){ +// 1. reduce accretion density from the density field. +// 2. Add the accretion mass, which is calculated from accretion density times volume of each cell and sum them into accretion buffer. + @@ -391,6 +396,11 @@ in Scalar tt = VTXBUF_TEMPERATURE; out Scalar out_tt = VTXBUF_TEMPERATURE; #endif +#if LSINK +in Scalar accretion = VTXBUF_ACCRETION; +out Scalar out_accretion = VTXBUF_ACCRETION; +#endif + Kernel void solve(Scalar dt) { out_lnrho = rk3(out_lnrho, lnrho, continuity(uu, lnrho), dt); From e5540f62785c9e41df050e8b914f796c4d38f8dc Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 8 Aug 2019 14:08:42 +0800 Subject: [PATCH 37/87] added some vertex buffer stuff, not completed. --- acc/mhd_solver/stencil_process.sps | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 0d0fbad..446d253 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -95,7 +95,7 @@ truelove_density(in Scalar lnrho){ return accretion_rho; } - +Scalar accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ // QUESTION: do I need to define grid_pos, sink_pos and distance again // if the sink_gravity kernel will also be called once LSINK swtich is on? Seems redundant. @@ -109,25 +109,24 @@ accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ const Scalar accretion_distance = length(grid_pos - sink_pos); if ((accretion_distance) <= profile_range){ // calculate accretion according to chosen criterion for the grid cell. - accretion = truelove_density(lnrho); + accretion_density = truelove_density(lnrho); } else { - accretion = Scalar(0.0); + accretion_density = Scalar(0.0); } - return accretion;// the returned value is effectively mass, doesn't seem right since MIIKKA said mass will be summed up in vertex buffer. But I'll keep it as it untill we discuss this. + return accretion_density; } - - -update_accretion_buffer(){ -// 1. reduce accretion density from the density field. +// Note for update_accretion_buffer: 1. reduce accretion density from the density field. // 2. Add the accretion mass, which is calculated from accretion density times volume of each cell and sum them into accretion buffer. +Scalar +update_accretion_buffer(in Scalar lnrho, out Scalar out_accretion){ + lnrho = log(exp(lnrho) - accretion_profile(lnrho)); + // This subtracts the accretion_density from the density field. + out_accretion = Scalar (0.0); //Initilize the buffer? + out_accretion = out_accretion + (accretion_profile(lnrho) * dsx * dsy * dsz); + // Not sure if this is correct, but it's suppose to add the accretion "mass" into vertex buffer and sum them all up. + - - - - - - - + return } #endif //TODO: basic structure of this part is as follows From c1b99b2b377e0c9d213b3d3b6aeebac7530f3027 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 8 Aug 2019 15:03:42 +0800 Subject: [PATCH 38/87] made step-wise buffer update. --- acc/mhd_solver/stencil_process.sps | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 446d253..65907c4 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -115,19 +115,7 @@ accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ } return accretion_density; } -// Note for update_accretion_buffer: 1. reduce accretion density from the density field. -// 2. Add the accretion mass, which is calculated from accretion density times volume of each cell and sum them into accretion buffer. -Scalar -update_accretion_buffer(in Scalar lnrho, out Scalar out_accretion){ - lnrho = log(exp(lnrho) - accretion_profile(lnrho)); - // This subtracts the accretion_density from the density field. - out_accretion = Scalar (0.0); //Initilize the buffer? - out_accretion = out_accretion + (accretion_profile(lnrho) * dsx * dsy * dsz); - // Not sure if this is correct, but it's suppose to add the accretion "mass" into vertex buffer and sum them all up. - - return -} #endif //TODO: basic structure of this part is as follows // update_accretion_buffer() <--> accretion_profile() <--> truelove_density() @@ -426,4 +414,10 @@ solve(Scalar dt) { out_uu = out_uu + forcing(globalVertexIdx, dt); } #endif + + #if LSINK + out_lnrho = log(exp(out_lnrho) - accretion_profile(globalVertexIdx, lnrho)); + out_accretion = accretion + (accretion_profile(globalVertexIdx,lnrho) * dsx * dsy * dsz); + #endif } + From 89128af44b58b394854a3e3d8cd4868f886d882f Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 8 Aug 2019 15:53:41 +0800 Subject: [PATCH 39/87] added update_accretion_buffer. --- acc/mhd_solver/stencil_defines.h | 1 + acc/mhd_solver/stencil_process.sps | 43 +++++++++++++++--------------- config/astaroth.conf | 2 +- 3 files changed, 24 insertions(+), 22 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index 0add153..6e22bc9 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -80,6 +80,7 @@ FUNC(AC_M_sink),\ FUNC(AC_M_sink_Msun),\ FUNC(AC_soft),\ + FUNC(AC_accretion_range),\ /* Run params */\ FUNC(AC_cdt), \ FUNC(AC_cdtv), \ diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 65907c4..fce21bf 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -82,14 +82,14 @@ sink_gravity(int3 globalVertexIdx){ #if LSINK Scalar truelove_density(in Scalar lnrho){ - const Scalar rho = exp(lnrho); + const Scalar rho = exp(value(lnrho)); const Scalar Jeans_length_squared = (M_PI * cs2_sound) / (AC_G_const * rho); const Scalar TJ_rho = ((M_PI) * ((dsx * dsx) / Jeans_length_squared) * cs2_sound) / (AC_G_const * dsx * dsx); //TODO: dsx will cancel out, deal with it later for optimization. - Scalar accrection_rho = rho - TJ_rho; - if (accrection_rho < 0){ - accrection_rho = Scalar(0); + Scalar accretion_rho = rho - TJ_rho; + if (accretion_rho < 0){ + accretion_rho = Scalar(0); } return accretion_rho; @@ -97,23 +97,24 @@ truelove_density(in Scalar lnrho){ Scalar accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ - // QUESTION: do I need to define grid_pos, sink_pos and distance again - // if the sink_gravity kernel will also be called once LSINK swtich is on? Seems redundant. - const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, - (globalVertexIdx.y - ny_min) * dsy, - (globalVertexIdx.z - nz_min) * dsz}; - const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), - DCONST_REAL(AC_sink_pos_y), - DCONST_REAL(AC_sink_pos_z)}; - const Scalar profile_range = DCONST_REAL(AC_accretion_range); - const Scalar accretion_distance = length(grid_pos - sink_pos); - if ((accretion_distance) <= profile_range){ + // QUESTION: do I need to define grid_pos, sink_pos and distance again + // if the sink_gravity kernel will also be called once LSINK swtich is on? Seems redundant. + const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, + (globalVertexIdx.y - ny_min) * dsy, + (globalVertexIdx.z - nz_min) * dsz}; + const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), + DCONST_REAL(AC_sink_pos_y), + DCONST_REAL(AC_sink_pos_z)}; + const Scalar profile_range = DCONST_REAL(AC_accretion_range); + const Scalar accretion_distance = length(grid_pos - sink_pos); + Scalar accretion_density; + if ((accretion_distance) <= profile_range){ // calculate accretion according to chosen criterion for the grid cell. - accretion_density = truelove_density(lnrho); - } else { - accretion_density = Scalar(0.0); - } - return accretion_density; + accretion_density = truelove_density(lnrho); + } else { + accretion_density = Scalar(0.0); + } + return accretion_density; } #endif @@ -417,7 +418,7 @@ solve(Scalar dt) { #if LSINK out_lnrho = log(exp(out_lnrho) - accretion_profile(globalVertexIdx, lnrho)); - out_accretion = accretion + (accretion_profile(globalVertexIdx,lnrho) * dsx * dsy * dsz); + out_accretion = value(accretion) + (accretion_profile(globalVertexIdx,lnrho) * dsx * dsy * dsz); #endif } diff --git a/config/astaroth.conf b/config/astaroth.conf index 4a127db..a003c8b 100644 --- a/config/astaroth.conf +++ b/config/astaroth.conf @@ -58,7 +58,7 @@ AC_soft = 0.12 // Accretion Parameters // profile_range is multiple of dsx -AC_profile_range = 2.0 +AC_accretion_range = 2.0 // Physical properties of the domain AC_unit_velocity = 1.0 From b782ead4f39ecedc265ce1b8d9726f683894f77a Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 12 Aug 2019 12:34:38 +0800 Subject: [PATCH 40/87] Now initilize VTXBUFF_ACCRETION to 0.0, and accretion now works as expected. --- src/standalone/model/host_memory.cc | 2 +- src/standalone/model/host_memory.h | 2 ++ src/standalone/simulation.cc | 3 ++- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index 4697690..94dbb5a 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -71,7 +71,7 @@ acmesh_create(const AcMeshInfo& mesh_info) return mesh; } -static void +void vertex_buffer_set(const VertexBufferHandle& key, const AcReal& val, AcMesh* mesh) { const int n = acVertexBufferSize(mesh->info); diff --git a/src/standalone/model/host_memory.h b/src/standalone/model/host_memory.h index e2958cd..c724e5e 100644 --- a/src/standalone/model/host_memory.h +++ b/src/standalone/model/host_memory.h @@ -48,6 +48,8 @@ extern const char* init_type_names[]; // Defined in host_memory.cc AcMesh* acmesh_create(const AcMeshInfo& mesh_info); +void vertex_buffer_set(const VertexBufferHandle& key, const AcReal& val, AcMesh* mesh); + void acmesh_clear(AcMesh* mesh); void acmesh_init_to(const InitType& type, AcMesh* mesh); diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index f4f7b36..8159084 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -96,7 +96,6 @@ write_mesh_info(const AcMeshInfo* config) fprintf(infotxt, "real AC_sink_pos_z %e \n", (double)config->real_params[AC_sink_pos_z]); fprintf(infotxt, "real AC_M_sink %e \n", (double)config->real_params[AC_M_sink]); fprintf(infotxt, "real AC_soft %e \n", (double)config->real_params[AC_soft]); - fprintf(infotxt, "real AC_G_const %e \n", (double)config->real_params[AC_G_const]); fclose(infotxt); @@ -196,6 +195,8 @@ run_simulation(void) // TODO: This need to be possible to define in astaroth.conf acmesh_init_to(INIT_TYPE_GAUSSIAN_RADIAL_EXPL, mesh); + vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); + acInit(mesh_info); acLoad(*mesh); From 8c7176d702b1466e266c52844755c19b0d99c5d6 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 12 Aug 2019 19:02:22 +0800 Subject: [PATCH 41/87] Completed function to sum VTXBUF_ACCRETION and updates mass of sink particle. Needs further work with crashing problem. --- acc/mhd_solver/stencil_defines.h | 1 + src/standalone/config_loader.cc | 2 ++ src/standalone/simulation.cc | 7 +++++++ 3 files changed, 10 insertions(+) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index 6e22bc9..26e7ffd 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -78,6 +78,7 @@ FUNC(AC_sink_pos_y),\ FUNC(AC_sink_pos_z),\ FUNC(AC_M_sink),\ + FUNC(AC_M_sink_init),\ FUNC(AC_M_sink_Msun),\ FUNC(AC_soft),\ FUNC(AC_accretion_range),\ diff --git a/src/standalone/config_loader.cc b/src/standalone/config_loader.cc index 95e4796..bee7050 100644 --- a/src/standalone/config_loader.cc +++ b/src/standalone/config_loader.cc @@ -150,6 +150,8 @@ update_config(AcMeshInfo* config) config->real_params[AC_M_sink] = config->real_params[AC_M_sink_Msun] * M_sun / config->real_params[AC_unit_mass]; + config->real_params[AC_M_sink_init] = config->real_params[AC_M_sink_Msun] * M_sun / + config->real_params[AC_unit_mass]; config->real_params[AC_G_const] = G_CONST_CGS / ((config->real_params[AC_unit_velocity] * config->real_params[AC_unit_velocity]) / diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 8159084..b9bf199 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -240,9 +240,16 @@ run_simulation(void) // acUpdate_sink_particle() will do the similar trick to the device. /* Step the simulation */ + AcReal accreted_mass = 0.0; for (int i = 1; i < max_steps; ++i) { const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); const AcReal dt = host_timestep(umax, mesh_info); + const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); + accreted_mass = accreted_mass + sum_mass; + AcReal sink_mass = AC_M_sink_init + accreted_mass; + printf("sink mass is: %e\n", sink_mass); + printf("accreted mass is: %e\n", accreted_mass); + acLoadDeviceConstant(AC_M_sink, sink_mass); #if LFORCING const ForcingParams forcing_params = generateForcingParams(mesh_info); From 870eb32bb3414898c69caafd5e9f98291df3ca35 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 13 Aug 2019 13:51:46 +0800 Subject: [PATCH 42/87] Added some preprocessing directives for accretion --- src/standalone/simulation.cc | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index b9bf199..c634019 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -195,7 +195,9 @@ run_simulation(void) // TODO: This need to be possible to define in astaroth.conf acmesh_init_to(INIT_TYPE_GAUSSIAN_RADIAL_EXPL, mesh); +#if LACCRETION vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); +#endif acInit(mesh_info); acLoad(*mesh); @@ -244,12 +246,15 @@ run_simulation(void) for (int i = 1; i < max_steps; ++i) { const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); const AcReal dt = host_timestep(umax, mesh_info); + +#if LACCRETION const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); - accreted_mass = accreted_mass + sum_mass; + accreted_mass = accreted_mass + sum_mass; AcReal sink_mass = AC_M_sink_init + accreted_mass; printf("sink mass is: %e\n", sink_mass); printf("accreted mass is: %e\n", accreted_mass); acLoadDeviceConstant(AC_M_sink, sink_mass); +#endif #if LFORCING const ForcingParams forcing_params = generateForcingParams(mesh_info); From d79dd428e7cd76c6cc6aec131c4292f61428330f Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 13 Aug 2019 14:03:36 +0800 Subject: [PATCH 43/87] Corrections to the previous. --- src/standalone/simulation.cc | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index c634019..fc2d901 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -195,7 +195,7 @@ run_simulation(void) // TODO: This need to be possible to define in astaroth.conf acmesh_init_to(INIT_TYPE_GAUSSIAN_RADIAL_EXPL, mesh); -#if LACCRETION +#if LSINK vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); #endif @@ -242,21 +242,23 @@ run_simulation(void) // acUpdate_sink_particle() will do the similar trick to the device. /* Step the simulation */ +#if LSINK AcReal accreted_mass = 0.0; +#endif for (int i = 1; i < max_steps; ++i) { const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); const AcReal dt = host_timestep(umax, mesh_info); -#if LACCRETION +#if LSINK const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); accreted_mass = accreted_mass + sum_mass; AcReal sink_mass = AC_M_sink_init + accreted_mass; - printf("sink mass is: %e\n", sink_mass); - printf("accreted mass is: %e\n", accreted_mass); + printf("sink mass is: %e \n", sink_mass); + printf("accreted mass is: %e \n", accreted_mass); acLoadDeviceConstant(AC_M_sink, sink_mass); #endif -#if LFORCING +#if LSINK const ForcingParams forcing_params = generateForcingParams(mesh_info); loadForcingParamsToDevice(forcing_params); #endif From ff59431d6518ff67e1540a646578429f80c55687 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 13 Aug 2019 17:43:52 +0800 Subject: [PATCH 44/87] Added modularized term for accretion range, which is some wave function, and module that'll allow time-dependent accretion. --- acc/mhd_solver/stencil_process.sps | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index ce2e434..247c739 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -108,15 +108,25 @@ accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ const Scalar profile_range = DCONST_REAL(AC_accretion_range); const Scalar accretion_distance = length(grid_pos - sink_pos); Scalar accretion_density; - if ((accretion_distance) <= profile_range){ - // calculate accretion according to chosen criterion for the grid cell. - accretion_density = truelove_density(lnrho); - } else { - accretion_density = Scalar(0.0); - } +// if ((accretion_distance) <= profile_range){ +// // calculate accretion according to chosen criterion for the grid cell. +// accretion_density = truelove_density(lnrho); +// } else { +// accretion_density = Scalar(0.0); +// } +// return accretion_density; + + // multiplying the truelove density by a wave function to avoid step-function like accretion profile. + const Scalar weight = exp(-(accretion_distance/profile_range)); + const Scalar rate = truelove_density(lnrho); + accretion_density = weight * rate; + return accretion_density; + + } + #endif //TODO: basic structure of this part is as follows // update_accretion_buffer() <--> accretion_profile() <--> truelove_density() From 927a5e74f274a6b26fbed65ea883aff2f0c33b8c Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 13 Aug 2019 18:06:29 +0800 Subject: [PATCH 45/87] Made accretion time-dependent now, need to come up with better accretion crition than truelove. --- acc/mhd_solver/stencil_process.sps | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 247c739..2e0b2fe 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -423,8 +423,11 @@ solve(Scalar dt) { #endif #if LSINK - out_lnrho = log(exp(out_lnrho) - accretion_profile(globalVertexIdx, lnrho)); - out_accretion = value(accretion) + (accretion_profile(globalVertexIdx,lnrho) * dsx * dsy * dsz); +// out_lnrho = log(exp(out_lnrho) - accretion_profile(globalVertexIdx, lnrho)); +// out_accretion = value(accretion) + (accretion_profile(globalVertexIdx,lnrho) * dsx * dsy * dsz); + out_accretion = rk3(out_accretion, accretion, accretion_profile(globalVertexIdx, lnrho), dt);// unit now is rho! + out_lnrho = log(exp(out_lnrho) - out_accretion); + out_accretion = out_accretion * dsx * dsy * dsz;// unit is now mass! #endif } From 0587d08b01f7e2ee6bfad544b361ca97bc35c96b Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 13 Aug 2019 18:31:57 +0800 Subject: [PATCH 46/87] Had some rough draft of accretion criterion. --- acc/mhd_solver/stencil_process.sps | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 2e0b2fe..7074a4b 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -118,7 +118,10 @@ accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ // multiplying the truelove density by a wave function to avoid step-function like accretion profile. const Scalar weight = exp(-(accretion_distance/profile_range)); - const Scalar rate = truelove_density(lnrho); +// const Scalar rate = truelove_density(lnrho); + const Scalar B = Scalar(3.0); + const Scalar k = Scalar(2.0); + const Scalar rate = B * (pow(sink_mass, k) / (dsx * dsy * dsz)); accretion_density = weight * rate; return accretion_density; From 56c51e53150b169eb699895f58474ea4572e1b14 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 13 Aug 2019 18:36:12 +0800 Subject: [PATCH 47/87] fixed the undefined error in compilation. --- acc/mhd_solver/stencil_process.sps | 1 + 1 file changed, 1 insertion(+) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 7074a4b..440ffe3 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -118,6 +118,7 @@ accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ // multiplying the truelove density by a wave function to avoid step-function like accretion profile. const Scalar weight = exp(-(accretion_distance/profile_range)); + const Scalar sink_mass = DCONST_REAL(AC_M_sink); // const Scalar rate = truelove_density(lnrho); const Scalar B = Scalar(3.0); const Scalar k = Scalar(2.0); From c7df5be0681fe4b455e539c77aba827de41c7498 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Wed, 14 Aug 2019 18:43:22 +0800 Subject: [PATCH 48/87] tried new accretion profile, and added some to-do's. --- acc/mhd_solver/stencil_process.sps | 28 ++++++++++++++++------------ 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 440ffe3..145d0c0 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -81,7 +81,7 @@ sink_gravity(int3 globalVertexIdx){ #if LSINK Scalar -truelove_density(in Scalar lnrho){ +truelove_density(in ScalarField lnrho){ const Scalar rho = exp(value(lnrho)); const Scalar Jeans_length_squared = (M_PI * cs2_sound) / (AC_G_const * rho); const Scalar TJ_rho = ((M_PI) * ((dsx * dsx) / Jeans_length_squared) * cs2_sound) / (AC_G_const * dsx * dsx); @@ -96,7 +96,7 @@ truelove_density(in Scalar lnrho){ } Scalar -accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ +accretion_profile(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ // QUESTION: do I need to define grid_pos, sink_pos and distance again // if the sink_gravity kernel will also be called once LSINK swtich is on? Seems redundant. const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, @@ -119,18 +119,20 @@ accretion_profile(int3 globalVertexIdx, in Scalar lnrho){ // multiplying the truelove density by a wave function to avoid step-function like accretion profile. const Scalar weight = exp(-(accretion_distance/profile_range)); const Scalar sink_mass = DCONST_REAL(AC_M_sink); + const Scalar lnrho_min = Scalar(-10.0); // const Scalar rate = truelove_density(lnrho); - const Scalar B = Scalar(3.0); - const Scalar k = Scalar(2.0); - const Scalar rate = B * (pow(sink_mass, k) / (dsx * dsy * dsz)); - accretion_density = weight * rate; - +// const Scalar B = Scalar(0.5); +// const Scalar k = Scalar(1.5); +// const Scalar rate = B * (pow(sink_mass, k) / (dsx * dsy * dsz)); + Scalar rate; + if (value(lnrho) > lnrho_min) { + rate = exp(value(lnrho)) / dt; + } else { + rate = exp(lnrho_min) / dt; + } + accretion_density = weight * rate ; return accretion_density; - - } - - #endif //TODO: basic structure of this part is as follows // update_accretion_buffer() <--> accretion_profile() <--> truelove_density() @@ -429,9 +431,11 @@ solve(Scalar dt) { #if LSINK // out_lnrho = log(exp(out_lnrho) - accretion_profile(globalVertexIdx, lnrho)); // out_accretion = value(accretion) + (accretion_profile(globalVertexIdx,lnrho) * dsx * dsy * dsz); - out_accretion = rk3(out_accretion, accretion, accretion_profile(globalVertexIdx, lnrho), dt);// unit now is rho! + out_accretion = rk3(out_accretion, accretion, accretion_profile(globalVertexIdx, lnrho, dt), dt);// unit now is rho! out_lnrho = log(exp(out_lnrho) - out_accretion); out_accretion = out_accretion * dsx * dsy * dsz;// unit is now mass! + //TODO: reset accretion buffer in the beginning. + //TODO: implement accretion correction to contiunity equation and momentum equation. #endif } From a5bb56873a45d5808a21dc6dfa3a173ed5890208 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 15 Aug 2019 17:51:39 +0800 Subject: [PATCH 49/87] Now resets accretion buffer at every step. --- acc/mhd_solver/stencil_process.sps | 1 - src/standalone/simulation.cc | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 145d0c0..e05c3f9 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -434,7 +434,6 @@ solve(Scalar dt) { out_accretion = rk3(out_accretion, accretion, accretion_profile(globalVertexIdx, lnrho, dt), dt);// unit now is rho! out_lnrho = log(exp(out_lnrho) - out_accretion); out_accretion = out_accretion * dsx * dsy * dsz;// unit is now mass! - //TODO: reset accretion buffer in the beginning. //TODO: implement accretion correction to contiunity equation and momentum equation. #endif } diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index fc2d901..cf5d05e 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -256,9 +256,10 @@ run_simulation(void) printf("sink mass is: %e \n", sink_mass); printf("accreted mass is: %e \n", accreted_mass); acLoadDeviceConstant(AC_M_sink, sink_mass); + vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); #endif -#if LSINK +#if LFORCING const ForcingParams forcing_params = generateForcingParams(mesh_info); loadForcingParamsToDevice(forcing_params); #endif From 6c50c0a40ed3af9ac13aa7a8ccf81209697e2630 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 15 Aug 2019 19:23:26 +0800 Subject: [PATCH 50/87] sink effetc in equations. --- acc/mhd_solver/stencil_process.sps | 39 +++++++++++++++++------------- 1 file changed, 22 insertions(+), 17 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index e05c3f9..8f2ccd7 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -45,16 +45,6 @@ gradients(in VectorField uu) return (Matrix){gradient(uu.x), gradient(uu.y), gradient(uu.z)}; } -Scalar -continuity(in VectorField uu, in ScalarField lnrho) { - return -dot(value(uu), gradient(lnrho)) -#if LUPWD - //This is a corrective hyperdiffusion term for upwinding. - + upwd_der6(uu, lnrho) -#endif - - divergence(uu); -} - #if LSINK Vector sink_gravity(int3 globalVertexIdx){ @@ -134,13 +124,27 @@ accretion_profile(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ return accretion_density; } #endif -//TODO: basic structure of this part is as follows -// update_accretion_buffer() <--> accretion_profile() <--> truelove_density() + + + +Scalar +continuity(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, Scalar dt) { + return -dot(value(uu), gradient(lnrho)) +#if LUPWD + //This is a corrective hyperdiffusion term for upwinding. + + upwd_der6(uu, lnrho) +#endif +#if LSINK + - accretion_profile(globalVertexIdx, lnrho, dt) / exp(value(lnrho)) +#endif + - divergence(uu); +} + #if LENTROPY Vector -momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, in ScalarField ss, in VectorField aa) { +momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, in ScalarField ss, in VectorField aa, Scalar dt) { const Matrix S = stress_tensor(uu); const Scalar cs2 = cs2_sound * exp(gamma * value(ss) / cp_sound + (gamma - 1) * (value(lnrho) - lnrho0)); const Vector j = (Scalar(1.) / mu0) * (gradient_of_divergence(aa) - laplace_vec(aa)); // Current density @@ -160,7 +164,9 @@ momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, in Scala ) + zeta * gradient_of_divergence(uu) #if LSINK - + sink_gravity(globalVertexIdx); + + sink_gravity(globalVertexIdx) + - accretion_profile(globalVertexIdx, lnrho, dt) / exp(value(lnrho)) + * value(uu); //TODO: Confirm #else ; #endif @@ -406,14 +412,14 @@ out Scalar out_accretion = VTXBUF_ACCRETION; Kernel void solve(Scalar dt) { - out_lnrho = rk3(out_lnrho, lnrho, continuity(uu, lnrho), dt); + out_lnrho = rk3(out_lnrho, lnrho, continuity(globalVertexIdx, uu, lnrho, dt), dt); #if LMAGNETIC out_aa = rk3(out_aa, aa, induction(uu, aa), dt); #endif #if LENTROPY - out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, ss, aa), dt); + out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, ss, aa, dt), dt); out_ss = rk3(out_ss, ss, entropy(ss, uu, lnrho, aa), dt); #elif LTEMPERATURE out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, tt), dt); @@ -437,4 +443,3 @@ solve(Scalar dt) { //TODO: implement accretion correction to contiunity equation and momentum equation. #endif } - From 60f2af0971eaec4ead808ef9144cf26e6942488f Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Fri, 16 Aug 2019 09:52:12 +0800 Subject: [PATCH 51/87] Renamed accretion_profile -> sink_accretion. More intuitive. --- acc/mhd_solver/stencil_process.sps | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 8f2ccd7..3f17d92 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -86,9 +86,7 @@ truelove_density(in ScalarField lnrho){ } Scalar -accretion_profile(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ - // QUESTION: do I need to define grid_pos, sink_pos and distance again - // if the sink_gravity kernel will also be called once LSINK swtich is on? Seems redundant. +sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, (globalVertexIdx.y - ny_min) * dsy, (globalVertexIdx.z - nz_min) * dsz}; @@ -135,7 +133,7 @@ continuity(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, Scalar + upwd_der6(uu, lnrho) #endif #if LSINK - - accretion_profile(globalVertexIdx, lnrho, dt) / exp(value(lnrho)) + - sink_accretion(globalVertexIdx, lnrho, dt) / exp(value(lnrho)) #endif - divergence(uu); } @@ -165,7 +163,7 @@ momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, in Scala + zeta * gradient_of_divergence(uu) #if LSINK + sink_gravity(globalVertexIdx) - - accretion_profile(globalVertexIdx, lnrho, dt) / exp(value(lnrho)) + - sink_accretion(globalVertexIdx, lnrho, dt) / exp(value(lnrho)) * value(uu); //TODO: Confirm #else ; @@ -435,9 +433,9 @@ solve(Scalar dt) { #endif #if LSINK -// out_lnrho = log(exp(out_lnrho) - accretion_profile(globalVertexIdx, lnrho)); -// out_accretion = value(accretion) + (accretion_profile(globalVertexIdx,lnrho) * dsx * dsy * dsz); - out_accretion = rk3(out_accretion, accretion, accretion_profile(globalVertexIdx, lnrho, dt), dt);// unit now is rho! +// out_lnrho = log(exp(out_lnrho) - sink_accretion(globalVertexIdx, lnrho)); +// out_accretion = value(accretion) + (sink_accretion(globalVertexIdx,lnrho) * dsx * dsy * dsz); + out_accretion = rk3(out_accretion, accretion, sink_accretion(globalVertexIdx, lnrho, dt), dt);// unit now is rho! out_lnrho = log(exp(out_lnrho) - out_accretion); out_accretion = out_accretion * dsx * dsy * dsz;// unit is now mass! //TODO: implement accretion correction to contiunity equation and momentum equation. From 53bd3d4aa449e898a37bb02998b0b7f498e53995 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Fri, 16 Aug 2019 11:13:21 +0800 Subject: [PATCH 52/87] Correction factor for the equation. --- acc/mhd_solver/stencil_process.sps | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 3f17d92..2103454 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -162,9 +162,12 @@ momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, in Scala ) + zeta * gradient_of_divergence(uu) #if LSINK - + sink_gravity(globalVertexIdx) - - sink_accretion(globalVertexIdx, lnrho, dt) / exp(value(lnrho)) - * value(uu); //TODO: Confirm + //Gravity term + + sink_gravity(globalVertexIdx) + //Corresponding loss of momentum + - (Scalar(1.0) / Scalar( (dsx*dsy*dsz) * exp(value(lnrho)))) // Correction factor by unit mass + * (sink_accretion(globalVertexIdx, lnrho, dt) * value(uu)) // As in Lee et al.(2014) + ; #else ; #endif From 42ba2ee5aa37010bd962653f9b9201282da553e4 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Fri, 16 Aug 2019 11:14:26 +0800 Subject: [PATCH 53/87] For live rendering. --- src/standalone/renderer.cc | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/standalone/renderer.cc b/src/standalone/renderer.cc index 2e8945f..cbe659d 100644 --- a/src/standalone/renderer.cc +++ b/src/standalone/renderer.cc @@ -359,6 +359,10 @@ run_renderer(void) AcMesh* mesh = acmesh_create(mesh_info); acmesh_init_to(InitType(init_type), mesh); +#if LSINK + vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); +#endif + acInit(mesh_info); acLoad(*mesh); @@ -375,6 +379,9 @@ run_renderer(void) int steps = 0; k_slice = mesh->info.int_params[AC_mz] / 2; k_slice_max = mesh->info.int_params[AC_mz]; +#if LSINK + AcReal accreted_mass = 0.0; +#endif while (running(mesh)) { /* Input */ @@ -386,6 +393,16 @@ run_renderer(void) const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); const AcReal dt = host_timestep(umax, mesh_info); +#if LSINK + const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); + accreted_mass = accreted_mass + sum_mass; + AcReal sink_mass = AC_M_sink_init + accreted_mass; + printf("sink mass is: %e \n", sink_mass); + printf("accreted mass is: %e \n", accreted_mass); + acLoadDeviceConstant(AC_M_sink, sink_mass); + vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); +#endif + #if LFORCING const ForcingParams forcing_params = generateForcingParams(mesh->info); loadForcingParamsToDevice(forcing_params); From a8fbced89d0eaf2d3dc960df72aa96b9db8a01ee Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Fri, 16 Aug 2019 11:36:39 +0800 Subject: [PATCH 54/87] Error correction. --- acc/mhd_solver/stencil_process.sps | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 2103454..f2c99dc 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -438,9 +438,12 @@ solve(Scalar dt) { #if LSINK // out_lnrho = log(exp(out_lnrho) - sink_accretion(globalVertexIdx, lnrho)); // out_accretion = value(accretion) + (sink_accretion(globalVertexIdx,lnrho) * dsx * dsy * dsz); - out_accretion = rk3(out_accretion, accretion, sink_accretion(globalVertexIdx, lnrho, dt), dt);// unit now is rho! - out_lnrho = log(exp(out_lnrho) - out_accretion); - out_accretion = out_accretion * dsx * dsy * dsz;// unit is now mass! + out_accretion = rk3(out_accretion, accretion, sink_accretion(globalVertexIdx, lnrho, dt), dt);// unit now is rho! +// out_lnrho = log(exp(out_lnrho) - out_accretion); + + if (step_number == 2) { + out_accretion = out_accretion * dsx * dsy * dsz;// unit is now mass! + } //TODO: implement accretion correction to contiunity equation and momentum equation. #endif } From f921840505802219efffb3966e890f355b6d163b Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Fri, 16 Aug 2019 11:44:41 +0800 Subject: [PATCH 55/87] Changed to step function --- acc/mhd_solver/stencil_process.sps | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index f2c99dc..58ba721 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -105,9 +105,18 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ // return accretion_density; // multiplying the truelove density by a wave function to avoid step-function like accretion profile. - const Scalar weight = exp(-(accretion_distance/profile_range)); + + Scalar weight; +// const Scalar weight = exp(-(accretion_distance/profile_range)); + // Step function weighting + if ((accretion_distance) <= profile_range){ + weight = Scalar(1.0); + } else { + weight = Scalar(0.0); + } + const Scalar sink_mass = DCONST_REAL(AC_M_sink); - const Scalar lnrho_min = Scalar(-10.0); + const Scalar lnrho_min = Scalar(-10.0); //TODO Define from astaroth.conf // const Scalar rate = truelove_density(lnrho); // const Scalar B = Scalar(0.5); // const Scalar k = Scalar(1.5); From 1bfb0390ad06d319671cc845e22c2f085dca68a0 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Fri, 16 Aug 2019 13:29:34 +0800 Subject: [PATCH 56/87] Seemingly reasonable sink for both density and velocity. --- acc/mhd_solver/stencil_process.sps | 40 +++++++++++++++++++++++++++--- config/templates/sinktest.conf | 4 +++ 2 files changed, 40 insertions(+), 4 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 58ba721..8420f82 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -115,8 +115,8 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ weight = Scalar(0.0); } - const Scalar sink_mass = DCONST_REAL(AC_M_sink); const Scalar lnrho_min = Scalar(-10.0); //TODO Define from astaroth.conf +// const Scalar sink_mass = DCONST_REAL(AC_M_sink); // const Scalar rate = truelove_density(lnrho); // const Scalar B = Scalar(0.5); // const Scalar k = Scalar(1.5); @@ -125,11 +125,43 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ if (value(lnrho) > lnrho_min) { rate = exp(value(lnrho)) / dt; } else { - rate = exp(lnrho_min) / dt; +// rate = exp(lnrho_min) / dt; + rate = Scalar(0.0); } accretion_density = weight * rate ; return accretion_density; } + +Vector +sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { + const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, + (globalVertexIdx.y - ny_min) * dsy, + (globalVertexIdx.z - nz_min) * dsz}; + const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), + DCONST_REAL(AC_sink_pos_y), + DCONST_REAL(AC_sink_pos_z)}; + const Scalar profile_range = DCONST_REAL(AC_accretion_range); + const Scalar accretion_distance = length(grid_pos - sink_pos); + + Vector accretion_velocity; + + Scalar weight; + // Step function weighting + if ((accretion_distance) <= profile_range){ + weight = Scalar(1.0); + } else { + weight = Scalar(0.0); + } + + Vector rate; + if (length(value(uu)) > Scalar(0.0)) { + rate = (Scalar(1.0)/dt) * value(uu); + } else { + rate = (Vector){0.0, 0.0, 0.0}; + } + accretion_velocity = weight * rate ; + return accretion_velocity; +} #endif @@ -174,8 +206,8 @@ momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, in Scala //Gravity term + sink_gravity(globalVertexIdx) //Corresponding loss of momentum - - (Scalar(1.0) / Scalar( (dsx*dsy*dsz) * exp(value(lnrho)))) // Correction factor by unit mass - * (sink_accretion(globalVertexIdx, lnrho, dt) * value(uu)) // As in Lee et al.(2014) + - //(Scalar(1.0) / Scalar( (dsx*dsy*dsz) * exp(value(lnrho)))) * // Correction factor by unit mass + sink_accretion_velocity(globalVertexIdx, uu, dt) // As in Lee et al.(2014) ; #else ; diff --git a/config/templates/sinktest.conf b/config/templates/sinktest.conf index 674f178..63ac4b8 100644 --- a/config/templates/sinktest.conf +++ b/config/templates/sinktest.conf @@ -57,6 +57,10 @@ AC_sink_pos_z = 3.14 AC_M_sink_Msun = 1e-6 AC_soft = 0.36 +// Accretion Parameters +// profile_range shoul be close to a multiple of dsx. E.g. 4*dsx +AC_accretion_range = 0.2 + // Physical properties of the domain AC_unit_velocity = 1e5 // using density estimate of 100 H2 molecules per cm^3 From 5d93d743c730296ad25f849a732712710436921c Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 19 Aug 2019 14:38:36 +0800 Subject: [PATCH 57/87] Improved sink particle stability vie Truelove criterion. --- acc/mhd_solver/stencil_process.sps | 22 +++++----------------- config/templates/sinktest.conf | 2 +- src/standalone/simulation.cc | 6 +++++- 3 files changed, 11 insertions(+), 19 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 8420f82..2cf6144 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -70,6 +70,7 @@ sink_gravity(int3 globalVertexIdx){ #if LSINK +// Give Truelove density Scalar truelove_density(in ScalarField lnrho){ const Scalar rho = exp(value(lnrho)); @@ -77,10 +78,7 @@ truelove_density(in ScalarField lnrho){ const Scalar TJ_rho = ((M_PI) * ((dsx * dsx) / Jeans_length_squared) * cs2_sound) / (AC_G_const * dsx * dsx); //TODO: dsx will cancel out, deal with it later for optimization. - Scalar accretion_rho = rho - TJ_rho; - if (accretion_rho < 0){ - accretion_rho = Scalar(0); - } + Scalar accretion_rho = TJ_rho; return accretion_rho; } @@ -96,16 +94,7 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ const Scalar profile_range = DCONST_REAL(AC_accretion_range); const Scalar accretion_distance = length(grid_pos - sink_pos); Scalar accretion_density; -// if ((accretion_distance) <= profile_range){ -// // calculate accretion according to chosen criterion for the grid cell. -// accretion_density = truelove_density(lnrho); -// } else { -// accretion_density = Scalar(0.0); -// } -// return accretion_density; - // multiplying the truelove density by a wave function to avoid step-function like accretion profile. - Scalar weight; // const Scalar weight = exp(-(accretion_distance/profile_range)); // Step function weighting @@ -115,17 +104,16 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ weight = Scalar(0.0); } - const Scalar lnrho_min = Scalar(-10.0); //TODO Define from astaroth.conf +// const Scalar lnrho_min = Scalar(-10.0); //TODO Define from astaroth.conf + const Scalar lnrho_min = log(truelove_density(lnrho)); // const Scalar sink_mass = DCONST_REAL(AC_M_sink); -// const Scalar rate = truelove_density(lnrho); // const Scalar B = Scalar(0.5); // const Scalar k = Scalar(1.5); // const Scalar rate = B * (pow(sink_mass, k) / (dsx * dsy * dsz)); Scalar rate; if (value(lnrho) > lnrho_min) { - rate = exp(value(lnrho)) / dt; + rate = (exp(value(lnrho)) - exp(lnrho_min)) / dt; } else { -// rate = exp(lnrho_min) / dt; rate = Scalar(0.0); } accretion_density = weight * rate ; diff --git a/config/templates/sinktest.conf b/config/templates/sinktest.conf index 63ac4b8..258e0a3 100644 --- a/config/templates/sinktest.conf +++ b/config/templates/sinktest.conf @@ -54,7 +54,7 @@ AC_sink_pos_x = 3.14 AC_sink_pos_y = 3.14 AC_sink_pos_z = 3.14 //AC_M_sink_Msun = 0.005 -AC_M_sink_Msun = 1e-6 +AC_M_sink_Msun = 1e-8 AC_soft = 0.36 // Accretion Parameters diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index cf5d05e..c883086 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -250,9 +250,13 @@ run_simulation(void) const AcReal dt = host_timestep(umax, mesh_info); #if LSINK + const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); accreted_mass = accreted_mass + sum_mass; - AcReal sink_mass = AC_M_sink_init + accreted_mass; + AcReal sink_mass = 0.0; + //if (i > 1000 ) { + sink_mass = AC_M_sink_init + accreted_mass; + //} printf("sink mass is: %e \n", sink_mass); printf("accreted mass is: %e \n", accreted_mass); acLoadDeviceConstant(AC_M_sink, sink_mass); From 9a1a6fef17ae81b09e1c34441991425ec2e6fa52 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Mon, 19 Aug 2019 15:38:35 +0800 Subject: [PATCH 58/87] modified the sink_mass initial value to make it stable. --- config/templates/sinktest.conf | 2 +- src/standalone/simulation.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/config/templates/sinktest.conf b/config/templates/sinktest.conf index 258e0a3..1088da3 100644 --- a/config/templates/sinktest.conf +++ b/config/templates/sinktest.conf @@ -54,7 +54,7 @@ AC_sink_pos_x = 3.14 AC_sink_pos_y = 3.14 AC_sink_pos_z = 3.14 //AC_M_sink_Msun = 0.005 -AC_M_sink_Msun = 1e-8 +AC_M_sink_Msun = 1e-10 AC_soft = 0.36 // Accretion Parameters diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index c883086..c72f1d9 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -255,7 +255,7 @@ run_simulation(void) accreted_mass = accreted_mass + sum_mass; AcReal sink_mass = 0.0; //if (i > 1000 ) { - sink_mass = AC_M_sink_init + accreted_mass; + sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; //} printf("sink mass is: %e \n", sink_mass); printf("accreted mass is: %e \n", accreted_mass); From eda83e58073867311ad03eb11bf33470974d1333 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 20 Aug 2019 12:08:06 +0800 Subject: [PATCH 59/87] Added on/off switch for forcing and accretion. Now both set to take effect in 1000 steps. --- src/standalone/simulation.cc | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index c72f1d9..167da4e 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -252,11 +252,15 @@ run_simulation(void) #if LSINK const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); - accreted_mass = accreted_mass + sum_mass; + if (i > 1000) { + accreted_mass = accreted_mass + sum_mass; + } else { + accreted_mass = 0.0; + } AcReal sink_mass = 0.0; //if (i > 1000 ) { sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; - //} + //} printf("sink mass is: %e \n", sink_mass); printf("accreted mass is: %e \n", accreted_mass); acLoadDeviceConstant(AC_M_sink, sink_mass); @@ -265,7 +269,10 @@ run_simulation(void) #if LFORCING const ForcingParams forcing_params = generateForcingParams(mesh_info); - loadForcingParamsToDevice(forcing_params); + if (i > 1000) { + loadForcingParamsToDevice(forcing_params); + } + #endif From 5b686bc65960cc4f7538266ec392c66e25a8f58b Mon Sep 17 00:00:00 2001 From: JackHsu Date: Tue, 20 Aug 2019 23:12:42 +0800 Subject: [PATCH 60/87] Fixed on/off switch for forcing and accretion, now forcing only happens for first 1000 steps (currently hard-coded), and accretion only happen after 1000 steps. --- acc/mhd_solver/stencil_defines.h | 1 + acc/mhd_solver/stencil_process.sps | 238 ++++++++++++++++------------- src/standalone/simulation.cc | 21 ++- 3 files changed, 149 insertions(+), 111 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index 26e7ffd..93995d2 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -82,6 +82,7 @@ FUNC(AC_M_sink_Msun),\ FUNC(AC_soft),\ FUNC(AC_accretion_range),\ + FUNC(AC_switch_accretion),\ /* Run params */\ FUNC(AC_cdt), \ FUNC(AC_cdtv), \ diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 2cf6144..e0c8211 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -68,7 +68,6 @@ sink_gravity(int3 globalVertexIdx){ #endif - #if LSINK // Give Truelove density Scalar @@ -92,33 +91,39 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ DCONST_REAL(AC_sink_pos_y), DCONST_REAL(AC_sink_pos_z)}; const Scalar profile_range = DCONST_REAL(AC_accretion_range); - const Scalar accretion_distance = length(grid_pos - sink_pos); + const Scalar accretion_distance = length(grid_pos - sink_pos); + int accretion_switch = DCONST_INT(AC_switch_accretion); Scalar accretion_density; - Scalar weight; -// const Scalar weight = exp(-(accretion_distance/profile_range)); - // Step function weighting - if ((accretion_distance) <= profile_range){ - weight = Scalar(1.0); - } else { - weight = Scalar(0.0); - } -// const Scalar lnrho_min = Scalar(-10.0); //TODO Define from astaroth.conf - const Scalar lnrho_min = log(truelove_density(lnrho)); -// const Scalar sink_mass = DCONST_REAL(AC_M_sink); -// const Scalar B = Scalar(0.5); -// const Scalar k = Scalar(1.5); -// const Scalar rate = B * (pow(sink_mass, k) / (dsx * dsy * dsz)); - Scalar rate; - if (value(lnrho) > lnrho_min) { - rate = (exp(value(lnrho)) - exp(lnrho_min)) / dt; - } else { - rate = Scalar(0.0); + if (accretion_switch == 1){ +// const Scalar weight = exp(-(accretion_distance/profile_range)); + // Step function weighting + if ((accretion_distance) <= profile_range){ + weight = Scalar(1.0); + } else { + weight = Scalar(0.0); + } + +// const Scalar lnrho_min = Scalar(-10.0); //TODO Define from astaroth.conf + const Scalar lnrho_min = log(truelove_density(lnrho)); +// const Scalar sink_mass = DCONST_REAL(AC_M_sink); +// const Scalar B = Scalar(0.5); +// const Scalar k = Scalar(1.5); +// const Scalar rate = B * (pow(sink_mass, k) / (dsx * dsy * dsz)); + Scalar rate; + if (value(lnrho) > lnrho_min) { + rate = (exp(value(lnrho)) - exp(lnrho_min)) / dt; + } else { + rate = Scalar(0.0); + } + accretion_density = weight * rate ; + } else { + accretion_density = 0; } - accretion_density = weight * rate ; return accretion_density; -} +} + Vector sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { @@ -130,24 +135,28 @@ sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { DCONST_REAL(AC_sink_pos_z)}; const Scalar profile_range = DCONST_REAL(AC_accretion_range); const Scalar accretion_distance = length(grid_pos - sink_pos); - + int accretion_switch = DCONST_INT(AC_switch_accretion); Vector accretion_velocity; - Scalar weight; - // Step function weighting - if ((accretion_distance) <= profile_range){ + if (accretion_switch == 1){ + Scalar weight; + // Step function weighting + if ((accretion_distance) <= profile_range){ weight = Scalar(1.0); - } else { + } else { weight = Scalar(0.0); - } + } - Vector rate; - if (length(value(uu)) > Scalar(0.0)) { - rate = (Scalar(1.0)/dt) * value(uu); - } else { - rate = (Vector){0.0, 0.0, 0.0}; + Vector rate; + if (length(value(uu)) > Scalar(0.0)) { + rate = (Scalar(1.0)/dt) * value(uu); + } else { + rate = (Vector){0.0, 0.0, 0.0}; + } + accretion_velocity = weight * rate ; + } else { + accretion_velocity = (Vector){0.0, 0.0, 0.0}; } - accretion_velocity = weight * rate ; return accretion_velocity; } #endif @@ -303,7 +312,7 @@ entropy(in ScalarField ss, in VectorField uu, in ScalarField lnrho, in VectorFie const Vector j = (Scalar(1.) / mu0) * (gradient_of_divergence(aa) - laplace_vec(aa)); // Current density const Scalar RHS = H_CONST - C_CONST + eta * (mu0) * dot(j, j) - + Scalar(2.) * exp(value(lnrho)) * nu_visc * contract(S) + + Scalar(2.) * exp(value(lnrho)) * nu_visc * contract(S) + zeta * exp(value(lnrho)) * divergence(uu) * divergence(uu); return - dot(value(uu), gradient(ss)) @@ -326,88 +335,111 @@ heat_transfer(in VectorField uu, in ScalarField lnrho, in ScalarField tt) #if LFORCING Vector -simple_vortex_forcing(Vector a, Vector b, Scalar magnitude) -{ - return magnitude * cross(normalized(b - a), (Vector){0, 0, 1}); // Vortex + simple_vortex_forcing(Vector a, Vector b, Scalar magnitude){ + int accretion_switch = DCONST_INT(AC_switch_accretion); + + if (accretion_switch == 0){ + return magnitude * cross(normalized(b - a), (Vector){ 0, 0, 1}); // Vortex + } else { + return (Vector){0,0,0}; + } +} +Vector + simple_outward_flow_forcing(Vector a, Vector b, Scalar magnitude){ + int accretion_switch = DCONST_INT(AC_switch_accretion); + if (accretion_switch == 0){ + return magnitude * (1 / length(b - a)) * normalized(b - a); // Outward flow + } else { + return (Vector){0,0,0}; + } } -Vector -simple_outward_flow_forcing(Vector a, Vector b, Scalar magnitude) -{ - return magnitude * (1 / length(b - a)) * normalized(b - a); // Outward flow -} // The Pencil Code forcing_hel_noshear(), manual Eq. 222, inspired forcing function with adjustable helicity Vector helical_forcing(Scalar magnitude, Vector k_force, Vector xx, Vector ff_re, Vector ff_im, Scalar phi) { - // JP: This looks wrong: - // 1) Should it be dsx * nx instead of dsx * ny? - // 2) Should you also use globalGrid.n instead of the local n? - // MV: You are rigth. Made a quickfix. I did not see the error because multigpu is split - // in z direction not y direction. - // 3) Also final point: can we do this with vectors/quaternions instead? - // Tringonometric functions are much more expensive and inaccurate/ - // MV: Good idea. No an immediate priority. - // Fun related article: - // https://randomascii.wordpress.com/2014/10/09/intel-underestimates-error-bounds-by-1-3-quintillion/ - xx.x = xx.x*(2.0*M_PI/(dsx*globalGridN.x)); - xx.y = xx.y*(2.0*M_PI/(dsy*globalGridN.y)); - xx.z = xx.z*(2.0*M_PI/(dsz*globalGridN.z)); + int accretion_switch = DCONST_INT(AC_switch_accretion); + if (accretion_switch == 0){ - Scalar cos_phi = cos(phi); - Scalar sin_phi = sin(phi); - Scalar cos_k_dot_x = cos(dot(k_force, xx)); - Scalar sin_k_dot_x = sin(dot(k_force, xx)); - // Phase affect only the x-component - //Scalar real_comp = cos_k_dot_x; - //Scalar imag_comp = sin_k_dot_x; - Scalar real_comp_phase = cos_k_dot_x*cos_phi - sin_k_dot_x*sin_phi; - Scalar imag_comp_phase = cos_k_dot_x*sin_phi + sin_k_dot_x*cos_phi; - - - Vector force = (Vector){ ff_re.x*real_comp_phase - ff_im.x*imag_comp_phase, - ff_re.y*real_comp_phase - ff_im.y*imag_comp_phase, - ff_re.z*real_comp_phase - ff_im.z*imag_comp_phase}; - - return force; + + // JP: This looks wrong: + // 1) Should it be dsx * nx instead of dsx * ny? + // 2) Should you also use globalGrid.n instead of the local n? + // MV: You are rigth. Made a quickfix. I did not see the error because multigpu is split + // in z direction not y direction. + // 3) Also final point: can we do this with vectors/quaternions instead? + // Tringonometric functions are much more expensive and inaccurate/ + // MV: Good idea. No an immediate priority. + // Fun related article: + // https://randomascii.wordpress.com/2014/10/09/intel-underestimates-error-bounds-by-1-3-quintillion/ + xx.x = xx.x*(2.0*M_PI/(dsx*globalGridN.x)); + xx.y = xx.y*(2.0*M_PI/(dsy*globalGridN.y)); + xx.z = xx.z*(2.0*M_PI/(dsz*globalGridN.z)); + + Scalar cos_phi = cos(phi); + Scalar sin_phi = sin(phi); + Scalar cos_k_dot_x = cos(dot(k_force, xx)); + Scalar sin_k_dot_x = sin(dot(k_force, xx)); + // Phase affect only the x-component + //Scalar real_comp = cos_k_dot_x; + //Scalar imag_comp = sin_k_dot_x; + Scalar real_comp_phase = cos_k_dot_x*cos_phi - sin_k_dot_x*sin_phi; + Scalar imag_comp_phase = cos_k_dot_x*sin_phi + sin_k_dot_x*cos_phi; + + + Vector force = (Vector){ ff_re.x*real_comp_phase - ff_im.x*imag_comp_phase, + ff_re.y*real_comp_phase - ff_im.y*imag_comp_phase, + ff_re.z*real_comp_phase - ff_im.z*imag_comp_phase}; + + + return force; + } else { + return (Vector){0,0,0}; + } } Vector forcing(int3 globalVertexIdx, Scalar dt) { - Vector a = Scalar(.5) * (Vector){globalGridN.x * dsx, - globalGridN.y * dsy, - globalGridN.z * dsz}; // source (origin) - Vector xx = (Vector){(globalVertexIdx.x - nx_min) * dsx, - (globalVertexIdx.y - ny_min) * dsy, - (globalVertexIdx.z - nz_min) * dsz}; // sink (current index) - const Scalar cs2 = cs2_sound; - const Scalar cs = sqrt(cs2); + int accretion_switch = DCONST_INT(AC_switch_accretion); + if (accretion_switch == 0){ - //Placeholders until determined properly - Scalar magnitude = DCONST_REAL(AC_forcing_magnitude); - Scalar phase = DCONST_REAL(AC_forcing_phase); - Vector k_force = (Vector){ DCONST_REAL(AC_k_forcex), DCONST_REAL(AC_k_forcey), DCONST_REAL(AC_k_forcez)}; - Vector ff_re = (Vector){DCONST_REAL(AC_ff_hel_rex), DCONST_REAL(AC_ff_hel_rey), DCONST_REAL(AC_ff_hel_rez)}; - Vector ff_im = (Vector){DCONST_REAL(AC_ff_hel_imx), DCONST_REAL(AC_ff_hel_imy), DCONST_REAL(AC_ff_hel_imz)}; - - - //Determine that forcing funtion type at this point. - //Vector force = simple_vortex_forcing(a, xx, magnitude); - //Vector force = simple_outward_flow_forcing(a, xx, magnitude); - Vector force = helical_forcing(magnitude, k_force, xx, ff_re,ff_im, phase); - - //Scaling N = magnitude*cs*sqrt(k*cs/dt) * dt - const Scalar NN = cs*sqrt(DCONST_REAL(AC_kaver)*cs); - //MV: Like in the Pencil Code. I don't understandf the logic here. - force.x = sqrt(dt)*NN*force.x; - force.y = sqrt(dt)*NN*force.y; - force.z = sqrt(dt)*NN*force.z; - - if (is_valid(force)) { return force; } - else { return (Vector){0, 0, 0}; } + Vector a = Scalar(.5) * (Vector){globalGridN.x * dsx, + globalGridN.y * dsy, + globalGridN.z * dsz}; // source (origin) + Vector xx = (Vector){(globalVertexIdx.x - nx_min) * dsx, + (globalVertexIdx.y - ny_min) * dsy, + (globalVertexIdx.z - nz_min) * dsz}; // sink (current index) + const Scalar cs2 = cs2_sound; + const Scalar cs = sqrt(cs2); + + //Placeholders until determined properly + Scalar magnitude = DCONST_REAL(AC_forcing_magnitude); + Scalar phase = DCONST_REAL(AC_forcing_phase); + Vector k_force = (Vector){ DCONST_REAL(AC_k_forcex), DCONST_REAL(AC_k_forcey), DCONST_REAL(AC_k_forcez)}; + Vector ff_re = (Vector){DCONST_REAL(AC_ff_hel_rex), DCONST_REAL(AC_ff_hel_rey), DCONST_REAL(AC_ff_hel_rez)}; + Vector ff_im = (Vector){DCONST_REAL(AC_ff_hel_imx), DCONST_REAL(AC_ff_hel_imy), DCONST_REAL(AC_ff_hel_imz)}; + + + //Determine that forcing funtion type at this point. + //Vector force = simple_vortex_forcing(a, xx, magnitude); + //Vector force = simple_outward_flow_forcing(a, xx, magnitude); + Vector force = helical_forcing(magnitude, k_force, xx, ff_re,ff_im, phase); + + //Scaling N = magnitude*cs*sqrt(k*cs/dt) * dt + const Scalar NN = cs*sqrt(DCONST_REAL(AC_kaver)*cs); + //MV: Like in the Pencil Code. I don't understandf the logic here. + force.x = sqrt(dt)*NN*force.x; + force.y = sqrt(dt)*NN*force.y; + force.z = sqrt(dt)*NN*force.z; + + if (is_valid(force)) { return force; } + else { return (Vector){0, 0, 0}; } + } else { + return (Vector){0,0,0}; + } } #endif // LFORCING diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 167da4e..911dfb8 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -252,11 +252,11 @@ run_simulation(void) #if LSINK const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); - if (i > 1000) { +// if (i > 1000) { accreted_mass = accreted_mass + sum_mass; - } else { - accreted_mass = 0.0; - } +// } else { +// accreted_mass = 0.0; +// } AcReal sink_mass = 0.0; //if (i > 1000 ) { sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; @@ -265,14 +265,19 @@ run_simulation(void) printf("accreted mass is: %e \n", accreted_mass); acLoadDeviceConstant(AC_M_sink, sink_mass); vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); + + int on_off_switch; + if (i < 1000) { + on_off_switch = 0; //accretion is off till 1000 steps. + } else { + on_off_switch = 1; + } + acLoadDeviceConstant(AC_switch_accretion, on_off_switch); #endif #if LFORCING const ForcingParams forcing_params = generateForcingParams(mesh_info); - if (i > 1000) { - loadForcingParamsToDevice(forcing_params); - } - + loadForcingParamsToDevice(forcing_params); #endif From 7ac8c29b560cb15e0f4edcaca5d0d20bedf1192a Mon Sep 17 00:00:00 2001 From: JackHsu Date: Wed, 21 Aug 2019 17:20:15 +0800 Subject: [PATCH 61/87] Now visualization prints time-series for accretion. Corrections to output. --- analysis/python/astar/data/read.py | 1 + analysis/python/astar/visual/lineplot.py | 11 ++++++++++- src/standalone/simulation.cc | 14 ++++---------- 3 files changed, 15 insertions(+), 11 deletions(-) diff --git a/analysis/python/astar/data/read.py b/analysis/python/astar/data/read.py index 270263f..2dd0d45 100644 --- a/analysis/python/astar/data/read.py +++ b/analysis/python/astar/data/read.py @@ -116,6 +116,7 @@ def parse_ts(fdir, fname): line[i] = line[i].replace('VTXBUF_', "") line[i] = line[i].replace('UU', "uu") line[i] = line[i].replace('_total', "tot") + line[i] = line[i].replace('ACCRETION', "acc") line[i] = line[i].replace('A', "aa") line[i] = line[i].replace('LNRHO', "lnrho") line[i] = line[i].replace('ENTROPY', "ss") diff --git a/analysis/python/astar/visual/lineplot.py b/analysis/python/astar/visual/lineplot.py index f33d75d..fe750ed 100644 --- a/analysis/python/astar/visual/lineplot.py +++ b/analysis/python/astar/visual/lineplot.py @@ -32,7 +32,7 @@ def plot_min_man_rms(ts, xaxis, yaxis1, yaxis2, yaxis3): plt.xlabel(xaxis) plt.legend() -def plot_ts(ts, show_all=False, lnrho=False, uutot=False, uux=False, uuy=False, uuz=False, ss=False): +def plot_ts(ts, show_all=False, lnrho=False, uutot=False, uux=False, uuy=False, uuz=False, ss=False, acc=False): if show_all: lnrho=True @@ -41,6 +41,7 @@ def plot_ts(ts, show_all=False, lnrho=False, uutot=False, uux=False, uuy=False, uuy=True uuz=True ss=True + acc=True if lnrho: plt.figure() @@ -89,5 +90,13 @@ def plot_ts(ts, show_all=False, lnrho=False, uutot=False, uux=False, uuy=False, yaxis2 = 'ss_min' yaxis3 = 'ss_max' plot_min_man_rms(ts, xaxis, yaxis1, yaxis2, yaxis3) + + if acc: + plt.figure() + xaxis = 't_step' + yaxis1 = 'acc_rms' + yaxis2 = 'acc_min' + yaxis3 = 'acc_max' + plot_min_man_rms(ts, xaxis, yaxis1, yaxis2, yaxis3) plt.show() diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 911dfb8..c16bdee 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -252,17 +252,9 @@ run_simulation(void) #if LSINK const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); -// if (i > 1000) { - accreted_mass = accreted_mass + sum_mass; -// } else { -// accreted_mass = 0.0; -// } + accreted_mass = accreted_mass + sum_mass; AcReal sink_mass = 0.0; - //if (i > 1000 ) { - sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; - //} - printf("sink mass is: %e \n", sink_mass); - printf("accreted mass is: %e \n", accreted_mass); + sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; acLoadDeviceConstant(AC_M_sink, sink_mass); vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); @@ -315,6 +307,8 @@ run_simulation(void) */ print_diagnostics(i, dt, t_step, diag_file); + printf("sink mass is: %.15e \n", sink_mass); + printf("accreted mass is: %.15e \n", accreted_mass); /* We would also might want an XY-average calculating funtion, From fa127bfd4e831d43d4418f8fc4c3a8162d9fc894 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 22 Aug 2019 10:31:49 +0800 Subject: [PATCH 62/87] Added time series plot for accetion. --- analysis/python/jupyter/notebook_example.ipynb | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/analysis/python/jupyter/notebook_example.ipynb b/analysis/python/jupyter/notebook_example.ipynb index 7595462..7d07452 100644 --- a/analysis/python/jupyter/notebook_example.ipynb +++ b/analysis/python/jupyter/notebook_example.ipynb @@ -24,7 +24,7 @@ "metadata": {}, "outputs": [], "source": [ - "meshdir = \"/scratch/data/tchsu/sink_double/\"\n", + "meshdir = \"/scratch/data/tchsu/sink1/\"\n", "#meshdir = \"/scratch/data/mvaisala/normaltest/\"" ] }, @@ -35,7 +35,7 @@ "outputs": [], "source": [ "#imesh = 30000\n", - "imesh = 1000\n", + "imesh = 1800000\n", "mesh = ad.read.Mesh(imesh, fdir=meshdir)" ] }, @@ -102,8 +102,15 @@ "metadata": {}, "outputs": [], "source": [ - "vis.lineplot.plot_ts(ts, lnrho=1, uutot=1, uux=1, uuy=1, uuz=1, ss=1)" + "vis.lineplot.plot_ts(ts, lnrho=1, uutot=1, uux=1, uuy=1, uuz=1, ss=1, acc=1)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 4414125a08e9428b04b43b84819c07b9417bf1b5 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 22 Aug 2019 11:15:03 +0800 Subject: [PATCH 63/87] config file for a six hour stable run. --- config/templates/six_hour_stable.conf | 75 +++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 config/templates/six_hour_stable.conf diff --git a/config/templates/six_hour_stable.conf b/config/templates/six_hour_stable.conf new file mode 100644 index 0000000..2a7791b --- /dev/null +++ b/config/templates/six_hour_stable.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 128 +AC_ny = 128 +AC_nz = 128 + +AC_dsx = 0.04908738521 +AC_dsy = 0.04908738521 +AC_dsz = 0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 1800001 +AC_save_steps = 100 +AC_bin_steps = 2000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-3 +AC_cs_sound = 1.0 +AC_zeta = 0.01 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-10 +AC_soft = 0.36 +AC_accretion_range = 0.15 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 0.0 From a81bc22fb628009b724bfc04754492bed613d35c Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Thu, 22 Aug 2019 11:50:31 +0800 Subject: [PATCH 64/87] Write now sink infor to time series. Also a bug cerrection for sink switch. --- acc/mhd_solver/stencil_process.sps | 37 ++++++++++++++---------- analysis/python/astar/visual/lineplot.py | 17 ++++++++++- analysis/python/samples/readtest.py | 4 +-- src/standalone/simulation.cc | 21 +++++++++++--- 4 files changed, 56 insertions(+), 23 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index e0c8211..d46c63a 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -48,22 +48,27 @@ gradients(in VectorField uu) #if LSINK Vector sink_gravity(int3 globalVertexIdx){ - Vector force_gravity; - const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, - (globalVertexIdx.y - ny_min) * dsy, - (globalVertexIdx.z - nz_min) * dsz}; - const Scalar sink_mass = DCONST_REAL(AC_M_sink); - const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), - DCONST_REAL(AC_sink_pos_y), - DCONST_REAL(AC_sink_pos_z)}; - const Scalar distance = length(grid_pos - sink_pos); - const Scalar soft = DCONST_REAL(AC_soft); - const Scalar gravity_magnitude = (AC_G_const * sink_mass) / pow(((distance * distance) + soft*soft), 1.5); - const Vector direction = (Vector){(sink_pos.x - grid_pos.x) / distance, - (sink_pos.y - grid_pos.y) / distance, - (sink_pos.z - grid_pos.z) / distance}; - force_gravity = gravity_magnitude * direction; - return force_gravity; + int accretion_switch = DCONST_INT(AC_switch_accretion); + if (accretion_switch == 1){ + Vector force_gravity; + const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, + (globalVertexIdx.y - ny_min) * dsy, + (globalVertexIdx.z - nz_min) * dsz}; + const Scalar sink_mass = DCONST_REAL(AC_M_sink); + const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), + DCONST_REAL(AC_sink_pos_y), + DCONST_REAL(AC_sink_pos_z)}; + const Scalar distance = length(grid_pos - sink_pos); + const Scalar soft = DCONST_REAL(AC_soft); + const Scalar gravity_magnitude = (AC_G_const * sink_mass) / pow(((distance * distance) + soft*soft), 1.5); + const Vector direction = (Vector){(sink_pos.x - grid_pos.x) / distance, + (sink_pos.y - grid_pos.y) / distance, + (sink_pos.z - grid_pos.z) / distance}; + force_gravity = gravity_magnitude * direction; + return force_gravity; + } else { + return (Vector){0.0, 0.0, 0.0}; + } } #endif diff --git a/analysis/python/astar/visual/lineplot.py b/analysis/python/astar/visual/lineplot.py index fe750ed..45d39df 100644 --- a/analysis/python/astar/visual/lineplot.py +++ b/analysis/python/astar/visual/lineplot.py @@ -32,7 +32,7 @@ def plot_min_man_rms(ts, xaxis, yaxis1, yaxis2, yaxis3): plt.xlabel(xaxis) plt.legend() -def plot_ts(ts, show_all=False, lnrho=False, uutot=False, uux=False, uuy=False, uuz=False, ss=False, acc=False): +def plot_ts(ts, show_all=False, lnrho=False, uutot=False, uux=False, uuy=False, uuz=False, ss=False, acc=False, sink=False): if show_all: lnrho=True @@ -42,6 +42,7 @@ def plot_ts(ts, show_all=False, lnrho=False, uutot=False, uux=False, uuy=False, uuz=True ss=True acc=True + sink=True if lnrho: plt.figure() @@ -98,5 +99,19 @@ def plot_ts(ts, show_all=False, lnrho=False, uutot=False, uux=False, uuy=False, yaxis2 = 'acc_min' yaxis3 = 'acc_max' plot_min_man_rms(ts, xaxis, yaxis1, yaxis2, yaxis3) + + plt.figure() + xaxis = 't_step' + yaxis1 = 'sink_mass' + yaxis2 = 'sink_mass' + yaxis3 = 'sink_mass' + plot_min_man_rms(ts, xaxis, yaxis1, yaxis2, yaxis3) + + plt.figure() + xaxis = 't_step' + yaxis1 = 'accreted_mass' + yaxis2 = 'accreted_mass' + yaxis3 = 'accreted_mass' + plot_min_man_rms(ts, xaxis, yaxis1, yaxis2, yaxis3) plt.show() diff --git a/analysis/python/samples/readtest.py b/analysis/python/samples/readtest.py index b2e4458..7f22858 100644 --- a/analysis/python/samples/readtest.py +++ b/analysis/python/samples/readtest.py @@ -45,7 +45,7 @@ print("sys.argv", sys.argv) #meshdir = "/tiara/home/mvaisala/astaroth-code/astaroth_2.0/build/" #meshdir = "/tiara/ara/data/mvaisala/tmp/astaroth-code/astaroth_2.0/build/" #meshdir = "/tiara/ara/data/mvaisala/asth_testbed_double/" -meshdir = "/scratch/data/mvaisala/forcingtest/" +meshdir = "/home/mvaisala/astaroth/build/" if "xtopbound" in sys.argv: for i in range(0, 171): @@ -199,6 +199,6 @@ if 'sl' in sys.argv: if 'ts' in sys.argv: ts = ad.read.TimeSeries(fdir=meshdir) - vis.lineplot.plot_ts(ts, lnrho=1, uutot=1, uux=1, ss=1) + vis.lineplot.plot_ts(ts, show_all=True) diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index c16bdee..611c1c6 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -145,7 +145,8 @@ save_mesh(const AcMesh& save_mesh, const int step, const AcReal t_step) // This function prints out the diagnostic values to std.out and also saves and // appends an ascii file to contain all the result. static inline void -print_diagnostics(const int step, const AcReal dt, const AcReal t_step, FILE* diag_file) +print_diagnostics(const int step, const AcReal dt, const AcReal t_step, FILE* diag_file, + const AcReal sink_mass, const AcReal accreted_mass) { AcReal buf_rms, buf_max, buf_min; @@ -175,6 +176,10 @@ print_diagnostics(const int step, const AcReal dt, const AcReal t_step, FILE* di fprintf(diag_file, "%e %e %e ", double(buf_min), double(buf_rms), double(buf_max)); } + if ((sink_mass >= 0.0) || (accreted_mass >= 0.0)) { + fprintf(diag_file, "%e %e ", sink_mass, accreted_mass); + } + fprintf(diag_file, "\n"); } @@ -213,11 +218,17 @@ run_simulation(void) fprintf(diag_file, "%s_min %s_rms %s_max ", vtxbuf_names[i], vtxbuf_names[i], vtxbuf_names[i]); } - +#if LSINK + fprintf(diag_file, "sink_mass accreted_mass "); +#endif fprintf(diag_file, "\n"); write_mesh_info(&mesh_info); - print_diagnostics(0, AcReal(.0), t_step, diag_file); +#if LSINK + print_diagnostics(0, AcReal(.0), t_step, diag_file, mesh_info.real_params[AC_M_sink_init], 0.0); +#else + print_diagnostics(0, AcReal(.0), t_step, diag_file, -1.0, -1.0); +#endif acBoundcondStep(); acStore(mesh); @@ -265,6 +276,8 @@ run_simulation(void) on_off_switch = 1; } acLoadDeviceConstant(AC_switch_accretion, on_off_switch); +#else + accreted_mass = -1.0; sink_mass = -1.0; #endif #if LFORCING @@ -306,7 +319,7 @@ run_simulation(void) timeseries.ts. */ - print_diagnostics(i, dt, t_step, diag_file); + print_diagnostics(i, dt, t_step, diag_file, sink_mass, accreted_mass); printf("sink mass is: %.15e \n", sink_mass); printf("accreted mass is: %.15e \n", accreted_mass); From 7f47bf5bfcbb6568dacacefa1efe82568fb34c49 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Thu, 22 Aug 2019 16:46:42 +0800 Subject: [PATCH 65/87] shorter time steps to turn on accretion (due to no forcing), and comment for unit_length. --- config/templates/sinktest.conf | 1 + src/standalone/simulation.cc | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/config/templates/sinktest.conf b/config/templates/sinktest.conf index 1088da3..b1e118e 100644 --- a/config/templates/sinktest.conf +++ b/config/templates/sinktest.conf @@ -65,6 +65,7 @@ AC_accretion_range = 0.2 AC_unit_velocity = 1e5 // using density estimate of 100 H2 molecules per cm^3 AC_unit_density = 3e-22 +// using 10,000 AU AC_unit_length = 1.5e17 /* diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 611c1c6..ce33ec6 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -270,7 +270,7 @@ run_simulation(void) vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); int on_off_switch; - if (i < 1000) { + if (i < 50) { on_off_switch = 0; //accretion is off till 1000 steps. } else { on_off_switch = 1; From 1410e578661e56df3f6d3783c453c46521961e5e Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Thu, 22 Aug 2019 18:18:30 +0800 Subject: [PATCH 66/87] Preparing isothermal collapse. --- acc/mhd_solver/stencil_defines.h | 6 +- acc/mhd_solver/stencil_process.sps | 8 +- analysis/python/astar/data/read.py | 2 + .../python/jupyter/notebook_example.ipynb | 247 +++++++++++++++++- src/standalone/model/host_memory.cc | 79 ++++++ src/standalone/model/host_memory.h | 1 + src/standalone/renderer.cc | 5 +- src/standalone/simulation.cc | 5 +- 8 files changed, 330 insertions(+), 23 deletions(-) diff --git a/acc/mhd_solver/stencil_defines.h b/acc/mhd_solver/stencil_defines.h index 93995d2..ab75115 100644 --- a/acc/mhd_solver/stencil_defines.h +++ b/acc/mhd_solver/stencil_defines.h @@ -28,10 +28,10 @@ #define LDENSITY (1) #define LHYDRO (1) #define LMAGNETIC (1) -#define LENTROPY (1) +#define LENTROPY (0) #define LTEMPERATURE (0) -#define LFORCING (1) -#define LUPWD (0) +#define LFORCING (0) +#define LUPWD (1) #define LSINK (1) #define AC_THERMAL_CONDUCTIVITY (AcReal(0.001)) // TODO: make an actual config parameter diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index d46c63a..1026617 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -238,7 +238,7 @@ momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, in Scala } #else Vector -momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho) { +momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, Scalar dt) { Vector mom; const Matrix S = stress_tensor(uu); @@ -252,6 +252,10 @@ momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho) { #if LSINK + sink_gravity(globalVertexIdx); + //Corresponding loss of momentum + - //(Scalar(1.0) / Scalar( (dsx*dsy*dsz) * exp(value(lnrho)))) * // Correction factor by unit mass + sink_accretion_velocity(globalVertexIdx, uu, dt) // As in Lee et al.(2014) + ; #else ; #endif @@ -492,7 +496,7 @@ solve(Scalar dt) { out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, tt), dt); out_tt = rk3(out_tt, tt, heat_transfer(uu, lnrho, tt), dt); #else - out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho), dt); + out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, dt), dt); #endif #if LFORCING diff --git a/analysis/python/astar/data/read.py b/analysis/python/astar/data/read.py index 2dd0d45..f55f145 100644 --- a/analysis/python/astar/data/read.py +++ b/analysis/python/astar/data/read.py @@ -78,6 +78,8 @@ class Mesh: if self.ok: self.ss, timestamp, ok = read_bin('VTXBUF_ENTROPY', fdir, fnum, self.minfo) + + self.accretion, timestamp, ok = read_bin('VTXBUF_ACCRETION', fdir, fnum, self.minfo) #TODO Generalize is a dict. Do not hardcode! uux, timestamp, ok = read_bin('VTXBUF_UUX', fdir, fnum, self.minfo) diff --git a/analysis/python/jupyter/notebook_example.ipynb b/analysis/python/jupyter/notebook_example.ipynb index 7d07452..241c43f 100644 --- a/analysis/python/jupyter/notebook_example.ipynb +++ b/analysis/python/jupyter/notebook_example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -20,22 +20,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "meshdir = \"/scratch/data/tchsu/sink1/\"\n", + "meshdir = \"/home/mvaisala/astaroth/build/\"\n", "#meshdir = \"/scratch/data/mvaisala/normaltest/\"" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/mvaisala/astaroth/build/VTXBUF_LNRHO_200.mesh\n", + "/home/mvaisala/astaroth/build/VTXBUF_ACCRETION_200.mesh\n", + "/home/mvaisala/astaroth/build/VTXBUF_UUX_200.mesh\n", + "/home/mvaisala/astaroth/build/VTXBUF_UUY_200.mesh\n", + "/home/mvaisala/astaroth/build/VTXBUF_UUZ_200.mesh\n", + "/home/mvaisala/astaroth/build/VTXBUF_AX_200.mesh\n", + "/home/mvaisala/astaroth/build/VTXBUF_AY_200.mesh\n", + "/home/mvaisala/astaroth/build/VTXBUF_AZ_200.mesh\n" + ] + } + ], "source": [ "#imesh = 30000\n", - "imesh = 1800000\n", + "imesh = 200\n", "mesh = ad.read.Mesh(imesh, fdir=meshdir)" ] }, @@ -48,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -64,11 +79,122 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", + "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "vis.slices.plot_3(mesh, uu_tot, title = r'$\\|u\\|$')\n", "vis.slices.plot_3(mesh, mesh.uu[0], title = r'$u_x$')\n", @@ -77,7 +203,8 @@ "vis.slices.plot_3(mesh, mesh.lnrho, title = r'$\\ln_\\rho$')\n", "vis.slices.plot_3(mesh, np.exp(mesh.lnrho), title = r'$\\rho$')\n", "vis.slices.plot_3(mesh, np.exp(mesh.lnrho), title = r'$N_\\mathrm{col}$', slicetype = 'sum')\n", - "vis.slices.plot_3(mesh, mesh.ss, title = r'$s$')\n" + "#vis.slices.plot_3(mesh, mesh.ss, title = r'$s$')\n", + "vis.slices.plot_3(mesh, mesh.accretion, title = r'$Accretion buffer$')\n" ] }, { @@ -89,18 +216,110 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HERE ARE ALL KEYS FOR TS DATA:\n", + "dict_keys(['step', 't_step', 'dt', 'uutot_min', 'uutot_rms', 'uutot_max', 'lnrho_min', 'lnrho_rms', 'lnrho_max', 'acc_min', 'acc_rms', 'acc_max', 'uux_min', 'uux_rms', 'uux_max', 'uuy_min', 'uuy_rms', 'uuy_max', 'uuz_min', 'uuz_rms', 'uuz_max', 'aax_min', 'aax_rms', 'aax_max', 'aay_min', 'aay_rms', 'aay_max', 'aaz_min', 'aaz_rms', 'aaz_max', 'sink_mass', 'accreted_mass'])\n" + ] + } + ], "source": [ "ts = ad.read.TimeSeries(fdir=meshdir)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "KeyError", + "evalue": "'ss_rms'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlineplot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_ts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlnrho\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muutot\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muux\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muuy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muuz\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0macc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/astaroth/analysis/python/astar/visual/lineplot.py\u001b[0m in \u001b[0;36mplot_ts\u001b[0;34m(ts, show_all, lnrho, uutot, uux, uuy, uuz, ss, acc, sink)\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0myaxis2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'ss_min'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m \u001b[0myaxis3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'ss_max'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 93\u001b[0;31m \u001b[0mplot_min_man_rms\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxaxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0macc\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/astaroth/analysis/python/astar/visual/lineplot.py\u001b[0m in \u001b[0;36mplot_min_man_rms\u001b[0;34m(ts, xaxis, yaxis1, yaxis2, yaxis3)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mplot_min_man_rms\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxaxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0myaxis1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0myaxis1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 30\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0myaxis2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0myaxis2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0myaxis3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0myaxis3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'ss_rms'" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "vis.lineplot.plot_ts(ts, lnrho=1, uutot=1, uux=1, uuy=1, uuz=1, ss=1, acc=1)" ] diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index 94dbb5a..94fa667 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -207,6 +207,81 @@ inflow_vedge(AcMesh* mesh) } } +// This is the initial condition type for the infalling vedge in the pseudodisk +// model. +void +simple_uniform_core(AcMesh* mesh) +{ + const int mx = mesh->info.int_params[AC_mx]; + const int my = mesh->info.int_params[AC_my]; + const int mz = mesh->info.int_params[AC_mz]; + + //const int nx_min = mesh->info.int_params[AC_nx_min]; + //const int nx_max = mesh->info.int_params[AC_nx_max]; + //const int ny_min = mesh->info.int_params[AC_ny_min]; + //const int ny_max = mesh->info.int_params[AC_ny_max]; + //const int nz_min = mesh->info.int_params[AC_nz_min]; + //const int nz_max = mesh->info.int_params[AC_nz_max]; + + const double DX = mesh->info.real_params[AC_dsx]; + const double DY = mesh->info.real_params[AC_dsy]; + const double DZ = mesh->info.real_params[AC_dsz]; + + const double ampl_lnrho = mesh->info.real_params[AC_ampl_lnrho]; + //const double AMPL_UU = mesh->info.real_params[AC_ampl_uu]; + // const double SQ2GM = mesh->info.real_params[AC_sq2GM_star]; + // const double GM = mesh->info.real_params[AC_GM_star]; + // const double M_star = mesh->info.real_params[AC_M_star]; + // const double G_CONST = mesh->info.real_params[AC_G_CONST]; + + // const double unit_length = mesh->info.real_params[AC_unit_length]; + // const double unit_density = mesh->info.real_params[AC_unit_density]; + // const double unit_velocity = mesh->info.real_params[AC_unit_velocity]; + + const double xorig = mesh->info.real_params[AC_xorig]; + const double yorig = mesh->info.real_params[AC_yorig]; + const double zorig = mesh->info.real_params[AC_zorig]; + //const double trans = mesh->info.real_params[AC_trans]; + double xx, yy, zz, RR; + double delx, dely, delz; + //double u_x, u_y, u_z; + double tanhRR; + + //const double sink_pos_x = mesh->info.real_params[AC_sink_pos_x]; + //const double sink_pos_y = mesh->info.real_params[AC_sink_pos_y]; + //const double sink_pos_z = mesh->info.real_params[AC_sink_pos_z]; + + //TEMPORARY TEST INPUT PARAMETERS + const double core_radius = DX*32.0; + const double trans = DX*6.0; + + for (int k = 0; k < mz; k++) { + for (int j = 0; j < my; j++) { + for (int i = 0; i < mx; i++) { + int idx = i + j*mx + k*mx*my; + xx = DX * double(i) - xorig; + yy = DY * double(j) - yorig; + zz = DZ * double(k) - zorig; + + delx = xx; + dely = yy; + delz = zz; + RR = sqrt(delx*delx + dely*dely + delz*delz); + + tanhRR = double(0.5)*tanh((core_radius-RR)/trans) + double(0.5) + + double(0.1); + + mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(exp(ampl_lnrho)*tanhRR); + mesh->vertex_buffer[VTXBUF_UUX][idx] = double(0.0); + mesh->vertex_buffer[VTXBUF_UUY][idx] = double(0.0); + mesh->vertex_buffer[VTXBUF_UUZ][idx] = double(0.0); + + } + } + } +} + + // This is the initial condition type for the infalling vedge in the pseudodisk // model. void @@ -582,6 +657,10 @@ acmesh_init_to(const InitType& init_type, AcMesh* mesh) } } break; + case INIT_TYPE_SIMPLE_CORE: + acmesh_clear(mesh); + simple_uniform_core(mesh); + break; case INIT_TYPE_VEDGE: acmesh_clear(mesh); inflow_vedge_freefall(mesh); diff --git a/src/standalone/model/host_memory.h b/src/standalone/model/host_memory.h index c724e5e..b4f1a77 100644 --- a/src/standalone/model/host_memory.h +++ b/src/standalone/model/host_memory.h @@ -34,6 +34,7 @@ FUNC(INIT_TYPE_XWAVE), \ FUNC(INIT_TYPE_GAUSSIAN_RADIAL_EXPL), \ FUNC(INIT_TYPE_ABC_FLOW) , \ + FUNC(INIT_TYPE_SIMPLE_CORE), \ FUNC(INIT_TYPE_VEDGE), \ FUNC(INIT_TYPE_VEDGEX), \ FUNC(INIT_TYPE_RAYLEIGH_TAYLOR), \ diff --git a/src/standalone/renderer.cc b/src/standalone/renderer.cc index cbe659d..a78c14c 100644 --- a/src/standalone/renderer.cc +++ b/src/standalone/renderer.cc @@ -292,7 +292,8 @@ renderer_quit(void) return 0; } -static int init_type = INIT_TYPE_GAUSSIAN_RADIAL_EXPL; +//static int init_type = INIT_TYPE_GAUSSIAN_RADIAL_EXPL; +static int init_type = INIT_TYPE_SIMPLE_CORE; static bool running(AcMesh* mesh) @@ -396,7 +397,7 @@ run_renderer(void) #if LSINK const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); accreted_mass = accreted_mass + sum_mass; - AcReal sink_mass = AC_M_sink_init + accreted_mass; + AcReal sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; printf("sink mass is: %e \n", sink_mass); printf("accreted mass is: %e \n", accreted_mass); acLoadDeviceConstant(AC_M_sink, sink_mass); diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 611c1c6..8c4ffd0 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -198,7 +198,8 @@ run_simulation(void) AcMesh* mesh = acmesh_create(mesh_info); // TODO: This need to be possible to define in astaroth.conf - acmesh_init_to(INIT_TYPE_GAUSSIAN_RADIAL_EXPL, mesh); + //acmesh_init_to(INIT_TYPE_GAUSSIAN_RADIAL_EXPL, mesh); + acmesh_init_to(INIT_TYPE_SIMPLE_CORE, mesh); #if LSINK vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); @@ -270,7 +271,7 @@ run_simulation(void) vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); int on_off_switch; - if (i < 1000) { + if (i < 1) { on_off_switch = 0; //accretion is off till 1000 steps. } else { on_off_switch = 1; From 3a0c3402d05ef40e3541dfb35f999da279b2d5bd Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Thu, 22 Aug 2019 19:07:25 +0800 Subject: [PATCH 67/87] Critical bug correction. --- src/standalone/renderer.cc | 12 +++++++----- src/standalone/simulation.cc | 2 +- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/standalone/renderer.cc b/src/standalone/renderer.cc index a78c14c..a9608ea 100644 --- a/src/standalone/renderer.cc +++ b/src/standalone/renderer.cc @@ -390,12 +390,8 @@ run_renderer(void) timer_reset(&io_timer); /* Step the simulation */ -#if 1 - const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); - const AcReal dt = host_timestep(umax, mesh_info); - #if LSINK - const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); + const AcReal sum_mass = acReduceScal(RTYPE_SUM, VTXBUF_ACCRETION); accreted_mass = accreted_mass + sum_mass; AcReal sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; printf("sink mass is: %e \n", sink_mass); @@ -409,6 +405,12 @@ run_renderer(void) loadForcingParamsToDevice(forcing_params); #endif + +#if 1 + const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); + const AcReal dt = host_timestep(umax, mesh_info); + + acIntegrate(dt); #else ModelMesh* model_mesh = modelmesh_create(mesh->info); diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 8c4ffd0..14f6ed1 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -263,7 +263,7 @@ run_simulation(void) #if LSINK - const AcReal sum_mass = acReduceScal(RTYPE_MAX, VTXBUF_ACCRETION); + const AcReal sum_mass = acReduceScal(RTYPE_SUM, VTXBUF_ACCRETION); accreted_mass = accreted_mass + sum_mass; AcReal sink_mass = 0.0; sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; From 4d4a7e53a780d6c425c851fac7d079695f6023a3 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Thu, 22 Aug 2019 19:13:51 +0800 Subject: [PATCH 68/87] Stable seeming core collapse configuration. --- config/templates/core_collapse.conf | 75 +++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 config/templates/core_collapse.conf diff --git a/config/templates/core_collapse.conf b/config/templates/core_collapse.conf new file mode 100644 index 0000000..03f702f --- /dev/null +++ b/config/templates/core_collapse.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 128 +AC_ny = 128 +AC_nz = 128 + +AC_dsx = 0.04908738521 +AC_dsy = 0.04908738521 +AC_dsz = 0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 501 +AC_save_steps = 10 +AC_bin_steps = 100 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-3 +AC_cs_sound = 1.0 +AC_zeta = 0.01 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 0.0 From 833319ad0157329f1d113bbe23103612ff8f6fba Mon Sep 17 00:00:00 2001 From: JackHsu Date: Fri, 23 Aug 2019 15:23:48 +0800 Subject: [PATCH 69/87] constant density keplerian velocity. --- src/standalone/model/host_memory.cc | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index 94fa667..1c622e3 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -253,7 +253,10 @@ simple_uniform_core(AcMesh* mesh) //TEMPORARY TEST INPUT PARAMETERS const double core_radius = DX*32.0; - const double trans = DX*6.0; + const double trans = DX*12.0; + + RR = 1.0; + printf("%e %e %e \n", RR, trans, core_radius); for (int k = 0; k < mz; k++) { for (int j = 0; j < my; j++) { @@ -268,8 +271,11 @@ simple_uniform_core(AcMesh* mesh) delz = zz; RR = sqrt(delx*delx + dely*dely + delz*delz); - tanhRR = double(0.5)*tanh((core_radius-RR)/trans) + double(0.5) - + double(0.1); + //tanhRR = double(-0.5)*tanh((core_radius-RR)/trans) + double(0.5) + // + double(0.1); + tanhRR = double(1.0); + + abso_vel = c * sqrt(2.0 * mesh->info.real_params[AC_G_const] * mesh->info.real_params[AC_M_sink_init] / RR); mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(exp(ampl_lnrho)*tanhRR); mesh->vertex_buffer[VTXBUF_UUX][idx] = double(0.0); From 5617eaac8ad5bd28b629639d8ecc833ca046fee4 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Fri, 23 Aug 2019 16:45:23 +0800 Subject: [PATCH 70/87] stable disk-like model. --- .../python/jupyter/notebook_example.ipynb | 251 ++---------------- config/templates/core_collapse.conf | 12 +- src/standalone/model/host_memory.cc | 15 +- src/standalone/simulation.cc | 2 +- 4 files changed, 36 insertions(+), 244 deletions(-) diff --git a/analysis/python/jupyter/notebook_example.ipynb b/analysis/python/jupyter/notebook_example.ipynb index 241c43f..3d053d9 100644 --- a/analysis/python/jupyter/notebook_example.ipynb +++ b/analysis/python/jupyter/notebook_example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -20,37 +20,22 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "meshdir = \"/home/mvaisala/astaroth/build/\"\n", + "meshdir = \"/scratch/data/tchsu/sink7/\"\n", "#meshdir = \"/scratch/data/mvaisala/normaltest/\"" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/mvaisala/astaroth/build/VTXBUF_LNRHO_200.mesh\n", - "/home/mvaisala/astaroth/build/VTXBUF_ACCRETION_200.mesh\n", - "/home/mvaisala/astaroth/build/VTXBUF_UUX_200.mesh\n", - "/home/mvaisala/astaroth/build/VTXBUF_UUY_200.mesh\n", - "/home/mvaisala/astaroth/build/VTXBUF_UUZ_200.mesh\n", - "/home/mvaisala/astaroth/build/VTXBUF_AX_200.mesh\n", - "/home/mvaisala/astaroth/build/VTXBUF_AY_200.mesh\n", - "/home/mvaisala/astaroth/build/VTXBUF_AZ_200.mesh\n" - ] - } - ], + "outputs": [], "source": [ "#imesh = 30000\n", - "imesh = 200\n", + "imesh = 15000\n", "mesh = ad.read.Mesh(imesh, fdir=meshdir)" ] }, @@ -63,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -79,130 +64,19 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n", - "dict_keys(['AC_mx', 'AC_my', 'AC_mz', 'AC_nx_min', 'AC_nx_max', 'AC_ny_min', 'AC_ny_max', 'AC_nz_min', 'AC_nz_max', 'AC_dsx', 'AC_dsy', 'AC_dsz', 'AC_inv_dsx', 'AC_inv_dsy', 'AC_inv_dsz', 'AC_dsmin', 'AC_mxy', 'AC_nxy', 'AC_nxyz', 'AC_cs2_sound', 'AC_cv_sound', 'AC_sink_pos_x', 'AC_sink_pos_y', 'AC_sink_pos_z', 'AC_M_sink', 'AC_soft', 'AC_G_const'])\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAHfCAYAAADEJHvkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOy9e7B8XVrX93nW2ru7zzm/y/C+c8G5CIMZCDolEkeshCrFiDggkaS0EryVmJjXiqKYeLe8IJpEjUZJQOOr4liKZaGCGacGkUQniBVhZhJBGUApQBmQwIzM+76/yzm9915P/lhr7b327t3ndO/TfU6f0+tbdapP796XtVf399nPfYmqkpGRkZGRkZERYW57ABkZGRkZGRmHhawcZGRkZGRkZPSQlYOMjIyMjIyMHrJykJGRkZGRkdFDVg4yMjIyMjIyesjKQUZGRkZGRkYPWTnIyMjIyMjI6CErB9eEiPywiHz+js85F5G/LCL/WkReE5H/V0S+8IpjPlVE3i8iPyUiPy4iXyMiRfjsM0XkH4rIKyLyAyLynw2O/XIR+ZCIXIjIewaffUBEzkXkSfj7/mve2wsi8k0i8jTc36/eZBwZGRkZGTeHrBwcJgrgR4BfCDwG/iDwDSLyqZcc8+eAnwB+GvBzwrG/OSgI/zvwPuAF4CXgr4vIpyfH/hjwx4CvW3PuL1fVB+HvM6beVMDXAkvgTcCvAf68iPysDceRkZGRkXEDOHrlQET+exH5s8n7twar9sq5EZG/Bvx04O8Fq/p372JMqvpUVb9SVX9YVZ2qvg/4IeDnXnLY24FvUNVzVf1x4O8DPwv494E3A39GVRtV/YfAPwF+XXK9b1TVvwt8fNuxisibReTviMhPisgPichvu2TfM+BXAH9QVZ+o6rcD741juc44MjIyMjJ2h6NXDvBW9ncl7z8L+B5VdVcdqKq/Dvg3wH8SrOo/OdxHRN4nIp9Y8/e+TQYoIm8CPh34nkt2+2rgS0XkVETeAnwhXkGQsVMC79zk2gH/o4h8TET+iYh8XjIuA/w9/Py9BfjFwG8XkV+65jyfDjSq+i+Tbd+FV2IyMjIyMg4EWTnwysF3J+8/a/D+WlDVL1bV1635++KrjheREvh64K+q6vddsuv/hX/Ivgp8FPgQ8HeB78OHG36XiJQi8gX4kMPphrfwe4BPwz/8X8Z7SX5G+OznAW9Q1a9S1aWq/iDwF4EvXXOuB8Arg22vAA83HEtGRkZGxg3gqJUDEXkDPvadWuSfRd+TcGsIlvlfw8fov/yK/b4F+EbgDHg98EnAn1DVCvhPgV8G/DjwO4BvwCsQV0JVv0NVX1PVC1X9q/iQxBeFjz8FeHPqDQF+P/AmEfk1SRLjN4f9nwCPBpd4BLy2yVgyMjIyMm4GR60c4C3tf6Wq5wAhee8XAd8tIq8LmfofEJEfEZGvWHOOS5e1FJFvTh6Sw79vvuQ4Af4yXnn5FeEhvw4vAG8DviY8xD8O/BXCQ1xVv1tVf6GqvqiqvxTvCfjOy8Z9CZQuVPEjwA8NvCEPVfWLVPXrkyTGWGnxL4FCRN6RnO+zuDxckpGRkZFxwyhuewC3DAFOg1LggD8JvAH4blX9BPB5IvIfAr8B+Jo15/j/8A/bUSQPxm3x54HPBD5fVZ9ftqOqfkxEfgj4b0TkT+Hd97+e4AERkZ+NfzAb4DfjKxreE48P918AFrAisgDqcJ6fjw9Z1MB/AfwC4LeHQ78TeFVEfg/wv+A9HJ8JnKjqB0fG+VREvhH4KhH5jfiQzpcA/9Fl41DVesM5y8jIyNgZfum7f7Z+/GNP9nqND3/4h75FVd+914tMgKheavjea4SH0TfhH2j/Gp9c9ztU9W3h888BfhPwm9Y9oETkS4D/Fe8e/2Oq+qd2MK5PAX4YuMA/lCN+k6p+fdjnm4F/rKr/Q3j/c4A/i7fEG+AfAb9FVX9CRP4n4DcCJfCPgd+qqj+QXO8rgT88GMYfwZcdvh9f8dDg8xf+oKp+a3Lsm4E/jfe4zIHvB/6Aqv4fa+7tBXyp4i/BVyX8XlX9G5eNQ1W/cu1kZWRkZOwJ73rXp+l3fOiP7vUahfzaD6vqu/Z6kQk4auXgMojIz8XH+V+6wqWfkZGRkXEP8XPf9Xb9p9/5R/Z6jZn99QepHBx7WOEyvA/4QeBbReS7VHVdzkFGRkZGxr2EcqxRzawcrIGq/rTbHkNGRkZGRsZt4NirFTIyMjIyMsahoNrs9W8TiMi7ReT7w9o4v3fk858uIv8orMPz3SLyRWPn2QZZOcjIyMjIyDhQiIjFJ4d/IfAzgV8lIj9zsNsfwLfP/2x8E7o/d93r5rBCRkZGRkbGCBTF3X7OwecAPxA60CIifxNfAv6RZB+lazD3GL+I3bVwUMrB43Kub5qd3fYwMjL4V89+6mOq+obbHscUZB5lHBLuMpduCK8XkQ8l719W1ZeT92/BN5yL+Ci+/0yKrwT+gYj8VnyX3M+/7qAOSjl40+yMr33nte9pBUYUp2PrD2VkjOMLvvNv/evbHsNU7ItHGRlTcJe5dEPVCh+7opRx7OE17EHwq4D3qOqfDo37/pqIvHOTBQTX4aCUAxH/IN8H9nXejIxDwz55lJFxXDiIUsaP4tvjR7yV1bDBfwW8G0BV/+/QXfb1+EX3JiEnJGZkZGRkZBwuPgi8Q0TeLiIzfMLhewf7/BvgFwOIyGcCC+Anr3PRg/IcZGRkZGRkHAxUUXe7ngNVrUXky/Er71rg61T1e0Tkq4APqep78avt/kUR+W/xIYcv02u2P87KQUZGRkZGxgFDVd+PX+cm3faHkv8/AnzuLq+ZlYOMjIyMjIx1uP2cg1tBVg4yMjIyMjJGcRAJibeCnJCYkZGRkZGR0UP2HGRkZGRkZIxCwVW3PYhbwV49ByLyOhH52yLyfSLyvaE5Q8YOILmO/aiQubQbXJc3mXcZx4J9ew6+Gvj7qvorQ33m6Z6vd28xJpR2Jag0d4+8C8hc2hH2qSBkLt0vqB5vzsHelAMReQT8AuDLAFR1CSz3db37gNuyStZdNwu6w0Dm0vbIXMrYDRRuuc/BbWGfnoNPw3do+isi8lnAh4GvUNWn6U4i8hLwEsAbZ8dnDG0qxPbZDnfduhPDsWUBd2u4kkvHziPYjEv7biuduZRxX7DPnIMC+A+APx/WmH4K/N7hTqr6sqq+S1Xf9bpyvsfhHAZEtPc3BiO68rfu+Ov8bXK9bceesRdcyaVj4xFM49Jlx1+XR2PX24RLGQcMDZ6Dff4dKPbpOfgo8FFV/Y7w/m8zohwcCy4TXpvuLysLcV19nstWoxRRdGTBL1UZPd/wXHGM2QraOzKXAi57mN4Wl1oeTORSOr7MpYxDwd6UA1X9cRH5ERH5DFX9fvyiEB/Z1/WODdY4GpfbVBwDMpcOB5l3R4ickLgX/Fbg60N29Q8Cv2HP1zsobOotGO6XWjWX7WuNW7tfu/8lloi3UvxxQ0tmaAWlFlD2INwKMpdGsCsuXXbOdv/w+055B+nvPnMp4/5gr8qBqv4z4F37vMYhYkzoXCaYogAb5hZcdtzGiYyD96nQSf+Xle3aF1zSfTYcU9wvu0f3h8wlj7EH921zafhbz1y6PxAUOeC8gH0id0jcEbZRCMasGVmTeJjuNybMtsm+diPCTFVwKhhWhZ2o9Kwip7JiCa2zgrIFlDEV++SSGXAocynjUsSExCNEVg52gMuE2TqrZkxYpdvi++Hnlwk3MYNyKbfqzkwFjAvvo1BLBZpTGQi0TsC59DIjVlAWbBlTsW8upbzZFZdSRSFzKeO+ICsHdxSLk3POny9uexgZGUeFk5NznmfeHRGy5yBjS1zl+lzn9lxnwYhom+gkyft2P6NY0/SsosXJeWL99JOkIlS7SKlTQV3fqmmcbbfFLOxoATXO9KyjaO1IzyqKN5zMQ3K94XxkqydjiJvkUvQIpFyK2zbl0snJeY9L8Tc9lUvd9njDyTyE18yljJtGVg4m4KokKRFdSYwaCq54jvi/NQ4TBVpQBIxxWOu3GdMgRjHG+VfbdNdKFIgUqSu0dXk2tt3unEGd4JylaQwuCLQo5JwzPSEXBVy6bZ17dJhslSZaZaGWEbEtl4bhgm25ZEzTbp/CpV64oOl4EveZwqVhXkLm0iFBkVzKmHEVtomHppZN/DwKLSPaCi9rHMY6CltjgiIQ/7dFty2+F9tgrGuFl9imE2SDEiuSemx1gkZh1gQh1ViausA1BtcYmtr/HFxjqJuifY3bjPNCL449CrxRCyiJn8Z5ypnYGRFTuZQqAlO4FLdP5VKrJCRc0sYCTOZSp0hkLh0cFHDNbY/iVpCVgw1xmYUTrZt1XgKgFWSF9VZMUdTt9qKoKcoaW/pttmi8MCtr7MyvJW7KGika/2odUgRrxzowbsXSiWi9B86gjUFriwblwFUFWltcVdAsS1zlfw5NXdDUlqYqqMO2ui5wzrSvAHVjW+E2bgHJSpLVWF13FmrHg01CCJdxKSoCU7lkwvbJXIpKQsKlyJupXKqDcpG5lHFIyMrBLeG6CYXlW55T/ejJDkd0faRWUEbGIWL+yf+Oix9/YfLxxVsr6o+WOxxRxmEj9znIWIN1HoN1rk/oxz6j5yC1cmywVBYn5xRlhS0aillFsfCr8Jr5srVyzNx7DmReIbMGKRUK0Le9hZIfg8KAEZDwmsIpaHCPugZqh9YK4beulaBLi16UuIvE2lmWuIsZ9fmMeukFYVNb6qqkqkqaOlg6ieUjojTBTSohlmpYTbJKVYccOz0u7IJLRcgPSLlUlp4jm3Jp/sn/rsclKcJvbxMuOa8gpFzSKoQaJnLJxBDEgEvARlxa6ciYuZSxA2Tl4BJcJsyGSVJp7LPn8gzCLBVk5XxJEQXawgsve3KBjQLt5AIzr5EThyyCCCgLWCxgNkMLL2T0bW/2/xsT/mz/BlwDLioHDqkrqGv/CshyCedLqC7Q8+fo8xBuuChwz+cU5zOa536Fv2ZZUp/PKKuS6mIG0BNudWOxSbhBRHHODCobpE2wivOUFYTjwK64FEMIk7lUBpGXcEmLEBbYhEuBTymXZOmvNZVLVdUpDVO4NOyJkLm0S2jOOcjo4yphNkw0TPMLCtu0gqwIMc6yrCiiMFssKU7P/b6n59jFEnN2gZwEwXNq4eQEFnN04UMHujhBy4UXZrMTtPAPaDW2/R8z+DoTd5jUS8Q1/nX5PGyrkOocOX8e/i78aZ6fo89eo3hucE+DQDufUT9bUD9bdML4YtZaQLYqqIMFJKJtHDUKtJ71syZ2mku07ifWdSGcwqXUSzCFSy2fJnJJaq8IpFxqle2JXCqCsj2VS5clKmYuXRO5Q2JGik2EWer2jIlSrZfABqumrCiDK7OcLylPzilO/Z89DcLj4QXmDDiZwYMzAPT0DF2c4uanuMUDv212gs5O0WKO2gVahHwFKbwgGwqziPjDdjVojdTnSOOFqdQXyPIZsnyOOX+CuXjmt58/Q549RZ48xTz3+5qn59jXLiienVM/89cuni2oni+wFw2VKbvysar0c9XYXg7CmHt0LLkqWz73A5sm8W7DpXLuH85TuaSzoBxM5VLkU8Ilqf31p3KpCHyazKVLEhUzlzKmImePJRjLpF6H4cpsAPPZcmXb4uHT0eOLT75Y2da86W0r2+oXP21lmzx8O/bB21e2lyerxxenq9v08TtGx1S94VNW933Tiyvb5q9/ZfT4xcn56vXtqktumx72GXcT67g0tn1TLgEsHr+2sm1TLgHUn7TKm224VIzs27zuZ6xs25RLAIsXXl3dtiGXoN8cKmP3ENfs9e9QkT0HA2ziNYjCLCZIpYlS89mSoqyZzZatlbN4+JTy5JzywXPsg+eYMy/Mik++gLMF+uAMffAI8ELNLc5wiwe4hd9Wv/hp3ropHyD2BAHK4jE8eDsi0f3oX4dCTbVuFQTVGm3O/evjd+Ca51A98RZQ9RRz/irVGz7FWz7nT5FHryFPXkXf9CLmyVPM2TnmtQvc0znz179C8WSJfVJhny+wxZzqYua7NlqHrQpMVVI3lsI2PTdn40ywcMhx0yPBLrhUnnjeLB6/NolLWnpvQv1Jb++4FHhjN+RS5F3KJZrnXkGYwCX79ILmyQmLF16dxCWc8R0X0eyJy9gpsnIQcFUmdSrMzKAKIbo+Z8HaKecVs8U55ckF5QMf3y8ePMc+eoY8VOShF2IA+uARevKQ5vQR7vR1ftvsFDd/XSvAAIxZYOwCkQIThVfxuBVkZphAFeASzVS1Ru0DXOj4pVrjynPUneOa57iTJ/5cF59Als8wzz6BPXno7/+BF27m7CnyWnCPniwx88oLtaLGxnpz66hMcIeGZCuJjWLSUkdnroybZqF297Bp8uEULhWBT1O5ZIx34adcEgkx/Q25VBaPe1zSwKepXDInsbJiIpfCa1a29wDNCYlHjSnCLFo3ZVG3wmwWLJvZ4oLy7Lm3bh75sIJ9tEQeFfDwAfrgIe7sMQDNg0/ysdDFIy/EoLNqgkLgx1Jgzbz9f50AG6K/n8W5BtG4bU4jBaoLnFmgQRFx5QOonnjBGnIezPkT7PwUs3gFWXjXriyeIPMnyHzpS8XKTqAZO++3o63W1IZvoCBATqy6K9g0+XAql+yjkBA4kUutp2CnXAqJhhO5JAuvSGQuZRwSsnKQYBthVgbNfjZbMpsvmS0umJ16q6Z88Jzy4TPso2eYxyGx6OEJ+ugR+uh1uJOHNKdeoLnTT0LLM3T+OiQqAvYECYKstWakQLVBxKJa0zTXz6BVbTBS4PCWlIZELJUClQJnF+2YdHaGFjPsbIFZnPpxzuZI+Sp2do6UryJJ9zkJ7s+2Ne1leQaJUPPjGu8Al3F3cFUYYSqX5GFIKJzIpeh12yWXVEPvhYlckllQVDKXDhKHnBewT+xVORCRHwZeAxqgVtV37fN6UzBGtE2EWXR7zhcXXpidPWf20GcoF4+eYh89xzwWeOxdifroMe7sMe70Ec3pYzTkE2j5AC0feAEWrA1aAdYJrWaw+IdOXAwkKhtD9M4nRTsWjRaYKXCh1MuGci9jS8xshsxewRZPkCJYQEXXsz5dMe9SRKEGPcunG/dxu0XvIpfWheSAyVzSR0ERmMilIY/Sz7a/391wyVjvCchcOkTksMI+8YtU9WM3cJ2jQnPxk9j5G257GDtFtnCuxJ3ikqAo9+v7vI+8y8gYw9GGFcbyDIaWThrnG1o680UXE50/eEb56CllsHbM43PMYwOPH+IehcSos8c+USrERLUM/Qvsoq2rbi0OrUGLVYvGVb39moufDNs3sHyS2u2exWPKle2968ax2W4diKhHq7FgLGIsxhiMCWVm5rmft2Q53cugKq01k1Yx+DrunHV96NiGS2ny4RQuacwv2DGXuu1XcMkUHe/YDZc05jLskEtda2Uyl64BUc1hhT1BgX8g/lf9F1T15eEOIvIS8BLAG2enex7OOIZ19+kqcL1mLEGYxbgo0Amzx0+xj0Nzocc+WWpUmM3OfOOVtNGKq1FqaLraZk2arQB+8Y/wJ9CtMZ78cIcLhOiwmYuxaE+Y+YYvagqQoquWXtMERk0BdgEzf81YnW7D/1EgGfMEMc9hZHW7ywRSzL42QJMkVAHZo3AFlw6BR9Dn0rDzYaxGACZzqTn1IYSpXJK0KdiuuGS61ylcSrs8ZC5lHAr2rRx8rqr+mIi8EfhWEfk+Vf22dIcg5F4G+IwHL9xIN4+xjOq0MiFd6KVn6ZQVs/mS+ck5s7OQMBWsHPv43Asy6ITZyQPcIpRZzU6gmPue7c53V/MDKLz5kAojVyNa+85rUWC52muwsXFG2N5qteu02yTDOlr6qaXitxX+/8InRmnsFBfHl4wLV3fnLOborMG5BuM6IWcA4QmWc3CdIBoKMw3L0ca/iMYZRLu67fg9ucTDcIS4lEu3wSO4nEvDzoe9yoSJXIodDidzKbZB3iWXwvbJXIr7TuRS/D9zaU/InoPdQ1V/LLz+hIh8E/A5wLddftR+cVUCInSeAzMUZjNv5ZQn513C1IPnmMfnyEMLZ95i0wcP0fmJF2ZJ33bACyQaaLqubt4rkAiuZB2EVnDVS8Q5f3xT9X+wyYIwKzBm8GrRkADlhZvxY0z6yrc95oOg89vWWUB+X7c4w4Qx6YMGcQ5xTzEu9L0PDVvUdcIr/h8XknGJ8NIkvAB9YXiMJVl3kUupshC5FNdGmMolTR7QU7jUrY0wkUsm6dMRudRy5Ha4pK6vHGzLpWPi0dY44rDC3toni8iZiDyM/wNfAPyLfV3vrsGcr7ZM3er4f3dn8tI2xlgb3Yy7yyVzgN+nfeV6vLmPvMvIGMM+PQdvAr5JROJ1/oaq/v09Xm8rrMszgEHZYrB0yrJuW7j2OrU9OPeLvZydoKcxhDBHZ4ueG1Jcg9YXCJ2VY85fba0ZSa2auoJ6Gaya/hKxBIsHEkG1hedAiwJpwwoGiqJdqrb1KBRxKdvOUmstokHDmFarNtbfM6BNBadniHOYOqwtUZ/7EqvGoBo6ujUG52xr7VR10SoITqUXL43f0ZHGS+8Nl8q4SulELsXfW8qlNBywCZfsKx/rcUnqNAxxtecg8q7lUuTYLXHJNYFPCZdSb0Dm0jVxpJ6DvSkHqvqDwGft6/xTcJkbNM2kjmvIF7bpllwOXdvKk3PKs+eYsEysnDk4maOLBRqambSCAbqwwPJ5W9SVCi8vnCovvJZB2CVrxRMFVx3Wk68bUAd1EGChoFnXyDNJfUNGkMJ0Gwsv2KSwnWCD7v/ZvL0XL/Tsqmt3BGr9sSwqZBmWs60vMPU5ZW3QOgjJxuAai1OhaWwvdmqN6+KlcNT12neVS1FpSLlUhp4GU7nULjcer7ktl+qoSOyQS0WnbN8GlzQqBxO5dIxhuoyrcZSljGOlVum2tMd76zkIlk5xeu4XTTkLMc3TAhZzCBZDCqmX/Spv5+OHrSUDXnAtL6CuOgtmGQRZ07SCS2uFWqHxsXrqGLeP/dXXEDvJchajUDSICdexQCFIIVAYxMZEwwKZld4yCkJOZ3Mv6GwJbTzV9Lwj/esaPyeL0P2taTC1X6ymqEJJV2NpqgLXWkGdQHOhrFHbDGtGS7IybheXcWl82eW45PLtcEnrwIddcilSYCKXNMkHGr/u5VzSuNZC5tIeoP53doQ4CuXgqvrgYQ22MY4i9HlP14+3iwvsyRIzr5FFIFVZQlH0hJmog+V5yKZuum2u6ayY1rKpvQBbVl6AAbp0UCtaJYIrWgjOtK8QhJuTtVp/e+8mtF81DrHhxx7+l8J5QRe8JBRLZBYE3Cws9hIF3GzeWkVShMxsMav36ifSz02YJ1k0mIsaGxaacVVBWdlWoMX16htnsMa1Ndv+RtffX7Z4bg7bcCnmHKRcKsNSxFO51P62JnIp9VpN4lJsYZxyKdznVC5J5MhELrmgbGcu7QHK0YYV9paQeOi49hros80Wa1l7/VdX16V3r2yuoVavrtayV6+eXWtM7tU1C7psCKkuVrap2fwnZkfWqx/GszPuDoqR77NYLK91Tnn25FrHN6O82bwvRPXa6r7NNXknT1ZlwTawJ6u8G+NSRsY2OArPQYp1btBhTwMbYqRFCCsUiyX25AJzcoHMQ5uSmYXCdg/A6H6qq84FOkgo9JZOSJZ69TWoau/uXHpfn3vFoUsDjUGXnctQa4M21icfOcMyCKm4pnssZxoqCHGxlthhLVo8gO/ZbhukCK+z2isI1iEzh5QNMgsu28IgZQGzc2QWwgpFsPQSN3CrICSuOI2x2JlF5jUmCDNbWYqqoFmWNGVBXRd+3m2Dc941Wjd2pRyr6/6WrZzbRNv5MFm5NOVSfEBdyaVZEEObcunZkz6XQiw+5ZJWweM2wqXm1dMel8ArCEMuDRG5U7122uOSsY7m1bMVLvmbv5pLWpReQRhwqUW47zg3Qy656hR7cnEll9pQwyVdSDOGyGsr3Fts6gaNtdjghVlZVhSzqrV07LzCzCukbGAmXXZSIsykrroTh6zndltMhlpWUNXe3QlQeQGmVYEuu1i8qyyuKhI3aCfMYnby8rVTn/mf1DmvvXejiPgFXEwSVugUhKZbJrZsWgEnZXBvzhqIAq4Mys2shMIiSZb2cE6664fkrZm05zTzCjv3c9zUBWW416axmMYizvQXm8nu0FvFLrhk554Pk7mUJuhO4FJUEFIudX0CNuBSuzJiwqUVZXs7LsksJi9O45IJc5q5dH8hIu8Gvhqf4fKXVPWPj+zznwNfiQ+GfJeq/urrXPPeKwcpUksnbXg07N5mbYMtGopZhZ1FYbZEytpbAUbABAI552Odw6QV5/rZ0VUFy6a1anQZHvqVbYVZjB26kGTkqqIrU2p8zoE68f+nXdEGlo6qQaQ/nriqm4hiwn2KUcQ6jPUrv0WBJrZp15SPFpCUdbB+HNIqB5X3npQlUiy7mGhq+cR5cc5neBtg5tpzmvkSe1FSzCrqZdnOf2rxtPc5aOaSrZ7bwyZcaj0HCZdMyOGZzKUqKA0TueSaLudgCpfSZZMjl9ptE7nUehQmcinmN0zlUvbEXQ5ZV75yU9cXscDXAr8E+CjwQRF5r6p+JNnnHcDvw3dS/anQSfVaOCrlIEWqRUdLJwqzoqgpZhWmqAcWgPMPJiNt2RNOO2smIpYdBjcn0BNkelGirfAKgqvqCzQXLZ5o6bi+MBt2GQTa/gHdPSZCLbhB08WkomAzJgi1aNEnAs0s4/3Xfg7KGgmWilQOWdbeEioMlIlAKwY5GU79nxGQRJiW4VphzgHvHk0snvR7WmfxZNwe1nGpKPxvJ+VS/I1N5ZIPvzGZSy5JPpzCpfZe1yjbU7gkVTj3RC7FBOPMpXuLzwF+IJQ0IyJ/E/gS4CPJPv818LWq+lPgO6le96L3WjmQxKJJMWztuhIjLRpsUWPLpmcBSOGiudoVQy+rTsC1mdTaz5IGL8gqi17MWiEG4C5muKqgqTqXZ1MXNHUQZq3nwGv+jbM9IQb93upj95/+38ZKAWuaINx8eMFUyf1XNWIbbBRywco3pcWEsct86S2gysdUKYKQmxmogru4tQrD/DhtTZUYnzWln2sbHia2aLB1g3z4qooAACAASURBVDUOF1y2jTNt7sFYM5dcq71fTOGSLeLvqeOSxAfpRC71vAQTuBT5NJVLQ06JUaxp2vdTuCStN2UalyTuu0MuZR4F6I3kHLxeRD6UvH95sLDaW4AfSd5/FPj5g3N8OoCI/BN86OErr9so7V4rB/cZVVW2PRjuC0zZ4KrrVYFkHA5sUdPU90vELJczZrPrVVwcGrIycAX23+fgY6r6rks+H/tyhglABfAO4POAtwL/WETeqaqfmDqo+8XcKzBceRG62KmxDhvcc7aoWxedFLGlaXR9eqVdYlc1Egsnbloq2kjrLQDQqsBdlJ3b88Jn/DeVxdVF28DEb+uamTSuS6DqFlYJGdZVubIK26X3HiwdE1ykjdju3k2DsbGZisOWFmMcLrh5TWWxVREsnm6bmVdI1cVQ/f37RDMxTWftBKjrpizOa5vAtSwxweqxtvQJXk33PcUmLm0Z6kjXxIybwWQupUsPT+BSG0KYyKXUcxC5NFy46Kr7Xi5nPS41YtvPpnDJBBmxSy7FsMYmXFKyt+DA8VHgbcn7twI/NrLPP1XVCvghEfl+vLLwwakXPSrlIKK3zGy7nGzfFWdsyDIeZmgr3sXp+kIOB9oMQghJ1nQUZM2y7MVEo9uzqfwr+B7pTWhkEpWD6P5sksQi6B6O65KJjIyHFsAvdCSiSONdo12GuaOpLbZoWiFrG4s2NaYxrXJgZxVa2zbZSqqYcNUgjQPbNY3psp5Y0XlF1LtEh2GdqsCGrnFNbAGbY6UHhcu4FMMKu+RSmkswhUupIrArLsUS6KlciknPmUsHCNWb8BxchQ8C7xCRtwM/CnwpMKxE+LvArwLeIyKvx4cZfvA6F723ysG6sqthq+R0eWbTliQ1vdh8hNbGE9R1Wcu+q1r4LFolQYhpKriCpdPUoRY5lhoFy6apC5p2AZXOymnc0NIZj5FOUQ5cEBAiijOmLXF0rsEYvyhSZ4F5C8jWBbbpCzM7r3zCU7gnU9fQ1GjsGAc+Nmq0na92PuPYTD9RMn4fK99TYvU0I/ecLaDdYyqX2kS9HXKpufBZ+FO5NGwrvAsuuUGi37ZciuXKU7mU8gi259I6HqVzknF7UNVaRL4c+BZ8PsHXqer3iMhXAR9S1feGz75ARD4CNMDvUtWPX+e691Y5iOgROlGze2vNBzdoW5JkVoUZTkBDQpTR7kxOfAvWtIY6zZoecXk2tW1jsU1tqeui5yWIgsw50wqqq5SDdUh13qFy0JajBQFngoYchZtzTStki6JuS71a66s0mMY3ZzLzJSYK9MZ4AWcbtOiy07UNzYQxq5D2sR/Ovw3JXQDSeGHWu5/gEs0rzN0MtuVS+n22SL77KVxqggt+Kpc2UQ7WYR2X0vufwiUt/fbJXIrjnsil+F1mLo1DDqAJkqq+H3j/YNsfSv5X4L8LfzvBvVcO4H5ak7Fn+r2CcW3Huoy7j/vIu7iIUcax4CDCCreCo1AOYLUWu6/5O0T6btDY9ay1NBoLS6BovNMmWcFNG4vWpl9bHd2g0aoJ7s9o7dRN2Lcx1E3RCyFEK2foOYivcVsactjo/sN+UbjpwPox0a0aLJ/UPRpLv4rG4MKiNs4ZHz/VCuuSRW1qi9ah8UuwALEhGS1VaIKF2Bt/cH/60I5rkyfT7611c+eyqxvHSinfllyKHoGpXGpCc5+pXBp6CoZW8iYJiU6lxyUdzMm2XOrlIkzhUtJFtR1/kgdxJZfCMZlLGSmORjlI0WsENHzgJPAxvfAAjku9Nl2CIIROa+Eh10uWSsIIQOv+jK7PJtZhh8YsjevnF8T46DAOelVcdC0SYdYkwiBu08SdaI1rBalNGsRY1wwaxfRdo9EV6hOu/F9X1+6bSI3Gntf0s9/0e8q4PWzLpZZHMIlLbX7BRC65gXIAW3Jp0BegSXpsxG3bcqnXhClz6bCgZM/BvhBaP34I+FFV/eJ9X29TDOOEaRIP4Emm0pY+GRKrIiFgXPNAa9vLmnZVVAb6ykEdLJ143hgPTZOl4v9DS6dVEEbLXi9vghTRqHTx4uAijQKu9SiotMu8xnOatPSrVQ6i0PWvNulRb4OgkyLGU71wk6H3IF1/PgkpDL+TdHzHivvApfgNT+VSqhwcDJcGive2XIrdGDOXMg4JN+E5+Arge4FHN3CtSxGzq4dZx+ssHa1t6zJ0zrQx8Z71HCydaN0AuMaulFTVTUiecuEz1xdoqfBKrZ6epcN497Z1WLtfsjlWkRmShKsRN2MUaDYdTxS60eKJ1pKakEhl2q5wahukMP3M9XQ+a7vW4klf0+9vXab1Pcad51J0oU/lUgwh3CcupR6MSVyKCsJELl1W/ZNxvDkHe83+EpG3Ar8M+Ev7vM5tIFYhTEXjrjf1+8govu6Y4mIvUxEtwIxV3EUu7SN+HZXtqVjnKdgU++Bdfc0ukteVRRmXQPHtk/f5d6DYt+fgzwK/G3i4bgcReQl4CeCNs9M9Dye97oiFkyb9NQYxtiv3SeJ77XoHF7N2pbfo+oyfpzFR8J6Hrsxq3A2a5hWMuT2HwnaKoDLDpKPo3Y0pFaHvetp/fQVhbRw1SaxUBVs01MsSdYKxwR0aXKbG+pKsuEx0CnVdolraCXKII4+RXsql2+KRv/Y4l1xjMbbpcWkYJ49LJ8f/N+FSv2Sxn3y4CZeU8RDDpoj7X8qlNNRwBZeMce29jeUhbMKlqCBELg07QQ5x5FzK2AB7Uw5E5IuBn1DVD4vI563bLyww8TLAZzx4YSe/2NRttg2iK841NjQzUSRsSxu1RMEHPokquj7jtjb5sDG9ZKl6TcLUMCbqVNa6Pa9ruaTH94TbwD0aXaPRlm8Sd23qHgXaBavS2KnVJryGbdbgwpK2MSltOKedgjDuFr0M8bu+jwvHbMKlffIIdselVDmYwqXIp0PiUppfAGzNJZOMYwqXxub0ulyK93bfuLQtBEWONKywT8/B5wK/XES+CFgAj0Tkr6vqr93jNSehzbrXzoIRMUDR7wUPvtwqEWhxpbco1ACcs9S1bb0F0PcSrEuYasfDqra/TpBtQ9yhtXCZBRStn7Tc0Ya2qynqZAy9MjEn2KJrmGSsL+VSa7pxDJrj9Feg7Mejjxx3kkvx+9wll4Zegm25dJlCMJVLaxVuuBkujcxr5lLGdbE35UBVfx/w+wCCtfM7b1qYXdawZEjCtDIhCjNVX7PdHWMSa8e027yl03Vli8lSw3rrVJgNE6XGwgdjguw6BF+XgT1qAQ3CDYau8dJobkJd9Oq4bRGsoljDrQ2ucZhEOfAZ1PEY0xNobdZ1MvbL7v0+d3W7q1zyPIJdcqltQXxAXBpTFG6SS203xMyl/SB7Du4PVGWrmJoXMLZdtUzCKmueQP0EKHXe0mmFTmN6i7sAvSzqYb31MJt6ndtz2+YsUxDPOaYkxDmMY4vu0Rg/TTGs46YAap+TYMPyej526nCNdg1yjJLOb+qKjg+IKfedLaTdYPj72PSYyKXIo+5c1+dS6iWYwqV98ghuh0tdWCFzKWN3uBHlQFU/AHzgJq6VcXfR1EW7MmbGOO4Sl+JqhBkZdxa5CdJxwWk/mzlaOi5aOvW49yG649QJLi7sEtyiznXJh2kIIVpAwxauaQb1vlyfm2J4r63Vk+4k/eQqv2PInh5altHSsU2XvGgF4xRjunaxY3XxTV20FmTqXo5zll2eh4XLuGRMQ1PbnXIpXutecSkJLUzh0rB/QRwHkLl0bRxvn4OjUg6cCqLSI6pTwTjBiaFp+uQaI5uqaYVY3D62vPJVwmzo/rwtYZZeayxhcRg7jUINEsE2smBSvNcYO7Xa4ERbwQZdjHS4PKyqaV3LrXt0xE2chdvtYSqX+rHv7bmUKtv3hUs9ZXsCl9JcjilcyjzKGMNRKQcRmgoZUdyIVdMlU/W3ayuUgvBysiK40kSpXjw0EWY3nV+wCTaJnbbZ1/QtHx0oUna4cJXxZWzGuZ6ls7ZGPliP7fcUHhA5BnpYuIxLXc7C7rg07F9wH7g0VLa35dKY5yA9PnPpGlA6gXdkOArlIE2s6gRS99Aerm4YNXQjfXeSSzKs04f+WMvW4XU2EWaHRNYx92gq1Py2fg13nMdUGEZryai3cpz0qxXSOY4PCaDNsG4SS3HYZyGOM+PmsA2X0mZXu+LSMPnwPnBpqGxvy6WYkJi5lLFLHIVykHE3kBPY7hfy93k3oCSLsWWsIucc3C9Ebb0X60NwChLipUDralMVzMB91wxKr4AVjTt9f1myVLz+urjoIWrtl1o8sNLgZdiZMm0ZG4/tLR3rdGWO2+Y3iRUJtG7QXgIcq3N5iPN41zGVS0a0W0Uxc2kjT9wULsUcnrE5jvtvy6VDnMPbQU5IPApEgqYuNvCEiOuuR4w1fEmJMxRocXu6bdOGLIdMxNSNDOOJVX775bHTuEzsMM/gqnkeJqZlN+hhIHNpe6zjUqps++03y6VDnrOM28O9Vg5SiweC9h0snrTPedqoJGKsOUl63mGsc+X9LTRj2SdSwdYT/PEf6ZZ8FdVeq1gI/doZT0JcN9djD47hQyJbOjeDXXFp7GGeueSRuXSAyAmJ9xepoHLqS68UQUOMbYx8m5wzYuiWG+5zlyybTTDMwl5Xx50KN4CGTnBNned1CWh3fU7vCjKXdosxTwLcPJfusqKVsT/ce+UAxuuOM3aPNOQwBbWzFCYnsN0X5O/zZnDdec7y8Qpozjm4t4hWDiQNRxL3aPQaTdHC02tsuu8ucN0H8S7Qs0biq0o7tzB0KfvXy+a5dsN+/B3um+V4FzH2na/j0rIurpQwh8Cl28bK77z34WZcSnmz0TUylzaE5rDCIUB1vWC4LtrzDs5/l+2aoYIwnLvL8iZ2jjXnvsvze1exTx71L3Q1l5b1QYmYS5G5lJHRYSPmisj/CfxpVX1/su1lVX1pbyPbE1a19O3jbWOWr1lTJ7xvd91lQuom26KumzvH6vap8zyc47vmCr1PPILMpX3hprl013h0o8gJiVfi7cDvEZGfp6p/JGx7157GtHP0XaHjpVL+s82QJgy1vcxl/MFlBr+r+0TEsXld2T6S7DR1ntP6b+jm9g7N6Z3mEWQu7QObKln74lI6r/dlTjOuj9Wm5+P4BPCLgTeJyN8Tkcd7HNNOMaZZx1XehhiL2y2bVf2pcqbNIB6ed4jraPuHirHxD0vSIsbmad08D+d63Tzf4fm7szy6DOu4NPyel00x+t1vw6UxPt1lrPstb8OlTeXWOi7dtzndOZzu9+9AsannQFS1Bn6ziHwZ8O3AJ+1tVDuGQzAoblAK1ziDg173tTpZPjZi2RS9mGNsNdqE5LvYDCaeU0RbrUtEW/IZ9C4/2IBOaHWWy2pi07BWvdHVsqlUoMVtlTNAN9fpPAtdVnWspXfSzekdsXjuNI+GXoOUN2NcqpJe/inS717w3+emXIrXTrl0R777FazzGKQc24RLcLXcSud5yKV47TvGpRuB6tEWK2ysHPxv8R9VfY+I/HPgt1x2gIgsgG8D5uE6f1tV//DUgU7BmAu0bQAStjfOoAi1G28IkqJPtG6bqPZrj0nIlxzv4jEDJeEukPGqEMLQpZw+JIDQMMc3zblsnqvQSAf8PBemq6HHOEzy3dmgeN2hB8XWPILD4pIbfHdXcalK2vamyFzy2CeXgI24ZLOCkDGCjZQDVf0Lg/cfBv7LKw67AP5jVX0iIiXw7SLyzar6T6cN9fpICRfdlo1617VTad1ul1n3Xkgpkgq0IOBiMxiL8+utJ4ITfAxHkgdaOq5DJeNV8dC0EZFLtjdqWgEGnUBTXbWQxiCiWFE0nMCK+i/OuLaD/CHP2xgm8gjuKJeu8pJlLq3mbMT323Bpk3m+jEt3RLG+PRyw63+f2Fudkaoq8CS8LcPfjc3yZZaOamfZNCo0riNg3OaP7cMQBVi/Q5kVRelqvDGm7RYnybFxOdZhqCGO99DIuYkwi4Kspygk1mM6p13LVtrjhwI/woakKRuXoTVgJH53cTx970Ec26HN43VxV7mUxrh3xaW0X8l94dJQKdiWS+2CSsn5t+HSHfbEZewRey1CFhELfBj494CvVdXvGNnnJeAlgDfOTvcyjmHjlnQ1Mhc080aFOol1jlEiCjIJlgx0q6VFweZP6jAigOuEWWL9RKHmx9N/sMFhEHKKMGs0xpg7K1ITgeaS/f1+4wvFCuCMCz/OsK69+sV8hE7wR6vnEOZr37iKSzfBI9iOS+1CPyPnmcol12bY3x8ujYUQtuFSp0isYhMu3VVP3I0g1Z6ODJtWK0yCqjaq+nOAtwKfIyLvHNnnZVV9l6q+63Ex3+dwMg4c1UiGeobHVVw6RB5VV7i7MzIyDhc30r5MVT8hIh8A3g38i5u45mVQOpdnE9yftQp1eDjV2k+0gk6LiolR0bIxorho6Rh/hKrBGiWkSwGrsdNhNcMwbho/u0mMxS7HcgyGls7Qjdw4Xx7VJKWIaSw6jafG84CfkypkqKsz7XwCiApGJViRx4u7xqVqwKVhvf22XLLhTPeJS2P5BdtwaejNgf6cZC5dE0fqOdibciAibwCqIMxOgM8H/sS+rrcJxmrxWzeeM11YIcROh+LEu0LD0rVhm1HBieKM8yQkJvy4gV/GjCZXrUusimO7KaG2C2HWuDh/q67lKMj6pVh9V2i8mg3zJs5g2ofEala3AhyBG/Sucil9wO2OS2H7PeJSFy6YxqUuUbHDNlxqjzsCLk3CkU7LPj0HPw34qyFWaoBvUNX37fF6G2M1Ttr9AdROWu/BECJKIdAE+lnjhZs603Z2c6IhA7ETak4B01cQgJ7l45LL3WTs9KrEQ1hNPgQvuGKyVExEg655US+PI1G44rbhddsOeWFSDLTzZGOcVQV7fAbPneRSHX7Qu+RSmqg4hUv7VhCmcCnyZiqX1s0tZC5lTMc+qxW+G/jsfZ3/8mtv94sfaut1IuDSKhYjvtVoI9K6QptGKI1PpIrJUhgHzuBEcMGu6Swg09YZQ5JYJf0M4Ztwj15Vpgir5VWxlh28MIuWzdDtmQo1gMql1k53vTi/RiDt8yZ+qrBbfpdxrPcpseq2uLQtj6DPpd7DbEdcShMVp3BpHz0RNvEUwHou1QMvwbZc6nq4+OtlLu0QCuqOU4PKGWC3hLH2sNtgiuA+dFRHSsL7irF2vRkZGXcDd2c91Qm4rGd4tF7Tmvm+ti49KzdCxFshNrR1s6I4B4VAEUMIzlCG2ClRCTDBv+cchfEdy5qQKHRZg5du26rls61Wv06hWNcCOT3mKkunSmKiVeJWHlqPjUtdrd01RfxcVr4nsk9USz0ng/3X3cO6Ff0yroeD4VKbWNdxqUk4dhWXxrxx3Xhuh0sxhDCVS6vzmoRVJnIp8yhBTkg8XniyJG1gA/kqlwi8QEzfuEUowgdWwBrxrtDAuNJ4V2eaJdz93wk1CEJiTYMX6Ndww+rD7zoehMtWfxvmF/ieBKvCrA7JZ/EVoHamfSDEcrbGhf11zZwqxD66RkPjFh3vg5BxuEi51FcQ6DXsgWlc0jXKNmzGpTGFux37RC6NKQTtZxtwqUl4M4VLK3OaubRbHKlH814qB3HxlrjY0qbQHvmikhA/a8+OFWjCaa1Aod6oKVtrB5waNFkLNSZYqSgqdCWO4rtsjDV4gdXSr+tayOsE2XA52GGDlc5L0FcOYjy0CkIMOmuncmlSWhcjbQZDF/FzasIkGwcqwjZpwnl9+t2jTWqbyKUm/IhTLvUt1u25lC7nfF+41OUSZC5lHA7upXKwCcZKfF37KkGgQRU2eg3dK+S1too5VoRGYs1/2BasH8W1PRLLsexrCBLL13BLPIFndNtyOWKdBbQthpZN3JZeK7o905atUZjFZkWtIAtuzyp1hTr/WrUhCP+Xli/G+fSWDu268lYENyLMcln2YWIdl+JvNOXS8Lvflktl8rC6L1xKlYMpXEoTETOXdoyckJixLZbN9Y6vRte13/zr2EdC4nXPeTFCouUW8bqxVeWOk5b3F9UWv4cxLPeQyLvN7360MuHavLnePY3N6TZjyt6BjDEcledApL/QC/iHzxiNnHbeA+g0dQhlWHgFwRrvDm1UaALHy+AadZg2dqqhhjtaPj75zuJCrbYVh5GgILiuW5xJLZPwasL4hiJlSPK1SVMDt2d67rS3e+zr7u+/K7FKrZoYE43x0Ivg/qy0qz5YxjCNCxZlMkwjBDeof/Vj699H+h3Ffvxj95txc7gOlyq3yiXYjEulUZbO9LjkJP6GUy6FkYxwaaxj41XJiWNNuOK9xddh59Du3q/m0oUzPS5F7qRcSmXRkEuVu5pLMnjNXNoEchA5ByLybuCr8VWqf0lV//ia/X4l8LeAn6eqH7rONY9KOUgRhZoR7RaAST7XoAwMCRkRZY9Vn11tTSIQTOcajc4AT2QfO1WgSBIVY+zUBl+gU0NhtF2Nzl9PW/doo6Gz3PDhv4G1MNZqte3YlvQvGDZjSdvitspBEGTeDdopCD4+ClUyZ3WYy2GWdOzgZgefxSzz4feUcXjYhkstnyZyqQ39TeRS+xAccGkFW3DJDbZty6U0vyBz6QCxBy/tNgjNz74W+CXAR4EPish7VfUjg/0eAr8NWFngcAqOUjnwdO0eukNhFpHG8xrXkRK6OKkQBJp2iVWFdtZPjCfO0F7stI0/ilIat9IwSV23fC3QxlBbAZdmKG9wz0MBBkmMlK5Xe9w+bMbSJktplxgVY6TLpu8pqByjAi2dT3+ffmBixtOlolCDaKl231vGYWBbLg0fcLAdl2Z0PJjCJUmemlO4NPTgp4mG/j6351LqiZvCpbbLYebSfcXnAD+gqj8IICJ/E/gS4COD/f4o8CeB37mLix6FcjC0FlS0FUgGbYnTLgCDIhIfnB61epJ6D0BHKhOSqFYFWuiBnngOmhA2KFRpwrXKYP1Y0baDmRXFmtAaNhIaP+ahgDOibJr+kCoD8b1PauoLtCjI+l3ZTM9T4Ld1LtCl62KfUaClDwAflomWS3TvAqbr5ibJd2IHDxoT7t8MHj7ZHXqz2IZLplUaOi7V4fCpXGrLjSdyKT4Qd8mlLrQwjUup52AKl9pbyFzaPfRGEhJfLyJpCOBlVX05ef8W4EeS9x8Ffn56AhH5bOBtqvo+EcnKwSZIS7CMaEvQ9qErXoAU6YNY4uepReAFU+W8BdLFTH2tthUoAiM7gZYSum/9tKWNOBq1FMZRJPkIVqUVbPE+4rhSjb8VzGuInVo13QItaZw0VGcMWrYOV9fz2eadpwBoLZwozFYFmnaloGHO2oxqoDR922U4/0WisHXfyer+uWHLzWBbLknvt9lXtqdyqf2NTuRSp7DsjktdlcI0LlXhXFO5VJr+3A6/k6u41Ps/c+k28DFVfdcln49pJ+0XJSIG+DPAl+1yUPdeObivqJ1pY633Bf30qYy7jkK0beZzX1A5Q3nPeJdxBa5ZTbIDfBR4W/L+rcCPJe8fAu8EPhC8dJ8MvFdEfvl1khLvrXIQGyGNbRe6GH5MzrGibeyuCBbM8OhGtf1rxYN2YYhorRStG7GfgFUZYW68izBq+6UKpSilQmM6aydq+jaxzgR61k/tzMA6W0W/MiFsi/XnzrQd1nqrUkZrZxAPrZwES8bvd5HEQ/vWjlKr+thouGibHa5djNQolGEscZQS5t8GKzRNohK0jWuvQ3aN7h6HxKUYd5/KpS5M1+eSvx/a+xhD5FLlTI9LsdXxVC5dxFyCiVyKPQ1SLsX5nsqlzKODwgeBd4jI24EfBb4U+NXxQ1V9BXh9fC8iHwB+Z65WmAADbWzRCzKHlc4SL4z4/u6y6s/xbWE9YXvnFKEO/xfGUKtfJ6AVXAZmQcCVOihLCvFTG1hfGkctcWydkPOtUX2sNxVym2Qe+wzqkGcQtnVli32BFt2ejXJlPLRzg3Zz4vMz3EpMGby7OMagI2IiWhEfKEYpjGu/m3j/kBtzHBou41IRfvu75FLsnDiVSzZ9QE7gUpdr0HGpX7a4PZcinzKXDhAqt17KqKq1iHw58C34tJKvU9XvEZGvAj6kqu/dx3WPSjmISTlNYkFoiOVHCwN8/bQnlbQkiz8PDZZOQ9TifR94g2DCXlXjKMVgpVsspXLSWjtV+AOYG7+91M7aihZQTzkwfuytkpDcVxdf7AuP0e5tyf+NxqVjBwlTGhfL6QRa7bynIMZAIb7XILy9FeiPD8IM7SVOxTnSVshJJ8yMF2Tt/EtMpOruMbV8xu434+awCZdiH4KUS+nvdgqX2gfsRC7FEsepXOpXJtBLPpzKpYtW2Z7Kpc5jMIVLmUeX4xBWwFXV9wPvH2z7Q2v2/bxdXPNeKwfpGgvQudMlEQiiwdoxQqHRyjeUxjdcSa0fGzR151zbkrTSxv+f8KvAsFTHTAyVxvbJnXCbW2kfsFXoI18aoZRuWyHihWpUDpwfdyGx+Ux3j8NFmiKGPQ20rU7wqNU3bmmUkDAVXaFp85UwpiSEcNFEq8YLskqVRh1LDfXmKPWg6MuoUIrFqSLGj9iKtMIszref/2DtGNdaO+vcoF2CWRZw+8QULpXhe065FJXtqVwqpXPXT+FS9ChM5VLf6xYrMKTdNoVL0UswlUtWOhmVuZSxK+zNsyQibxORfyQi3ysi3yMiX7Gvax0jnjX3zyk4z4leo7irXLqPiXvP69W25xn3HM7s9+9AsU/PQQ38DlX9f0Lnpg+LyLcOuzrdFtq2qaKh7WgSVjCOuRGW0uUMFMZb7z5GKTjXuUIbHE46QVgBRr2lU7SeA0sZLJ9apS3VinHU0tBaO23Og5E2rFCEMYqEJC/xCkLa3CS9t9FmLfikxM7Sid3awmvSZCVNjoJ+LLRy0dJTKnVU2lDjaMJV07kw7XoRvv2tMV3bZ9taOl0r3LlxlKEUzUpSQy96zDHSO8mlmlUuxeWVp3KpFP9wnsqlznPRKWRHlwAAIABJREFU51K8j0249Ly2PS7FKNlULlVJCGEKl9rkz4RLUdHOXMqYir0pB6r6b4F/G/5/TUS+F9/M4dYEmkFx0ie8AFYcLggQ8BnShTHMrDILgmtufQJRafxr18hHqaWhoekTGYNBsKEtSaUWG4Rb6Uznco2JVtIJziJ5aKYuQ++KpU90+g1PUqSrzfka7NjGNlUOugYrUXjFpiteqPVdnpVzVGH2Km1ocN39R5dzmAejBhuEuVEJsdIku9zA3MLMKDOrbZzUJ7O5kNwWXKHBDZrGSI+lJvuucimG6VIuzcOTbCqXKvW/p6lc6oc1tudSV6XQcalTDqZxqVKf0jmVSzFJcyqXjoVHU6B6I02QDhI3knMgIp8KfDYjPZ9F5CXgJYA3zk73cO3xMqyItMtbZ6V7zbs2QtUKM2FmYClecTBNjN+FWKQ46pBjrbg28yrayYUUFGqxWEotKBtP9JkYrPNWUOulEAlx0i7rOC5KY8UL03hHceEaL9RW73MozJSkJbR25WFRgAGhdKpv1cQ4aEVDJf4+G2mopaGmRgf2lWAopMAGYS4hgaowXdx4Zvzfwvr5jtZOaul0jY7W45hipOu4tG8e+Wtsx6XoiUu5tHTddz+FS4V4kTWVS+36AxO5FH/lKZeG669sy6VGvHIwlUuzWMGRubQHyK1XK9wW9q4ciMgD4O8Av11VXx1+HtpEvgzw6Wcv7P2XmVo84MmeWjzQWT0zY5gHDXxhNVkERdqlYys1VG33N0/IWuroIMWEK1VYjBisFhRSUGrpr6WWUi2lWIowgJidXRppPQdWJAizINTC+CVsW/fzjRPqtBNuUZh1i+H47OgYLmhCuKBGW6umwisClVSt4G6kxnXO4PZeBUuhRZjvIKQxlGKYG2ERwrYLG4WZMguJU37+O0sn7Qd/7JbOZVy6aR7B1VxKPXGRSwsbredpXKqCJ24qlzo+TeNS2xkx4VJf2d6eS01QtqdyqeNT5lLG7rDX0JOIlHhh9vWq+o37vNbl49g9AWbmelP3xLx2reNfq3d/T6821bWOr7i41vFltlrW4lC4tA3sHr7Pc55c6/hXq/rqnS7Ba9Xh3dMi50juFRqquvb1d6jYm+dAfHeOvwx8r6r+z/u6zubjWe8Sje7QGKdr1NdoN8bRhLCCjyPaUJcsXDhlZgyV+jhohWlNDqWh4qJdGa67jkHEUlBgKXliXsNqwUxnWCyFxmQri8VQOION1oJ0lo8ReFI3QJG4RMfvLW2couHeOktH2yY0sdb81aaiwbXWTXR5LmVJIzUNVeLybXr36C27C0rmQIFR092TWGbGMBt4Dk6tY2Eds5hAFdyghdGNEqeOwQ16SFyK870Jl4w6cKbHpei1SrkUFe1NuXTOkz6XxHsONuFSIcKrVd3jUvQmbMql1yrtcanRTm5ELtWhFHFTLp3zZIVLwGQuRUU7cyljKvYZVvhc4NcB/1xE/lnY9vtDM4dbRXSH+v87d2hsA1sa5xNRSBZ6sYRmJsYvn9quzW6pm4IlNTKgX0O1Ej8EWGKweIFmxHAuJZaSUmcAFHT5CUWSgGUQrMTkLOGVqm4F2Trip1d3QXDFZKdGO0dmKrxi7LOSJQ1Vey8Ot/aeBINh3ntvsczCT2xhLKfWcFrASfjVpcJsbhtK07TzP6zFPnI36B3lkqxwKaQH3BqXbLjWkEv++GlcaoIicFtcOg3NGzKX9gDloMsN94l9Vit8O+vDd7eCMe9BbHyiKhCsV3VCYRwOYWY9yRxdn3S/Prs/vlFDowWVK2lCI9lG6tbF7jQeX+E0sQykiylaKb0AiBYQpU9AomzLlywFhRaYkI4UlQbfj36se338uCsTAy+sokByotRS01DjxLXCq8ZbNanwarTyok8H3hAxGEqsdASylMx0xlxLToz/iZ1aw6mFswJOQ9z5pHDMrWNmmzar2p8zrqB3eTfEY7F07iqXYpZ3yqX465nKJRd+o1O5ZIkJjdO45JIHauSSk8it2+HSSeHPM5VLx8KjqcjVCkeGsU5vRmOykgPjF6iNAlBVgltUcHRLsjokCLWybQtca00jc5ogGMALM6dV5zpM+BhdpNFaSgWcCeVLlgIRiwmWkknsG6NmxdKK6BSBaN10giv6DWJldaNVe4wXYA5tlZtVC8ePoQxZ3ja4QKHUGSc650xKTkN6+FkhnJVwVnTCbGFdm1ldGteGday4NTXnWYgdItZxKZbOpVzS1hM3jUvxgTqVS1E5mMqltMQycimOYyqXuutP49IieA4ylzJ2iaNTDi6zeNJ6bd8Ktsv6nYVFitT6umYXLHqnglOD0wIXVqBxTnHGCxInqecAVP0DWdv2qLGMqxNIIqGqW7xCED83Ep2gplUaJMRnDeNZSa5dFicIN+08B9F6iYKr0S6XYDi+eK04Nr/Bj8lKyYwTZnoCwJk75VRmnNmCB0UUaPCgUE6t69ygxrtB48IwkrRvHfY0GH5fGbePq7gUP0m5NEvWKJjCpc5zMI1L8bNdcknD9slckm5MU7i0iDIqc2kPOOykwX3iOIMp9wBP64/f9hB2DnsP2+0eM+6jcHna3D/eZWSM4eg8B9C3eLzDU3qLrrT5B67rf1Ea770c6tn+KAmvYTobvOlkOne+SrB+cDhX4aLbMVgbK2PEUOEtHz9m21ob/nPL0/rj7Xt/L31xPHRfRkur/95bOprEP9eNR0JM1JiYAFZSyIIZpyz0jIfuAQAPZM5DW/CwNDz0u/KwVB4UjrPCsQh5HDFxKu3elsZHU6smLwpzmLiMS40GOz3hUuzmN5VLGsNjE7mUeuJSLgEbc+lp8/Eel1LPwBQumZAfMZVLcxuTDzsuRUU7c+mayAmJx40o1CLa/INLLFnX45UXap3LssDUtELNn5Q2nVulE2KqrveQTq7A0PZKBVt/+9U/3nUCa/Wa8X7ouWGjYPUKgY+Hzswpcx5wqg956B7wKGx/WHgX6MPSCzK/zXFivTCLysHM+OSpMqwa1zWjWRVkGXcDKZfa7PhdckmS3W6BSzpIItwFl2bGd7ScyqVZqEzIXMrYJY5WORjWa4+VZBkVNLZUNsrqEizJ+TBdKZQYhBKpBRNOakzIGYjNkxLZoc4FoZMIuXaH5JorQnQK1t1DEqdtrSrbCktjSqzMKc0Jc+OtmkUrzM54KHMeFv7n9LAUHpY+LvogJB+eWMdpsSrM0hrsq0qtsqVzmFjHpbRzYuRSTJSbyiVjkpyBe8KlBZ5PU7nUdUPMXNoHcrXCkeKqpKouNclXMIwJBCOx9WrMkI4NiwqKOrRxdZaZlLxmSqwpuQiuxAv3BMFQu+fJmatOwK0kM+0yLh/dqrHpTGrZlBgpKIxPjLJmztw8YC6dMHvoHvJAT3hgSh4UlodhKbyHIZP6rEiSD+24MPNu0C5pyl8/J07dRQy51C2QlXKpq2CYwqXSxXUUpnGp7+bfFZf6ysC2XHroHgJM5lJamZC5tFso6xt+3XccZzDlHmDo3rwPyEIr49BxH3mXkTGGo/ccpEjrtYflja3VM2LxCJ23AcAmi72UoXFJURvKxlI2JU/NgmchpmhtyVKeYaSkds8AaJzxo9EaDYuyiIKGVqtxqcUpgkoIpll7pwWIQSiQsOKdkRJrZhTmlDJYOzNzygmPONWHnDkfI30gc86KgochJnoWfk1noczqpGjaMqv5lpZOjo/ebQxzDzb1xF3FpaIObYUncinqnymXdMvfWuRdx6X4fhqXHoTxT+VSm8y7pmwxc+kaUMkJiceMoTt0rIKh5xYdCDWBXu9yK4oVEwSaP+/cGOZ1ybw2zF3BPAiEuZzw3Dzlwjzhwvlttbugds9o3LLLxKYmBFVRcUjbACYoCmsEQK/bm/isyDYJKxFkUYgBFOaUIro+QwjhRM841TPOdM6DUK1wVlgepg1ZQufD2BbZuz79OMuJwix7E+4WhtULsJ2yfRWX5iHPYCqXWqVgl1xqqx6mcems8LMxlUs2UawzlzJ2hawcBFymIPj3fQVBTBpb7ZcLWbFYUUrjl1YFmBlhZoWFLTipLaeNf8A+c3OeyhnP5IznIdFvaZ5R6TOW7jmNi61jq0RZcLjQZIXwoJV1XoRe9rXBSEGMJkUh5l/nzIJlU8opM05bIQZwpnNOgyA7Lfy9nxX9Fq7RslmENq7zpI2rFZ9JbUTXCrOcNHU/sK2yvQ2XZmHfqVyKyvYuuRRLEadyqfMSTOPSMPkwzvnwO8mYhpyQmDGedb3GNdrTzrVPzEIUK5bSabs62szGVdSEEyucNn7qn9aG06bkuVvwTLxAey7nXMg5S/uMpX0OQK3n1O6CRmvfOnZQ270uxNDVcofaaunqqq0UFGYe6qtPmBFKqnTBiS441XnXz70wnBWGEwun4VdzYpXTQlmY/sqKc5uUKLZCviuxysLs/mMbZXsbLs1sp2xP4VKt5wCTuZSWI0Yu2RBCmMql1kswkUtXheQyl66HnJCYcaN4cX71PpfhYfnm3Qxkh4j9CzIy4DAfSi/I2651/MPZ4fHuEOc54+4jew5GsEncNC7SFLu/GZG2n7lBEXy3PxuarZROvbXTGE6s8LwRXpzDiTWcN4bnjeU8uEfP3QnPXc2FVFzIEoALOaeyFzRUVFzwen0LlN3CLrDajS1t8JIuQBMXdbH4/+e6YB5WfgM4kYKFsSysHyuE9eKDlbMIlo5fOEmZGdeuXrkIXQ9jTDTOSbZ0jhNjHRTj9ilcKkPHpCGXYDMuXcg5L8jbelwaLpIU/+/dR8Klh7M397gUl4yeyqVu4aSOS9HjmLl0y8gJiRlDXBU3bfuuxOVpVUJyFRhxiIBVoYgkd4aZM8yNMjeGhY0CTVg64bwRzsNi9+eNZelKzps5F85fqVLHhdZUUvu136ThTXwqNXWvNXMKg2mXfBaMX9ve+bXtAUotmEtBiQljSl22tH9+mxdkc9MJs1lwd5bJgi9AEg91PTdyTpg6TmyapLgJl8ogqKdyqQohgyGXgI24FJWElEulejE6lUtdomHmUsbhICsHl2CTxCpEEfU6vQQh0ziDsUrtJIkTqie/M8yMYRmE3MIKtRMunOE8WEBLB8tGqNRyEYTc0kHlZlSqNOEPoFEvxpwqTvsCwYhgiEI5lIUZ31QGoAwlYjMDcwuh7wozCzNDEGBdw6Jo2ZSJMIur7VnpShQFHc0vALIwO1LsikvpQ3MKl5bhmT+VS70Sy8ClMvJpIpcin6ZyKXsL9ouckLhjiMjXAV8M/ISqvnNf19k3xpIUoVuQyW9bdY+qCmKE2C3WiOJUekoCwEKFyhmWzrXrtVcqVE6oHCzDhSrnF7KpnNAoNOG8jcbla9eNP14fbPIHfhEcGxbDmRltF8UpjU/+Ko1jZjphHMceBXSRZExbcT2htanbM/0sYxz3iUtDBQG241L8PU3lUhWUg6lcioUVKZcib6ZyKVYhZC4dHpSckLgPvAd49x7Pf6sYEtOIriw5bI2jNKtJenPbcFLUvW0PioZHZX/b62YNL877x79hobxhobxx0T/nJ5/AG09Wt71psF88fojXzRpeV66O6Wwwzrlt2vyCFDZRGiLWrSGfsTXewz3h0tjvYRMugY+/zwZ82pRLAC/OG96w6J93Wy4N933DQnlx3h//plwCfH7BiNzIXMq4bezNc6Cq3yYin7qv8980xtZgSF2j8TNrXOsajZQvTYNVoVHTehAAToqaxhlmxlEF6+dRWVOp0DihCvu9OG96lg7AC7MGsDQDS2co1MALNUk8BuCFmrd0tCeIXlfWWNOVYAKcFbW3aBIhNrPNipUD/cZG6dzF+Rqb14zLkbnUP2ZmmklcasK+b1i4Fa/BGxdsxCWvrFus0PuNvzjXrbmU7luGcELm0oFBc1jh1iAiLwEvAbxxdnrLo7kcwxADrNZv+21dDbcmxxrVVkmw0ZUpiiqUxrTCywVB1qhQh22NCqoSXJ/+sxdmDY5OoKXLTsexdWOPeQedsLHix2VFQz15lx+Rujjj8V540W7rVnwb5BKMWDk5v2C/uEs8gulcah+OE7kUtw+5RLjOJlx6cd70uBSV7qlcGgshtNfNXMq4Jdy6cqCqLwMvA3z62Qt34pe+NnY6KNPy2zxS4Wa0s3gK/P9OHU2oLFD152pcJwaiEHPRK5EINH/MuHY7FLRGtBV7UWjFbdEzYNCeAKM9btjRcDVJKr1mtm5uDneRR7A9l+LaDFO55BJle1dcMgNFYFsumcH5M5cOCYJqLmXM2AIpMYfJitAlWaU/qzELSFWw4gVUEQWjik+MMq4VXFHIaWIRQX9ZejcQamYgPIRVwROFVxRY/ri+AOvvv2rZDOcjC7KMbXCTXEo9A7viUvoAz1zKuC/IysEO8P+3d+/Bkpzlfce/P620EuiuCF1Kq1gQBEbGgMhBgFWGii6UMBQiqThBCSARqP3DAUPhmBLGIVXYTgiuEEiZorJZAcIS5iJE2BBxESsIoQyyVkgGpAWvrMLWIoFYbO6FlNV58sfMETNHPXvOnrNzumf6+6G6dnq6p+dpVm/vM8/79tsr9aH+4r2B5b+Alh9j6QJXI6XNpYvc4DPj76/WwxcfRi9Ij3x/eZlz9DxHt4++t3TOy3kh08GYdlt6uEpgW9Jq9XTMwdTqJUn+DPgS8MQke5O8clrf1UfLRzhrftmWuuNIpwjvnRqO95rW0lXTvFvhsmkdu4tWLI2O/PLZNPrrKMP5Dxgvay4fsLU06OkXJdCsKUEY/6Uz6VdLw3sNJc9f7O+vnGmyLTWPRYCDb0ujd+yMtqWDsZQgLK8ONMVvW9KsslthCiaNxF4yqURKftFPurxUuvzYy61mENVyTWXOh7cd8ILXfEwvYjrUJk1CtqQLbWl5+dW2NEfKWxk1BU2/gODAiQI88tfQw/uOXOiWm3QpWekis/zCdaDPeCFTW5oSbrAtSdNicrBBVnNxW9J0kYNlF7pHfMHBX1QOXFVY+XheyLTRJiXc0F5bWjFpWKEt2Y66q7yVURutaVT2Rn5e0sGz3fWP3QraEKO/EiZdaCb9Ahr9/GHUIbvDZjVVgtHvlrpg+X+Pq2lLozMfrvW/5/VW3Nbz3dJGMTlo2YHKpKOaLjqrvRCtlRcwzZLVtKVpt5lJbEszqvr7VEaTgw450AVkmv+BeuHSvDnYOxGm/b3SrDE5mBFedKT1sx3pYFk5kCRJY/o6ILGf92hIkjQjklyS5JtJ7kpyZcP21ye5M8lXk+xM8kvr/U6TA0mSGizNczDNZSVJNgHvAp4PnANcluScZbvdBixU1VOA64C3rffcTQ4kSequ84C7quruqnoQ+CBw6egOVfW5qvrZcPXLwJb1fqljDiRJarIxz1Y4OcmukfVtVbVtZP0M4J6R9b3AMw9wvFcCn1xvUCYHkiS1Z19VLRxge1N20njbTZKXAgvAc9cbVC+Sg8OGj3KdJ56Tum4e/z49p/7pwK2Me4EzR9a3APcu3ynJRcCbgOdW1QPr/dJOJQdJ85PNDoVpHbdNnpOaTLMdHayuxHEoeU790oHk4Bbg7CSPBb4NvAT4V6M7JDkX+O/AJVV1/6H40qkOSFzp9gtJq2NbkvqpqvYDrwY+DewGPlxVdyR5S5IXDXf7Y+AY4CNJbk+yY73fO7XKwcjtFxczKIvckmRHVd05re+U5pFtSWpJpROTIFXVDcANy95788jriw71d06zcrDi7ReSVsW2JGlDTXPMwapuv0iyFdg6XH3gopuv+/oUY9ooJwP72g7iEOjzeax7hrFDaMW2NKftCPr932AXzXpbOihFJ8YctGKaycGqbr8Y3s+5DSDJrhVu6ZgJnke3zMF5rNiW5rEdwfyci+cxu1Yzi+E8muZZr+r2C0krsi1J2lDTrBysePuFpFWxLUkt6escEFNLDqpqf5Kl2y82Ae+pqjtW+Ni2FbbPCs+jW2b6PNbQlmb6fJeZl3PxPDRTUuXkF5IkLferJxxb1z/3aVP9jifs+OKtXRzH0akZEiVJ6oo+363Qz2GYkiRpok4kB/MwNWySM5N8LsnuJHckeW3bMa1Hkk1JbkvyibZjWY8kJyS5Lsk3hn83z247pmmyLXWPbWm2VWWqS1e1nhyMTA37fOAc4LIk57Qb1ZrsB36nqp4EPAv4tzN6Hktey2Ae71n3TuBTVfXLwFOZj3NqZFvqLNuSZk7ryQFzMjVsVd1XVV8Zvv4xg4ZzRrtRrU2SLcALgO1tx7IeSY4DngNcBVBVD1bVD9qNaqpsSx1jW5p9Vg7a0zQ17ExeCJYkOQs4F7i53UjW7B3AG4DFtgNZp8cB3wPeOyzrbk9ydNtBTZFtqXtsS5pJXUgOVjXN8qxIcgzwUeB1VfWjtuM5WEleCNxfVbe2HcshcDjwdODdVXUu8FNgJvvhV8m21CG2pTlQYbEOm+rSVV2IbG6mhk1yBIOL2bVVdX3b8azR+cCLknyLQVn6giTXtBvSmu0F9lbV0q/O6xhc4OaVbalbbEszroBazFSXrupCcvDw1LBJNjOYGnZHyzEdtCRh0B+3u6re3nY8a1VVb6yqLVV1FoO/i5uq6qUth7UmVfUd4J4kTxy+dSFwZ4shTZttqUNsS5plrU+CtMZplrvofOBlwNeS3D587/eq6oYWYxK8Brh2+I/l3cArWo5namxLmrLetKVRXR40OE1OnyxJUoNfOf64+tCzz5vqd/zqp3c6fbIkSbOkr5UDkwNJkppUfx/Z3IUBiZIkqUOsHEiS1KDo9iyG02TlQJIkjbFyIEnSBH2tHJgcSJI0gQMSNdOS/MHoc++T/FGS324zJmkWJXlGkq8mOSrJ0UnuSPLktuOSNpKVg/lxFXA98M4khzGYrnW6s3dIc6iqbkmyA/hD4FHANVX19ZbDUkvsVtBMq6pvJfl+knOBU4Hbqur7bcclzai3MHhWxc8BK3DqHZOD+bIduAI4DXhPu6FIM+0k4BjgCOAoBo8oVs9U9bdy4JiD+fIx4BLgGQweviNpbbYB/x64FvjPLccibTgrB3Okqh5M8jngB1X1UNvxSLMoycuB/VX1gSSbgD9PckFV3dR2bNpo6e3dCiYHc2Q4EPFZwG+2HYs0q6rq/cD7h68fAp7ZbkRqk90KmmlJzgHuAnZW1Z6245EkzS4rB3Oiqu4EHtd2HJI0T6wcSJIkYeVAkqRGRX+nTzY5kCSpifMcSJIkDVg5kCSpUX/nObByIEmSxlg5kCSpQQFFPysHJgeSJE3ggERJkiRMDiRJmmixMtVlNZJckuSbSe5KcmXD9iOTfGi4/eYkZ633vE0OJEnqqOGTQd8FPB84B7hs+CydUa8E/r6qHg/8Vw7BY8ZNDiRJahSqpruswnnAXVV1d1U9CHwQuHTZPpcCVw9fXwdcmGRdgyUckChJUoOqDZk++eQku0bWt1XVtpH1M4B7Rtb38sjHiD+8T1XtT/JD4B8A+9YalMmBJEnt2VdVCwfY3pSd1Br2OSgmB5IkTdCBWxn3AmeOrG8B7p2wz94khwPHA3+3ni91zIEkSd11C3B2kscm2Qy8BNixbJ8dwOXD1/8cuKmqrBxIkjQNiy3PkDgcQ/Bq4NPAJuA9VXVHkrcAu6pqB3AV8KdJ7mJQMXjJer/X5ECSpA6rqhuAG5a99+aR1z8HfvNQfqfJgSRJDYpOjDlohcmBJEmNfGSzJEkSYOVAkqSJ+tqtYOVAkiSNsXIgSVKDAhbbDqIlJgeSJDUpuxUkSZIAKweSJE3krYySJElYOZAkaaJq+dkKbTE5kCSpQTlDoiRJ0oCVA0mSJlistiNoh5UDSZI0xsqBJEkT9HVAopUDSZI0xsqBJEkNiv5OgmRyIElSk4JyQKIkSZKVA0mSJlp0QKIkSZKVA0mSGhVQDkiUJEm/4LMVJEmSACsHkiRN1NM7Ga0cSJKkcVYOJElq4AyJkiTpERbbDqAlditIkqQxVg4kSZqgr/McWDmQJEljrBxIktSgqr8DEq0cSJKkMVYOJEmaoK+TIJkcSJI0gd0KkiRJWDmQJKlR4SRIkiRJgJUDae4cf8SRdermo9sOQwJgz8/+fl9VPabtONYmvZ0EyeRAmjOnbj6adz35orbDkAB43l985G/ajmE97FaQJEnCyoEkSY0Kn60gSZJmSJKTktyYZM/wzxMb9nlaki8luSPJV5P8y9Uc2+RAkqQJFmu6yzpdCeysqrOBncP15X4GvLyqfgW4BHhHkhNWOrDJgSRJE9SUl3W6FLh6+Ppq4MWPiL/qr6pqz/D1vcD9wIp3jzjmQJKk9pycZNfI+raq2rbKz55aVfcBVNV9SU450M5JzgM2A3+90oFNDiRJarBBj2zeV1ULkzYm+SxwWsOmNx3MlyQ5HfhT4PKqWvEOTZMDSZI6qqomTlqS5LtJTh9WDU5n0GXQtN9xwP8Gfr+qvrya73XMgTQDkpyQ5Lok30iyO8mz245J6oPFKS/rtAO4fPj6cuDjy3dIshn4GPD+qvrIag9sciDNhncCn6qqXwaeCuxuOR5J7XsrcHGSPcDFw3WSLCTZPtznXwDPAa5IcvtwedpKB7ZbQeq4YUnwOcAVAFX1IPBgmzFJfdHlSZCq6vvAhQ3v7wJeNXx9DXDNwR7byoHUfY8Dvge8N8ltSbYnGXuyUpKtSXYl2fXD/Q+0E6U0Z5Ye2dzhboWpMTmQuu9w4OnAu6vqXOCnLJvspKq2VdVCVS0cf/iRbcQoaY6YHEjdtxfYW1U3D9evY5AsSJqyqukuXWVyIHVcVX0HuCfJE4dvXQjc2WJIkuacAxKl2fAa4NrhbUl3A69oOR6pFxbp7oDEaTI5kGZAVd0OTJxFTdKhVxyShyPNJLsVJEnSGCsHkiRN0OVBg9Nk5UCSJI2xciBJUqM4IFGSJI3o+FwE02S3giRJGmPlQJKkBkvPVugjKweSJGmMlQNJkiZwEiRJkiSsHEiSNFFPCwcmB5IkNRk8W6Gf8xzYrSDIbVnBAAANrUlEQVRJksZYOZAkaQInQZIkScLKgSRJE/V1EiSTA2kGJPkW8GPgIWB/VS20G5E0/4r+diuYHEiz459U1b62g5A0/0wOJEmaoK/dCg5IlGZDAZ9JcmuSrcs3JtmaZFeSXT/c/0AL4UmaJ1YOpNlwflXdm+QU4MYk36iqLyxtrKptwDaAJxx9Uk97SaVDrHy2gqQOq6p7h3/eD3wMOK/diKT5VxuwdJXJgdRxSY5OcuzSa+B5wNfbjUrSPLNbQeq+U4GPJYFBm/1AVX2q3ZCkfuhrt4LJgdRxVXU38NS245DUHyYHkiRN0NdJkBxzIEmSxlg5kCSpQdHfSZBMDiRJmqCvAxLtVpAkSWOsHEiSNEFPCwdWDiRJ0jgrB5IkNSj6O+bA5ECSpCblPAeSJEmAlQNJkibq6zwHVg4kSdIYKweSJDXo84BEKweSJE1QU17WI8lJSW5Msmf454kH2Pe4JN9O8ierObbJgSRJs+lKYGdVnQ3sHK5P8gfA/1ntgU0OJEmaYLGmu6zTpcDVw9dXAy9u2inJPwZOBT6z2gObHEgzIsmmJLcl+UTbsUg6ZE5Osmtk2XoQnz21qu4DGP55yvIdkhwG/Bfgdw8mKAckSrPjtcBu4Li2A5H6YgMmQdpXVQuTNib5LHBaw6Y3rfL4vwXcUFX3JFl1UCYH0gxIsgV4AfBHwOtbDkfSBqmqiyZtS/LdJKdX1X1JTgfub9jt2cCvJ/kt4Bhgc5KfVNWBxieYHEgz4h3AG4BjmzYOS5FbAU7Z/OgNDEuaX0XnJ0HaAVwOvHX458eX71BV/3rpdZIrgIWVEgNwzIHUeUleCNxfVbdO2qeqtlXVQlUtHH/4kRsYnTTfFqumuqzTW4GLk+wBLh6uk2Qhyfb1HNjKgdR95wMvSvIbwFHAcUmuqaqXthyXpBZV1feBCxve3wW8quH99wHvW82xrRxIHVdVb6yqLVV1FvAS4CYTA2ljdHkSpGkyOZAkSWPsVpBmSFV9Hvh8y2FIvVCHZqKimWRyIElSo6I6XfyfHrsVJEnSGCsHkiQ18JHNkiRJQ1YOJEmaoOMzJE6NyYEkSRPUBjx5qYvsVpAkSWOsHEjSBIelWKzVP+ZW82UGHrw0NVYOJEnSGCsHkjTisFTjuhWEfurrmAOTA0laZnkisDxhkOadyYEksXICMLrdKkJ/OOZA0lQleXWSE9uOQ2tnUtAvgxkSa6pLV5kcSBvnNOCWJB9OckkS/6XpkMXKAf/xX9pmgqA+MDmQNkhV/T5wNnAVcAWwJ8l/TPKPWg1Mj3BYamxRf9WU/9dVJgfSBqrB0OfvDJf9wInAdUne1mpgethSBWG0UmC1QH3jgERpgyT5beByYB+wHfjdqvp/SQ4D9gBvmPC5o4AvAEcyaLPXVdV/2JiopX7r64BEkwNp45wM/LOq+pvRN6tqMckLD/C5B4ALquonSY4Avpjkk1X15WkGK/VdUSx2uPQ/TSYH0gapqjcfYNvuA2wr4CfD1SOGSz+vWBvM7gT1lcmBNAOSbAJuBR4PvKuqbl62fSuwFeCUzY/e+ACleVR0+nbDaXJAojQDquqhqnoasAU4L8mTl23fVlULVbVw/OFHthOkpLlhciDNkKr6AfB54JKWQ5F6wVsZJXVSksckOWH4+lHARcA32o1Kmn+DRzbXVJeucsyB1H2nA1cPxx0cBny4qj7RckyS5pjJgdRxVfVV4Ny245D6qMu/7qfJbgVJkjTGyoEkSY26PWhwmkwOJElqsDQgsY/sVpAkSWOsHEiS1CSwmH4+esnKgSRJGmPlQJKkCRxzIEmShJUDSZIaDW5k7OeYA5MDSZImsFtBkiQJKweSJE3krYySJElYOZAkqdFgOGI/KwcmB5IkTdDX5MBuBUmSZlCSk5LcmGTP8M8TJ+z3D5N8JsnuJHcmOWulY5scSJLUaNCxMM1lna4EdlbV2cDO4XqT9wN/XFVPAs4D7l/pwCYHUsclOTPJ54ZZ/x1JXtt2TJI64VLg6uHrq4EXL98hyTnA4VV1I0BV/aSqfrbSgR1zIHXffuB3quorSY4Fbk1yY1Xd2XZg0jwrNuRWxpOT7BpZ31ZV21b52VOr6j6AqrovySkN+zwB+EGS64HHAp8Frqyqhw50YJMDqeOGjX/pAvDjJLuBMwCTA2mqNuRuhX1VtTBpY5LPAqc1bHrTKo9/OPDrwLnA3wIfAq4ArlrpQ5JmxHAg0bnAzcve3wpsBThl86M3PC5J01FVF03aluS7SU4fVg1Op3kswV7gtqq6e/iZ/wk8ixWSA8ccSDMiyTHAR4HXVdWPRrdV1baqWqiqheMPP7KdAKU5VDw01WWddgCXD19fDny8YZ9bgBOTPGa4fgGrqDqaHEgzIMkRDBKDa6vq+rbjkdQJbwUuTrIHuHi4TpKFJNsBhmML/h2wM8nXgAD/Y6UD260gdVySMCgB7q6qt7cdj9QXXZ8hsaq+D1zY8P4u4FUj6zcCTzmYY1s5kLrvfOBlwAVJbh8uv9F2UJLml5UDqeOq6osMSoGSNliXKwfTZHIgSVKjOhSDBmeS3QqSJGmMlQNJkhoU/e1WsHIgSZLGWDmQJGmCQ/DkxJlkciBJUqNi0QGJkiRJVg4kSWpU9LdbwcqBJEkaY+VAkqRGxWL1c8yByYEkSRPYrSBJkoSVA0mSJvDZCpIkSYCVA0mSGhWwWI45kCRJMjmQui7Je5Lcn+Trbcci9UtRLE516SqTA6n73gdc0nYQUu8UVD001aWrTA6kjquqLwB/13YckvrDAYnSHEiyFdgKcMrmR7ccjTQfBp0K3S39T5OVA2kOVNW2qlqoqoXjDz+y7XAkzTgrB5IkTVA9vZXR5ECSpEbOkCipo5L8GfAl4IlJ9iZ5ZdsxSZpvVg6kjquqy9qOQeqrvnYrWDmQJEljrBxIktSoOj2L4TSZHEiS1KCg07MYTpPdCpIkaYyVA0mSGpUDEiVJksDKgSRJE/V1QKKVA0mSNMbKgSRJTaq/kyCZHEiS1Ki/8xzYrSBJksZYOZAkqYGTIEmSJA1ZOZAkqVFBT8ccmBxIkjRBX+9WsFtBkiSNMTmQZkCSS5J8M8ldSa5sOx6pHwa3Mk5zWY8kJyW5Mcme4Z8nTtjvbUnuSLI7yX9LkpWObXIgdVySTcC7gOcD5wCXJTmn3agkdcCVwM6qOhvYOVwfk+TXgPOBpwBPBp4BPHelA5scSN13HnBXVd1dVQ8CHwQubTkmqScWp7ysy6XA1cPXVwMvbtingKOAzcCRwBHAd1c6sAMSpe47A7hnZH0v8MzRHZJsBbYOVx943l985OsbFNu0nQzsazuIQ6DP5/FL0whkw0x/QOLJSXaNrG+rqm2r/OypVXUfQFXdl+SU5TtU1ZeSfA64DwjwJ1W1e6UDmxxI3dfUP1hjK4OLyTaAJLuqamEjApu2eTkXz0MHsO9A/58m+SxwWsOmN63m4EkeDzwJ2DJ868Ykz6mqLxzocyYHUvftBc4cWd8C3NtSLFKPtP9shaq6aNK2JN9NcvqwanA6cH/Dbv8U+HJV/WT4mU8CzwIOmBw45kDqvluAs5M8Nslm4CXAjpZjktS+HcDlw9eXAx9v2OdvgecmOTzJEQwGI67YrWByIHVcVe0HXg18mkGj/nBV3XGAj6y2v3IWzMu5eB4zq9MDEt8KXJxkD3DxcJ0kC0m2D/e5Dvhr4GvAXwJ/WVX/a6UDp6pW2keSpN5JDqvBj+3pqXrw1i6O43DMgSRJk/T0B7TJgSRJjYrC5EDSjEtyCfBOYBOwvare2nJIBy3JmcD7Gdy+tcjgvu93thvV2g1nuNwFfLuqXth2PGuV5ARgO4NZ9gr4N1X1pXajmrpPw/6Tp/wdnZz/wjEH0pwY/iP0VwwGJu1lcJfDZVV1Z6uBHaThLVmnV9VXkhwL3Aq8eNbOY0mS1wMLwHEznhxcDfzfqto+vGvm0VX1g7bj0nR4t4I0P+ZimuWquq+qvjJ8/WMGd2ic0W5Ua5NkC/ACBr+4Z1aS44DnAFcBVNWDJgbzzeRAmh9N0yzP5D+qS5KcBZwL3NxuJGv2DuANHIJ71lr2OOB7wHuT3JZke5Kj2w5K02NyIM2PFadZniVJjgE+Cryuqn7UdjwHK8kLgfur6ta2YzkEDgeeDry7qs4FfkrDEwA1P0wOpPkxN9MsD2dy+yhwbVVd33Y8a3Q+8KIk32LQxXNBkmvaDWnN9gJ7q2qpgnMdg2RBc8rkQJofczHNcpIw6NveXVVvbzuetaqqN1bVlqo6i8HfxU1V9dKWw1qTqvoOcE+SJw7fuhCYyQGiWh1vZZTmRFXtT7I0zfIm4D0rTLPcVecDLwO+luT24Xu/V1U3tBiT4DXAtcPE827gFS3HoynyVkZJkjTGbgVJkjTG5ECSJI0xOZAkSWNMDiRJ0hiTA0mSNMbkQJIkjTE5kCRJY0wOJGlEkmck+WqSo5IcneSOJE9uOy5pIzkJkiQtk+QPgaOARzF4psB/ajkkaUOZHEjSMsMpgm8Bfg78WlU91HJI0oayW0GSHukk4BjgWAYVBKlXrBxI0jJJdjB4zPJjgdOr6tUthyRtKJ/KKEkjkrwc2F9VH0iyCfjzJBdU1U1txyZtFCsHkiRpjGMOJEnSGJMDSZI0xuRAkiSNMTmQJEljTA4kSdIYkwNJkjTG5ECSJI35/zx+vxbnwC/JAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "vis.slices.plot_3(mesh, uu_tot, title = r'$\\|u\\|$')\n", "vis.slices.plot_3(mesh, mesh.uu[0], title = r'$u_x$')\n", "vis.slices.plot_3(mesh, mesh.uu[1], title = r'$u_y$')\n", "vis.slices.plot_3(mesh, mesh.uu[2], title = r'$u_z$')\n", - "vis.slices.plot_3(mesh, mesh.lnrho, title = r'$\\ln_\\rho$')\n", + "vis.slices.plot_3(mesh, mesh.lnrho, title = r'$\\ln_\\rho$', colrange=[0,0.1])\n", "vis.slices.plot_3(mesh, np.exp(mesh.lnrho), title = r'$\\rho$')\n", - "vis.slices.plot_3(mesh, np.exp(mesh.lnrho), title = r'$N_\\mathrm{col}$', slicetype = 'sum')\n", + "vis.slices.plot_3(mesh, np.exp(mesh.lnrho), title = r'$N_\\mathrm{col}$', slicetype = 'sum', colrange=[130,139])\n", "#vis.slices.plot_3(mesh, mesh.ss, title = r'$s$')\n", "vis.slices.plot_3(mesh, mesh.accretion, title = r'$Accretion buffer$')\n" ] @@ -216,112 +90,21 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HERE ARE ALL KEYS FOR TS DATA:\n", - "dict_keys(['step', 't_step', 'dt', 'uutot_min', 'uutot_rms', 'uutot_max', 'lnrho_min', 'lnrho_rms', 'lnrho_max', 'acc_min', 'acc_rms', 'acc_max', 'uux_min', 'uux_rms', 'uux_max', 'uuy_min', 'uuy_rms', 'uuy_max', 'uuz_min', 'uuz_rms', 'uuz_max', 'aax_min', 'aax_rms', 'aax_max', 'aay_min', 'aay_rms', 'aay_max', 'aaz_min', 'aaz_rms', 'aaz_max', 'sink_mass', 'accreted_mass'])\n" - ] - } - ], + "outputs": [], "source": [ "ts = ad.read.TimeSeries(fdir=meshdir)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "KeyError", - "evalue": "'ss_rms'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlineplot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_ts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlnrho\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muutot\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muux\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muuy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muuz\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0macc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/astaroth/analysis/python/astar/visual/lineplot.py\u001b[0m in \u001b[0;36mplot_ts\u001b[0;34m(ts, show_all, lnrho, uutot, uux, uuy, uuz, ss, acc, sink)\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0myaxis2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'ss_min'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m \u001b[0myaxis3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'ss_max'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 93\u001b[0;31m \u001b[0mplot_min_man_rms\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxaxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0macc\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/astaroth/analysis/python/astar/visual/lineplot.py\u001b[0m in \u001b[0;36mplot_min_man_rms\u001b[0;34m(ts, xaxis, yaxis1, yaxis2, yaxis3)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mplot_min_man_rms\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxaxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myaxis3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0myaxis1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0myaxis1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 30\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0myaxis2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0myaxis2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mts\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0myaxis3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mend_rm\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0myaxis3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'ss_rms'" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "vis.lineplot.plot_ts(ts, lnrho=1, uutot=1, uux=1, uuy=1, uuz=1, ss=1, acc=1)" + "vis.lineplot.plot_ts(ts, lnrho=True, acc=True, uux=True)\n", + "\n" ] }, { diff --git a/config/templates/core_collapse.conf b/config/templates/core_collapse.conf index 03f702f..df70dbe 100644 --- a/config/templates/core_collapse.conf +++ b/config/templates/core_collapse.conf @@ -18,18 +18,18 @@ AC_dsz = 0.04908738521 * Run-time params * ============================================================================= */ -AC_max_steps = 501 -AC_save_steps = 10 -AC_bin_steps = 100 +AC_max_steps = 20001 +AC_save_steps = 50 +AC_bin_steps = 1000 AC_bin_save_t = 1e666 // Hydro AC_cdt = 0.4 AC_cdtv = 0.3 AC_cdts = 1.0 -AC_nu_visc = 5e-3 +AC_nu_visc = 5e-4 AC_cs_sound = 1.0 -AC_zeta = 0.01 +AC_zeta = 0.0 // Magnetic AC_eta = 5e-3 @@ -72,4 +72,4 @@ AC_unit_length = 1.5e17 * ============================================================================= */ AC_ampl_lnrho = 0.0 -AC_ampl_uu = 0.0 +AC_ampl_uu = 2e10 diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index 1c622e3..0187b00 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -254,6 +254,8 @@ simple_uniform_core(AcMesh* mesh) //TEMPORARY TEST INPUT PARAMETERS const double core_radius = DX*32.0; const double trans = DX*12.0; + const double vel_scale = mesh->info.real_params[AC_ampl_uu]; + double abso_vel; RR = 1.0; printf("%e %e %e \n", RR, trans, core_radius); @@ -274,12 +276,19 @@ simple_uniform_core(AcMesh* mesh) //tanhRR = double(-0.5)*tanh((core_radius-RR)/trans) + double(0.5) // + double(0.1); tanhRR = double(1.0); + + if (RR >= mesh->info.real_params[AC_soft]) { - abso_vel = c * sqrt(2.0 * mesh->info.real_params[AC_G_const] * mesh->info.real_params[AC_M_sink_init] / RR); + abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] * mesh->info.real_params[AC_M_sink_init] / RR); + } else { + abso_vel = 0.0; + RR = 1.0; + } + mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(exp(ampl_lnrho)*tanhRR); - mesh->vertex_buffer[VTXBUF_UUX][idx] = double(0.0); - mesh->vertex_buffer[VTXBUF_UUY][idx] = double(0.0); + mesh->vertex_buffer[VTXBUF_UUX][idx] = -abso_vel * (yy / RR); + mesh->vertex_buffer[VTXBUF_UUY][idx] = abso_vel * (xx / RR); mesh->vertex_buffer[VTXBUF_UUZ][idx] = double(0.0); } diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 14f6ed1..b65fd17 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -272,7 +272,7 @@ run_simulation(void) int on_off_switch; if (i < 1) { - on_off_switch = 0; //accretion is off till 1000 steps. + on_off_switch = 0; //accretion is off till certain amount of steps. } else { on_off_switch = 1; } From 083ff59ed1e388611ba1b6522cd732fa19529357 Mon Sep 17 00:00:00 2001 From: JackHsu Date: Fri, 30 Aug 2019 15:16:09 +0800 Subject: [PATCH 71/87] config templates over summer project. --- .../128res_non-rotating_highvisc.conf | 75 +++++++++++++++++++ .../sinktest/128res_rotating_highvisc.conf | 75 +++++++++++++++++++ .../256res_non-rotating_highvisc.conf | 75 +++++++++++++++++++ .../sinktest/256res_rotating_highvisc.conf | 75 +++++++++++++++++++ .../sinktest/256res_rotating_lowvisc.conf | 75 +++++++++++++++++++ .../512res_non-rotating_highvisc.conf | 75 +++++++++++++++++++ .../sinktest/512res_rotating_highvisc.conf | 75 +++++++++++++++++++ .../sinktest/512res_rotating_lowvisc.conf | 75 +++++++++++++++++++ 8 files changed, 600 insertions(+) create mode 100644 config/templates/sinktest/128res_non-rotating_highvisc.conf create mode 100644 config/templates/sinktest/128res_rotating_highvisc.conf create mode 100644 config/templates/sinktest/256res_non-rotating_highvisc.conf create mode 100644 config/templates/sinktest/256res_rotating_highvisc.conf create mode 100644 config/templates/sinktest/256res_rotating_lowvisc.conf create mode 100644 config/templates/sinktest/512res_non-rotating_highvisc.conf create mode 100644 config/templates/sinktest/512res_rotating_highvisc.conf create mode 100644 config/templates/sinktest/512res_rotating_lowvisc.conf diff --git a/config/templates/sinktest/128res_non-rotating_highvisc.conf b/config/templates/sinktest/128res_non-rotating_highvisc.conf new file mode 100644 index 0000000..3a798dc --- /dev/null +++ b/config/templates/sinktest/128res_non-rotating_highvisc.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 128 +AC_ny = 128 +AC_nz = 128 + +AC_dsx = 0.04908738521 +AC_dsy = 0.04908738521 +AC_dsz = 0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 20001 +AC_save_steps = 50 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 0.0 diff --git a/config/templates/sinktest/128res_rotating_highvisc.conf b/config/templates/sinktest/128res_rotating_highvisc.conf new file mode 100644 index 0000000..df70dbe --- /dev/null +++ b/config/templates/sinktest/128res_rotating_highvisc.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 128 +AC_ny = 128 +AC_nz = 128 + +AC_dsx = 0.04908738521 +AC_dsy = 0.04908738521 +AC_dsz = 0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 20001 +AC_save_steps = 50 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 2e10 diff --git a/config/templates/sinktest/256res_non-rotating_highvisc.conf b/config/templates/sinktest/256res_non-rotating_highvisc.conf new file mode 100644 index 0000000..e451e7b --- /dev/null +++ b/config/templates/sinktest/256res_non-rotating_highvisc.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 256 +AC_ny = 256 +AC_nz = 256 + +AC_dsx = 0.0245436926 //0.04908738521 +AC_dsy = 0.0245436926 //0.04908738521 +AC_dsz = 0.0245436926 //0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 40001 +AC_save_steps = 50 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 0.0 diff --git a/config/templates/sinktest/256res_rotating_highvisc.conf b/config/templates/sinktest/256res_rotating_highvisc.conf new file mode 100644 index 0000000..484bb82 --- /dev/null +++ b/config/templates/sinktest/256res_rotating_highvisc.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 256 +AC_ny = 256 +AC_nz = 256 + +AC_dsx = 0.0245436926 //0.04908738521 +AC_dsy = 0.0245436926 //0.04908738521 +AC_dsz = 0.0245436926 //0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 40001 +AC_save_steps = 50 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 2e10 diff --git a/config/templates/sinktest/256res_rotating_lowvisc.conf b/config/templates/sinktest/256res_rotating_lowvisc.conf new file mode 100644 index 0000000..2dc7082 --- /dev/null +++ b/config/templates/sinktest/256res_rotating_lowvisc.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 256 +AC_ny = 256 +AC_nz = 256 + +AC_dsx = 0.0245436926 //0.04908738521 +AC_dsy = 0.0245436926 //0.04908738521 +AC_dsz = 0.0245436926 //0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 40001 +AC_save_steps = 50 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 2.5e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 2e10 diff --git a/config/templates/sinktest/512res_non-rotating_highvisc.conf b/config/templates/sinktest/512res_non-rotating_highvisc.conf new file mode 100644 index 0000000..f58c76b --- /dev/null +++ b/config/templates/sinktest/512res_non-rotating_highvisc.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 512 +AC_ny = 512 +AC_nz = 512 + +AC_dsx = 0.0122718463 //0.0245436926 //0.04908738521 +AC_dsy = 0.0122718463 //0.0245436926 //0.04908738521 +AC_dsz = 0.0122718463 //0.0245436926 //0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 80001 +AC_save_steps = 50 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 0.0 diff --git a/config/templates/sinktest/512res_rotating_highvisc.conf b/config/templates/sinktest/512res_rotating_highvisc.conf new file mode 100644 index 0000000..c3a9420 --- /dev/null +++ b/config/templates/sinktest/512res_rotating_highvisc.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 512 +AC_ny = 512 +AC_nz = 512 + +AC_dsx = 0.0122718463 //0.0245436926 //0.04908738521 +AC_dsy = 0.0122718463 //0.0245436926 //0.04908738521 +AC_dsz = 0.0122718463 //0.0245436926 //0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 80001 +AC_save_steps = 50 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 2e10 diff --git a/config/templates/sinktest/512res_rotating_lowvisc.conf b/config/templates/sinktest/512res_rotating_lowvisc.conf new file mode 100644 index 0000000..7b60afe --- /dev/null +++ b/config/templates/sinktest/512res_rotating_lowvisc.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 512 +AC_ny = 512 +AC_nz = 512 + +AC_dsx = 0.0122718463 //0.0245436926 //0.04908738521 +AC_dsy = 0.0122718463 //0.0245436926 //0.04908738521 +AC_dsz = 0.0122718463 //0.0245436926 //0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 80001 +AC_save_steps = 50 +AC_bin_steps = 1000 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 1.25e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.36 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 2e10 From 02ac6c956feb49e0559bef7bac93e93cc4ff8062 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 2 Sep 2019 14:04:27 +0800 Subject: [PATCH 72/87] Desperately trying to port the new changes of DSL. Still work to do. --- acc/mhd_solver/stencil_definition.sdh | 7 +- acc/mhd_solver/stencil_process.sps | 98 +++++++++++++-------------- 2 files changed, 55 insertions(+), 50 deletions(-) diff --git a/acc/mhd_solver/stencil_definition.sdh b/acc/mhd_solver/stencil_definition.sdh index e4475ad..5527534 100644 --- a/acc/mhd_solver/stencil_definition.sdh +++ b/acc/mhd_solver/stencil_definition.sdh @@ -89,7 +89,7 @@ uniform Scalar AC_ff_hel_imx; uniform Scalar AC_ff_hel_imy; uniform Scalar AC_ff_hel_imz; // Additional helper params // (deduced from other params do not set these directly!) -uniform Scalar AC_G_CONST; +uniform Scalar AC_G_const; uniform Scalar AC_GM_star; uniform Scalar AC_unit_mass; uniform Scalar AC_sq2GM_star; @@ -128,3 +128,8 @@ uniform ScalarField VTXBUF_UUZ; #else uniform ScalarField VTXBUF_LNRHO; #endif + +#if LSINK +uniform ScalarField VTXBUF_ACCRETION; +#endif + diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index e8d7cf4..1e388fa 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -26,18 +26,18 @@ gradients(in VectorField uu) #if LSINK Vector sink_gravity(int3 globalVertexIdx){ - int accretion_switch = DCONST_INT(AC_switch_accretion); + int accretion_switch = AC_switch_accretion; if (accretion_switch == 1){ Vector force_gravity; - const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, - (globalVertexIdx.y - ny_min) * dsy, - (globalVertexIdx.z - nz_min) * dsz}; - const Scalar sink_mass = DCONST_REAL(AC_M_sink); - const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), - DCONST_REAL(AC_sink_pos_y), - DCONST_REAL(AC_sink_pos_z)}; + const Vector grid_pos = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, + (globalVertexIdx.y - AC_ny_min) * AC_dsy, + (globalVertexIdx.z - AC_nz_min) * AC_dsz}; + const Scalar sink_mass = AC_M_sink; + const Vector sink_pos = (Vector){AC_sink_pos_x, + AC_sink_pos_y, + AC_sink_pos_z}; const Scalar distance = length(grid_pos - sink_pos); - const Scalar soft = DCONST_REAL(AC_soft); + const Scalar soft = AC_soft; const Scalar gravity_magnitude = (AC_G_const * sink_mass) / pow(((distance * distance) + soft*soft), 1.5); const Vector direction = (Vector){(sink_pos.x - grid_pos.x) / distance, (sink_pos.y - grid_pos.y) / distance, @@ -56,9 +56,9 @@ sink_gravity(int3 globalVertexIdx){ Scalar truelove_density(in ScalarField lnrho){ const Scalar rho = exp(value(lnrho)); - const Scalar Jeans_length_squared = (M_PI * cs2_sound) / (AC_G_const * rho); - const Scalar TJ_rho = ((M_PI) * ((dsx * dsx) / Jeans_length_squared) * cs2_sound) / (AC_G_const * dsx * dsx); - //TODO: dsx will cancel out, deal with it later for optimization. + const Scalar Jeans_length_squared = (M_PI * AC_cs2_sound) / (AC_G_const * rho); + const Scalar TJ_rho = ((M_PI) * ((AC_dsx * AC_dsx) / Jeans_length_squared) * AC_cs2_sound) / (AC_G_const * AC_dsx * AC_dsx); + //TODO: AC_dsx will cancel out, deal with it later for optimization. Scalar accretion_rho = TJ_rho; @@ -67,15 +67,15 @@ truelove_density(in ScalarField lnrho){ Scalar sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ - const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, - (globalVertexIdx.y - ny_min) * dsy, - (globalVertexIdx.z - nz_min) * dsz}; - const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), - DCONST_REAL(AC_sink_pos_y), - DCONST_REAL(AC_sink_pos_z)}; - const Scalar profile_range = DCONST_REAL(AC_accretion_range); + const Vector grid_pos = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, + (globalVertexIdx.y - AC_ny_min) * AC_dsy, + (globalVertexIdx.z - AC_nz_min) * AC_dsz}; + const Vector sink_pos = (Vector){AC_sink_pos_x, + AC_sink_pos_y, + AC_sink_pos_z}; + const Scalar profile_range = AC_accretion_range; const Scalar accretion_distance = length(grid_pos - sink_pos); - int accretion_switch = DCONST_INT(AC_switch_accretion); + int accretion_switch = AC_switch_accretion; Scalar accretion_density; Scalar weight; @@ -90,10 +90,10 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ // const Scalar lnrho_min = Scalar(-10.0); //TODO Define from astaroth.conf const Scalar lnrho_min = log(truelove_density(lnrho)); -// const Scalar sink_mass = DCONST_REAL(AC_M_sink); +// const Scalar sink_mass = AC_M_sink; // const Scalar B = Scalar(0.5); // const Scalar k = Scalar(1.5); -// const Scalar rate = B * (pow(sink_mass, k) / (dsx * dsy * dsz)); +// const Scalar rate = B * (pow(sink_mass, k) / (AC_dsx * AC_dsy * AC_dsz)); Scalar rate; if (value(lnrho) > lnrho_min) { rate = (exp(value(lnrho)) - exp(lnrho_min)) / dt; @@ -110,15 +110,15 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ Vector sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { - const Vector grid_pos = (Vector){(globalVertexIdx.x - nx_min) * dsx, - (globalVertexIdx.y - ny_min) * dsy, - (globalVertexIdx.z - nz_min) * dsz}; - const Vector sink_pos = (Vector){DCONST_REAL(AC_sink_pos_x), - DCONST_REAL(AC_sink_pos_y), - DCONST_REAL(AC_sink_pos_z)}; - const Scalar profile_range = DCONST_REAL(AC_accretion_range); + const Vector grid_pos = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, + (globalVertexIdx.y - AC_ny_min) * AC_dsy, + (globalVertexIdx.z - AC_nz_min) * AC_dsz}; + const Vector sink_pos = (Vector){AC_sink_pos_x, + AC_sink_pos_y, + AC_sink_pos_z}; + const Scalar profile_range = AC_accretion_range; const Scalar accretion_distance = length(grid_pos - sink_pos); - int accretion_switch = DCONST_INT(AC_switch_accretion); + int accretion_switch = AC_switch_accretion; Vector accretion_velocity; if (accretion_switch == 1){ @@ -187,7 +187,7 @@ momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, in Scala //Gravity term + sink_gravity(globalVertexIdx) //Corresponding loss of momentum - - //(Scalar(1.0) / Scalar( (dsx*dsy*dsz) * exp(value(lnrho)))) * // Correction factor by unit mass + - //(Scalar(1.0) / Scalar( (AC_dsx*AC_dsy*AC_dsz) * exp(value(lnrho)))) * // Correction factor by unit mass sink_accretion_velocity(globalVertexIdx, uu, dt) // As in Lee et al.(2014) ; #else @@ -238,7 +238,7 @@ momentum(int3 globalVertexIdx, in VectorField uu, in ScalarField lnrho, Scalar d #if LSINK + sink_gravity(globalVertexIdx) //Corresponding loss of momentum - - //(Scalar(1.0) / Scalar( (dsx*dsy*dsz) * exp(value(lnrho)))) * // Correction factor by unit mass + - //(Scalar(1.0) / Scalar( (AC_dsx*AC_dsy*AC_dsz) * exp(value(lnrho)))) * // Correction factor by unit mass sink_accretion_velocity(globalVertexIdx, uu, dt) // As in Lee et al.(2014) ; #else @@ -335,7 +335,7 @@ heat_transfer(in VectorField uu, in ScalarField lnrho, in ScalarField tt) #if LFORCING Vector simple_vortex_forcing(Vector a, Vector b, Scalar magnitude){ - int accretion_switch = DCONST_INT(AC_switch_accretion); + int accretion_switch = AC_switch_accretion; if (accretion_switch == 0){ return magnitude * cross(normalized(b - a), (Vector){ 0, 0, 1}); // Vortex @@ -345,7 +345,7 @@ Vector } Vector simple_outward_flow_forcing(Vector a, Vector b, Scalar magnitude){ - int accretion_switch = DCONST_INT(AC_switch_accretion); + int accretion_switch = AC_switch_accretion; if (accretion_switch == 0){ return magnitude * (1 / length(b - a)) * normalized(b - a); // Outward flow } else { @@ -392,24 +392,24 @@ helical_forcing(Scalar magnitude, Vector k_force, Vector xx, Vector ff_re, Vecto Vector forcing(int3 globalVertexIdx, Scalar dt) { - int accretion_switch = DCONST_INT(AC_switch_accretion); + int accretion_switch = AC_switch_accretion; if (accretion_switch == 0){ - Vector a = Scalar(.5) * (Vector){globalGridN.x * dsx, - globalGridN.y * dsy, - globalGridN.z * dsz}; // source (origin) - Vector xx = (Vector){(globalVertexIdx.x - nx_min) * dsx, - (globalVertexIdx.y - ny_min) * dsy, - (globalVertexIdx.z - nz_min) * dsz}; // sink (current index) - const Scalar cs2 = cs2_sound; + Vector a = Scalar(.5) * (Vector){globalGridN.x * AC_dsx, + globalGridN.y * AC_dsy, + globalGridN.z * AC_dsz}; // source (origin) + Vector xx = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, + (globalVertexIdx.y - AC_ny_min) * AC_dsy, + (globalVertexIdx.z - AC_nz_min) * AC_dsz}; // sink (current index) + const Scalar cs2 = AC_cs2_sound; const Scalar cs = sqrt(cs2); //Placeholders until determined properly - Scalar magnitude = DCONST_REAL(AC_forcing_magnitude); - Scalar phase = DCONST_REAL(AC_forcing_phase); - Vector k_force = (Vector){ DCONST_REAL(AC_k_forcex), DCONST_REAL(AC_k_forcey), DCONST_REAL(AC_k_forcez)}; - Vector ff_re = (Vector){DCONST_REAL(AC_ff_hel_rex), DCONST_REAL(AC_ff_hel_rey), DCONST_REAL(AC_ff_hel_rez)}; - Vector ff_im = (Vector){DCONST_REAL(AC_ff_hel_imx), DCONST_REAL(AC_ff_hel_imy), DCONST_REAL(AC_ff_hel_imz)}; + Scalar magnitude = AC_forcing_magnitude; + Scalar phase = AC_forcing_phase; + Vector k_force = (Vector){AC_k_forcex, AC_k_forcey, AC_k_forcez}; + Vector ff_re = (Vector){AC_ff_hel_rex, AC_ff_hel_rey, AC_ff_hel_rez}; + Vector ff_im = (Vector){AC_ff_hel_imx, AC_ff_hel_imy, AC_ff_hel_imz}; //Determine that forcing funtion type at this point. @@ -418,7 +418,7 @@ forcing(int3 globalVertexIdx, Scalar dt) Vector force = helical_forcing(magnitude, k_force, xx, ff_re,ff_im, phase); //Scaling N = magnitude*cs*sqrt(k*cs/dt) * dt - const Scalar NN = cs*sqrt(DCONST_REAL(AC_kaver)*cs); + const Scalar NN = cs*sqrt(AC_kaver*cs); //MV: Like in the Pencil Code. I don't understandf the logic here. force.x = sqrt(dt)*NN*force.x; force.y = sqrt(dt)*NN*force.y; @@ -490,7 +490,7 @@ solve() out_accretion = rk3(out_accretion, accretion, sink_accretion(globalVertexIdx, lnrho, dt), dt);// unit now is rho! if (step_number == 2) { - out_accretion = out_accretion * dsx * dsy * dsz;// unit is now mass! + out_accretion = out_accretion * AC_dsx * AC_dsy * AC_dsz;// unit is now mass! } #endif } From b4cd92da0c2269b40781a974a4f42cd475b06b8f Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 2 Sep 2019 14:47:58 +0800 Subject: [PATCH 73/87] Now compiles and runs. PLEASE NOTE THAT FLAGS NEED TO BE SET SEPARATELY IN simulation.cc and renderer.cc FOR LSINK and LFORCING! --- acc/mhd_solver/stencil_definition.sdh | 6 +++--- acc/mhd_solver/stencil_process.sps | 10 +++++----- src/standalone/model/model_rk3.cc | 6 +++--- src/standalone/renderer.cc | 4 ++++ src/standalone/simulation.cc | 10 ++++++---- 5 files changed, 21 insertions(+), 15 deletions(-) diff --git a/acc/mhd_solver/stencil_definition.sdh b/acc/mhd_solver/stencil_definition.sdh index 5527534..39a9e10 100644 --- a/acc/mhd_solver/stencil_definition.sdh +++ b/acc/mhd_solver/stencil_definition.sdh @@ -1,9 +1,9 @@ #define LDENSITY (1) #define LHYDRO (1) -#define LMAGNETIC (1) -#define LENTROPY (1) +#define LMAGNETIC (0) +#define LENTROPY (0) #define LTEMPERATURE (0) -#define LFORCING (1) +#define LFORCING (0) #define LUPWD (1) #define LSINK (1) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 1e388fa..1cd336b 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -456,8 +456,8 @@ out ScalarField out_tt(VTXBUF_TEMPERATURE); #endif #if LSINK -in Scalar accretion = VTXBUF_ACCRETION; -out Scalar out_accretion = VTXBUF_ACCRETION; +in ScalarField accretion(VTXBUF_ACCRETION); +out ScalarField out_accretion(VTXBUF_ACCRETION); #endif Kernel void @@ -471,13 +471,13 @@ solve() #endif #if LENTROPY - out_uu = rk3(out_uu, uu, momentum(uu, lnrho, ss, aa), dt); + out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, ss, aa, dt), dt); out_ss = rk3(out_ss, ss, entropy(ss, uu, lnrho, aa), dt); #elif LTEMPERATURE - out_uu = rk3(out_uu, uu, momentum(uu, lnrho, tt), dt); + out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, tt, dt), dt); out_tt = rk3(out_tt, tt, heat_transfer(uu, lnrho, tt), dt); #else - out_uu = rk3(out_uu, uu, momentum(uu, lnrho), dt); + out_uu = rk3(out_uu, uu, momentum(globalVertexIdx, uu, lnrho, dt), dt); #endif #if LFORCING diff --git a/src/standalone/model/model_rk3.cc b/src/standalone/model/model_rk3.cc index 5fab4b4..0680daa 100644 --- a/src/standalone/model/model_rk3.cc +++ b/src/standalone/model/model_rk3.cc @@ -34,10 +34,10 @@ // Standalone flags #define LDENSITY (1) #define LHYDRO (1) -#define LMAGNETIC (1) -#define LENTROPY (1) +#define LMAGNETIC (0) +#define LENTROPY (0) #define LTEMPERATURE (0) -#define LFORCING (1) +#define LFORCING (0) #define LUPWD (1) #define AC_THERMAL_CONDUCTIVITY (AcReal(0.001)) // TODO: make an actual config parameter diff --git a/src/standalone/renderer.cc b/src/standalone/renderer.cc index a9608ea..11fd693 100644 --- a/src/standalone/renderer.cc +++ b/src/standalone/renderer.cc @@ -41,6 +41,10 @@ #include "src/core/math_utils.h" #include "timer_hires.h" +//NEED TO BE DEFINED HERE. IS NOT NOTICED BY compile_acc call. +#define LFORCING (0) +#define LSINK (1) + // Window SDL_Renderer* renderer = NULL; static SDL_Window* window = NULL; diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index b65fd17..375772b 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -40,6 +40,10 @@ #include #include +//NEED TO BE DEFINED HERE. IS NOT NOTICED BY compile_acc call. +#define LFORCING (0) +#define LSINK (1) + // Write all setting info into a separate ascii file. This is done to guarantee // that we have the data specifi information in the thing, even though in // principle these things are in the astaroth.conf. @@ -254,9 +258,7 @@ run_simulation(void) // acUpdate_sink_particle() will do the similar trick to the device. /* Step the simulation */ -#if LSINK - AcReal accreted_mass = 0.0; -#endif + AcReal accreted_mass = 0.0; AcReal sink_mass = 0.0; for (int i = 1; i < max_steps; ++i) { const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); const AcReal dt = host_timestep(umax, mesh_info); @@ -265,7 +267,7 @@ run_simulation(void) const AcReal sum_mass = acReduceScal(RTYPE_SUM, VTXBUF_ACCRETION); accreted_mass = accreted_mass + sum_mass; - AcReal sink_mass = 0.0; + sink_mass = 0.0; sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; acLoadDeviceConstant(AC_M_sink, sink_mass); vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); From f3a36ec276b6bf04ced33dba22716164ef2b5408 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 2 Sep 2019 18:29:16 +0800 Subject: [PATCH 74/87] Moved definition location of AC_nx_min etc. Otherwide DSL does not compile the code correctly!!! --- acc/mhd_solver/stencil_definition.sdh | 8 ++++++++ acc/mhd_solver/stencil_process.sps | 2 +- include/astaroth_defines.h | 6 ------ 3 files changed, 9 insertions(+), 7 deletions(-) diff --git a/acc/mhd_solver/stencil_definition.sdh b/acc/mhd_solver/stencil_definition.sdh index 39a9e10..3b945d9 100644 --- a/acc/mhd_solver/stencil_definition.sdh +++ b/acc/mhd_solver/stencil_definition.sdh @@ -15,6 +15,14 @@ uniform int AC_save_steps; uniform int AC_bin_steps; uniform int AC_bc_type; +// Added these here. Otherwise DSL does not recognize them +uniform int AC_nx_min; +uniform int AC_ny_min; +uniform int AC_nz_min; +uniform int AC_nx_max; +uniform int AC_ny_max; +uniform int AC_nz_max; + // Real params uniform Scalar AC_dt; // Spacing diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 1cd336b..5be7c66 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -26,7 +26,7 @@ gradients(in VectorField uu) #if LSINK Vector sink_gravity(int3 globalVertexIdx){ - int accretion_switch = AC_switch_accretion; + int accretion_switch = int(AC_switch_accretion); if (accretion_switch == 1){ Vector force_gravity; const Vector grid_pos = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, diff --git a/include/astaroth_defines.h b/include/astaroth_defines.h index 58525ba..02fbeef 100644 --- a/include/astaroth_defines.h +++ b/include/astaroth_defines.h @@ -78,12 +78,6 @@ typedef struct { FUNC(AC_mx), \ FUNC(AC_my), \ FUNC(AC_mz), \ - FUNC(AC_nx_min), \ - FUNC(AC_ny_min), \ - FUNC(AC_nz_min), \ - FUNC(AC_nx_max), \ - FUNC(AC_ny_max), \ - FUNC(AC_nz_max), \ FUNC(AC_mxy),\ FUNC(AC_nxy),\ FUNC(AC_nxyz),\ From ac92123842dd5be2f1aaa48ae6990aa1cb485f53 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 2 Sep 2019 18:40:38 +0800 Subject: [PATCH 75/87] Made a note about a bug in 083ff59 , just to remember that code is now more correct. --- acc/mhd_solver/stencil_process.sps | 2 ++ 1 file changed, 2 insertions(+) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 5be7c66..8c3f9a0 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -38,6 +38,8 @@ sink_gravity(int3 globalVertexIdx){ AC_sink_pos_z}; const Scalar distance = length(grid_pos - sink_pos); const Scalar soft = AC_soft; + //MV: The commit 083ff59 had AC_G_const defined wrong here in DSL making it exxessively strong. + //MV: Scalar gravity_magnitude = ... below is correct! const Scalar gravity_magnitude = (AC_G_const * sink_mass) / pow(((distance * distance) + soft*soft), 1.5); const Vector direction = (Vector){(sink_pos.x - grid_pos.x) / distance, (sink_pos.y - grid_pos.y) / distance, From b3ed0937fe60a619f24c57e1d87061138c2ed95a Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 3 Sep 2019 10:19:22 +0800 Subject: [PATCH 76/87] Changes according to JP's comments in the Issue #8. --- acc/mhd_solver/stencil_definition.sdh | 8 -------- acc/mhd_solver/stencil_process.sps | 24 ++++++++++++------------ include/astaroth_defines.h | 6 ++++++ 3 files changed, 18 insertions(+), 20 deletions(-) diff --git a/acc/mhd_solver/stencil_definition.sdh b/acc/mhd_solver/stencil_definition.sdh index 3b945d9..39a9e10 100644 --- a/acc/mhd_solver/stencil_definition.sdh +++ b/acc/mhd_solver/stencil_definition.sdh @@ -15,14 +15,6 @@ uniform int AC_save_steps; uniform int AC_bin_steps; uniform int AC_bc_type; -// Added these here. Otherwise DSL does not recognize them -uniform int AC_nx_min; -uniform int AC_ny_min; -uniform int AC_nz_min; -uniform int AC_nx_max; -uniform int AC_ny_max; -uniform int AC_nz_max; - // Real params uniform Scalar AC_dt; // Spacing diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index 8c3f9a0..ba8bbb7 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -29,9 +29,9 @@ sink_gravity(int3 globalVertexIdx){ int accretion_switch = int(AC_switch_accretion); if (accretion_switch == 1){ Vector force_gravity; - const Vector grid_pos = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, - (globalVertexIdx.y - AC_ny_min) * AC_dsy, - (globalVertexIdx.z - AC_nz_min) * AC_dsz}; + const Vector grid_pos = (Vector){(globalVertexIdx.x - DCONST(AC_nx_min)) * AC_dsx, + (globalVertexIdx.y - DCONST(AC_ny_min)) * AC_dsy, + (globalVertexIdx.z - DCONST(AC_nz_min)) * AC_dsz}; const Scalar sink_mass = AC_M_sink; const Vector sink_pos = (Vector){AC_sink_pos_x, AC_sink_pos_y, @@ -69,9 +69,9 @@ truelove_density(in ScalarField lnrho){ Scalar sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ - const Vector grid_pos = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, - (globalVertexIdx.y - AC_ny_min) * AC_dsy, - (globalVertexIdx.z - AC_nz_min) * AC_dsz}; + const Vector grid_pos = (Vector){(globalVertexIdx.x - DCONST(AC_nx_min)) * AC_dsx, + (globalVertexIdx.y - DCONST(AC_ny_min)) * AC_dsy, + (globalVertexIdx.z - DCONST(AC_nz_min)) * AC_dsz}; const Vector sink_pos = (Vector){AC_sink_pos_x, AC_sink_pos_y, AC_sink_pos_z}; @@ -112,9 +112,9 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ Vector sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { - const Vector grid_pos = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, - (globalVertexIdx.y - AC_ny_min) * AC_dsy, - (globalVertexIdx.z - AC_nz_min) * AC_dsz}; + const Vector grid_pos = (Vector){(globalVertexIdx.x - DCONST(AC_nx_min)) * AC_dsx, + (globalVertexIdx.y - DCONST(AC_ny_min)) * AC_dsy, + (globalVertexIdx.z - DCONST(AC_nz_min)) * AC_dsz}; const Vector sink_pos = (Vector){AC_sink_pos_x, AC_sink_pos_y, AC_sink_pos_z}; @@ -400,9 +400,9 @@ forcing(int3 globalVertexIdx, Scalar dt) Vector a = Scalar(.5) * (Vector){globalGridN.x * AC_dsx, globalGridN.y * AC_dsy, globalGridN.z * AC_dsz}; // source (origin) - Vector xx = (Vector){(globalVertexIdx.x - AC_nx_min) * AC_dsx, - (globalVertexIdx.y - AC_ny_min) * AC_dsy, - (globalVertexIdx.z - AC_nz_min) * AC_dsz}; // sink (current index) + Vector xx = (Vector){(globalVertexIdx.x - DCONST(AC_nx_min)) * AC_dsx, + (globalVertexIdx.y - DCONST(AC_ny_min)) * AC_dsy, + (globalVertexIdx.z - DCONST(AC_nz_min)) * AC_dsz}; // sink (current index) const Scalar cs2 = AC_cs2_sound; const Scalar cs = sqrt(cs2); diff --git a/include/astaroth_defines.h b/include/astaroth_defines.h index 02fbeef..58525ba 100644 --- a/include/astaroth_defines.h +++ b/include/astaroth_defines.h @@ -78,6 +78,12 @@ typedef struct { FUNC(AC_mx), \ FUNC(AC_my), \ FUNC(AC_mz), \ + FUNC(AC_nx_min), \ + FUNC(AC_ny_min), \ + FUNC(AC_nz_min), \ + FUNC(AC_nx_max), \ + FUNC(AC_ny_max), \ + FUNC(AC_nz_max), \ FUNC(AC_mxy),\ FUNC(AC_nxy),\ FUNC(AC_nxyz),\ From 6560ab04bf2419904f382fa0ca4724d6245f5670 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 3 Sep 2019 12:33:44 +0800 Subject: [PATCH 77/87] Improvement to the initial velocity profile. --- .../python/jupyter/notebook_example.ipynb | 10 ++--- src/standalone/model/host_memory.cc | 38 +++++-------------- 2 files changed, 15 insertions(+), 33 deletions(-) diff --git a/analysis/python/jupyter/notebook_example.ipynb b/analysis/python/jupyter/notebook_example.ipynb index 3d053d9..3cbc3ce 100644 --- a/analysis/python/jupyter/notebook_example.ipynb +++ b/analysis/python/jupyter/notebook_example.ipynb @@ -24,8 +24,7 @@ "metadata": {}, "outputs": [], "source": [ - "meshdir = \"/scratch/data/tchsu/sink7/\"\n", - "#meshdir = \"/scratch/data/mvaisala/normaltest/\"" + "meshdir = \"/home/mvaisala/astaroth/build/\"" ] }, { @@ -35,7 +34,7 @@ "outputs": [], "source": [ "#imesh = 30000\n", - "imesh = 15000\n", + "imesh = 0\n", "mesh = ad.read.Mesh(imesh, fdir=meshdir)" ] }, @@ -74,9 +73,10 @@ "vis.slices.plot_3(mesh, mesh.uu[0], title = r'$u_x$')\n", "vis.slices.plot_3(mesh, mesh.uu[1], title = r'$u_y$')\n", "vis.slices.plot_3(mesh, mesh.uu[2], title = r'$u_z$')\n", - "vis.slices.plot_3(mesh, mesh.lnrho, title = r'$\\ln_\\rho$', colrange=[0,0.1])\n", + "vis.slices.plot_3(mesh, mesh.lnrho, title = r'$\\ln_\\rho$')#, colrange=[0,0.1])\n", "vis.slices.plot_3(mesh, np.exp(mesh.lnrho), title = r'$\\rho$')\n", - "vis.slices.plot_3(mesh, np.exp(mesh.lnrho), title = r'$N_\\mathrm{col}$', slicetype = 'sum', colrange=[130,139])\n", + "vis.slices.plot_3(mesh, np.exp(mesh.lnrho), title = r'$N_\\mathrm{col}$', slicetype = 'sum')#, colrange=[130,139])\n", + "vis.slices.plot_3(mesh, uu_tot, title = r'$\\Sigma \\|u\\|$', slicetype = 'sum')#, colrange=[130,139])\n", "#vis.slices.plot_3(mesh, mesh.ss, title = r'$s$')\n", "vis.slices.plot_3(mesh, mesh.accretion, title = r'$Accretion buffer$')\n" ] diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index 0187b00..21d64e3 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -216,41 +216,19 @@ simple_uniform_core(AcMesh* mesh) const int my = mesh->info.int_params[AC_my]; const int mz = mesh->info.int_params[AC_mz]; - //const int nx_min = mesh->info.int_params[AC_nx_min]; - //const int nx_max = mesh->info.int_params[AC_nx_max]; - //const int ny_min = mesh->info.int_params[AC_ny_min]; - //const int ny_max = mesh->info.int_params[AC_ny_max]; - //const int nz_min = mesh->info.int_params[AC_nz_min]; - //const int nz_max = mesh->info.int_params[AC_nz_max]; - const double DX = mesh->info.real_params[AC_dsx]; const double DY = mesh->info.real_params[AC_dsy]; const double DZ = mesh->info.real_params[AC_dsz]; const double ampl_lnrho = mesh->info.real_params[AC_ampl_lnrho]; - //const double AMPL_UU = mesh->info.real_params[AC_ampl_uu]; - // const double SQ2GM = mesh->info.real_params[AC_sq2GM_star]; - // const double GM = mesh->info.real_params[AC_GM_star]; - // const double M_star = mesh->info.real_params[AC_M_star]; - // const double G_CONST = mesh->info.real_params[AC_G_CONST]; - - // const double unit_length = mesh->info.real_params[AC_unit_length]; - // const double unit_density = mesh->info.real_params[AC_unit_density]; - // const double unit_velocity = mesh->info.real_params[AC_unit_velocity]; const double xorig = mesh->info.real_params[AC_xorig]; const double yorig = mesh->info.real_params[AC_yorig]; const double zorig = mesh->info.real_params[AC_zorig]; - //const double trans = mesh->info.real_params[AC_trans]; double xx, yy, zz, RR; double delx, dely, delz; - //double u_x, u_y, u_z; double tanhRR; - //const double sink_pos_x = mesh->info.real_params[AC_sink_pos_x]; - //const double sink_pos_y = mesh->info.real_params[AC_sink_pos_y]; - //const double sink_pos_z = mesh->info.real_params[AC_sink_pos_z]; - //TEMPORARY TEST INPUT PARAMETERS const double core_radius = DX*32.0; const double trans = DX*12.0; @@ -276,20 +254,24 @@ simple_uniform_core(AcMesh* mesh) //tanhRR = double(-0.5)*tanh((core_radius-RR)/trans) + double(0.5) // + double(0.1); tanhRR = double(1.0); + AcReal RR_inner_bound = mesh->info.real_params[AC_soft]/AcReal(2.0); - if (RR >= mesh->info.real_params[AC_soft]) { - + if (RR >= RR_inner_bound) { abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] * mesh->info.real_params[AC_M_sink_init] / RR); } else { + abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] * mesh->info.real_params[AC_M_sink_init] / RR_inner_bound); + } + + if (RR <= sqrt(DX*DX + DY*DY + DZ*DZ)) { abso_vel = 0.0; RR = 1.0; - } + } mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(exp(ampl_lnrho)*tanhRR); - mesh->vertex_buffer[VTXBUF_UUX][idx] = -abso_vel * (yy / RR); - mesh->vertex_buffer[VTXBUF_UUY][idx] = abso_vel * (xx / RR); - mesh->vertex_buffer[VTXBUF_UUZ][idx] = double(0.0); + mesh->vertex_buffer[VTXBUF_UUX][idx] = -abso_vel * (yy / RR); + mesh->vertex_buffer[VTXBUF_UUY][idx] = abso_vel * (xx / RR); + mesh->vertex_buffer[VTXBUF_UUZ][idx] = double(0.0); } } From dac509241fa8f27d267714e679fa9c7fecbabbe6 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 3 Sep 2019 15:24:58 +0800 Subject: [PATCH 78/87] Cleanup, comments and a new template. --- acc/mhd_solver/stencil_process.sps | 15 ++-- .../sink_aftersummer/128_basic_rotating.conf | 75 +++++++++++++++++++ 2 files changed, 82 insertions(+), 8 deletions(-) create mode 100644 config/templates/sink_aftersummer/128_basic_rotating.conf diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index ba8bbb7..b888cbc 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -67,6 +67,7 @@ truelove_density(in ScalarField lnrho){ return accretion_rho; } +// This controls accretion of density/mass to the sink particle. Scalar sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ const Vector grid_pos = (Vector){(globalVertexIdx.x - DCONST(AC_nx_min)) * AC_dsx, @@ -82,7 +83,6 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ Scalar weight; if (accretion_switch == 1){ -// const Scalar weight = exp(-(accretion_distance/profile_range)); // Step function weighting if ((accretion_distance) <= profile_range){ weight = Scalar(1.0); @@ -90,12 +90,8 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ weight = Scalar(0.0); } -// const Scalar lnrho_min = Scalar(-10.0); //TODO Define from astaroth.conf + //Truelove criterion is used as a kind of arbitrary density floor. const Scalar lnrho_min = log(truelove_density(lnrho)); -// const Scalar sink_mass = AC_M_sink; -// const Scalar B = Scalar(0.5); -// const Scalar k = Scalar(1.5); -// const Scalar rate = B * (pow(sink_mass, k) / (AC_dsx * AC_dsy * AC_dsz)); Scalar rate; if (value(lnrho) > lnrho_min) { rate = (exp(value(lnrho)) - exp(lnrho_min)) / dt; @@ -104,12 +100,12 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ } accretion_density = weight * rate ; } else { - accretion_density = 0; + accretion_density = Scalar(0.0); } return accretion_density; } - +// This controls accretion of velocity to the sink particle. Vector sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { const Vector grid_pos = (Vector){(globalVertexIdx.x - DCONST(AC_nx_min)) * AC_dsx, @@ -126,6 +122,7 @@ sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { if (accretion_switch == 1){ Scalar weight; // Step function weighting + // MV: This is too aggeressive creating velocity artefacts. if ((accretion_distance) <= profile_range){ weight = Scalar(1.0); } else { @@ -133,6 +130,8 @@ sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { } Vector rate; + // MV: Could we use divergence here ephasize velocitie which are compressive and + // MV: not absorbins stuff that would not be accreted anyway? if (length(value(uu)) > Scalar(0.0)) { rate = (Scalar(1.0)/dt) * value(uu); } else { diff --git a/config/templates/sink_aftersummer/128_basic_rotating.conf b/config/templates/sink_aftersummer/128_basic_rotating.conf new file mode 100644 index 0000000..e6c769d --- /dev/null +++ b/config/templates/sink_aftersummer/128_basic_rotating.conf @@ -0,0 +1,75 @@ + + +/* + * ============================================================================= + * "Compile-time" params + * ============================================================================= + */ +AC_nx = 128 +AC_ny = 128 +AC_nz = 128 + +AC_dsx = 0.04908738521 +AC_dsy = 0.04908738521 +AC_dsz = 0.04908738521 + +/* + * ============================================================================= + * Run-time params + * ============================================================================= + */ +AC_max_steps = 501 +AC_save_steps = 1 +AC_bin_steps = 100 +AC_bin_save_t = 1e666 + +// Hydro +AC_cdt = 0.4 +AC_cdtv = 0.3 +AC_cdts = 1.0 +AC_nu_visc = 5e-4 +AC_cs_sound = 1.0 +AC_zeta = 0.0 + +// Magnetic +AC_eta = 5e-3 +AC_mu0 = 1.4 +AC_chi = 0.0001 + +// Forcing +AC_relhel = 0.0 +AC_forcing_magnitude = 1e-20 +AC_kmin = 0.8 +AC_kmax = 1.2 + + +// Entropy +AC_cp_sound = 1.0 +AC_gamma = 0.5 +AC_lnT0 = 1.2 +AC_lnrho0 = 1.3 + +// Sink Particle +AC_sink_pos_x = 3.14 +AC_sink_pos_y = 3.14 +AC_sink_pos_z = 3.14 + +//AC_M_sink_Msun = 0.005 +AC_M_sink_Msun = 1e-4 //1e-5 +AC_soft = 0.25 +AC_accretion_range = 0.25 + +// Physical properties of the domain +// Typical 1km/s velocity +AC_unit_velocity = 1e5 +// using density estimate of 100 H2 molecules per cm^3. +AC_unit_density = 3e-20 +// using 100,000 A.U. +AC_unit_length = 1.5e17 +/* + * ============================================================================= + * Initial conditions + * ============================================================================= + */ +AC_ampl_lnrho = 0.0 +AC_ampl_uu = 0.5 From bd55c42fe55098becd7d353ba211e8c32bfdf659 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 3 Sep 2019 16:38:16 +0800 Subject: [PATCH 79/87] Hann-windowing for the sink --- acc/mhd_solver/stencil_process.sps | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/acc/mhd_solver/stencil_process.sps b/acc/mhd_solver/stencil_process.sps index b888cbc..a0787c7 100644 --- a/acc/mhd_solver/stencil_process.sps +++ b/acc/mhd_solver/stencil_process.sps @@ -83,9 +83,11 @@ sink_accretion(int3 globalVertexIdx, in ScalarField lnrho, Scalar dt){ Scalar weight; if (accretion_switch == 1){ - // Step function weighting if ((accretion_distance) <= profile_range){ - weight = Scalar(1.0); + //weight = Scalar(1.0); + //Hann window function + Scalar window_ratio = accretion_distance/profile_range; + weight = Scalar(0.5)*(Scalar(1.0) - cos(Scalar(2.0)*M_PI*window_ratio)); } else { weight = Scalar(0.0); } @@ -121,14 +123,19 @@ sink_accretion_velocity(int3 globalVertexIdx, in VectorField uu, Scalar dt) { if (accretion_switch == 1){ Scalar weight; - // Step function weighting - // MV: This is too aggeressive creating velocity artefacts. + // Step function weighting + // Arch of a cosine function? + // Cubic spline x^3 - x in range [-0.5 , 0.5] if ((accretion_distance) <= profile_range){ - weight = Scalar(1.0); + //weight = Scalar(1.0); + //Hann window function + Scalar window_ratio = accretion_distance/profile_range; + weight = Scalar(0.5)*(Scalar(1.0) - cos(Scalar(2.0)*M_PI*window_ratio)); } else { - weight = Scalar(0.0); + weight = Scalar(0.0); } + Vector rate; // MV: Could we use divergence here ephasize velocitie which are compressive and // MV: not absorbins stuff that would not be accreted anyway? From 65d69027be1bf10dafa9e0b74db7f0d2cb5c1096 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 3 Sep 2019 17:48:56 +0800 Subject: [PATCH 80/87] Found an error in the gravitational constant. Now corrected! --- src/standalone/config_loader.cc | 7 +++---- src/standalone/model/host_memory.cc | 10 ++++++---- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/src/standalone/config_loader.cc b/src/standalone/config_loader.cc index cc50883..3df7d12 100644 --- a/src/standalone/config_loader.cc +++ b/src/standalone/config_loader.cc @@ -125,7 +125,7 @@ update_config(AcMeshInfo* config) config->real_params[AC_gamma]; AcReal G_CONST_CGS = AcReal( - 6.674e-8); // g/cm3/s GGS definition //TODO define in a separate module + 6.674e-8); // cm^3/(g*s^2) GGS definition //TODO define in a separate module AcReal M_sun = AcReal(1.989e33); // g solar mass @@ -137,8 +137,6 @@ update_config(AcMeshInfo* config) - - config->real_params[AC_M_sink] = config->real_params[AC_M_sink_Msun] * M_sun / config->real_params[AC_unit_mass]; config->real_params[AC_M_sink_init] = config->real_params[AC_M_sink_Msun] * M_sun / @@ -147,7 +145,8 @@ update_config(AcMeshInfo* config) config->real_params[AC_G_const] = G_CONST_CGS / ((config->real_params[AC_unit_velocity] * config->real_params[AC_unit_velocity]) / (config->real_params[AC_unit_density] * - config->real_params[AC_unit_length])); + config->real_params[AC_unit_length] * + config->real_params[AC_unit_length] )); config->real_params[AC_sq2GM_star] = AcReal(sqrt(AcReal(2) * config->real_params[AC_GM_star])); diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index 21d64e3..ac47f28 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -227,16 +227,18 @@ simple_uniform_core(AcMesh* mesh) const double zorig = mesh->info.real_params[AC_zorig]; double xx, yy, zz, RR; double delx, dely, delz; - double tanhRR; + double core_profile; //TEMPORARY TEST INPUT PARAMETERS const double core_radius = DX*32.0; const double trans = DX*12.0; + const double epsilon = DX*2.0; const double vel_scale = mesh->info.real_params[AC_ampl_uu]; double abso_vel; RR = 1.0; printf("%e %e %e \n", RR, trans, core_radius); + for (int k = 0; k < mz; k++) { for (int j = 0; j < my; j++) { @@ -251,9 +253,9 @@ simple_uniform_core(AcMesh* mesh) delz = zz; RR = sqrt(delx*delx + dely*dely + delz*delz); - //tanhRR = double(-0.5)*tanh((core_radius-RR)/trans) + double(0.5) + //core_profile = double(-0.5)*tanh((core_radius-RR)/trans) + double(0.5) // + double(0.1); - tanhRR = double(1.0); + core_profile = pow(RR+epsilon, -2.0); //double(1.0); AcReal RR_inner_bound = mesh->info.real_params[AC_soft]/AcReal(2.0); if (RR >= RR_inner_bound) { @@ -268,7 +270,7 @@ simple_uniform_core(AcMesh* mesh) } - mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(exp(ampl_lnrho)*tanhRR); + mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(exp(ampl_lnrho)*core_profile); mesh->vertex_buffer[VTXBUF_UUX][idx] = -abso_vel * (yy / RR); mesh->vertex_buffer[VTXBUF_UUY][idx] = abso_vel * (xx / RR); mesh->vertex_buffer[VTXBUF_UUZ][idx] = double(0.0); From 88a8198810fe639835f70cb4a13bd9f2ab59d433 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Tue, 3 Sep 2019 18:42:14 +0800 Subject: [PATCH 81/87] Revising the initial condition into a self-similar profile. --- .../sink_aftersummer/128_basic_rotating.conf | 6 +++--- src/standalone/model/host_memory.cc | 20 +++++++++++-------- src/standalone/simulation.cc | 6 ++++++ 3 files changed, 21 insertions(+), 11 deletions(-) diff --git a/config/templates/sink_aftersummer/128_basic_rotating.conf b/config/templates/sink_aftersummer/128_basic_rotating.conf index e6c769d..ccfc07c 100644 --- a/config/templates/sink_aftersummer/128_basic_rotating.conf +++ b/config/templates/sink_aftersummer/128_basic_rotating.conf @@ -55,7 +55,7 @@ AC_sink_pos_y = 3.14 AC_sink_pos_z = 3.14 //AC_M_sink_Msun = 0.005 -AC_M_sink_Msun = 1e-4 //1e-5 +AC_M_sink_Msun = 1.0 // 1e-4 //1e-5 AC_soft = 0.25 AC_accretion_range = 0.25 @@ -71,5 +71,5 @@ AC_unit_length = 1.5e17 * Initial conditions * ============================================================================= */ -AC_ampl_lnrho = 0.0 -AC_ampl_uu = 0.5 +AC_ampl_lnrho = 1.2 +AC_ampl_uu = 1.0 diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index ac47f28..1337a77 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -227,12 +227,12 @@ simple_uniform_core(AcMesh* mesh) const double zorig = mesh->info.real_params[AC_zorig]; double xx, yy, zz, RR; double delx, dely, delz; - double core_profile; + double core_profile, core_coeff; //TEMPORARY TEST INPUT PARAMETERS const double core_radius = DX*32.0; const double trans = DX*12.0; - const double epsilon = DX*2.0; + //const double epsilon = DX*2.0; const double vel_scale = mesh->info.real_params[AC_ampl_uu]; double abso_vel; @@ -253,15 +253,19 @@ simple_uniform_core(AcMesh* mesh) delz = zz; RR = sqrt(delx*delx + dely*dely + delz*delz); - //core_profile = double(-0.5)*tanh((core_radius-RR)/trans) + double(0.5) - // + double(0.1); - core_profile = pow(RR+epsilon, -2.0); //double(1.0); AcReal RR_inner_bound = mesh->info.real_params[AC_soft]/AcReal(2.0); + core_coeff = (exp(ampl_lnrho) * mesh->info.real_params[AC_cs2_sound]) / + (double(4.0)*M_PI * mesh->info.real_params[AC_G_const]); + if (RR >= RR_inner_bound) { - abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] * mesh->info.real_params[AC_M_sink_init] / RR); + abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] + * mesh->info.real_params[AC_M_sink_init] / RR); + core_profile = pow(RR, -2.0); //double(1.0); } else { - abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] * mesh->info.real_params[AC_M_sink_init] / RR_inner_bound); + abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] + * mesh->info.real_params[AC_M_sink_init] / RR_inner_bound); + core_profile = pow(RR_inner_bound, -2.0); //double(1.0); } if (RR <= sqrt(DX*DX + DY*DY + DZ*DZ)) { @@ -270,7 +274,7 @@ simple_uniform_core(AcMesh* mesh) } - mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(exp(ampl_lnrho)*core_profile); + mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(core_coeff*core_profile); mesh->vertex_buffer[VTXBUF_UUX][idx] = -abso_vel * (yy / RR); mesh->vertex_buffer[VTXBUF_UUY][idx] = abso_vel * (xx / RR); mesh->vertex_buffer[VTXBUF_UUZ][idx] = double(0.0); diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 375772b..15b294c 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -92,6 +92,12 @@ write_mesh_info(const AcMeshInfo* config) fprintf(infotxt, "real AC_cs2_sound %e \n", (double)config->real_params[AC_cs2_sound]); fprintf(infotxt, "real AC_cv_sound %e \n", (double)config->real_params[AC_cv_sound]); + //Physical units + fprintf(infotxt, "real AC_unit_density %e \n", (double)config->real_params[AC_unit_density]); + fprintf(infotxt, "real AC_unit_velocity %e \n", (double)config->real_params[AC_unit_velocity]); + fprintf(infotxt, "real AC_unit_mass %e \n", (double)config->real_params[AC_unit_mass ]); + fprintf(infotxt, "real AC_unit_length %e \n", (double)config->real_params[AC_unit_length ]); + //Here I'm still trying to copy the structure of the code above, and see if this will work for sink particle. //I haven't fully undertand what these lines do but I'll read up on them soon. This is still yet experimental. // Sink particle From f5733e5144c863c7adfa5397365f12ed900a54b1 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 16 Sep 2019 11:15:44 +0800 Subject: [PATCH 82/87] Turnin LSINK off by default to prepare for merge to master. --- acc/mhd_solver/stencil_definition.sdh | 8 ++++---- src/standalone/renderer.cc | 4 ++-- src/standalone/simulation.cc | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/acc/mhd_solver/stencil_definition.sdh b/acc/mhd_solver/stencil_definition.sdh index 39a9e10..abc341c 100644 --- a/acc/mhd_solver/stencil_definition.sdh +++ b/acc/mhd_solver/stencil_definition.sdh @@ -1,11 +1,11 @@ #define LDENSITY (1) #define LHYDRO (1) -#define LMAGNETIC (0) -#define LENTROPY (0) +#define LMAGNETIC (1) +#define LENTROPY (1) #define LTEMPERATURE (0) -#define LFORCING (0) +#define LFORCING (1) #define LUPWD (1) -#define LSINK (1) +#define LSINK (0) #define AC_THERMAL_CONDUCTIVITY (AcReal(0.001)) // TODO: make an actual config parameter diff --git a/src/standalone/renderer.cc b/src/standalone/renderer.cc index 11fd693..c99c1f4 100644 --- a/src/standalone/renderer.cc +++ b/src/standalone/renderer.cc @@ -42,8 +42,8 @@ #include "timer_hires.h" //NEED TO BE DEFINED HERE. IS NOT NOTICED BY compile_acc call. -#define LFORCING (0) -#define LSINK (1) +#define LFORCING (1) +#define LSINK (0) // Window SDL_Renderer* renderer = NULL; diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 15b294c..012829c 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -41,8 +41,8 @@ #include //NEED TO BE DEFINED HERE. IS NOT NOTICED BY compile_acc call. -#define LFORCING (0) -#define LSINK (1) +#define LFORCING (1) +#define LSINK (0) // Write all setting info into a separate ascii file. This is done to guarantee // that we have the data specifi information in the thing, even though in From 4d7cb0184c3ebfbcdb49040d6e89a709c7317845 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 16 Sep 2019 12:12:10 +0800 Subject: [PATCH 83/87] Corrected type definition problems. --- src/standalone/model/host_memory.cc | 37 +++++++++++------------ src/standalone/simulation.cc | 47 ++++++++++++----------------- 2 files changed, 38 insertions(+), 46 deletions(-) diff --git a/src/standalone/model/host_memory.cc b/src/standalone/model/host_memory.cc index 1337a77..f6a54cb 100644 --- a/src/standalone/model/host_memory.cc +++ b/src/standalone/model/host_memory.cc @@ -225,9 +225,16 @@ simple_uniform_core(AcMesh* mesh) const double xorig = mesh->info.real_params[AC_xorig]; const double yorig = mesh->info.real_params[AC_yorig]; const double zorig = mesh->info.real_params[AC_zorig]; + + const double G_const = mesh->info.real_params[AC_G_const]; + const double M_sink_init = mesh->info.real_params[AC_M_sink_init]; + const double cs2_sound = mesh->info.real_params[AC_cs2_sound]; + + const double RR_inner_bound = mesh->info.real_params[AC_soft]/AcReal(2.0); + const double core_coeff = (exp(ampl_lnrho) * cs2_sound) / (double(4.0)*M_PI * G_const); + double xx, yy, zz, RR; - double delx, dely, delz; - double core_profile, core_coeff; + double core_profile; //TEMPORARY TEST INPUT PARAMETERS const double core_radius = DX*32.0; @@ -248,23 +255,15 @@ simple_uniform_core(AcMesh* mesh) yy = DY * double(j) - yorig; zz = DZ * double(k) - zorig; - delx = xx; - dely = yy; - delz = zz; - RR = sqrt(delx*delx + dely*dely + delz*delz); - - AcReal RR_inner_bound = mesh->info.real_params[AC_soft]/AcReal(2.0); - - core_coeff = (exp(ampl_lnrho) * mesh->info.real_params[AC_cs2_sound]) / - (double(4.0)*M_PI * mesh->info.real_params[AC_G_const]); + RR = sqrt(xx*xx + yy*yy + zz*zz); if (RR >= RR_inner_bound) { - abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] - * mesh->info.real_params[AC_M_sink_init] / RR); + abso_vel = vel_scale * sqrt(2.0 * G_const + * M_sink_init / RR); core_profile = pow(RR, -2.0); //double(1.0); } else { - abso_vel = vel_scale * sqrt(2.0 * mesh->info.real_params[AC_G_const] - * mesh->info.real_params[AC_M_sink_init] / RR_inner_bound); + abso_vel = vel_scale * sqrt(2.0 * AC_G_const + * AC_M_sink_init / RR_inner_bound); core_profile = pow(RR_inner_bound, -2.0); //double(1.0); } @@ -274,10 +273,10 @@ simple_uniform_core(AcMesh* mesh) } - mesh->vertex_buffer[VTXBUF_LNRHO][idx] = log(core_coeff*core_profile); - mesh->vertex_buffer[VTXBUF_UUX][idx] = -abso_vel * (yy / RR); - mesh->vertex_buffer[VTXBUF_UUY][idx] = abso_vel * (xx / RR); - mesh->vertex_buffer[VTXBUF_UUZ][idx] = double(0.0); + mesh->vertex_buffer[VTXBUF_LNRHO][idx] = AcReal(log(core_coeff*core_profile)); + mesh->vertex_buffer[VTXBUF_UUX][idx] = AcReal(-abso_vel * (yy / RR)); + mesh->vertex_buffer[VTXBUF_UUY][idx] = AcReal( abso_vel * (xx / RR)); + mesh->vertex_buffer[VTXBUF_UUZ][idx] = AcReal(0.0); } } diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 012829c..efa6914 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -186,8 +186,8 @@ print_diagnostics(const int step, const AcReal dt, const AcReal t_step, FILE* di fprintf(diag_file, "%e %e %e ", double(buf_min), double(buf_rms), double(buf_max)); } - if ((sink_mass >= 0.0) || (accreted_mass >= 0.0)) { - fprintf(diag_file, "%e %e ", sink_mass, accreted_mass); + if ((sink_mass >= AcReal(0.0)) || (accreted_mass >= AcReal(0.0))) { + fprintf(diag_file, "%e %e ", double(sink_mass), double(accreted_mass)); } fprintf(diag_file, "\n"); @@ -208,8 +208,8 @@ run_simulation(void) AcMesh* mesh = acmesh_create(mesh_info); // TODO: This need to be possible to define in astaroth.conf - //acmesh_init_to(INIT_TYPE_GAUSSIAN_RADIAL_EXPL, mesh); - acmesh_init_to(INIT_TYPE_SIMPLE_CORE, mesh); + acmesh_init_to(INIT_TYPE_GAUSSIAN_RADIAL_EXPL, mesh); + //acmesh_init_to(INIT_TYPE_SIMPLE_CORE, mesh); //Initial condition for a collapse test #if LSINK vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); @@ -285,6 +285,18 @@ run_simulation(void) on_off_switch = 1; } acLoadDeviceConstant(AC_switch_accretion, on_off_switch); + + //MV: Old TODOs to remind of eventual future directions. + //TODO_SINK acUpdate_sink_particle() + // 3. Velocity of the particle) + // TODO_SINK acAdvect_sink_particle() + // 1. Calculate the equation of motion for the sink particle. + // NOTE: Might require embedding with acIntegrate(dt). + // TODO_SINK acAccrete_sink_particle() + // 2. Transfer momentum into sink particle + // (OPTIONAL: Affection the motion of the particle) + // NOTE: Might require embedding with acIntegrate(dt). + // This is the hardest part. Please see Lee et al. ApJ 783 (2014) for reference. #else accreted_mass = -1.0; sink_mass = -1.0; #endif @@ -295,27 +307,7 @@ run_simulation(void) #endif - //TODO_SINK acUpdate_sink_particle() - // Update properties of the sing particle for acIntegrate(). Essentially: - // 1. Location of the particle - // 2. Mass of the particle - // 3. Velocity of the particle) - // These can be used for calculating he gravitational field. - // This is my first comment! by Jack - // This is my second comment! by Jack acIntegrate(dt); - // TODO_SINK acAdvect_sink_particle() - // THIS IS OPTIONAL. We will start from unmoving particle. - // 1. Calculate the equation of motion for the sink particle. - // NOTE: Might require embedding with acIntegrate(dt). - - // TODO_SINK acAccrete_sink_particle() - // Calculate accretion of the sink particle from the surrounding medium - // 1. Transfer density into sink particle mass - // 2. Transfer momentum into sink particle - // (OPTIONAL: Affection the motion of the particle) - // NOTE: Might require embedding with acIntegrate(dt). - // This is the hardest part. Please see Lee et al. ApJ 783 (2014) for reference. t_step += dt; @@ -329,9 +321,10 @@ run_simulation(void) */ print_diagnostics(i, dt, t_step, diag_file, sink_mass, accreted_mass); - printf("sink mass is: %.15e \n", sink_mass); - printf("accreted mass is: %.15e \n", accreted_mass); - +#if LSINK + printf("sink mass is: %.15e \n", double(sink_mass)); + printf("accreted mass is: %.15e \n", double(accreted_mass)); +#endif /* We would also might want an XY-average calculating funtion, which can be very useful when observing behaviour of turbulent From 297b788ce77e719a0a5ef92989c405acc09fb795 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 16 Sep 2019 12:33:56 +0800 Subject: [PATCH 84/87] Small corrections to keep the defaults in place. --- src/standalone/model/model_rk3.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/standalone/model/model_rk3.cc b/src/standalone/model/model_rk3.cc index 0680daa..5fab4b4 100644 --- a/src/standalone/model/model_rk3.cc +++ b/src/standalone/model/model_rk3.cc @@ -34,10 +34,10 @@ // Standalone flags #define LDENSITY (1) #define LHYDRO (1) -#define LMAGNETIC (0) -#define LENTROPY (0) +#define LMAGNETIC (1) +#define LENTROPY (1) #define LTEMPERATURE (0) -#define LFORCING (0) +#define LFORCING (1) #define LUPWD (1) #define AC_THERMAL_CONDUCTIVITY (AcReal(0.001)) // TODO: make an actual config parameter From af254257a2dcaa21adc4b1f4f3e3386ca893fee3 Mon Sep 17 00:00:00 2001 From: Miikka Vaisala Date: Mon, 16 Sep 2019 12:38:17 +0800 Subject: [PATCH 85/87] Back to defualts in renderer.cc --- src/standalone/renderer.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/standalone/renderer.cc b/src/standalone/renderer.cc index c99c1f4..475b4b2 100644 --- a/src/standalone/renderer.cc +++ b/src/standalone/renderer.cc @@ -296,8 +296,8 @@ renderer_quit(void) return 0; } -//static int init_type = INIT_TYPE_GAUSSIAN_RADIAL_EXPL; -static int init_type = INIT_TYPE_SIMPLE_CORE; +static int init_type = INIT_TYPE_GAUSSIAN_RADIAL_EXPL; +//static int init_type = INIT_TYPE_SIMPLE_CORE; static bool running(AcMesh* mesh) From 9b0be40b983a9581410bb9a794c170dff9f733bf Mon Sep 17 00:00:00 2001 From: jpekkila Date: Tue, 17 Sep 2019 17:36:28 +0300 Subject: [PATCH 86/87] Auto-formatted --- src/standalone/config_loader.cc | 18 +++++------- src/standalone/renderer.cc | 14 ++++----- src/standalone/simulation.cc | 51 +++++++++++++++++---------------- 3 files changed, 40 insertions(+), 43 deletions(-) diff --git a/src/standalone/config_loader.cc b/src/standalone/config_loader.cc index 3df7d12..98098ff 100644 --- a/src/standalone/config_loader.cc +++ b/src/standalone/config_loader.cc @@ -125,28 +125,24 @@ update_config(AcMeshInfo* config) config->real_params[AC_gamma]; AcReal G_CONST_CGS = AcReal( - 6.674e-8); // cm^3/(g*s^2) GGS definition //TODO define in a separate module + 6.674e-8); // cm^3/(g*s^2) GGS definition //TODO define in a separate module AcReal M_sun = AcReal(1.989e33); // g solar mass - config->real_params[AC_unit_mass] = (config->real_params[AC_unit_length] * config->real_params[AC_unit_length] * config->real_params[AC_unit_length]) * - config->real_params[AC_unit_density]; + config->real_params[AC_unit_density]; - - - - config->real_params[AC_M_sink] = config->real_params[AC_M_sink_Msun] * M_sun / - config->real_params[AC_unit_mass]; - config->real_params[AC_M_sink_init] = config->real_params[AC_M_sink_Msun] * M_sun / - config->real_params[AC_unit_mass]; + config->real_params[AC_M_sink] = config->real_params[AC_M_sink_Msun] * M_sun / + config->real_params[AC_unit_mass]; + config->real_params[AC_M_sink_init] = config->real_params[AC_M_sink_Msun] * M_sun / + config->real_params[AC_unit_mass]; config->real_params[AC_G_const] = G_CONST_CGS / ((config->real_params[AC_unit_velocity] * config->real_params[AC_unit_velocity]) / (config->real_params[AC_unit_density] * config->real_params[AC_unit_length] * - config->real_params[AC_unit_length] )); + config->real_params[AC_unit_length])); config->real_params[AC_sq2GM_star] = AcReal(sqrt(AcReal(2) * config->real_params[AC_GM_star])); diff --git a/src/standalone/renderer.cc b/src/standalone/renderer.cc index 475b4b2..be36a37 100644 --- a/src/standalone/renderer.cc +++ b/src/standalone/renderer.cc @@ -41,7 +41,7 @@ #include "src/core/math_utils.h" #include "timer_hires.h" -//NEED TO BE DEFINED HERE. IS NOT NOTICED BY compile_acc call. +// NEED TO BE DEFINED HERE. IS NOT NOTICED BY compile_acc call. #define LFORCING (1) #define LSINK (0) @@ -297,7 +297,7 @@ renderer_quit(void) } static int init_type = INIT_TYPE_GAUSSIAN_RADIAL_EXPL; -//static int init_type = INIT_TYPE_SIMPLE_CORE; +// static int init_type = INIT_TYPE_SIMPLE_CORE; static bool running(AcMesh* mesh) @@ -396,10 +396,10 @@ run_renderer(void) /* Step the simulation */ #if LSINK const AcReal sum_mass = acReduceScal(RTYPE_SUM, VTXBUF_ACCRETION); - accreted_mass = accreted_mass + sum_mass; - AcReal sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; - printf("sink mass is: %e \n", sink_mass); - printf("accreted mass is: %e \n", accreted_mass); + accreted_mass = accreted_mass + sum_mass; + AcReal sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; + printf("sink mass is: %e \n", sink_mass); + printf("accreted mass is: %e \n", accreted_mass); acLoadDeviceConstant(AC_M_sink, sink_mass); vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); #endif @@ -409,12 +409,10 @@ run_renderer(void) loadForcingParamsToDevice(forcing_params); #endif - #if 1 const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); const AcReal dt = host_timestep(umax, mesh_info); - acIntegrate(dt); #else ModelMesh* model_mesh = modelmesh_create(mesh->info); diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index efa6914..65df422 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -40,7 +40,7 @@ #include #include -//NEED TO BE DEFINED HERE. IS NOT NOTICED BY compile_acc call. +// NEED TO BE DEFINED HERE. IS NOT NOTICED BY compile_acc call. #define LFORCING (1) #define LSINK (0) @@ -92,22 +92,23 @@ write_mesh_info(const AcMeshInfo* config) fprintf(infotxt, "real AC_cs2_sound %e \n", (double)config->real_params[AC_cs2_sound]); fprintf(infotxt, "real AC_cv_sound %e \n", (double)config->real_params[AC_cv_sound]); - //Physical units + // Physical units fprintf(infotxt, "real AC_unit_density %e \n", (double)config->real_params[AC_unit_density]); fprintf(infotxt, "real AC_unit_velocity %e \n", (double)config->real_params[AC_unit_velocity]); - fprintf(infotxt, "real AC_unit_mass %e \n", (double)config->real_params[AC_unit_mass ]); - fprintf(infotxt, "real AC_unit_length %e \n", (double)config->real_params[AC_unit_length ]); + fprintf(infotxt, "real AC_unit_mass %e \n", (double)config->real_params[AC_unit_mass]); + fprintf(infotxt, "real AC_unit_length %e \n", (double)config->real_params[AC_unit_length]); - //Here I'm still trying to copy the structure of the code above, and see if this will work for sink particle. - //I haven't fully undertand what these lines do but I'll read up on them soon. This is still yet experimental. - // Sink particle + // Here I'm still trying to copy the structure of the code above, and see if this will work for + // sink particle. I haven't fully undertand what these lines do but I'll read up on them soon. + // This is still yet experimental. + // Sink particle fprintf(infotxt, "real AC_sink_pos_x %e \n", (double)config->real_params[AC_sink_pos_x]); fprintf(infotxt, "real AC_sink_pos_y %e \n", (double)config->real_params[AC_sink_pos_y]); fprintf(infotxt, "real AC_sink_pos_z %e \n", (double)config->real_params[AC_sink_pos_z]); fprintf(infotxt, "real AC_M_sink %e \n", (double)config->real_params[AC_M_sink]); fprintf(infotxt, "real AC_soft %e \n", (double)config->real_params[AC_soft]); fprintf(infotxt, "real AC_G_const %e \n", (double)config->real_params[AC_G_const]); - + fclose(infotxt); } @@ -155,8 +156,8 @@ save_mesh(const AcMesh& save_mesh, const int step, const AcReal t_step) // This function prints out the diagnostic values to std.out and also saves and // appends an ascii file to contain all the result. static inline void -print_diagnostics(const int step, const AcReal dt, const AcReal t_step, FILE* diag_file, - const AcReal sink_mass, const AcReal accreted_mass) +print_diagnostics(const int step, const AcReal dt, const AcReal t_step, FILE* diag_file, + const AcReal sink_mass, const AcReal accreted_mass) { AcReal buf_rms, buf_max, buf_min; @@ -209,7 +210,7 @@ run_simulation(void) AcMesh* mesh = acmesh_create(mesh_info); // TODO: This need to be possible to define in astaroth.conf acmesh_init_to(INIT_TYPE_GAUSSIAN_RADIAL_EXPL, mesh); - //acmesh_init_to(INIT_TYPE_SIMPLE_CORE, mesh); //Initial condition for a collapse test + // acmesh_init_to(INIT_TYPE_SIMPLE_CORE, mesh); //Initial condition for a collapse test #if LSINK vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); @@ -264,7 +265,8 @@ run_simulation(void) // acUpdate_sink_particle() will do the similar trick to the device. /* Step the simulation */ - AcReal accreted_mass = 0.0; AcReal sink_mass = 0.0; + AcReal accreted_mass = 0.0; + AcReal sink_mass = 0.0; for (int i = 1; i < max_steps; ++i) { const AcReal umax = acReduceVec(RTYPE_MAX, VTXBUF_UUX, VTXBUF_UUY, VTXBUF_UUZ); const AcReal dt = host_timestep(umax, mesh_info); @@ -272,22 +274,23 @@ run_simulation(void) #if LSINK const AcReal sum_mass = acReduceScal(RTYPE_SUM, VTXBUF_ACCRETION); - accreted_mass = accreted_mass + sum_mass; - sink_mass = 0.0; - sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; + accreted_mass = accreted_mass + sum_mass; + sink_mass = 0.0; + sink_mass = mesh_info.real_params[AC_M_sink_init] + accreted_mass; acLoadDeviceConstant(AC_M_sink, sink_mass); vertex_buffer_set(VTXBUF_ACCRETION, 0.0, mesh); - + int on_off_switch; if (i < 1) { - on_off_switch = 0; //accretion is off till certain amount of steps. - } else { + on_off_switch = 0; // accretion is off till certain amount of steps. + } + else { on_off_switch = 1; } acLoadDeviceConstant(AC_switch_accretion, on_off_switch); - //MV: Old TODOs to remind of eventual future directions. - //TODO_SINK acUpdate_sink_particle() + // MV: Old TODOs to remind of eventual future directions. + // TODO_SINK acUpdate_sink_particle() // 3. Velocity of the particle) // TODO_SINK acAdvect_sink_particle() // 1. Calculate the equation of motion for the sink particle. @@ -298,7 +301,8 @@ run_simulation(void) // NOTE: Might require embedding with acIntegrate(dt). // This is the hardest part. Please see Lee et al. ApJ 783 (2014) for reference. #else - accreted_mass = -1.0; sink_mass = -1.0; + accreted_mass = -1.0; + sink_mass = -1.0; #endif #if LFORCING @@ -306,7 +310,6 @@ run_simulation(void) loadForcingParamsToDevice(forcing_params); #endif - acIntegrate(dt); t_step += dt; @@ -322,8 +325,8 @@ run_simulation(void) print_diagnostics(i, dt, t_step, diag_file, sink_mass, accreted_mass); #if LSINK - printf("sink mass is: %.15e \n", double(sink_mass)); - printf("accreted mass is: %.15e \n", double(accreted_mass)); + printf("sink mass is: %.15e \n", double(sink_mass)); + printf("accreted mass is: %.15e \n", double(accreted_mass)); #endif /* We would also might want an XY-average calculating funtion, From d2057b8f5a9160d42d80e6fede442c3336d81e74 Mon Sep 17 00:00:00 2001 From: jpekkila Date: Tue, 17 Sep 2019 18:12:43 +0300 Subject: [PATCH 87/87] Added a suggestion for writing out the configuration in simulation.cc --- src/standalone/simulation.cc | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/src/standalone/simulation.cc b/src/standalone/simulation.cc index 65df422..bdf0b18 100644 --- a/src/standalone/simulation.cc +++ b/src/standalone/simulation.cc @@ -60,6 +60,28 @@ write_mesh_info(const AcMeshInfo* config) infotxt = fopen("mesh_info.list", "w"); + /* + // JP: this could be done shorter and with smaller chance for errors with the following + // (modified from acPrintMeshInfo() in astaroth.cu) + + for (int i = 0; i < NUM_INT_PARAMS; ++i) + fprintf(infotxt, "int %s: %d\n", intparam_names[i], config.int_params[i]); + + for (int i = 0; i < NUM_INT3_PARAMS; ++i) + fprintf(infotxt, "int3 %s: (%d, %d, %d)\n", int3param_names[i], config.int3_params[i].x, + config.int3_params[i].y, + config.int3_params[i].z); + + for (int i = 0; i < NUM_REAL_PARAMS; ++i) + fprintf(infotxt, "real %s: %g\n", realparam_names[i], double(config.real_params[i])); + + for (int i = 0; i < NUM_REAL3_PARAMS; ++i) + fprintf(infotxt, "real %s: (%g, %g, %g)\n", real3param_names[i], + double(config.real3_params[i].x), + double(config.real3_params[i].y), + double(config.real3_params[i].z)); + */ + // Total grid dimensions fprintf(infotxt, "int AC_mx %i \n", config->int_params[AC_mx]); fprintf(infotxt, "int AC_my %i \n", config->int_params[AC_my]);