Amrex.jl 3.37 KB
Newer Older
William F Godoy's avatar
William F Godoy committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

abstract type AbstractAmrex <: AbstractExtractor end

mutable struct Amrex <: AbstractAmrex
    app::String
    outputPrefix::String
    degreesOfFreedom::Any

    Amrex() = new()
end

"""
   
   initialize members of the extractor::Amrex type
   Using bang convention as init modifies the extractor::Amrex
   https://docs.julialang.org/en/v1/manual/style-guide/index.html#bang-convention-1
"""
function init!(extractor::Amrex, outputPrefix::String)
    extractor.app = "Amrex"
    extractor.outputPrefix = outputPrefix
    extractor.degreesOfFreedom =
        ["max_step", "amr.check_int", "amr.plot_int", "amr.n_cell", "amr.max_level"]
end

"""
    Parses an input file with entries key = value, returns all entries in a Dict
    # Arguments
    - `extractor::AbstractAmrex` : input type extending AbstractAmrex
    - `inputFile::String` : input file to be parsed, absolute path is preferred
"""
function input_parser(extractor::AbstractAmrex, inputFile::String)::Dict{String,String}

    parameters = Dict{String,String}()
    # get file contents in a single iterable type, \n newline is removed 
    fileContents = readlines(inputFile)

    # go through each line
    for line in fileContents
        if isempty(line)
            continue
        end

        # remove comments marked with #
        result = findfirst("#", line)

        if isnothing(result) == false
            line = SubString(line, 1, result[1] - 1)
            if isempty(line)
                continue
            end
        end

        parameter = split(line, "=")
        parameters[strip(parameter[1])] = strip(parameter[2])

    end

    return parameters
end
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

"""
    Get actual independent variables for I/O characterization: 
    number of cells or ncells, output frequency or nplots, ncheckpoints, etc.    
    from input parameters 
    # Arguments
    - `extractor::AbstractAmrex` : input type extending AbstractAmrex
    - `parameters::Dict{String,String}` : input file to be parsed, absolute path is preferred
"""
function get_independent_variables(extractor::AbstractAmrex, parameters)::Dict
  
  independentVariables = Dict()
  
  # Number of output events, 
  # get is the safe way. 3rd argument is a default fallback if key not found
  maxStepStr = get(parameters, "max_step", "")
  
  if maxStepStr != ""
    # safe string conversion to a type
    maxStep = parse(Int64, maxStepStr) 
    
    plotIntStr = get(parameters, "amr.plot_int", "")
    if plotIntStr != ""
      plotFrequency = parse(Int64, plotIntStr)
      independentVariables["nplots"] = maxStep / plotFrequency
    else
      throw(NoSuchFieldException("jexio Amrex: Can't find amr.plot_int"))
    end
    
    checkIntStr = get(parameters, "amr.check_int", "")
    if checkIntStr != ""
      checkpointFrequency = parse(Int64, checkIntStr)
      independentVariables["ncheckpoints"] = maxStep / checkpointFrequency
    else
      throw(NoSuchFieldException("jexio Amrex: Can't find amr.check_int"))
    end
    
  end
  
  # Using the dot "." operator to apply it on an element-by-element basis (like a dot product)
  # input is a dictionary with key="amr.ncell" and value = {"nx" "ny" "nz"},  
  # output is nx*ny*nz
  # Example:  
  # input Dict[ "amr.n_cell" => ["16" "16"] ], if key not found return 0
  # >ncells
  #   256
  ncells = prod(parse.(Int64, split(get(parameters, "amr.n_cell", ["0"] ) )))
  independentVariables["ncells"] = ncells
  
  return independentVariables
   
end