\hypertarget{interfacemom__file__parser_1_1get__param}{}\doxysection{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}}


\doxysubsection{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.

\doxysubsection*{Private functions}
\begin{DoxyCompactItemize}
\item 
subroutine \mbox{\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 \mbox{\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 \mbox{\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 \mbox{\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 \mbox{\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 \mbox{\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 \mbox{\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 \mbox{\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}


\doxysubsection{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.



\doxysubsection{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}}
\doxysubsubsection{\texorpdfstring{get\_param\_char()}{get\_param\_char()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+char (\begin{DoxyParamCaption}\item[{type(\mbox{\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{\texttt{ in}}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters \\
\hline
\mbox{\texttt{ in}}  & {\em modulename} & The name of the calling module \\
\hline
\mbox{\texttt{ in}}  & {\em varname} & The case-\/sensitive name of the parameter to read \\
\hline
\mbox{\texttt{ in,out}}  & {\em value} & The value of the parameter that may be read from the parameter file and logged \\
\hline
\mbox{\texttt{ in}}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file \\
\hline
\mbox{\texttt{ in}}  & {\em units} & The units of this parameter \\
\hline
\mbox{\texttt{ in}}  & {\em default} & The default value of the parameter \\
\hline
\mbox{\texttt{ 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{\texttt{ 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{\texttt{ in}}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged. \\
\hline
\mbox{\texttt{ in}}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files \\
\hline
\mbox{\texttt{ in}}  & {\em layoutparam} & If present and true, this parameter is logged in the layout parameter file \\
\hline
\mbox{\texttt{ in}}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file \\
\hline
\end{DoxyParams}


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


\begin{DoxyCode}{0}
\DoxyCodeLine{1827   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: CS\textcolor{comment}{      !< The control structure for the file\_parser module,}}
\DoxyCodeLine{1828 \textcolor{comment}{                                         !! it is also a structure to parse for run-\/time parameters}}
\DoxyCodeLine{1829   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}}
\DoxyCodeLine{1830   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-\/sensitive name of the parameter to read}}
\DoxyCodeLine{1831   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}}
\DoxyCodeLine{1832 \textcolor{comment}{                                         !! read from the parameter file and logged}}
\DoxyCodeLine{1833   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}}
\DoxyCodeLine{1834 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}}
\DoxyCodeLine{1835   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}}
\DoxyCodeLine{1836   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}}
\DoxyCodeLine{1837   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}}
\DoxyCodeLine{1838 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}}
\DoxyCodeLine{1839 \textcolor{comment}{                                         !! what is in the parameter file.}}
\DoxyCodeLine{1840   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}}
\DoxyCodeLine{1841 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}}
\DoxyCodeLine{1842   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}}
\DoxyCodeLine{1843 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}}
\DoxyCodeLine{1844   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}}
\DoxyCodeLine{1845 \textcolor{comment}{                                         !! parameter to the documentation files}}
\DoxyCodeLine{1846   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: layoutParam\textcolor{comment}{ !< If present and true, this parameter is}}
\DoxyCodeLine{1847 \textcolor{comment}{                                         !! logged in the layout parameter file}}
\DoxyCodeLine{1848   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingParam\textcolor{comment}{ !< If present and true, this parameter is}}
\DoxyCodeLine{1849 \textcolor{comment}{                                         !! logged in the debugging parameter file}}
\DoxyCodeLine{1850 }
\DoxyCodeLine{1851   \textcolor{keywordtype}{logical} :: do\_read, do\_log}
\DoxyCodeLine{1852 }
\DoxyCodeLine{1853   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read}
\DoxyCodeLine{1854   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log}
\DoxyCodeLine{1855 }
\DoxyCodeLine{1856   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}}
\DoxyCodeLine{1857     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default}
\DoxyCodeLine{1858     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value}
\DoxyCodeLine{1859     \textcolor{keyword}{call }read\_param\_char(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)}
\DoxyCodeLine{1860 \textcolor{keywordflow}{  endif}}
\DoxyCodeLine{1861 }
\DoxyCodeLine{1862   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}}
\DoxyCodeLine{1863     \textcolor{keyword}{call }log\_param\_char(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, units, \&}
\DoxyCodeLine{1864                         default, layoutparam, debuggingparam)}
\DoxyCodeLine{1865 \textcolor{keywordflow}{  endif}}
\DoxyCodeLine{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}}
\doxysubsubsection{\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(\mbox{\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{\texttt{ in}}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters \\
\hline
\mbox{\texttt{ in}}  & {\em modulename} & The name of the calling module \\
\hline
\mbox{\texttt{ in}}  & {\em varname} & The case-\/sensitive name of the parameter to read \\
\hline
\mbox{\texttt{ in,out}}  & {\em value} & The value of the parameter that may be read from the parameter file and logged \\
\hline
\mbox{\texttt{ in}}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file \\
\hline
\mbox{\texttt{ in}}  & {\em units} & The units of this parameter \\
\hline
\mbox{\texttt{ in}}  & {\em default} & The default value of the parameter \\
\hline
\mbox{\texttt{ 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{\texttt{ 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{\texttt{ in}}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged. \\
\hline
\mbox{\texttt{ in}}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files \\
\hline
\end{DoxyParams}


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


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


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


\begin{DoxyCode}{0}
\DoxyCodeLine{1629   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: CS\textcolor{comment}{      !< The control structure for the file\_parser module,}}
\DoxyCodeLine{1630 \textcolor{comment}{                                         !! it is also a structure to parse for run-\/time parameters}}
\DoxyCodeLine{1631   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}}
\DoxyCodeLine{1632   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-\/sensitive name of the parameter to read}}
\DoxyCodeLine{1633   \textcolor{keywordtype}{integer},                    \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}}
\DoxyCodeLine{1634 \textcolor{comment}{                                         !! read from the parameter file and logged}}
\DoxyCodeLine{1635   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}}
\DoxyCodeLine{1636 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}}
\DoxyCodeLine{1637   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}}
\DoxyCodeLine{1638   \textcolor{keywordtype}{integer},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}}
\DoxyCodeLine{1639   \textcolor{keywordtype}{integer},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}}
\DoxyCodeLine{1640 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}}
\DoxyCodeLine{1641 \textcolor{comment}{                                         !! what is in the parameter file.}}
\DoxyCodeLine{1642   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}}
\DoxyCodeLine{1643 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}}
\DoxyCodeLine{1644   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}}
\DoxyCodeLine{1645 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}}
\DoxyCodeLine{1646   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}}
\DoxyCodeLine{1647 \textcolor{comment}{                                         !! parameter to the documentation files}}
\DoxyCodeLine{1648   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: layoutParam\textcolor{comment}{ !< If present and true, this parameter is}}
\DoxyCodeLine{1649 \textcolor{comment}{                                         !! logged in the layout parameter file}}
\DoxyCodeLine{1650   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingParam\textcolor{comment}{ !< If present and true, this parameter is}}
\DoxyCodeLine{1651 \textcolor{comment}{                                         !! logged in the debugging parameter file}}
\DoxyCodeLine{1652 }
\DoxyCodeLine{1653   \textcolor{keywordtype}{logical} :: do\_read, do\_log}
\DoxyCodeLine{1654 }
\DoxyCodeLine{1655   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read}
\DoxyCodeLine{1656   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log}
\DoxyCodeLine{1657 }
\DoxyCodeLine{1658   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}}
\DoxyCodeLine{1659     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default}
\DoxyCodeLine{1660     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value}
\DoxyCodeLine{1661     \textcolor{keyword}{call }read\_param\_int(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)}
\DoxyCodeLine{1662 \textcolor{keywordflow}{  endif}}
\DoxyCodeLine{1663 }
\DoxyCodeLine{1664   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}}
\DoxyCodeLine{1665     \textcolor{keyword}{call }log\_param\_int(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, units, \&}
\DoxyCodeLine{1666                        default, layoutparam, debuggingparam)}
\DoxyCodeLine{1667 \textcolor{keywordflow}{  endif}}
\DoxyCodeLine{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}}
\doxysubsubsection{\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(\mbox{\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{\texttt{ in}}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters \\
\hline
\mbox{\texttt{ in}}  & {\em modulename} & The name of the calling module \\
\hline
\mbox{\texttt{ in}}  & {\em varname} & The case-\/sensitive name of the parameter to read \\
\hline
\mbox{\texttt{ in,out}}  & {\em value} & The value of the parameter that may be reset from the parameter file \\
\hline
\mbox{\texttt{ in}}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file \\
\hline
\mbox{\texttt{ in}}  & {\em units} & The units of this parameter \\
\hline
\mbox{\texttt{ in}}  & {\em default} & The default value of the parameter \\
\hline
\mbox{\texttt{ 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{\texttt{ 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{\texttt{ in}}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged. \\
\hline
\mbox{\texttt{ in}}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files \\
\hline
\mbox{\texttt{ in}}  & {\em layoutparam} & If present and true, this parameter is logged in the layout parameter file \\
\hline
\mbox{\texttt{ in}}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file \\
\hline
\end{DoxyParams}


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


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


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


\begin{DoxyCode}{0}
\DoxyCodeLine{1927   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: CS\textcolor{comment}{      !< The control structure for the file\_parser module,}}
\DoxyCodeLine{1928 \textcolor{comment}{                                         !! it is also a structure to parse for run-\/time parameters}}
\DoxyCodeLine{1929   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}}
\DoxyCodeLine{1930   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-\/sensitive name of the parameter to read}}
\DoxyCodeLine{1931   \textcolor{keywordtype}{logical},                    \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}}
\DoxyCodeLine{1932 \textcolor{comment}{                                         !! read from the parameter file and logged}}
\DoxyCodeLine{1933   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}}
\DoxyCodeLine{1934 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}}
\DoxyCodeLine{1935   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}}
\DoxyCodeLine{1936   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}}
\DoxyCodeLine{1937   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}}
\DoxyCodeLine{1938 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}}
\DoxyCodeLine{1939 \textcolor{comment}{                                         !! what is in the parameter file.}}
\DoxyCodeLine{1940   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}}
\DoxyCodeLine{1941 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}}
\DoxyCodeLine{1942   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}}
\DoxyCodeLine{1943 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}}
\DoxyCodeLine{1944   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}}
\DoxyCodeLine{1945 \textcolor{comment}{                                         !! parameter to the documentation files}}
\DoxyCodeLine{1946   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: layoutParam\textcolor{comment}{ !< If present and true, this parameter is}}
\DoxyCodeLine{1947 \textcolor{comment}{                                         !! logged in the layout parameter file}}
\DoxyCodeLine{1948   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingParam\textcolor{comment}{ !< If present and true, this parameter is}}
\DoxyCodeLine{1949 \textcolor{comment}{                                         !! logged in the debugging parameter file}}
\DoxyCodeLine{1950 }
\DoxyCodeLine{1951   \textcolor{keywordtype}{logical} :: do\_read, do\_log}
\DoxyCodeLine{1952 }
\DoxyCodeLine{1953   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read}
\DoxyCodeLine{1954   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log}
\DoxyCodeLine{1955 }
\DoxyCodeLine{1956   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}}
\DoxyCodeLine{1957     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default}
\DoxyCodeLine{1958     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value}
\DoxyCodeLine{1959     \textcolor{keyword}{call }read\_param\_logical(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)}
\DoxyCodeLine{1960 \textcolor{keywordflow}{  endif}}
\DoxyCodeLine{1961 }
\DoxyCodeLine{1962   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}}
\DoxyCodeLine{1963     \textcolor{keyword}{call }log\_param\_logical(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, \&}
\DoxyCodeLine{1964                            units, default, layoutparam, debuggingparam)}
\DoxyCodeLine{1965 \textcolor{keywordflow}{  endif}}
\DoxyCodeLine{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}}
\doxysubsubsection{\texorpdfstring{get\_param\_real()}{get\_param\_real()}}
{\footnotesize\ttfamily subroutine mom\+\_\+file\+\_\+parser\+::get\+\_\+param\+::get\+\_\+param\+\_\+real (\begin{DoxyParamCaption}\item[{type(\mbox{\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{\texttt{ in}}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters \\
\hline
\mbox{\texttt{ in}}  & {\em modulename} & The name of the calling module \\
\hline
\mbox{\texttt{ in}}  & {\em varname} & The case-\/sensitive name of the parameter to read \\
\hline
\mbox{\texttt{ in,out}}  & {\em value} & The value of the parameter that may be read from the parameter file and logged \\
\hline
\mbox{\texttt{ in}}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file \\
\hline
\mbox{\texttt{ in}}  & {\em units} & The units of this parameter \\
\hline
\mbox{\texttt{ in}}  & {\em default} & The default value of the parameter \\
\hline
\mbox{\texttt{ 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{\texttt{ 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{\texttt{ in}}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged. \\
\hline
\mbox{\texttt{ in}}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files \\
\hline
\mbox{\texttt{ in}}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file \\
\hline
\mbox{\texttt{ in}}  & {\em scale} & A scaling factor that the parameter is multiplied by before it is returned. \\
\hline
\mbox{\texttt{ 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 1720 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


\begin{DoxyCode}{0}
\DoxyCodeLine{1723   \textcolor{keywordtype}{type}(param\_file\_type),      \textcolor{keywordtype}{intent(in)}    :: CS\textcolor{comment}{      !< The control structure for the file\_parser module,}}
\DoxyCodeLine{1724 \textcolor{comment}{                                         !! it is also a structure to parse for run-\/time parameters}}
\DoxyCodeLine{1725   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: modulename\textcolor{comment}{ !< The name of the calling module}}
\DoxyCodeLine{1726   \textcolor{keywordtype}{character(len=*)},           \textcolor{keywordtype}{intent(in)}    :: varname\textcolor{comment}{ !< The case-\/sensitive name of the parameter to read}}
\DoxyCodeLine{1727 \textcolor{keywordtype}{  real},                       \textcolor{keywordtype}{intent(inout)} :: \textcolor{keywordtype}{value}\textcolor{comment}{   !< The value of the parameter that may be}}
\DoxyCodeLine{1728 \textcolor{comment}{                                         !! read from the parameter file and logged}}
\DoxyCodeLine{1729   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: desc\textcolor{comment}{    !< A description of this variable; if not}}
\DoxyCodeLine{1730 \textcolor{comment}{                                         !! present, this parameter is not written to a doc file}}
\DoxyCodeLine{1731   \textcolor{keywordtype}{character(len=*)}, \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: units\textcolor{comment}{   !< The units of this parameter}}
\DoxyCodeLine{1732 \textcolor{keywordtype}{  real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: default\textcolor{comment}{ !< The default value of the parameter}}
\DoxyCodeLine{1733 \textcolor{keywordtype}{  real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: static\_value\textcolor{comment}{ !< If this parameter is static, it takes}}
\DoxyCodeLine{1734 \textcolor{comment}{                                         !! this value, which can be compared for consistency with}}
\DoxyCodeLine{1735 \textcolor{comment}{                                         !! what is in the parameter file.}}
\DoxyCodeLine{1736   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: fail\_if\_missing\textcolor{comment}{ !< If present and true, a fatal error occurs}}
\DoxyCodeLine{1737 \textcolor{comment}{                                         !! if this variable is not found in the parameter file}}
\DoxyCodeLine{1738   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_read\textcolor{comment}{  !< If present and true, do not read a}}
\DoxyCodeLine{1739 \textcolor{comment}{                                         !! value for this parameter, although it might be logged.}}
\DoxyCodeLine{1740   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: do\_not\_log\textcolor{comment}{ !< If present and true, do not log this}}
\DoxyCodeLine{1741 \textcolor{comment}{                                         !! parameter to the documentation files}}
\DoxyCodeLine{1742   \textcolor{keywordtype}{logical},          \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: debuggingParam\textcolor{comment}{ !< If present and true, this parameter is}}
\DoxyCodeLine{1743 \textcolor{comment}{                                         !! logged in the debugging parameter file}}
\DoxyCodeLine{1744 \textcolor{keywordtype}{  real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(in)}    :: scale\textcolor{comment}{   !< A scaling factor that the parameter is}}
\DoxyCodeLine{1745 \textcolor{comment}{                                         !! multiplied by before it is returned.}}
\DoxyCodeLine{1746 \textcolor{keywordtype}{  real},             \textcolor{keywordtype}{optional}, \textcolor{keywordtype}{intent(out)}   :: unscaled\textcolor{comment}{ !< The value of the parameter that would be}}
\DoxyCodeLine{1747 \textcolor{comment}{                                         !! returned without any multiplication by a scaling factor.}}
\DoxyCodeLine{1748 }
\DoxyCodeLine{1749   \textcolor{keywordtype}{logical} :: do\_read, do\_log}
\DoxyCodeLine{1750 }
\DoxyCodeLine{1751   do\_read = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_read)) do\_read = .not.do\_not\_read}
\DoxyCodeLine{1752   do\_log  = .true. ; \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(do\_not\_log))  do\_log  = .not.do\_not\_log}
\DoxyCodeLine{1753 }
\DoxyCodeLine{1754   \textcolor{keywordflow}{if} (do\_read) \textcolor{keywordflow}{then}}
\DoxyCodeLine{1755     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(default)) \textcolor{keywordtype}{value} = default}
\DoxyCodeLine{1756     \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(static\_value)) \textcolor{keywordtype}{value} = static\_value}
\DoxyCodeLine{1757     \textcolor{keyword}{call }read\_param\_real(cs, varname, \textcolor{keywordtype}{value}, fail\_if\_missing)}
\DoxyCodeLine{1758 \textcolor{keywordflow}{  endif}}
\DoxyCodeLine{1759 }
\DoxyCodeLine{1760   \textcolor{keywordflow}{if} (do\_log) \textcolor{keywordflow}{then}}
\DoxyCodeLine{1761     \textcolor{keyword}{call }log\_param\_real(cs, modulename, varname, \textcolor{keywordtype}{value}, desc, units, \&}
\DoxyCodeLine{1762                         default, debuggingparam)}
\DoxyCodeLine{1763 \textcolor{keywordflow}{  endif}}
\DoxyCodeLine{1764 }
\DoxyCodeLine{1765   \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(unscaled)) unscaled = \textcolor{keywordtype}{value}}
\DoxyCodeLine{1766   \textcolor{keywordflow}{if} (\textcolor{keyword}{present}(scale)) \textcolor{keywordtype}{value} = scale*\textcolor{keywordtype}{value}}
\DoxyCodeLine{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}}
\doxysubsubsection{\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(\mbox{\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{\texttt{ in}}  & {\em cs} & The control structure for the file\+\_\+parser module, it is also a structure to parse for run-\/time parameters \\
\hline
\mbox{\texttt{ in}}  & {\em modulename} & The name of the calling module \\
\hline
\mbox{\texttt{ in}}  & {\em varname} & The case-\/sensitive name of the parameter to read \\
\hline
\mbox{\texttt{ in,out}}  & {\em value} & The value of the parameter that may be read from the parameter file and logged \\
\hline
\mbox{\texttt{ in}}  & {\em desc} & A description of this variable; if not present, this parameter is not written to a doc file \\
\hline
\mbox{\texttt{ in}}  & {\em units} & The units of this parameter \\
\hline
\mbox{\texttt{ in}}  & {\em default} & The default value of the parameter \\
\hline
\mbox{\texttt{ 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{\texttt{ 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{\texttt{ in}}  & {\em do\+\_\+not\+\_\+read} & If present and true, do not read a value for this parameter, although it might be logged. \\
\hline
\mbox{\texttt{ in}}  & {\em do\+\_\+not\+\_\+log} & If present and true, do not log this parameter to the documentation files \\
\hline
\mbox{\texttt{ in}}  & {\em debuggingparam} & If present and true, this parameter is logged in the debugging parameter file \\
\hline
\mbox{\texttt{ in}}  & {\em scale} & A scaling factor that the parameter is multiplied by before it is returned. \\
\hline
\mbox{\texttt{ 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 1772 of file M\+O\+M\+\_\+file\+\_\+parser.\+F90.


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


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


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