docs: remove model-specific references from documentation

doc/.gitignore

@@ -4,3 +4,4 @@ source/Tools_api
 source/CIME_api
 source/_autosummary
 source/generated
+build/

doc/source/ccs/index.rst

@@ -18,7 +18,7 @@ The first thing to do is clone the model repository into ``$SRCROOT``.
 
 All examples will be run from ``$CIMEROOT`` which is should exist under ``$SRCROOT`` e.g. (``$CIMEROOT`` would be ``$SRCROOT/cime``).
 
-Next set the ``CIME_MODEL`` evnironment variable for your model, e.g. ``export CIME_MODEL=e3sm``.
+Next set the ``CIME_MODEL`` environment variable for your model, e.g. ``export CIME_MODEL=<your-model>`` (see :ref:`Setting up your environment for CCS <ccs-env-setup>` for valid values).
 
 .. note::
 
@@ -155,16 +155,18 @@ Customizations
 The CCS allows for a number of customizations to be made to a case.
 
 
+.. _ccs-env-setup:
+
 Setting up your environment for CCS
 ```````````````````````````````````
 After you've cloned the model repository, you'll need to set up your environment to use the CCS.
 
 First you'll need to let CIME know which model configuration to use by setting the ``CIME_MODEL`` environment variable. In bash, use **export** as shown and replace
-**<model>** with the appropriate text. Current possibilities are "e3sm", "cesm", or "ufs".
+**<your-model>** with the appropriate text. Current possibilities are "e3sm", "cesm", or "ufs".
 
 ::
 
-    export CIME_MODEL=<model>
+    export CIME_MODEL=<your-model>
 
 There are a number of possible ways to set CIME variables.
 For variables that can be set in more than one way, the order of precedence is:

doc/source/ccs/model-configuration/support-a-new-machine.rst

@@ -68,24 +68,88 @@ As an example, on a MAC with 2 cores that has mpich with gnu fortran you would i
    > mpif90 fhello_world_mpi.F90 -o hello_world
    > mpirun -np 2 ./hello_world
 
-CESM Linux and Mac Support
+Linux and Mac Support
 ---------------------------
 
-The distribution of CESM includes machines called **homebrew** and **centos7-linux** in the file **$CIMEROOT/config/cesm/machines/config_machines.xml**.
+Your model distribution may include generic machine definitions in the model's ``config_machines.xml`` file.
+The location of this file is model-dependent and is set by the ``MACHINES_SPEC_FILE`` entry in the model's ``config_files.xml`` (see :ref:`MACHINES_SPEC_FILE <model_config_machines>`); refer to your model repository for the exact path.
 Please see the instructions in the file to create the directory structure and use these generic machine definitions.
 
+.. _config-machines-schema-versions:
+
+About config_machines.xml
+---------------------------
+
+The ``config_machines.xml`` file describes the machines on which CIME-driven models can be built and run.
+Both its location and the XML schema(s) it must conform to are **model-dependent**.
+
+The schema(s) advertised by a model are declared as ``<schema>`` children of the ``MACHINES_SPEC_FILE`` entry in that model's ``config_files.xml``.
+The XSD applied at validation time is then selected from the ``version`` attribute on the root ``<config_machines>`` element of the file being loaded.
+The two supported schemas are:
+
+**Version 2.0 (monolithic)** — ``$CIMEROOT/CIME/data/config/xml_schemas/config_machines.xsd``
+   A single file contains the full definition for every supported machine.
+   Each ``<machine MACH="...">`` block carries its own ``<NODENAME_REGEX>`` (used by CIME to auto-detect the machine), and ``<machine>`` must appear at least once at the top level.
+
+   .. code-block:: xml
+
+      <config_machines version="2.0">
+        <machine MACH="mymachine">
+          <DESC>...</DESC>
+          <NODENAME_REGEX>mymachine.*</NODENAME_REGEX>
+          <OS>LINUX</OS>
+          ...
+        </machine>
+        <machine MACH="othermachine">
+          ...
+        </machine>
+      </config_machines>
+
+**Version 3.0 (per-machine directory)** — ``$CIMEROOT/CIME/data/config/xml_schemas/config_machines_version3.xsd``
+   The top-level ``config_machines.xml`` only holds a registry that maps each machine to its node-name regex.
+   The full definition for each machine lives in its own subdirectory (``<machines_dir>/<MACH>/config_machines.xml``) next to that machine's ``config_batch.xml`` and ``*.cmake`` files.
+   Top-level ``<machine>`` blocks are optional, ``<NODENAME_REGEX>`` is removed from individual ``<machine>`` blocks, and the v3 schema additionally accepts a ``<TORCH_DIR>`` element per machine.
+
+   .. code-block:: xml
+
+      <config_machines version="3.0">
+        <NODENAME_REGEX>
+          <value MACH="mymachine">mymachine.*</value>
+          <value MACH="othermachine">other.*</value>
+        </NODENAME_REGEX>
+      </config_machines>
+
+   Per-machine file (``<machines_dir>/mymachine/config_machines.xml``):
+
+   .. code-block:: xml
+
+      <config_machines version="3.0">
+        <machine MACH="mymachine">
+          <DESC>...</DESC>
+          <OS>LINUX</OS>
+          ...
+        </machine>
+      </config_machines>
+
+Not every model registers both schemas. Refer to the ``MACHINES_SPEC_FILE`` entry in your model's ``config_files.xml`` to see which schema versions are available; if no ``version`` attribute is present on the ``<schema>`` entry, the model accepts a single unversioned schema matching the **2.0** layout.
+
+See :ref:`MACHINES_SPEC_FILE <model_config_machines>` for the full element reference for both schema versions.
+
 Steps for porting
 ---------------------------
 
 Porting CIME involves several steps. The first step is to define your machine. You can do this in one of two ways:
 
-1. You can edit **$CIMEROOT/config/$model/machines/config_machines.xml** and add an appropriate section for your machine.
+1. You can edit the model's ``config_machines.xml`` directly (the path is given by ``MACHINES_SPEC_FILE`` in the model's ``config_files.xml``) and add an appropriate section for your machine.
+   For a **version 3.0** layout, instead add (or update) a ``<value MACH="...">`` entry under the top-level ``<NODENAME_REGEX>`` and create a ``<machines_dir>/<your_machine>/`` subdirectory containing the per-machine ``config_machines.xml``, ``config_batch.xml`` and ``*.cmake`` files.
 
 2. You can use your **$HOME/.cime** directory (see :ref:`customizing-cime`).
    In particular, you can create a **$HOME/.cime/config_machines.xml** file with the definition for your machine.
-   A template to create this definition is provided in **$CIMEROOT/config/xml_schemas/config_machines_template.xml**. More details are provided in the template file.
+   A template to create this definition is provided in **$CIMEROOT/CIME/data/config/xml_schemas/config_machines_template.xml**. More details are provided in the template file.
    In addition, if you have a batch system, you will also need to add a **config_batch.xml** file to your **$HOME/.cime** directory.
-   All files in **$HOME/.cime/** are appended to the xml objects that are read into memory from the **$CIME/config/$model**, where **$model** is either ``e3sm`` or ``cesm``.
+   All files in **$HOME/.cime/** are appended to the xml objects that are read into memory from the directory containing the model's ``MACHINES_SPEC_FILE``.
+
+   .. note:: When the model uses the **version 3.0** schema, the per-machine override is read from **$HOME/.cime/<your_machine>/config_machines.xml** (and a top-level **$HOME/.cime/config_machines.xml** may be used to register the ``NODENAME_REGEX``).
 
    .. note:: If you use method (2), you can download CIME updates without affecting your machine definitions in **$HOME/.cime**.
 
@@ -97,26 +161,34 @@ In what follows we outline the process for method (2) above:
 
    This file contains all the information you must set in order to configure a new machine to be CIME-compliant.
 
-   Fill in the contents of **$HOME/.cime/config_machines.xml** that are specific to your machine. For more details see :ref:`the config_machines.xml file <model_config>`.
+   Fill in the contents of **$HOME/.cime/config_machines.xml** that are specific to your machine. For more details see :ref:`MACHINES_SPEC_FILE <model_config_machines>` and :ref:`the schema overview above <config-machines-schema-versions>`.
 
-   Check to ensure that your **config_machines.xml** file conforms to the CIME schema definition by doing the following:
+   Check to ensure that your **config_machines.xml** file conforms to the CIME schema definition by validating it against the XSD that matches the ``version`` declared on its root element:
    ::
 
-      xmllint --noout --schema $CIME/config/xml_schemas/config_machines.xsd $HOME/.cime/config_machines.xml
+      # version 2.0 (also used when the model registers only an unversioned schema)
+      xmllint --noout --schema $CIMEROOT/CIME/data/config/xml_schemas/config_machines.xsd $HOME/.cime/config_machines.xml
+
+      # version 3.0
+      xmllint --noout --schema $CIMEROOT/CIME/data/config/xml_schemas/config_machines_version3.xsd $HOME/.cime/config_machines.xml
 
 -  If you find that you need to introduce compiler settings specific to your machine, create a **$HOME/.cime/*.cmake** file.
-   The default compiler settings are defined in **$CIME/config/$model/machines/cmake_macros/**.
+   The default compiler settings are defined in the ``cmake_macros/`` directory that lives alongside the model's ``MACHINES_SPEC_FILE``.
 
 -  If you have a batch system, you may also need to create a **$HOME/.cime/config_batch.xml** file.
-   Out-of-the-box batch settings are set in **$CIME/config/$model/machines/config_batch.xml**.
+   Out-of-the-box batch settings are set in the ``config_batch.xml`` file that lives alongside the model's ``MACHINES_SPEC_FILE`` (its path is given by ``BATCH_SPEC_FILE`` in the model's ``config_files.xml``).
 
 -  Once you have defined a basic configuration for your machine in your **$HOME/.cime** xml files, run the :ref:`unittest <contributing-guide-running-tests>`.
 
 After running those steps correctly, you are ready to try a case at your target compset and resolution.
 
-Validating a CESM port with prognostic components
+Validating a port with prognostic components
 -------------------------------------------------
 
+.. note::
+
+   This section is specific to CESM (and NorESM). Consult your model's documentation for the equivalent procedure.
+
 The following port validation is recommended for any new machine.
 Carrying out these steps does not guarantee the model is running
 properly in all cases nor that the model is scientifically valid on
@@ -133,15 +205,15 @@ possible.
 Users are responsible for their own validation process,
 especially with respect to science validation.
 
-These are the recommended steps for validating a port for the CESM model:
+These are the recommended steps for validating a port:
 
-1. Verify basic functionality of your port by performing the cheyenne "prealpha" tests on your machine. This can be done by issuing the following command:
+1. Verify basic functionality of your port by performing the "prealpha" tests on your machine. This can be done by issuing the following command:
 
    ::
 
-      ./create_test --xml-category prealpha --xml-machine cheyenne --xml-compiler intel --machine <your_machine_name> --compiler <your_compiler_name>
+      ./create_test --xml-category prealpha --xml-machine <reference_machine> --xml-compiler <reference_compiler> --machine <your_machine_name> --compiler <your_compiler_name>
 
-   This command will run the prealpha tests *defined* for cheyenne with the intel compiler, but will run them on *your* machine with *your* compiler.
+   This command will run the prealpha tests *defined* for the reference machine with the reference compiler, but will run them on *your* machine with *your* compiler.
    These tests will be run in the **$CIME_OUTPUT_ROOT**. To see the results of tests, you need to do the following:
 
    ::
@@ -153,11 +225,11 @@ These are the recommended steps for validating a port for the CESM model:
 2. Carry out ensemble consistency tests:
 
    This is described in ``$CIMEROOT/tools/statistical_ensemble_test/README``.
-   The CESM-ECT (CESM Ensemble Consistency Test) determines whether a new simulation set up (new machine, compiler, etc.) is statistically distinguishable from an accepted ensemble.
-   The ECT process involves comparing several runs (3) generated with the new scenario to an ensemble built on a trusted machine (currently cheyenne).
+   The Ensemble Consistency Test (ECT) determines whether a new simulation set up (new machine, compiler, etc.) is statistically distinguishable from an accepted ensemble.
+   The ECT process involves comparing several runs (3) generated with the new scenario to an ensemble built on a trusted machine.
    The python ECT tools are located in the pyCECT subdirectory ``$CIMEROOT/tools/statistical_ensemble_test/pyCECT``.
 
-   The verification tools in the CESM-ECT suite are:
+   The verification tools in the ECT suite are:
 
    ``CAM-ECT``: detects issues in CAM and CLM (12 month runs)
 
@@ -166,9 +238,8 @@ These are the recommended steps for validating a port for the CESM model:
    ``POP-ECT``: detects issues in POP and CICE (12 month runs)
 
    Follow the instructions in the **README** file to generate three ensemble runs for any of the above tests that are most relevant to your port.
-   Then please go to the `CESM2 ensemble verification website <http://www.cesm.ucar.edu/models/cesm2.0/verification>`_, where you can upload your files and subsequently obtain a quick response as to the success or failure of your verification.
 
-Performance tuning of a CESM port
+Performance tuning of a port
 -------------------------------------------------
 
 Once you have performed the verification that your port is successful,

doc/source/ccs/model-configuration/variables/compsets.rst

@@ -48,7 +48,7 @@ Every file listed in ``COMPSETS_SPEC_FILE`` will be searched to compile possible
 
 CIME will note which component's config_compsets.xml had the matching compset name and that component will be treated as
 the **primary component** As an example, the primary component for a compset that has a prognostic atmosphere,
-land and cice (in prescribed mode) and a data ocean is the atmosphere component (for cesm this is CAM) because the compset
+land and cice (in prescribed mode) and a data ocean is the atmosphere component (e.g. CAM in CESM) because the compset
 is defined, using the above example, in ``$SRCROOT/components/cam/cime_config/config_compsets.xml``
 In a compset where all components are prognostic, the primary component will be **allactive**.
 

doc/source/ccs/model-configuration/variables/grids.rst

@@ -387,14 +387,14 @@ The steps for adding a new component grid to the model system follow. This proce
    At this time, if you are running with a new ocean or runoff grid, please contact Michael Levy (mlevy_AT_ucar_DOT_edu) for assistance. If you are running with standard ocean and runoff grids, the mapping file should already exist and you do not need to generate it.
 
 
-6. CESM specific: If you are adding a new atmosphere grid, this means you are also generating a new land grid, and you will need to create a new CLM surface dataset. (Otherwise you can skip this step).
-   You need to first generate mapping files for CLM surface dataset (since this is a non-standard grid).
+6. If you are adding a new atmosphere grid, this means you are also generating a new land grid, and you may need to create a new land surface dataset. (Otherwise you can skip this step).
+   You need to first generate mapping files for the land surface dataset (since this is a non-standard grid).
    ::
 
       > cd $CIMEROOT/../components/clm/tools/mkmapdata
       > ./mkmapdata.sh --gridfile <lnd SCRIP grid file> --res <atm resolution name> --gridtype global
 
-    These mapping files are then used to generate CLM surface dataset. Below is an example for a current day surface dataset (model year 2000).
+    These mapping files are then used to generate the land surface dataset. Below is an example for a current day surface dataset (model year 2000).
 
     ::
 
@@ -403,7 +403,7 @@ The steps for adding a new component grid to the model system follow. This proce
 
 7. Create grid file needed for create_newcase.
    The next step is to add the necessary new entries in the appropriate ``config_grids.xml`` file.
-   You will need to modify ``$CIMEROOT/config/cesm/config_grids.xml`` or ``$CIMEROOT/config/e3sm/config_grids.xml`` depending on the value of ``$CIME_MODEL``.
+   You will need to modify ``$CIMEROOT/config/$model/config_grids.xml`` depending on the value of ``$CIME_MODEL``.
    You will need to:
 
    - add a single  ``<model_grid>`` entry

doc/source/ccs/model-configuration/variables/pes.rst

@@ -436,8 +436,8 @@ help determine the optimal load balance.
 Changing the pe layout of the model has NO IMPACT on the scientific
 results. The basic order of operations and calling sequence are
 hardwired into the driver and do not change with the pe
-layout. However, both CESM and E3SM do impose some contraints in the
-tempororal evolution of the components.  For example, the prognostic
+layout. However, models such as CESM and E3SM may impose some constraints in the
+temporal evolution of the components.  For example, the prognostic
 atmosphere model always run sequentially with the ice and land models
 for scientific reasons. As a result, running the atmosphere
 concurrently with the ice and land will result in idle processors at

doc/source/ccs/running-a-case.rst

@@ -19,6 +19,10 @@ Before submitting a case, it is a good idea to preview the run to ensure that th
 
 Example output:
 
+.. note::
+
+   The following is an example output. The specific paths, environment variables, and commands will vary depending on your model and machine configuration.
+
 .. code-block:: bash
 
   CASE INFO:
@@ -343,6 +347,8 @@ The XML variable ``$GET_REFCASE`` is a flag that if set will automatically pre-s
 
 - If ``$GET_REFCASE`` is ``FALSE``, then the data is assumed to already exist in ``$RUNDIR``.
 
+.. _restarting-a-run:
+
 Restarting a Run
 `````````````````
 Active components (and some data components) write restart files
@@ -500,7 +506,7 @@ or a hybrid run or to back up to a previous restart date.
 Long-term Archiving
 ```````````````````
 Users may choose to follow their institution's preferred method for long-term
-archiving of model output. Previous releases of CESM provided an external
+archiving of model output. Previous releases of some CIME-driven models provided an external
 long-term archiver tool that supported mass tape storage and HPSS systems.
 However, with the industry migration away from tape archives, it is no longer
 feasible for CIME to support all the possible archival schemes available.
@@ -516,7 +522,7 @@ Scripts
 ```````
 Variables ``PRERUN_SCRIPT`` and ``POSTRUN_SCRIPT`` can each be used to name
 a script which should be executed immediately prior starting or
-following completion of the CESM executable within the batch
+following completion of the model executable within the batch
 environment.  The script is expected to be found in the case directory
 and will receive one argument which is the full path to that
 directory.  If the script is written in python and contains a