OpenMindat

https://quexiang.github.io/OpenMindat/
Admin
An R package for querying and accessing open data from the Mindat API, allowing users to retrieve...
Tokens:59,892
Snippets:530
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example: Get Icosahedral Crystal Classes

Source: https://quexiang.github.io/OpenMindat/reference/crystalclasses_systems.html

This example demonstrates how to retrieve crystal classes belonging to the 'Icosahedral' system. The \dontrun{} block indicates that this code is not run by default during package checks.

```r
if (FALSE) { # \dontrun{

df <-geomaterials_crystal_system(c("Icosahedral"))
} # }
```

--------------------------------

### Mindat Connection and Setup

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Functions for establishing a connection to the Mindat API and performing initial setup.

```APIDOC
## mindat_connection()

### Description
Initializing Mindat API connection.

### Method
POST (assumed)

### Endpoint
/mindat/connect

```

```APIDOC
## mindat_setup()

### Description
Perform Mindat API setup.

### Method
POST (assumed)

### Endpoint
/mindat/setup

```

--------------------------------

### Install OpenMindat from GitHub using devtools

Source: https://quexiang.github.io/OpenMindat/index.html

Install the OpenMindat package from GitHub using the devtools package. Ensure devtools is installed first.

```r
install.packages("devtools")
library("devtools")
install_github("quexiang/OpenMindat")
```

--------------------------------

### Install OpenMindat from GitHub using remotes

Source: https://quexiang.github.io/OpenMindat/index.html

Install the OpenMindat package directly from GitHub using the remotes package. Ensure remotes is installed first.

```r
install.packages("remotes")
remotes::install_github("quexiang/OpenMindat")
```

--------------------------------

### R Example: Get Geomaterials within Density Range (2-3)

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_dens_range.html

Demonstrates how to use the `geomaterials_dens_range` function to retrieve geomaterials with densities between 2 and 3. This example is wrapped in `if (FALSE)` to prevent execution during package checks.

```R
if (FALSE) { # \dontrun{
df <-geomaterials_dens_range(2,3)
} # }
```

--------------------------------

### R Example: Get Geomaterials with Birefringence Greater Than 0.2

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_bi_greater_than.html

This R code example demonstrates how to use the `geomaterials_bi_greater_than` function to retrieve a data frame of geomaterials whose minimum birefringence is greater than 0.2. The example is wrapped in `if (FALSE)` to prevent execution during standard R checks.

```R
if (FALSE) { # \dontrun{
df <-geomaterials_bi_greater_than(0.2)
} # }
```

--------------------------------

### Default Mindat Setup

Source: https://quexiang.github.io/OpenMindat/reference/mindat_setup.html

Initializes the Mindat API connection using default settings for base URI and page size. This is a basic setup for accessing Mindat data.

```r
mindat_setup()
```

--------------------------------

### Retrieve Dana8 Subgroups

Source: https://quexiang.github.io/OpenMindat/reference/mindat_dana8_subgroups.html

This example shows how to call the mindat_dana8_subgroups function to get a data frame of subgroups. It is a non-runnable example by default.

```r
if (FALSE) { # \dontrun{
 df<- mindat_dana8_subgroups()
} # }
```

--------------------------------

### Example Usage of Locentries_stat_retrieve

Source: https://quexiang.github.io/OpenMindat/reference/Locentries_stat_retrieve.html

Demonstrates how to call the Locentries_stat_retrieve function with a specific ID. This example is non-runnable by default.

```R
if (FALSE) { # \dontrun{

df <-Locentries_stat_retrieve(2)
} # }
```

--------------------------------

### Example Usage of geomaterials_updated_at

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_updated_at.html

Demonstrates how to call the geomaterials_updated_at function with a specific datetime string to retrieve updated geomaterials. This example is non-runnable by default.

```r
if (FALSE) { # \dontrun{
df <-geomaterials_updated_at("2020-2-12 10:15:12")
} # }
```

--------------------------------

### Example Usage of geomaterials_optical2v_max

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_optical2v_max.html

This example demonstrates how to call the `geomaterials_optical2v_max` function with a threshold value of 0.2 to retrieve a data frame of geomaterials. The code is designed to be run in an R environment.

```R
if (FALSE) { # \dontrun{

df <-geomaterials_optical2v_max(0.2)
} # }
```

--------------------------------

### Example: Querying Geomaterials by Cleavage Type

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_cleavagetype.html

Demonstrates how to use `geomaterials_cleavagetype` to find geomaterials with 'Poor/Indistinct' cleavage. This example is wrapped in `
if (FALSE) { # \dontrun{ ... } # }` to prevent execution during package checks.

```R
if (FALSE) { # \dontrun{
  df <-geomaterials_cleavagetype(c("Poor/Indistinct"))
} # }
```

--------------------------------

### Example Usage of geomaterials_varietyof

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_varietyof.html

This example demonstrates how to call the geomaterials_varietyof function with a specific mineral ID (3337) and store the result in a data frame. The example is wrapped in a \dontrun{} block, indicating it should not be run automatically.

```R
if (FALSE) { # \dontrun{
df <-geomaterials_varietyof(3337)
} # }
```

--------------------------------

### Example Usage of localities_list_updated_at

Source: https://quexiang.github.io/OpenMindat/reference/localities_list_updated_at.html

Demonstrates how to call the localities_list_updated_at function with a sample update date. This example is wrapped in a dontrun block as it requires an active connection or specific data.

```R
if (FALSE) { # \dontrun{

df <-localities_list_updated_at("lava")
} # }
```

--------------------------------

### Fetch All Localities with Specific Fields

Source: https://quexiang.github.io/OpenMindat/reference/localities_list_all.html

This example demonstrates how to retrieve a list of all localities, specifying the desired fields such as id, name, latitude, and longitude. The query is wrapped in a \`dontrun\` block, indicating it's a runnable example that should not be executed automatically during package checks.

```r
if (FALSE) { # \dontrun{

df <-localities_list_all(fields = "id,name,latitude,longitude")
} # }
```

--------------------------------

### R Example: Querying for 'volcano' localities

Source: https://quexiang.github.io/OpenMindat/reference/localities_list_description.html

Demonstrates how to call the localities_list_description function to retrieve localities containing the description 'volcano'. This example is non-runnable by default.

```R
if (FALSE) { # \dontrun{
df <-localities_list_description("volcano")
} # }
```

--------------------------------

### R Example: Retrieve Approved Geomaterials

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_ima_status.html

Demonstrates how to call the `geomaterials_ima_status` function to fetch geomaterials with an 'APPROVED' IMA status. This example is non-runnable by default.

```r
if (FALSE) { # \dontrun{
df <-geomaterials_ima_status(c("APPROVED"))
} # }
```

--------------------------------

### Example Usage of geomaterials_ima

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_ima.html

Demonstrates how to call the geomaterials_ima function to retrieve a data frame of IMA-approved geomaterials. This example is wrapped in a conditional block to prevent execution during package checks.

```R
if (FALSE) { # \dontrun{
  df <-geomaterials_ima(TRUE)
} # }
```

--------------------------------

### Retrieve Nickel-Strunz 10th Edition Subclasses

Source: https://quexiang.github.io/OpenMindat/reference/mindat_nickel_strunz10_subclasses.html

Call the function to get a data frame of Nickel-Strunz 10th edition subclasses. This example is for demonstration and will not run by default.

```r
if (FALSE) { # \dontrun{
 df<- mindat_nickel_strunz10_subclasses()
} # }
```

--------------------------------

### Example Usage of geomaterials_bi_less_than in R

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_bi_less_than.html

Demonstrates how to call the `geomaterials_bi_less_than` function to retrieve geomaterials with a maximum birefringence of 0.3. This example is wrapped in `if (FALSE)` to prevent execution during package checks.

```R
if (FALSE) { # \dontrun{
df <-geomaterials_bi_less_than(0.3)
} # }
```

--------------------------------

### Example Usage of geomaterials_meteoritical_code Function

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_meteoritical_code.html

This R code demonstrates how to call the geomaterials_meteoritical_code function. It shows an example of retrieving geomaterials where the meteoritical code exists (TRUE). This example is non-executable and intended for illustration.

```R
if (FALSE) { # \dontrun{
    df <-geomaterials_meteoritical_code(TRUE)
} # }
```

--------------------------------

### R Example Usage

Source: https://quexiang.github.io/OpenMindat/reference/minerals_ima_updated_at.html

Demonstrates how to call the minerals_ima_updated_at function with a specific update date.

```R
if (FALSE) { # \dontrun{
df <-minerals_ima_updated_at("2020-11-10 10:12:20")
} # }
```

--------------------------------

### Example Usage of geomaterials_bi_range in R

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_bi_range.html

Demonstrates how to use the `geomaterials_bi_range` function to fetch geomaterials with a birefringence between 0.2 and 0.3. This example is wrapped in `if (FALSE)` to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
df <-geomaterials_bi_range(0.2,0.3)
} # }
```

--------------------------------

### Check and Setup Cached Function

Source: https://quexiang.github.io/OpenMindat/reference/mindat_cache_return_or_setup.html

This snippet demonstrates how to use mindat_cache_return_or_setup to retrieve an existing cached function or set up a new one if it doesn't exist. It's particularly useful for caching API endpoints.

```r
aep<-  api_end_points<-mindat_cache_return_or_setup('api_end_points', function(){return (list()) })
```

--------------------------------

### Get Geomaterials by Expand

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the specified expand criteria.

```python
geomaterials_expand()
```

--------------------------------

### Retrieve IMA Minerals List

Source: https://quexiang.github.io/OpenMindat/reference/minerals_ima_list.html

Call the minerals_ima_list function to get a data frame of IMA minerals. This example is wrapped in a \"dontrun\" block and requires execution within a specific environment.

```r
if (FALSE) { # \dontrun{

df <-minerals_ima_list()
} # }
```

--------------------------------

### Retrieve Mindat Localities List

Source: https://quexiang.github.io/OpenMindat/reference/mindat_localities_list.html

Call the mindat_localities_list function to get a data frame of localities. This example is for demonstration and requires execution within a specific environment.

```r
if (FALSE) { # \dontrun{
 df<- mindat_localities_list()
} # }
```

--------------------------------

### Retrieve Nickel-Strunz 10th Edition Classes

Source: https://quexiang.github.io/OpenMindat/reference/mindat_nickel_strunz10_classes.html

Call the `mindat_nickel_strunz10_classes` function to get a data frame of Nickel-Strunz 10th edition classifications. This example is intended for non-interactive use.

```r
if (FALSE) { # \dontrun{
 df<- mindat_nickel_strunz10_classes()
} # }
```

--------------------------------

### Parse Mindat Raw Data into R Data Frame

Source: https://quexiang.github.io/OpenMindat/reference/mindat_parse_raw_data.html

This example demonstrates how to use the `mindat_parse_raw_data` function. It takes a raw JSON string as input and returns an R data frame. The example includes a sample JSON string with paginated results.

```R
if (FALSE) { # \dontrun{
rd<-"{\"count\":5,\"next\":null,\"previous\":null,+
\"results\":[{\"name\":\"Diamond\"},{\"name\":\"Khamrabaevite\"}+ 
,    {\"name\":\"Moissanite\"},{\"name\":\"Qingsongite\"},{\"name\":\"Uakitite\"}]}"
df<- mindat_parse_raw_data(rd)
} # } 

```

--------------------------------

### Retrieve IMA Mineral List

Source: https://quexiang.github.io/OpenMindat/reference/mindat_mineral_ima_list.html

Call the mindat_mineral_ima_list function to get a data frame containing the list of IMA-recognized minerals. This example is for demonstration and will not run by default.

```r
if (FALSE) { # \dontrun{
 df<- mindat_mineral_ima_list()
} # }
```

--------------------------------

### Retrieve Locality Status List

Source: https://quexiang.github.io/OpenMindat/reference/mindat_locality_status_list.html

Call the `mindat_locality_status_list` function to get a data frame of all locality statuses. This example is wrapped in `if (FALSE)` to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
 df<- mindat_locality_status_list()
} # }
```

--------------------------------

### Retrieve All Countries

Source: https://quexiang.github.io/OpenMindat/reference/mindat_countries.html

Call the mindat_countries function without arguments to get a data frame of all available countries. This example is wrapped in a \dontrun{} block and requires the `if (FALSE)` condition to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
 df<- mindat_countries()
} # }
```

--------------------------------

### R Example: Find Geomaterials with Iron or Sulfur, Excluding Oxygen

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_contain_any_but_not_elems.html

Demonstrates how to use the `geomaterials_contain_any_but_not_elems` function to find geomaterials that contain either Iron (Fe) or Sulfur (S), but do not contain Oxygen (O). This example is wrapped in `if (FALSE)` to prevent execution during standard R checks.

```R
if (FALSE) { # \dontrun{

df <-geomaterials_contain_any_but_not_elems(c('Fe','S'), c('O'))
} # }
```

--------------------------------

### Retrieve space group sets by crystal class ID

Source: https://quexiang.github.io/OpenMindat/reference/spacegroupsets_cclass.html

This example demonstrates how to use the spacegroupsets_cclass function to fetch space group sets matching a crystal class ID. The function returns a data frame of matching space groups. This is a non-runnable example.

```R
if (FALSE) { # \dontrun{

df <-spacegroupsets_cclass(2)
} # }
```

--------------------------------

### Filter Geomaterials by Elements

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_contain_only_elems.html

Retrieves a data frame of geomaterials that contain only the specified elements. Ensure the 'mindat' package is installed and loaded. The example demonstrates filtering for geomaterials containing only 'Fe' and 'S', requesting specific fields.

```r
if (FALSE) { # \dontrun{
 df <-geomaterials_contain_only_elems(c('Fe','S'),fields ="id,name,mindat_formula,elements")
} # }
```

--------------------------------

### R Example: Fetching Geomaterials with Non-UTF Names

Source: https://quexiang.github.io/OpenMindat/reference/geomeaterials_non_utf.html

Example of how to call the geomeaterials_non_utf function in R to retrieve geomaterial data, specifying fields to include non-UTF mineral names.

```R
if (FALSE) { # \dontrun{
df <-geomeaterials_non_utf(TRUE,fields = "id,name,non_utf")
} # }
```

--------------------------------

### List Localities with Included and Excluded Elements

Source: https://quexiang.github.io/OpenMindat/reference/localities_list_elems_inc_exc.html

This example demonstrates how to use the `localities_list_elems_inc_exc` function to find localities containing 'Dy' but not 'Li'. The `if (FALSE)` block indicates this is a non-runnable example, typically used for documentation.

```R
if (FALSE) { # \dontrun{

df <-localities_list_elems_inc_exc(c("Dy"), c("Li"))
} # }
```

--------------------------------

### Get Geomaterials by Entry Type

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the specified entry type.

```python
geomaterials_entrytype()
```

--------------------------------

### Get Geomaterials by Lustre Type

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the specified lustre type.

```python
geomaterials_lustretype()
```

--------------------------------

### Get Geomaterials by Optical Type

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the specified optical type.

```python
geomaterials_opticaltype()
```

--------------------------------

### Get Geomaterials by Color

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that possess the specified colors.

```python
geomaterials_colour()
```

--------------------------------

### Get Geomaterials by Crystal System

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that belong to the specified crystal system.

```python
geomaterials_crystal_system()
```

--------------------------------

### Get Geomaterials by Optical 2V Minimum

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials with an optical 2V value higher than the specified minimum.

```python
geomaterials_optical2v_min()
```

--------------------------------

### Convert Parameters to String for Mindat Query

Source: https://quexiang.github.io/OpenMindat/reference/params_to_string.html

This example demonstrates how to use the params_to_string function. It's intended for use within a conditional block that prevents execution during standard package checks.

```r
if (FALSE) { # \dontrun{
params_to_string("")
} # }
```

--------------------------------

### Get Geomaterials by Optical Sign

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the specified optical signs.

```python
geomaterials_opticalsign()
```

--------------------------------

### Get Geomaterials by Name

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match a given string in their name.

```python
geomaterials_name()
```

--------------------------------

### Query Mindat Data

Source: https://quexiang.github.io/OpenMindat/reference/mindat_query.html

Demonstrates how to query a list of geomaterials with a minimum hardness of 9 using the mindat_query function. This example is non-runnable by default.

```R
if (FALSE) { # \dontrun{

df <-mindat_query("geomaterials_list",list(ids="",hardness_min=9))
} # }
```

--------------------------------

### Search for Geomaterials by Name

Source: https://quexiang.github.io/OpenMindat/reference/mindat_geomaterial_search.html

This example demonstrates how to search for geomaterials by name using the `mindat_geomaterial_search` function. It retrieves a data frame of matching geomaterials.

```r
df <- mindat_geomaterial_search(q="Quartz")
```

--------------------------------

### Get Geomaterials by IMA Approval

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that are approved by the IMA (International Mineralogical Association) or not.

```python
geomaterials_ima()
```

--------------------------------

### Retrieve Geomaterial Varieties by ID

Source: https://quexiang.github.io/OpenMindat/reference/mindat_geomaterial_varieties.html

Demonstrates how to use the `mindat_geomaterial_varieties` function to retrieve geomaterial varieties. This example requires the `id` argument.

```r
if (FALSE) { # \dontrun{
 df<- mindat_geomaterial_varieties(3337)
} # }
```

--------------------------------

### Get Geomaterials by Optical 2V Maximum

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials with an optical 2V value less than the specified maximum.

```python
geomaterials_optical2v_max()
```

--------------------------------

### Get Geomaterials by Refractive Index Less Than

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials with a refractive index lower than the specified value.

```python
geomaterials_ri_lt()
```

--------------------------------

### mindat_setup

Source: https://quexiang.github.io/OpenMindat/reference/mindat_setup.html

Sets up the base URI and page size for Mindat API requests. This function initializes the connection parameters for subsequent API calls.

```APIDOC
## Function: mindat_setup

### Description
Sets up the base URI and page size for Mindat API requests. This function initializes the connection parameters for subsequent API calls.

### Usage
```
mindat_setup(base_uri = 'https://api.mindat.org/v1', page_size = 800)
```

### Arguments

* **base_uri** (string) - The base URI of the Mindat API. Defaults to 'https://api.mindat.org/v1'.
* **page_size** (integer) - Sets the page size for the data returned from the API server. Defaults to 800.

### Examples
```R
# Example of setting up Mindat API connection
if (FALSE) { # \dontrun{
mindat_setup()
}
}
```
```

--------------------------------

### Get Geomaterials by Diaphaneity

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the specified diaphaneity.

```python
geomaterials_diapheny()
```

--------------------------------

### Get Geomaterials by Density Less Than

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose density is lower than the specified value.

```python
geomaterials_dens_less_than()
```

--------------------------------

### Retrieve and Map Localities by IMA Status

Source: https://quexiang.github.io/OpenMindat/articles/Mindat_data.html

This example retrieves localities associated with IMA-approved minerals, processes them, and then maps them. It involves iterating through mineral types, retrieving locality data by ID, and converting coordinates to numeric types before mapping.

```r
#df_elements<-minerals_ima_list_ima(1)$type_localities
#df_out <- data.frame()
#for (elements in df_elements) {
#  elm_id_list <- as.list(elements)
#  for (elm in elm_id_list){
#    df_cur_locality <- localities_retrieve_id(elm)
#    df_out <- rbind(df_out,df_cur_locality)
#  }
#}
#df_out$longitude <- as.numeric(df_out$longitude)
#df_out$latitude <- as.numeric(df_out$latitude)
#mapview(df_out2, xcol = "longitude", ycol = "latitude", crs = 4269, grid = FALSE)
```

--------------------------------

### Get Geomaterials by Hardness Less Than

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose hardness is lower than the specified value.

```python
geomaterials_hardness_lt()
```

--------------------------------

### Get Geomaterials by Optical 2V Range

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose optical 2V values fall within the specified range.

```python
geomaterials_optical2v_range()
```

--------------------------------

### Initialize Mindat API Connection

Source: https://quexiang.github.io/OpenMindat/articles/OpenMindat.html

Set up the API connection with an authentication token. The page_size can be adjusted from 0 to 1500, with a default of 800.

```R
test_base_token = "9ce67655d74bcd981e937be80dcea9cb"
#mindat_connection(test_base_token,page_size = 1500)
```

--------------------------------

### Get Geomaterials by Birefringence Less Than

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose birefringence is lower than the specified value.

```python
geomaterials_bi_less_than()
```

--------------------------------

### Get Geomaterials by Meteoritical Code

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match a given string in their meteoritical code.

```python
geomaterials_meteoritical_code()
```

--------------------------------

### Get Geomaterials by IMA Notes

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the given notes related to IMA status.

```python
geomaterials_ima_notes()
```

--------------------------------

### Get Geomaterials by Fracture Type

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the specified fracture type.

```python
geomaterials_fracturetype()
```

--------------------------------

### Get Geomaterials by Cleavage Type

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match a specified cleavage type.

```python
geomaterials_cleavagetype()
```

--------------------------------

### Display Package Documentation

Source: https://quexiang.github.io/OpenMindat/index.html

Access the help documentation for the OpenMindat package directly within the R environment.

```r
help(package = OpenMindat)
```

--------------------------------

### Retrieve Country by ID

Source: https://quexiang.github.io/OpenMindat/reference/mindat_country.html

Demonstrates how to retrieve country data using the mindat_country function with a specific ID. This example is intended for non-interactive use and requires the 'id' argument.

```R
if (FALSE) { # \dontrun{
 df<- mindat_country(1)
} # }
```

--------------------------------

### Get Geomaterials Containing All Elements

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that contain all of the specified elements.

```python
geomaterials_contain_all_elems()
```

--------------------------------

### Get Geomaterials by IMA Status

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that match the given IMA status.

```python
geomaterials_ima_status()
```

--------------------------------

### Retrieve Nickel-Strunz 10 Families

Source: https://quexiang.github.io/OpenMindat/reference/Nickel_strunz10_families.html

Call the Nickel_strunz10_families function to get a data frame of Nickel-Strunz 10th edition classification families. This is a basic usage example.

```r
if (FALSE) { # \dontrun{

df <-Nickel_strunz10_families()
} # }
```

--------------------------------

### Retrieve Locality Age List

Source: https://quexiang.github.io/OpenMindat/reference/locality_age_list.html

Use this function to retrieve all locality age data. The example is wrapped in a conditional to prevent execution during package checks.

```R
if (FALSE) { # \dontrun{

df <-locality_age_list()
} # }
```

--------------------------------

### Get Nickel-Strunz 10 Families

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves mineral families based on the Nickel-Strunz 10 classification system.

```python
Nickel_strunz10_families()
```

--------------------------------

### File Extension Function

Source: https://quexiang.github.io/OpenMindat/reference/index.html

A utility function to get the file extension from a filename.

```APIDOC
## getExtension()

### Description
Output the file extension of a filename.

### Method
GET (assumed)

### Endpoint
/file/extension

### Parameters
#### Query Parameters
- **filename** (string) - Required - The name of the file.
```

--------------------------------

### Get Geomaterials by Density Range

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose density falls within a specified range.

```python
geomaterials_dens_range()
```

--------------------------------

### Get Geomaterials by Refractive Index Greater Than

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials with a refractive index higher than the specified value.

```python
geomaterials_ri_gt()
```

--------------------------------

### List Localities by Elements

Source: https://quexiang.github.io/OpenMindat/reference/localities_list_elems_inc.html

Use this function to find localities containing specific elements. Ensure the elements are provided as a character vector. The example is wrapped in `if (FALSE)` to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
df <-localities_list_elems_inc(c("Dy"))
} # }
```

--------------------------------

### Get Geomaterials by Density Greater Than

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose density is higher than the specified value.

```python
geomaterials_dens_greater_than()
```

--------------------------------

### Get Geomaterials by Hardness Greater Than

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose hardness is higher than the specified value.

```python
geomaterials_hardness_gt()
```

--------------------------------

### Get Geomaterials by Hardness Range

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose hardness falls within the specified range.

```python
geomaterials_hardness_range()
```

--------------------------------

### Retrieve Locality Age by ID

Source: https://quexiang.github.io/OpenMindat/reference/locality_age.html

This R code snippet demonstrates how to retrieve locality age data from Mindat using the locality_age function. It requires the 'id' argument, which specifies the locality age ID. The example is wrapped in a \dontrun{} block, indicating it's a runnable example that should not be executed automatically during package checks.

```R
if (FALSE) { # \dontrun{
df <-locality_age(3337)
} # }
```

--------------------------------

### Get Geomaterials by Birefringence Greater Than

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose birefringence is higher than the specified value.

```python
geomaterials_bi_greater_than()
```

--------------------------------

### Retrieve Locality Type List

Source: https://quexiang.github.io/OpenMindat/reference/mindat_locality_type_list.html

Call the mindat_locality_type_list function to get a data frame containing all locality types. This example is for demonstration and requires execution within a specific environment.

```r
if (FALSE) { # \dontrun{
 df<- mindat_locality_type_list()
} # }
```

--------------------------------

### Mindat Data Handling Utilities

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Utility functions for extracting response bodies, getting data from URIs, and parsing raw data.

```APIDOC
## mindat_extract_response_body()

### Description
Extract the response body from a Mindat API request.

### Method
POST (assumed)

### Endpoint
/mindat/utils/extract_response

### Parameters
#### Request Body
- **response** (object) - Required - The API response object.
```

```APIDOC
## mindat_get_data_from_uri()

### Description
Retrieve data from a given URI.

### Method
GET (assumed)

### Endpoint
/mindat/utils/get_data_from_uri

### Parameters
#### Query Parameters
- **uri** (string) - Required - The URI to fetch data from.
```

```APIDOC
## mindat_parse_raw_data()

### Description
Parse raw data retrieved from the Mindat API.

### Method
POST (assumed)

### Endpoint
/mindat/utils/parse_raw_data

### Parameters
#### Request Body
- **raw_data** (string) - Required - The raw data string to parse.
```

--------------------------------

### Get Nickel-Strunz 10 Subclasses

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves mineral subclasses based on the Nickel-Strunz 10 classification system.

```python
Nickel_strunz10_subclasses()
```

--------------------------------

### Get File Extension

Source: https://quexiang.github.io/OpenMindat/reference/getExtension.html

Extracts the file extension from a filename. Assigns the result to a variable.

```r
filename<- "fname.txt"
fname_extension<- getExtension(filename)
```

--------------------------------

### Get Nickel-Strunz 10 Classes

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves mineral classes based on the Nickel-Strunz 10 classification system.

```python
Nickel_strunz10_classes()
```

--------------------------------

### Get Geomaterials by Birefringence Range

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials whose birefringence falls within a specified range.

```python
geomaterials_bi_range()
```

--------------------------------

### Retrieve all expanded mineral IMA list

Source: https://quexiang.github.io/OpenMindat/reference/minerals_ima_list_expand.html

Fetches a data frame of all IMA minerals with all fields expanded. This is a basic usage example.

```r
if (FALSE) { # \dontrun{
df <-minerals_ima_list_expand("~all")
} # }
```

--------------------------------

### Get Geomaterials by Field Existence

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials records based on whether a given field is empty or not.

```python
geomaterials_field_exists()
```

--------------------------------

### Retrieve Nickel-Strunz 10th Edition Classifications

Source: https://quexiang.github.io/OpenMindat/reference/Nickel_strunz10_classes.html

Call the Nickel_strunz10_classes function to get a data frame of Nickel-Strunz 10th edition classifications. This example is part of a don't run block and requires execution within a specific environment.

```R
if (FALSE) { # \dontrun{

df <-Nickel_strunz10_classes()
} # }
```

--------------------------------

### Connect to Mindat Server

Source: https://quexiang.github.io/OpenMindat/index.html

Establishes a connection to the Mindat server. Specify the base_url if using a non-default server.

```r
mindat_connection("YourToken",base_url = "147.135.28.115")
```

--------------------------------

### Retrieve all crystal classes

Source: https://quexiang.github.io/OpenMindat/reference/mindat_crystalclass_list.html

Call the mindat_crystalclass_list function without any arguments to retrieve a data frame containing all crystal classes. This example is wrapped in a dontrun block as it may take time to execute.

```r
if (FALSE) { # \dontrun{
 df<- mindat_crystalclass_list()
} # }
```

--------------------------------

### Set up Mindat API Base URI and Page Size

Source: https://quexiang.github.io/OpenMindat/reference/mindat_setup.html

Configures the base URI for the Mindat API and sets the page size for API responses. Use this function to initialize your connection to the Mindat API.

```r
mindat_setup(base_uri = 'https://api.mindat.org/v1',page_size = 800)
```

--------------------------------

### mindat_cache_return_or_setup

Source: https://quexiang.github.io/OpenMindat/reference/mindat_cache_return_or_setup.html

Checks if the current environment has a cached function named 'varname'. If it exists, it returns the cached function. Otherwise, it sets up a new cache function named 'varname'.

```APIDOC
## mindat_cache_return_or_setup

### Description
Checks whether the current environment has the cached function named varname. If it has, return it. If not, set up a new cache function named varname.

### Usage
```
mindat_cache_return_or_setup(varname, setupfun)
```

### Arguments

* **varname** (string): The name of the cached function to check or set up.
* **setupfun** (boolean): Indicates if the cache is a setup function.

### Value
Returns the cached function if 'varname' is found in the current environment's cache. Otherwise, it evaluates the function and returns the cached function.

### Examples
```R
aep <- mindat_cache_return_or_setup('api_end_points', function(){return (list()) })
```
```

--------------------------------

### Get Geomaterials Containing Any But Not Elements

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that contain any of the specified elements but none of the excluded elements.

```python
geomaterials_contain_any_but_not_elems()
```

--------------------------------

### Extracting Mindat API Response Body

Source: https://quexiang.github.io/OpenMindat/reference/mindat_extract_response_body.html

Demonstrates how to use the `mindat_extract_response_body` function to retrieve data from a Mindat API request. This example fetches geological materials with a minimum hardness of 9.3 and extracts the response body.

```R
if (FALSE) { # \dontrun{
library(httr)
uri<- "https://api.mindat.org/v1/geomaterials/?id_in=&hardness_min=9.3&fields=name,+
hardness&page_size=1500"
api_token<- "9ce67655d74bcd981e937be80dcea9cb"
response <- GET(uri,add_headers('Authorization'= paste('Token ',api_token,sep = "")))
raw_data <- mindat_extract_response_body(response)
} # } 
```

--------------------------------

### Set Up Mindat API Connection

Source: https://quexiang.github.io/OpenMindat/index.html

Establish a connection to the Mindat API by providing your unique API token. This function must be called before using other functions that interact with the Mindat API.

```r
#input your Mindat API token
mindat_connection("YourToken") #including the quotation marks
```

--------------------------------

### Get Geomaterials Containing All But Not Elements

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that contain all specified elements but none of the excluded elements.

```python
geomaterials_contain_all_but_not_elems()
```

--------------------------------

### Mindat Cache Management

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Functions for managing the Mindat API cache, including setting, getting, deleting, and checking for cached values.

```APIDOC
## mindat_cache_delete()

### Description
Delete a cached value by the user's input variable name.

### Method
DELETE (assumed)

### Endpoint
/mindat/cache/{varname}

### Parameters
#### Path Parameters
- **varname** (string) - Required - The name of the cached variable to delete.
```

```APIDOC
## mindat_cache_empty()

### Description
Remove all cached values.

### Method
DELETE (assumed)

### Endpoint
/mindat/cache

```

```APIDOC
## mindat_cache_get()

### Description
Get a cached value.

### Method
GET (assumed)

### Endpoint
/mindat/cache/{varname}

### Parameters
#### Path Parameters
- **varname** (string) - Required - The name of the cached variable to retrieve.
```

```APIDOC
## mindat_cache_has()

### Description
Check if the current environment has the cached value of a variable name.

### Method
GET (assumed)

### Endpoint
/mindat/cache/has/{varname}

### Parameters
#### Path Parameters
- **varname** (string) - Required - The name of the cached variable to check.
```

```APIDOC
## mindat_cache_return_or_setup()

### Description
Check if the current environment has the cached function named varname, and return it or set it up.

### Method
GET (assumed)

### Endpoint
/mindat/cache/return_or_setup/{varname}

### Parameters
#### Path Parameters
- **varname** (string) - Required - The name of the cached function.
```

```APIDOC
## mindat_cache_set()

### Description
Set a cache name and value.

### Method
POST (assumed)

### Endpoint
/mindat/cache

### Parameters
#### Request Body
- **varname** (string) - Required - The name for the cache.
- **value** (any) - Required - The value to cache.
```

--------------------------------

### Retrieve Mindat Locality Entries Statistics

Source: https://quexiang.github.io/OpenMindat/reference/mindat_locentries_stat.html

Calls the mindat_locentries_stat function to fetch locality-geomaterial pairs and statistics from Mindat. This example is non-executable and requires a specific environment.

```r
if (FALSE) { # \dontrun{
 df<- mindat_locentries_stat()
} # }
```

--------------------------------

### Connect to Mindat API

Source: https://quexiang.github.io/OpenMindat/articles/Mindat_data.html

Establish a connection to the Mindat API using your personal API key and set the page size for data retrieval.

```r
#mindat_connection("3214e7170011236535c9a6e17d4ebd69", page_size = 1500)
```

--------------------------------

### Retrieve IMA Mineral by ID

Source: https://quexiang.github.io/OpenMindat/reference/mindat_mineral_ima.html

Use this function to fetch IMA mineral data by its Mindat ID. The function returns results as a data frame. This example is for demonstration and will not run by default.

```R
if (FALSE) { # \dontrun{
 df<- mindat_mineral_ima(3337)
} # }
```

--------------------------------

### Query Spacegroups by ID in R

Source: https://quexiang.github.io/OpenMindat/reference/spacegroups_by_id.html

Retrieves a data frame of spacegroups matching a specific integer ID. Ensure the 'mindat' package is installed and loaded.

```r
if (FALSE) { # \dontrun{
 df <-spacegroups_by_id(2)
} # }
```

--------------------------------

### Retrieve Nickel-Strunz 10th Edition Families

Source: https://quexiang.github.io/OpenMindat/reference/mindat_nickel_strunz10_families.html

Use this snippet to fetch the list of Nickel-Strunz 10th edition classification families. The function returns a data frame. This example is conditional and will not run by default.

```r
if (FALSE) { # \dontrun{
 df<- mindat_nickel_strunz10_families()
} # }
```

--------------------------------

### mindat_connection

Source: https://quexiang.github.io/OpenMindat/reference/mindat_connection.html

Initializes the Mindat API connection by setting the base URL, authentication token, and page size for API requests.

```APIDOC
## Function: mindat_connection

### Description
Initializes the Mindat API connection by setting the base URL, authentication token, and page size for API requests.

### Usage
```
mindat_connection(token, base_url = "https://api.mindat.org/v1", page_size = 800)
```

### Arguments

*   **token** (string) - Required - Your authentication token from Mindat.org.
*   **base_url** (string) - Optional - The base URL of the Mindat API. Defaults to "https://api.mindat.org/v1".
*   **page_size** (integer) - Optional - Sets the page size for data returned from the API server. Defaults to 800.

### Examples
```R
mindat_connection("9ce67655d74bcd981e937be80dcea9cb", page_size = 1500)
```
```

--------------------------------

### Load Required Libraries

Source: https://quexiang.github.io/OpenMindat/articles/Mindat_data.html

Load the necessary R libraries for interacting with the Mindat API and data manipulation.

```r
#library(httr)
#library(jsonlite)
#library(OpenMindat)
#library(tidyverse)
#library(sf)
#library(mapview)
```

--------------------------------

### Retrieve All Locality Statuses

Source: https://quexiang.github.io/OpenMindat/reference/localities_status_list.html

This snippet shows how to call the localities_status_list function to get a data frame of all locality statuses. It is wrapped in a \dontrun{} block as it requires an active internet connection to the Mindat API.

```r
if (FALSE) { # \dontrun{

df <-localities_status_list()

} # }
```

--------------------------------

### Load Required Libraries for OpenMindat

Source: https://quexiang.github.io/OpenMindat/articles/OpenMindat.html

Before using the OpenMindat package, ensure you load the necessary R libraries. This includes packages for making HTTP requests, handling JSON data, the OpenMindat package itself, string manipulation, and reading Excel files.

```r
library(httr)
library(jsonlite)
library(OpenMindat)
library("stringr")
library(readxl)
```

--------------------------------

### Get Geomaterials Not Containing Elements

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that do not contain the specified elements.

```python
geomaterials_not_contain_elems()
```

--------------------------------

### Find Crystal Classes by Systems

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Finds crystal classes that match a given vector of crystal systems (case-insensitive).

```python
crystalclasses_systems()
```

--------------------------------

### Build Mindat API Query String

Source: https://quexiang.github.io/OpenMindat/reference/mindat_build_querystring.html

Use this function to construct a query string for Mindat API calls. It takes a list of arguments that specify the desired data, such as record IDs, minimum hardness, and requested fields. Ensure Mindat cache is set appropriately before calling.

```R
if (FALSE) { # \dontrun{
mindat_cache_set('page-size',800)
ids<-c("")
hardness_min<- 9.3
fields<- c("name,hardness")
args<- list(ids,hardness_min,fields)
querystring<-mindat_build_querystring(args)
} # }
```

--------------------------------

### Get Geomaterials Containing Only Elements

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that exclusively contain the specified elements.

```python
geomaterials_contain_only_elems()
```

--------------------------------

### Load Required Packages for OpenMindat

Source: https://quexiang.github.io/OpenMindat/index.html

Load the OpenMindat package along with its dependencies and other useful packages for data retrieval and processing. These packages are necessary before calling OpenMindat functions.

```r
#install.packages("httr")
#install.packages("jsonlite")
#install.packages("usethis")
#install.packages("readxl")
#install.packages("OpenMindat")
library(OpenMindat)
library(httr)
library(usethis)
library(jsonlite)
library(readxl)
```

--------------------------------

### Get Geomaterials by Group ID

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials associated with a given group ID.

```python
geomaterials_by_groupid()
```

--------------------------------

### Get Dana 8 Subgroups

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves data classified under the Dana 8 subgroups.

```python
Dana8_subgroups()
```

--------------------------------

### mindat_build_querystring

Source: https://quexiang.github.io/OpenMindat/reference/mindat_build_querystring.html

Builds a query string for Mindat API requests by processing a list of arguments.

```APIDOC
## mindat_build_querystring

### Description
Builds a query string for Mindat API requests by processing a list of arguments.

### Usage
```R
mindat_build_querystring (args)
```

### Arguments

*   **args** (list) - A list containing query arguments such as IDs, minimum hardness, and fields to retrieve.

### Value

*   **qs** (string) - The generated query string.

### Examples

```R
if (FALSE) { # \dontrun{
mindat_cache_set('page-size',800)
ids<-c("")
hardness_min<- 9.3
fields<- c("name,hardness")
args<- list(ids,hardness_min,fields)
querystring<-mindat_build_querystring(args)
} # }
```
```

--------------------------------

### Retrieve Dana8 Groups

Source: https://quexiang.github.io/OpenMindat/reference/mindat_dana8_groups.html

Retrieves a data frame containing all classifications of Dana8. This is a non-runnable example.

```R
if (FALSE) { # \dontrun{
 df<- mindat_dana8_groups()
} # }
```

--------------------------------

### R Function Signature for localities_list_updated_at

Source: https://quexiang.github.io/OpenMindat/reference/localities_list_updated_at.html

Shows the usage and arguments for the localities_list_updated_at function. The updateDate argument requires a date-time string in the format %Y-%m-%d %H:%M:%S.

```R
localities_list_updated_at(updateDate,...)
```

--------------------------------

### R Function Signature

Source: https://quexiang.github.io/OpenMindat/reference/localities_list_description.html

Shows the basic usage and arguments for the localities_list_description function.

```R
localities_list_description(desc,...)
```

--------------------------------

### Get Geomaterials Containing Any Element

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials that contain at least one of the specified elements.

```python
geomaterials_contain_any_elems()
```

--------------------------------

### Get Dana 8 Groups

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves data classified under the Dana 8 classification system.

```python
Dana8_groups()
```

--------------------------------

### List Localities with Expands (R)

Source: https://quexiang.github.io/OpenMindat/reference/localities_list_expand.html

Queries the list of localities that contain the given expands. Use '~all' to retrieve all available expands.

```r
localities_list_expand("~all")
```

--------------------------------

### Retrieve API Token from Cache

Source: https://quexiang.github.io/OpenMindat/reference/mindat_cache_get.html

This snippet shows how to retrieve the 'api_token' from the cache. Ensure the token has been previously set in the cache.

```r
token<- mindat_cache_get('api_token')
```

--------------------------------

### Get Geomaterials by Polytype ID

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Retrieves geomaterials by the ID of their polytype, referring to the mineral of which this record is a polytype.

```python
geomaterials_polytypeof()
```

--------------------------------

### R Function Signature for geomaterials_optical2v_max

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_optical2v_max.html

This is the function signature for retrieving geomaterials with a maximum optical 2V value less than a specified threshold. It takes 'lt' as a primary argument and accepts additional parameters.

```R
geomaterials_optical2v_max(lt, ...)
```

--------------------------------

### Utility Functions

Source: https://quexiang.github.io/OpenMindat/reference/index.html

General utility functions for string manipulation and data saving.

```APIDOC
## params_to_string()

### Description
Convert parameters to a string format.

### Method
POST (assumed)

### Endpoint
/utils/params_to_string

### Parameters
#### Request Body
- **params** (object) - Required - The parameters to convert.
```

```APIDOC
## saveMindatDataAs()

### Description
Output Mindat data as a given file format.

### Method
POST (assumed)

### Endpoint
/mindat/save

### Parameters
#### Request Body
- **data** (any) - Required - The Mindat data to save.
- **format** (string) - Required - The desired output format (e.g., 'json', 'csv').
```

--------------------------------

### Search Geomaterials by Name

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_search_name.html

Queries the list of geomaterials by a given name. Supports wildcard searches.

```r
if (FALSE) { # \dontrun{

df <-geomaterials_search_name("Quartz")
}

```

--------------------------------

### Retrieve Geomaterials by Ordering

Source: https://quexiang.github.io/OpenMindat/reference/geomeaterials_ordering.html

Queries the geomaterials by a given ordering. Use this function to sort geomaterials based on fields like 'id', 'name', or 'approval_year'. Prepend '-' to a field name for descending order.

```R
if (FALSE) { # \dontrun{
df <-geomeaterials_ordering(-id)
} # }
```

--------------------------------

### R: Filter Geomaterials by Minimum Optical 2V

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_optical2v_min.html

Use this function to query geomaterials that have an optical 2V value greater than the provided threshold. The function relates to the 'optical2v_mix' field in geomaterials data.

```R
if (FALSE) { # \dontrun{
df <-geomaterials_optical2v_min(0.1)
} # }
```

--------------------------------

### Retrieve Locality Type List

Source: https://quexiang.github.io/OpenMindat/reference/locality_type_list.html

Call the `locality_type_list` function to get a data frame of all available locality types. This function requires no arguments.

```R
if (FALSE) { # \dontrun{

df <-locality_type_list()
}

```

--------------------------------

### Query Geomaterials by Optical 2V Range

Source: https://quexiang.github.io/OpenMindat/reference/geomaterials_optical2v_range.html

Use this function to retrieve geomaterials that have an optical 2V value within a specified range (greater than gt and less than lt). The function relates to the 'optical2v_min' and 'optical2v_max' fields of geomaterials.

```R
if (FALSE) { # \dontrun{

df <-geomaterials_optical2v_range(0.1,0.2)
}

```

--------------------------------

### spacegroupsets_list

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Returns a full list of spacegroupsets.

```APIDOC
## spacegroupsets_list()

### Description
Returns a full list of spacegroupsets.

### Method
Not applicable (SDK function)

### Endpoint
Not applicable (SDK function)

### Parameters
None explicitly documented.

### Request Example
```
spacegroupsets_list()
```

### Response
None explicitly documented.
```

--------------------------------

### Find Crystal Classes by Symbols

Source: https://quexiang.github.io/OpenMindat/reference/index.html

Finds crystal classes that match a given vector of symbols (case-insensitive).

```python
crystalclasses_symbols()
```

--------------------------------

### Retrieve Locality Type by ID

Source: https://quexiang.github.io/OpenMindat/reference/localitiy_type_retrieve.html

This function retrieves the locality type for a given Mindat locality ID. Ensure you have the OpenMindat package installed and loaded.

```R
if (FALSE) { # \dontrun{

df <-localitiy_type_retrieve(50)
}


```

--------------------------------

### Retrieve Spacegroups by ID

Source: https://quexiang.github.io/OpenMindat/reference/mindat_spacegroups.html

Use the `mindat_spacegroups` function to get spacegroup information by its unique identifier. This function returns a data frame containing the spacegroup details.

```r
if (FALSE) { # \dontrun{
 df<- mindat_spacegroups(4)
} # }
```

--------------------------------

### Query Crystal Classes by System

Source: https://quexiang.github.io/OpenMindat/reference/crystalclasses_systems.html

Use this function to filter crystal classes by one or more crystal systems. The input is case-insensitive.

```r
crystalclasses_systems(systems, ...)
```

--------------------------------

### Retrieve Spacegroupsets by ID

Source: https://quexiang.github.io/OpenMindat/reference/spacegroupsets_by_id.html

Demonstrates how to use the `spacegroupsets_by_id` function to fetch spacegroupsets data for a specific ID. This function filters data by a given spacegroup ID.

```r
if (FALSE) { # \dontrun{

df <-spacegroupsets_by_id(2)
} # }
```
Tokens:
Raw