clean up links

docs/src/distributed/1_functions.md

@@ -14,8 +14,8 @@ You may run your analyses in parallel to gain speed-ups. The usual workflow in
 
 1. Import the `Distributed` package and add worker processes, e.g. using
    `addprocs`.
-2. Pick an analysis function that can be parallelized (such as [`screen`](@ref)
-   or [`flux_variability_analysis`](@ref)) and prepare it to work on your data.
+2. Pick an analysis function that can be parallelized (such as `screen`
+   or `flux_variability_analysis`) and prepare it to work on your data.
 3. Pass the desired set of worker IDs to the function using `workers=` argument,
    in the simplest form using e.g. `screen(...,  workers=workers())`.
 4. Worker communication will be managed automatically, and you will get results
@@ -29,12 +29,12 @@ locally](2_parallel.md) and [running distributed analysis in HPC clusters](3_slu
 As of COBREXA 1.3, the list of functions that accept the `worker` argument is
 as follows:
 
-- [`affine_hit_and_run`](@ref) sampling, together with [`warmup_from_variability`](@ref)
-- [`flux_variability_analysis`](@ref)
-- [`max_min_driving_force`](@ref)
-- [`objective_envelope`](@ref)
-- [`screen`](@ref)
-- [`screen_optmodel_modifications`](@ref)
+- `affine_hit_and_run`](@ref) sampling, together with [`warmup_from_variability`
+- `flux_variability_analysis`
+- `max_min_driving_force`
+- `objective_envelope`
+- `screen`
+- `screen_optmodel_modifications`
 
 Notably, the screening functions are reused to run many other kinds of analyses
 which, in turn, inherit the parallelizability. This includes a wide range of
@@ -57,7 +57,7 @@ that reduce the parallel efficiency, which can be summarized as follows:
   supported (and if it is, it may be inefficient for usual problem sizes). You
   usually want to parallelize the analyzes that comprise multiple independent
   runs of the solvers.
-- Some analysis function, such as [`flux_variability_analysis`](@ref), have
+- Some analysis function, such as `flux_variability_analysis`, have
   serial parts that can not be parallelized by default. Usually, you may avoid
   the inefficiency by precomputing the serial analysis parts without involving
   the cluster of the workers.

docs/src/distributed/3_slurm.md

@@ -29,7 +29,7 @@ Adding of the Slurm-provided is done as follows:
 
 After adding the Slurm workers, you may continue as if the workers were added
 using normal `addprocs` --- typically you load the model and (for example) run
-the [`flux_variability_analysis`](@ref) as if you would use the [local
+the `flux_variability_analysis` as if you would use the [local
 workers](2_parallel.md).
 
 The Julia script that does a parallel analysis in a Slurm cluster may look as follows:

docs/src/examples/03-parsimonious-flux-balance.jl

@@ -17,7 +17,7 @@
 # # Parsimonious flux balance analysis
 
 # We will use [`parsimonious_flux_balance_analysis`](@ref) and
-# [`minimize_metabolic_adjustment`](@ref) to find the optimal flux
+# [`minimization_of_metabolic_adjustment`](@ref) to find the optimal flux
 # distribution in the *E. coli* "core" model.
 #
 # TODO pFBA citation

docs/src/examples/08-community-models.jl

@@ -68,7 +68,7 @@ ecoli2.fluxes.ACALD.bound = C.Between(-5.0, 5.0)
 # Because we created the trees with interfaces, we can connect them easily to
 # form a new model with the interface. For simplicity, we use the
 # interface-scaling functionality of [`interface_constraints`](@ref
-# ConstraintTrees.interface_constraints) to bring in cFBA-like community member
+# COBREXA.interface_constraints) to bring in cFBA-like community member
 # abundances:
 
 cc = interface_constraints(

src/analysis/parsimonious.jl

@@ -25,7 +25,7 @@ sense, optimizer, and adding more settings).
 For efficiency, everything is performed on a single instance of JuMP model.
 
 A simpler version suitable for direct work with metabolic models is available
-in [`parsimonious_flux_balance`](@ref).
+in [`parsimonious_flux_balance_analysis`](@ref).
 """
 function parsimonious_optimized_values(
     constraints::C.ConstraintTreeElem;

src/analysis/solver.jl

@@ -23,7 +23,7 @@ the model, and return either `nothing` if the optimization failed, or `output`
 substituted with the solved values (`output` defaults to `constraints`.
 
 For a "nice" version for simpler finding of metabolic model optima, use
-[`flux_balance`](@ref).
+[`flux_balance_analysis`](@ref).
 """
 function optimized_values(
     constraints::C.ConstraintTree;

src/builders/fbc.jl

@@ -27,7 +27,7 @@ function of the model.
 
 Optionally if `interface` is specified, an "interface block" will be created
 within the constraint tree for later use as a "module" in creating bigger
-models (such as communities) using [`join_module_constraints`](@ref). The
+models (such as communities) using [`interface_constraints`](@ref). The
 possible parameter values include:
 - `nothing` -- default, no interface is created
 - `:sbo` -- the interface gets created from model's SBO annotations)

src/frontend/moma.jl

@@ -95,10 +95,10 @@ export minimization_of_metabolic_adjustment
 """
 $(TYPEDSIGNATURES)
 
-Like [`minimization_of_metabolic_adjustment`](@ref) but optimizes the
-L1 norm. This typically produces a sufficiently good result with less
-resources, depending on the situation. See documentation of
-[`linear_parsimonious_flux_balance`](@ref) for some of the
+Like [`minimization_of_metabolic_adjustment`](@ref) but optimizes the L1 norm.
+This typically produces a sufficiently good result with less resources,
+depending on the situation. See documentation of
+[`linear_parsimonious_flux_balance_analysis`](@ref) for some of the
 considerations.
 """
 function linear_minimization_of_metabolic_adjustment(

src/frontend/sample.jl

@@ -14,10 +14,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-function flux_sampling_achr(model::A.AbstractFBCModel; optimizer, kwargs...)
+"""
+$(TYPEDSIGNATURES)
+
+TODO
+"""
+function achr_flux_sample(model::A.AbstractFBCModel; optimizer, kwargs...)
     #TODO
 end
 
-function flux_sampling_affine_hr(model::A.AbstractFBCModel; optimizer, kwargs...)
+"""
+$(TYPEDSIGNATURES)
+
+TODO
+"""
+function affine_hr_flux_sample(model::A.AbstractFBCModel; optimizer, kwargs...)
     #TODO probably share a lot of the frontend with the above thing
 end