Merge pull request #102 from JuliaGeodynamics/bk-rename-functions-2

Rename function names to follow Julia style

Author: boriskaus

Project.toml

@@ -1,7 +1,7 @@
 name = "GeophysicalModelGenerator"
 uuid = "3700c31b-fa53-48a6-808a-ef22d5a84742"
 authors = ["Boris Kaus", "Marcel Thielmann"]
-version = "0.6.0"
+version = "0.7.0"
 
 [deps]
 Colors = "5ae59095-9a9b-59fe-a467-6f913c188581"

README.md

@@ -33,7 +33,7 @@ Some of the key features are:
 - Create initial model setups for the 3D geodynamic code [LaMEM](https://github.com/UniMainzGeo/LaMEM).
 - Import LaMEM timesteps.
 
-All data is transformed into either a `GeoData` or a `UTMData`  structure which contains info about `longitude/latitude/depth`, `ew/ns/depth` coordinates along with an arbitrary number of scalar/vector datasets, respectively. All data can be exported to Paraview with the `write_Paraview` routine, which transfers the data to a `ParaviewData` structure (that contains Cartesian Earth-Centered-Earth-Fixed (ECEF) `x/y/z` coordinates, used for plotting)
+All data is transformed into either a `GeoData` or a `UTMData`  structure which contains info about `longitude/latitude/depth`, `ew/ns/depth` coordinates along with an arbitrary number of scalar/vector datasets, respectively. All data can be exported to Paraview with the `write_paraview` routine, which transfers the data to a `ParaviewData` structure (that contains Cartesian Earth-Centered-Earth-Fixed (ECEF) `x/y/z` coordinates, used for plotting)
 
 ## Usage
 The best way to learn how to use this is to install the package (see below) and look at the tutorials in the [manual](https://juliageodynamics.github.io/GeophysicalModelGenerator.jl/dev/).

docs/src/man/Tutorial_AlpineData.md

@@ -26,20 +26,20 @@ and load both `GMG` and `GMT` with:
 using GeophysicalModelGenerator, GMT
 ```
 
-When loading both packages, several `GMT` routines within `GMG` will be loaded. One of these routines is the function `importTopo`, where one simply has to provide the region for which to download the topographic data and the data source.
+When loading both packages, several `GMT` routines within `GMG` will be loaded. One of these routines is the function `import_topo`, where one simply has to provide the region for which to download the topographic data and the data source.
 
 ```julia
-Topo = importTopo([4,20,37,50], file="@earth_relief_01m.grd")
+Topo = import_topo([4,20,37,50], file="@earth_relief_01m.grd")
 ```
 
 The data is available in different resolutions; see [here](http://gmt.soest.hawaii.edu/doc/latest/grdimage.html) for an overview. Generally, it is advisable to not use the largest resolution if you have a large area, as the files become very large.
 
 If you have issues with loading the topography with `GMT`, there is also the alternative to download the data yourself and import it using `Rasters.jl`.
 
-We can now export this data to a `VTK` format so that we can visualize it with `Paraview`. To do so, `GMG` provides the function `write_Paraview`:
+We can now export this data to a `VTK` format so that we can visualize it with `Paraview`. To do so, `GMG` provides the function `write_paraview`:
 
 ```julia
-write_Paraview(Topo, "Topography_Alps")
+write_paraview(Topo, "Topography_Alps")
 ```
 
 Also, if you want to save this data for later use in julia, you can save it as `*.jld2` file using the function `save_GMG`:
@@ -126,10 +126,10 @@ units = unique(tag) #get different units
 We will use these units later to save the Moho data separately for each tectonic unit.
 
 ### 2.2 Converting the data to a `GMG` dataset
-To convert this data to a `GMG` dataset, we now have to interpolate it to a regular grid. You can generate the respective grid with the `GMG` function `lonlatdepthGrid`
+To convert this data to a `GMG` dataset, we now have to interpolate it to a regular grid. You can generate the respective grid with the `GMG` function `lonlatdepth_grid`
 
 ```julia
-Lon,Lat,Depth = lonlatdepthGrid(9.9:0.02:15.1,45.0:.02:49.0,0km);
+Lon,Lat,Depth = lonlatdepth_grid(9.9:0.02:15.1,45.0:.02:49.0,0km);
 nothing #hide
 ```
 
@@ -156,7 +156,7 @@ for iunit = 1:length(units)
     #for later checking, we can now save the original point data as a VTK file:
     data_Moho = GeophysicalModelGenerator.GeoData(lon_tmp,lat_tmp,depth_tmp,(MohoDepth=depth_tmp*km,))
     filename = "Mroczek_Moho_" * units[iunit]
-    write_Paraview(data_Moho, filename, PointsData=true)
+    write_paraview(data_Moho, filename, PointsData=true)
 
     #Now we create a KDTree for an effective nearest neighbor determination;
     kdtree = KDTree([lon_tmp';lat_tmp']; leafsize = 10)
@@ -187,7 +187,7 @@ for iunit = 1:length(units)
     #Finally, we can now export that data to VTK and save a `jld2` file using the `save_GMG` routine
     Data_Moho = GeophysicalModelGenerator.GeoData(Lon, Lat, Depth, (MohoDepth=Depth,PointDist=Dist),Data_attribs)
     filename = "Mrozek_Moho_Grid_" * units[iunit]
-    write_Paraview(Data_Moho, filename)
+    write_paraview(Data_Moho, filename)
     save_GMG(filename,Topo)
 
 end
@@ -218,7 +218,7 @@ nothing #hide
 As before, we can export this dataset to `VTK` and also save it as a `jld2` file (as we are now exporting point data, we have to use the option `PointsData=true`):
 
 ```julia
-write_Paraview(Data_ISC, "EQ_ISC", PointsData=true);
+write_paraview(Data_ISC, "EQ_ISC", PointsData=true);
 save_GMG("EQ_ISC",Data_ISC)
 ```
 
@@ -363,10 +363,10 @@ nothing #hide
 At this stage we have the 3D velocity components on a grid. Yet, we don't have information yet about the elevation of the stations (as the provided data set did not give this).
 We could ignore that and set the elevation to zero, which would allow saving the data directly.
 Yet, a better way is to load the topographic map of the area and interpolate the elevation to the velocity grid.
-As we have already the loaded the topographic map in section 1 of this tutorial, we can simply reuse it. To interpolate, we will use the function `interpolateDataFields2D`
+As we have already the loaded the topographic map in section 1 of this tutorial, we can simply reuse it. To interpolate, we will use the function `interpolate_datafields_2D`
 
 ```julia
-topo_v, fields_v = interpolateDataFields2D(Topo, Lon, Lat)
+topo_v, fields_v = interpolate_datafields_2D(Topo, Lon, Lat)
 ```
 
 The variable we are interested in is the variable `topo_v`. `fields_v` contains the interpolation of all the fields in `Topo` to the new grid and we only keep it here for completeness.
@@ -380,7 +380,7 @@ Data_GPS_Sanchez = GeoData(Lon,Lat,topo_v,(Velocity_mm_year=(Ve,Vn,Vz),V_north=V
 And as always, we'll save everything in `VTK` format and in `jld2` format
 
 ```julia
-write_Paraview(Data_GPS_Sanchez, "GPS_Sanchez")
+write_paraview(Data_GPS_Sanchez, "GPS_Sanchez")
 save_GMG("GPS_Sanchez",Data_GPS_Sanchez)
 ```
 
@@ -445,7 +445,7 @@ nothing #hide
 And then we save it again.
 
 ```julia
-write_Paraview(Data, "Rappisi2022")
+write_paraview(Data, "Rappisi2022")
 save_GMG("Rappisi2022",Data)
 ```
 

docs/src/man/Tutorial_Basic.md

@@ -34,7 +34,7 @@ This is a so-called `GeoData` object, which is a 3D grid of seismic velocities a
 We can save this in `VTK` format, which is a widely used format that can for exampke be read by the 3D open-source visualization tool [Paraview](https://www.paraview.org/):
 
 ```julia
-write_Paraview(Tomo_Alps_full,"Tomo_Alps_full")
+write_paraview(Tomo_Alps_full,"Tomo_Alps_full")
 ```
 
 ````
@@ -62,7 +62,7 @@ Different than the 3D tomographic model, the topography has size 1 for the last
 We can write this to disk as well
 
 ```julia
-write_Paraview(Topo_Alps,"Topo_Alps")
+write_paraview(Topo_Alps,"Topo_Alps")
 ```
 
 ````
@@ -76,12 +76,12 @@ Note that I use the `Oleron` scientific colormap for the tomography which you ca
 
 ### 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.
-It is thus advantageous to cut out a piece of the dataset that we are interested in which can be done with `extractSubvolume`:
+It is thus advantageous to cut out a piece of the dataset that we are interested in which can be done with `extract_subvolume`:
 
 ```julia
-Tomo_Alps = extractSubvolume(Tomo_Alps_full,Lon_level=(4,20),Lat_level=(36,50), Depth_level=(-600,-10))
+Tomo_Alps = extract_subvolume(Tomo_Alps_full,Lon_level=(4,20),Lat_level=(36,50), Depth_level=(-600,-10))
 
-write_Paraview(Tomo_Alps,"Tomo_Alps");
+write_paraview(Tomo_Alps,"Tomo_Alps");
 ```
 
 ````
@@ -95,10 +95,10 @@ Which looks like:
 ### 3. Create cross sections
 Paraview has the option to `Slice` through the data but it is not very intuitive to do this in 3D. Another limitation of Paraview is that it does not have native support for spherical coordinates, and therefore the data is translated to cartesian (`x`,`y`,`z`) coordinates (with the center of the Earth at `(0,0,0)`).
 That makes this a bit cumbersome to make a cross-section at a particular location.
-If you are interested in this you can use the `crossSection` function:
+If you are interested in this you can use the `cross_section` function:
 
 ```julia
-data_200km = crossSection(Tomo_Alps, Depth_level=-200)
+data_200km = cross_section(Tomo_Alps, Depth_level=-200)
 ```
 
 ````
@@ -114,7 +114,7 @@ GeoData
 As you see, this is not exactly at 200 km depth, but at the closest `z`-level in the data sets. If you want to be exactly at 200 km, use the `Interpolate` option:
 
 ```julia
-data_200km_exact = crossSection(Tomo_Alps, Depth_level=-200, Interpolate=true)
+data_200km_exact = cross_section(Tomo_Alps, Depth_level=-200, Interpolate=true)
 ```
 
 ````
@@ -129,10 +129,10 @@ GeoData
 
 In general, you can get help info for all functions with `?`:
 ```julia
-help?> crossSection
-search: crossSection crossSectionVolume crossSectionPoints crossSectionSurface flattenCrossSection
+help?> cross_section
+search: cross_section cross_section_volume cross_section_points cross_section_surface flatten_cross_section
 
-  crossSection(DataSet::AbstractGeneralGrid; dims=(100,100), Interpolate=false, Depth_level=nothing, Lat_level=nothing, Lon_level=nothing, Start=nothing, End=nothing, Depth_extent=nothing, section_width=50km)
+  cross_section(DataSet::AbstractGeneralGrid; dims=(100,100), Interpolate=false, Depth_level=nothing, Lat_level=nothing, Lon_level=nothing, Start=nothing, End=nothing, Depth_extent=nothing, section_width=50km)
 
   Creates a cross-section through a GeoData object.
 
@@ -156,11 +156,11 @@ search: crossSection crossSectionVolume crossSectionPoints crossSectionSurface f
   Example:
   ≡≡≡≡≡≡≡≡
 
-  julia> Lon,Lat,Depth   =   lonlatdepthGrid(10:20,30:40,(-300:25:0)km);
+  julia> Lon,Lat,Depth   =   lonlatdepth_grid(10:20,30:40,(-300:25:0)km);
   julia> Data            =   Depth*2;                # some data
   julia> Vx,Vy,Vz        =   ustrip(Data*3),ustrip(Data*4),ustrip(Data*5);
   julia> Data_set3D      =   GeoData(Lon,Lat,Depth,(Depthdata=Data,LonData=Lon, Velocity=(Vx,Vy,Vz)));
-  julia> Data_cross      =   crossSection(Data_set3D, Depth_level=-100km)
+  julia> Data_cross      =   cross_section(Data_set3D, Depth_level=-100km)
   GeoData
     size  : (11, 11, 1)
     lon   ϵ [ 10.0 : 20.0]
@@ -172,7 +172,7 @@ search: crossSection crossSectionVolume crossSectionPoints crossSectionSurface f
 Let's use this to make a vertical cross-section as well:
 
 ```julia
-Cross_vert = crossSection(Tomo_Alps, Start=(5,47), End=(15,44))
+Cross_vert = cross_section(Tomo_Alps, Start=(5,47), End=(15,44))
 ```
 
 ````
@@ -188,8 +188,8 @@ GeoData
 And write them to paraview:
 
 ```julia
-write_Paraview(Cross_vert,"Cross_vert");
-write_Paraview(data_200km,"data_200km");
+write_paraview(Cross_vert,"Cross_vert");
+write_paraview(data_200km,"data_200km");
 ```
 
 ````
@@ -204,10 +204,10 @@ In creating this image, I used the `Clip` tool of Paraview to only show topograp
 ### 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.
 `GeophysicalModelGenerator` has a number of tools for this.
-First we need do define a `projectionPoint`  around which we project the data
+First we need do define a `ProjectionPoint`  around which we project the data
 
 ```julia
-proj = projectionPoint(Lon=12.0,Lat =43)
+proj = ProjectionPoint(Lon=12.0,Lat =43)
 
 Topo_cart = convert2CartData(Topo_Alps, proj)
 ```
@@ -241,8 +241,8 @@ CartData
 Save:
 
 ```julia
-write_Paraview(Tomo_cart,"Tomo_cart");
-write_Paraview(Topo_cart,"Topo_cart");
+write_paraview(Tomo_cart,"Tomo_cart");
+write_paraview(Topo_cart,"Topo_cart");
 ```
 
 ````
@@ -259,13 +259,13 @@ Yet, because of the curvature of the Earth, the resulting 3D model is not strict
 This can be achieved in a relatively straightforward manner, by creating a new 3D dataset that is slightly within the curved boundaries of the projected data set:
 
 ```julia
-Tomo_rect = CartData(xyzGrid(-550.0:10:600, -500.0:10:700, -600.0:5:-17));
+Tomo_rect = CartData(xyz_grid(-550.0:10:600, -500.0:10:700, -600.0:5:-17));
 ```
 
-the routine `projectCartData` will then project the data from the geographic coordinates to the new rectilinear grid:
+the routine `project_CartData` will then project the data from the geographic coordinates to the new rectilinear grid:
 
 ```julia
-Tomo_rect = projectCartData(Tomo_rect, Tomo_Alps, proj)
+Tomo_rect = project_CartData(Tomo_rect, Tomo_Alps, proj)
 ```
 
 ````
@@ -281,8 +281,8 @@ CartData
 we can do the same with topography:
 
 ```julia
-Topo_rect = CartData(xyzGrid(-550.0:1:600, -500.0:1:700, 0))
-Topo_rect = projectCartData(Topo_rect, Topo_Alps, proj)
+Topo_rect = CartData(xyz_grid(-550.0:1:600, -500.0:1:700, 0))
+Topo_rect = project_CartData(Topo_rect, Topo_Alps, proj)
 ```
 
 ````
@@ -298,8 +298,8 @@ CartData
 Save it:
 
 ```julia
-write_Paraview(Tomo_rect,"Tomo_rect");
-write_Paraview(Topo_rect,"Topo_rect");
+write_paraview(Tomo_rect,"Tomo_rect");
+write_paraview(Topo_rect,"Topo_rect");
 ```
 
 ````

docs/src/man/Tutorial_FaultDensity.md

@@ -76,18 +76,18 @@ data   = faults.data[indlon,indlat]
 Create GeoData from restricted data
 
 ```julia
-Lon3D,Lat3D, Faults = lonlatdepthGrid(Lon,Lat,0);
+Lon3D,Lat3D, Faults = lonlatdepth_grid(Lon,Lat,0);
 Faults[:,:,1]       = data
 Data_Faults         = GeoData(Lon3D,Lat3D,Faults,(Faults=Faults,))
 ```
 
 ## 2. Create Density Map
-Create a density map of the fault data. This is done with the `countMap` function. This function takes a specified field of a 2D `GeoData` struct and counts the entries in all control areas which are defined by steplon (number of control areas in lon direction) and steplat (number of control areas in lat direction). The field should only consist of 0.0 and 1.0 and the steplength. The final result is normalized by the highest count.
+Create a density map of the fault data. This is done with the `countmap` function. This function takes a specified field of a 2D `GeoData` struct and counts the entries in all control areas which are defined by steplon (number of control areas in lon direction) and steplat (number of control areas in lat direction). The field should only consist of 0.0 and 1.0 and the steplength. The final result is normalized by the highest count.
 
 ```julia
 steplon  = 188
 steplat  = 104
-cntmap   = countMap(Data_Faults,"Faults",steplon,steplat)
+cntmap   = countmap(Data_Faults,"Faults",steplon,steplat)
 ```
 
 Plot the density map with coastlines
@@ -103,7 +103,7 @@ Plot this using `Plots.jl`:
 
 ```julia
 heatmap(lon,lat,coastlinesEurope',colormap=cgrad(:gray1,rev=true),alpha=1.0);
-heatmap!(lon,lat,cntmap.fields.countMap[:,:,1]',colormap=cgrad(:batlowW,rev=true),alpha = 0.8,legend=true,title="Fault Density Map Europe",ylabel="Lat",xlabel="Lon")
+heatmap!(lon,lat,cntmap.fields.countmap[:,:,1]',colormap=cgrad(:batlowW,rev=true),alpha = 0.8,legend=true,title="Fault Density Map Europe",ylabel="Lat",xlabel="Lon")
 ```
 
 ![tutorial_Fault_Map](../assets/img/FaultDensity.png)