added/updated doxygen comments

Applications/ApplicationsLib/ProjectData.cpp

@@ -263,12 +263,13 @@ void ProjectData::parseProcesses(BaseLib::ConfigTree const& processes_config,
         //! \ogs_file_param{process__type}
         auto const type = process_config.peekConfigParameter<std::string>("type");
 
-        //! \ogs_file_param{process__type}
+        //! \ogs_file_param{process__name}
         auto const name = process_config.getConfigParameter<std::string>("name");
 
         std::unique_ptr<ProcessLib::Process> process;
 
         auto jacobian_assembler = ProcessLib::createJacobianAssembler(
+            //! \ogs_file_param{process__jacobian_assembler}
             process_config.getConfigSubtreeOptional("jacobian_assembler"));
 
         if (type == "GROUNDWATER_FLOW")
@@ -297,6 +298,7 @@ void ProjectData::parseProcesses(BaseLib::ConfigTree const& processes_config,
         }
         else if (type == "SMALL_DEFORMATION")
         {
+            //! \ogs_file_param{process__SMALL_DEFORMATION__dimension}
             switch (process_config.getConfigParameter<int>("dimension"))
             {
                 case 2:

MaterialLib/SolidModels/CreateLinearElasticIsotropic.h

@@ -24,17 +24,20 @@ createLinearElasticIsotropic(
     std::vector<std::unique_ptr<ProcessLib::ParameterBase>> const& parameters,
     BaseLib::ConfigTree const& config)
 {
+    //! \ogs_file_param{process__SMALL_DEFORMATION__constitutive_relation__type}
     config.checkConfigParameter("type", "LinearElasticIsotropic");
     DBUG("Create LinearElasticIsotropic material");
 
     // Youngs modulus
     auto& youngs_modulus = ProcessLib::findParameter<double>(
+        //! \ogs_file_param_special{process__SMALL_DEFORMATION__constitutive_relation__LinearElasticIsotropic__youngs_modulus}
         config, "youngs_modulus", parameters, 1);
 
     DBUG("Use '%s' as youngs_modulus parameter.", youngs_modulus.name.c_str());
 
     // Poissons ratio
     auto& poissons_ratio = ProcessLib::findParameter<double>(
+        //! \ogs_file_param_special{process__SMALL_DEFORMATION__constitutive_relation__LinearElasticIsotropic__poissons_ratio}
         config, "poissons_ratio", parameters, 1);
 
     DBUG("Use '%s' as poissons_ratio parameter.", poissons_ratio.name.c_str());

NumLib/ODESolver/ConvergenceCriterion.cpp

@@ -21,7 +21,7 @@ namespace NumLib
 std::unique_ptr<ConvergenceCriterion> createConvergenceCriterion(
     const BaseLib::ConfigTree& config)
 {
-    //! \ogs_file_param{process__convergence_criterion__type}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__type}
     auto const type = config.peekConfigParameter<std::string>("type");
 
     if (type == "DeltaX") {

NumLib/ODESolver/ConvergenceCriterionDeltaX.cpp

@@ -54,15 +54,15 @@ void ConvergenceCriterionDeltaX::checkDeltaX(const GlobalVector& minus_delta_x,
 std::unique_ptr<ConvergenceCriterionDeltaX> createConvergenceCriterionDeltaX(
     const BaseLib::ConfigTree& config)
 {
-    //! \ogs_file_param{process__convergence_criterion__type}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__type}
     config.checkConfigParameter("type", "DeltaX");
 
-    //! \ogs_file_param{process__convergence_criterion__DeltaX__abstol}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__DeltaX__abstol}
     auto abstol = config.getConfigParameterOptional<double>("abstol");
-    //! \ogs_file_param{process__convergence_criterion__DeltaX__reltol}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__DeltaX__reltol}
     auto reltol = config.getConfigParameterOptional<double>("reltol");
     auto const norm_type_str =
-        //! \ogs_file_param{process__convergence_criterion__DeltaX__norm_type}
+        //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__DeltaX__norm_type}
         config.getConfigParameter<std::string>("norm_type");
     auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
 

NumLib/ODESolver/ConvergenceCriterionPerComponentDeltaX.cpp

@@ -80,17 +80,17 @@ void ConvergenceCriterionPerComponentDeltaX::setDOFTable(
 std::unique_ptr<ConvergenceCriterionPerComponentDeltaX>
 createConvergenceCriterionPerComponentDeltaX(const BaseLib::ConfigTree& config)
 {
-    //! \ogs_file_param{process__convergence_criterion__type}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__type}
     config.checkConfigParameter("type", "PerComponentDeltaX");
 
     auto abstols =
-        //! \ogs_file_param{process__convergence_criterion__PerComponentDeltaX__abstols}
+        //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__abstols}
         config.getConfigParameterOptional<std::vector<double>>("abstols");
     auto reltols =
-        //! \ogs_file_param{process__convergence_criterion__PerComponentDeltaX__reltols}
+        //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__reltols}
         config.getConfigParameterOptional<std::vector<double>>("reltols");
     auto const norm_type_str =
-        //! \ogs_file_param{process__convergence_criterion__PerComponentDeltaX__norm_type}
+        //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__PerComponentDeltaX__norm_type}
         config.getConfigParameter<std::string>("norm_type");
 
     if ((!abstols) && (!reltols))

NumLib/ODESolver/ConvergenceCriterionPerComponentResidual.cpp

@@ -90,17 +90,17 @@ std::unique_ptr<ConvergenceCriterionPerComponentResidual>
 createConvergenceCriterionPerComponentResidual(
     const BaseLib::ConfigTree& config)
 {
-    //! \ogs_file_param{process__convergence_criterion__type}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__type}
     config.checkConfigParameter("type", "PerComponentResidual");
 
     auto abstols =
-        //! \ogs_file_param{process__convergence_criterion__PerComponentResidual__abstols}
+        //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__abstols}
         config.getConfigParameterOptional<std::vector<double>>("abstols");
     auto reltols =
-        //! \ogs_file_param{process__convergence_criterion__PerComponentResidual__reltols}
+        //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__reltols}
         config.getConfigParameterOptional<std::vector<double>>("reltols");
     auto const norm_type_str =
-        //! \ogs_file_param{process__convergence_criterion__PerComponentResidual__norm_type}
+        //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__PerComponentResidual__norm_type}
         config.getConfigParameter<std::string>("norm_type");
 
     if ((!abstols) && (!reltols))

NumLib/ODESolver/ConvergenceCriterionResidual.cpp

@@ -58,15 +58,15 @@ void ConvergenceCriterionResidual::checkResidual(const GlobalVector& residual)
 std::unique_ptr<ConvergenceCriterionResidual>
 createConvergenceCriterionResidual(const BaseLib::ConfigTree& config)
 {
-    //! \ogs_file_param{process__convergence_criterion__type}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__type}
     config.checkConfigParameter("type", "Residual");
 
-    //! \ogs_file_param{process__convergence_criterion__Residual__abstol}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__Residual__abstol}
     auto abstol = config.getConfigParameterOptional<double>("abstol");
-    //! \ogs_file_param{process__convergence_criterion__Residual__reltol}
+    //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__Residual__reltol}
     auto reltol = config.getConfigParameterOptional<double>("reltol");
     auto const norm_type_str =
-        //! \ogs_file_param{process__convergence_criterion__Residual__norm_type}
+        //! \ogs_file_param{prj__time_loop__processes__process__convergence_criterion__Residual__norm_type}
         config.getConfigParameter<std::string>("norm_type");
     auto const norm_type = MathLib::convertStringToVecNormType(norm_type_str);
 

NumLib/ODESolver/TimeDiscretizationBuilder.cpp

@@ -18,31 +18,31 @@ std::unique_ptr<TimeDiscretization> createTimeDiscretization(
 {
     using T = std::unique_ptr<TimeDiscretization>;
 
-    //! \ogs_file_param{process__time_discretization__type}
+    //! \ogs_file_param{prj__time_loop__processes__process__time_discretization__type}
     auto const type = config.getConfigParameter<std::string>("type");
 
     if (type == "BackwardEuler")
     {
-        //! \ogs_file_param_special{process__time_discretization__BackwardEuler}
+        //! \ogs_file_param_special{prj__time_loop__processes__process__time_discretization__BackwardEuler}
         using ConcreteTD = BackwardEuler;
         return T(new ConcreteTD);
     }
     else if (type == "ForwardEuler")
     {
-        //! \ogs_file_param_special{process__time_discretization__ForwardEuler}
+        //! \ogs_file_param_special{prj__time_loop__processes__process__time_discretization__ForwardEuler}
         using ConcreteTD = ForwardEuler;
         return T(new ConcreteTD);
     }
     else if (type == "CrankNicolson")
     {
-        //! \ogs_file_param{process__time_discretization__CrankNicolson__theta}
+        //! \ogs_file_param{prj__time_loop__processes__process__time_discretization__CrankNicolson__theta}
         auto const theta = config.getConfigParameter<double>("theta");
         using ConcreteTD = CrankNicolson;
         return T(new ConcreteTD(theta));
     }
     else if (type == "BackwardDifferentiationFormula")
     {
-        //! \ogs_file_param{process__time_discretization__BackwardDifferentiationFormula__order}
+        //! \ogs_file_param{prj__time_loop__processes__process__time_discretization__BackwardDifferentiationFormula__order}
         auto const order = config.getConfigParameter<unsigned>("order");
         using ConcreteTD = BackwardDifferentiationFormula;
         return T(new ConcreteTD(order));

NumLib/TimeStepping/Algorithms/FixedTimeStepping.cpp

@@ -36,14 +36,14 @@ FixedTimeStepping::FixedTimeStepping(double t0, double tn, double dt)
 std::unique_ptr<ITimeStepAlgorithm>
 FixedTimeStepping::newInstance(BaseLib::ConfigTree const& config)
 {
-    //! \ogs_file_param{prj__time_stepping__type}
+    //! \ogs_file_param{prj__time_loop__time_stepping__type}
     config.checkConfigParameter("type", "FixedTimeStepping");
 
-    //! \ogs_file_param{prj__time_stepping__FixedTimeStepping__t_initial}
+    //! \ogs_file_param{prj__time_loop__time_stepping__FixedTimeStepping__t_initial}
     auto const t_initial = config.getConfigParameter<double>("t_initial");
-    //! \ogs_file_param{prj__time_stepping__FixedTimeStepping__t_end}
+    //! \ogs_file_param{prj__time_loop__time_stepping__FixedTimeStepping__t_end}
     auto const t_end     = config.getConfigParameter<double>("t_end");
-    //! \ogs_file_param{prj__time_stepping__FixedTimeStepping__timesteps}
+    //! \ogs_file_param{prj__time_loop__time_stepping__FixedTimeStepping__timesteps}
     auto const delta_ts  = config.getConfigSubtree("timesteps");
 
     std::vector<double> timesteps;
@@ -51,16 +51,16 @@ FixedTimeStepping::newInstance(BaseLib::ConfigTree const& config)
     double delta_t = 0.0;
 
     // TODO: consider adding call "listNonEmpty" to config tree
-    //! \ogs_file_param{prj__time_stepping__FixedTimeStepping__timesteps__pair}
+    //! \ogs_file_param{prj__time_loop__time_stepping__FixedTimeStepping__timesteps__pair}
     auto const range = delta_ts.getConfigSubtreeList("pair");
     if (range.begin() == range.end()) {
         OGS_FATAL("no timesteps have been given");
     }
     for (auto const pair : range)
     {
-        //! \ogs_file_param{prj__time_stepping__FixedTimeStepping__timesteps__pair__repeat}
+        //! \ogs_file_param{prj__time_loop__time_stepping__FixedTimeStepping__timesteps__pair__repeat}
         auto const repeat = pair.getConfigParameter<std::size_t>("repeat");
-        //! \ogs_file_param{prj__time_stepping__FixedTimeStepping__timesteps__pair__delta_t}
+        //! \ogs_file_param{prj__time_loop__time_stepping__FixedTimeStepping__timesteps__pair__delta_t}
         delta_t           = pair.getConfigParameter<double>("delta_t");
 
         if (repeat == 0) {

ProcessLib/CalculateSurfaceFlux/ParseCalculateSurfaceFluxData.cpp

@@ -23,14 +23,14 @@ void parseCalculateSurfaceFluxData(BaseLib::ConfigTree const& config,
         return;
 
     mesh_name =
-        //! \ogs_file_attr{process__calculatesurfaceflux__mesh}
+        //! \ogs_file_param{process__calculatesurfaceflux__mesh}
         calculatesurfaceflux_config->getConfigParameter<std::string>("mesh");
     property_name =
-        //! \ogs_file_attr{process__calculatesurfaceflux__property_name}
+        //! \ogs_file_param{process__calculatesurfaceflux__property_name}
         calculatesurfaceflux_config->getConfigParameter<std::string>(
             "property_name");
     out_fname =
-        //! \ogs_file_attr{process__calculatesurfaceflux__output_mesh}
+        //! \ogs_file_param{process__calculatesurfaceflux__output_mesh}
         calculatesurfaceflux_config->getConfigParameter<std::string>(
             "output_mesh");
 }

ProcessLib/CentralDifferencesJacobianAssembler.cpp

@@ -130,11 +130,14 @@ void CentralDifferencesJacobianAssembler::assembleWithJacobian(
 std::unique_ptr<CentralDifferencesJacobianAssembler>
 createCentralDifferencesJacobianAssembler(BaseLib::ConfigTree const& config)
 {
+    //! \ogs_file_param{process__jacobian_assembler__type}
     config.checkConfigParameter("type", "CentralDifferences");
 
     // TODO make non-optional.
+    //! \ogs_file_param{process__jacobian_assembler__relative_epsilons}
     auto rel_eps = config.getConfigParameterOptional<std::vector<double>>(
         "relative_epsilons");
+    //! \ogs_file_param{process__jacobian_assembler__component_magnitudes}
     auto comp_mag = config.getConfigParameterOptional<std::vector<double>>(
         "component_magnitudes");
 

ProcessLib/CreateJacobianAssembler.cpp

@@ -22,6 +22,7 @@ std::unique_ptr<AbstractJacobianAssembler> createJacobianAssembler(
         return std::unique_ptr<AbstractJacobianAssembler>(
             new AnalyticalJacobianAssembler);
 
+    //! \ogs_file_param{process__jacobian_assembler__type}
     auto const type = config->peekConfigParameter<std::string>("type");
 
     if (type == "Analytical") {

ProcessLib/Output.cpp

@@ -49,24 +49,24 @@ std::unique_ptr<Output> Output::
 newInstance(const BaseLib::ConfigTree &config, std::string const& output_directory)
 {
     auto const output_iteration_results =
-        //! \ogs_file_param{prj__output__output_iteration_results}
+        //! \ogs_file_param{prj__time_loop__output__output_iteration_results}
         config.getConfigParameterOptional<bool>("output_iteration_results");
 
     std::unique_ptr<Output> out{new Output{
         BaseLib::joinPaths(output_directory,
-                           //! \ogs_file_param{prj__output__prefix}
+                           //! \ogs_file_param{prj__time_loop__output__prefix}
                            config.getConfigParameter<std::string>("prefix")),
         output_iteration_results ? *output_iteration_results : false}};
 
-    //! \ogs_file_param{prj__output__timesteps}
+    //! \ogs_file_param{prj__time_loop__output__timesteps}
     if (auto const timesteps = config.getConfigSubtreeOptional("timesteps"))
     {
-        //! \ogs_file_param{prj__output__timesteps__pair}
+        //! \ogs_file_param{prj__time_loop__output__timesteps__pair}
         for (auto pair : timesteps->getConfigSubtreeList("pair"))
         {
-            //! \ogs_file_param{prj__output__timesteps__pair__repeat}
+            //! \ogs_file_param{prj__time_loop__output__timesteps__pair__repeat}
             auto repeat     = pair.getConfigParameter<unsigned>("repeat");
-            //! \ogs_file_param{prj__output__timesteps__pair__each_steps}
+            //! \ogs_file_param{prj__time_loop__output__timesteps__pair__each_steps}
             auto each_steps = pair.getConfigParameter<unsigned>("each_steps");
 
             assert(repeat != 0 && each_steps != 0);

ProcessLib/ProcessOutput.cpp

@@ -17,10 +17,10 @@ namespace ProcessLib
 
 ProcessOutput::ProcessOutput(BaseLib::ConfigTree const& output_config)
 {
-    //! \ogs_file_param{process__output__variables}
+    //! \ogs_file_param{prj__time_loop__processes__process__output__variables}
     auto const out_vars = output_config.getConfigSubtree("variables");
 
-    //! \ogs_file_param{process__output__variables__variable}
+    //! \ogs_file_param{prj__time_loop__processes__process__output__variables__variable}
     for (auto out_var : out_vars.getConfigParameterList<std::string>("variable"))
     {
         if (output_variables.find(out_var) != output_variables.cend())
@@ -33,7 +33,7 @@ ProcessOutput::ProcessOutput(BaseLib::ConfigTree const& output_config)
     }
 
     if (auto out_resid =
-            //! \ogs_file_param{process__output__output_extrapolation_residuals}
+            //! \ogs_file_param{prj__time_loop__processes__process__output__output_extrapolation_residuals}
             output_config.getConfigParameterOptional<bool>("output_extrapolation_residuals"))
     {
         output_residuals = *out_resid;

ProcessLib/SmallDeformation/CreateSmallDeformationProcess.cpp

@@ -68,6 +68,7 @@ createSmallDeformationProcess(
         config.getConfigSubtree("constitutive_relation");
 
     auto const type =
+        //! \ogs_file_param{process__SMALL_DEFORMATION__constitutive_relation__type}
         constitutive_relation_config.peekConfigParameter<std::string>("type");
 
     std::unique_ptr<MaterialLib::Solids::MechanicsBase<DisplacementDim>>

ProcessLib/UncoupledProcessesTimeLoop.cpp

@@ -25,7 +25,7 @@ std::unique_ptr<NumLib::ITimeStepAlgorithm> createTimeStepper(
 
     if (type == "SingleStep")
     {
-        //! \ogs_file_param_special{prj__time_stepping__SingleStep}
+        //! \ogs_file_param_special{prj__time_loop__time_stepping__SingleStep}
         config.ignoreConfigParameter("type");
         timestepper.reset(new NumLib::FixedTimeStepping(0.0, 1.0, 1.0));
     }
@@ -282,8 +282,8 @@ std::vector<std::unique_ptr<SingleProcessData>> createPerProcessData(
             processes, pcs_name,
             "A process with the given name has not been defined.");
 
-        //! \ogs_file_param{prj__time_loop__processes__process__nonlinear_solver}
         auto const nl_slv_name =
+            //! \ogs_file_param{prj__time_loop__processes__process__nonlinear_solver}
             pcs_config.getConfigParameter<std::string>("nonlinear_solver");
         auto& nl_slv = *BaseLib::getOrError(
             nonlinear_solvers, nl_slv_name,
@@ -298,8 +298,7 @@ std::vector<std::unique_ptr<SingleProcessData>> createPerProcessData(
             pcs_config.getConfigSubtree("convergence_criterion"));
 
         //! \ogs_file_param{prj__time_loop__processes__process__output}
-        ProcessOutput process_output{
-            pcs_config.getConfigSubtree("output")};
+        ProcessOutput process_output{pcs_config.getConfigSubtree("output")};
 
         per_process_data.emplace_back(makeSingleProcessData(
             nl_slv, pcs, std::move(time_disc), std::move(conv_crit),
@@ -321,16 +320,16 @@ std::unique_ptr<UncoupledProcessesTimeLoop> createUncoupledProcessesTimeLoop(
     const std::map<std::string, std::unique_ptr<NumLib::NonlinearSolverBase>>&
         nonlinear_solvers)
 {
-    //! \ogs_file_param{prj__time_loop__time_stepping}
     auto timestepper =
+        //! \ogs_file_param{prj__time_loop__time_stepping}
         createTimeStepper(config.getConfigSubtree("time_stepping"));
 
-    //! \ogs_file_param{prj__time_loop__output}
     auto output =
+        //! \ogs_file_param{prj__time_loop__output}
         createOutput(config.getConfigSubtree("output"), output_directory);
 
-    //! \ogs_file_param{prj__time_loop__processes}
     auto per_process_data = createPerProcessData(
+        //! \ogs_file_param{prj__time_loop__processes}
         config.getConfigSubtree("processes"), processes, nonlinear_solvers);
 
     return std::unique_ptr<UncoupledProcessesTimeLoop>{