\hypertarget{interfacemom__file__parser_1_1get__param}{}\section{mom\+\_\+file\+\_\+parser\+:\+:get\+\_\+param Interface Reference}
\label{interfacemom__file__parser_1_1get__param}\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}


\subsection{Detailed Description}
An overloaded interface to read and log the values of various types of parameters. 

Definition at line 102 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.

\subsection*{Private functions}
\begin{DoxyCompactItemize}
\item 
subroutine \hyperlink{interfacemom__file__parser_1_1get__param_acc66a19b265d929aab2ba7ff32a48484}{get\+\_\+param\+\_\+int} (CS, modulename, varname, value, desc, units, default, fail\+\_\+if\+\_\+missing, do\+\_\+not\+\_\+read, do\+\_\+not\+\_\+log, static\+\_\+value, layout\+Param, debugging\+Param)
\begin{DoxyCompactList}\small\item\em This subroutine reads the value of an integer model parameter from a parameter file and logs it in documentation files. \end{DoxyCompactList}\item 
subroutine \hyperlink{interfacemom__file__parser_1_1get__param_a8b8891ce33eed2fd4bd613cc4a63f91b}{get\+\_\+param\+\_\+real} (CS, modulename, varname, value, desc, units, default, fail\+\_\+if\+\_\+missing, do\+\_\+not\+\_\+read, do\+\_\+not\+\_\+log, static\+\_\+value, debugging\+Param, scale, unscaled)
\begin{DoxyCompactList}\small\item\em This subroutine reads the value of a real model parameter from a parameter file and logs it in documentation files. \end{DoxyCompactList}\item 
subroutine \hyperlink{interfacemom__file__parser_1_1get__param_a4d80a13419b84de623613043bebe5b29}{get\+\_\+param\+\_\+logical} (CS, modulename, varname, value, desc, units, default, fail\+\_\+if\+\_\+missing, do\+\_\+not\+\_\+read, do\+\_\+not\+\_\+log, static\+\_\+value, layout\+Param, debugging\+Param)
\begin{DoxyCompactList}\small\item\em This subroutine reads the value of a logical model parameter from a parameter file and logs it in documentation files. \end{DoxyCompactList}\item 
subroutine \hyperlink{interfacemom__file__parser_1_1get__param_af0f92cf72c64900999842b73cbf4b879}{get\+\_\+param\+\_\+char} (CS, modulename, varname, value, desc, units, default, fail\+\_\+if\+\_\+missing, do\+\_\+not\+\_\+read, do\+\_\+not\+\_\+log, static\+\_\+value, layout\+Param, debugging\+Param)
\begin{DoxyCompactList}\small\item\em This subroutine reads the value of a character string model parameter from a parameter file and logs it in documentation files. \end{DoxyCompactList}\item 
subroutine \hyperlink{interfacemom__file__parser_1_1get__param_a2fc68d15c0d977b234ee37797ea8a2bd}{get\+\_\+param\+\_\+char\+\_\+array} (CS, modulename, varname, value, desc, units, default, fail\+\_\+if\+\_\+missing, do\+\_\+not\+\_\+read, do\+\_\+not\+\_\+log, static\+\_\+value)
\begin{DoxyCompactList}\small\item\em This subroutine reads the values of an array of character string model parameters from a parameter file and logs them in documentation files. \end{DoxyCompactList}\item 
subroutine \hyperlink{interfacemom__file__parser_1_1get__param_a11cd2c3771b40e03d240d0b84fb25913}{get\+\_\+param\+\_\+time} (CS, modulename, varname, value, desc, units, default, fail\+\_\+if\+\_\+missing, do\+\_\+not\+\_\+read, do\+\_\+not\+\_\+log, timeunit, static\+\_\+value, layout\+Param, debugging\+Param, log\+\_\+as\+\_\+date)
\begin{DoxyCompactList}\small\item\em This subroutine reads the value of a time-\/type model parameter from a parameter file and logs it in documentation files. \end{DoxyCompactList}\item 
subroutine \hyperlink{interfacemom__file__parser_1_1get__param_a29796bb5f29f7a02fcb7ec956f90a129}{get\+\_\+param\+\_\+int\+\_\+array} (CS, modulename, varname, value, desc, units, default, fail\+\_\+if\+\_\+missing, do\+\_\+not\+\_\+read, do\+\_\+not\+\_\+log, static\+\_\+value, layout\+Param, debugging\+Param)
\begin{DoxyCompactList}\small\item\em This subroutine reads the values of an array of integer model parameters from a parameter file and logs them in documentation files. \end{DoxyCompactList}\item 
subroutine \hyperlink{interfacemom__file__parser_1_1get__param_a3d34e9640391f0d919bb6534b104b270}{get\+\_\+param\+\_\+real\+\_\+array} (CS, modulename, varname, value, desc, units, default, fail\+\_\+if\+\_\+missing, do\+\_\+not\+\_\+read, do\+\_\+not\+\_\+log, debugging\+Param, static\+\_\+value, scale, unscaled)
\begin{DoxyCompactList}\small\item\em This subroutine reads the values of an array of real model parameters from a parameter file and logs them in documentation files. \end{DoxyCompactList}\end{DoxyCompactItemize}


\subsection{Detailed Description}
An overloaded interface to read and log the values of various types of parameters. 

Definition at line 102 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.



\subsection{Functions and subroutines}
\mbox{\Hypertarget{interfacemom__file__parser_1_1get__param_af0f92cf72c64900999842b73cbf4b879}\label{interfacemom__file__parser_1_1get__param_af0f92cf72c64900999842b73cbf4b879}} 
\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}!get\+\_\+param\+\_\+char@{get\+\_\+param\+\_\+char}}
\index{get\+\_\+param\+\_\+char@{get\+\_\+param\+\_\+char}!mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}
\subsubsection{\texorpdfstring{get\+\_\+param\+\_\+char()}{get\_param\_char()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+char (\begin{DoxyParamCaption}\item[{type(\hyperlink{structmom__file__parser_1_1param__file__type}{param\+\_\+file\+\_\+type}), intent(in)}]{CS,  }\item[{character(len=$\ast$), intent(in)}]{modulename,  }\item[{character(len=$\ast$), intent(in)}]{varname,  }\item[{character(len=$\ast$), intent(inout)}]{value,  }\item[{character(len=$\ast$), intent(in), optional}]{desc,  }\item[{character(len=$\ast$), intent(in), optional}]{units,  }\item[{character(len=$\ast$), intent(in), optional}]{default,  }\item[{logical, intent(in), optional}]{fail\+\_\+if\+\_\+missing,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+read,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+log,  }\item[{character(len=$\ast$), intent(in), optional}]{static\+\_\+value,  }\item[{logical, intent(in), optional}]{layout\+Param,  }\item[{logical, intent(in), optional}]{debugging\+Param }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



This subroutine reads the value of a character string model parameter from a parameter file and logs it in documentation files. 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters\\
\hline
\mbox{\tt in}  & {\em modulename} & The name of the calling module\\
\hline
\mbox{\tt in}  & {\em varname} & The case-\/sensitive name of the parameter to read\\
\hline
\mbox{\tt in,out}  & {\em value} & The value of the parameter that may be read from the parameter file and logged\\
\hline
\mbox{\tt in}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file\\
\hline
\mbox{\tt in}  & {\em units} & The units of this parameter\\
\hline
\mbox{\tt in}  & {\em default} & The default value of the parameter\\
\hline
\mbox{\tt in}  & {\em static\+\_\+value} & If this parameter is static, it takes this value, which can be compared for consistency with what is in the parameter file.\\
\hline
\mbox{\tt in}  & {\em fail\+\_\+if\+\_\+missing} & If present and true, a fatal error occurs if this variable is not found in the parameter file\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged.\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files\\
\hline
\mbox{\tt in}  & {\em layoutparam} & If present and true, this parameter is logged in the layout parameter file\\
\hline
\mbox{\tt in}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file \\
\hline
\end{DoxyParams}


Definition at line 1827 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}
1827   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: cs\textcolor{comment}{      !< The control structure for the file\_parser module,}
1828 \textcolor{comment}{                                         !! it is also a structure to parse for run-time parameters}
1829   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}
1830   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-sensitive name of the parameter to read}
1831   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}
1832 \textcolor{comment}{                                         !! read from the parameter file and logged}
1833   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}
1834 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}
1835   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}
1836   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}
1837   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}
1838 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}
1839 \textcolor{comment}{                                         !! what is in the parameter file.}
1840   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}
1841 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}
1842   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}
1843 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}
1844   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}
1845 \textcolor{comment}{                                         !! parameter to the documentation files}
1846   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: layoutparam\textcolor{comment}{ !< If present and true, this parameter is}
1847 \textcolor{comment}{                                         !! logged in the layout parameter file}
1848   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingparam\textcolor{comment}{ !< If present and true, this parameter is}
1849 \textcolor{comment}{                                         !! logged in the debugging parameter file}
1850 
1851   \textcolor{keywordtype}{logical} :: do\_read, do\_log
1852 
1853   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read
1854   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log
1855 
1856   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}
1857     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default
1858     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value
1859     \textcolor{keyword}{call }read\_param\_char(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)
1860 \textcolor{keywordflow}{  endif}
1861 
1862   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}
1863     \textcolor{keyword}{call }log\_param\_char(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, units, &
1864                         default, layoutparam, debuggingparam)
1865 \textcolor{keywordflow}{  endif}
1866 
\end{DoxyCode}
\mbox{\Hypertarget{interfacemom__file__parser_1_1get__param_a2fc68d15c0d977b234ee37797ea8a2bd}\label{interfacemom__file__parser_1_1get__param_a2fc68d15c0d977b234ee37797ea8a2bd}} 
\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}!get\+\_\+param\+\_\+char\+\_\+array@{get\+\_\+param\+\_\+char\+\_\+array}}
\index{get\+\_\+param\+\_\+char\+\_\+array@{get\+\_\+param\+\_\+char\+\_\+array}!mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}
\subsubsection{\texorpdfstring{get\+\_\+param\+\_\+char\+\_\+array()}{get\_param\_char\_array()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+char\+\_\+array (\begin{DoxyParamCaption}\item[{type(\hyperlink{structmom__file__parser_1_1param__file__type}{param\+\_\+file\+\_\+type}), intent(in)}]{CS,  }\item[{character(len=$\ast$), intent(in)}]{modulename,  }\item[{character(len=$\ast$), intent(in)}]{varname,  }\item[{character(len=$\ast$), dimension(\+:), intent(inout)}]{value,  }\item[{character(len=$\ast$), intent(in), optional}]{desc,  }\item[{character(len=$\ast$), intent(in), optional}]{units,  }\item[{character(len=$\ast$), intent(in), optional}]{default,  }\item[{logical, intent(in), optional}]{fail\+\_\+if\+\_\+missing,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+read,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+log,  }\item[{character(len=$\ast$), intent(in), optional}]{static\+\_\+value }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



This subroutine reads the values of an array of character string model parameters from a parameter file and logs them in documentation files. 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters\\
\hline
\mbox{\tt in}  & {\em modulename} & The name of the calling module\\
\hline
\mbox{\tt in}  & {\em varname} & The case-\/sensitive name of the parameter to read\\
\hline
\mbox{\tt in,out}  & {\em value} & The value of the parameter that may be read from the parameter file and logged\\
\hline
\mbox{\tt in}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file\\
\hline
\mbox{\tt in}  & {\em units} & The units of this parameter\\
\hline
\mbox{\tt in}  & {\em default} & The default value of the parameter\\
\hline
\mbox{\tt in}  & {\em static\+\_\+value} & If this parameter is static, it takes this value, which can be compared for consistency with what is in the parameter file.\\
\hline
\mbox{\tt in}  & {\em fail\+\_\+if\+\_\+missing} & If present and true, a fatal error occurs if this variable is not found in the parameter file\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged.\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files \\
\hline
\end{DoxyParams}


Definition at line 1873 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}
1873   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: cs\textcolor{comment}{      !< The control structure for the file\_parser module,}
1874 \textcolor{comment}{                                         !! it is also a structure to parse for run-time parameters}
1875   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}
1876   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-sensitive name of the parameter to read}
1877   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{dimension(:)}, \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}
1878 \textcolor{comment}{                                         !! read from the parameter file and logged}
1879   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}
1880 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}
1881   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}
1882   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}
1883   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}
1884 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}
1885 \textcolor{comment}{                                         !! what is in the parameter file.}
1886   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}
1887 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}
1888   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}
1889 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}
1890   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}
1891 \textcolor{comment}{                                         !! parameter to the documentation files}
1892 
1893   \textcolor{comment}{! Local variables}
1894   \textcolor{keywordtype}{logical} :: do\_read, do\_log
1895   \textcolor{keywordtype}{integer} :: i, len\_tot, len\_val
1896   \textcolor{keywordtype}{character(len=1024)} :: cat\_val
1897 
1898   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read
1899   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log
1900 
1901   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}
1902     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordflow}{then} ; value(:) = default ;\textcolor{keywordflow}{ endif}
1903     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordflow}{then} ; value(:) = static\_value ;\textcolor{keywordflow}{ endif}
1904     \textcolor{keyword}{call }read\_param\_char\_array(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)
1905 \textcolor{keywordflow}{  endif}
1906 
1907   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}
1908     cat\_val = trim(value(1)); len\_tot = len\_trim(value(1))
1909     \textcolor{keywordflow}{do} i=2,\textcolor{keyword}{size}(\textcolor{keywordtype}{value})
1910       len\_val = len\_trim(value(i))
1911       \textcolor{keywordflow}{if} ((len\_val > 0) .and. (len\_tot + len\_val + 2 < 240)) \textcolor{keywordflow}{then}
1912         cat\_val = trim(cat\_val)//achar(34)// \textcolor{stringliteral}{", "}//achar(34)//trim(value(i))
1913         len\_tot = len\_tot + len\_val
1914 \textcolor{keywordflow}{      endif}
1915 \textcolor{keywordflow}{    enddo}
1916     \textcolor{keyword}{call }log\_param\_char(cs, modulename, varname, cat\_val, desc, &
1917                         units, default)
1918 \textcolor{keywordflow}{  endif}
1919 
\end{DoxyCode}
\mbox{\Hypertarget{interfacemom__file__parser_1_1get__param_acc66a19b265d929aab2ba7ff32a48484}\label{interfacemom__file__parser_1_1get__param_acc66a19b265d929aab2ba7ff32a48484}} 
\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}!get\+\_\+param\+\_\+int@{get\+\_\+param\+\_\+int}}
\index{get\+\_\+param\+\_\+int@{get\+\_\+param\+\_\+int}!mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}
\subsubsection{\texorpdfstring{get\+\_\+param\+\_\+int()}{get\_param\_int()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+int (\begin{DoxyParamCaption}\item[{type(\hyperlink{structmom__file__parser_1_1param__file__type}{param\+\_\+file\+\_\+type}), intent(in)}]{CS,  }\item[{character(len=$\ast$), intent(in)}]{modulename,  }\item[{character(len=$\ast$), intent(in)}]{varname,  }\item[{integer, intent(inout)}]{value,  }\item[{character(len=$\ast$), intent(in), optional}]{desc,  }\item[{character(len=$\ast$), intent(in), optional}]{units,  }\item[{integer, intent(in), optional}]{default,  }\item[{logical, intent(in), optional}]{fail\+\_\+if\+\_\+missing,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+read,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+log,  }\item[{integer, intent(in), optional}]{static\+\_\+value,  }\item[{logical, intent(in), optional}]{layout\+Param,  }\item[{logical, intent(in), optional}]{debugging\+Param }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



This subroutine reads the value of an integer model parameter from a parameter file and logs it in documentation files. 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters\\
\hline
\mbox{\tt in}  & {\em modulename} & The name of the calling module\\
\hline
\mbox{\tt in}  & {\em varname} & The case-\/sensitive name of the parameter to read\\
\hline
\mbox{\tt in,out}  & {\em value} & The value of the parameter that may be read from the parameter file and logged\\
\hline
\mbox{\tt in}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file\\
\hline
\mbox{\tt in}  & {\em units} & The units of this parameter\\
\hline
\mbox{\tt in}  & {\em default} & The default value of the parameter\\
\hline
\mbox{\tt in}  & {\em static\+\_\+value} & If this parameter is static, it takes this value, which can be compared for consistency with what is in the parameter file.\\
\hline
\mbox{\tt in}  & {\em fail\+\_\+if\+\_\+missing} & If present and true, a fatal error occurs if this variable is not found in the parameter file\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged.\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files\\
\hline
\mbox{\tt in}  & {\em layoutparam} & If present and true, this parameter is logged in the layout parameter file\\
\hline
\mbox{\tt in}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file \\
\hline
\end{DoxyParams}


Definition at line 1629 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}
1629   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: cs\textcolor{comment}{      !< The control structure for the file\_parser module,}
1630 \textcolor{comment}{                                         !! it is also a structure to parse for run-time parameters}
1631   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}
1632   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-sensitive name of the parameter to read}
1633   \textcolor{keywordtype}{integer},                    \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}
1634 \textcolor{comment}{                                         !! read from the parameter file and logged}
1635   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}
1636 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}
1637   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}
1638   \textcolor{keywordtype}{integer},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}
1639   \textcolor{keywordtype}{integer},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}
1640 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}
1641 \textcolor{comment}{                                         !! what is in the parameter file.}
1642   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}
1643 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}
1644   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}
1645 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}
1646   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}
1647 \textcolor{comment}{                                         !! parameter to the documentation files}
1648   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: layoutparam\textcolor{comment}{ !< If present and true, this parameter is}
1649 \textcolor{comment}{                                         !! logged in the layout parameter file}
1650   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingparam\textcolor{comment}{ !< If present and true, this parameter is}
1651 \textcolor{comment}{                                         !! logged in the debugging parameter file}
1652 
1653   \textcolor{keywordtype}{logical} :: do\_read, do\_log
1654 
1655   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read
1656   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log
1657 
1658   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}
1659     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default
1660     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value
1661     \textcolor{keyword}{call }read\_param\_int(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)
1662 \textcolor{keywordflow}{  endif}
1663 
1664   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}
1665     \textcolor{keyword}{call }log\_param\_int(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, units, &
1666                        default, layoutparam, debuggingparam)
1667 \textcolor{keywordflow}{  endif}
1668 
\end{DoxyCode}
\mbox{\Hypertarget{interfacemom__file__parser_1_1get__param_a29796bb5f29f7a02fcb7ec956f90a129}\label{interfacemom__file__parser_1_1get__param_a29796bb5f29f7a02fcb7ec956f90a129}} 
\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}!get\+\_\+param\+\_\+int\+\_\+array@{get\+\_\+param\+\_\+int\+\_\+array}}
\index{get\+\_\+param\+\_\+int\+\_\+array@{get\+\_\+param\+\_\+int\+\_\+array}!mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}
\subsubsection{\texorpdfstring{get\+\_\+param\+\_\+int\+\_\+array()}{get\_param\_int\_array()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+int\+\_\+array (\begin{DoxyParamCaption}\item[{type(\hyperlink{structmom__file__parser_1_1param__file__type}{param\+\_\+file\+\_\+type}), intent(in)}]{CS,  }\item[{character(len=$\ast$), intent(in)}]{modulename,  }\item[{character(len=$\ast$), intent(in)}]{varname,  }\item[{integer, dimension(\+:), intent(inout)}]{value,  }\item[{character(len=$\ast$), intent(in), optional}]{desc,  }\item[{character(len=$\ast$), intent(in), optional}]{units,  }\item[{integer, intent(in), optional}]{default,  }\item[{logical, intent(in), optional}]{fail\+\_\+if\+\_\+missing,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+read,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+log,  }\item[{integer, intent(in), optional}]{static\+\_\+value,  }\item[{logical, intent(in), optional}]{layout\+Param,  }\item[{logical, intent(in), optional}]{debugging\+Param }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



This subroutine reads the values of an array of integer model parameters from a parameter file and logs them in documentation files. 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters\\
\hline
\mbox{\tt in}  & {\em modulename} & The name of the calling module\\
\hline
\mbox{\tt in}  & {\em varname} & The case-\/sensitive name of the parameter to read\\
\hline
\mbox{\tt in,out}  & {\em value} & The value of the parameter that may be reset from the parameter file\\
\hline
\mbox{\tt in}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file\\
\hline
\mbox{\tt in}  & {\em units} & The units of this parameter\\
\hline
\mbox{\tt in}  & {\em default} & The default value of the parameter\\
\hline
\mbox{\tt in}  & {\em static\+\_\+value} & If this parameter is static, it takes this value, which can be compared for consistency with what is in the parameter file.\\
\hline
\mbox{\tt in}  & {\em fail\+\_\+if\+\_\+missing} & If present and true, a fatal error occurs if this variable is not found in the parameter file\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged.\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files\\
\hline
\mbox{\tt in}  & {\em layoutparam} & If present and true, this parameter is logged in the layout parameter file\\
\hline
\mbox{\tt in}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file \\
\hline
\end{DoxyParams}


Definition at line 1676 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}
1676   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: cs\textcolor{comment}{      !< The control structure for the file\_parser module,}
1677 \textcolor{comment}{                                         !! it is also a structure to parse for run-time parameters}
1678   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}
1679   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-sensitive name of the parameter to read}
1680   \textcolor{keywordtype}{integer}, \textcolor{keywordtype}{dimension(:)},      \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be reset}
1681 \textcolor{comment}{                                         !! from the parameter file}
1682   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}
1683 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}
1684   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}
1685   \textcolor{keywordtype}{integer},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}
1686   \textcolor{keywordtype}{integer},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}
1687 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}
1688 \textcolor{comment}{                                         !! what is in the parameter file.}
1689   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}
1690 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}
1691   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}
1692 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}
1693   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}
1694 \textcolor{comment}{                                         !! parameter to the documentation files}
1695   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: layoutparam\textcolor{comment}{ !< If present and true, this parameter is}
1696 \textcolor{comment}{                                         !! logged in the layout parameter file}
1697   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingparam\textcolor{comment}{ !< If present and true, this parameter is}
1698 \textcolor{comment}{                                         !! logged in the debugging parameter file}
1699 
1700   \textcolor{keywordtype}{logical} :: do\_read, do\_log
1701 
1702   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read
1703   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log
1704 
1705   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}
1706     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordflow}{then} ; value(:) = default ;\textcolor{keywordflow}{ endif}
1707     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordflow}{then} ; value(:) = static\_value ;\textcolor{keywordflow}{ endif}
1708     \textcolor{keyword}{call }read\_param\_int\_array(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)
1709 \textcolor{keywordflow}{  endif}
1710 
1711   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}
1712     \textcolor{keyword}{call }log\_param\_int\_array(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, &
1713                              units, default, layoutparam, debuggingparam)
1714 \textcolor{keywordflow}{  endif}
1715 
\end{DoxyCode}
\mbox{\Hypertarget{interfacemom__file__parser_1_1get__param_a4d80a13419b84de623613043bebe5b29}\label{interfacemom__file__parser_1_1get__param_a4d80a13419b84de623613043bebe5b29}} 
\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}!get\+\_\+param\+\_\+logical@{get\+\_\+param\+\_\+logical}}
\index{get\+\_\+param\+\_\+logical@{get\+\_\+param\+\_\+logical}!mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}
\subsubsection{\texorpdfstring{get\+\_\+param\+\_\+logical()}{get\_param\_logical()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+logical (\begin{DoxyParamCaption}\item[{type(\hyperlink{structmom__file__parser_1_1param__file__type}{param\+\_\+file\+\_\+type}), intent(in)}]{CS,  }\item[{character(len=$\ast$), intent(in)}]{modulename,  }\item[{character(len=$\ast$), intent(in)}]{varname,  }\item[{logical, intent(inout)}]{value,  }\item[{character(len=$\ast$), intent(in), optional}]{desc,  }\item[{character(len=$\ast$), intent(in), optional}]{units,  }\item[{logical, intent(in), optional}]{default,  }\item[{logical, intent(in), optional}]{fail\+\_\+if\+\_\+missing,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+read,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+log,  }\item[{logical, intent(in), optional}]{static\+\_\+value,  }\item[{logical, intent(in), optional}]{layout\+Param,  }\item[{logical, intent(in), optional}]{debugging\+Param }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



This subroutine reads the value of a logical model parameter from a parameter file and logs it in documentation files. 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters\\
\hline
\mbox{\tt in}  & {\em modulename} & The name of the calling module\\
\hline
\mbox{\tt in}  & {\em varname} & The case-\/sensitive name of the parameter to read\\
\hline
\mbox{\tt in,out}  & {\em value} & The value of the parameter that may be read from the parameter file and logged\\
\hline
\mbox{\tt in}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file\\
\hline
\mbox{\tt in}  & {\em units} & The units of this parameter\\
\hline
\mbox{\tt in}  & {\em default} & The default value of the parameter\\
\hline
\mbox{\tt in}  & {\em static\+\_\+value} & If this parameter is static, it takes this value, which can be compared for consistency with what is in the parameter file.\\
\hline
\mbox{\tt in}  & {\em fail\+\_\+if\+\_\+missing} & If present and true, a fatal error occurs if this variable is not found in the parameter file\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged.\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files\\
\hline
\mbox{\tt in}  & {\em layoutparam} & If present and true, this parameter is logged in the layout parameter file\\
\hline
\mbox{\tt in}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file \\
\hline
\end{DoxyParams}


Definition at line 1927 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}
1927   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: cs\textcolor{comment}{      !< The control structure for the file\_parser module,}
1928 \textcolor{comment}{                                         !! it is also a structure to parse for run-time parameters}
1929   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}
1930   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-sensitive name of the parameter to read}
1931   \textcolor{keywordtype}{logical},                    \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}
1932 \textcolor{comment}{                                         !! read from the parameter file and logged}
1933   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}
1934 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}
1935   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}
1936   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}
1937   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}
1938 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}
1939 \textcolor{comment}{                                         !! what is in the parameter file.}
1940   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}
1941 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}
1942   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}
1943 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}
1944   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}
1945 \textcolor{comment}{                                         !! parameter to the documentation files}
1946   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: layoutparam\textcolor{comment}{ !< If present and true, this parameter is}
1947 \textcolor{comment}{                                         !! logged in the layout parameter file}
1948   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingparam\textcolor{comment}{ !< If present and true, this parameter is}
1949 \textcolor{comment}{                                         !! logged in the debugging parameter file}
1950 
1951   \textcolor{keywordtype}{logical} :: do\_read, do\_log
1952 
1953   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read
1954   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log
1955 
1956   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}
1957     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default
1958     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value
1959     \textcolor{keyword}{call }read\_param\_logical(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)
1960 \textcolor{keywordflow}{  endif}
1961 
1962   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}
1963     \textcolor{keyword}{call }log\_param\_logical(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, &
1964                            units, default, layoutparam, debuggingparam)
1965 \textcolor{keywordflow}{  endif}
1966 
\end{DoxyCode}
\mbox{\Hypertarget{interfacemom__file__parser_1_1get__param_a8b8891ce33eed2fd4bd613cc4a63f91b}\label{interfacemom__file__parser_1_1get__param_a8b8891ce33eed2fd4bd613cc4a63f91b}} 
\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}!get\+\_\+param\+\_\+real@{get\+\_\+param\+\_\+real}}
\index{get\+\_\+param\+\_\+real@{get\+\_\+param\+\_\+real}!mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}
\subsubsection{\texorpdfstring{get\+\_\+param\+\_\+real()}{get\_param\_real()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+real (\begin{DoxyParamCaption}\item[{type(\hyperlink{structmom__file__parser_1_1param__file__type}{param\+\_\+file\+\_\+type}), intent(in)}]{CS,  }\item[{character(len=$\ast$), intent(in)}]{modulename,  }\item[{character(len=$\ast$), intent(in)}]{varname,  }\item[{real, intent(inout)}]{value,  }\item[{character(len=$\ast$), intent(in), optional}]{desc,  }\item[{character(len=$\ast$), intent(in), optional}]{units,  }\item[{real, intent(in), optional}]{default,  }\item[{logical, intent(in), optional}]{fail\+\_\+if\+\_\+missing,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+read,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+log,  }\item[{real, intent(in), optional}]{static\+\_\+value,  }\item[{logical, intent(in), optional}]{debugging\+Param,  }\item[{real, intent(in), optional}]{scale,  }\item[{real, intent(out), optional}]{unscaled }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



This subroutine reads the value of a real model parameter from a parameter file and logs it in documentation files. 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters\\
\hline
\mbox{\tt in}  & {\em modulename} & The name of the calling module\\
\hline
\mbox{\tt in}  & {\em varname} & The case-\/sensitive name of the parameter to read\\
\hline
\mbox{\tt in,out}  & {\em value} & The value of the parameter that may be read from the parameter file and logged\\
\hline
\mbox{\tt in}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file\\
\hline
\mbox{\tt in}  & {\em units} & The units of this parameter\\
\hline
\mbox{\tt in}  & {\em default} & The default value of the parameter\\
\hline
\mbox{\tt in}  & {\em static\+\_\+value} & If this parameter is static, it takes this value, which can be compared for consistency with what is in the parameter file.\\
\hline
\mbox{\tt in}  & {\em fail\+\_\+if\+\_\+missing} & If present and true, a fatal error occurs if this variable is not found in the parameter file\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged.\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files\\
\hline
\mbox{\tt in}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file\\
\hline
\mbox{\tt in}  & {\em scale} & A scaling factor that the parameter is multiplied by before it is returned.\\
\hline
\mbox{\tt out}  & {\em unscaled} & The value of the parameter that would be returned without any multiplication by a scaling factor. \\
\hline
\end{DoxyParams}


Definition at line 1723 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}
1723   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: cs\textcolor{comment}{      !< The control structure for the file\_parser module,}
1724 \textcolor{comment}{                                         !! it is also a structure to parse for run-time parameters}
1725   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}
1726   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-sensitive name of the parameter to read}
1727   \textcolor{keywordtype}{real},                       \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}
1728 \textcolor{comment}{                                         !! read from the parameter file and logged}
1729   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}
1730 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}
1731   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}
1732   \textcolor{keywordtype}{real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}
1733   \textcolor{keywordtype}{real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}
1734 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}
1735 \textcolor{comment}{                                         !! what is in the parameter file.}
1736   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}
1737 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}
1738   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}
1739 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}
1740   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}
1741 \textcolor{comment}{                                         !! parameter to the documentation files}
1742   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingparam\textcolor{comment}{ !< If present and true, this parameter is}
1743 \textcolor{comment}{                                         !! logged in the debugging parameter file}
1744   \textcolor{keywordtype}{real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: scale\textcolor{comment}{   !< A scaling factor that the parameter is}
1745 \textcolor{comment}{                                         !! multiplied by before it is returned.}
1746   \textcolor{keywordtype}{real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(out)}   :: unscaled\textcolor{comment}{ !< The value of the parameter that would be}
1747 \textcolor{comment}{                                         !! returned without any multiplication by a scaling factor.}
1748 
1749   \textcolor{keywordtype}{logical} :: do\_read, do\_log
1750 
1751   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read
1752   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log
1753 
1754   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}
1755     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default
1756     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value
1757     \textcolor{keyword}{call }read\_param\_real(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)
1758 \textcolor{keywordflow}{  endif}
1759 
1760   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}
1761     \textcolor{keyword}{call }log\_param\_real(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, units, &
1762                         default, debuggingparam)
1763 \textcolor{keywordflow}{  endif}
1764 
1765   \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(unscaled)) unscaled = \textcolor{keywordtype}{value}
1766   \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(scale)) \textcolor{keywordtype}{value} = scale*\textcolor{keywordtype}{value}
1767 
\end{DoxyCode}
\mbox{\Hypertarget{interfacemom__file__parser_1_1get__param_a3d34e9640391f0d919bb6534b104b270}\label{interfacemom__file__parser_1_1get__param_a3d34e9640391f0d919bb6534b104b270}} 
\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}!get\+\_\+param\+\_\+real\+\_\+array@{get\+\_\+param\+\_\+real\+\_\+array}}
\index{get\+\_\+param\+\_\+real\+\_\+array@{get\+\_\+param\+\_\+real\+\_\+array}!mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}
\subsubsection{\texorpdfstring{get\+\_\+param\+\_\+real\+\_\+array()}{get\_param\_real\_array()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+real\+\_\+array (\begin{DoxyParamCaption}\item[{type(\hyperlink{structmom__file__parser_1_1param__file__type}{param\+\_\+file\+\_\+type}), intent(in)}]{CS,  }\item[{character(len=$\ast$), intent(in)}]{modulename,  }\item[{character(len=$\ast$), intent(in)}]{varname,  }\item[{real, dimension(\+:), intent(inout)}]{value,  }\item[{character(len=$\ast$), intent(in), optional}]{desc,  }\item[{character(len=$\ast$), intent(in), optional}]{units,  }\item[{real, intent(in), optional}]{default,  }\item[{logical, intent(in), optional}]{fail\+\_\+if\+\_\+missing,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+read,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+log,  }\item[{logical, intent(in), optional}]{debugging\+Param,  }\item[{real, intent(in), optional}]{static\+\_\+value,  }\item[{real, intent(in), optional}]{scale,  }\item[{real, dimension(\+:), intent(out), optional}]{unscaled }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



This subroutine reads the values of an array of real model parameters from a parameter file and logs them in documentation files. 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters\\
\hline
\mbox{\tt in}  & {\em modulename} & The name of the calling module\\
\hline
\mbox{\tt in}  & {\em varname} & The case-\/sensitive name of the parameter to read\\
\hline
\mbox{\tt in,out}  & {\em value} & The value of the parameter that may be read from the parameter file and logged\\
\hline
\mbox{\tt in}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file\\
\hline
\mbox{\tt in}  & {\em units} & The units of this parameter\\
\hline
\mbox{\tt in}  & {\em default} & The default value of the parameter\\
\hline
\mbox{\tt in}  & {\em static\+\_\+value} & If this parameter is static, it takes this value, which can be compared for consistency with what is in the parameter file.\\
\hline
\mbox{\tt in}  & {\em fail\+\_\+if\+\_\+missing} & If present and true, a fatal error occurs if this variable is not found in the parameter file\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged.\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files\\
\hline
\mbox{\tt in}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file\\
\hline
\mbox{\tt in}  & {\em scale} & A scaling factor that the parameter is multiplied by before it is returned.\\
\hline
\mbox{\tt out}  & {\em unscaled} & The value of the parameter that would be returned without any multiplication by a scaling factor. \\
\hline
\end{DoxyParams}


Definition at line 1775 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}
1775   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: cs\textcolor{comment}{      !< The control structure for the file\_parser module,}
1776 \textcolor{comment}{                                         !! it is also a structure to parse for run-time parameters}
1777   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}
1778   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-sensitive name of the parameter to read}
1779   \textcolor{keywordtype}{real}, \textcolor{keywordtype}{dimension(:)},         \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}
1780 \textcolor{comment}{                                         !! read from the parameter file and logged}
1781   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}
1782 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}
1783   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}
1784   \textcolor{keywordtype}{real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}
1785   \textcolor{keywordtype}{real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}
1786 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}
1787 \textcolor{comment}{                                         !! what is in the parameter file.}
1788   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}
1789 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}
1790   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}
1791 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}
1792   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}
1793 \textcolor{comment}{                                         !! parameter to the documentation files}
1794   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingparam\textcolor{comment}{ !< If present and true, this parameter is}
1795 \textcolor{comment}{                                         !! logged in the debugging parameter file}
1796   \textcolor{keywordtype}{real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: scale\textcolor{comment}{   !< A scaling factor that the parameter is}
1797 \textcolor{comment}{                                         !! multiplied by before it is returned.}
1798   \textcolor{keywordtype}{real}, \textcolor{keywordtype}{dimension(:)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(out)} :: unscaled\textcolor{comment}{ !< The value of the parameter that would be}
1799 \textcolor{comment}{                                         !! returned without any multiplication by a scaling factor.}
1800 
1801   \textcolor{keywordtype}{logical} :: do\_read, do\_log
1802 
1803   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read
1804   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log
1805 
1806   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}
1807     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordflow}{then} ; value(:) = default ;\textcolor{keywordflow}{ endif}
1808     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordflow}{then} ; value(:) = static\_value ;\textcolor{keywordflow}{ endif}
1809     \textcolor{keyword}{call }read\_param\_real\_array(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)
1810 \textcolor{keywordflow}{  endif}
1811 
1812   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}
1813     \textcolor{keyword}{call }log\_param\_real\_array(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, &
1814                               units, default, debuggingparam)
1815 \textcolor{keywordflow}{  endif}
1816 
1817   \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(unscaled)) unscaled(:) = value(:)
1818   \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(scale)) value(:) = scale*value(:)
1819 
\end{DoxyCode}
\mbox{\Hypertarget{interfacemom__file__parser_1_1get__param_a11cd2c3771b40e03d240d0b84fb25913}\label{interfacemom__file__parser_1_1get__param_a11cd2c3771b40e03d240d0b84fb25913}} 
\index{mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}!get\+\_\+param\+\_\+time@{get\+\_\+param\+\_\+time}}
\index{get\+\_\+param\+\_\+time@{get\+\_\+param\+\_\+time}!mom\+\_\+file\+\_\+parser\+::get\+\_\+param@{mom\+\_\+file\+\_\+parser\+::get\+\_\+param}}
\subsubsection{\texorpdfstring{get\+\_\+param\+\_\+time()}{get\_param\_time()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+time (\begin{DoxyParamCaption}\item[{type(\hyperlink{structmom__file__parser_1_1param__file__type}{param\+\_\+file\+\_\+type}), intent(in)}]{CS,  }\item[{character(len=$\ast$), intent(in)}]{modulename,  }\item[{character(len=$\ast$), intent(in)}]{varname,  }\item[{type(time\+\_\+type), intent(inout)}]{value,  }\item[{character(len=$\ast$), intent(in), optional}]{desc,  }\item[{character(len=$\ast$), intent(in), optional}]{units,  }\item[{type(time\+\_\+type), intent(in), optional}]{default,  }\item[{logical, intent(in), optional}]{fail\+\_\+if\+\_\+missing,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+read,  }\item[{logical, intent(in), optional}]{do\+\_\+not\+\_\+log,  }\item[{real, intent(in), optional}]{timeunit,  }\item[{type(time\+\_\+type), intent(in), optional}]{static\+\_\+value,  }\item[{logical, intent(in), optional}]{layout\+Param,  }\item[{logical, intent(in), optional}]{debugging\+Param,  }\item[{logical, intent(in), optional}]{log\+\_\+as\+\_\+date }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [private]}}



This subroutine reads the value of a time-\/type model parameter from a parameter file and logs it in documentation files. 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters\\
\hline
\mbox{\tt in}  & {\em modulename} & The name of the calling module\\
\hline
\mbox{\tt in}  & {\em varname} & The case-\/sensitive name of the parameter to read\\
\hline
\mbox{\tt in,out}  & {\em value} & The value of the parameter that may be read from the parameter file and logged\\
\hline
\mbox{\tt in}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file\\
\hline
\mbox{\tt in}  & {\em units} & The units of this parameter\\
\hline
\mbox{\tt in}  & {\em default} & The default value of the parameter\\
\hline
\mbox{\tt in}  & {\em static\+\_\+value} & If this parameter is static, it takes this value, which can be compared for consistency with what is in the parameter file.\\
\hline
\mbox{\tt in}  & {\em fail\+\_\+if\+\_\+missing} & If present and true, a fatal error occurs if this variable is not found in the parameter file\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged.\\
\hline
\mbox{\tt in}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files\\
\hline
\mbox{\tt in}  & {\em timeunit} & The number of seconds in a time unit for real-\/number input to be translated to a time.\\
\hline
\mbox{\tt in}  & {\em layoutparam} & If present and true, this parameter is logged in the layout parameter file\\
\hline
\mbox{\tt in}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file\\
\hline
\mbox{\tt in}  & {\em log\+\_\+as\+\_\+date} & If true, log the time\+\_\+type in date format. The default is false. \\
\hline
\end{DoxyParams}


Definition at line 1975 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}
1975   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: cs\textcolor{comment}{      !< The control structure for the file\_parser module,}
1976 \textcolor{comment}{                                         !! it is also a structure to parse for run-time parameters}
1977   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}
1978   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-sensitive name of the parameter to read}
1979   \textcolor{keywordtype}{type}(time\_type),            \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}
1980 \textcolor{comment}{                                         !! read from the parameter file and logged}
1981   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}
1982 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}
1983   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}
1984   \textcolor{keywordtype}{type}(time\_type),  \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}
1985   \textcolor{keywordtype}{type}(time\_type),  \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}
1986 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}
1987 \textcolor{comment}{                                         !! what is in the parameter file.}
1988   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}
1989 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}
1990   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}
1991 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}
1992   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}
1993 \textcolor{comment}{                                         !! parameter to the documentation files}
1994   \textcolor{keywordtype}{real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: timeunit\textcolor{comment}{ !< The number of seconds in a time unit for}
1995 \textcolor{comment}{                                         !! real-number input to be translated to a time.}
1996   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: layoutparam\textcolor{comment}{ !< If present and true, this parameter is}
1997 \textcolor{comment}{                                         !! logged in the layout parameter file}
1998   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingparam\textcolor{comment}{ !< If present and true, this parameter is}
1999 \textcolor{comment}{                                         !! logged in the debugging parameter file}
2000   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: log\_as\_date\textcolor{comment}{  !< If true, log the time\_type in date}
2001 \textcolor{comment}{                                         !! format. The default is false.}
2002 
2003   \textcolor{keywordtype}{logical} :: do\_read, do\_log, date\_format, log\_date
2004 
2005   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read
2006   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log
2007   log\_date = .false.
2008 
2009   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}
2010     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default
2011     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value
2012     \textcolor{keyword}{call }read\_param\_time(cs, varname, \textcolor{keywordtype}{value}, timeunit, fail\_if\_missing, date\_format=log\_date)
2013 \textcolor{keywordflow}{  endif}
2014 
2015   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}
2016     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(log\_as\_date)) log\_date = log\_as\_date
2017     \textcolor{keyword}{call }log\_param\_time(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, units, default, &
2018                         timeunit, layoutparam=layoutparam, &
2019                         debuggingparam=debuggingparam, log\_date=log\_date)
2020 \textcolor{keywordflow}{  endif}
2021 
\end{DoxyCode}


The documentation for this interface was generated from the following file\+:\begin{DoxyCompactItemize}
\item 
/home/cermak/src/\+M\+O\+M6.\+devrob/src/framework/M\+O\+M\+\_\+file\+\_\+parser.\+F90\end{DoxyCompactItemize}
