diff --git a/.lib/git-fleximod/.github/workflows/pytest.yaml b/.lib/git-fleximod/.github/workflows/pytest.yaml
index 0868dd9a33..6cb8102b94 100644
--- a/.lib/git-fleximod/.github/workflows/pytest.yaml
+++ b/.lib/git-fleximod/.github/workflows/pytest.yaml
@@ -18,7 +18,7 @@ jobs:
       # reference the matrixe python version here.
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.9'
+          python-version: '3.12'
 
       # Cache the installation of Poetry itself, e.g. the next step. This prevents the workflow
       # from installing Poetry every time, which can be slow. Note the use of the Poetry version
@@ -29,7 +29,7 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.local
-          key: poetry-1.7.1
+          key: poetry-1.8.2
 
       # Install Poetry. You could do this manually, or there are several actions that do this.
       # `snok/install-poetry` seems to be minimal yet complete, and really just calls out to
@@ -42,7 +42,7 @@ jobs:
       # cache it.
       - uses: snok/install-poetry@v1
         with:
-          version: 1.7.1
+          version: 1.8.2
           virtualenvs-create: true
           virtualenvs-in-project: true
 
@@ -74,4 +74,7 @@ jobs:
           git config --global user.name "${GITHUB_ACTOR}"
           git config --global user.email "${GITHUB_ACTOR_ID}+${GITHUB_ACTOR}@users.noreply.github.com"
           poetry run pytest
+      - name: Setup tmate session
+        if: ${{ failure() }}
+        uses: mxschmitt/action-tmate@v3
 
diff --git a/.lib/git-fleximod/CODE_OF_CONDUCT.md b/.lib/git-fleximod/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000..84f2925bba
--- /dev/null
+++ b/.lib/git-fleximod/CODE_OF_CONDUCT.md
@@ -0,0 +1,107 @@
+# Contributor Code of Conduct
+_The Contributor Code of Conduct is for participants in our software projects and community._
+
+## Our Pledge
+We, as contributors, creators, stewards, and maintainers (participants), of **git-fleximod** pledge to make participation in
+our software, system or hardware project and community a safe, productive, welcoming and inclusive experience for everyone.
+All participants are required to abide by this Code of Conduct.
+This includes respectful treatment of everyone regardless of age, body size, disability, ethnicity, gender identity or expression,
+level of experience, nationality, political affiliation, veteran status, pregnancy, genetic information, physical appearance, race,
+religion, or sexual orientation, as well as any other characteristic protected under applicable US federal or state law.
+
+## Our Standards
+Examples of behaviors that contribute to a positive environment include:
+
+* All participants are treated with respect and consideration, valuing a diversity of views and opinions
+* Be considerate, respectful, and collaborative
+* Communicate openly with respect for others, critiquing ideas rather than individuals and gracefully accepting criticism
+* Acknowledging the contributions of others
+* Avoid personal attacks directed toward other participants
+* Be mindful of your surroundings and of your fellow participants 
+* Alert UCAR staff and suppliers/vendors if you notice a dangerous situation or someone in distress
+* Respect the rules and policies of the project and venue
+
+Examples of unacceptable behavior include, but are not limited to:
+
+* Harassment, intimidation, or discrimination in any form
+* Physical, verbal, or written abuse by anyone to anyone, including repeated use of pronouns other than those requested
+* Unwelcome sexual attention or advances
+* Personal attacks directed at other guests, members, participants, etc.
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Alarming, intimidating, threatening, or hostile comments or conduct
+* Inappropriate use of nudity and/or sexual images 
+* Threatening or stalking anyone, including a participant
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Scope
+This Code of Conduct applies to all spaces managed by the Project whether they be physical, online or face-to-face.
+This includes project code, code repository, associated web pages, documentation, mailing lists, project websites and wiki pages,
+issue tracker, meetings, telecons, events, project social media accounts, and any other forums created by the project team which the
+community uses for communication.
+In addition, violations of this Code of Conduct outside these spaces may affect a person's ability to participate within them.
+Representation of a project may be further defined and clarified by project maintainers.
+
+## Community Responsibilities
+Everyone in the community is empowered to respond to people who are showing unacceptable behavior.
+They can talk to them privately or publicly.
+Anyone requested to stop unacceptable behavior is expected to comply immediately.
+If the behavior continues concerns may be brought to the project administrators or to any other party listed in the
+[Reporting](#reporting) section below.
+
+## Project Administrator Responsibilities
+Project administrators are responsible for clarifying the standards of acceptable behavior and are encouraged to model appropriate
+behavior and provide support when people in the community point out inappropriate behavior.
+Project administrator(s) are normally the ones that would be tasked to carry out the actions in the [Consequences](#consequences)
+section below.
+
+Project administrators are also expected to keep this Code of Conduct updated with the main one housed at UCAR, as listed below in
+the [Attribution](#attribution) section.
+
+## Reporting
+Instances of unacceptable behavior can be brought to the attention of the project administrator(s) who may take any action as
+outlined in the [Consequences](#consequences) section below.
+However, making a report to a project administrator is not considered an 'official report' to UCAR. 
+
+Instances of unacceptable behavior may also be reported directly to UCAR pursuant to [UCAR's Harassment Reporting and Complaint
+Procedure](https://www2.fin.ucar.edu/procedures/hr/harassment-reporting-and-complaint-procedure), or anonymously through [UCAR's
+EthicsPoint Hotline](https://www2.fin.ucar.edu/ethics/anonymous-reporting).
+
+Complaints received by UCAR will be handled pursuant to the procedures outlined in UCAR's Harassment Reporting and Complaint
+Procedure.
+Complaints to UCAR will be held as confidential as practicable under the circumstances, and retaliation against a person who
+initiates a complaint or an inquiry about inappropriate behavior will not be tolerated.
+
+Any Contributor can use these reporting methods even if they are not directly affiliated with UCAR.
+The Frequently Asked Questions (FAQ) page for reporting is [here](https://www2.fin.ucar.edu/procedures/hr/reporting-faqs).
+
+## Consequences
+Upon receipt of a complaint, the project administrator(s) may take any action deemed necessary and appropriate under the
+circumstances.
+Such action can include things such as: removing, editing, or rejecting comments, commits, code, wiki edits, email, issues, and
+other contributions that are not aligned to this Code of Conduct, or banning temporarily or permanently any contributor for other
+behaviors that are deemed inappropriate, threatening, offensive, or harmful.
+Project administrators also have the right to report violations to UCAR HR and/or UCAR's Office of Diversity, Equity and Inclusion
+(ODEI), as well as a participant's home institution and/or law enforcement.
+In the event an incident is reported to UCAR, UCAR will follow its Harassment Reporting and Complaint Procedure.
+
+## Process for Changes
+All UCAR managed projects are required to adopt this Contributor Code of Conduct.
+Adoption is assumed even if not expressly stated in the repository.
+Projects should fill in sections where prompted with project-specific information, including, project name and adoption date.
+
+Projects that adopt this Code of Conduct need to stay up to date with UCAR's Contributor Code of Conduct, linked with a DOI in the
+[Attribution](#attribution) section below.
+Projects can make limited substantive changes to the Code of Conduct, however, the changes must be limited in scope and may not
+contradict the UCAR Contributor Code of Conduct.
+
+## Attribution
+This Code of Conduct was originally adapted from the [Contributor Covenant](http://contributor-covenant.org/version/1/4), version
+1.4.
+We then aligned it with the UCAR Participant Code of Conduct, which also borrows from the American Geophysical Union (AGU) Code of
+Conduct.
+The UCAR Participant Code of Conduct applies to both UCAR employees as well as participants in activities run by UCAR.
+The original version of this for all software projects that have strong management from UCAR or UCAR staff is available on the UCAR
+website at https://doi.org/10.5065/6w2c-a132.
+The date that it was adopted by this project was **Feb/13/2018**.
+When responding to complaints, UCAR HR and ODEI will do so based on the latest published version.
+Therefore, any project-specific changes should follow the [Process for Changes](#process-for-changes) section above.
diff --git a/.lib/git-fleximod/git_fleximod/cli.py b/.lib/git-fleximod/git_fleximod/cli.py
index a15a226de4..ac9493cfc3 100644
--- a/.lib/git-fleximod/git_fleximod/cli.py
+++ b/.lib/git-fleximod/git_fleximod/cli.py
@@ -2,27 +2,31 @@
 import argparse
 from git_fleximod import utils
 
-__version__ = "0.7.8"
+__version__ = "0.9.3"
 
 def find_root_dir(filename=".gitmodules"):
     """ finds the highest directory in tree
     which contains a file called filename """
-    d = Path.cwd()
-    root = Path(d.root)
-    dirlist = []
-    dl = d
-    while dl != root:
-        dirlist.append(dl)
-        dl = dl.parent
-    dirlist.append(root)
-    dirlist.reverse()
-
-    for dl in dirlist:
-        attempt = dl / filename
-        if attempt.is_file():
-            return str(dl)
-    return None
-
+    try:
+        root = utils.execute_subprocess(["git","rev-parse", "--show-toplevel"],
+                                        output_to_caller=True ).rstrip()
+    except:
+        d = Path.cwd()
+        root = Path(d.root)
+        dirlist = []
+        dl = d
+        while dl != root:
+            dirlist.append(dl)
+            dl = dl.parent
+        dirlist.append(root)
+        dirlist.reverse()
+
+        for dl in dirlist:
+            attempt = dl / filename
+            if attempt.is_file():
+                return str(dl)
+        return None
+    return Path(root)
 
 def get_parser():
     description = """
diff --git a/.lib/git-fleximod/git_fleximod/git_fleximod.py b/.lib/git-fleximod/git_fleximod/git_fleximod.py
index e1b8f484a5..13f35df959 100755
--- a/.lib/git-fleximod/git_fleximod/git_fleximod.py
+++ b/.lib/git-fleximod/git_fleximod/git_fleximod.py
@@ -13,14 +13,14 @@
 from git_fleximod import cli
 from git_fleximod.gitinterface import GitInterface
 from git_fleximod.gitmodules import GitModules
-from configparser import NoOptionError
+from git_fleximod.submodule import Submodule
 
 # logger variable is global
 logger = None
 
 
 def fxrequired_allowed_values():
-    return ["ToplevelRequired", "ToplevelOptional", "AlwaysRequired", "AlwaysOptional"]
+    return ["ToplevelRequired", "ToplevelOptional", "AlwaysRequired", "AlwaysOptional", "TopLevelRequired", "TopLevelOptional"]
 
 
 def commandline_arguments(args=None):
@@ -33,14 +33,9 @@ def commandline_arguments(args=None):
 
     # explicitly listing a component overrides the optional flag
     if options.optional or options.components:
-        fxrequired = [
-            "ToplevelRequired",
-            "ToplevelOptional",
-            "AlwaysRequired",
-            "AlwaysOptional",
-        ]
+        fxrequired = fxrequired_allowed_values()
     else:
-        fxrequired = ["ToplevelRequired", "AlwaysRequired"]
+        fxrequired = ["ToplevelRequired", "AlwaysRequired", "TopLevelRequired"]
 
     action = options.action
     if not action:
@@ -98,7 +93,8 @@ def submodule_sparse_checkout(root_dir, name, url, path, sparsefile, tag="master
     """
     logger.info("Called sparse_checkout for {}".format(name))
     rgit = GitInterface(root_dir, logger)
-    superroot = rgit.git_operation("rev-parse", "--show-superproject-working-tree")
+    superroot = git_toplevelroot(root_dir, logger)
+
     if superroot:
         gitroot = superroot.strip()
     else:
@@ -128,8 +124,8 @@ def submodule_sparse_checkout(root_dir, name, url, path, sparsefile, tag="master
     # set the repository remote
 
     logger.info("Setting remote origin in {}/{}".format(root_dir, path))
-    status = sprepo_git.git_operation("remote", "-v")
-    if url not in status:
+    _, remotelist = sprepo_git.git_operation("remote", "-v")
+    if url not in remotelist:
         sprepo_git.git_operation("remote", "add", "origin", url)
 
     topgit = os.path.join(gitroot, ".git")
@@ -154,6 +150,8 @@ def submodule_sparse_checkout(root_dir, name, url, path, sparsefile, tag="master
 
     if os.path.isdir(os.path.join(root_dir, path, ".git")):
         with utils.pushd(sprep_repo):
+            if os.path.isdir(os.path.join(topgit,".git")):
+                shutil.rmtree(os.path.join(topgit,".git"))
             shutil.move(".git", topgit)
             with open(".git", "w") as f:
                 f.write("gitdir: " + os.path.relpath(topgit))
@@ -166,7 +164,9 @@ def submodule_sparse_checkout(root_dir, name, url, path, sparsefile, tag="master
             return
 
         with utils.pushd(sprep_repo):
-            shutil.copy(sparsefile, gitsparse)
+            if os.path.isfile(sparsefile):
+                shutil.copy(sparsefile, gitsparse)
+                
 
     # Finally checkout the repo
     sprepo_git.git_operation("fetch", "origin", "--tags")
@@ -176,285 +176,82 @@ def submodule_sparse_checkout(root_dir, name, url, path, sparsefile, tag="master
     rgit.config_set_value(f'submodule "{name}"', "active", "true")
     rgit.config_set_value(f'submodule "{name}"', "url", url)
 
-
-def single_submodule_checkout(
-    root, name, path, url=None, tag=None, force=False, optional=False
-):
-    """
-    This function checks out a single git submodule.
-
-    Parameters:
-    root (str): The root directory for the git operation.
-    name (str): The name of the submodule.
-    path (str): The path to the submodule.
-    url (str, optional): The URL of the submodule. Defaults to None.
-    tag (str, optional): The tag to checkout. Defaults to None.
-    force (bool, optional): If set to True, forces the checkout operation. Defaults to False.
-    optional (bool, optional): If set to True, the submodule is considered optional. Defaults to False.
-
-    Returns:
-    None
-    """
-    # function implementation...
-    git = GitInterface(root, logger)
-    repodir = os.path.join(root, path)
-    logger.info("Checkout {} into {}/{}".format(name, root, path))
-    # if url is provided update to the new url
-    tmpurl = None
-    repo_exists = False
-    if os.path.exists(os.path.join(repodir, ".git")):
-        logger.info("Submodule {} already checked out".format(name))
-        repo_exists = True
-    # Look for a .gitmodules file in the newly checkedout repo
-    if not repo_exists and url:
-        # ssh urls cause problems for those who dont have git accounts with ssh keys defined
-        # but cime has one since e3sm prefers ssh to https, because the .gitmodules file was
-        # opened with a GitModules object we don't need to worry about restoring the file here
-        # it will be done by the GitModules class
-        if url.startswith("git@"):
-            tmpurl = url
-            url = url.replace("git@github.com:", "https://github.com/")
-            git.git_operation("clone", url, path)
-            smgit = GitInterface(repodir, logger)
-            if not tag:
-                tag = smgit.git_operation("describe", "--tags", "--always").rstrip()
-            smgit.git_operation("checkout", tag)
-            # Now need to move the .git dir to the submodule location
-            rootdotgit = os.path.join(root, ".git")
-            if os.path.isfile(rootdotgit):
-                with open(rootdotgit) as f:
-                    line = f.readline()
-                    if line.startswith("gitdir: "):
-                        rootdotgit = line[8:].rstrip()
-
-            newpath = os.path.abspath(os.path.join(root, rootdotgit, "modules", name))
-            if os.path.exists(newpath):
-                shutil.rmtree(os.path.join(repodir, ".git"))
-            else:
-                shutil.move(os.path.join(repodir, ".git"), newpath)
-
-            with open(os.path.join(repodir, ".git"), "w") as f:
-                f.write("gitdir: " + os.path.relpath(newpath, start=repodir))
-                
-    if not os.path.exists(repodir):
-        parent = os.path.dirname(repodir)
-        if not os.path.isdir(parent):
-            os.makedirs(parent)
-        git.git_operation("submodule", "add", "--name", name, "--", url, path) 
-
-    if not repo_exists or not tmpurl:
-        git.git_operation("submodule", "update", "--init", "--", path)
-            
-    if os.path.exists(os.path.join(repodir, ".gitmodules")):
-        # recursively handle this checkout
-        print(f"Recursively checking out submodules of {name}")
-        gitmodules = GitModules(logger, confpath=repodir)
-        requiredlist = ["AlwaysRequired"]
-        if optional:
-            requiredlist.append("AlwaysOptional")
-        submodules_checkout(gitmodules, repodir, requiredlist, force=force)
-    if not os.path.exists(os.path.join(repodir, ".git")):
-        utils.fatal_error(
-            f"Failed to checkout {name} {repo_exists} {tmpurl} {repodir} {path}"
-        )
-
-    if tmpurl:
-        print(git.git_operation("restore", ".gitmodules"))
-
-    return
-
-def add_remote(git, url):
-    remotes = git.git_operation("remote", "-v")
-    newremote = "newremote.00"
-    if url in remotes:
-        for line in remotes:
-            if url in line and "fetch" in line:
-                newremote = line.split()[0]
-                break
-    else:
-        i = 0
-        while "newremote" in remotes:
-            i = i + 1
-            newremote = f"newremote.{i:02d}"
-        git.git_operation("remote", "add", newremote, url)
-    return newremote
-
-def submodules_status(gitmodules, root_dir, toplevel=False):
+def init_submodule_from_gitmodules(gitmodules, name, root_dir, logger):
+    path = gitmodules.get(name, "path")
+    url = gitmodules.get(name, "url")
+    assert path and url, f"Malformed .gitmodules file {path} {url}"
+    tag = gitmodules.get(name, "fxtag")
+    fxurl = gitmodules.get(name, "fxDONOTUSEurl")
+    fxsparse = gitmodules.get(name, "fxsparse")
+    fxrequired = gitmodules.get(name, "fxrequired")
+    return Submodule(root_dir, name, path, url, fxtag=tag, fxurl=fxurl, fxsparse=fxsparse, fxrequired=fxrequired, logger=logger)
+
+def submodules_status(gitmodules, root_dir, toplevel=False, depth=0):
     testfails = 0
     localmods = 0
     needsupdate = 0
+    wrapper = textwrap.TextWrapper(initial_indent=' '*(depth*10), width=120,subsequent_indent=' '*(depth*20))
     for name in gitmodules.sections():
-        path = gitmodules.get(name, "path")
-        tag = gitmodules.get(name, "fxtag")
-        url = gitmodules.get(name, "url")
-        required = gitmodules.get(name, "fxrequired")
-        level = required and "Toplevel" in required
-        if not path:
-            utils.fatal_error("No path found in .gitmodules for {}".format(name))
-        newpath = os.path.join(root_dir, path)
-        logger.debug("newpath is {}".format(newpath))
-        if not os.path.exists(os.path.join(newpath, ".git")):
-            rootgit = GitInterface(root_dir, logger)
-            # submodule commands use path, not name
-            url = url.replace("git@github.com:", "https://github.com/")
-            tags = rootgit.git_operation("ls-remote", "--tags", url)
-            result = rootgit.git_operation("submodule","status",newpath).split()
-            ahash = None
-            if result:
-                ahash = result[0][1:]
-            hhash = None
-            atag = None
+        submod = init_submodule_from_gitmodules(gitmodules, name, root_dir, logger)
+            
+        result,n,l,t = submod.status()
+        if toplevel or not submod.toplevel():
+            print(wrapper.fill(result))
+            testfails += t
+            localmods += l
+            needsupdate += n
+        subdir = os.path.join(root_dir, submod.path)
+        if os.path.exists(os.path.join(subdir, ".gitmodules")):
+            gsubmod = GitModules(logger, confpath=subdir)
+            t,l,n = submodules_status(gsubmod, subdir, depth=depth+1)
+            if toplevel or not submod.toplevel():
+                testfails += t
+                localmods += l
+                needsupdate += n
             
-            needsupdate += 1
-            if not toplevel and level:
-                continue
-            for htag in tags.split("\n"):
-                if htag.endswith('^{}'):
-                    htag = htag[:-3]
-                if ahash and not atag and ahash in htag:
-                    atag = (htag.split()[1])[10:]
-                if tag and not hhash and htag.endswith(tag):
-                    hhash = htag.split()[0]
-                if hhash and atag:
-                    break
-            optional = " (optional)" if required and "Optional" in required else ""
-            if tag and (ahash == hhash or atag == tag):
-                print(f"e {name:>20} not checked out, aligned at tag {tag}{optional}")
-            elif tag:
-                ahash = rootgit.git_operation(
-                    "submodule", "status", "{}".format(path)
-                ).rstrip()
-                ahash = ahash[1 : len(tag) + 1]
-                if tag == ahash:
-                    print(f"e {name:>20} not checked out, aligned at hash {ahash}{optional}")
-                else:
-                    print(
-                        f"e {name:>20} not checked out, out of sync at tag {atag}, expected tag is {tag}{optional}"
-                    )
-                    testfails += 1
-            else:
-                print(f"e {name:>20} has no fxtag defined in .gitmodules{optional}")
-                testfails += 1
-        else:
-            with utils.pushd(newpath):
-                git = GitInterface(newpath, logger)
-                atag = git.git_operation("describe", "--tags", "--always").rstrip()
-                ahash =  git.git_operation("rev-list", "HEAD").partition("\n")[0]
-                rurl = git.git_operation("ls-remote","--get-url").rstrip()
-                if rurl != url:
-                    remote = add_remote(git, url)
-                    git.git_operation("fetch", remote)
-                if tag and atag == tag:
-                    print(f"  {name:>20} at tag {tag}")
-                elif tag and ahash[: len(tag)] == tag:
-                    print(f"  {name:>20} at hash {ahash}")
-                elif atag == ahash:
-                    print(f"  {name:>20} at hash {ahash}")
-                elif tag:
-                    print(
-                        f"s {name:>20} {atag} {ahash} is out of sync with .gitmodules {tag}"
-                    )
-                    testfails += 1
-                    needsupdate += 1
-                else:
-                    print(
-                        f"e {name:>20} has no fxtag defined in .gitmodules, module at {atag}"
-                    )
-                    testfails += 1
-
-                status = git.git_operation("status", "--ignore-submodules", "-uno")
-                if "nothing to commit" not in status:
-                    localmods = localmods + 1
-                    print("M" + textwrap.indent(status, "                      "))
-
     return testfails, localmods, needsupdate
 
+def git_toplevelroot(root_dir, logger):
+    rgit = GitInterface(root_dir, logger)
+    _, superroot = rgit.git_operation("rev-parse", "--show-superproject-working-tree")
+    return superroot
 
 def submodules_update(gitmodules, root_dir, requiredlist, force):
-    _, localmods, needsupdate = submodules_status(gitmodules, root_dir)
-
-    if localmods and not force:
-        local_mods_output()
-        return
-    if needsupdate == 0:
-        return
-
     for name in gitmodules.sections():
-        fxtag = gitmodules.get(name, "fxtag")
-        path = gitmodules.get(name, "path")
-        url = gitmodules.get(name, "url")
-        logger.info(
-            "name={} path={} url={} fxtag={} requiredlist={} ".format(
-                name, os.path.join(root_dir, path), url, fxtag, requiredlist
-            )
-        )
-
-        fxrequired = gitmodules.get(name, "fxrequired")
-        assert fxrequired in fxrequired_allowed_values()
-        rgit = GitInterface(root_dir, logger)
-        superroot = rgit.git_operation("rev-parse", "--show-superproject-working-tree")
-
-        fxsparse = gitmodules.get(name, "fxsparse")
-
+        submod = init_submodule_from_gitmodules(gitmodules, name, root_dir, logger)
+    
+        _, needsupdate, localmods, testfails = submod.status()
+        if not submod.fxrequired:
+            submod.fxrequired = "AlwaysRequired"
+        fxrequired = submod.fxrequired    
+        allowedvalues = fxrequired_allowed_values()
+        assert fxrequired in allowedvalues
+
+        superroot = git_toplevelroot(root_dir, logger)
+                                     
         if (
             fxrequired
-            and (superroot and "Toplevel" in fxrequired)
-            or fxrequired not in requiredlist
+            and ((superroot and "Toplevel" in fxrequired)
+            or fxrequired not in requiredlist)
         ):
-            if "ToplevelOptional" == fxrequired:
-                print("Skipping optional component {}".format(name))
-            continue
-        if fxsparse:
-            logger.debug(
-                "Callng submodule_sparse_checkout({}, {}, {}, {}, {}, {}".format(
-                    root_dir, name, url, path, fxsparse, fxtag
-                )
-            )
-            submodule_sparse_checkout(root_dir, name, url, path, fxsparse, tag=fxtag)
-        else:
-            logger.info(
-                "Calling submodule_checkout({},{},{},{})".format(
-                    root_dir, name, path, url
-                )
-            )
-
-            single_submodule_checkout(
-                root_dir,
-                name,
-                path,
-                url=url,
-                tag=fxtag,
-                force=force,
-                optional=("AlwaysOptional" in requiredlist),
-            )
-
-        if os.path.exists(os.path.join(path, ".git")):
-            submoddir = os.path.join(root_dir, path)
-            with utils.pushd(submoddir):
-                git = GitInterface(submoddir, logger)
-                # first make sure the url is correct
-                upstream = git.git_operation("ls-remote", "--get-url").rstrip()
-                newremote = "origin"
-                if upstream != url:
-                    add_remote(git, url)
-
-                tags = git.git_operation("tag", "-l")
-                if fxtag and fxtag not in tags:
-                    git.git_operation("fetch", newremote, "--tags")
-                atag = git.git_operation("describe", "--tags", "--always").rstrip()
-                if fxtag and fxtag != atag:
-                    try:
-                        git.git_operation("checkout", fxtag)
-                        print(f"{name:>20} updated to {fxtag}")
-                    except Exception as error:
-                        print(error)
-                elif not fxtag:
-                    print(f"No fxtag found for submodule {name:>20}")
-                else:
-                    print(f"{name:>20} up to date.")
-
+            if "Optional" in fxrequired and "Optional" not in requiredlist:
+                if fxrequired.startswith("Always"):
+                    print(f"Skipping optional component {name:>20}")
+                continue
+        optional = "AlwaysOptional" in requiredlist
 
+        if fxrequired in requiredlist:
+            submod.update()
+            repodir = os.path.join(root_dir, submod.path)
+            if os.path.exists(os.path.join(repodir, ".gitmodules")):
+                # recursively handle this checkout
+                print(f"Recursively checking out submodules of {name}")
+                gitsubmodules = GitModules(submod.logger, confpath=repodir)
+                newrequiredlist = ["AlwaysRequired"]
+                if optional:
+                    newrequiredlist.append("AlwaysOptional")
 
+                submodules_update(gitsubmodules, repodir, newrequiredlist, force=force)
 
 def local_mods_output():
     text = """\
@@ -469,62 +266,6 @@ def local_mods_output():
 """
     print(text)
 
-
-# checkout is done by update if required so this function may be depricated
-def submodules_checkout(gitmodules, root_dir, requiredlist, force=False):
-    """
-    This function checks out all git submodules based on the provided parameters.
-
-    Parameters:
-    gitmodules (ConfigParser): The gitmodules configuration.
-    root_dir (str): The root directory for the git operation.
-    requiredlist (list): The list of required modules.
-    force (bool, optional): If set to True, forces the checkout operation. Defaults to False.
-
-    Returns:
-    None
-    """
-    # function implementation...
-    print("")
-    _, localmods, needsupdate = submodules_status(gitmodules, root_dir)
-    if localmods and not force:
-        local_mods_output()
-        return
-    if not needsupdate:
-        return
-    for name in gitmodules.sections():
-        fxrequired = gitmodules.get(name, "fxrequired")
-        fxsparse = gitmodules.get(name, "fxsparse")
-        fxtag = gitmodules.get(name, "fxtag")
-        path = gitmodules.get(name, "path")
-        url = gitmodules.get(name, "url")
-        if fxrequired and fxrequired not in requiredlist:
-            if "Optional" in fxrequired:
-                print("Skipping optional component {}".format(name))
-            continue
-
-        if fxsparse:
-            logger.debug(
-                "Callng submodule_sparse_checkout({}, {}, {}, {}, {}, {}".format(
-                    root_dir, name, url, path, fxsparse, fxtag
-                )
-            )
-            submodule_sparse_checkout(root_dir, name, url, path, fxsparse, tag=fxtag)
-        else:
-            logger.debug(
-                "Calling submodule_checkout({},{},{})".format(root_dir, name, path)
-            )
-            single_submodule_checkout(
-                root_dir,
-                name,
-                path,
-                url=url,
-                tag=fxtag,
-                force=force,
-                optional="AlwaysOptional" in requiredlist,
-            )
-
-
 def submodules_test(gitmodules, root_dir):
     """
     This function tests the git submodules based on the provided parameters.
@@ -547,7 +288,7 @@ def submodules_test(gitmodules, root_dir):
     # and that sparse checkout files exist
     for name in gitmodules.sections():
         url = gitmodules.get(name, "url")
-        fxurl = gitmodules.get(name, "fxDONOTMODIFYurl")
+        fxurl = gitmodules.get(name, "fxDONOTUSEurl")
         fxsparse = gitmodules.get(name, "fxsparse")
         path = gitmodules.get(name, "path")
         fxurl = fxurl[:-4] if fxurl.endswith(".git") else fxurl
@@ -601,7 +342,7 @@ def main():
         excludelist=excludelist,
     )
     if not gitmodules.sections():
-        sys.exit("No submodule components found")
+        sys.exit(f"No submodule components found, root_dir={root_dir}")
     retval = 0
     if action == "update":
         submodules_update(gitmodules, root_dir, fxrequired, force)
diff --git a/.lib/git-fleximod/git_fleximod/gitinterface.py b/.lib/git-fleximod/git_fleximod/gitinterface.py
index 93ae38ecde..fb20883cd0 100644
--- a/.lib/git-fleximod/git_fleximod/gitinterface.py
+++ b/.lib/git-fleximod/git_fleximod/gitinterface.py
@@ -49,20 +49,31 @@ def _init_git_repo(self):
 
     # pylint: disable=unused-argument
     def git_operation(self, operation, *args, **kwargs):
-        command = self._git_command(operation, *args)
-        self.logger.info(command)
+        newargs = []
+        for a in args:
+            # Do not use ssh interface
+            if isinstance(a, str):
+                a = a.replace("git@github.com:", "https://github.com/")
+            newargs.append(a)
+
+        command = self._git_command(operation, *newargs)
         if isinstance(command, list):
             try:
-                return utils.execute_subprocess(command, output_to_caller=True)
+                status, output = utils.execute_subprocess(command, status_to_caller=True, output_to_caller=True)
+                return status, output.rstrip()
             except Exception as e:
                 sys.exit(e)
         else:
-            return command
+            return 0, command
 
     def config_get_value(self, section, name):
         if self._use_module:
             config = self.repo.config_reader()
-            return config.get_value(section, name)
+            try:
+                val = config.get_value(section, name)
+            except:
+                val = None
+            return val
         else:
             cmd = ("git", "-C", str(self.repo_path), "config", "--get", f"{section}.{name}")
             output = utils.execute_subprocess(cmd, output_to_caller=True)
@@ -71,6 +82,8 @@ def config_get_value(self, section, name):
     def config_set_value(self, section, name, value):
         if self._use_module:
             with self.repo.config_writer() as writer:
+                if "." in section:  
+                    section = section.replace("."," \"")+'"'           
                 writer.set_value(section, name, value)
             writer.release()  # Ensure changes are saved
         else:
diff --git a/.lib/git-fleximod/git_fleximod/gitmodules.py b/.lib/git-fleximod/git_fleximod/gitmodules.py
index 7e4e05394a..cf8b350dd6 100644
--- a/.lib/git-fleximod/git_fleximod/gitmodules.py
+++ b/.lib/git-fleximod/git_fleximod/gitmodules.py
@@ -1,4 +1,4 @@
-import shutil
+import shutil, os
 from pathlib import Path
 from configparser import RawConfigParser, ConfigParser
 from .lstripreader import LstripReader
diff --git a/.lib/git-fleximod/git_fleximod/submodule.py b/.lib/git-fleximod/git_fleximod/submodule.py
new file mode 100644
index 0000000000..75d9dd4eb9
--- /dev/null
+++ b/.lib/git-fleximod/git_fleximod/submodule.py
@@ -0,0 +1,427 @@
+import os
+import textwrap
+import shutil
+import string
+from configparser import NoOptionError
+from git_fleximod import utils
+from git_fleximod.gitinterface import GitInterface
+
+class Submodule():
+    """
+    Represents a Git submodule with enhanced features for flexible management.
+
+    Attributes:
+        name (str): The name of the submodule.
+        root_dir (str): The root directory of the main project.
+        path (str): The relative path from the root directory to the submodule.
+        url (str): The URL of the submodule repository.
+        fxurl (str): The URL for flexible submodule management (optional).
+        fxtag (str): The tag for flexible submodule management (optional).
+        fxsparse (str): Path to the sparse checkout file relative to the submodule path, see git-sparse-checkout for details (optional).
+        fxrequired (str): Indicates if the submodule is optional or required (optional).
+        logger (logging.Logger): Logger instance for logging (optional).
+    """
+    def __init__(self, root_dir, name, path, url, fxtag=None, fxurl=None, fxsparse=None, fxrequired=None, logger=None):
+        """
+        Initializes a new Submodule instance with the provided attributes.
+        """
+        self.name = name
+        self.root_dir = root_dir
+        self.path = path 
+        self.url = url
+        self.fxurl = fxurl
+        self.fxtag = fxtag
+        self.fxsparse = fxsparse
+        if fxrequired:
+            self.fxrequired = fxrequired
+        else:
+            self.fxrequired = "AlwaysRequired"
+        self.logger = logger
+       
+    def status(self):
+        """
+        Checks the status of the submodule and returns 4 parameters:
+        - result (str): The status of the submodule.
+        - needsupdate (bool): An indicator if the submodule needs to be updated.
+        - localmods (bool): An indicator if the submodule has local modifications.
+        - testfails (bool): An indicator if the submodule has failed a test, this is used for testing purposes.        
+        """
+
+        smpath = os.path.join(self.root_dir, self.path)
+        testfails = False
+        localmods = False
+        needsupdate = False
+        ahash = None
+        optional = ""
+        if "Optional" in self.fxrequired:
+            optional = " (optional)" 
+        required = None
+        level = None
+        if not os.path.exists(os.path.join(smpath, ".git")):
+            rootgit = GitInterface(self.root_dir, self.logger)
+            # submodule commands use path, not name
+            status, tags = rootgit.git_operation("ls-remote", "--tags", self.url)
+            status, result = rootgit.git_operation("submodule","status",smpath)
+            result = result.split()
+            
+            if result:
+                ahash = result[0][1:]
+            hhash = None
+            atag = None
+            for htag in tags.split("\n"):
+                if htag.endswith('^{}'):
+                    htag = htag[:-3]
+                if ahash and not atag and ahash in htag:
+                    atag = (htag.split()[1])[10:]
+                if self.fxtag and not hhash and htag.endswith(self.fxtag):
+                    hhash = htag.split()[0]
+                if hhash and atag:
+                    break
+            if self.fxtag and (ahash == hhash or atag == self.fxtag):
+                result = f"e {self.name:>20} not checked out, aligned at tag {self.fxtag}{optional}"
+                needsupdate = True
+            elif self.fxtag:
+                status, ahash = rootgit.git_operation(
+                    "submodule", "status", "{}".format(self.path)
+                )
+                ahash = ahash[1 : len(self.fxtag) + 1]
+                if self.fxtag == ahash:
+                    result = f"e {self.name:>20} not checked out, aligned at hash {ahash}{optional}"
+                else:
+                    result = f"e {self.name:>20} not checked out, out of sync at tag {atag}, expected tag is {self.fxtag}{optional}"
+                    testfails = True
+                needsupdate = True
+            else:
+                result = f"e {self.name:>20} has no fxtag defined in .gitmodules{optional}"
+                testfails = False
+        else:
+            with utils.pushd(smpath):
+                git = GitInterface(smpath, self.logger)
+                status, remote = git.git_operation("remote")
+                if remote == '':
+                    result = f"e {self.name:>20} has no associated remote"
+                    testfails = True
+                    needsupdate = True
+                    return result, needsupdate, localmods, testfails                    
+                status, rurl = git.git_operation("ls-remote","--get-url")
+                status, lines = git.git_operation("log", "--pretty=format:\"%h %d\"")
+                line = lines.partition('\n')[0]
+                parts = line.split()
+                ahash = parts[0][1:]
+                atag = None
+                if len(parts) > 3:
+                    idx = 0
+                    while idx < len(parts)-1:
+                        idx = idx+1
+                        if parts[idx] == 'tag:':
+                            atag = parts[idx+1]
+                            while atag.endswith(')') or atag.endswith(',') or atag.endswith("\""):
+                                atag = atag[:-1]
+                            if atag == self.fxtag:
+                                break
+
+                
+                #print(f"line is {line} ahash is {ahash} atag is {atag} {parts}")
+                #                atag = git.git_operation("describe", "--tags", "--always")
+                # ahash =  git.git_operation("rev-list", "HEAD").partition("\n")[0]
+                    
+                recurse = False
+                if rurl != self.url:
+                    remote = self._add_remote(git)
+                    git.git_operation("fetch", remote)
+                if self.fxtag and atag == self.fxtag:
+                    result = f"  {self.name:>20} at tag {self.fxtag}"
+                    recurse = True
+                    testfails = False
+                elif self.fxtag and (ahash[: len(self.fxtag)] == self.fxtag or (self.fxtag.find(ahash)==0)):
+                    result = f"  {self.name:>20} at hash {ahash}"
+                    recurse = True
+                    testfails = False
+                elif atag == ahash:
+                    result = f"  {self.name:>20} at hash {ahash}"
+                    recurse = True
+                elif self.fxtag:
+                    result = f"s {self.name:>20} {atag} {ahash} is out of sync with .gitmodules {self.fxtag}"
+                    testfails = True
+                    needsupdate = True
+                else:
+                    if atag:
+                        result = f"e {self.name:>20} has no fxtag defined in .gitmodules, module at {atag}"
+                    else:
+                        result = f"e {self.name:>20} has no fxtag defined in .gitmodules, module at {ahash}"
+                    testfails = False
+                    
+                status, output = git.git_operation("status", "--ignore-submodules", "-uno")
+                if "nothing to commit" not in output:
+                    localmods = True
+                    result = "M" + textwrap.indent(output, "                      ")
+#        print(f"result {result} needsupdate {needsupdate} localmods {localmods} testfails {testfails}")
+        return result, needsupdate, localmods, testfails
+
+    
+    def _add_remote(self, git):
+        """
+        Adds a new remote to the submodule if it does not already exist.
+
+        This method checks the existing remotes of the submodule. If the submodule's URL is not already listed as a remote,
+        it attempts to add a new remote. The name for the new remote is generated dynamically to avoid conflicts. If no
+        remotes exist, it defaults to naming the new remote 'origin'.
+
+        Args:
+            git (GitInterface): An instance of GitInterface to perform git operations.
+
+        Returns:
+            str: The name of the new remote if added, or the name of the existing remote that matches the submodule's URL.
+        """ 
+        status, remotes = git.git_operation("remote", "-v")
+        remotes = remotes.splitlines()
+        upstream = None
+        if remotes:
+            status, upstream = git.git_operation("ls-remote", "--get-url")
+            newremote = "newremote.00"
+            tmpurl = self.url.replace("git@github.com:", "https://github.com/")
+            line = next((s for s in remotes if self.url in s or tmpurl in s), None)
+            if line:
+                newremote = line.split()[0]
+                return newremote
+            else:
+                i = 0
+                while newremote in remotes:
+                    i = i + 1
+                    newremote = f"newremote.{i:02d}"
+        else:
+            newremote = "origin"
+        git.git_operation("remote", "add", newremote, self.url)
+        return newremote
+
+    def toplevel(self):
+        """
+        Returns True if the submodule is Toplevel (either Required or Optional)
+        """
+        return True if "Top" in self.fxrequired else False
+
+    def sparse_checkout(self):
+        """
+        Performs a sparse checkout of the submodule.
+
+        This method optimizes the checkout process by only checking out files specified in the submodule's sparse-checkout configuration,
+        rather than the entire submodule content. It achieves this by first ensuring the `.git/info/sparse-checkout` file is created and
+        configured in the submodule's directory. Then, it proceeds to checkout the desired tag. If the submodule has already been checked out,
+        this method will not perform the checkout again.
+
+        This approach is particularly beneficial for submodules with a large number of files, as it significantly reduces the time and disk space
+        required for the checkout process by avoiding the unnecessary checkout and subsequent removal of unneeded files.
+
+        Returns:
+            None
+        """ 
+        self.logger.info("Called sparse_checkout for {}".format(self.name))
+        rgit = GitInterface(self.root_dir, self.logger)
+        status, superroot = rgit.git_operation("rev-parse", "--show-superproject-working-tree")
+        if superroot:
+            gitroot = superroot.strip()
+        else:
+            gitroot = self.root_dir
+        # Now need to move the .git dir to the submodule location
+        rootdotgit = os.path.join(self.root_dir, ".git")
+        while os.path.isfile(rootdotgit):
+            with open(rootdotgit) as f:
+                line = f.readline().rstrip()
+                if line.startswith("gitdir: "):
+                    rootdotgit = os.path.abspath(os.path.join(self.root_dir,line[8:]))
+        assert os.path.isdir(rootdotgit)
+        # first create the module directory
+        if not os.path.isdir(os.path.join(self.root_dir, self.path)):
+            os.makedirs(os.path.join(self.root_dir, self.path))
+
+        # initialize a new git repo and set the sparse checkout flag
+        sprep_repo = os.path.join(self.root_dir, self.path)
+        sprepo_git = GitInterface(sprep_repo, self.logger)
+        if os.path.exists(os.path.join(sprep_repo, ".git")):
+            try:
+                self.logger.info("Submodule {} found".format(self.name))
+                chk = sprepo_git.config_get_value("core", "sparseCheckout")
+                if chk == "true":
+                    self.logger.info("Sparse submodule {} already checked out".format(self.name))
+                    return
+            except (NoOptionError):
+                self.logger.debug("Sparse submodule {} not present".format(self.name))
+            except Exception as e:
+                utils.fatal_error("Unexpected error {} occured.".format(e))
+
+        sprepo_git.config_set_value("core", "sparseCheckout", "true")
+
+        # set the repository remote
+        
+        self.logger.info("Setting remote origin in {}/{}".format(self.root_dir, self.path))
+        status, remotes = sprepo_git.git_operation("remote", "-v")
+        if self.url not in remotes:
+            sprepo_git.git_operation("remote", "add", "origin", self.url)
+
+        topgit = os.path.join(gitroot, ".git")
+
+        if gitroot != self.root_dir and os.path.isfile(os.path.join(self.root_dir, ".git")):
+            with open(os.path.join(self.root_dir, ".git")) as f:
+                gitpath = os.path.relpath(
+                    os.path.join(self.root_dir, f.read().split()[1]),
+                    start=os.path.join(self.root_dir, self.path),
+                )
+                rootdotgit = os.path.join(gitpath, "modules", self.name)
+        else:
+            rootdotgit = os.path.relpath(
+                os.path.join(self.root_dir, ".git", "modules", self.name),
+                start=os.path.join(self.root_dir, self.path),
+            )
+
+        if os.path.isdir(os.path.join(self.root_dir, self.path, ".git")):
+            with utils.pushd(sprep_repo):
+                if os.path.isdir(os.path.join(rootdotgit,".git")):
+                    shutil.rmtree(os.path.join(rootdotgit,".git"))
+                shutil.move(".git", rootdotgit)
+                with open(".git", "w") as f:
+                    f.write("gitdir: " + os.path.relpath(rootdotgit))
+                infodir = os.path.join(rootdotgit, "info")
+                if not os.path.isdir(infodir):
+                    os.makedirs(infodir)
+                gitsparse = os.path.abspath(os.path.join(infodir, "sparse-checkout"))
+            if os.path.isfile(gitsparse):
+                self.logger.warning(
+                    "submodule {} is already initialized {}".format(self.name, rootdotgit)
+                )
+                return
+
+            with utils.pushd(sprep_repo):
+                if os.path.isfile(self.fxsparse):
+                    
+                    shutil.copy(self.fxsparse, gitsparse)
+                
+
+        # Finally checkout the repo
+        sprepo_git.git_operation("fetch", "origin", "--tags")
+        status,_ = sprepo_git.git_operation("checkout", self.fxtag)
+        if status:
+            print(f"Error checking out {self.name:>20} at {self.fxtag}")
+        else:
+            print(f"Successfully checked out {self.name:>20} at {self.fxtag}")
+        rgit.config_set_value('submodule.' + self.name, "active", "true")
+        rgit.config_set_value('submodule.' + self.name, "url", self.url)
+        rgit.config_set_value('submodule.' + self.name, "path", self.path)
+
+    def update(self):
+        """
+        Updates the submodule to the latest or specified version.
+
+        This method handles the update process of the submodule, including checking out the submodule into the specified path,
+        handling sparse checkouts if configured, and updating the submodule's URL if necessary. It supports both SSH and HTTPS URLs,
+        automatically converting SSH URLs to HTTPS to avoid issues for users without SSH keys.
+
+        The update process involves the following steps:
+        1. If the submodule is configured for sparse checkout, it performs a sparse checkout.
+        2. If the submodule is not already checked out, it clones the submodule using the provided URL.
+        3. If a specific tag or hash is provided, it checks out that tag; otherwise, it checks out the latest version.
+        4. If the root `.git` is a file (indicating a submodule or a worktree), additional steps are taken to integrate the submodule properly.
+
+        Args:
+           None
+        Note:
+            - SSH URLs are automatically converted to HTTPS to accommodate users without SSH keys.
+
+        Returns:
+            None
+        """
+        git = GitInterface(self.root_dir, self.logger)
+        repodir = os.path.join(self.root_dir, self.path)
+        self.logger.info("Checkout {} into {}/{}".format(self.name, self.root_dir, self.path))
+        # if url is provided update to the new url
+        tag = None
+        repo_exists = False
+        if os.path.exists(os.path.join(repodir, ".git")):
+            self.logger.info("Submodule {} already checked out".format(self.name))
+            repo_exists = True
+        # Look for a .gitmodules file in the newly checkedout repo
+        if self.fxsparse:
+            print(f"Sparse checkout {self.name} fxsparse {self.fxsparse}")
+            self.sparse_checkout()
+        else:
+            if not repo_exists and self.url:
+                # ssh urls cause problems for those who dont have git accounts with ssh keys defined
+                # but cime has one since e3sm prefers ssh to https, because the .gitmodules file was
+                # opened with a GitModules object we don't need to worry about restoring the file here
+                # it will be done by the GitModules class
+                if self.url.startswith("git@"):
+                    git.git_operation("clone", self.url, self.path)
+                    smgit = GitInterface(repodir, self.logger)
+                    if not tag:
+                        status, tag = smgit.git_operation("describe", "--tags", "--always")
+                    smgit.git_operation("checkout", tag)
+                    # Now need to move the .git dir to the submodule location
+                    rootdotgit = os.path.join(self.root_dir, ".git")
+                    if os.path.isfile(rootdotgit):
+                        with open(rootdotgit) as f:
+                            line = f.readline()
+                            if line.startswith("gitdir: "):
+                                rootdotgit = line[8:]
+
+                    newpath = os.path.abspath(os.path.join(self.root_dir, rootdotgit, "modules", self.name))
+                    if os.path.exists(newpath):
+                        shutil.rmtree(os.path.join(repodir, ".git"))
+                    else:
+                        shutil.move(os.path.join(repodir, ".git"), newpath)
+                    
+                    with open(os.path.join(repodir, ".git"), "w") as f:
+                        f.write("gitdir: " + os.path.relpath(newpath, start=repodir))
+
+            if not os.path.exists(repodir):
+                parent = os.path.dirname(repodir)
+                if not os.path.isdir(parent):
+                    os.makedirs(parent)
+                git.git_operation("submodule", "add", "--name", self.name, "--", self.url, self.path) 
+
+            if not repo_exists:
+                git.git_operation("submodule", "update", "--init", "--", self.path)
+
+            if self.fxtag:        
+                smgit = GitInterface(repodir, self.logger)
+                newremote = self._add_remote(smgit)
+                # Trying to distingush a tag from a hash
+                allowed = set(string.digits + 'abcdef') 
+                if not set(self.fxtag) <= allowed:
+                    # This is a tag
+                    tag = f"refs/tags/{self.fxtag}:refs/tags/{self.fxtag}"
+                    smgit.git_operation("fetch", newremote, tag)
+                smgit.git_operation("checkout", self.fxtag)
+
+            if not os.path.exists(os.path.join(repodir, ".git")):
+                utils.fatal_error(
+                    f"Failed to checkout {self.name} {repo_exists} {repodir} {self.path}"
+                )
+                
+
+        if os.path.exists(os.path.join(self.path, ".git")):
+            submoddir = os.path.join(self.root_dir, self.path)
+            with utils.pushd(submoddir):
+                git = GitInterface(submoddir, self.logger)
+                # first make sure the url is correct
+                newremote = self._add_remote(git)
+                status, tags = git.git_operation("tag", "-l")
+                fxtag = self.fxtag
+                if fxtag and fxtag not in tags:
+                    git.git_operation("fetch", newremote, "--tags")
+                status, atag = git.git_operation("describe", "--tags", "--always")
+                if fxtag and fxtag != atag:
+                    try:
+                        status, _ = git.git_operation("checkout", fxtag)
+                        if not status:
+                            print(f"{self.name:>20} updated to {fxtag}")
+                    except Exception as error:
+                        print(error)
+                    
+
+                elif not fxtag:
+                    print(f"No fxtag found for submodule {self.name:>20}")
+                else:
+                    print(f"{self.name:>20} up to date.")
+
+
+                
+        return
diff --git a/.lib/git-fleximod/git_fleximod/utils.py b/.lib/git-fleximod/git_fleximod/utils.py
index 1a2d5ccf2f..c4f43d5238 100644
--- a/.lib/git-fleximod/git_fleximod/utils.py
+++ b/.lib/git-fleximod/git_fleximod/utils.py
@@ -307,12 +307,12 @@ def execute_subprocess(commands, status_to_caller=False, output_to_caller=False)
         # simple status check. If returning, it is the callers
         # responsibility determine if an error occurred and handle it
         # appropriately.
+        msg_context = (
+            "Process did not run successfully; "
+            "returned status {0}".format(error.returncode)
+        )
+        msg = failed_command_msg(msg_context, commands, output=error.output)
         if not return_to_caller:
-            msg_context = (
-                "Process did not run successfully; "
-                "returned status {0}".format(error.returncode)
-            )
-            msg = failed_command_msg(msg_context, commands, output=error.output)
             logging.error(error)
             logging.error(msg)
             log_process_output(error.output)
diff --git a/.lib/git-fleximod/poetry.lock b/.lib/git-fleximod/poetry.lock
index b59ed3942c..ac82fb0d97 100644
--- a/.lib/git-fleximod/poetry.lock
+++ b/.lib/git-fleximod/poetry.lock
@@ -13,13 +13,13 @@ files = [
 
 [[package]]
 name = "babel"
-version = "2.14.0"
+version = "2.15.0"
 description = "Internationalization utilities"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
 files = [
-    {file = "Babel-2.14.0-py3-none-any.whl", hash = "sha256:efb1a25b7118e67ce3a259bed20545c29cb68be8ad2c784c83689981b7a57287"},
-    {file = "Babel-2.14.0.tar.gz", hash = "sha256:6919867db036398ba21eb5c7a0f6b28ab8cbc3ae7a73a44ebe34ae74a4e7d363"},
+    {file = "Babel-2.15.0-py3-none-any.whl", hash = "sha256:08706bdad8d0a3413266ab61bd6c34d0c28d6e1e7badf40a2cebe67644e2e1fb"},
+    {file = "babel-2.15.0.tar.gz", hash = "sha256:8daf0e265d05768bc6c7a314cf1321e9a123afc328cc635c18622a2f30a04413"},
 ]
 
 [package.dependencies]
@@ -30,13 +30,13 @@ dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"]
 
 [[package]]
 name = "certifi"
-version = "2024.2.2"
+version = "2024.8.30"
 description = "Python package for providing Mozilla's CA Bundle."
 optional = false
 python-versions = ">=3.6"
 files = [
-    {file = "certifi-2024.2.2-py3-none-any.whl", hash = "sha256:dc383c07b76109f368f6106eee2b593b04a011ea4d55f652c6ca24a754d1cdd1"},
-    {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"},
+    {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"},
+    {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"},
 ]
 
 [[package]]
@@ -162,13 +162,13 @@ files = [
 
 [[package]]
 name = "exceptiongroup"
-version = "1.2.0"
+version = "1.2.1"
 description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "exceptiongroup-1.2.0-py3-none-any.whl", hash = "sha256:4bfd3996ac73b41e9b9628b04e079f193850720ea5945fc96a08633c66912f14"},
-    {file = "exceptiongroup-1.2.0.tar.gz", hash = "sha256:91f5c769735f051a4290d52edd0858999b57e5876e9f85937691bd4c9fa3ed68"},
+    {file = "exceptiongroup-1.2.1-py3-none-any.whl", hash = "sha256:5258b9ed329c5bbdd31a309f53cbfb0b155341807f6ff7606a1e801a891b29ad"},
+    {file = "exceptiongroup-1.2.1.tar.gz", hash = "sha256:a4785e48b045528f5bfe627b6ad554ff32def154f42372786903b7abcfe1aa16"},
 ]
 
 [package.extras]
@@ -225,30 +225,31 @@ smmap = ">=3.0.1,<6"
 
 [[package]]
 name = "gitpython"
-version = "3.1.41"
+version = "3.1.43"
 description = "GitPython is a Python library used to interact with Git repositories"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "GitPython-3.1.41-py3-none-any.whl", hash = "sha256:c36b6634d069b3f719610175020a9aed919421c87552185b085e04fbbdb10b7c"},
-    {file = "GitPython-3.1.41.tar.gz", hash = "sha256:ed66e624884f76df22c8e16066d567aaa5a37d5b5fa19db2c6df6f7156db9048"},
+    {file = "GitPython-3.1.43-py3-none-any.whl", hash = "sha256:eec7ec56b92aad751f9912a73404bc02ba212a23adb2c7098ee668417051a1ff"},
+    {file = "GitPython-3.1.43.tar.gz", hash = "sha256:35f314a9f878467f5453cc1fee295c3e18e52f1b99f10f6cf5b1682e968a9e7c"},
 ]
 
 [package.dependencies]
 gitdb = ">=4.0.1,<5"
 
 [package.extras]
-test = ["black", "coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar", "sumtypes"]
+doc = ["sphinx (==4.3.2)", "sphinx-autodoc-typehints", "sphinx-rtd-theme", "sphinxcontrib-applehelp (>=1.0.2,<=1.0.4)", "sphinxcontrib-devhelp (==1.0.2)", "sphinxcontrib-htmlhelp (>=2.0.0,<=2.0.1)", "sphinxcontrib-qthelp (==1.0.3)", "sphinxcontrib-serializinghtml (==1.1.5)"]
+test = ["coverage[toml]", "ddt (>=1.1.1,!=1.4.3)", "mock", "mypy", "pre-commit", "pytest (>=7.3.1)", "pytest-cov", "pytest-instafail", "pytest-mock", "pytest-sugar", "typing-extensions"]
 
 [[package]]
 name = "idna"
-version = "3.6"
+version = "3.7"
 description = "Internationalized Domain Names in Applications (IDNA)"
 optional = false
 python-versions = ">=3.5"
 files = [
-    {file = "idna-3.6-py3-none-any.whl", hash = "sha256:c05567e9c24a6b9faaa835c4821bad0590fbb9d5779e7caa6e1cc4978e7eb24f"},
-    {file = "idna-3.6.tar.gz", hash = "sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca"},
+    {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"},
+    {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"},
 ]
 
 [[package]]
@@ -264,22 +265,22 @@ files = [
 
 [[package]]
 name = "importlib-metadata"
-version = "7.0.1"
+version = "8.0.0"
 description = "Read metadata from Python packages"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "importlib_metadata-7.0.1-py3-none-any.whl", hash = "sha256:4805911c3a4ec7c3966410053e9ec6a1fecd629117df5adee56dfc9432a1081e"},
-    {file = "importlib_metadata-7.0.1.tar.gz", hash = "sha256:f238736bb06590ae52ac1fab06a3a9ef1d8dce2b7a35b5ab329371d6c8f5d2cc"},
+    {file = "importlib_metadata-8.0.0-py3-none-any.whl", hash = "sha256:15584cf2b1bf449d98ff8a6ff1abef57bf20f3ac6454f431736cd3e660921b2f"},
+    {file = "importlib_metadata-8.0.0.tar.gz", hash = "sha256:188bd24e4c346d3f0a933f275c2fec67050326a856b9a359881d7c2a697e8812"},
 ]
 
 [package.dependencies]
 zipp = ">=0.5"
 
 [package.extras]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
+doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
 perf = ["ipython"]
-testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"]
+test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"]
 
 [[package]]
 name = "iniconfig"
@@ -294,13 +295,13 @@ files = [
 
 [[package]]
 name = "jinja2"
-version = "3.1.3"
+version = "3.1.4"
 description = "A very fast and expressive template engine."
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "Jinja2-3.1.3-py3-none-any.whl", hash = "sha256:7d6d50dd97d52cbc355597bd845fabfbac3f551e1f99619e39a35ce8c370b5fa"},
-    {file = "Jinja2-3.1.3.tar.gz", hash = "sha256:ac8bd6544d4bb2c9792bf3a159e80bba8fda7f07e81bc3aed565432d5925ba90"},
+    {file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"},
+    {file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"},
 ]
 
 [package.dependencies]
@@ -380,24 +381,24 @@ files = [
 
 [[package]]
 name = "packaging"
-version = "23.2"
+version = "24.1"
 description = "Core utilities for Python packages"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
 files = [
-    {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"},
-    {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"},
+    {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"},
+    {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
 ]
 
 [[package]]
 name = "pluggy"
-version = "1.4.0"
+version = "1.5.0"
 description = "plugin and hook calling mechanisms for python"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pluggy-1.4.0-py3-none-any.whl", hash = "sha256:7db9f7b503d67d1c5b95f59773ebb58a8c1c288129a88665838012cfb07b8981"},
-    {file = "pluggy-1.4.0.tar.gz", hash = "sha256:8c85c2876142a764e5b7548e7d9a0e0ddb46f5185161049a79b7e974454223be"},
+    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
+    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
 ]
 
 [package.extras]
@@ -406,39 +407,38 @@ testing = ["pytest", "pytest-benchmark"]
 
 [[package]]
 name = "pyfakefs"
-version = "5.3.5"
+version = "5.5.0"
 description = "pyfakefs implements a fake file system that mocks the Python file system modules."
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "pyfakefs-5.3.5-py3-none-any.whl", hash = "sha256:751015c1de94e1390128c82b48cdedc3f088bbdbe4bc713c79d02a27f0f61e69"},
-    {file = "pyfakefs-5.3.5.tar.gz", hash = "sha256:7cdc500b35a214cb7a614e1940543acc6650e69a94ac76e30f33c9373bd9cf90"},
+    {file = "pyfakefs-5.5.0-py3-none-any.whl", hash = "sha256:8dbf203ab7bef1529f11f7d41b9478b898e95bf9f3b71262163aac07a518cd76"},
+    {file = "pyfakefs-5.5.0.tar.gz", hash = "sha256:7448aaa07142f892d0a4eb52a5ed3206a9f02c6599e686cd97d624c18979c154"},
 ]
 
 [[package]]
 name = "pygments"
-version = "2.17.2"
+version = "2.18.0"
 description = "Pygments is a syntax highlighting package written in Python."
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
 files = [
-    {file = "pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c"},
-    {file = "pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367"},
+    {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"},
+    {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"},
 ]
 
 [package.extras]
-plugins = ["importlib-metadata"]
 windows-terminal = ["colorama (>=0.4.6)"]
 
 [[package]]
 name = "pytest"
-version = "8.0.0"
+version = "8.2.2"
 description = "pytest: simple powerful testing with Python"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pytest-8.0.0-py3-none-any.whl", hash = "sha256:50fb9cbe836c3f20f0dfa99c565201fb75dc54c8d76373cd1bde06b06657bdb6"},
-    {file = "pytest-8.0.0.tar.gz", hash = "sha256:249b1b0864530ba251b7438274c4d251c58d868edaaec8762893ad4a0d71c36c"},
+    {file = "pytest-8.2.2-py3-none-any.whl", hash = "sha256:c434598117762e2bd304e526244f67bf66bbd7b5d6cf22138be51ff661980343"},
+    {file = "pytest-8.2.2.tar.gz", hash = "sha256:de4bb8104e201939ccdc688b27a89a7be2079b22e2bd2b07f806b6ba71117977"},
 ]
 
 [package.dependencies]
@@ -446,11 +446,11 @@ colorama = {version = "*", markers = "sys_platform == \"win32\""}
 exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
 iniconfig = "*"
 packaging = "*"
-pluggy = ">=1.3.0,<2.0"
-tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""}
+pluggy = ">=1.5,<2.0"
+tomli = {version = ">=1", markers = "python_version < \"3.11\""}
 
 [package.extras]
-testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
+dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
 
 [[package]]
 name = "pytz"
@@ -465,13 +465,13 @@ files = [
 
 [[package]]
 name = "requests"
-version = "2.31.0"
+version = "2.32.3"
 description = "Python HTTP for Humans."
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
 files = [
-    {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"},
-    {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"},
+    {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"},
+    {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"},
 ]
 
 [package.dependencies]
@@ -643,13 +643,13 @@ files = [
 
 [[package]]
 name = "urllib3"
-version = "2.2.0"
+version = "2.2.2"
 description = "HTTP library with thread-safe connection pooling, file post, and more."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "urllib3-2.2.0-py3-none-any.whl", hash = "sha256:ce3711610ddce217e6d113a2732fafad960a03fd0318c91faa79481e35c11224"},
-    {file = "urllib3-2.2.0.tar.gz", hash = "sha256:051d961ad0c62a94e50ecf1af379c3aba230c66c710493493560c0c223c49f20"},
+    {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"},
+    {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"},
 ]
 
 [package.extras]
@@ -674,18 +674,18 @@ test = ["pytest (>=6.0.0)", "setuptools (>=65)"]
 
 [[package]]
 name = "zipp"
-version = "3.17.0"
+version = "3.19.2"
 description = "Backport of pathlib-compatible object wrapper for zip files"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "zipp-3.17.0-py3-none-any.whl", hash = "sha256:0e923e726174922dce09c53c59ad483ff7bbb8e572e00c7f7c46b88556409f31"},
-    {file = "zipp-3.17.0.tar.gz", hash = "sha256:84e64a1c28cf7e91ed2078bb8cc8c259cb19b76942096c8d7b84947690cabaf0"},
+    {file = "zipp-3.19.2-py3-none-any.whl", hash = "sha256:f091755f667055f2d02b32c53771a7a6c8b47e1fdbc4b72a8b9072b3eef8015c"},
+    {file = "zipp-3.19.2.tar.gz", hash = "sha256:bf1dcf6450f873a13e952a29504887c89e6de7506209e5b1bcc3460135d4de19"},
 ]
 
 [package.extras]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"]
-testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy (>=0.9.1)", "pytest-ruff"]
+doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
+test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
 
 [metadata]
 lock-version = "2.0"
diff --git a/.lib/git-fleximod/pyproject.toml b/.lib/git-fleximod/pyproject.toml
index 5b1332549c..1d0419ad20 100644
--- a/.lib/git-fleximod/pyproject.toml
+++ b/.lib/git-fleximod/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "git-fleximod"
-version = "0.7.8"
+version = "0.9.3"
 description = "Extended support for git-submodule and git-sparse-checkout"
 authors = ["Jim Edwards <jedwards@ucar.edu>"]
 maintainers = ["Jim Edwards <jedwards@ucar.edu>"]
diff --git a/.lib/git-fleximod/tbump.toml b/.lib/git-fleximod/tbump.toml
index c4f7ac96ea..b432206a54 100644
--- a/.lib/git-fleximod/tbump.toml
+++ b/.lib/git-fleximod/tbump.toml
@@ -2,7 +2,7 @@
 github_url = "https://github.com/jedwards4b/git-fleximod/"
 
 [version]
-current = "0.7.8"
+current = "0.9.3"
 
 # Example of a semver regexp.
 # Make sure this matches current_version before
diff --git a/.lib/git-fleximod/tests/conftest.py b/.lib/git-fleximod/tests/conftest.py
index 65ee85d23d..1dd1b86f34 100644
--- a/.lib/git-fleximod/tests/conftest.py
+++ b/.lib/git-fleximod/tests/conftest.py
@@ -32,7 +32,7 @@ def logger():
      "submodule_name": "test_optional",
      "status1" : "test_optional MPIserial_2.5.0-3-gd82ce7c is out of sync with .gitmodules MPIserial_2.4.0",
      "status2" : "test_optional at tag MPIserial_2.4.0",
-     "status3" : "test_optional not checked out, out of sync at tag None, expected tag is MPIserial_2.4.0 (optional)",
+     "status3" : "test_optional not checked out, out of sync at tag MPIserial_2.5.1, expected tag is MPIserial_2.4.0 (optional)",
      "status4" : "test_optional at tag MPIserial_2.4.0",
      "gitmodules_content": """
      [submodule "test_optional"]
@@ -46,7 +46,7 @@ def logger():
      "submodule_name": "test_alwaysoptional",
      "status1" : "test_alwaysoptional MPIserial_2.3.0 is out of sync with .gitmodules e5cf35c",
      "status2" : "test_alwaysoptional at hash e5cf35c",
-     "status3" : "out of sync at tag None, expected tag is e5cf35c",
+     "status3" : "out of sync at tag MPIserial_2.5.1, expected tag is e5cf35c",
      "status4" : "test_alwaysoptional at hash e5cf35c",
      "gitmodules_content": """
     [submodule "test_alwaysoptional"]
@@ -119,8 +119,20 @@ def complex_repo(tmp_path, logger):
     str_path = str(test_dir)
     gitp = GitInterface(str_path, logger)
     gitp.git_operation("remote", "add", "origin", "https://github.com/jedwards4b/fleximod-test2")
-    gitp.git_operation("fetch", "origin", "main")
-    gitp.git_operation("checkout", "main")
+    gitp.git_operation("fetch", "origin")
+    gitp.git_operation("checkout", "v0.0.1")
+    return test_dir
+
+@pytest.fixture
+def complex_update(tmp_path, logger):
+    test_dir = tmp_path / "testcomplex"
+    test_dir.mkdir()
+    str_path = str(test_dir)
+    gitp = GitInterface(str_path, logger)
+    gitp.git_operation("remote", "add", "origin", "https://github.com/jedwards4b/fleximod-test2")
+    gitp.git_operation("fetch", "origin")
+    gitp.git_operation("checkout", "v0.0.2")
+    
     return test_dir
     
 @pytest.fixture
diff --git a/.lib/git-fleximod/tests/test_e_complex_update.py b/.lib/git-fleximod/tests/test_e_complex_update.py
new file mode 100644
index 0000000000..0c3ab4c6a6
--- /dev/null
+++ b/.lib/git-fleximod/tests/test_e_complex_update.py
@@ -0,0 +1,69 @@
+import pytest
+from pathlib import Path
+from git_fleximod.gitinterface import GitInterface
+
+def test_complex_update(git_fleximod, complex_update, logger):
+    status = git_fleximod(complex_update, "status")
+    assert("ToplevelOptional not checked out, aligned at tag v5.3.2" in status.stdout)
+    assert("ToplevelRequired not checked out, aligned at tag MPIserial_2.5.0" in status.stdout)
+    assert("AlwaysRequired not checked out, aligned at tag MPIserial_2.4.0" in status.stdout)
+    assert("Complex not checked out, out of sync at tag testtag02, expected tag is testtag3" in status.stdout)
+    assert("AlwaysOptional not checked out, out of sync at tag None, expected tag is MPIserial_2.3.0" in status.stdout)
+    
+    # This should checkout and update test_submodule and complex_sub
+    result = git_fleximod(complex_update, "update")    
+    assert result.returncode == 0
+
+    status = git_fleximod(complex_update, "status")
+    assert("ToplevelOptional not checked out, aligned at tag v5.3.2" in status.stdout)
+    assert("ToplevelRequired at tag MPIserial_2.5.0" in status.stdout)
+    assert("AlwaysRequired at tag MPIserial_2.4.0" in status.stdout)
+    assert("Complex at tag testtag3" in status.stdout)
+
+    # now check the complex_sub
+    root = (complex_update / "modules" / "complex")
+    assert(not (root / "libraries" / "gptl" / ".git").exists())
+    assert(not (root / "libraries" / "mpi-serial" / ".git").exists())
+    assert((root / "modules" / "mpi-serialAR" / ".git").exists())
+    assert((root / "modules" / "mpi-serialSAR" / ".git").exists())
+    assert(not (root / "modules" / "mpi-serial2" / ".git").exists())
+    assert((root / "modules" / "mpi-sparse" / ".git").exists())
+    assert((root / "modules" / "mpi-sparse" / "m4").exists())
+    assert(not (root / "modules" / "mpi-sparse" / "README").exists())
+
+    # update a single optional submodule
+
+    result = git_fleximod(complex_update, "update ToplevelOptional")
+    assert result.returncode == 0
+
+    status = git_fleximod(complex_update, "status")
+    assert("ToplevelOptional at tag v5.3.2" in status.stdout)
+    assert("ToplevelRequired at tag MPIserial_2.5.0" in status.stdout)
+    assert("AlwaysRequired at tag MPIserial_2.4.0" in status.stdout)
+    assert("Complex at tag testtag3" in status.stdout)
+    assert("AlwaysOptional not checked out, out of sync at tag None, expected tag is MPIserial_2.3.0" in status.stdout)
+
+    # Finally update optional
+    result = git_fleximod(complex_update, "update --optional")
+    assert result.returncode == 0
+
+    status = git_fleximod(complex_update, "status")
+    assert("ToplevelOptional at tag v5.3.2" in status.stdout)
+    assert("ToplevelRequired at tag MPIserial_2.5.0" in status.stdout)
+    assert("AlwaysRequired at tag MPIserial_2.4.0" in status.stdout)
+    assert("Complex at tag testtag3" in status.stdout)
+    assert("AlwaysOptional at tag MPIserial_2.3.0" in status.stdout)
+    
+    # now check the complex_sub
+    root = (complex_update / "modules" / "complex" )
+    assert(not (root / "libraries" / "gptl" / ".git").exists())
+    assert(not (root / "libraries" / "mpi-serial" / ".git").exists())
+    assert(not (root / "modules" / "mpi-serial" / ".git").exists())
+    assert((root / "modules" / "mpi-serialAR" / ".git").exists())
+    assert((root / "modules" / "mpi-serialSAR" / ".git").exists())
+    assert((root / "modules" / "mpi-sparse" / ".git").exists())
+    assert((root / "modules" / "mpi-serial2" / ".git").exists())
+    assert((root / "modules" / "mpi-sparse" / "m4").exists())
+    assert(not (root / "modules" / "mpi-sparse" / "README").exists())
+
+
diff --git a/doc/ChangeLog b/doc/ChangeLog
index 5a2a3c472e..fc4ee9f376 100644
--- a/doc/ChangeLog
+++ b/doc/ChangeLog
@@ -1,4 +1,103 @@
 ===============================================================
+Tag name: ctsm5.3.013
+Originator(s): erik (Erik Kluzek,UCAR/TSS,303-497-1326)
+Date: Tue 26 Nov 2024 02:59:49 PM MST
+One-line Summary: Merge b4b-dev
+
+Purpose and description of changes
+----------------------------------
+
+Bring in latest b4b-dev branch to main CTSM development.
+
+- Update git-fleximod
+- Fix equation number in tech note
+- Implement urbanl and urbanc coszen filters
+- Make ALBGRD and ALBGRI active by default
+- Some adjustments to control pylint for the RXCROPMATURITY python tests
+- Run_sys_tests: Print test list in --verbose/--debug.
+
+Significant changes to scientifically-supported configurations
+--------------------------------------------------------------
+
+Does this tag change answers significantly for any of the following physics configurations?
+(Details of any changes will be given in the "Answer changes" section below.)
+
+    [Put an [X] in the box for any configuration with significant answer changes.]
+
+[ ] clm6_0
+
+[ ] clm5_1
+
+[ ] clm5_0
+
+[ ] ctsm5_0-nwp
+
+[ ] clm4_5
+
+
+Bugs fixed
+----------
+
+List of CTSM issues fixed (include CTSM Issue # and description) [one per line]:
+   Fixes #17 albgrd and albgri history fields depend on decomposition, for urban points
+   Fixes #747 In UrbanAlbedo: Create a filter for coszen>0 and operate over that
+
+Notes of particular relevance for users
+---------------------------------------
+
+Changes made to namelist defaults (e.g., changed parameter values):
+   ALBGRD/ALBGRI are now active by default on the h0 files
+
+Changes to documentation: Fixed equation number
+
+Notes of particular relevance for developers:
+---------------------------------------------
+NOTE: Be sure to review the steps in README.CHECKLIST.master_tags as well as the coding style in the Developers Guide
+[Remove any lines that don't apply. Remove entire section if nothing applies.]
+
+Caveats for developers (e.g., code that is duplicated that requires double maintenance):
+
+Changes to tests or testing:
+    Testlist that will be run is now output when --verbose/--debug is given to run_sys_tests
+
+Testing summary: regular
+----------------
+ [PASS means all tests PASS; OK means tests PASS other than expected fails.]
+
+  build-namelist tests (if CLMBuildNamelist.pm has changed):
+
+    derecho - PASS
+
+  python testing (if python code has changed; see instructions in python/README.md; document testing done):
+
+    derecho - PASS
+
+  regular tests (aux_clm: https://github.com/ESCOMP/CTSM/wiki/System-Testing-Guide#pre-merge-system-testing):
+
+    derecho ----- OK
+    izumi ------- OK
+
+If the tag used for baseline comparisons was NOT the previous tag, note that here:
+
+
+Answer changes
+--------------
+
+Changes answers relative to baseline: No bit-for-bit
+
+Other details
+-------------
+
+Pull Requests that document the changes (include PR ids):
+(https://github.com/ESCOMP/ctsm/pull)
+  #2893 -- Merge b4b-dev
+  #2786 -- git fleximod
+  #2848 -- equation number in tech note
+  #2875 -- run_sys_tests log testlist for --verbose/--debug options
+  #2860 -- Remove num_solar and implement coszen filters in UrbanAlbedoMod.F90
+
+===============================================================
+===============================================================
 Tag name: ctsm5.3.012
 Originator(s): afoster (Adrianna Foster,UCAR/TSS,303-497-1728)
 Date: Wed 13 Nov 2024 09:53:51 AM MST
diff --git a/doc/ChangeSum b/doc/ChangeSum
index 87d5709a68..85e347513b 100644
--- a/doc/ChangeSum
+++ b/doc/ChangeSum
@@ -1,5 +1,6 @@
 Tag                   Who      Date  Summary
 ============================================================================================================================
+       ctsm5.3.013     erik 11/26/2024 Merge b4b-dev
        ctsm5.3.012  afoster 11/13/2024 update fates tag
        ctsm5.3.011 samrabin 11/11/2024 Improve handling of cold-start finidat
        ctsm5.3.010  afoster 11/09/2024 Merge b4b-dev
diff --git a/doc/source/tech_note/Fluxes/CLM50_Tech_Note_Fluxes.rst b/doc/source/tech_note/Fluxes/CLM50_Tech_Note_Fluxes.rst
index c759d11f92..05b35d8b34 100644
--- a/doc/source/tech_note/Fluxes/CLM50_Tech_Note_Fluxes.rst
+++ b/doc/source/tech_note/Fluxes/CLM50_Tech_Note_Fluxes.rst
@@ -1213,7 +1213,7 @@ The numerical solution for vegetation temperature and the fluxes of momentum, se
 
 #. Magnitude of the wind velocity incident on the leaves :math:`U_{av}` (:eq:`5.117` )
 
-#. Leaf boundary layer resistance :math:`r_{b}` (:eq:`5.136` )
+#. Leaf boundary layer resistance :math:`r_{b}` (:eq:`5.122` )
 
 #. Aerodynamic resistances :math:`r_{ah} ^{{'} }` and :math:`r_{aw} ^{{'} }`(:eq:`5.116` )
 
diff --git a/python/ctsm/crop_calendars/cropcal_figs_module.py b/python/ctsm/crop_calendars/cropcal_figs_module.py
index d820460175..f26b5975d4 100644
--- a/python/ctsm/crop_calendars/cropcal_figs_module.py
+++ b/python/ctsm/crop_calendars/cropcal_figs_module.py
@@ -1,6 +1,7 @@
 """
 Functions for making crop calendar figures
 """
+# pylint: disable=abstract-class-instantiated
 
 import numpy as np
 
diff --git a/python/ctsm/crop_calendars/generate_gdds_functions.py b/python/ctsm/crop_calendars/generate_gdds_functions.py
index 14bd6b2e40..81c71e2a51 100644
--- a/python/ctsm/crop_calendars/generate_gdds_functions.py
+++ b/python/ctsm/crop_calendars/generate_gdds_functions.py
@@ -1,7 +1,7 @@
 """
 Functions to support generate_gdds.py
 """
-# pylint: disable=too-many-lines,too-many-statements
+# pylint: disable=too-many-lines,too-many-statements,abstract-class-instantiated
 import warnings
 import os
 import glob
diff --git a/python/ctsm/run_sys_tests.py b/python/ctsm/run_sys_tests.py
index 6afc43cd19..7d3ffe8444 100644
--- a/python/ctsm/run_sys_tests.py
+++ b/python/ctsm/run_sys_tests.py
@@ -8,6 +8,7 @@
 from datetime import datetime
 
 from CIME.test_utils import get_tests_from_xml  # pylint: disable=import-error
+from CIME.test_utils import test_to_string  # pylint: disable=import-error
 from CIME.cs_status_creator import create_cs_status  # pylint: disable=import-error
 
 from ctsm.ctsm_logging import (
@@ -780,6 +781,11 @@ def _get_compilers_for_suite(suite_name, machine_name, running_ctsm_py_tests):
         raise RuntimeError(
             "No tests found for suite {} on machine {}".format(suite_name, machine_name)
         )
+    if logger.getEffectiveLevel() <= logging.INFO:
+        logger.info("Tests:")
+        for test in test_data:
+            test_string = test_to_string(test).split(" ")[1]
+            logger.info("   %s", test_string)
     if not running_ctsm_py_tests:
         _check_py_env([t["testname"] for t in test_data])
         _check_py_env([t["testmods"] for t in test_data if "testmods" in t.keys()])
diff --git a/src/biogeophys/SurfaceAlbedoType.F90 b/src/biogeophys/SurfaceAlbedoType.F90
index e90caeecbb..10819a47b6 100644
--- a/src/biogeophys/SurfaceAlbedoType.F90
+++ b/src/biogeophys/SurfaceAlbedoType.F90
@@ -242,12 +242,12 @@ subroutine InitHistory(this, bounds)
     this%albgrd_col(begc:endc,:) = spval
     call hist_addfld2d (fname='ALBGRD', units='proportion', type2d='numrad', &
          avgflag='A', long_name='ground albedo (direct)', &
-         ptr_col=this%albgrd_col, default='inactive')
+         ptr_col=this%albgrd_col, default='active')
 
     this%albgri_col(begc:endc,:) = spval
     call hist_addfld2d (fname='ALBGRI', units='proportion', type2d='numrad', &
          avgflag='A', long_name='ground albedo (indirect)', &
-         ptr_col=this%albgri_col, default='inactive')
+         ptr_col=this%albgri_col, default='active')
 
     if (use_SSRE) then
        this%albdSF_patch(begp:endp,:) = spval
diff --git a/src/biogeophys/UrbanAlbedoMod.F90 b/src/biogeophys/UrbanAlbedoMod.F90
index 2e854a0497..3e84f73176 100644
--- a/src/biogeophys/UrbanAlbedoMod.F90
+++ b/src/biogeophys/UrbanAlbedoMod.F90
@@ -78,9 +78,14 @@ subroutine UrbanAlbedo (bounds, num_urbanl, filter_urbanl, &
     type(surfalb_type)     , intent(inout) :: surfalb_inst
     !
     ! !LOCAL VARIABLES:
-    integer  :: fl,fp,fc,g,l,p,c,ib                                  ! indices
+    integer  :: fl,fp,fc,g,l,p,c,ib,f,fn                             ! indices and counters
     integer  :: ic                                                   ! 0=unit incoming direct; 1=unit incoming diffuse
-    integer  :: num_solar                                            ! counter
+    integer, allocatable :: filter_urbanl_coszen_gt0(:)              ! filter for urban landunits with coszen > 0
+    integer  :: num_urbanl_coszen_gt0                                ! number of urban landunits with coszen > 0
+    integer, allocatable :: filter_nourbanl_coszen_gt0(:)            ! filter for urban landunits with coszen <= 0
+    integer  :: num_nourbanl_coszen_gt0                              ! number of urban landunits with coszen <= 0
+    integer, allocatable :: filter_urbanc_coszen_gt0(:)              ! filter for urban columns with coszen > 0
+    integer  :: num_urbanc_coszen_gt0                                ! number of urban columns with coszen > 0
     real(r8) :: coszen             (bounds%begl:bounds%endl)         ! cosine solar zenith angle for next time step (landunit)
     real(r8) :: zen                (bounds%begl:bounds%endl)         ! solar zenith angle (radians)
     real(r8) :: sdir               (bounds%begl:bounds%endl, numrad) ! direct beam solar radiation on horizontal surface
@@ -165,9 +170,16 @@ subroutine UrbanAlbedo (bounds, num_urbanl, filter_urbanl, &
          begl               => bounds%begl                          , &
          vf_sr              => urbanparams_inst%vf_sr               , & ! Input:  [real(r8) (:) ]  view factor of sky for road
          vf_sw              => urbanparams_inst%vf_sw               , & ! Input:  [real(r8) (:) ]  view factor of sky for one wall
-         endl               => bounds%endl                            &
+         endl               => bounds%endl                          , &
+         begc               => bounds%begc                          , &
+         endc               => bounds%endc                            &
          )
 
+      ! Allocate urbanl and urbanc coszen filters
+      allocate(filter_urbanl_coszen_gt0(bounds%endl-bounds%begl+1))
+      allocate(filter_nourbanl_coszen_gt0(bounds%endl-bounds%begl+1))
+      allocate(filter_urbanc_coszen_gt0(bounds%endc-bounds%begc+1))
+
       ! ----------------------------------------------------------------------------
       ! Solar declination and cosine solar zenith angle and zenith angle for 
       ! next time step
@@ -228,15 +240,36 @@ subroutine UrbanAlbedo (bounds, num_urbanl, filter_urbanl, &
          end do
       end do
 
-      ! ----------------------------------------------------------------------------
-      ! Urban Code
-      ! ----------------------------------------------------------------------------
-
-      num_solar = 0
+      ! Populate urbanl and urbanc coszen filters
+      f = 0
+      fn = 0
       do fl = 1,num_urbanl
          l = filter_urbanl(fl)
-         if (coszen(l) > 0._r8) num_solar = num_solar + 1
+         if (coszen(l) > 0._r8) then
+            f = f + 1
+            filter_urbanl_coszen_gt0(f) = l
+         else
+            fn = fn + 1
+            filter_nourbanl_coszen_gt0(fn) = l
+         end if
+      end do
+      num_urbanl_coszen_gt0 = f
+      num_nourbanl_coszen_gt0 = fn
+
+      f = 0
+      do fc = 1,num_urbanc
+         c = filter_urbanc(fc)
+         l = col%landunit(c)
+         if (coszen(l) > 0._r8) then
+            f = f + 1
+            filter_urbanc_coszen_gt0(f) = c
+         end if
       end do
+      num_urbanc_coszen_gt0 = f
+
+      ! ----------------------------------------------------------------------------
+      ! Urban Code
+      ! ----------------------------------------------------------------------------
 
       do ib = 1,numrad
          do fl = 1,num_urbanl
@@ -267,184 +300,183 @@ subroutine UrbanAlbedo (bounds, num_urbanl, filter_urbanl, &
       end do
 
       ! ----------------------------------------------------------------------------
-      ! Only do the rest if all coszen are positive 
+      ! Use the urban coszen filters to only calculate quantities when coszen > 0
       ! ----------------------------------------------------------------------------
 
-      if (num_solar > 0)then
 
-         ! Set constants - solar fluxes are per unit incoming flux
+      ! Set constants - solar fluxes are per unit incoming flux
 
-         do ib = 1,numrad
-            do fl = 1,num_urbanl
-               l = filter_urbanl(fl)
-               sdir(l,ib) = 1._r8
-               sdif(l,ib) = 1._r8
-            end do
+      do ib = 1,numrad
+         do fl = 1,num_urbanl_coszen_gt0
+            l = filter_urbanl_coszen_gt0(fl)
+            sdir(l,ib) = 1._r8
+            sdif(l,ib) = 1._r8
          end do
+      end do
 
-         ! Incident direct beam radiation for 
-         ! (a) roof and (b) road and both walls in urban canyon
-
-         if (num_urbanl > 0) then
-            call incident_direct (bounds, &
-                 num_urbanl, filter_urbanl, &
-                 canyon_hwr(begl:endl), &
-                 coszen(begl:endl), &
-                 zen(begl:endl), &
-                 sdir(begl:endl, :), &
-                 sdir_road(begl:endl, :), &
-                 sdir_sunwall(begl:endl, :), &
-                 sdir_shadewall(begl:endl, :))
-         end if
+      ! Incident direct beam radiation for 
+      ! (a) roof and (b) road and both walls in urban canyon
+
+      if (num_urbanl > 0) then
+         call incident_direct (bounds, &
+              num_urbanl_coszen_gt0, &
+              filter_urbanl_coszen_gt0, &
+              num_nourbanl_coszen_gt0, &
+              filter_nourbanl_coszen_gt0, &
+              canyon_hwr(begl:endl), &
+              zen(begl:endl), &
+              sdir(begl:endl, :), &
+              sdir_road(begl:endl, :), &
+              sdir_sunwall(begl:endl, :), &
+              sdir_shadewall(begl:endl, :))
+      end if
 
-         ! Incident diffuse radiation for 
-         ! (a) roof and (b) road and both walls in urban canyon.
-
-         if (num_urbanl > 0) then
-            call incident_diffuse (bounds, &
-                 num_urbanl, filter_urbanl, &
-                 canyon_hwr(begl:endl), &
-                 sdif(begl:endl, :), &
-                 sdif_road(begl:endl, :), &
-                 sdif_sunwall(begl:endl, :), &
-                 sdif_shadewall(begl:endl, :), &
-                 urbanparams_inst)
-         end if
+      ! Incident diffuse radiation for 
+      ! (a) roof and (b) road and both walls in urban canyon.
+
+      if (num_urbanl_coszen_gt0 > 0) then
+         call incident_diffuse (bounds, &
+              num_urbanl_coszen_gt0, &
+              filter_urbanl_coszen_gt0, &
+              canyon_hwr(begl:endl), &
+              sdif(begl:endl, :), &
+              sdif_road(begl:endl, :), &
+              sdif_sunwall(begl:endl, :), &
+              sdif_shadewall(begl:endl, :), &
+              urbanparams_inst)
+      end if
 
-         ! Get snow albedos for roof and impervious and pervious road
-         if (num_urbanl > 0) then
-            ic = 0
-            call SnowAlbedo(bounds, &
-                 num_urbanc, filter_urbanc, &
-                 coszen(begl:endl), &
-                 ic, &
-                 albsnd_roof(begl:endl, :), &
-                 albsnd_improad(begl:endl, :), &
-                 albsnd_perroad(begl:endl, :), &
-                 waterstatebulk_inst)
-
-            ic = 1
-            call SnowAlbedo(bounds, &
-                 num_urbanc, filter_urbanc, &
-                 coszen(begl:endl), &
-                 ic, &
-                 albsni_roof(begl:endl, :), &
-                 albsni_improad(begl:endl, :), &
-                 albsni_perroad(begl:endl, :), &
-                 waterstatebulk_inst)
-         end if
+      ! Get snow albedos for roof and impervious and pervious road
+      if (num_urbanl > 0) then
+         ic = 0
+         call SnowAlbedo(bounds, &
+              num_urbanc, filter_urbanc, &
+              num_urbanc_coszen_gt0, &
+              filter_urbanc_coszen_gt0, &
+              ic, &
+              albsnd_roof(begl:endl, :), &
+              albsnd_improad(begl:endl, :), &
+              albsnd_perroad(begl:endl, :), &
+              waterstatebulk_inst)
+
+         ic = 1
+         call SnowAlbedo(bounds, &
+              num_urbanc, filter_urbanc, &
+              num_urbanc_coszen_gt0, &
+              filter_urbanc_coszen_gt0, &
+              ic, &
+              albsni_roof(begl:endl, :), &
+              albsni_improad(begl:endl, :), &
+              albsni_perroad(begl:endl, :), &
+              waterstatebulk_inst)
+      end if
 
-         ! Combine snow-free and snow albedos
-         do ib = 1,numrad
-            do fc = 1,num_urbanc
-               c = filter_urbanc(fc)
-               l = col%landunit(c)
-               if (ctype(c) == icol_roof) then    
-                  alb_roof_dir_s(l,ib) = alb_roof_dir(l,ib)*(1._r8-frac_sno(c))  &
-                       + albsnd_roof(l,ib)*frac_sno(c)
-                  alb_roof_dif_s(l,ib) = alb_roof_dif(l,ib)*(1._r8-frac_sno(c))  &
-                       + albsni_roof(l,ib)*frac_sno(c)
-               else if (ctype(c) == icol_road_imperv) then    
-                  alb_improad_dir_s(l,ib) = alb_improad_dir(l,ib)*(1._r8-frac_sno(c))  &
-                       + albsnd_improad(l,ib)*frac_sno(c)
-                  alb_improad_dif_s(l,ib) = alb_improad_dif(l,ib)*(1._r8-frac_sno(c))  &
-                       + albsni_improad(l,ib)*frac_sno(c)
-               else if (ctype(c) == icol_road_perv) then    
-                  alb_perroad_dir_s(l,ib) = alb_perroad_dir(l,ib)*(1._r8-frac_sno(c))  &
-                       + albsnd_perroad(l,ib)*frac_sno(c)
-                  alb_perroad_dif_s(l,ib) = alb_perroad_dif(l,ib)*(1._r8-frac_sno(c))  &
-                       + albsni_perroad(l,ib)*frac_sno(c)
-               end if
-            end do
+      ! Combine snow-free and snow albedos
+      do ib = 1,numrad
+         do fc = 1,num_urbanc_coszen_gt0
+            c = filter_urbanc_coszen_gt0(fc)
+            l = col%landunit(c)
+            if (ctype(c) == icol_roof) then    
+               alb_roof_dir_s(l,ib) = alb_roof_dir(l,ib)*(1._r8-frac_sno(c))  &
+                    + albsnd_roof(l,ib)*frac_sno(c)
+               alb_roof_dif_s(l,ib) = alb_roof_dif(l,ib)*(1._r8-frac_sno(c))  &
+                    + albsni_roof(l,ib)*frac_sno(c)
+            else if (ctype(c) == icol_road_imperv) then    
+               alb_improad_dir_s(l,ib) = alb_improad_dir(l,ib)*(1._r8-frac_sno(c))  &
+                    + albsnd_improad(l,ib)*frac_sno(c)
+               alb_improad_dif_s(l,ib) = alb_improad_dif(l,ib)*(1._r8-frac_sno(c))  &
+                    + albsni_improad(l,ib)*frac_sno(c)
+            else if (ctype(c) == icol_road_perv) then    
+               alb_perroad_dir_s(l,ib) = alb_perroad_dir(l,ib)*(1._r8-frac_sno(c))  &
+                    + albsnd_perroad(l,ib)*frac_sno(c)
+               alb_perroad_dif_s(l,ib) = alb_perroad_dif(l,ib)*(1._r8-frac_sno(c))  &
+                    + albsni_perroad(l,ib)*frac_sno(c)
+            end if
          end do
+      end do
 
-         ! Reflected and absorbed solar radiation per unit incident radiation 
-         ! for road and both walls in urban canyon allowing for multiple reflection
-         ! Reflected and absorbed solar radiation per unit incident radiation for roof
+      ! Reflected and absorbed solar radiation per unit incident radiation 
+      ! for road and both walls in urban canyon allowing for multiple reflection
+      ! Reflected and absorbed solar radiation per unit incident radiation for roof
+
+      if (num_urbanl_coszen_gt0 > 0) then
+         call net_solar (bounds, &
+              num_urbanl_coszen_gt0, &
+              filter_urbanl_coszen_gt0, &
+              canyon_hwr         (begl:endl), &
+              wtroad_perv        (begl:endl), &
+              sdir               (begl:endl, :), &
+              sdif               (begl:endl, :), &
+              alb_improad_dir_s  (begl:endl, :), &
+              alb_perroad_dir_s  (begl:endl, :), &
+              alb_wall_dir       (begl:endl, :), &
+              alb_roof_dir_s     (begl:endl, :), &
+              alb_improad_dif_s  (begl:endl, :), &
+              alb_perroad_dif_s  (begl:endl, :), &
+              alb_wall_dif       (begl:endl, :), &
+              alb_roof_dif_s     (begl:endl, :), &
+              sdir_road          (begl:endl, :), &
+              sdir_sunwall       (begl:endl, :), &
+              sdir_shadewall     (begl:endl, :),  &
+              sdif_road          (begl:endl, :), &
+              sdif_sunwall       (begl:endl, :), &
+              sdif_shadewall     (begl:endl, :),  &
+              sref_improad_dir   (begl:endl, :), &
+              sref_perroad_dir   (begl:endl, :), &
+              sref_sunwall_dir   (begl:endl, :), &
+              sref_shadewall_dir (begl:endl, :), &
+              sref_roof_dir      (begl:endl, :), &
+              sref_improad_dif   (begl:endl, :), &
+              sref_perroad_dif   (begl:endl, :), &
+              sref_sunwall_dif   (begl:endl, :), &
+              sref_shadewall_dif (begl:endl, :), &
+              sref_roof_dif      (begl:endl, :), &
+              urbanparams_inst, solarabs_inst)
+      end if
 
-         if (num_urbanl > 0) then
-            call net_solar (bounds, &
-                 num_urbanl, filter_urbanl, &
-                 coszen             (begl:endl), &
-                 canyon_hwr         (begl:endl), &
-                 wtroad_perv        (begl:endl), &
-                 sdir               (begl:endl, :), &
-                 sdif               (begl:endl, :), &
-                 alb_improad_dir_s  (begl:endl, :), &
-                 alb_perroad_dir_s  (begl:endl, :), &
-                 alb_wall_dir       (begl:endl, :), &
-                 alb_roof_dir_s     (begl:endl, :), &
-                 alb_improad_dif_s  (begl:endl, :), &
-                 alb_perroad_dif_s  (begl:endl, :), &
-                 alb_wall_dif       (begl:endl, :), &
-                 alb_roof_dif_s     (begl:endl, :), &
-                 sdir_road          (begl:endl, :), &
-                 sdir_sunwall       (begl:endl, :), &
-                 sdir_shadewall     (begl:endl, :),  &
-                 sdif_road          (begl:endl, :), &
-                 sdif_sunwall       (begl:endl, :), &
-                 sdif_shadewall     (begl:endl, :),  &
-                 sref_improad_dir   (begl:endl, :), &
-                 sref_perroad_dir   (begl:endl, :), &
-                 sref_sunwall_dir   (begl:endl, :), &
-                 sref_shadewall_dir (begl:endl, :), &
-                 sref_roof_dir      (begl:endl, :), &
-                 sref_improad_dif   (begl:endl, :), &
-                 sref_perroad_dif   (begl:endl, :), &
-                 sref_sunwall_dif   (begl:endl, :), &
-                 sref_shadewall_dif (begl:endl, :), &
-                 sref_roof_dif      (begl:endl, :), &
-                 urbanparams_inst, solarabs_inst)
-         end if
+      ! ----------------------------------------------------------------------------
+      ! Map urban output to surfalb_inst components 
+      ! ----------------------------------------------------------------------------
 
-         ! ----------------------------------------------------------------------------
-         ! Map urban output to surfalb_inst components 
-         ! ----------------------------------------------------------------------------
-
-         !  Set albgrd and albgri (ground albedos) and albd and albi (surface albedos)
-
-         do ib = 1,numrad
-            do fc = 1,num_urbanc
-               c = filter_urbanc(fc)
-               l = col%landunit(c)
-               if (ctype(c) == icol_roof) then    
-                  albgrd(c,ib) = sref_roof_dir(l,ib) 
-                  albgri(c,ib) = sref_roof_dif(l,ib) 
-               else if (ctype(c) == icol_sunwall) then   
-                  albgrd(c,ib) = sref_sunwall_dir(l,ib)
-                  albgri(c,ib) = sref_sunwall_dif(l,ib)
-               else if (ctype(c) == icol_shadewall) then 
-                  albgrd(c,ib) = sref_shadewall_dir(l,ib)
-                  albgri(c,ib) = sref_shadewall_dif(l,ib)
-               else if (ctype(c) == icol_road_perv) then
-                  albgrd(c,ib) = sref_perroad_dir(l,ib)
-                  albgri(c,ib) = sref_perroad_dif(l,ib)
-               else if (ctype(c) == icol_road_imperv) then
-                  albgrd(c,ib) = sref_improad_dir(l,ib)
-                  albgri(c,ib) = sref_improad_dif(l,ib)
-               endif
-! add new snicar albedo variables for history fields
-               if (coszen(l) > 0._r8) then
-                  albgrd_hst(c,ib) = albgrd(c,ib)
-                  albgri_hst(c,ib) = albgri(c,ib)
-               end if
-! end add new snicar
-            end do
-            do fp = 1,num_urbanp
-               p = filter_urbanp(fp)
-               c = patch%column(p)
-               l = patch%landunit(p)
-               albd(p,ib) = albgrd(c,ib)
-               albi(p,ib) = albgri(c,ib)
-! add new snicar albedo variables for history fields
-               if (coszen(l) > 0._r8) then
-                  albd_hst(p,ib) = albd(p,ib)
-                  albi_hst(p,ib) = albi(p,ib)
-               end if
-! end add new snicar
-            end do
+      !  Set albgrd and albgri (ground albedos) and albd and albi (surface albedos)
+
+      do ib = 1,numrad
+         do fc = 1,num_urbanc
+            c = filter_urbanc(fc)
+            l = col%landunit(c)
+            if (ctype(c) == icol_roof) then    
+               albgrd(c,ib) = sref_roof_dir(l,ib) 
+               albgri(c,ib) = sref_roof_dif(l,ib) 
+            else if (ctype(c) == icol_sunwall) then   
+               albgrd(c,ib) = sref_sunwall_dir(l,ib)
+               albgri(c,ib) = sref_sunwall_dif(l,ib)
+            else if (ctype(c) == icol_shadewall) then 
+               albgrd(c,ib) = sref_shadewall_dir(l,ib)
+               albgri(c,ib) = sref_shadewall_dif(l,ib)
+            else if (ctype(c) == icol_road_perv) then
+               albgrd(c,ib) = sref_perroad_dir(l,ib)
+               albgri(c,ib) = sref_perroad_dif(l,ib)
+            else if (ctype(c) == icol_road_imperv) then
+               albgrd(c,ib) = sref_improad_dir(l,ib)
+               albgri(c,ib) = sref_improad_dif(l,ib)
+            endif
+            if (coszen(l) > 0._r8) then
+               albgrd_hst(c,ib) = albgrd(c,ib)
+               albgri_hst(c,ib) = albgri(c,ib)
+            end if
          end do
-      end if
+         do fp = 1,num_urbanp
+            p = filter_urbanp(fp)
+            c = patch%column(p)
+            l = patch%landunit(p)
+            albd(p,ib) = albgrd(c,ib)
+            albi(p,ib) = albgri(c,ib)
+            if (coszen(l) > 0._r8) then
+               albd_hst(p,ib) = albd(p,ib)
+               albi_hst(p,ib) = albi(p,ib)
+            end if
+         end do
+      end do
 
     end associate
 
@@ -452,7 +484,7 @@ end subroutine UrbanAlbedo
 
   !-----------------------------------------------------------------------
   subroutine SnowAlbedo (bounds          , &
-       num_urbanc, filter_urbanc, coszen, ind , &
+       num_urbanc, filter_urbanc, num_urbanc_coszen_gt0, filter_urbanc_coszen_gt0, ind , &
        albsn_roof, albsn_improad, albsn_perroad, &
        waterstatebulk_inst)
     !
@@ -466,8 +498,9 @@ subroutine SnowAlbedo (bounds          , &
     type(bounds_type), intent(in) :: bounds                     
     integer , intent(in) :: num_urbanc                          ! number of urban columns in clump
     integer , intent(in) :: filter_urbanc(:)                    ! urban column filter
+    integer , intent(in) :: num_urbanc_coszen_gt0               ! number of urban columns with coszen > 0
+    integer , intent(in) :: filter_urbanc_coszen_gt0(:)         ! filter for urban columns with coszen > 0
     integer , intent(in) :: ind                                 ! 0=direct beam, 1=diffuse radiation
-    real(r8), intent(in) :: coszen        ( bounds%begl: )      ! cosine solar zenith angle [landunit]
     real(r8), intent(out):: albsn_roof    ( bounds%begl: , 1: ) ! roof snow albedo by waveband [landunit, numrad]
     real(r8), intent(out):: albsn_improad ( bounds%begl: , 1: ) ! impervious road snow albedo by waveband [landunit, numrad]
     real(r8), intent(out):: albsn_perroad ( bounds%begl: , 1: ) ! pervious road snow albedo by waveband [landunit, numrad]
@@ -488,7 +521,6 @@ subroutine SnowAlbedo (bounds          , &
     SHR_ASSERT_ALL_FL(numrad == 2, sourcefile, __LINE__)
 
     ! Enforce expected array sizes
-    SHR_ASSERT_ALL_FL((ubound(coszen)        == (/bounds%endl/)),         sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(albsn_roof)    == (/bounds%endl, numrad/)), sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(albsn_improad) == (/bounds%endl, numrad/)), sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(albsn_perroad) == (/bounds%endl, numrad/)), sourcefile, __LINE__)
@@ -497,10 +529,10 @@ subroutine SnowAlbedo (bounds          , &
          caller = 'UrbanAlbedoMod:SnowAlbedo', &
          h2osno_total = h2osno_total(bounds%begc:bounds%endc))
 
-    do fc = 1,num_urbanc
-       c = filter_urbanc(fc)
+    do fc = 1,num_urbanc_coszen_gt0
+       c = filter_urbanc_coszen_gt0(fc)
        l = col%landunit(c)
-       if (coszen(l) > 0._r8 .and. h2osno_total(c) > 0._r8) then
+       if (h2osno_total(c) > 0._r8) then
           if (col%itype(c) == icol_roof) then
              albsn_roof(l,1) = snal0
              albsn_roof(l,2) = snal1
@@ -528,8 +560,9 @@ subroutine SnowAlbedo (bounds          , &
   end subroutine SnowAlbedo
 
   !-----------------------------------------------------------------------
-  subroutine incident_direct (bounds                      ,                    &
-       num_urbanl, filter_urbanl, canyon_hwr, coszen, zen ,                    &
+  subroutine incident_direct (bounds,                                        &
+       num_urbanl_coszen_gt0, filter_urbanl_coszen_gt0,                      &
+       num_nourbanl_coszen_gt0, filter_nourbanl_coszen_gt0, canyon_hwr, zen, &
        sdir, sdir_road, sdir_sunwall, sdir_shadewall)
     !
     ! !DESCRIPTION: 
@@ -567,10 +600,11 @@ subroutine incident_direct (bounds                      ,                    &
     !
     ! !ARGUMENTS:
     type(bounds_type), intent(in) :: bounds                      
-    integer , intent(in)  :: num_urbanl                          ! number of urban landunits
-    integer , intent(in)  :: filter_urbanl(:)                    ! urban landunit filter
+    integer , intent(in)  :: num_urbanl_coszen_gt0               ! number of urban landunits with coszen > 0
+    integer , intent(in)  :: filter_urbanl_coszen_gt0(:)         ! filter for urban landunits with coszen > 0
+    integer , intent(in)  :: num_nourbanl_coszen_gt0             ! number of urban landunits with coszen <= 0
+    integer , intent(in)  :: filter_nourbanl_coszen_gt0(:)       ! filter for urban landunits with coszen <= 0
     real(r8), intent(in)  :: canyon_hwr( bounds%begl: )          ! ratio of building height to street width [landunit]
-    real(r8), intent(in)  :: coszen( bounds%begl: )              ! cosine solar zenith angle [landunit]
     real(r8), intent(in)  :: zen( bounds%begl: )                 ! solar zenith angle (radians) [landunit]
     real(r8), intent(in)  :: sdir( bounds%begl: , 1: )           ! direct beam solar radiation incident on horizontal surface [landunit, numrad]
     real(r8), intent(out) :: sdir_road( bounds%begl: , 1: )      ! direct beam solar radiation incident on road per unit incident flux [landunit, numrad]
@@ -595,54 +629,49 @@ subroutine incident_direct (bounds                      ,                    &
 
     ! Enforce expected array sizes
     SHR_ASSERT_ALL_FL((ubound(canyon_hwr)     == (/bounds%endl/)),         sourcefile, __LINE__)
-    SHR_ASSERT_ALL_FL((ubound(coszen)         == (/bounds%endl/)),         sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(zen)            == (/bounds%endl/)),         sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(sdir)           == (/bounds%endl, numrad/)), sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(sdir_road)      == (/bounds%endl, numrad/)), sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(sdir_sunwall)   == (/bounds%endl, numrad/)), sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(sdir_shadewall) == (/bounds%endl, numrad/)), sourcefile, __LINE__)
 
-    do fl = 1,num_urbanl
-       l = filter_urbanl(fl)
-       if (coszen(l) > 0._r8) then
-          theta0(l) = asin(min( (1._r8/(canyon_hwr(l)*tan(max(zen(l),0.000001_r8)))), 1._r8 ))
-          tanzen(l) = tan(zen(l))
-       end if
+    do fl = 1,num_urbanl_coszen_gt0
+       l = filter_urbanl_coszen_gt0(fl)
+       theta0(l) = asin(min( (1._r8/(canyon_hwr(l)*tan(max(zen(l),0.000001_r8)))), 1._r8 ))
+       tanzen(l) = tan(zen(l))
     end do
 
     do ib = 1,numrad
 
-       do fl = 1,num_urbanl
-          l = filter_urbanl(fl)
-          if (coszen(l) > 0._r8) then
-             sdir_shadewall(l,ib) = 0._r8
+       do fl = 1,num_urbanl_coszen_gt0
+          l = filter_urbanl_coszen_gt0(fl)
+          sdir_shadewall(l,ib) = 0._r8
 
-             ! incident solar radiation on wall and road integrated over all canyon orientations (0 <= theta <= pi/2)
+          ! incident solar radiation on wall and road integrated over all canyon orientations (0 <= theta <= pi/2)
 
-             sdir_road(l,ib) = sdir(l,ib) *                                    &
-                  (2._r8*theta0(l)/rpi - 2./rpi*canyon_hwr(l)*tanzen(l)*(1._r8-cos(theta0(l))))
-             sdir_sunwall(l,ib) = 2._r8 * sdir(l,ib) * ((1._r8/canyon_hwr(l))* &
-                  (0.5_r8-theta0(l)/rpi) + (1._r8/rpi)*tanzen(l)*(1._r8-cos(theta0(l))))
+          sdir_road(l,ib) = sdir(l,ib) *                                    &
+               (2._r8*theta0(l)/rpi - 2./rpi*canyon_hwr(l)*tanzen(l)*(1._r8-cos(theta0(l))))
+          sdir_sunwall(l,ib) = 2._r8 * sdir(l,ib) * ((1._r8/canyon_hwr(l))* &
+               (0.5_r8-theta0(l)/rpi) + (1._r8/rpi)*tanzen(l)*(1._r8-cos(theta0(l))))
 
-             ! conservation check for road and wall. need to use wall fluxes converted to ground area
+          ! conservation check for road and wall. need to use wall fluxes converted to ground area
 
-             swall_projected = (sdir_shadewall(l,ib) + sdir_sunwall(l,ib)) * canyon_hwr(l)
-             err1(l) = sdir(l,ib) - (sdir_road(l,ib) + swall_projected)
-          else
-             sdir_road(l,ib) = 0._r8
-             sdir_sunwall(l,ib) = 0._r8
-             sdir_shadewall(l,ib) = 0._r8
-          endif
+          swall_projected = (sdir_shadewall(l,ib) + sdir_sunwall(l,ib)) * canyon_hwr(l)
+          err1(l) = sdir(l,ib) - (sdir_road(l,ib) + swall_projected)
+       end do
+       do fl = 1,num_nourbanl_coszen_gt0
+          l = filter_nourbanl_coszen_gt0(fl)
+          sdir_road(l,ib) = 0._r8
+          sdir_sunwall(l,ib) = 0._r8
+          sdir_shadewall(l,ib) = 0._r8
        end do
 
-       do fl = 1,num_urbanl
-          l = filter_urbanl(fl)
-          if (coszen(l) > 0._r8) then
-             if (abs(err1(l)) > 0.001_r8) then
-                write (iulog,*) 'urban direct beam solar radiation balance error',err1(l)
-                write (iulog,*) 'clm model is stopping'
-                call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
-             endif
+       do fl = 1,num_urbanl_coszen_gt0
+          l = filter_urbanl_coszen_gt0(fl)
+          if (abs(err1(l)) > 0.001_r8) then
+             write (iulog,*) 'urban direct beam solar radiation balance error',err1(l)
+             write (iulog,*) 'clm model is stopping'
+             call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
           endif
        end do
 
@@ -650,41 +679,37 @@ subroutine incident_direct (bounds                      ,                    &
        ! sum sroad and swall over all canyon orientations (0 <= theta <= pi/2)
 
        if (numchk) then
-          do fl = 1,num_urbanl
-             l = filter_urbanl(fl)
-             if (coszen(l) > 0._r8) then
-                sumr = 0._r8
-                sumw = 0._r8
-                num  = 0._r8
-                do i = 1, 9000
-                   theta = i/100._r8 * rpi/180._r8
-                   zen0 = atan(1._r8/(canyon_hwr(l)*sin(theta)))
-                   if (zen(l) >= zen0) then 
-                      sumr = sumr + 0._r8
-                      sumw = sumw + sdir(l,ib) / canyon_hwr(l)
-                   else
-                      sumr = sumr + sdir(l,ib) * (1._r8-canyon_hwr(l)*sin(theta)*tanzen(l))
-                      sumw = sumw + sdir(l,ib) * sin(theta)*tanzen(l)
-                   end if
-                   num = num + 1._r8
-                end do
-                err2(l) = sumr/num - sdir_road(l,ib)
-                err3(l) = sumw/num - sdir_sunwall(l,ib)
-             endif
-          end do
-          do fl = 1,num_urbanl
-             l = filter_urbanl(fl)
-             if (coszen(l) > 0._r8) then
-                if (abs(err2(l)) > 0.0006_r8 ) then
-                   write (iulog,*) 'urban road incident direct beam solar radiation error',err2(l)
-                   write (iulog,*) 'clm model is stopping'
-                   call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
-                endif
-                if (abs(err3(l)) > 0.0006_r8 ) then
-                   write (iulog,*) 'urban wall incident direct beam solar radiation error',err3(l)
-                   write (iulog,*) 'clm model is stopping'
-                   call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
+          do fl = 1,num_urbanl_coszen_gt0
+             l = filter_urbanl_coszen_gt0(fl)
+             sumr = 0._r8
+             sumw = 0._r8
+             num  = 0._r8
+             do i = 1, 9000
+                theta = i/100._r8 * rpi/180._r8
+                zen0 = atan(1._r8/(canyon_hwr(l)*sin(theta)))
+                if (zen(l) >= zen0) then 
+                   sumr = sumr + 0._r8
+                   sumw = sumw + sdir(l,ib) / canyon_hwr(l)
+                else
+                   sumr = sumr + sdir(l,ib) * (1._r8-canyon_hwr(l)*sin(theta)*tanzen(l))
+                   sumw = sumw + sdir(l,ib) * sin(theta)*tanzen(l)
                 end if
+                num = num + 1._r8
+             end do
+             err2(l) = sumr/num - sdir_road(l,ib)
+             err3(l) = sumw/num - sdir_sunwall(l,ib)
+          end do
+          do fl = 1,num_urbanl_coszen_gt0
+             l = filter_urbanl_coszen_gt0(fl)
+             if (abs(err2(l)) > 0.0006_r8 ) then
+                write (iulog,*) 'urban road incident direct beam solar radiation error',err2(l)
+                write (iulog,*) 'clm model is stopping'
+                call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
+             endif
+             if (abs(err3(l)) > 0.0006_r8 ) then
+                write (iulog,*) 'urban wall incident direct beam solar radiation error',err3(l)
+                write (iulog,*) 'clm model is stopping'
+                call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
              end if
           end do
        end if
@@ -695,7 +720,7 @@ end subroutine incident_direct
 
   !-----------------------------------------------------------------------
   subroutine incident_diffuse (bounds, &
-       num_urbanl, filter_urbanl, canyon_hwr, &
+       num_urbanl_coszen_gt0, filter_urbanl_coszen_gt0, canyon_hwr, &
        sdif, sdif_road, sdif_sunwall, sdif_shadewall, &
        urbanparams_inst)
     !
@@ -707,8 +732,8 @@ subroutine incident_diffuse (bounds, &
     !
     ! !ARGUMENTS:
     type(bounds_type)     , intent(in)  :: bounds                      
-    integer               , intent(in)  :: num_urbanl                           ! number of urban landunits
-    integer               , intent(in)  :: filter_urbanl(:)                     ! urban landunit filter
+    integer               , intent(in)  :: num_urbanl_coszen_gt0                ! number of urban landunits with coszen > 0
+    integer               , intent(in)  :: filter_urbanl_coszen_gt0(:)          ! filter for urban landunits with coszen > 0
     real(r8)              , intent(in)  :: canyon_hwr     ( bounds%begl: )      ! ratio of building height to street width [landunit]
     real(r8)              , intent(in)  :: sdif           ( bounds%begl: , 1: ) ! diffuse solar radiation incident on horizontal surface [landunit, numrad]
     real(r8)              , intent(out) :: sdif_road      ( bounds%begl: , 1: ) ! diffuse solar radiation incident on road [landunit, numrad]
@@ -738,8 +763,8 @@ subroutine incident_diffuse (bounds, &
          
          ! diffuse solar and conservation check. need to convert wall fluxes to ground area
          
-         do fl = 1,num_urbanl
-            l = filter_urbanl(fl)
+         do fl = 1,num_urbanl_coszen_gt0
+            l = filter_urbanl_coszen_gt0(fl)
             sdif_road(l,ib)      = sdif(l,ib) * vf_sr(l)
             sdif_sunwall(l,ib)   = sdif(l,ib) * vf_sw(l) 
             sdif_shadewall(l,ib) = sdif(l,ib) * vf_sw(l) 
@@ -750,8 +775,8 @@ subroutine incident_diffuse (bounds, &
 
          ! error check
 
-         do fl = 1, num_urbanl
-            l = filter_urbanl(fl)
+         do fl = 1, num_urbanl_coszen_gt0
+            l = filter_urbanl_coszen_gt0(fl)
             if (abs(err(l)) > 0.001_r8) then
                write (iulog,*) 'urban diffuse solar radiation balance error',err(l) 
                write (iulog,*) 'clm model is stopping'
@@ -767,11 +792,11 @@ end subroutine incident_diffuse
 
   !-----------------------------------------------------------------------
   subroutine net_solar (bounds                                                                 , &
-       num_urbanl, filter_urbanl, coszen, canyon_hwr, wtroad_perv, sdir, sdif                  , &
+       num_urbanl_coszen_gt0, filter_urbanl_coszen_gt0, canyon_hwr, wtroad_perv, sdir, sdif    , &
        alb_improad_dir, alb_perroad_dir, alb_wall_dir, alb_roof_dir                            , &
        alb_improad_dif, alb_perroad_dif, alb_wall_dif, alb_roof_dif                            , &
-       sdir_road, sdir_sunwall, sdir_shadewall,                                                  &
-       sdif_road, sdif_sunwall, sdif_shadewall,                                                  &
+       sdir_road, sdir_sunwall, sdir_shadewall                                                 , &
+       sdif_road, sdif_sunwall, sdif_shadewall                                                 , &
        sref_improad_dir, sref_perroad_dir, sref_sunwall_dir, sref_shadewall_dir, sref_roof_dir , &
        sref_improad_dif, sref_perroad_dif, sref_sunwall_dif, sref_shadewall_dif, sref_roof_dif , &
        urbanparams_inst, solarabs_inst)
@@ -782,9 +807,8 @@ subroutine net_solar (bounds
     !
     ! !ARGUMENTS:
     type (bounds_type), intent(in) :: bounds                            
-    integer , intent(in)    :: num_urbanl                               ! number of urban landunits
-    integer , intent(in)    :: filter_urbanl(:)                         ! urban landunit filter
-    real(r8), intent(in)    :: coszen             ( bounds%begl: )      ! cosine solar zenith angle [landunit]
+    integer,  intent(in)    :: num_urbanl_coszen_gt0                    ! number of urban landunits with coszen > 0
+    integer,  intent(in)    :: filter_urbanl_coszen_gt0(:)              ! filter for urban landunits with coszen > 0
     real(r8), intent(in)    :: canyon_hwr         ( bounds%begl: )      ! ratio of building height to street width [landunit]
     real(r8), intent(in)    :: wtroad_perv        ( bounds%begl: )      ! weight of pervious road wrt total road [landunit]
     real(r8), intent(in)    :: sdir               ( bounds%begl: , 1: ) ! direct beam solar radiation incident on horizontal surface [landunit, numrad]
@@ -897,7 +921,6 @@ subroutine net_solar (bounds
     !-----------------------------------------------------------------------
 
     ! Enforce expected array sizes
-    SHR_ASSERT_ALL_FL((ubound(coszen)             == (/bounds%endl/)),         sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(canyon_hwr)         == (/bounds%endl/)),         sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(wtroad_perv)        == (/bounds%endl/)),         sourcefile, __LINE__)
     SHR_ASSERT_ALL_FL((ubound(sdir)               == (/bounds%endl, numrad/)), sourcefile, __LINE__)
@@ -948,351 +971,345 @@ subroutine net_solar (bounds
 
       ! Calculate impervious road
       
-      do fl = 1,num_urbanl 
-         l = filter_urbanl(fl)
+      do fl = 1,num_urbanl_coszen_gt0
+         l = filter_urbanl_coszen_gt0(fl)
          wtroad_imperv(l) = 1._r8 - wtroad_perv(l)
       end do
 
       do ib = 1,numrad
-         do fl = 1,num_urbanl
-            l = filter_urbanl(fl)
-            if (coszen(l) > 0._r8) then
+         do fl = 1,num_urbanl_coszen_gt0
+            l = filter_urbanl_coszen_gt0(fl)
+
+            ! initial absorption and reflection for road and both walls. 
+            ! distribute reflected radiation to sky, road, and walls 
+            ! according to appropriate view factor. radiation reflected to 
+            ! road and walls will undergo multiple reflections within the canyon. 
+            ! do separately for direct beam and diffuse radiation.
+
+            ! direct beam
+
+            road_a_dir(l)              = 0.0_r8
+            road_r_dir(l)              = 0.0_r8
+            improad_a_dir(l)           = (1._r8-alb_improad_dir(l,ib)) * sdir_road(l,ib) 
+            improad_r_dir(l)           =     alb_improad_dir(l,ib)  * sdir_road(l,ib) 
+            improad_r_sky_dir(l)       = improad_r_dir(l) * vf_sr(l)
+            improad_r_sunwall_dir(l)   = improad_r_dir(l) * vf_wr(l)
+            improad_r_shadewall_dir(l) = improad_r_dir(l) * vf_wr(l)
+            road_a_dir(l)              = road_a_dir(l) + improad_a_dir(l)*wtroad_imperv(l)
+            road_r_dir(l)              = road_r_dir(l) + improad_r_dir(l)*wtroad_imperv(l)
+
+            perroad_a_dir(l)           = (1._r8-alb_perroad_dir(l,ib)) * sdir_road(l,ib) 
+            perroad_r_dir(l)           =     alb_perroad_dir(l,ib)  * sdir_road(l,ib) 
+            perroad_r_sky_dir(l)       = perroad_r_dir(l) * vf_sr(l)
+            perroad_r_sunwall_dir(l)   = perroad_r_dir(l) * vf_wr(l)
+            perroad_r_shadewall_dir(l) = perroad_r_dir(l) * vf_wr(l)
+            road_a_dir(l)              = road_a_dir(l) + perroad_a_dir(l)*wtroad_perv(l)
+            road_r_dir(l)              = road_r_dir(l) + perroad_r_dir(l)*wtroad_perv(l)
+
+            road_r_sky_dir(l)          = road_r_dir(l) * vf_sr(l)
+            road_r_sunwall_dir(l)      = road_r_dir(l) * vf_wr(l)
+            road_r_shadewall_dir(l)    = road_r_dir(l) * vf_wr(l)
+
+            sunwall_a_dir(l)           = (1._r8-alb_wall_dir(l,ib)) * sdir_sunwall(l,ib)
+            sunwall_r_dir(l)           =     alb_wall_dir(l,ib)  * sdir_sunwall(l,ib)
+            sunwall_r_sky_dir(l)       = sunwall_r_dir(l) * vf_sw(l)
+            sunwall_r_road_dir(l)      = sunwall_r_dir(l) * vf_rw(l)
+            sunwall_r_shadewall_dir(l) = sunwall_r_dir(l) * vf_ww(l)
+
+            shadewall_a_dir(l)         = (1._r8-alb_wall_dir(l,ib)) * sdir_shadewall(l,ib)
+            shadewall_r_dir(l)         =     alb_wall_dir(l,ib)  * sdir_shadewall(l,ib)
+            shadewall_r_sky_dir(l)     = shadewall_r_dir(l) * vf_sw(l)
+            shadewall_r_road_dir(l)    = shadewall_r_dir(l) * vf_rw(l)
+            shadewall_r_sunwall_dir(l) = shadewall_r_dir(l) * vf_ww(l)
+
+            ! diffuse
+
+            road_a_dif(l)              = 0.0_r8
+            road_r_dif(l)              = 0.0_r8
+            improad_a_dif(l)           = (1._r8-alb_improad_dif(l,ib)) * sdif_road(l,ib) 
+            improad_r_dif(l)           =     alb_improad_dif(l,ib)  * sdif_road(l,ib) 
+            improad_r_sky_dif(l)       = improad_r_dif(l) * vf_sr(l)
+            improad_r_sunwall_dif(l)   = improad_r_dif(l) * vf_wr(l)
+            improad_r_shadewall_dif(l) = improad_r_dif(l) * vf_wr(l)
+            road_a_dif(l)              = road_a_dif(l) + improad_a_dif(l)*wtroad_imperv(l)
+            road_r_dif(l)              = road_r_dif(l) + improad_r_dif(l)*wtroad_imperv(l)
+
+            perroad_a_dif(l)           = (1._r8-alb_perroad_dif(l,ib)) * sdif_road(l,ib) 
+            perroad_r_dif(l)           =     alb_perroad_dif(l,ib)  * sdif_road(l,ib) 
+            perroad_r_sky_dif(l)       = perroad_r_dif(l) * vf_sr(l)
+            perroad_r_sunwall_dif(l)   = perroad_r_dif(l) * vf_wr(l)
+            perroad_r_shadewall_dif(l) = perroad_r_dif(l) * vf_wr(l)
+            road_a_dif(l)              = road_a_dif(l) + perroad_a_dif(l)*wtroad_perv(l)
+            road_r_dif(l)              = road_r_dif(l) + perroad_r_dif(l)*wtroad_perv(l)
+
+            road_r_sky_dif(l)          = road_r_dif(l) * vf_sr(l)
+            road_r_sunwall_dif(l)      = road_r_dif(l) * vf_wr(l)
+            road_r_shadewall_dif(l)    = road_r_dif(l) * vf_wr(l)
+
+            sunwall_a_dif(l)           = (1._r8-alb_wall_dif(l,ib)) * sdif_sunwall(l,ib)
+            sunwall_r_dif(l)           =     alb_wall_dif(l,ib)  * sdif_sunwall(l,ib)
+            sunwall_r_sky_dif(l)       = sunwall_r_dif(l) * vf_sw(l)
+            sunwall_r_road_dif(l)      = sunwall_r_dif(l) * vf_rw(l)
+            sunwall_r_shadewall_dif(l) = sunwall_r_dif(l) * vf_ww(l)
+
+            shadewall_a_dif(l)         = (1._r8-alb_wall_dif(l,ib)) * sdif_shadewall(l,ib)
+            shadewall_r_dif(l)         =     alb_wall_dif(l,ib)  * sdif_shadewall(l,ib)
+            shadewall_r_sky_dif(l)     = shadewall_r_dif(l) * vf_sw(l)
+            shadewall_r_road_dif(l)    = shadewall_r_dif(l) * vf_rw(l) 
+            shadewall_r_sunwall_dif(l) = shadewall_r_dif(l) * vf_ww(l) 
+
+            ! initialize sum of direct and diffuse solar absorption and reflection for road and both walls
+
+            sabs_improad_dir(l,ib)   = improad_a_dir(l)
+            sabs_perroad_dir(l,ib)   = perroad_a_dir(l)
+            sabs_sunwall_dir(l,ib)   = sunwall_a_dir(l)
+            sabs_shadewall_dir(l,ib) = shadewall_a_dir(l)
+
+            sabs_improad_dif(l,ib)   = improad_a_dif(l)
+            sabs_perroad_dif(l,ib)   = perroad_a_dif(l)
+            sabs_sunwall_dif(l,ib)   = sunwall_a_dif(l)
+            sabs_shadewall_dif(l,ib) = shadewall_a_dif(l)
+
+            sref_improad_dir(l,ib)   = improad_r_sky_dir(l) 
+            sref_perroad_dir(l,ib)   = perroad_r_sky_dir(l) 
+            sref_sunwall_dir(l,ib)   = sunwall_r_sky_dir(l) 
+            sref_shadewall_dir(l,ib) = shadewall_r_sky_dir(l) 
+
+            sref_improad_dif(l,ib)   = improad_r_sky_dif(l)
+            sref_perroad_dif(l,ib)   = perroad_r_sky_dif(l)
+            sref_sunwall_dif(l,ib)   = sunwall_r_sky_dif(l)
+            sref_shadewall_dif(l,ib) = shadewall_r_sky_dif(l)
+
+         end do
+
+         ! absorption and reflection for walls and road with multiple reflections
+         ! (i.e., absorb and reflect initial reflection in canyon and allow for 
+         ! subsequent scattering)
+         !
+         ! (1) absorption and reflection of scattered solar radiation
+         !     road: reflected fluxes from walls need to be projected to ground area
+         !     wall: reflected flux from road needs to be projected to wall area
+         !
+         ! (2) add absorbed radiation for ith reflection to total absorbed
+         !
+         ! (3) distribute reflected radiation to sky, road, and walls according to view factors
+         !
+         ! (4) add solar reflection to sky for ith reflection to total reflection
+         !
+         ! (5) stop iteration when absorption for ith reflection is less than some nominal amount. 
+         !     small convergence criteria is required to ensure solar radiation is conserved
+         !
+         ! do separately for direct beam and diffuse
+
+         do fl = 1,num_urbanl_coszen_gt0
+            l = filter_urbanl_coszen_gt0(fl)
+
+            ! reflected direct beam
+
+            do iter_dir = 1, n
+               ! step (1)
+
+               stot(l) = (sunwall_r_road_dir(l) + shadewall_r_road_dir(l))*canyon_hwr(l)
+
+               road_a_dir(l) = 0.0_r8
+               road_r_dir(l) = 0.0_r8
+               improad_a_dir(l) = (1._r8-alb_improad_dir(l,ib)) * stot(l) 
+               improad_r_dir(l) =     alb_improad_dir(l,ib)  * stot(l) 
+               road_a_dir(l)    = road_a_dir(l) + improad_a_dir(l)*wtroad_imperv(l)
+               road_r_dir(l)    = road_r_dir(l) + improad_r_dir(l)*wtroad_imperv(l)
+               perroad_a_dir(l) = (1._r8-alb_perroad_dir(l,ib)) * stot(l) 
+               perroad_r_dir(l) =     alb_perroad_dir(l,ib)  * stot(l) 
+               road_a_dir(l)    = road_a_dir(l) + perroad_a_dir(l)*wtroad_perv(l)
+               road_r_dir(l)    = road_r_dir(l) + perroad_r_dir(l)*wtroad_perv(l)
+
+               stot(l) = road_r_sunwall_dir(l)/canyon_hwr(l) + shadewall_r_sunwall_dir(l)
+               sunwall_a_dir(l) = (1._r8-alb_wall_dir(l,ib)) * stot(l)
+               sunwall_r_dir(l) =     alb_wall_dir(l,ib)  * stot(l)
+
+               stot(l) = road_r_shadewall_dir(l)/canyon_hwr(l) + sunwall_r_shadewall_dir(l)
+               shadewall_a_dir(l) = (1._r8-alb_wall_dir(l,ib)) * stot(l)
+               shadewall_r_dir(l) =     alb_wall_dir(l,ib)  * stot(l)
 
-               ! initial absorption and reflection for road and both walls. 
-               ! distribute reflected radiation to sky, road, and walls 
-               ! according to appropriate view factor. radiation reflected to 
-               ! road and walls will undergo multiple reflections within the canyon. 
-               ! do separately for direct beam and diffuse radiation.
+               ! step (2)
 
-               ! direct beam
+               sabs_improad_dir(l,ib)   = sabs_improad_dir(l,ib)   + improad_a_dir(l)
+               sabs_perroad_dir(l,ib)   = sabs_perroad_dir(l,ib)   + perroad_a_dir(l)
+               sabs_sunwall_dir(l,ib)   = sabs_sunwall_dir(l,ib)   + sunwall_a_dir(l)
+               sabs_shadewall_dir(l,ib) = sabs_shadewall_dir(l,ib) + shadewall_a_dir(l)
+
+               ! step (3)
 
-               road_a_dir(l)              = 0.0_r8
-               road_r_dir(l)              = 0.0_r8
-               improad_a_dir(l)           = (1._r8-alb_improad_dir(l,ib)) * sdir_road(l,ib) 
-               improad_r_dir(l)           =     alb_improad_dir(l,ib)  * sdir_road(l,ib) 
                improad_r_sky_dir(l)       = improad_r_dir(l) * vf_sr(l)
                improad_r_sunwall_dir(l)   = improad_r_dir(l) * vf_wr(l)
                improad_r_shadewall_dir(l) = improad_r_dir(l) * vf_wr(l)
-               road_a_dir(l)              = road_a_dir(l) + improad_a_dir(l)*wtroad_imperv(l)
-               road_r_dir(l)              = road_r_dir(l) + improad_r_dir(l)*wtroad_imperv(l)
 
-               perroad_a_dir(l)           = (1._r8-alb_perroad_dir(l,ib)) * sdir_road(l,ib) 
-               perroad_r_dir(l)           =     alb_perroad_dir(l,ib)  * sdir_road(l,ib) 
                perroad_r_sky_dir(l)       = perroad_r_dir(l) * vf_sr(l)
                perroad_r_sunwall_dir(l)   = perroad_r_dir(l) * vf_wr(l)
                perroad_r_shadewall_dir(l) = perroad_r_dir(l) * vf_wr(l)
-               road_a_dir(l)              = road_a_dir(l) + perroad_a_dir(l)*wtroad_perv(l)
-               road_r_dir(l)              = road_r_dir(l) + perroad_r_dir(l)*wtroad_perv(l)
 
                road_r_sky_dir(l)          = road_r_dir(l) * vf_sr(l)
                road_r_sunwall_dir(l)      = road_r_dir(l) * vf_wr(l)
                road_r_shadewall_dir(l)    = road_r_dir(l) * vf_wr(l)
 
-               sunwall_a_dir(l)           = (1._r8-alb_wall_dir(l,ib)) * sdir_sunwall(l,ib)
-               sunwall_r_dir(l)           =     alb_wall_dir(l,ib)  * sdir_sunwall(l,ib)
                sunwall_r_sky_dir(l)       = sunwall_r_dir(l) * vf_sw(l)
                sunwall_r_road_dir(l)      = sunwall_r_dir(l) * vf_rw(l)
                sunwall_r_shadewall_dir(l) = sunwall_r_dir(l) * vf_ww(l)
 
-               shadewall_a_dir(l)         = (1._r8-alb_wall_dir(l,ib)) * sdir_shadewall(l,ib)
-               shadewall_r_dir(l)         =     alb_wall_dir(l,ib)  * sdir_shadewall(l,ib)
                shadewall_r_sky_dir(l)     = shadewall_r_dir(l) * vf_sw(l)
                shadewall_r_road_dir(l)    = shadewall_r_dir(l) * vf_rw(l)
                shadewall_r_sunwall_dir(l) = shadewall_r_dir(l) * vf_ww(l)
 
-               ! diffuse
+               ! step (4)
+
+               sref_improad_dir(l,ib)   = sref_improad_dir(l,ib) + improad_r_sky_dir(l)
+               sref_perroad_dir(l,ib)   = sref_perroad_dir(l,ib) + perroad_r_sky_dir(l)
+               sref_sunwall_dir(l,ib)   = sref_sunwall_dir(l,ib) + sunwall_r_sky_dir(l)
+               sref_shadewall_dir(l,ib) = sref_shadewall_dir(l,ib) + shadewall_r_sky_dir(l)
+
+               ! step (5)
+
+               crit = max(road_a_dir(l), sunwall_a_dir(l), shadewall_a_dir(l))
+               if (crit < errcrit) exit
+            end do
+            if (iter_dir >= n) then
+               write (iulog,*) 'urban net solar radiation error: no convergence, direct beam'
+               write (iulog,*) 'clm model is stopping'
+               call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
+            endif
+
+            ! reflected diffuse
+
+            do iter_dif = 1, n
+               ! step (1)
+
+               stot(l) = (sunwall_r_road_dif(l) + shadewall_r_road_dif(l))*canyon_hwr(l)
+               road_a_dif(l)    = 0.0_r8
+               road_r_dif(l)    = 0.0_r8
+               improad_a_dif(l) = (1._r8-alb_improad_dif(l,ib)) * stot(l) 
+               improad_r_dif(l) =     alb_improad_dif(l,ib)  * stot(l) 
+               road_a_dif(l)    = road_a_dif(l) + improad_a_dif(l)*wtroad_imperv(l)
+               road_r_dif(l)    = road_r_dif(l) + improad_r_dif(l)*wtroad_imperv(l)
+               perroad_a_dif(l) = (1._r8-alb_perroad_dif(l,ib)) * stot(l) 
+               perroad_r_dif(l) =     alb_perroad_dif(l,ib)  * stot(l) 
+               road_a_dif(l)    = road_a_dif(l) + perroad_a_dif(l)*wtroad_perv(l)
+               road_r_dif(l)    = road_r_dif(l) + perroad_r_dif(l)*wtroad_perv(l)
+
+               stot(l) = road_r_sunwall_dif(l)/canyon_hwr(l) + shadewall_r_sunwall_dif(l)
+               sunwall_a_dif(l) = (1._r8-alb_wall_dif(l,ib)) * stot(l)
+               sunwall_r_dif(l) =     alb_wall_dif(l,ib)  * stot(l)
+
+               stot(l) = road_r_shadewall_dif(l)/canyon_hwr(l) + sunwall_r_shadewall_dif(l)
+               shadewall_a_dif(l) = (1._r8-alb_wall_dif(l,ib)) * stot(l)
+               shadewall_r_dif(l) =     alb_wall_dif(l,ib)  * stot(l)
+
+               ! step (2)
+
+               sabs_improad_dif(l,ib)   = sabs_improad_dif(l,ib)   + improad_a_dif(l)
+               sabs_perroad_dif(l,ib)   = sabs_perroad_dif(l,ib)   + perroad_a_dif(l)
+               sabs_sunwall_dif(l,ib)   = sabs_sunwall_dif(l,ib)   + sunwall_a_dif(l)
+               sabs_shadewall_dif(l,ib) = sabs_shadewall_dif(l,ib) + shadewall_a_dif(l)
+
+               ! step (3)
 
-               road_a_dif(l)              = 0.0_r8
-               road_r_dif(l)              = 0.0_r8
-               improad_a_dif(l)           = (1._r8-alb_improad_dif(l,ib)) * sdif_road(l,ib) 
-               improad_r_dif(l)           =     alb_improad_dif(l,ib)  * sdif_road(l,ib) 
                improad_r_sky_dif(l)       = improad_r_dif(l) * vf_sr(l)
                improad_r_sunwall_dif(l)   = improad_r_dif(l) * vf_wr(l)
                improad_r_shadewall_dif(l) = improad_r_dif(l) * vf_wr(l)
-               road_a_dif(l)              = road_a_dif(l) + improad_a_dif(l)*wtroad_imperv(l)
-               road_r_dif(l)              = road_r_dif(l) + improad_r_dif(l)*wtroad_imperv(l)
 
-               perroad_a_dif(l)           = (1._r8-alb_perroad_dif(l,ib)) * sdif_road(l,ib) 
-               perroad_r_dif(l)           =     alb_perroad_dif(l,ib)  * sdif_road(l,ib) 
                perroad_r_sky_dif(l)       = perroad_r_dif(l) * vf_sr(l)
                perroad_r_sunwall_dif(l)   = perroad_r_dif(l) * vf_wr(l)
                perroad_r_shadewall_dif(l) = perroad_r_dif(l) * vf_wr(l)
-               road_a_dif(l)              = road_a_dif(l) + perroad_a_dif(l)*wtroad_perv(l)
-               road_r_dif(l)              = road_r_dif(l) + perroad_r_dif(l)*wtroad_perv(l)
 
                road_r_sky_dif(l)          = road_r_dif(l) * vf_sr(l)
                road_r_sunwall_dif(l)      = road_r_dif(l) * vf_wr(l)
                road_r_shadewall_dif(l)    = road_r_dif(l) * vf_wr(l)
 
-               sunwall_a_dif(l)           = (1._r8-alb_wall_dif(l,ib)) * sdif_sunwall(l,ib)
-               sunwall_r_dif(l)           =     alb_wall_dif(l,ib)  * sdif_sunwall(l,ib)
                sunwall_r_sky_dif(l)       = sunwall_r_dif(l) * vf_sw(l)
                sunwall_r_road_dif(l)      = sunwall_r_dif(l) * vf_rw(l)
                sunwall_r_shadewall_dif(l) = sunwall_r_dif(l) * vf_ww(l)
 
-               shadewall_a_dif(l)         = (1._r8-alb_wall_dif(l,ib)) * sdif_shadewall(l,ib)
-               shadewall_r_dif(l)         =     alb_wall_dif(l,ib)  * sdif_shadewall(l,ib)
                shadewall_r_sky_dif(l)     = shadewall_r_dif(l) * vf_sw(l)
-               shadewall_r_road_dif(l)    = shadewall_r_dif(l) * vf_rw(l) 
-               shadewall_r_sunwall_dif(l) = shadewall_r_dif(l) * vf_ww(l) 
-
-               ! initialize sum of direct and diffuse solar absorption and reflection for road and both walls
-
-               sabs_improad_dir(l,ib)   = improad_a_dir(l)
-               sabs_perroad_dir(l,ib)   = perroad_a_dir(l)
-               sabs_sunwall_dir(l,ib)   = sunwall_a_dir(l)
-               sabs_shadewall_dir(l,ib) = shadewall_a_dir(l)
-
-               sabs_improad_dif(l,ib)   = improad_a_dif(l)
-               sabs_perroad_dif(l,ib)   = perroad_a_dif(l)
-               sabs_sunwall_dif(l,ib)   = sunwall_a_dif(l)
-               sabs_shadewall_dif(l,ib) = shadewall_a_dif(l)
-
-               sref_improad_dir(l,ib)   = improad_r_sky_dir(l) 
-               sref_perroad_dir(l,ib)   = perroad_r_sky_dir(l) 
-               sref_sunwall_dir(l,ib)   = sunwall_r_sky_dir(l) 
-               sref_shadewall_dir(l,ib) = shadewall_r_sky_dir(l) 
-
-               sref_improad_dif(l,ib)   = improad_r_sky_dif(l)
-               sref_perroad_dif(l,ib)   = perroad_r_sky_dif(l)
-               sref_sunwall_dif(l,ib)   = sunwall_r_sky_dif(l)
-               sref_shadewall_dif(l,ib) = shadewall_r_sky_dif(l)
-            endif
-
-         end do
+               shadewall_r_road_dif(l)    = shadewall_r_dif(l) * vf_rw(l)
+               shadewall_r_sunwall_dif(l) = shadewall_r_dif(l) * vf_ww(l)
 
-         ! absorption and reflection for walls and road with multiple reflections
-         ! (i.e., absorb and reflect initial reflection in canyon and allow for 
-         ! subsequent scattering)
-         !
-         ! (1) absorption and reflection of scattered solar radiation
-         !     road: reflected fluxes from walls need to be projected to ground area
-         !     wall: reflected flux from road needs to be projected to wall area
-         !
-         ! (2) add absorbed radiation for ith reflection to total absorbed
-         !
-         ! (3) distribute reflected radiation to sky, road, and walls according to view factors
-         !
-         ! (4) add solar reflection to sky for ith reflection to total reflection
-         !
-         ! (5) stop iteration when absorption for ith reflection is less than some nominal amount. 
-         !     small convergence criteria is required to ensure solar radiation is conserved
-         !
-         ! do separately for direct beam and diffuse
+               ! step (4)
 
-         do fl = 1,num_urbanl
-            l = filter_urbanl(fl)
-            if (coszen(l) > 0._r8) then
-
-               ! reflected direct beam
-
-               do iter_dir = 1, n
-                  ! step (1)
-
-                  stot(l) = (sunwall_r_road_dir(l) + shadewall_r_road_dir(l))*canyon_hwr(l)
-
-                  road_a_dir(l) = 0.0_r8
-                  road_r_dir(l) = 0.0_r8
-                  improad_a_dir(l) = (1._r8-alb_improad_dir(l,ib)) * stot(l) 
-                  improad_r_dir(l) =     alb_improad_dir(l,ib)  * stot(l) 
-                  road_a_dir(l)    = road_a_dir(l) + improad_a_dir(l)*wtroad_imperv(l)
-                  road_r_dir(l)    = road_r_dir(l) + improad_r_dir(l)*wtroad_imperv(l)
-                  perroad_a_dir(l) = (1._r8-alb_perroad_dir(l,ib)) * stot(l) 
-                  perroad_r_dir(l) =     alb_perroad_dir(l,ib)  * stot(l) 
-                  road_a_dir(l)    = road_a_dir(l) + perroad_a_dir(l)*wtroad_perv(l)
-                  road_r_dir(l)    = road_r_dir(l) + perroad_r_dir(l)*wtroad_perv(l)
+               sref_improad_dif(l,ib)   = sref_improad_dif(l,ib)   + improad_r_sky_dif(l)
+               sref_perroad_dif(l,ib)   = sref_perroad_dif(l,ib)   + perroad_r_sky_dif(l)
+               sref_sunwall_dif(l,ib)   = sref_sunwall_dif(l,ib)   + sunwall_r_sky_dif(l)
+               sref_shadewall_dif(l,ib) = sref_shadewall_dif(l,ib) + shadewall_r_sky_dif(l)
 
-                  stot(l) = road_r_sunwall_dir(l)/canyon_hwr(l) + shadewall_r_sunwall_dir(l)
-                  sunwall_a_dir(l) = (1._r8-alb_wall_dir(l,ib)) * stot(l)
-                  sunwall_r_dir(l) =     alb_wall_dir(l,ib)  * stot(l)
+               ! step (5)
 
-                  stot(l) = road_r_shadewall_dir(l)/canyon_hwr(l) + sunwall_r_shadewall_dir(l)
-                  shadewall_a_dir(l) = (1._r8-alb_wall_dir(l,ib)) * stot(l)
-                  shadewall_r_dir(l) =     alb_wall_dir(l,ib)  * stot(l)
-
-                  ! step (2)
-
-                  sabs_improad_dir(l,ib)   = sabs_improad_dir(l,ib)   + improad_a_dir(l)
-                  sabs_perroad_dir(l,ib)   = sabs_perroad_dir(l,ib)   + perroad_a_dir(l)
-                  sabs_sunwall_dir(l,ib)   = sabs_sunwall_dir(l,ib)   + sunwall_a_dir(l)
-                  sabs_shadewall_dir(l,ib) = sabs_shadewall_dir(l,ib) + shadewall_a_dir(l)
+               crit = max(road_a_dif(l), sunwall_a_dif(l), shadewall_a_dif(l))
+               if (crit < errcrit) exit
+            end do
+            if (iter_dif >= n) then
+               write (iulog,*) 'urban net solar radiation error: no convergence, diffuse'
+               write (iulog,*) 'clm model is stopping'
+               call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
+            endif
 
-                  ! step (3)
+            ! total reflected by canyon - sum of solar reflection to sky from canyon.
+            ! project wall fluxes to horizontal surface
+
+            sref_canyon_dir(l) = 0.0_r8
+            sref_canyon_dif(l) = 0.0_r8
+            sref_canyon_dir(l) = sref_canyon_dir(l) + sref_improad_dir(l,ib)*wtroad_imperv(l)
+            sref_canyon_dif(l) = sref_canyon_dif(l) + sref_improad_dif(l,ib)*wtroad_imperv(l)
+            sref_canyon_dir(l) = sref_canyon_dir(l) + sref_perroad_dir(l,ib)*wtroad_perv(l)
+            sref_canyon_dif(l) = sref_canyon_dif(l) + sref_perroad_dif(l,ib)*wtroad_perv(l)
+            sref_canyon_dir(l) = sref_canyon_dir(l) + (sref_sunwall_dir(l,ib) + sref_shadewall_dir(l,ib))*canyon_hwr(l)
+            sref_canyon_dif(l) = sref_canyon_dif(l) + (sref_sunwall_dif(l,ib) + sref_shadewall_dif(l,ib))*canyon_hwr(l)
+
+            ! total absorbed by canyon. project wall fluxes to horizontal surface
+
+            sabs_canyon_dir(l) = 0.0_r8
+            sabs_canyon_dif(l) = 0.0_r8
+            sabs_canyon_dir(l) = sabs_canyon_dir(l) + sabs_improad_dir(l,ib)*wtroad_imperv(l)
+            sabs_canyon_dif(l) = sabs_canyon_dif(l) + sabs_improad_dif(l,ib)*wtroad_imperv(l)
+            sabs_canyon_dir(l) = sabs_canyon_dir(l) + sabs_perroad_dir(l,ib)*wtroad_perv(l)
+            sabs_canyon_dif(l) = sabs_canyon_dif(l) + sabs_perroad_dif(l,ib)*wtroad_perv(l)
+            sabs_canyon_dir(l) = sabs_canyon_dir(l) + (sabs_sunwall_dir(l,ib) + sabs_shadewall_dir(l,ib))*canyon_hwr(l)
+            sabs_canyon_dif(l) = sabs_canyon_dif(l) + (sabs_sunwall_dif(l,ib) + sabs_shadewall_dif(l,ib))*canyon_hwr(l)
+
+            ! conservation check. note: previous conservation checks confirm partioning of total direct
+            ! beam and diffuse radiation from atmosphere to road and walls is conserved as
+            !    sdir (from atmosphere) = sdir_road + (sdir_sunwall + sdir_shadewall)*canyon_hwr
+            !    sdif (from atmosphere) = sdif_road + (sdif_sunwall + sdif_shadewall)*canyon_hwr
+
+            stot_dir(l) = sdir_road(l,ib) + (sdir_sunwall(l,ib) + sdir_shadewall(l,ib))*canyon_hwr(l)
+            stot_dif(l) = sdif_road(l,ib) + (sdif_sunwall(l,ib) + sdif_shadewall(l,ib))*canyon_hwr(l)
+
+            err = stot_dir(l) + stot_dif(l) &
+                 - (sabs_canyon_dir(l) + sabs_canyon_dif(l) + sref_canyon_dir(l) + sref_canyon_dif(l))
+            if (abs(err) > 0.001_r8 ) then
+               write(iulog,*)'urban net solar radiation balance error for ib=',ib,' err= ',err
+               write(iulog,*)' l= ',l,' ib= ',ib 
+               write(iulog,*)' stot_dir        = ',stot_dir(l)
+               write(iulog,*)' stot_dif        = ',stot_dif(l)
+               write(iulog,*)' sabs_canyon_dir = ',sabs_canyon_dir(l)
+               write(iulog,*)' sabs_canyon_dif = ',sabs_canyon_dif(l)
+               write(iulog,*)' sref_canyon_dir = ',sref_canyon_dir(l)
+               write(iulog,*)' sref_canyon_dif = ',sref_canyon_dir(l)
+               write(iulog,*) 'clm model is stopping'
+               call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
+            endif
 
-                  improad_r_sky_dir(l)       = improad_r_dir(l) * vf_sr(l)
-                  improad_r_sunwall_dir(l)   = improad_r_dir(l) * vf_wr(l)
-                  improad_r_shadewall_dir(l) = improad_r_dir(l) * vf_wr(l)
+            ! canyon albedo
 
-                  perroad_r_sky_dir(l)       = perroad_r_dir(l) * vf_sr(l)
-                  perroad_r_sunwall_dir(l)   = perroad_r_dir(l) * vf_wr(l)
-                  perroad_r_shadewall_dir(l) = perroad_r_dir(l) * vf_wr(l)
-
-                  road_r_sky_dir(l)          = road_r_dir(l) * vf_sr(l)
-                  road_r_sunwall_dir(l)      = road_r_dir(l) * vf_wr(l)
-                  road_r_shadewall_dir(l)    = road_r_dir(l) * vf_wr(l)
-
-                  sunwall_r_sky_dir(l)       = sunwall_r_dir(l) * vf_sw(l)
-                  sunwall_r_road_dir(l)      = sunwall_r_dir(l) * vf_rw(l)
-                  sunwall_r_shadewall_dir(l) = sunwall_r_dir(l) * vf_ww(l)
-
-                  shadewall_r_sky_dir(l)     = shadewall_r_dir(l) * vf_sw(l)
-                  shadewall_r_road_dir(l)    = shadewall_r_dir(l) * vf_rw(l)
-                  shadewall_r_sunwall_dir(l) = shadewall_r_dir(l) * vf_ww(l)
-
-                  ! step (4)
-
-                  sref_improad_dir(l,ib)   = sref_improad_dir(l,ib) + improad_r_sky_dir(l)
-                  sref_perroad_dir(l,ib)   = sref_perroad_dir(l,ib) + perroad_r_sky_dir(l)
-                  sref_sunwall_dir(l,ib)   = sref_sunwall_dir(l,ib) + sunwall_r_sky_dir(l)
-                  sref_shadewall_dir(l,ib) = sref_shadewall_dir(l,ib) + shadewall_r_sky_dir(l)
-
-                  ! step (5)
-
-                  crit = max(road_a_dir(l), sunwall_a_dir(l), shadewall_a_dir(l))
-                  if (crit < errcrit) exit
-               end do
-               if (iter_dir >= n) then
-                  write (iulog,*) 'urban net solar radiation error: no convergence, direct beam'
-                  write (iulog,*) 'clm model is stopping'
-                  call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
-               endif
-
-               ! reflected diffuse
-
-               do iter_dif = 1, n
-                  ! step (1)
-
-                  stot(l) = (sunwall_r_road_dif(l) + shadewall_r_road_dif(l))*canyon_hwr(l)
-                  road_a_dif(l)    = 0.0_r8
-                  road_r_dif(l)    = 0.0_r8
-                  improad_a_dif(l) = (1._r8-alb_improad_dif(l,ib)) * stot(l) 
-                  improad_r_dif(l) =     alb_improad_dif(l,ib)  * stot(l) 
-                  road_a_dif(l)    = road_a_dif(l) + improad_a_dif(l)*wtroad_imperv(l)
-                  road_r_dif(l)    = road_r_dif(l) + improad_r_dif(l)*wtroad_imperv(l)
-                  perroad_a_dif(l) = (1._r8-alb_perroad_dif(l,ib)) * stot(l) 
-                  perroad_r_dif(l) =     alb_perroad_dif(l,ib)  * stot(l) 
-                  road_a_dif(l)    = road_a_dif(l) + perroad_a_dif(l)*wtroad_perv(l)
-                  road_r_dif(l)    = road_r_dif(l) + perroad_r_dif(l)*wtroad_perv(l)
-
-                  stot(l) = road_r_sunwall_dif(l)/canyon_hwr(l) + shadewall_r_sunwall_dif(l)
-                  sunwall_a_dif(l) = (1._r8-alb_wall_dif(l,ib)) * stot(l)
-                  sunwall_r_dif(l) =     alb_wall_dif(l,ib)  * stot(l)
-
-                  stot(l) = road_r_shadewall_dif(l)/canyon_hwr(l) + sunwall_r_shadewall_dif(l)
-                  shadewall_a_dif(l) = (1._r8-alb_wall_dif(l,ib)) * stot(l)
-                  shadewall_r_dif(l) =     alb_wall_dif(l,ib)  * stot(l)
-
-                  ! step (2)
-
-                  sabs_improad_dif(l,ib)   = sabs_improad_dif(l,ib)   + improad_a_dif(l)
-                  sabs_perroad_dif(l,ib)   = sabs_perroad_dif(l,ib)   + perroad_a_dif(l)
-                  sabs_sunwall_dif(l,ib)   = sabs_sunwall_dif(l,ib)   + sunwall_a_dif(l)
-                  sabs_shadewall_dif(l,ib) = sabs_shadewall_dif(l,ib) + shadewall_a_dif(l)
-
-                  ! step (3)
-
-                  improad_r_sky_dif(l)       = improad_r_dif(l) * vf_sr(l)
-                  improad_r_sunwall_dif(l)   = improad_r_dif(l) * vf_wr(l)
-                  improad_r_shadewall_dif(l) = improad_r_dif(l) * vf_wr(l)
-
-                  perroad_r_sky_dif(l)       = perroad_r_dif(l) * vf_sr(l)
-                  perroad_r_sunwall_dif(l)   = perroad_r_dif(l) * vf_wr(l)
-                  perroad_r_shadewall_dif(l) = perroad_r_dif(l) * vf_wr(l)
-
-                  road_r_sky_dif(l)          = road_r_dif(l) * vf_sr(l)
-                  road_r_sunwall_dif(l)      = road_r_dif(l) * vf_wr(l)
-                  road_r_shadewall_dif(l)    = road_r_dif(l) * vf_wr(l)
-
-                  sunwall_r_sky_dif(l)       = sunwall_r_dif(l) * vf_sw(l)
-                  sunwall_r_road_dif(l)      = sunwall_r_dif(l) * vf_rw(l)
-                  sunwall_r_shadewall_dif(l) = sunwall_r_dif(l) * vf_ww(l)
-
-                  shadewall_r_sky_dif(l)     = shadewall_r_dif(l) * vf_sw(l)
-                  shadewall_r_road_dif(l)    = shadewall_r_dif(l) * vf_rw(l)
-                  shadewall_r_sunwall_dif(l) = shadewall_r_dif(l) * vf_ww(l)
-
-                  ! step (4)
-
-                  sref_improad_dif(l,ib)   = sref_improad_dif(l,ib)   + improad_r_sky_dif(l)
-                  sref_perroad_dif(l,ib)   = sref_perroad_dif(l,ib)   + perroad_r_sky_dif(l)
-                  sref_sunwall_dif(l,ib)   = sref_sunwall_dif(l,ib)   + sunwall_r_sky_dif(l)
-                  sref_shadewall_dif(l,ib) = sref_shadewall_dif(l,ib) + shadewall_r_sky_dif(l)
-
-                  ! step (5)
-
-                  crit = max(road_a_dif(l), sunwall_a_dif(l), shadewall_a_dif(l))
-                  if (crit < errcrit) exit
-               end do
-               if (iter_dif >= n) then
-                  write (iulog,*) 'urban net solar radiation error: no convergence, diffuse'
-                  write (iulog,*) 'clm model is stopping'
-                  call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
-               endif
-
-               ! total reflected by canyon - sum of solar reflection to sky from canyon.
-               ! project wall fluxes to horizontal surface
-
-               sref_canyon_dir(l) = 0.0_r8
-               sref_canyon_dif(l) = 0.0_r8
-               sref_canyon_dir(l) = sref_canyon_dir(l) + sref_improad_dir(l,ib)*wtroad_imperv(l)
-               sref_canyon_dif(l) = sref_canyon_dif(l) + sref_improad_dif(l,ib)*wtroad_imperv(l)
-               sref_canyon_dir(l) = sref_canyon_dir(l) + sref_perroad_dir(l,ib)*wtroad_perv(l)
-               sref_canyon_dif(l) = sref_canyon_dif(l) + sref_perroad_dif(l,ib)*wtroad_perv(l)
-               sref_canyon_dir(l) = sref_canyon_dir(l) + (sref_sunwall_dir(l,ib) + sref_shadewall_dir(l,ib))*canyon_hwr(l)
-               sref_canyon_dif(l) = sref_canyon_dif(l) + (sref_sunwall_dif(l,ib) + sref_shadewall_dif(l,ib))*canyon_hwr(l)
-
-               ! total absorbed by canyon. project wall fluxes to horizontal surface
-
-               sabs_canyon_dir(l) = 0.0_r8
-               sabs_canyon_dif(l) = 0.0_r8
-               sabs_canyon_dir(l) = sabs_canyon_dir(l) + sabs_improad_dir(l,ib)*wtroad_imperv(l)
-               sabs_canyon_dif(l) = sabs_canyon_dif(l) + sabs_improad_dif(l,ib)*wtroad_imperv(l)
-               sabs_canyon_dir(l) = sabs_canyon_dir(l) + sabs_perroad_dir(l,ib)*wtroad_perv(l)
-               sabs_canyon_dif(l) = sabs_canyon_dif(l) + sabs_perroad_dif(l,ib)*wtroad_perv(l)
-               sabs_canyon_dir(l) = sabs_canyon_dir(l) + (sabs_sunwall_dir(l,ib) + sabs_shadewall_dir(l,ib))*canyon_hwr(l)
-               sabs_canyon_dif(l) = sabs_canyon_dif(l) + (sabs_sunwall_dif(l,ib) + sabs_shadewall_dif(l,ib))*canyon_hwr(l)
-
-               ! conservation check. note: previous conservation checks confirm partioning of total direct
-               ! beam and diffuse radiation from atmosphere to road and walls is conserved as
-               !    sdir (from atmosphere) = sdir_road + (sdir_sunwall + sdir_shadewall)*canyon_hwr
-               !    sdif (from atmosphere) = sdif_road + (sdif_sunwall + sdif_shadewall)*canyon_hwr
-
-               stot_dir(l) = sdir_road(l,ib) + (sdir_sunwall(l,ib) + sdir_shadewall(l,ib))*canyon_hwr(l)
-               stot_dif(l) = sdif_road(l,ib) + (sdif_sunwall(l,ib) + sdif_shadewall(l,ib))*canyon_hwr(l)
-
-               err = stot_dir(l) + stot_dif(l) &
-                    - (sabs_canyon_dir(l) + sabs_canyon_dif(l) + sref_canyon_dir(l) + sref_canyon_dif(l))
-               if (abs(err) > 0.001_r8 ) then
-                  write(iulog,*)'urban net solar radiation balance error for ib=',ib,' err= ',err
-                  write(iulog,*)' l= ',l,' ib= ',ib 
-                  write(iulog,*)' stot_dir        = ',stot_dir(l)
-                  write(iulog,*)' stot_dif        = ',stot_dif(l)
-                  write(iulog,*)' sabs_canyon_dir = ',sabs_canyon_dir(l)
-                  write(iulog,*)' sabs_canyon_dif = ',sabs_canyon_dif(l)
-                  write(iulog,*)' sref_canyon_dir = ',sref_canyon_dir(l)
-                  write(iulog,*)' sref_canyon_dif = ',sref_canyon_dir(l)
-                  write(iulog,*) 'clm model is stopping'
-                  call endrun(subgrid_index=l, subgrid_level=subgrid_level_landunit, msg=errmsg(sourcefile, __LINE__))
-               endif
-
-               ! canyon albedo
-
-               canyon_alb_dif(l) = sref_canyon_dif(l) / max(stot_dif(l), 1.e-06_r8)
-               canyon_alb_dir(l) = sref_canyon_dir(l) / max(stot_dir(l), 1.e-06_r8)
-            end if
+            canyon_alb_dif(l) = sref_canyon_dif(l) / max(stot_dif(l), 1.e-06_r8)
+            canyon_alb_dir(l) = sref_canyon_dir(l) / max(stot_dir(l), 1.e-06_r8)
 
          end do   ! end of landunit loop
 
-         ! Refected and absorbed solar radiation per unit incident radiation for roof
+         ! Reflected and absorbed solar radiation per unit incident radiation for roof
 
-         do fl = 1,num_urbanl
-            l = filter_urbanl(fl)
-            if (coszen(l) > 0._r8) then
-               sref_roof_dir(l,ib) = alb_roof_dir(l,ib) * sdir(l,ib)
-               sref_roof_dif(l,ib) = alb_roof_dif(l,ib) * sdif(l,ib)
-               sabs_roof_dir(l,ib) = sdir(l,ib) - sref_roof_dir(l,ib)
-               sabs_roof_dif(l,ib) = sdif(l,ib) - sref_roof_dif(l,ib)
-            end if
+         do fl = 1,num_urbanl_coszen_gt0
+            l = filter_urbanl_coszen_gt0(fl)
+            sref_roof_dir(l,ib) = alb_roof_dir(l,ib) * sdir(l,ib)
+            sref_roof_dif(l,ib) = alb_roof_dif(l,ib) * sdif(l,ib)
+            sabs_roof_dir(l,ib) = sdir(l,ib) - sref_roof_dir(l,ib)
+            sabs_roof_dif(l,ib) = sdif(l,ib) - sref_roof_dif(l,ib)
          end do
 
       end do   ! end of radiation band loop