lalsuite 7.22.1.dev20240408__cp312-cp312-manylinux_2_28_aarch64.whl → 7.26.2.dev20251202__cp312-cp312-manylinux_2_28_aarch64.whl

{lalsuite-7.22.1.dev20240408.data → lalsuite-7.26.2.dev20251202.data}/scripts/lalpulsar_MakeSFTDAG

@@ -1,6 +1,5 @@
 #!python
-##(in place of shebang, for consistent line numbers)
-# Copyright (C) 2013, 2014, 2020--2022 Evan Goetz
+# Copyright (C) 2013, 2014, 2020--2024 Evan Goetz
 # Copyright (C) 2011, 2021, 2022 Karl Wette
 # Copyright (C) 2005, 2007 Gregory Mendell
 #
@@ -19,19 +18,35 @@
 # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301  USA
 
+## \file
+## \ingroup lalpulsar_bin_SFTTools
 """Creates DAGs to run jobs that generates SFTs"""
 
 import math
 import argparse
 import os
 import re
+from pathlib import Path
+from urllib.parse import urlparse
 
-from lalpulsar import git_version
+from gwdatafind import find_urls
+from gwdatafind.utils import filename_metadata, file_segment
+
+from igwn_segments import segment, segmentlist
+
+from lalpulsar import (
+    git_version,
+    SFTFilenameSpec,
+    FillSFTFilenameSpecStrings,
+    BuildSFTFilenameFromSpec,
+)
 
 __author__ = "Evan Goetz <evan.goetz@ligo.org>, Greg Mendell"
 __version__ = git_version.id
 __date__ = git_version.date
 
+cache_re = re.compile(r"^([A-Z])(\s+)(\w+)(\s+)(\d+)(\s+)(\d+)(\s+)(.+gwf)")
+
 
 # REVISIONS:
 # 12/02/05 gam; generate datafind.sub and MakeSFTs.sub as well as dag file in
@@ -69,23 +84,139 @@ __date__ = git_version.date
 # 11/2022  kww; -R command line option now used for --observing-revision
 #               instead of --output-jobs-per-node, which now uses -r
 # 11/2022  kww; --datafind-path and --makesfts-path accept executable names
+# 03/2023  eag; Allow user to pass a frame cache file --cache-file
+# 04/2023  kww; Improve documentation of --window-type argument
+# 05/2023  eag; Add the --gaps flag to gw_data_find
+# 08/2023  eag; Allow for multiple channel names to be provided
+# 09/2023  eag; Modify use of environment variables
+# 01/2024  eag; Allow skipping of channels if not in frames or too low data
+#               rate
+# 10/2024  eag; Modify workflow for version 3 SFTs and HTCondor file transfer
+#               workflow
+# 12/2024  eag; Modify workflow to use lalpulsar_MoveSFTs script instead of
+#               remapping files
+# 03/2025  eag; Rewrite to generate cache files running lalpulsar_MakeSFTDAG
+#               enabling frame files on /home or OSDF
+
+
+def sft_name_from_vars(
+    obs,
+    gpsstart,
+    Tsft,
+    channel=None,
+    kind=None,
+    rev=None,
+    window="unknown",
+    par=None,
+    miscstr=None,
+):
+    """Create SFT file name from specification"""
+
+    spec = SFTFilenameSpec()
+
+    FillSFTFilenameSpecStrings(
+        spec=spec,
+        path=None,
+        extn=None,
+        detector=channel[:2],
+        window_type=window,
+        privMisc=miscstr,
+        pubObsKind=kind,
+        pubChannel=channel,
+    )
+    spec.pubObsRun = obs or 0
+    spec.pubRevision = rev or 0
+    spec.window_param = par or 0
+    spec.numSFTs = 1  # MakeSFTDAG will only ever generate 1 SFT per file
+    spec.SFTtimebase = Tsft
+    spec.gpsStart = gpsstart
+    spec.SFTspan = Tsft  # MakeSFTDAG will only ever generate 1 SFT per file
 
+    return BuildSFTFilenameFromSpec(spec)
+
+
+def get_urls(args):
+    """Get frame file URL list from gwdatafind or cache file"""
+
+    if not args.cache_file:
+        urls = find_urls(
+            site,
+            args.input_data_type,
+            segList[0][0],
+            segList[-1][-1],
+            match=args.datafind_match,
+            urltype=args.datafind_urltype,
+        )
+    else:
+        urls = []
+        with open(args.cache_file, "r") as f:
+            for line in f:
+                m = cache_re.match(line)
+                if m:
+                    framefile = m.group(9)
+                    urls.append(framefile)
+
+    # sort the urls by gps time since find_urls() may not return a sorted list
+    sorted_urls = sorted(urls, key=lambda x: file_segment(x)[0])
+
+    return sorted_urls
+
+
+def make_cache(
+    urls,
+    job_seg,
+):
+    """Make a frame list and cache list from a list of URLs"""
+
+    cache = []  # list of lines for the cache file
+    frames = []  # list of frame filenames used in the job
+    for idx, url in enumerate(urls):
+        obs, desc, dataseg = filename_metadata(url)
+        dataseg = segment(dataseg)
+        if dataseg.disjoint(job_seg) < 0:
+            continue
+        if dataseg.disjoint(job_seg) > 0:
+            break
+        if dataseg.intersects(job_seg):
+            framefileurl = urlparse(url)
+            framefilepath = Path(framefileurl.path)
+
+            # list in cache file if files not visible on execute node
+            # otherwise use file url
+            if "/home" in str(framefilepath.parent) or "osdf" in framefileurl.scheme:
+                newcache = (
+                    f"{obs}\t{desc}\t{dataseg[0]}\t{abs(dataseg)}\t{framefilepath.name}"
+                )
+            else:
+                newcache = f"{obs}\t{desc}\t{dataseg[0]}\t{abs(dataseg)}\t{url}"
+            cache.append(newcache)
+
+            if "/home" in str(framefilepath.parent):
+                frames.append(framefilepath)
+            else:
+                frames.append(url)
+
+    return frames, cache
+
+
+def writeToDag(dagFID, nodeCount, startTimeThisNode, endTimeThisNode, urls, args):
+    """Write one job to DAG file"""
 
-#
-# FUNCTION THAT WRITE ONE JOB TO DAG FILE
-#
-def writeToDag(dagFID, nodeCount, startTimeThisNode, endTimeThisNode, site, args):
-    datafind = f"datafind_{nodeCount}"
     MakeSFTs = f"MakeSFTs_{nodeCount}"
-    startTimeDatafind = startTimeThisNode - args.extra_datafind_time
-    endTimeDatafind = endTimeThisNode + args.extra_datafind_time
     tagStringOut = f"{args.tag_string}_{nodeCount}"
-    if args.cache_file:
-        cacheFile = args.cache_file
-    else:
-        cacheFile = (
-            f"{args.cache_path}/{site}-{startTimeDatafind}-{endTimeDatafind}.cache"
-        )
+
+    job_segment = segment(
+        startTimeThisNode - args.extra_datafind_time,
+        endTimeThisNode + args.extra_datafind_time,
+    )
+
+    frames, cache = make_cache(urls, job_segment)
+
+    obs, desc, dataseg = filename_metadata(urls[0])
+    cacheFile = args.cache_path / f"{obs}-{job_segment[0]}-{job_segment[1]}.cache"
+    with open(cacheFile, "w") as f:
+        for l in cache:
+            f.write(f"{l}\n")
 
     argList = []
     argList.append(f"-O {args.observing_run}")
@@ -96,8 +227,14 @@ def writeToDag(dagFID, nodeCount, startTimeThisNode, endTimeThisNode, site, args
         argList.append(f"-X {args.misc_desc}")
     argList.append(f"-f {args.filter_knee_freq}")
     argList.append(f"-t {args.time_baseline}")
-    argList.append(f"-p {','.join(args.output_sft_path)}")
-    argList.append(f"-C {cacheFile}")
+    # To work with the condor file transfer protocol, we save everything to the
+    # scratch directory because the files will have unique names. Since
+    # lalpulsar_MakeSFTs wants to have a path to save the file to, we provide .
+    argList.append(f"-p {','.join(['.' for p in args.output_sft_path])}")
+    # To work with the condor file transfer protocol, the cache file is saved
+    # to the scratch directory on transfer so we just need the name, not the
+    # full path
+    argList.append(f"-C {cacheFile.name}")
     argList.append(f"-s {startTimeThisNode}")
     argList.append(f"-e {endTimeThisNode}")
     argList.append(f"-N {','.join(args.channel_name)}")
@@ -105,36 +242,59 @@ def writeToDag(dagFID, nodeCount, startTimeThisNode, endTimeThisNode, site, args
     argList.append(f"-B {args.band}")
     if args.comment_field:
         argList.append(f"-c {args.comment_field}")
-    if args.window_type:
-        if ":" in args.window_type:
-            window_type, window_param = args.window_type.split(":")
-            argList.append(f"-w {window_type} -r {window_param}")
-        else:
-            argList.append(f"-w {args.window_type}")
+    if ":" in args.window_type:
+        window_type, window_param = args.window_type.split(":")
+        window_param = float(window_param)
+        argList.append(f"-w {window_type} -r {window_param}")
+    else:
+        window_type = args.window_type
+        window_param = None
+        argList.append(f"-w {window_type}")
     if args.overlap_fraction:
         argList.append(f"-P {args.overlap_fraction}")
     if args.allow_skipping:
         argList.append("--allow-skipping TRUE")
     argStr = " ".join(argList)
 
-    # gw_data_find job
-    if not args.cache_file:
-        dagFID.write(
-            f"JOB {datafind} {os.path.join(os.path.dirname(dagFID.name), 'datafind.sub')}\n"
-        )
-        dagFID.write(f"RETRY {datafind} 1\n")
-        dagFID.write(
-            f'VARS {datafind} gpsstarttime="{startTimeDatafind}" gpsendtime="{endTimeDatafind}" observatory="{site}" inputdatatype="{args.input_data_type}" tagstring="{tagStringOut}"\n'
-        )
+    # The files are going to go to specific directories, so we need to map
+    # the files to their output directories
+    outputfiles = []
+    remap = []
+    sft_start = startTimeThisNode
+    sft_end = sft_start + args.time_baseline
+    # loop over start times
+    while sft_end <= endTimeThisNode:
+        # loop over channels
+        for idx, c in enumerate(args.channel_name):
+            filename = sft_name_from_vars(
+                args.observing_run,
+                sft_start,
+                args.time_baseline,
+                c,
+                kind=args.observing_kind,
+                rev=args.observing_revision,
+                window=window_type,
+                par=window_param,
+                miscstr=args.misc_desc,
+            )
+            outputfiles.append(filename)
+            remap.append(f"{filename}={args.output_sft_path[idx]/filename}")
+
+        # update start and end times
+        if args.overlap_fraction:
+            sft_start += int(round((1 - args.overlap_fraction) * args.time_baseline))
+        else:
+            sft_start += args.time_baseline
+        sft_end = sft_start + args.time_baseline
 
     # MakeSFT job
-    dagFID.write(
-        f"JOB {MakeSFTs} {os.path.join(os.path.dirname(dagFID.name), 'MakeSFTs.sub')}\n"
-    )
+    dagFID.write(f"JOB {MakeSFTs} {Path(dagFID.name).parent / 'MakeSFTs.sub'}\n")
     dagFID.write(f"RETRY {MakeSFTs} 1\n")
-    dagFID.write(f'VARS {MakeSFTs} argList="{argStr}" tagstring="{tagStringOut}"\n')
-    if not args.cache_file:
-        dagFID.write(f"PARENT {datafind} CHILD {MakeSFTs}\n")
+    dagFID.write(f'VARS {MakeSFTs} argList="{argStr}" cachefile="{cacheFile}" ')
+    if args.transfer_frame_files:
+        framefiles = ",".join([str(fr) for fr in frames])
+        dagFID.write(f'framefiles="{framefiles}" ')
+    dagFID.write(f'tagstring="{tagStringOut}"\n')
 
 
 #
@@ -142,76 +302,157 @@ def writeToDag(dagFID, nodeCount, startTimeThisNode, endTimeThisNode, site, args
 #
 
 parser = argparse.ArgumentParser(
-    description="This script creates datafind.sub, MakeSFTs.sub, and a dag \
+    description="This script creates MakeSFTs.sub, MoveSFTs.sub, and a dag \
                  file that generates SFTs based on the options given.",
     fromfile_prefix_chars="@",
 )
-parser.add_argument(
-    "-O",
-    "--observing-run",
-    required=True,
-    type=int,
-    help="For public SFTs, observing run data the SFTs are generated from, or \
-          (in the case of mock data challenge data) the observing \
-          run on which the data is most closely based",
+
+dag_group = parser.add_argument_group(
+    "DAG organization", "Options for workflow control"
 )
-parser.add_argument(
-    "-K",
-    "--observing-kind",
-    type=str,
-    choices=["RUN", "AUX", "SIM", "DEV"],
-    help='For public SFTs, one of: "RUN" for production SFTs of h(t) channels; \
-          "AUX" for SFTs of non-h(t) channels; \
-          "SIM" for mock data challenge or other simulated data; or \
-          "DEV" for development/testing purposes',
+datafind_group = parser.add_argument_group(
+    "Datafind", "Options for locating frame files"
 )
-parser.add_argument(
-    "-R",
-    "--observing-revision",
-    type=int,
-    help="For public SFTs: revision number starts at 1, and should be incremented once \
-          SFTs have been widely distributed across clusters, advertised \
-          as being ready for use, etc.  For example, if mistakes are found \
-          in the initial SFT production run after they have been published, \
-          regenerated SFTs should have a revision number of at least 2",
+makesfts_group = parser.add_argument_group(
+    "SFT creation", "Options for SFT creation and output"
 )
-parser.add_argument(
-    "-X",
-    "--misc-desc",
+deprecated_group = parser.add_argument_group("DEPRECATED")
+
+dag_group.add_argument(
+    "-f",
+    "--dag-file",
+    required=True,
+    type=Path,
+    help="filename for .dag file (should end in .dag)",
+)
+dag_group.add_argument(
+    "-G",
+    "--tag-string",
+    required=True,
     type=str,
-    help="For private SFTs, miscellaneous part of the SFT \
-          description field in the filename",
+    help="tag string used in names of various files unique to \
+          jobs that will run under the DAG",
 )
-parser.add_argument(
+dag_group.add_argument(
     "-a",
     "--analysis-start-time",
     type=int,
     help="GPS start time of data from which to generate \
           SFTs (optional and unused if a segment file is given)",
 )
-parser.add_argument(
+dag_group.add_argument(
     "-b",
     "--analysis-end-time",
     type=int,
     help="GPS end time of data from which to generate SFTs \
           (optional and unused if a segment file is given)",
 )
-parser.add_argument(
-    "-f",
-    "--dag-file",
+dag_group.add_argument(
+    "-L",
+    "--max-length-all-jobs",
+    type=int,
+    help="maximum total amount of data to process, in seconds \
+          (optional and unused if a segment file is given)",
+)
+dag_group.add_argument(
+    "-g",
+    "--segment-file",
+    type=Path,
+    help="alternative file with segments to use, rather than \
+          the input times",
+)
+dag_group.add_argument(
+    "-l",
+    "--min-seg-length",
+    type=int,
+    default=0,
+    help="minimum length segments to process in seconds (used \
+          only if a segment file is given)",
+)
+dag_group.add_argument(
+    "-y",
+    "--synchronize-start",
+    action="store_true",
+    help="synchronize the start times of the SFTs so that the \
+          start times are synchronized when there are gaps in the \
+          data",
+)
+dag_group.add_argument(
+    "-o",
+    "--log-path",
+    type=Path,
+    default="logs",
+    help="path to log, output, and error files (default \
+          is $PWD/logs; this directory is created if it does not \
+          exist and usually should be under a local file system)",
+)
+dag_group.add_argument(
+    "-m",
+    "--max-num-per-node",
+    type=int,
+    default=1,
+    help="maximum number of SFTs to generate on one node",
+)
+dag_group.add_argument(
+    "-J",
+    "--makesfts-path",
+    type=Path,
+    help="string specifying the lalpulsar_MakeSFTs executable, \
+          or a path to it; if not set, will use \
+          MAKESFTS_PATH env variable or system default (in that \
+          order)",
+)
+dag_group.add_argument(
+    "--movesfts-path",
+    type=Path,
+    help="string specifying the lalpulsar_MoveSFTs executable, \
+          or a path to it; if not set, will use \
+          MOVESFTS_PATH env variable or system default (in that \
+          order)",
+)
+dag_group.add_argument(
+    "-Y",
+    "--request-memory",
+    type=int,
+    default=4096,
+    help="memory allocation in MB to request from condor for \
+          lalpulsar_MakeSFTs step",
+)
+dag_group.add_argument(
+    "-s",
+    "--request-disk",
+    type=int,
+    default=4096,
+    help="disk space allocation in MB to request from condor \
+          for lalpulsar_MakeSFTs step",
+)
+dag_group.add_argument(
+    "-A",
+    "--accounting-group",
     required=True,
     type=str,
-    help="filename for .dag file (should end in .dag)",
+    help="Condor tag for the production of SFTs",
 )
-parser.add_argument(
-    "-G",
-    "--tag-string",
+dag_group.add_argument(
+    "-U",
+    "--accounting-group-user",
     required=True,
     type=str,
-    help="tag string used in names of various files unique to \
-          jobs that will run under the DAG",
+    help="albert.einstein username (do not add @LIGO.ORG)",
+)
+dag_group.add_argument(
+    "-t",
+    "--transfer-frame-files",
+    action="store_true",
+    help="Transfer frame files via HTCondor file transfer system. \
+          This should be specified if frames are not visible to the \
+          compute node file system. Ex. this should be specified if \
+          frames are on /home or running on the open science grid. \
+          Usually frame files are visible on CIT, LHO, LLO clusters \
+          so that this does not need to be specified in that case.",
 )
-parser.add_argument(
+
+datafind_group.add_argument(
     "-d",
     "--input-data-type",
     required=True,
@@ -219,7 +460,7 @@ parser.add_argument(
     help="input data type for use with the gw_data_find --type \
           option",
 )
-parser.add_argument(
+datafind_group.add_argument(
     "-x",
     "--extra-datafind-time",
     type=int,
@@ -227,95 +468,136 @@ parser.add_argument(
     help="extra time to subtract/add from/to start/end time \
           arguments of gw_data_find",
 )
-parser.add_argument(
+datafind_group.add_argument(
     "-M",
     "--datafind-match",
     type=str,
     help="string to use with the gw_data_find --match option",
 )
-parser.add_argument(
-    "-y",
-    "--synchronize-start",
-    action="store_true",
-    help="synchronize the start times of the SFTs so that the \
-          start times are synchronized when there are gaps in the \
-          data",
+datafind_group.add_argument(
+    "--datafind-urltype",
+    type=str,
+    default="file",
+    choices=["file", "osdf"],
+    help="String for the gw_data_find --urltype option. \
+          Use 'file' if creating SFTs on a local LDG cluster. \
+          Use 'osdf' if creating SFTs on the open science grid",
+)
+datafind_group.add_argument(
+    "-e",
+    "--cache-file",
+    type=Path,
+    help="path and filename to frame cache file to use instead \
+          of gw_data_find",
 )
-parser.add_argument(
+
+makesfts_group.add_argument(
+    "-O",
+    "--observing-run",
+    required=True,
+    type=int,
+    help="For public SFTs, observing run data the SFTs are generated from, or \
+          (in the case of mock data challenge data) the observing \
+          run on which the data is most closely based",
+)
+makesfts_group.add_argument(
+    "-K",
+    "--observing-kind",
+    type=str,
+    choices=["RUN", "AUX", "SIM", "DEV"],
+    help='For public SFTs, one of: "RUN" for production SFTs of h(t) channels; \
+          "AUX" for SFTs of non-h(t) channels; \
+          "SIM" for mock data challenge or other simulated data; or \
+          "DEV" for development/testing purposes',
+)
+makesfts_group.add_argument(
+    "-R",
+    "--observing-revision",
+    type=int,
+    help="For public SFTs: revision number starts at 1, and should be incremented once \
+          SFTs have been widely distributed across clusters, advertised \
+          as being ready for use, etc.  For example, if mistakes are found \
+          in the initial SFT production run after they have been published, \
+          regenerated SFTs should have a revision number of at least 2",
+)
+makesfts_group.add_argument(
+    "-X",
+    "--misc-desc",
+    type=str,
+    help="For private SFTs, miscellaneous part of the SFT \
+          description field in the filename",
+)
+makesfts_group.add_argument(
     "-k",
     "--filter-knee-freq",
     required=True,
-    type=int,
+    type=float,
     help="high pass filter knee frequency used on time domain \
           data before generating SFTs",
 )
-parser.add_argument(
+makesfts_group.add_argument(
     "-T",
     "--time-baseline",
     required=True,
     type=int,
     help="time baseline of SFTs  (e.g., 60 or 1800 seconds)",
 )
-parser.add_argument(
-    "-p", "--output-sft-path", nargs="+", type=str, help="path to output SFTs"
+makesfts_group.add_argument(
+    "-p",
+    "--output-sft-path",
+    nargs="+",
+    type=Path,
+    help="Path where to save the SFT files. Can specify multiple options, \
+          If specifying multiple options then it is required to specify the \
+          same number of output-sft-path options as the number of channels. \
+          The first listed channel will have the SFTs go into the first \
+          listed output-sft-path. Otherwise specify only one output path. \
+          If one path is specified and more than 1 channels are specified \
+          then --observing-run must be >= 1 and --observing-kind and \
+          --observing-revision must be set",
 )
-parser.add_argument(
+makesfts_group.add_argument(
     "-C",
     "--cache-path",
-    type=str,
+    type=Path,
     default="cache",
     help="path to cache files that will be produced by \
           gw_data_find (default is $PWD/cache; this directory is \
           created if it does not exist and must agree with that \
           given in .sub files)",
 )
-parser.add_argument(
-    "-e",
-    "--cache-file",
-    type=str,
-    help="path and filename to frame cache file to use instead \
-          of gw_data_find",
-)
-parser.add_argument(
-    "-o",
-    "--log-path",
-    type=str,
-    default="logs",
-    help="path to log, output, and error files (default \
-          is $PWD/logs; this directory is created if it does not \
-          exist and usually should be under a local file system)",
-)
-parser.add_argument(
+makesfts_group.add_argument(
     "-N",
     "--channel-name",
     nargs="+",
     type=str,
-    help="name of input time-domain channel to read from \
-          frames",
+    help="Name of input time-domain channel to read from frames. \
+          Can specify multiple options. The number of channels must be \
+          equal to the number of output-sft-path options given. The \
+          first listed channel will have the SFTs go to the first listed \
+          output-sft-path. Can only specify one channel when generating \
+          private SFTs (--observing-run=0)",
 )
-parser.add_argument(
-    "--allow-skipping",
-    action="store_true",
-    help="allow channels to be skipped if not in frames or too low sampling \
-          frequency",
+makesfts_group.add_argument(
+    "-c", "--comment-field", type=str, help="comment for SFT header"
 )
-parser.add_argument("-c", "--comment-field", type=str, help="comment for SFT header")
-parser.add_argument(
+makesfts_group.add_argument(
     "-F", "--start-freq", type=int, default=10, help="start frequency of the SFTs"
 )
-parser.add_argument(
+makesfts_group.add_argument(
     "-B", "--band", type=int, default=1990, help="frequency band of the SFTs"
 )
-parser.add_argument(
+makesfts_group.add_argument(
     "-w",
     "--window-type",
     type=str,
+    default="tukey:0.001",
     help='type of windowing of time-domain to do \
           before generating SFTs, e.g. "rectangular", \
           "hann", "tukey:<beta in [0,1], required>"; \
-          if unspecified use lalpulsar_MakeSFTs defaults',
+          (default is "tukey:0.001", standard choice for LVK production SFTs)',
 )
-parser.add_argument(
+makesfts_group.add_argument(
     "-P",
     "--overlap-fraction",
     type=float,
@@ -323,112 +605,19 @@ parser.add_argument(
     help="overlap fraction (for use with windows; e.g., use \
           --overlap-fraction 0.5 with --window-type hann windows)",
 )
-parser.add_argument(
-    "-m",
-    "--max-num-per-node",
-    type=int,
-    default=1,
-    help="maximum number of SFTs to generate on one node",
-)
-parser.add_argument(
-    "-L",
-    "--max-length-all-jobs",
-    type=int,
-    help="maximum total amount of data to process, in seconds \
-          (optional and unused if a segment file is given)",
-)
-parser.add_argument(
-    "-g",
-    "--segment-file",
-    type=str,
-    help="alternative file with segments to use, rather than \
-          the input times",
-)
-parser.add_argument(
-    "-l",
-    "--min-seg-length",
-    type=int,
-    default=0,
-    help="minimum length segments to process in seconds (used \
-          only if a segment file is given)",
-)
-parser.add_argument(
-    "-q",
-    "--list-of-nodes",
-    type=str,
-    help="file with list of nodes on which to output SFTs",
-)
-parser.add_argument(
-    "-Q",
-    "--node-path",
-    type=str,
-    help="path to nodes to output SFTs; the node name is \
-          appended to this path, followed by path given by the -p \
-          option; for example, if -q point to file with the list \
-          node1 node2 ... and the -Q /data/ -p /frames/S5/sfts/LHO \
-          options are given, the first output file will go into \
-          /data/node1/frames/S5/sfts/LHO; the next node in the list \
-          is used in constructing the path when the number of jobs \
-          given by the -r option reached, and so on",
-)
-parser.add_argument(
-    "-r",
-    "--output-jobs-per-node",
-    type=int,
-    default=0,
-    help="number of jobs to output per node in the list of \
-          nodes given with the -q option",
-)
-parser.add_argument(
-    "-j",
-    "--datafind-path",
-    type=str,
-    help="string specifying the gw_data_find executable, \
-          or a path to it; if not set, will use \
-          LSC_DATAFIND_PATH env variable or system default (in \
-          that order)",
-)
-parser.add_argument(
-    "-J",
-    "--makesfts-path",
-    type=str,
-    help="string specifying the lalpulsar_MakeSFTs executable, \
-          or a path to it; if not set, will use \
-          MAKESFTS_PATH env variable or system default (in that \
-          order)",
-)
-parser.add_argument(
-    "-Y",
-    "--request-memory",
-    type=int,
-    default=2048,
-    help="memory allocation in MB to request from condor for \
-          lalpulsar_MakeSFTs step",
-)
-parser.add_argument(
-    "-s",
-    "--request-disk",
-    type=int,
-    default=1024,
-    help="disk space allocation in MB to request from condor \
-          for lalpulsar_MakeSFTs step",
+makesfts_group.add_argument(
+    "--allow-skipping",
+    action="store_true",
+    help="allow channels to be skipped if not in frames or too low sampling \
+          frequency",
 )
-parser.add_argument(
-    "-A",
-    "--accounting-group",
-    required=True,
-    type=str,
-    help="Condor tag for the production of SFTs",
-)
-parser.add_argument(
-    "-U",
-    "--accounting-group-user",
-    required=True,
-    type=str,
-    help="albert.einstein username (do not add @LIGO.ORG)",
+makesfts_group.add_argument(
+    "--no-validate",
+    dest="validate",
+    action="store_false",
+    help="do not validate created SFTs",
 )
 
-
 ##### DEPRECATED OPTIONS #####
 class DeprecateAction(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
@@ -437,7 +626,7 @@ class DeprecateAction(argparse.Action):
         )
 
 
-parser.add_argument(
+deprecated_group.add_argument(
     "-u",
     "--frame-struct-type",
     nargs=0,
@@ -445,15 +634,15 @@ parser.add_argument(
     help="DEPRECATED. No longer required; \
           the frame channel type is determined automatically",
 )
-parser.add_argument(
+deprecated_group.add_argument(
     "-H",
-    "--use-hot",
+    "--use-hoft",
     nargs=0,
     action=DeprecateAction,
     help="DEPRECATED. No longer required; \
           the frame channel type is determined automatically",
 )
-parser.add_argument(
+deprecated_group.add_argument(
     "-i",
     "--ifo",
     nargs=0,
@@ -461,158 +650,160 @@ parser.add_argument(
     help="DEPRECATED. No longer required; \
           the detector prefix is deduced from the channel name",
 )
-parser.add_argument(
+deprecated_group.add_argument(
     "-D",
     "--make-gps-dirs",
     nargs=0,
     action=DeprecateAction,
     help="DEPRECATED. No longer supported",
 )
-parser.add_argument(
+deprecated_group.add_argument(
     "-Z",
     "--make-tmp-file",
     nargs=0,
     action=DeprecateAction,
     help="DEPRECATED. Default behaviour",
 )
-parser.add_argument(
+deprecated_group.add_argument(
     "-v",
     "--sft-version",
     nargs=0,
     action=DeprecateAction,
     help="DEPRECATED. No longer supported",
 )
-parser.add_argument(
+deprecated_group.add_argument(
     "-S",
     "--use-single",
     nargs=0,
     action=DeprecateAction,
     help="DEPRECATED. No longer supported",
 )
+deprecated_group.add_argument(
+    "-q",
+    "--list-of-nodes",
+    type=str,
+    action=DeprecateAction,
+    help="DEPCRECATED. No longer supported",
+)
+deprecated_group.add_argument(
+    "-Q",
+    "--node-path",
+    type=Path,
+    action=DeprecateAction,
+    help="DEPCRECATED. No longer supported",
+)
+deprecated_group.add_argument(
+    "-r",
+    "--output-jobs-per-node",
+    type=int,
+    default=0,
+    action=DeprecateAction,
+    help="DEPRECATED. No longer supported",
+)
 
 args = parser.parse_args()
 
 # Some basic argument value checking
 if args.observing_run < 0:
-    raise argparse.error("--observing-run must be >= 0")
+    raise parser.error("--observing-run must be >= 0")
 
 if args.observing_run > 0 and not args.observing_kind:
-    raise argparse.error("--observing-run requires --observing-kind")
+    raise parser.error("--observing-run requires --observing-kind")
 
 if args.observing_run > 0 and not args.observing_revision:
-    raise argparse.error("--observing-run requires --observing-revision")
+    raise parser.error("--observing-run requires --observing-revision")
 
 if args.observing_revision and args.observing_revision <= 0:
-    raise argparse.error("--observing-revision must be > 0")
+    raise parser.error("--observing-revision must be > 0")
 
 if args.observing_run > 0 and args.misc_desc:
-    raise argparse.error(
+    raise parser.error(
         f"--observing-run={args.observing_run} incompatible with --misc-desc"
     )
 
 if args.misc_desc and not re.compile(r"^[A-Za-z0-9]+$").match(args.misc_desc):
-    raise argparse.error("--misc-desc may only contain A-Z, a-z, 0-9 characters")
+    raise parser.error("--misc-desc may only contain A-Z, a-z, 0-9 characters")
 
 if args.extra_datafind_time < 0:
-    raise argparse.error("--extra-datafind-time must be >= 0")
+    raise parser.error("--extra-datafind-time must be >= 0")
 
 if args.filter_knee_freq < 0:
-    raise argparse.error("--filter-knee-freq must be >= 0")
+    raise parser.error("--filter-knee-freq must be >= 0")
 
 if args.time_baseline <= 0:
-    raise argparse.error("--time-baseline must be > 0")
+    raise parser.error("--time-baseline must be > 0")
 
 if args.overlap_fraction < 0.0 or args.overlap_fraction >= 1.0:
-    raise argparse.error("--overlap-fraction must be in the range [0,1)")
+    raise parser.error("--overlap-fraction must be in the range [0,1)")
 
 if args.start_freq < 0.0 or args.start_freq >= 7192.0:
-    raise argparse.error("--start-freq must be in the range [0,7192)")
+    raise parser.error("--start-freq must be in the range [0,7192)")
 
 if args.band <= 0 or args.band >= 8192.0:
-    raise argparse.error("--band must be in the range (0,8192)")
+    raise parser.error("--band must be in the range (0,8192)")
 
 if args.start_freq + args.band >= 8192.0:
-    raise argparse.error("--start-freq + --band must be < 8192")
+    raise parser.error("--start-freq + --band must be < 8192")
 
 if args.max_num_per_node <= 0:
-    raise argparse.error("--max-num-per-node must be > 0")
+    raise parser.error("--max-num-per-node must be > 0")
 
 if (
     len(args.channel_name) != len(args.output_sft_path)
     and len(args.output_sft_path) != 1
 ):
-    raise argparse.error(
+    raise parser.error(
         "--channel-name and --output-sft-path must be the "
         "same length or --output-sft-path must be length of 1"
     )
 
-# Set the data find executable and lalpulsar_MakeSFTs executable
-dataFindExe = "gw_data_find"
-if args.datafind_path:
-    if os.path.isfile(args.datafind_path):
-        dataFindExe = args.datafind_path
-    else:
-        dataFindExe = os.path.join(args.datafind_path, dataFindExe)
-elif "LSC_DATAFIND_PATH" in os.environ:
-    dataFindExe = os.path.join("$ENV(LSC_DATAFIND_PATH)", dataFindExe)
-else:
-    dataFindExe = os.path.join("/usr/bin", dataFindExe)
+if len(args.channel_name) > 1 and args.observing_run == 0:
+    raise parser.error(
+        "When creating SFTs from multiple channels, public SFT naming "
+        "convention must be used: --observing-run > 0 and set "
+        "--observing-kind and --observing-revision"
+    )
+
+if args.datafind_urltype == "osdf" and not args.transfer_frame_files:
+    raise parser.error(
+        "--transfer-frame-files must be specified when --datafind-urltype=osdf"
+    )
 
+# Set executables for lalpulsar_MakeSFTs, and lalpulsar_MoveSFTs
 makeSFTsExe = "lalpulsar_MakeSFTs"
 if args.makesfts_path:
-    if os.path.isfile(args.makesfts_path):
+    if args.makesfts_path.is_file():
         makeSFTsExe = args.makesfts_path
     else:
-        makeSFTsExe = os.path.join(args.makesfts_path, makeSFTsExe)
+        makeSFTsExe = args.makesfts_path / makeSFTsExe
 elif "MAKESFTS_PATH" in os.environ:
-    makeSFTsExe = os.path.join("$ENV(MAKESFTS_PATH)", makeSFTsExe)
+    makeSFTsExe = Path("$ENV(MAKESFTS_PATH)") / makeSFTsExe
 else:
-    makeSFTsExe = os.path.join("/builds/lscsoft/lalsuite/wheel/build/inst/bin", makeSFTsExe)
-
-# try and make a directory to store the cache files and job logs
-try:
-    os.mkdir(args.log_path)
-except:
-    pass
-if not args.cache_file:
-    try:
-        os.mkdir(args.cache_path)
-    except:
-        pass
-
-# Check if list of nodes is given, on which to output SFTs.
-nodeList = []
-useNodeList = False
-savedOutputSFTPath = None
-if args.list_of_nodes is not None:
-    if args.node_path is None:
-        raise argparse.error("Node file list given, but no node path specified")
-
-    if args.output_jobs_per_node < 1:
-        raise argparse.error(
-            "Node file list given, but invalid output jobs per node specified"
-        )
+    makeSFTsExe = Path("/builds/lscsoft/lalsuite/wheel/build/inst/bin") / makeSFTsExe
 
-    with open(args.list_of_nodes) as fp_nodelist:
-        for idx, line in enumerate(fp_nodelist):
-            splitLine = line.split()
-            nodeList.append(splitLine[0])
-        if len(nodeList) < 1:
-            raise ValueError(
-                "No nodes found in node list file: {}".format(args.list_of_nodes)
-            )
+moveSFTsExe = "lalpulsar_MoveSFTs"
+if args.movesfts_path:
+    if args.movesfts_path.is_file():
+        moveSFTsExe = args.movesfts_path
+    else:
+        moveSFTsExe = args.movesfts_path / moveSFTsExe
+elif "MOVESFTS_PATH" in os.environ:
+    moveSFTsExe = Path("$ENV(MOVESFTS_PATH)") / moveSFTsExe
+else:
+    moveSFTsExe = Path("/builds/lscsoft/lalsuite/wheel/build/inst/bin") / moveSFTsExe
 
-    # Set flag to use list of nodes in constructing output files
-    useNodeList = True
-    savedOutputSFTPath = args.output_sft_path
-# END if (args.list_of_nodes != None)
+# make directories to store the cache files, job logs, and SFTs
+args.log_path.mkdir(exist_ok=True)
+args.cache_path.mkdir(exist_ok=True)
+for p in args.output_sft_path:
+    p.mkdir(exist_ok=True)
 
 # Check if segment file was given, else set up one segment from the command line
-segList = []
+segList = segmentlist()
 adjustSegExtraTime = False
 if args.segment_file is not None:
     if args.min_seg_length < 0:
-        raise argparse.error("--min-seg-length must be >= 0")
+        raise parser.error("--min-seg-length must be >= 0")
 
     # the next flag causes extra time that cannot be processes to be trimmed
     # from the start and end of a segment
@@ -621,108 +812,125 @@ if args.segment_file is not None:
     with open(args.segment_file) as fp_segfile:
         for idx, line in enumerate(fp_segfile):
             splitLine = line.split()
-            oneSeg = []
-            oneSeg.append(int(splitLine[0]))
-            oneSeg.append(int(splitLine[1]))
-            if (oneSeg[1] - oneSeg[0]) >= args.min_seg_length:
+            oneSeg = segment(int(splitLine[0]), int(splitLine[1]))
+            if abs(oneSeg) >= args.min_seg_length:
                 segList.append(oneSeg)
 
     if len(segList) < 1:
-        raise ValueError(
-            "No segments found in segment file: {}".format(args.segment_file)
-        )
+        raise ValueError(f"No segments found in segment file: {args.segment_file}")
 else:
     if args.analysis_start_time is None:
-        raise argparse.error(
-            "--analysis-start-time must be specified if no segment file is \
-            given"
+        raise parser.error(
+            "--analysis-start-time must be specified if no segment file is " "given"
         )
 
     if args.analysis_end_time is None:
-        raise argparse.error(
-            "--analysis-start-time must be specified if no segment file is \
-            given"
+        raise parser.error(
+            "--analysis-start-time must be specified if no segment file is " "given"
         )
 
     if args.max_length_all_jobs is None:
-        raise argparse.error(
-            "--max-length-all-jobs must be specified if no segment file is \
-            given"
+        raise parser.error(
+            "--max-length-all-jobs must be specified if no segment file is " "given"
         )
 
     # Make sure not to exceed maximum allow analysis
     if args.analysis_end_time > (args.analysis_start_time + args.max_length_all_jobs):
         args.analysis_end_time = args.analysis_start_time + args.max_length_all_jobs
 
-    oneSeg = []
-    oneSeg.append(args.analysis_start_time)
-    oneSeg.append(args.analysis_end_time)
+    oneSeg = segment(args.analysis_start_time, args.analysis_end_time)
     segList.append(oneSeg)
 # END if (args.segment_file != None)
+segList.coalesce()
 
 # Get the IFO site, which is the first letter of the channel name.
 site = args.channel_name[0][0]
 
+# Get the frame file URL list
+urls = get_urls(args)
+
+# Basic check that the frame file url list are traditionally visible on EPs
+if not args.transfer_frame_files:
+    for f in urls:
+        if "/home" in f:
+            raise parser.error(
+                "--transfer-frame-files must be specified when frame files are in /home"
+            )
+
+# data segments created from the list of frame URLs
+dataSegs = segmentlist()
+for url in urls:
+    dataSegs.append(file_segment(url))
+dataSegs.coalesce()
+
+# intersection of segList with dataSegs
+segList &= dataSegs
+segList.coalesce()  # just in case
+
 # initialize count of nodes
 nodeCount = 0
 
 # Create .sub files
-path_to_dag_file = os.path.dirname(args.dag_file)
-dag_filename = os.path.basename(args.dag_file)
-datafind_sub = os.path.join(path_to_dag_file, "datafind.sub")
-makesfts_sub = os.path.join(path_to_dag_file, "MakeSFTs.sub")
-
-# create datafind.sub
-if not args.cache_file:
-    with open(datafind_sub, "w") as datafindFID:
-        datafindLogFile = f"{args.log_path}/datafind_{dag_filename}.log"
-        datafindFID.write("universe = vanilla\n")
-        datafindFID.write(f"executable = {dataFindExe}\n")
-        datafindFID.write("arguments = ")
-        datafindFID.write("--observatory $(observatory) --url-type file ")
-        datafindFID.write("--gps-start-time $(gpsstarttime) ")
-        datafindFID.write("--gps-end-time $(gpsendtime) --lal-cache --gaps ")
-        datafindFID.write(f"--type $(inputdatatype)")
-        if args.datafind_match:
-            datafindFID.write(f" --match {args.datafind_match}\n")
-        else:
-            datafindFID.write("\n")
-        datafindFID.write(
-            "getenv = *DATAFIND*, KRB5*, X509*, BEARER_TOKEN*, SCITOKEN*\n"
-        )
-        datafindFID.write("request_disk = 5MB\n")
-        datafindFID.write("request_memory = 2000MB\n")
-        datafindFID.write(f"accounting_group = {args.accounting_group}\n")
-        datafindFID.write(f"accounting_group_user = {args.accounting_group_user}\n")
-        datafindFID.write(f"log = {datafindLogFile}\n")
-        datafindFID.write(f"error = {args.log_path}/datafind_$(tagstring).err\n")
-        datafindFID.write(f"output = {args.cache_path}/")
-        datafindFID.write("$(observatory)-$(gpsstarttime)-$(gpsendtime).cache\n")
-        datafindFID.write("notification = never\n")
-        datafindFID.write("queue 1\n")
+path_to_dag_file = args.dag_file.parent
+dag_filename = args.dag_file.name
+makesfts_sub = path_to_dag_file / "MakeSFTs.sub"
+movesfts_sub = path_to_dag_file / "MoveSFTs.sub"
 
 # create MakeSFTs.sub
 with open(makesfts_sub, "w") as MakeSFTsFID:
-    MakeSFTsLogFile = "{}/MakeSFTs_{}.log".format(args.log_path, dag_filename)
+    MakeSFTsLogFile = f"{args.log_path}/MakeSFTs_{dag_filename}.log"
     MakeSFTsFID.write("universe = vanilla\n")
-    MakeSFTsFID.write("executable = {}\n".format(makeSFTsExe))
+    MakeSFTsFID.write(f"executable = {makeSFTsExe}\n")
     MakeSFTsFID.write("arguments = $(argList)\n")
-    MakeSFTsFID.write("accounting_group = {}\n".format(args.accounting_group))
-    MakeSFTsFID.write("accounting_group_user = {}\n".format(args.accounting_group_user))
-    MakeSFTsFID.write("log = {}\n".format(MakeSFTsLogFile))
-    MakeSFTsFID.write("error = {}/MakeSFTs_$(tagstring).err\n".format(args.log_path))
-    MakeSFTsFID.write("output = {}/MakeSFTs_$(tagstring).out\n".format(args.log_path))
+    MakeSFTsFID.write(f"accounting_group = {args.accounting_group}\n")
+    MakeSFTsFID.write(f"accounting_group_user = {args.accounting_group_user}\n")
+    MakeSFTsFID.write(f"log = {MakeSFTsLogFile}\n")
+    MakeSFTsFID.write(f"error = {args.log_path}/MakeSFTs_$(tagstring).err\n")
+    MakeSFTsFID.write(f"output = {args.log_path}/MakeSFTs_$(tagstring).out\n")
     MakeSFTsFID.write("notification = never\n")
     MakeSFTsFID.write(f"request_memory = {args.request_memory}MB\n")
     MakeSFTsFID.write(f"request_disk = {args.request_disk}MB\n")
     MakeSFTsFID.write("RequestCpus = 1\n")
+    MakeSFTsFID.write("should_transfer_files = yes\n")
+    if args.transfer_frame_files:
+        MakeSFTsFID.write("transfer_input_files = $(cachefile),$(framefiles)\n")
+    else:
+        MakeSFTsFID.write("transfer_input_files = $(cachefile)\n")
+    if "MAKESFTS_PATH" in os.environ and not args.makesfts_path:
+        MakeSFTsFID.write("getenv = MAKESFTS_PATH\n")
+    if args.datafind_urltype == "osdf":
+        MakeSFTsFID.write("use_oauth_services = scitokens\n")
+        MakeSFTsFID.write(
+            "environment = BEARER_TOKEN_FILE=$$(CondorScratchDir)/.condor_creds/scitokens.use\n"
+        )
     MakeSFTsFID.write("queue 1\n")
 
+# create MoveSFTs.sub
+with open(movesfts_sub, "w") as MoveSFTsFID:
+    MoveSFTsLogFile = f"{args.log_path}/MoveSFTs_{dag_filename}.log"
+    MoveSFTsFID.write("universe = local\n")
+    MoveSFTsFID.write(f"executable = {moveSFTsExe}\n")
+    MoveSFTsFID.write("arguments = ")
+    if not args.validate:
+        MoveSFTsFID.write("$(opts) ")
+    MoveSFTsFID.write("-s $(sourcedirectory) -c $(channels) -d $(destdirectory)\n")
+    MoveSFTsFID.write(f"accounting_group = {args.accounting_group}\n")
+    MoveSFTsFID.write(f"accounting_group_user = {args.accounting_group_user}\n")
+    MoveSFTsFID.write(f"log = {MoveSFTsLogFile}\n")
+    MoveSFTsFID.write(f"error = {args.log_path}/MoveSFTs.err\n")
+    MoveSFTsFID.write(f"output = {args.log_path}/MoveSFTs.out\n")
+    MoveSFTsFID.write("notification = never\n")
+    MoveSFTsFID.write(f"request_memory = 1GB\n")
+    MoveSFTsFID.write(f"request_disk = 10MB\n")
+    MoveSFTsFID.write("RequestCpus = 1\n")
+    if "MOVESFTS_PATH" in os.environ and not args.movesfts_path:
+        MoveSFTsFID.write("getenv = MOVESFTS_PATH\n")
+    MoveSFTsFID.write("queue 1\n")
+
 # create the DAG file with the jobs to run
 with open(args.dag_file, "w") as dagFID:
     startTimeAllNodes = None
     firstSFTstartTime = 0  # need this for the synchronized start option
-    nodeListIndex = 0
 
     # Loop over the segment list to generate the SFTs for each segment
     for seg in segList:
@@ -867,17 +1075,6 @@ with open(args.dag_file, "w") as dagFID:
                     # write jobs to dag for this node
                     nodeCount = nodeCount + 1
 
-                    if useNodeList:
-                        args.output_sft_path = (
-                            args.node_path
-                            + nodeList[nodeListIndex]
-                            + savedOutputSFTPath
-                        )
-                        if (nodeCount % args.output_jobs_per_node) == 0:
-                            nodeListIndex = nodeListIndex + 1
-                        # END if ((nodeCount % args.output_jobs_per_node) == 0L)
-                    # END if (useNodeList)
-
                     if nodeCount == 1:
                         startTimeAllNodes = startTimeThisNode
                     writeToDag(
@@ -885,7 +1082,7 @@ with open(args.dag_file, "w") as dagFID:
                         nodeCount,
                         startTimeThisNode,
                         endTimeThisNode,
-                        site,
+                        urls,
                         args,
                     )
                     # Update for next node
@@ -905,22 +1102,30 @@ with open(args.dag_file, "w") as dagFID:
                 # write jobs to dag for this node
                 nodeCount = nodeCount + 1
 
-                if useNodeList:
-                    args.output_sft_path = (
-                        args.node_path + nodeList[nodeListIndex] + savedOutputSFTPath
-                    )
-                    if (nodeCount % args.output_jobs_per_node) == 0:
-                        nodeListIndex = nodeListIndex + 1
-                    # END if ((nodeCount % args.output_jobs_per_node) == 0L)
-                # END if (useNodeList)
-
                 if nodeCount == 1:
                     startTimeAllNodes = startTimeThisNode
                 writeToDag(
-                    dagFID, nodeCount, startTimeThisNode, endTimeThisNode, site, args
+                    dagFID, nodeCount, startTimeThisNode, endTimeThisNode, urls, args
                 )
         # END while (endTimeAllNodes < args.analysis_end_time)
     # END for seg in segList
+
+    # Write the move SFTs job to the DAG
+    # Move SFTs
+    dagFID.write(f"JOB MoveSFTs {Path(dagFID.name).parent / 'MoveSFTs.sub'}\n")
+    dagFID.write(f"RETRY MoveSFTs 1\n")
+    dagFID.write(f"VARS MoveSFTs ")
+    if not args.validate:
+        dagFID.write('opts="--no-validate" ')
+    dagFID.write(
+        f'sourcedirectory="." '
+        f"channels=\"{' '.join(args.channel_name)}\" "
+        f"destdirectory=\"{' '.join([str(p) for p in args.output_sft_path])}\"\n"
+    )
+    dagFID.write(
+        f"PARENT {' '.join([f'MakeSFTs_{n}' for n in range(1, nodeCount+1)])} CHILD MoveSFTs\n"
+    )
+
 # Close the DAG file
 
 # Update actual end time of the last job and print out the times all jobs will run on: