1) remove override sza/azi options as these angles are provided through the input files, we prefer to keep the slowly growing command line somewhat consise. 2) rename 'disable-2s' (default False) cmd line option to 'two-stream' (default True)

Author: MennoVeerman

include_test/Radiation_solver_rt.h

@@ -99,7 +99,7 @@ class Radiation_solver_shortwave
         #ifdef __CUDACC__
         void solve_gpu(
                 const bool switch_fluxes,
-                const bool switch_disable_2s,
+                const bool switch_twostream,
                 const bool switch_raytracing,
                 const bool switch_independent_column,
                 const bool switch_cloud_optics,

src_test/Radiation_solver_rt.cu

@@ -567,7 +567,7 @@ void Radiation_solver_shortwave::load_mie_tables(
 
 void Radiation_solver_shortwave::solve_gpu(
         const bool switch_fluxes,
-        const bool switch_disable_2s,
+        const bool switch_twostream,
         const bool switch_raytracing,
         const bool switch_independent_column,
         const bool switch_cloud_optics,
@@ -637,7 +637,7 @@ void Radiation_solver_shortwave::solve_gpu(
 
     if (switch_fluxes)
     {
-        if (!switch_disable_2s)
+        if (switch_twostream)
         {
                 Gas_optics_rrtmgp_kernels_cuda_rt::zero_array(n_lev, grid_cells.y, grid_cells.x, sw_flux_up.ptr());
                 Gas_optics_rrtmgp_kernels_cuda_rt::zero_array(n_lev, grid_cells.y, grid_cells.x, sw_flux_dn.ptr());
@@ -840,7 +840,7 @@ void Radiation_solver_shortwave::solve_gpu(
             }
 
             (*fluxes).net_flux();
-            if (!switch_disable_2s)
+            if (switch_twostream)
             {
                 Gpt_combine_kernels_cuda_rt::add_from_gpoint(
                         n_col, n_lev, sw_flux_up.ptr(), sw_flux_dn.ptr(), sw_flux_dn_dir.ptr(), sw_flux_net.ptr(),

src_test/test_rte_rrtmgp_rt.cu

@@ -227,7 +227,7 @@ void solve_radiation(int argc, char** argv)
         {"shortwave"         , { true,  "Enable computation of shortwave radiation."}},
         {"longwave"          , { false, "Enable computation of longwave radiation." }},
         {"fluxes"            , { true,  "Enable computation of fluxes."             }},
-        {"disable-2s"        , { false, "use raytracing onlu for flux computation. must be passed with raytracing" }},
+        {"two-stream"        , { true, "Run two-stream solver for to obtain 1D fluxes" }},
         {"raytracing"        , { true,  "Use raytracing for flux computation. '--raytracing 256': use 256 rays per pixel" }},
         {"independent-column", { false, "run raytracer in independent column mode"}},
         {"cloud-optics"      , { false, "Enable cloud optics (both liquid and ice)."}},
@@ -238,23 +238,19 @@ void solve_radiation(int argc, char** argv)
         {"single-gpt"        , { false, "Output optical properties and fluxes for a single g-point. '--single-gpt 100': output 100th g-point" }},
         {"profiling"         , { false, "Perform additional profiling run."         }},
         {"delta-cloud"       , { false, "delta-scaling of cloud optical properties"   }},
-        {"delta-aerosol"     , { false, "delta-scaling of aerosol optical properties"   }} ,
-        {"override-sza"     , { false, "override provided value of sza in input file. IN DEGREES. '--override-sza 50': use a sza of 50 degrees" }},
-        {"override-azi"     , { false, "override provided value of azi in input file. IN DEGREES. '--override-azi 240': use of azi of 240 degrees"   }}};
+        {"delta-aerosol"     , { false, "delta-scaling of aerosol optical properties"   }}};
 
     std::map<std::string, std::pair<int, std::string>> command_line_ints {
         {"raytracing", {32, "Number of rays initialised at TOD per pixel per quadraute."}},
-        {"single-gpt", {1 , "g-point to store optical properties and fluxes of" }},
-        {"override-sza", {0, "solar zenith angle (theta) in degrees."}},
-        {"override-azi", {0, "Solar azimuth angle in degrees."}} };
+        {"single-gpt", {1 , "g-point to store optical properties and fluxes of" }}};
 
     if (parse_command_line_options(command_line_switches, command_line_ints, argc, argv))
         return;
 
     const bool switch_shortwave         = command_line_switches.at("shortwave"         ).first;
     const bool switch_longwave          = command_line_switches.at("longwave"          ).first;
     const bool switch_fluxes            = command_line_switches.at("fluxes"            ).first;
-    const bool switch_disable_2s        = command_line_switches.at("disable-2s"        ).first;
+    const bool switch_twostream         = command_line_switches.at("two-stream"        ).first;
     const bool switch_raytracing        = command_line_switches.at("raytracing"        ).first;
     const bool switch_independent_column= command_line_switches.at("independent-column").first;
     bool switch_cloud_optics      = command_line_switches.at("cloud-optics"      ).first;
@@ -266,8 +262,6 @@ void solve_radiation(int argc, char** argv)
     const bool switch_profiling         = command_line_switches.at("profiling"         ).first;
     const bool switch_delta_cloud       = command_line_switches.at("delta-cloud"       ).first;
     const bool switch_delta_aerosol     = command_line_switches.at("delta-aerosol"     ).first;
-    const bool override_sza             = command_line_switches.at("override-sza"    ).first;
-    const bool override_azi             = command_line_switches.at("override-azi"    ).first;
 
     Int photons_per_pixel = Int(command_line_ints.at("raytracing").first);
     if (Float(int(std::log2(Float(photons_per_pixel)))) != std::log2(Float(photons_per_pixel)))
@@ -282,7 +276,7 @@ void solve_radiation(int argc, char** argv)
         throw std::runtime_error(error);
     }
 
-    if (switch_disable_2s && !switch_raytracing) {
+    if (!switch_twostream && !switch_raytracing) {
         std::string error = "cannot disable two-stream for flux calculation without turning ray tracing on";
         throw std::runtime_error(error);
     }
@@ -301,21 +295,9 @@ void solve_radiation(int argc, char** argv)
     print_command_line_options(command_line_switches, command_line_ints);
 
     int single_gpt = command_line_ints.at("single-gpt").first;
-    int sza_deg = Int(command_line_ints.at("override-sza").first);
-    int azi_deg = Int(command_line_ints.at("override-azi").first);
 
     Status::print_message("Using "+ std::to_string(photons_per_pixel) + " rays per pixel");
 
-    if (override_sza) 
-    {
-        Status::print_message("Using SZA of "+ std::to_string(sza_deg) + " degrees");
-    }
-
-    if (override_azi) 
-    {
-        Status::print_message("Using azi of "+ std::to_string(azi_deg) + " degrees");
-    }
-
     ////// READ THE ATMOSPHERIC DATA //////
     Status::print_message("Reading atmospheric input data from NetCDF.");
 
@@ -392,15 +374,17 @@ void solve_radiation(int argc, char** argv)
     if (switch_cloud_optics)
     {
 
-        if(switch_liq_cloud_optics){
+        if(switch_liq_cloud_optics)
+        {
             lwp.set_dims({n_col, n_lay});
             lwp = std::move(input_nc.get_variable<Float>("lwp", {n_lay, n_col_y, n_col_x}));
 
             rel.set_dims({n_col, n_lay});
             rel = std::move(input_nc.get_variable<Float>("rel", {n_lay, n_col_y, n_col_x}));
         }
 
-        if(switch_ice_cloud_optics){
+        if(switch_ice_cloud_optics)
+        {
             iwp.set_dims({n_col, n_lay});
             iwp = std::move(input_nc.get_variable<Float>("iwp", {n_lay, n_col_y, n_col_x}));
 
@@ -682,24 +666,8 @@ void solve_radiation(int argc, char** argv)
             rad_sw.load_mie_tables("mie_lut_broadband.nc");
         }
 
-        Array<Float,1> mu0({n_col});
-        Array<Float,1> azi({n_col});
-
-        if (override_sza) {
-            Float mu0_in = cosf(sza_deg * 3.14159f / 180.0f);
-            for (int icol=1; icol<=n_col; ++icol)
-                mu0({icol}) = mu0_in;
-        } else {
-            mu0 = input_nc.get_variable<Float>("mu0", {n_col_y, n_col_x});
-        }
-
-        if (override_azi) {
-            Float azi_in = azi_deg * 3.14159f / 180.0f;
-            for (int icol=1; icol<=n_col; ++icol)
-                azi({icol}) = azi_in;
-        } else {
-            azi = input_nc.get_variable<Float>("azi", {n_col_y, n_col_x});
-        }
+        Array<Float,1> mu0(input_nc.get_variable<Float>("mu0", {n_col_y, n_col_x}), {n_col});
+        Array<Float,1> azi(input_nc.get_variable<Float>("azi", {n_col_y, n_col_x}), {n_col});
 
         Array<Float,2> sfc_alb_dir(input_nc.get_variable<Float>("sfc_alb_dir", {n_col_y, n_col_x, n_bnd_sw}), {n_bnd_sw, n_col});
         Array<Float,2> sfc_alb_dif(input_nc.get_variable<Float>("sfc_alb_dif", {n_col_y, n_col_x, n_bnd_sw}), {n_bnd_sw, n_col});
@@ -761,7 +729,7 @@ void solve_radiation(int argc, char** argv)
 
         if (switch_fluxes)
         {
-            if(!switch_disable_2s)
+            if(switch_twostream)
             {
                 sw_flux_up    .set_dims({n_col, n_lev});
                 sw_flux_dn    .set_dims({n_col, n_lev});
@@ -828,7 +796,7 @@ void solve_radiation(int argc, char** argv)
 
             rad_sw.solve_gpu(
                     switch_fluxes,
-                    switch_disable_2s,
+                    switch_twostream,
                     switch_raytracing,
                     switch_independent_column,
                     switch_cloud_optics,
@@ -966,7 +934,7 @@ void solve_radiation(int argc, char** argv)
 
         if (switch_fluxes)
         {
-            if (!switch_disable_2s)
+            if (switch_twostream)
             {
                 auto nc_sw_flux_up     = output_nc.add_variable<Float>("sw_flux_up"    , {"lev", "y", "x"});
                 auto nc_sw_flux_dn     = output_nc.add_variable<Float>("sw_flux_dn"    , {"lev", "y", "x"});
@@ -1032,7 +1000,7 @@ void solve_radiation(int argc, char** argv)
 
             if (switch_single_gpt)
             { 
-                if (!switch_disable_2s)
+                if (switch_twostream)
                 {
                     auto nc_sw_gpt_flux_up     = output_nc.add_variable<Float>("sw_gpt_flux_up"    , {"lev", "y", "x"});
                     auto nc_sw_gpt_flux_dn     = output_nc.add_variable<Float>("sw_gpt_flux_dn"    , {"lev", "y", "x"});