address joss changes

aelligp · aelligp · commit a67afb59cdd3 · 2024-10-18T14:53:04.000+02:00
diff --git a/docs/src/man/Tutorial_Basic.md b/docs/src/man/Tutorial_Basic.md
@@ -70,9 +70,17 @@ Saved file: Topo_Alps.vts
 
 ````
 
-If we open both datasets in Paraview, we see this (after giving some color to the topography):
+If we open both datasets in Paraview, and changing both files from outline/solid colors to the corresponing data field, we see:
+![Basic_Tutorial_1](../assets/img/Basic_Tutorial_Paraview_1.png)
+Now we can change the colormap on the right side, marked by a red square. For topography we use the `Oleron` colormap, which you can download [here](https://www.fabiocrameri.ch/colourmaps/).
+For the tomography we use the `Roma` scientific colormap. You will now see a blue'ish box of the tomography, this is not the best color to visualise the data. Let's invert the colormap by clicking on the item marked by the blue arrow.
+Now we see the tomography in a more intuitive way, but the topography is not visible anymore. We can change the opacity of the tomography by setting a value in the `Opacity` field marked by the red square.
+Note that you will need to adapt the range of the topography colormap as the change in color is not at 0.0. By clicking on the item marked by the black arrow, you can set your desired range.
+
+![Basic_Tutorial_1](../assets/img/Basic_Tutorial_Paraview_2.png)
+
+Now you should see somthing like this:
 ![Basic_Tutorial_1](../assets/img/Basic_Tutorial_1.png)
-Note that I use the `Oleron` scientific colormap for the tomography which you can download [here](https://www.fabiocrameri.ch/colourmaps/)
 
 ### 2. Extract subset of data
 As you can see the tomographic data covers a much larger area than the Alps itself, and in most of that area there is no data.
@@ -89,7 +97,7 @@ Saved file: Tomo_Alps.vts
 
 ````
 
-Which looks like:
+After loading the new data again in paraview, switching to the proper data field and adjusting the colormap, you should see somthing like this:
 ![Basic_Tutorial_2](../assets/img/Basic_Tutorial_2.png)
 
 ### 3. Create cross sections
@@ -128,7 +136,7 @@ GeoData
 ````
 
 In general, you can get help info for all functions with `?`:
-```julia
+```julia-repl
 help?> cross_section
 search: cross_section cross_section_volume cross_section_points cross_section_surface flatten_cross_section
 
@@ -198,8 +206,12 @@ Saved file: data_200km.vts
 
 ````
 
+After loading the data in Paraview, you can use the `Clip` tool on the topography to only show the topography above sealevel and make it 60% transparent. Also adjust the colormap of the tomography to 5.0 and -5.0
+
+![Basic_Tutorial_3](../assets/img/Basic_Tutorial_Paraview_3.png)
+
+After doing all these steps, you should see something like this:
 ![Basic_Tutorial_3](../assets/img/Basic_Tutorial_3.png)
-In creating this image, I used the `Clip` tool of Paraview to only show topography above sealevel and made it 50% transparent.
 
 ### 4. Cartesian data
 As you can see, the curvature or the Earth is taken into account here. Yet, for many applications it is more convenient to work in Cartesian coordinates (kilometers) rather then in geographic coordinates.
diff --git a/docs/src/man/Tutorial_Chmy_MPI.md b/docs/src/man/Tutorial_Chmy_MPI.md
@@ -156,9 +156,8 @@ You can than run it with:
 mpiexecjl -n 4 --project=. julia Tutorial_Chmy_MPI.jl
 ```
 
-The full file can be downloaded [here](../../../tutorials/Tutorial_Chmy_MPI.jl)
+The full file can be downloaded [here](https://github.com/JuliaGeodynamics/GeophysicalModelGenerator.jl/blob/main/tutorials/Tutorial_Chmy_MPI.jl)
 
 ---
 
 *This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).*
-
diff --git a/docs/src/man/tutorial_ISC_data.md b/docs/src/man/tutorial_ISC_data.md
@@ -10,7 +10,7 @@ You can get data from the ISC catalogue here:
 The catalogue will give you an on screen CSV output that will then have to be copied to a file of your choice (here we will call it `ISC1.dat`). Do that and start julia from the directory where it was downloaded.
 
 #### 2. Read data into Julia
-The main data-file, `ISC1.dat`, has 23 lines of comments (indicated with `#`), after which the data starts. We can use the julia package [https://github.com/JuliaData/CSV.jl](CSV.jl) to read in the data, and tell it that the data is separated by `,`.
+The main data-file, `ISC1.dat`, has 23 lines of comments (indicated with `#`), after which the data starts. We can use the julia package [CSV.jl](https://github.com/JuliaData/CSV.jl) to read in the data, and tell it that the data is separated by `,`.
 ```julia-repl
 julia> using CSV, GeophysicalModelGenerator
 julia> data_file = CSV.File("ISC1.dat",datarow=24,header=false,delim=',')
diff --git a/docs/src/man/tutorial_loadregular3DSeismicData_netCDF.md b/docs/src/man/tutorial_loadregular3DSeismicData_netCDF.md
@@ -11,7 +11,7 @@ El-Sharkawy et al. (2020), *The Slab Puzzle of the Alpine‐Mediterranean Region
 The data is can be downloaded from [https://ds.iris.edu/files/products/emc/emc-files/El-Sharkawy-etal-G3.2020-MeRE2020-Mediterranean-0.0.nc](https://ds.iris.edu/files/products/emc/emc-files/El-Sharkawy-etal-G3.2020-MeRE2020-Mediterranean-0.0.nc). Do that and start julia from the directory where it was downloaded.
 
 #### 2. Read data into Julia
-The main data-file, `El-Sharkawy-etal-G3.2020-MeRE2020-Mediterranean-0.0.nc`, is given as netCDF file. To read in data of this type, it is necessary to load an appropriate package. Here, we will use the [https://github.com/JuliaGeo/NetCDF.jl](NetCDF.jl) package. Download and install the package with:
+The main data-file, `El-Sharkawy-etal-G3.2020-MeRE2020-Mediterranean-0.0.nc`, is given as netCDF file. To read in data of this type, it is necessary to load an appropriate package. Here, we will use the [NetCDF.jl](https://github.com/JuliaGeo/NetCDF.jl) package. Download and install the package with:
  ```julia
 julia> using Pkg
 julia> Pkg.add("NetCDF")
diff --git a/src/LaMEM_io.jl b/src/LaMEM_io.jl
@@ -97,12 +97,12 @@ Extracts a certain `keyword` from a LaMEM input `file` and convert it to a certa
 Optionally, you can also pass command-line arguments which will override the value read from the input file.
 
 # Example 1:
-```julia
+```julia-repl
 julia> nmark_z = ParseValue_LaMEM_InputFile("SaltModels.dat","nmark_z",Int64)
 ```
 
 # Example 2:
-```julia
+```julia-repl
 julia> nmark_z = ParseValue_LaMEM_InputFile("SaltModels.dat","nmark_z",Int64, args="-nel_x 128 -coord_x -4,4")
 ```
 
@@ -173,7 +173,7 @@ Parses a LaMEM input file and stores grid information in the `Grid` structure.
 Optionally, you can pass LaMEM command-line arguments as well.
 
 # Example 1
-```julia
+```julia-repl
 julia> Grid = read_LaMEM_inputfile("SaltModels.dat")
 LaMEM Grid:
 nel         : (32, 32, 32)
@@ -185,7 +185,7 @@ z           ϵ [-2.0 : 0.0]
 ```
 
 # Example 2 (with command-line arguments)
-```julia
+```julia-repl
 julia> Grid = read_LaMEM_inputfile("SaltModels.dat", args="-nel_x 64 -coord_x -4,4")
 LaMEM Grid:
   nel         : (64, 32, 32)
@@ -823,7 +823,7 @@ end
 Reads a parallel, rectilinear, `*.vts` file with the name `fname` and located in `dir` and create a 3D `Data` struct from it.
 
 # Example
-```julia
+```julia-repl
 julia> Data = read_data_PVTR("Haaksbergen.pvtr", "./Timestep_00000005_3.35780500e-01/")
 ParaviewData
   size  : (33, 33, 33)
@@ -1025,6 +1025,6 @@ function coordinate_grids(Data::LaMEM_grid; cell=false)
     if cell
         X,Y,Z = average_q1(X),average_q1(Y), average_q1(Z)
     end
-    
+
     return X,Y,Z
 end
diff --git a/src/WaterFlow.jl b/src/WaterFlow.jl
@@ -19,7 +19,7 @@ function spacing(lon,lat)
      dlat[:,2:end-1] = (lat.val[:,3:end,1] - lat.val[:,1:end-2,1])/2
      dlat[:,1] = dlat[:,2]
      dlat[:,end] = dlat[:,end-1]
-    
+
     return dlon, dlat
 end
 
@@ -39,26 +39,26 @@ end
 
 
 """
-    Topo_water, sinks, pits, bnds  = waterflows(Topo::GeoData; 
+    Topo_water, sinks, pits, bnds  = waterflows(Topo::GeoData;
         flowdir_fn=WhereTheWaterFlows.d8dir_feature, feedback_fn=nothing, drain_pits=true, bnd_as_sink=true,
         rainfall = nothing,
         minsize=300)
 
 Takes a GMG GeoData object of a topographic map and routes water through the grid. Optionally,
-you can specify `rainfall` in which case we accumulate the rain as specified in this 2D array instead of the cellarea. 
+you can specify `rainfall` in which case we accumulate the rain as specified in this 2D array instead of the cellarea.
 This allows you to, for example, sum, up water if you have variable rainfall in the area.
 The other options are as in the `waterflows` function of the package `WhereTheWaterFlows`.
 
 Example
 ===
-```julia
+```julia-repl
 # Download some topographic data
 julia> Topo = import_topo([6.5,7.3,50.2,50.6], file="@earth_relief_03s");
 
 # Flow the water through the area:
 julia> Topo_water, sinks, pits, bnds  = waterflows(Topo)
 julia> Topo_water
-GeoData 
+GeoData
   size      : (961, 481, 1)
   lon       ϵ [ 6.5 : 7.3]
   lat       ϵ [ 50.2 : 50.59999999999999]
@@ -68,7 +68,7 @@ GeoData
 ```
 
 """
-function waterflows(Topo::GeoData, flowdir_fn= WhereTheWaterFlows.d8dir_feature; feedback_fn=nothing, drain_pits=true, bnd_as_sink=true, rainfall=nothing, minsize=300) 
+function waterflows(Topo::GeoData, flowdir_fn= WhereTheWaterFlows.d8dir_feature; feedback_fn=nothing, drain_pits=true, bnd_as_sink=true, rainfall=nothing, minsize=300)
 
     cellarea = cell_area(Topo)
     cellarea_m2 = cellarea
@@ -96,10 +96,10 @@ function waterflows(Topo::GeoData, flowdir_fn= WhereTheWaterFlows.d8dir_feature;
     largest_catchment = catchment_large .== catchment_large[id_max]
     largest_area = copy(area)
     largest_area[.!largest_catchment] .= NaN
-    
+
     log10_area = log10.(area)
     log10_largest_area = log10.(largest_area)
 
-    Topo_water =  addfield(Topo,(;area, slen, dir, nout, nin, c, cellarea_m2, catchment_large, log10_area, largest_catchment, largest_area, log10_largest_area))                        
-    return Topo_water, sinks, pits, bnds 
-end
+    Topo_water =  addfield(Topo,(;area, slen, dir, nout, nin, c, cellarea_m2, catchment_large, log10_area, largest_catchment, largest_area, log10_largest_area))
+    return Topo_water, sinks, pits, bnds
+end
diff --git a/src/surface_functions.jl b/src/surface_functions.jl
@@ -17,12 +17,12 @@ function is_surface(surf::AbstractGeneralGrid)
     return issurf
 end
 
-function  +(a::_T, b::_T) where _T<:AbstractGeneralGrid 
+function  +(a::_T, b::_T) where _T<:AbstractGeneralGrid
     @assert size(a) == size(b)
     return _addSurfaces(a,b)
 end
 
-function  -(a::_T, b::_T) where _T<:AbstractGeneralGrid 
+function  -(a::_T, b::_T) where _T<:AbstractGeneralGrid
     @assert size(a) == size(b)
     return _subtractSurfaces(a,b)
 end
@@ -71,11 +71,11 @@ This drapes fields of a data set `Data` on the topography `Topo`
 function drape_on_topo(Topo::GeoData, Data::GeoData)
     @assert is_surface(Topo)
     @assert is_surface(Data)
-   
+
     Lon,Lat,_   =   lonlatdepth_grid( Topo.lon.val[:,1,1], Topo.lat.val[1,:,1],Topo.depth.val[1,1,:]);
 
     # use nearest neighbour to interpolate data
-    idx         =   nearest_point_indices(Lon,Lat, vec(Data.lon.val), vec(Data.lat.val) ); 
+    idx         =   nearest_point_indices(Lon,Lat, vec(Data.lon.val), vec(Data.lat.val) );
 
     idx_out     =   findall(  (Lon .<  minimum(Data.lon.val)) .| (Lon .>  maximum(Data.lon.val)) .|
                               (Lat .<  minimum(Data.lat.val)) .| (Lat .>  maximum(Data.lat.val)) )
@@ -137,7 +137,7 @@ Drapes Cartesian Data on topography
 function drape_on_topo(Topo::CartData, Data::CartData)
     @assert is_surface(Topo)
     @assert is_surface(Data)
-    
+
     Topo_lonlat = GeoData(ustrip.(Topo.x.val),ustrip.(Topo.y.val), ustrip.(Topo.z.val), Topo.fields )
     Data_lonlat = GeoData(ustrip.(Data.x.val),ustrip.(Data.y.val), ustrip.(Data.z.val), Data.fields )
 
@@ -152,12 +152,12 @@ end
 """
     surf_new = fit_surface_to_points(surf::GeoData, lon_pt::Vector, lat_pt::Vector, depth_pt::Vector)
 
-This fits the `depth` values of the surface `surf` to the `depth` value of the closest-by-points in (`lon_pt`,`lat_pt`, `depth_pt`) 
+This fits the `depth` values of the surface `surf` to the `depth` value of the closest-by-points in (`lon_pt`,`lat_pt`, `depth_pt`)
 
 """
 function fit_surface_to_points(surf::GeoData, lon_pt::Vector, lat_pt::Vector, depth_pt::Vector)
     @assert is_surface(surf)
-    
+
     idx = nearest_point_indices(NumValue(surf.lon),NumValue(surf.lat),  lon_pt, lat_pt);
     depth = NumValue(surf.depth)
     depth[idx] .= depth_pt[idx];
@@ -171,12 +171,12 @@ end
 """
     surf_new = fit_surface_to_points(surf::CartData, lon_pt::Vector, lat_pt::Vector, depth_pt::Vector)
 
-This fits the `depth` values of the surface `surf` to the `depth` value of the closest-by-points in (`lon_pt`,`lat_pt`, `depth_pt`) 
+This fits the `depth` values of the surface `surf` to the `depth` value of the closest-by-points in (`lon_pt`,`lat_pt`, `depth_pt`)
 
 """
 function fit_surface_to_points(surf::CartData, X_pt::Vector, Y_pt::Vector, Z_pt::Vector)
     @assert is_surface(surf)
-    
+
     idx = nearest_point_indices(NumValue(surf.x),NumValue(surf.y),  X_pt[:], Y_pt[:]);
     depth = NumValue(surf.z)
     depth = Z_pt[idx]
@@ -197,7 +197,7 @@ This can be used, for example, to mask points above/below the Moho in a volumetr
 
 # Example
 First we create a 3D data set and a 2D surface:
-```julia
+```julia-repl
 julia> Lon,Lat,Depth   =   lonlatdepth_grid(10:20,30:40,(-300:25:0)km);
 julia> Data            =   Depth*2;
 julia> Data_set3D      =   GeoData(Lon,Lat,Depth,(Depthdata=Data,LonData=Lon))
@@ -217,7 +217,7 @@ julia> Data_Moho       =   GeoData(Lon,Lat,Depth+Lon*km, (MohoDepth=Depth,))
     fields: (:MohoDepth,)
 ```
 Next, we intersect the surface with the data set:
-```julia
+```julia-repl
 julia> Above       =   above_surface(Data_set3D, Data_Moho);
 ```
 Now, `Above` is a boolean array that is true for points above the surface and false for points below and at the surface.
@@ -337,7 +337,7 @@ end
 
 Interpolates a 3D data set `V` on a surface defined by `Surf`.
 # Example
-```julia
+```julia-repl
 julia> Data
 ParaviewData
   size  : (33, 33, 33)
@@ -403,4 +403,4 @@ function interpolate_data_surface(V::GeoData, Surf::GeoData)
     Surf_interp = interpolate_datafields(V, Surf.lon.val, Surf.lat.val, Surf.depth.val)
 
     return Surf_interp
-end
+end
diff --git a/tutorials/Tutorial_AlpineData.jl b/tutorials/Tutorial_AlpineData.jl
diff --git a/tutorials/Tutorial_Basic.jl b/tutorials/Tutorial_Basic.jl
diff --git a/tutorials/Tutorial_Chmy_MPI.jl b/tutorials/Tutorial_Chmy_MPI.jl
