`cape.cntl`: Base module for CFD operations and processing¶

This module provides tools and templates for tools to interact with various CFD codes and their input files. The base class is cape.cfdx.cntl.Cntl, and the derivative classes include cape.pycart.cntl.Cntl. This module creates folders for cases, copies files, and can be used as an interface to perform most of the tasks that Cape can accomplish except for running individual cases.

The control module is set up as a Python interface for thec master JSON file, which contains the settings to be used for a given CFD project.

The derivative classes are used to read input files, set up cases, submit and/or run cases, and be an interface for the various Cape options as they are customized for the various CFD solvers. The individualized modules are below.

cape.pycart.cntl

cape.pyfun.cntl

cape.pyover.cntl

See also:

class cape.cfdx.cntl.Cntl(fname=None)¶

Class to handle options, setup, and execution of CFD codes

Call:

>>> cntl = cape.Cntl(fname="cape.json")

Inputs:

fname: str: Name of JSON settings file from which to read options

Outputs:

cntl: cape.cfdx.cntl.Cntl: Instance of Cape control interface
cntl.opts: cape.cfdx.options.Options: Options interface
cntl.x: cape.runmatrix.RunMatrix: Run matrix interface
cntl.RootDir: str: Working directory from which the class was generated

Versions:

2015-09-20 @ddalle: Started
2016-04-01 @ddalle: v1.0

ApplyCases(**kw)¶

Reapply settings to one or more cases

Call:

>>> cntl.ApplyCases(cons=[], j=None, extend=1, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of overall control interface
extend: {True} | positive int: Extend phase j by extend nominal runs
j: {None} | nonnegative int: Phase number
cons: list[str]: List of constraints
I: list[int]: List of indices

Versions:

2016-12-12 @ddalle: v1.0

ArchiveCase(i: int, test: bool = False)¶

Perform --archive archiving on one case

There are no restrictions on the status of the case for this action.

Call:

>>> cntl.CleanCase(i, test=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of control interface
i: int: Case index
test: True | {False}: Log file/folder actions but don’t actually delete/copy

Versions:

2024-09-18 @ddalle: v1.0

ArchiveCases(**kw)¶

Archive completed cases and clean them up if specified

Call:

>>> cntl.ArchiveCases()
>>> cntl.ArchiveCases(cons=[], **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of overall control interface
cons: list[str]: List of constraints
I: list[int]: List of indices

Versions:

2016-12-09 @ddalle: v1.0
2024-09-19 @ddalle: v2.0

CaseFunction(i: int)¶

Run one or more functions at “prepare-case” hook

This function is executed at the beginning of PrepareCase(i)().

This is meant to serve as a filter if a user wants to change the settings for some subset of the cases. Using this function can change any setting, which can be dependent on the case i.

This calls the function(s) in the global "CaseFunction" option from the JSON file. These functions must take cntl as an input and the case number i. The function(s) are usually from a module imported via the "Modules" option. See the following example:

"Modules": ["testmod"],
"CaseFunction": ["testmod.testfunc"]

This leads CAPE to call testmod.testfunc(cntl, i) at the beginning of PrepareCase() for each case i in the run matrix. The function is also called at the beginning of ApplyCase() if pyfun --apply or similar is issued.

Call:

>>> cntl.CaseFunction(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall control interface
i: int: Case number

Versions:

2017-04-05 @ddalle: v1.0

See also:

CaseGetCurrentPhase()¶

Get the current phase number from the appropriate module

This function utilizes the cape.cfdx.case module, and so it must be copied to the definition for each solver’s control class.

Call:

>>> j = cntl.CaseGetCurrentPhase()

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance

Outputs:

j: int | None: Phase number

Versions:

2017-06-29 @ddalle: v1.0
2023-07-06 @ddalle: v1.1; use CaseRunner

CheckBatch()¶

Check to see if we are running inside a batch job

This looks for environment variables to see if this is running inside a batch job. Currently supports slurm and PBS.

Call:

>>> q = cntl.CheckBatch()

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance

Outputs:

jobid: int: 0 if no batch environment was detected

Versions:

2023-12-13 @dvicker: v1.0
2023-12-18 @ddalle: v1.1; debug

CheckCase(i: int, v=False)¶

Check current status of case i

Because the file structure is different for each solver, some of this method may need customization. This customization, however, can be kept to the functions cape.cfdx.casecntl.GetCurrentIter() and cape.cfdx.cntl.Cntl.CheckNone().

Call:

>>> n = cntl.CheckCase(i, v=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)
v: True | {False}: Verbose flag; prints messages if n is None

Outputs:

n: int | None: Number of completed iterations or None if not set up

Versions:

2014-09-27 @ddalle: v1.0
2015-09-27 @ddalle: v2.0; generic
2015-10-14 @ddalle: v2.1; no case req
2017-02-22 @ddalle: v2.2; add verbose flag
2023-11-06 @ddalle: v2.3; call setx_i(i)

CheckCaseStatus(i: int, jobs: dict | None = None, auto: bool = False, u: str | None = None, qstat: bool = True)¶

Determine the current status of a case

Call:

>>> sts = cntl.CheckCaseStatus(i, jobs=None, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)
jobs: dict: Information on each job by ID number
u: str: User name (defaults to process username)
qstat: {True} | False: Option to call qstat/squeue to get job status

Versions:

2014-10-04 @ddalle: v1.0
2014-10-06 @ddalle: v1.1; check queue status
2023-12-13 @dvicker: v1.2; check for THIS_JOB
2024-08-22 @ddalle: v1.3; add qstat

CheckError(i)¶

Check if a case has a failure

Call:

>>> q = cntl.CheckError(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Run index

Outputs:

q: bool: If True, case has FAIL file in it

Versions:

2015-01-02 @ddalle: v1.0

CheckFM(**kw)¶

Display missing force & moment components

Call:

>>> cntl.CheckFM(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
fm, aero: {None} | str: Wildcard to subset list of FM components
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2018-10-19 @ddalle: v1.0

CheckLL(**kw)¶

Display missing line load components

Call:

>>> cntl.CheckLL(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
fm, aero: {None} | str: Wildcard to subset list of FM components
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2018-10-19 @ddalle: v1.0

CheckNone(v=False)¶

Check if the current directory has the needed files to run

This function needs to be customized for each CFD solver so that it checks for the appropriate files.

Call:

>>> q = cntl.CheckNone(v=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Cape control interface
v: True | {False}: Verbose flag; prints message if q is True

Outputs:

q: `True | False`: Whether or not case is missing files

Versions:

2015-09-27 @ddalle: v1.0
2017-02-22 @ddalle: v1.1, verbosity option

CheckPhase(i, v=False)¶

Check current phase number of run i

Call:

>>> n = cntl.CheckPhase(i, v=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)
v: True | {False}: Verbose flag; prints messages if n is None

Outputs:

j: int | None: Phase number

Versions:

2017-06-29 @ddalle: v1.0

CheckRunning(i)¶

Check if a case is currently running

Call:

>>> q = cntl.CheckRunning(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Run index

Outputs:

q: bool: If True, case has RUNNING file in it

Versions:

2014-10-03 @ddalle: v1.0

CheckTriqFM(**kw)¶

Display missing TriqFM components

Call:

>>> cntl.CheckTriqFM(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
fm, aero: {None} | str: Wildcard to subset list of FM components
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2018-10-19 @ddalle: v1.0

CheckTriqPoint(**kw)¶

Display missing TriqPoint components

Call:

>>> cntl.CheckTriqPoint(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
fm, aero: {None} | str: Wildcard to subset list of FM components
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2018-10-19 @ddalle: v1.0

CheckUsedPhase(i, v=False)¶

Check maximum phase number run at least once

Call:

>>> j, n = cntl.CheckUsedPhase(i, v=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)
v: True | {False}: Verbose flag; prints messages if n is None

Outputs:

j: int | None: Phase number
n: int | None: Maximum phase number

Versions:

2017-06-29 @ddalle: v1.0
2017-07-11 @ddalle: v1.1, verbosity option

CheckZombie(i)¶

Check a case for ZOMBIE status

A running case is declared a zombie if none of the listed files (by default *.out) have been modified in the last 30 minutes. However, a case cannot be a zombie unless it contains a RUNNING file and returns True from CheckRunning().

Call:

>>> q = cntl.CheckZombie(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Run index

Outputs:

q: bool: True if no listed files have been modified recently

Versions:

2017-04-04 @ddalle: v1.0
2021-01-25 @ddalle: v1.1; use cls._zombie_files

CleanCase(i: int, test: bool = False)¶

Perform --clean archiving on one case

There are no restrictions on the status of the case for this action.

Call:

>>> cntl.CleanCase(i, test=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of control interface
i: int: Case index
test: True | {False}: Log file/folder actions but don’t actually delete/copy

Versions:

2024-09-18 @ddalle: v1.0

CleanCases(**kw)¶

Clean a list of cases using Progress archive options only

Call:

>>> cntl.CleanCases(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of control interface

Versions:

2017-03-13 @ddalle: v1.0
2024-09-18 @ddalle: v2.0

CountQueuedCases(I=None, jobs=None, u=None, **kw) → int¶

Count cases that have currently active PBS/Slurm jobs

Call:

>>> n = cntl.CountQueuedCases(I=None, jobs=None, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
I: list[int]: List of indices
jobs: dict: Information on each job by ID number
u: str: User name (defaults to process username)
kw: dict: Other kwargs used to subset the run matrix

Outputs:

n: int: Number of running or queued jobs (not counting the job from which function is called, if applicable)

Versions:

2024-01-12 @ddalle: v1.0
2024-01-17 @ddalle: v1.1; check for this_job

CountRunningCases(I, jobs=None, u=None)¶

Count number of running cases via the batch system

Also print a status of the running jobs.

Call:

>>> n = cntl.CountRunningCases(I, jobs=None, u=None)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
I: list[int]: List of indices
jobs: dict: Information on each job by ID number
u: str: User name (defaults to process username)

Outputs:

n: int: Number of running or queued jobs

Versions:

2023-12-08 @dvicker: v1.0

DeleteCase(i, **kw)¶

Delete a case

This function deletes a case’s PBS job and removes the entire directory. By default, the method prompts for user’s confirmation before deleting; set prompt to False to delete without prompt.

Call:

>>> n = cntl.DeleteCase(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Cape control interface
i: int: Index of the case to check (0-based)
prompt: {True} | False: Whether or not to prompt user before deleting case

Outputs:

n: 0 | 1: Number of folders deleted

Versions:

2018-11-20 @ddalle: v1.0

Dezombie(**kw)¶

Clean up any ZOMBIE cases

Call:

>>> cntl.Dezombie(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of overall control interface
extend: {True} | positive int: Extend phase j by extend nominal runs
j: {None} | int >= 0: Phase number
imax: {None} | int: Do not increase iteration number beyond imax
cons: list[str]: List of constraints
I: list[int]: List of indices

Versions:

2021-10-14 @ddalle: v1.0

DisplayStatus(**kw)¶

Display current status for all cases

This prints case names, current iteration numbers, and so on. This is the function that is called when the user issues a system command like cape -c.

Call:

>>> cntl.DisplayStatus(j=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
j: bool: Whether or not to display job ID numbers
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2014-10-04 @ddalle: v1.0
2014-12-09 @ddalle: v2.0, --cons

ExecScript(**kw)¶

Execute a script in a given case folder

This function is the interface to command-line calls using the -e flag, such as pycart -e 'ls -lh'.

Call:

>>> ierr = cntl.ExecScript(i, cmd)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Case index (0-based)

Outputs:

ierr: None | int: Exit status from the command

Versions:

2016-08-26 @ddalle: v1.0
2024-12-09 @jfdiaz3:v1.1

ExtendCase(i: int, n: int = 1, j: int | None = None, imax: int | None = None)¶

Add iterations to case i by repeating the last phase

Call:

>>> cntl.ExtendCase(i, n=1, j=None, imax=None)

Inputs:

cntl: cape.pyfun.cntl.Cntl: CAPE main control instance
i: int: Run index
n: {1} | positive int: Add n times steps to the total iteration count
j: {None} | int: Optional phase to extend
imax: {None} | nonnegative int: Use imax as the maximum iteration count

Versions:

2016-12-12 @ddalle: v1.0
2024-08-27 @ddalle: v2.0; move code to CaseRunner
2024-09-28 @ddalle: v2.1; add j

ExtendCases(**kw)¶

Extend one or more case by a number of iterations

By default, this applies to the final phase, but the phase number j can also be specified as input. The number of additional iterations is generally the nominal number of iterations that phase j would normally run.

Call:

>>> cntl.ExtendCases(cons=[], extend=1, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of overall control interface
extend: {True} | positive int: Extend phase j by extend nominal runs
imax: {None} | int: Do not increase iteration number beyond imax
j, phase: {None} | int: Optional index of phase to extend
cons: list[str]: List of constraints
I: list[int]: List of indices

Versions:

2016-12-12 @ddalle: v1.0

FilterUser(i, **kw)¶

Determine if case i is assigned to current user

Call:

>>> q = cntl.FilterUser(i, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)
u, user: str: User name (default: executing process’s username) for comparing to run matrix

Versions:

2017-07-10 @ddalle: v1.0

GetCPUTime(i: int)¶

Read a CAPE-style core-hour file from a case

This function needs to be customized for each solver because it needs to know the name of the file in which timing data is saved. It defaults to cape_time.dat. Modifying this command is a one-line fix with a call to cape.cfdx.cntl.Cntl.GetCPUTimeFromFile() with the correct file name.

Call:

>>> CPUt = cntl.GetCPUTime(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: CAPE control interface
i: int: Case index

Outputs:

CPUt: float | None: Total core hours used in this job

Versions:

2015-12-22 @ddalle: v1.0
2016-08-30 @ddalle: v1.1; check for RUNNING
2016-08-31 @ddalle: v1.2; use GetCPUTimeBoth
2023-07-09 @ddalle: v2.0; use CaseRunner

GetCaseIndex(frun: str) → int | None¶

Get index of a case in the current run matrix

Call:

>>> i = cntl.GetCaseIndex(frun)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Cape control interface
frun: str: Name of case, must match exactly

Outputs:

i: int | None: Index of case with name frun in run matrix, if present

Versions:

2024-08-15 @ddalle: v1.0
2024-10-16 @ddalle: v1.1; move to RunMatrix

GetCurrentIter(i: int) → int¶

Get the current iteration number (using case)

This function utilizes the cape.cfdx.case module, and so it must be copied to the definition for each solver’s control class.

Call:

>>> n = cntl.GetCurrentIter(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)

Outputs:

n: int | None: Number of completed iterations or None if not set up

Versions:

2015-10-14 @ddalle: v1.0
2023-07-07 @ddalle: v2.0; use CaseRunner

GetLastIter(i)¶

Get minimum required iteration for a given case

Call:

>>> nIter = cntl.GetLastIter(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Cape control interface
i: int: Run index

Outputs:

nIter: int: Number of iterations required for case i

Versions:

2014-10-03 @ddalle: v1.0

GetPBSJobID(i: int) → str | None¶

Get PBS job number if one exists

Call:

>>> jobID = cntl.GetPBSJobID(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Run index

Outputs:

jobID: None | str: Most recent PBS/Slurm job name, if able

Versions:

2014-10-06 @ddalle: v1.0
2024-01-12 @ddalle: v1.1; remove CheckCase() for speed

GetPBSName(i: int) → str¶

Get PBS name for a given case

Call:

>>> lbl = cntl.GetPBSName(i, pre=None)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Run index
pre: {None} | str: Prefix for PBS job name

Outputs:

lbl: str: Short name for the PBS job, visile via qstat

Versions:

2014-09-30 @ddalle: v1.0
2016-12-20 @ddalle: v1.1, moved to x

GetPhaseBreaks()¶

Get expected iteration numbers at phase breaks

This fills in 0 entries in RunControl ‣ PhaseIters and returns the filled-out list.

Call:

>>> PI = cntl.GetPhaseBreaks()

Inputs:

cntl: cape.cfdx.cntl.Cntl: Cape control interface

Outputs:

PI: list[int]: Min iteration counts for each phase

Versions:

2017-04-12 @ddalle: v1.0

GetSurfCT_ExitArea(key, i, comp=None)¶

Get exit area for a CT trajectory key

This can use either the area ratio (if available) or calculate from the exit Mach number. The input area is determined from the component ID. If using the exit Mach number M2, the input Mach number M1 is also needed. The relationship between area ratio and exit Mach is given below.

$\begin{array}{r} f r a c A_{2} A_{1} = \\ f r a c M_{1} M_{2} \\ l e f t ( \\ f r a c 1 + f r a c g a m m a - 1 2 M_{2}^{2} 1 + f r a c g a m m a - 1 2 M_{1}^{2} \\ r i g h t)^{f r a c 12 f r a c g a m m a + 1 g a m m a - 1} \end{array}$

Call:

>>> A2 = cntl.GetSurfCT_ExitArea(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of trajectory key to check
i: int: Case number
comp: {None} | str: Name of component for which to get BCs

Outputs:

A2: list (float): Exit area for each component referenced by this key

Versions:

2016-04-13 @ddalle: v1.0

GetSurfCT_ExitMach(key, i, comp=None)¶

Get exit Mach number for a CT trajectory key

This can use either the "ExitMach" parameter (if available) or calculate from the area ratio. If using the area ratio, the input Mach number is also needed. The relationship between area ratio and exit Mach is given below.

$\frac{A_{2}}{A_{1}} = \frac{M_{1}}{M_{2}} {(\frac{1 + \frac{γ - 1}{2} M_{2}^{2}}{1 + \frac{γ - 1}{2} M_{1}^{2}})}^{\frac{1}{2} \frac{γ + 1}{γ - 1}}$

Call:

>>> M2 = cntl.GetSurfCT_ExitMach(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of trajectory key to check
i: int: Case number
comp: {None} | str: Name of component for which to get BCs

Outputs:

M2: float: Exit Mach number

Versions:

2016-04-13 @ddalle: v1.0

GetSurfCT_RefArea(key, i)¶

Get reference area for surface CT trajectory key

This references the "RefArea" parameter of the definition for the run matrix variable key. The user should set this parameter to 1.0 if thrust inputs are given as dimensional values.

If this is None, it returns the global reference area; if it is a string the reference area comes from the reference area for that component using cntl.opts.get_RefArea(comp).

Call:

>>> Aref = cntl.GetSurfCT_RefArea(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of trajectory key to check
i: int: Case number

Outputs:

Aref: float: Reference area for normalizing thrust coefficients

Versions:

2016-04-13 @ddalle: v1.0

ImportModules()¶

Import user-defined modules if specified in the options

All modules from the "Modules" global option of the JSON file (cntl.opts["Modules"]) will be imported and saved as attributes of cntl. For example, if the user wants to use a module called dac3, it will be imported as cntl.dac3. A noncomprehensive list of disallowed module names is below.

DataBook, RootDir, jobs, opts, tri, x

The name of any method of this class is also disallowed. However, if the user wishes to import a module whose name is disallowed, he/she can use a dictionary to specify a different name to import the module as. For example, the user may import a module called tri as mytri using the following JSON syntax.

"Modules": [{"tri": "mytri"}]

Call:

>>> cntl.ImportModules()

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of Cape control interface

Versions:

2014-10-08 @ddalle: v1.0 (pycart)
2015-09-20 @ddalle: v1.0
2022-04-12 @ddalle: v2.0; use self.modules

InitFunction()¶

Run one or more functions a “initialization” hook

This calls the function(s) in the global "InitFunction" option from the JSON file. These functions must take cntl as an input, and they are usually from a module imported via the "Modules" option. See the following example:

"Modules": ["testmod"],
"InitFunction": ["testmod.testfunc"]

This leads CAPE to call testmod.testfunc(cntl).

Call:

>>> cntl.InitFunction()

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall control interface

Versions:

2017-04-04 @ddalle: v1.0
2022-04-12 @ddalle: v2.0; use _exec_funclist()

MarkERROR(**kw)¶

Mark one or more cases as ERROR and rewrite matrix

Call:

>>> cntl.MarkERROR(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'
flag: {"E"} | "e" | "ERROR" | "$E": Marker to use to denote status

Versions:

2019-06-14 @ddalle: v1.0

MarkPASS(**kw)¶

Mark one or more cases as PASS and rewrite matrix

Call:

>>> cntl.MarkPASS(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'
flag: {"p"} | "P" | "PASS" | "$p": Marker to use to denote status

Versions:

2019-06-14 @ddalle: v1.0

PrepareCase(i: int)¶

Prepare case for running if necessary

This function creates the folder, copies mesh files, and saves settings and input files. All of these tasks are completed only if they have not already been completed, and it needs to be customized for each CFD solver.

Call:

>>> cntl.PrepareCase(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of case to analyze

Versions:

2014-09-30 @ddalle: v1.0
2015-09-27 @ddalle: v2.0, convert to template

PrepareConfig(i)¶

Apply rotations, translations, etc. to Config.xml

Call:

>>> cntl.PrepareConfig(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Case index

Versions:

2016-08-23 @ddalle: v1.0

PrepareConfigFunction(key, i)¶

Apply special configuration modification function for a case

Call:

>>> cntl.PrepareConfigFunction(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of key
i: int: Index of the case to check (0-based)

Versions:

2016-08-23 @ddalle: v1.0
2022-04-13 @ddalle: v2.0; exec_modfunction()

PrepareConfigRotation(key, i)¶

Apply a rotation to a component or components

Call:

>>> cntl.PrepareConfigRotation(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of the trajectory key
i: int: Index of the case to check (0-based)

Versions:

2016-08-23 @ddalle: v1.0

PrepareConfigTranslation(key, i)¶

Apply a translation to a component or components

Call:

>>> cntl.PrepareConfigTranslation(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of variable from which to get value
i: int: Index of the case to check (0-based)

Versions:

2016-08-23 @ddalle: v1.0

PreparePoints(i)¶

Calculate the value of each named "Point" for case i

Call:

>>> x = cntl.PreparePoints(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance Index of the case to check (0-based)

Versions:

2022-03-07 @ddalle: v1.0

PreparePointsRotation(key, i)¶

Apply a rotation to named config points for one col

Call:

>>> cntl.PreparePointsRotation(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of the trajectory key
i: int: Index of the case to check (0-based)

Versions:

2022-03-07 @ddalle: v1.0

PreparePointsTranslation(key, i)¶

Apply a translation to named config points for one col

Call:

>>> cntl.PreparePointsTranslation(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of the trajectory key
i: int: Index of the case to check (0-based)

Versions:

2022-03-07 @ddalle: v1.0

PrepareTri(i)¶

Rotate/translate/etc. triangulation for given case

Call:

>>> cntl.PrepareTri(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)

Versions:

2014-12-01 @ddalle: v1.0
2016-04-05 @ddalle: v1.1, pycart -> cape

PrepareTriFunction(key, i)¶

Apply special surf modification function for a case

Call:

>>> cntl.PrepareTriFunction(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
key: str: Name of key
i: int: Index of the case to check (0-based)

Versions:

2015-09-11 @ddalle: v1.0
2016-04-05 @ddalle: v1.1, pycart -> cape
2022-04-13 @ddalle: v2.0; exec_modfunction()

PrepareTriRotation(key, i)¶

Apply a rotation to a component or components

Call:

>>> cntl.PrepareTriRotation(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)

Versions:

2015-09-11 @ddalle: v1.0
2016-04-05 @ddalle: v1.1, pycart -> cape

PrepareTriTranslation(key, i)¶

Apply a translation to a component or components

Call:

>>> cntl.PrepareTriTranslation(key, i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)

Versions:

2015-09-11 @ddalle: v1.0
2016-04-05 @ddalle: v1.1, pycart -> cape

ReadCaseRunner(i: int) → CaseRunner¶

Read CaseRunner into slot

Call:

>>> runner = cntl.ReadCaseRunner(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)

Outputs:

runner: CaseRunner: Controller to run one case of solver

Versions:

2023-06-22 @ddalle: v1.0

ReadConfig(f=False)¶

Read Config.xml or other surf configuration format

Call:

>>> cntl.ReadConfig(f=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
f: True | {False}: Option to reread existing cntl.config

Versions:

2016-06-10 @ddalle: v1.0
2016-10-21 @ddalle: v2.0, added Config.json
2020-09-01 @ddalle: v2.1, add f kwarg

ReadDataBook(comp=None)¶

Read the current data book

Call:

>>> cntl.ReadDataBook()

Inputs:

cntl: cape.cfdx.cntl.Cntl: CAPE run matrix control instance

Versions:

2016-09-15 @ddalle: v1.0
2023-05-31 @ddalle: v2.0; universal cape.cntl

ReadDataBookPost()¶

Do py{x} specific init actions after reading DataBook

Call:

>>> cntl.ReadDataBookPost()

Inputs:

cntl: cape.cfdx.cntl.Cntl: CAPE run matrix control instance

Versions:

2023-05-31 @ddalle: v1.0

ReadFolderCaseRunner(fdir: str) → CaseRunner¶

Read a CaseRunner from a folder by name

Call:

>>> runner = cntl.ReadFolderCaseRunner(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)

Outputs:

runner: CaseRunner: Controller to run one case of solver

Versions:

2024-11-05 @ddalle: v1.0

ReadReport(rep)¶

Read a report interface

Call:

>>> R = cntl.ReadReport(rep)

Inputs:

cntl: cape.pyfun.cntl.Cntl: CAPE main control instance
rep: str: Name of report

Outputs:

R: pyFun.report.Report: Report interface

Versions:

2018-10-19 @ddalle: Version 1.0

ReadTri()¶

Read initial triangulation file(s)

Call:

>>> cntl.ReadTri()

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance

Versions:

2014-08-30 @ddalle: v1.0

RevertOptions()¶

Revert to cntl.opts0 as working options

Call:

>>> cntl.ResetOptions()

Inputs:

cntl: Cntl: CAPE solver control interface

Versions:

2021-07-31 @ddalle: v1.0

SaveOptions()¶

Copy cntl.opts and store it as cntl.opts0

Call:

>>> cntl.SaveOptions()

Inputs:

cntl: Cntl: CAPE solver control interface

Versions:

2021-07-31 @ddalle: v1.0

SkeletonCase(i: int, test: bool = False)¶

Perform --skeleton archiving on one case

There are no restrictions on the status of the case for this action.

Call:

>>> cntl.SkeletonCase(i, test=False)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of control interface
i: int: Case index
test: True | {False}: Log file/folder actions but don’t actually delete/copy

Versions:

2024-09-18 @ddalle: v1.0

SkeletonCases(**kw)¶

Archive completed cases and delete all but a few files

Call:

>>> cntl.SkeletonCases()
>>> cntl.SkeletonCases(cons=[], **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of overall control interface
cons: list[str]: List of constraints
I: list[int]: List of indices

Versions:

2016-12-14 @ddalle: v1.0
2024-09-19 @ddalle: v2.0

StartCase(i: int)¶

Start a case by either submitting it or running it

This function checks whether or not a case is submittable. If so, the case is submitted via cape.cfdx.queue.pqsub(), and otherwise the case is started using a system call.

Before starting case, this function checks the folder using cape.cfdx.cntl.CheckCase(); if this function returns None, the case is not started. Actual starting of the case is done using CaseStartCase(), which has a specific version for each CFD solver.

Call:

>>> pbs = cntl.StartCase(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of the case to check (0-based)

Outputs:

pbs: int | None: PBS job ID if submitted successfully

Versions:

2014-10-06 @ddalle: v1.0
2023-06-27 @ddalle: v2.0; use CaseRunner

StopCase(i: int)¶

Stop a case if running

This function deletes a case’s PBS job and removes the RUNNING file if it exists.

Call:

>>> cntl.StopCase(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Cape control interface
i: int: Index of the case to check (0-based)

Versions:

2014-12-27 @ddalle: v1.0
2023-06-27 @ddalle: v2.0; use CaseRunner

SubmitBatchPBS(argv)¶

Write a PBS script for a batch run

Call:

>>> cntl.SubmitBatchPBS(argv)

Inputs:

argv: list[str]: List of command-line inputs

Versions:

2016-09-25 @ddalle: v1.0

SubmitJobs(**kw)¶

Check jobs and prepare or submit jobs if necessary

Call:

>>> cntl.SubmitJobs(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
c: :True | {False}: If True, only display status; do not submit new jobs
j: bool: Whether or not to display job ID numbers
n: int: Maximum number of jobs to submit
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2014-10-05 @ddalle: v1.0
2014-12-09 @ddalle: v2.0, --cons
2021-08-01 @ddalle: v2.1, save/revert options
2023-05-17 @ddalle: v2.2, opts.setx_i()

UnarchiveCases(**kw)¶

Unarchive a list of cases

Call:

>>> cntl.UnarchiveCases(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of control interface

Versions:

2017-03-13 @ddalle: v1.0
2023-10-20 @ddalle: v1.1; arbitrary-depth frun
2024-09-20 @ddalle: v2.0; use CaseArchivist

UnmarkCase(**kw)¶

Remove PASS or ERROR marking from one or more cases

Call:

>>> cntl.UnmarkCase(**kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2019-06-14 @ddalle: v1.0

UpdateCaseProp(**kw)¶

Update generic-property databook for one or more comp

Call:

>>> cntl.UpdateCaseProp(cons=[], **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
prop: {None} | str: Wildcard to subset list of "Prop" components
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2022-04-08 @ddalle: v1.0

UpdateDBPyFunc(**kw)¶

Update Python function databook for one or more comp

Call:

>>> cntl.UpdateDBPyFunc(cons=[], **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
prop: {None} | str: Wildcard to subset list of "Prop" components
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2022-04-10 @ddalle: v1.0

UpdateFM(**kw)¶

Collect force and moment data

Call:

>>> cntl.UpdateFM(cons=[], **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
fm, aero: {None} | str: Wildcard to subset list of FM components
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2014-12-12 @ddalle: v1.0
2014-12-22 @ddalle: v2.0
- Complete rewrite of DataBook class
- Eliminate “Aero” class
2017-04-25 @ddalle: v2.1, add wildcards
2018-10-19 @ddalle: v3.0, rename from Aero()

UpdateLL(**kw)¶

Update one or more line load data books

Call:

>>> cntl.UpdateLL(ll=None, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
ll: {None} | str: Optional name of line load component to update
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'
pbs: True | {False}: Whether or not to calculate line loads with PBS scripts

Versions:

2016-06-07 @ddalle: v1.0
2016-12-21 @ddalle: v1.1, Add pbs flag
2017-04-25 @ddalle: v1.2
- Removed pbs
- Added --delete

UpdateTS(**kw)¶

Update one or more time series data books

Call:

>>> cntl.UpdateTS(ts=None, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
ts: {None} | str: Optional name of time series component to update
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'
pbs: True | {False}: Whether or not to calculate line loads with PBS scripts

Versions:

2016-06-07 @ddalle: v1.0
2016-12-21 @ddalle: v1.1, Add pbs flag
2017-04-25 @ddalle: v1.2
- Removed pbs
- Added --delete

UpdateTriqFM(**kw)¶

Update one or more TriqFM data books

Call:

>>> cntl.UpdateTriqFM(comp=None, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Control class
comp: {None} | str: Name of TriqFM component
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2017-03-29 @ddalle: v1.0

UpdateTriqPoint(**kw)¶

Update one or more TriqPoint point sensor data books

Call:

>>> cntl.UpdateTriqPoint(comp=None, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Control class
comp: {None} | str: Name of TriqFM component
I: list[int]: List of indices
cons: list[str]: List of constraints like 'Mach<=0.5'

Versions:

2017-03-29 @ddalle: v1.0

WriteCaseJSON(i: int, rc: RunControlOpts | None = None)¶

Write JSON file with run control settings for case i

Call:

>>> cntl.WriteCaseJSON(i, rc=None)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Generic control class
i: int: Run index
rc: {None} | dict: If specified, write specified “RunControl” options

Versions:

2015-10-19 @ddalle: v1.0
2023-03-31 @ddalle: v2.0; manual options input
2023-08-29 @ddalle: v2.1; call sample_dict()
2024-08-24 @ddalle: v2.2; use CaseRunner

WriteConditionsJSON(i, rc=None)¶

Write JSON file with run matrix settings for case i

Call:

>>> cntl.WriteConditionsJSON(i, rc=None)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Generic control class
i: int: Run index
rc: {None} | dict: If specified, write specified “RunControl” options

Versions:

2021-09-08 @ddalle: v1.0

WritePBS(i: int)¶

Write the PBS script(s) for a given case

Call:

>>> cntl.WritePBS(i)

Inputs:

cntl: cape.pyfun.cntl.Cntl: CAPE main control instance
i: int: Run index

Versions:

2014-10-19 @ddalle: v1.0
2023-10-20 @ddalle: v1.1; arbitrary frun depth
2024-08-01 @ddalle: v2.0; solver-agnostic

WritePBSHeader(fp: IOBase, i: int | None = None, j: int = 0, typ: str | None = None, wd: str | None = None)¶

Write common part of PBS or Slurm script

Call:

>>> cntl.WritePBSHeader(fp, i=None, j=0, typ=None, wd=None)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
fp: IOBase: Open file handle
i: {None} | int: Case index (ignore if None); used for PBS job name
j: int: Phase number
typ: {None} | "batch" | "post": Group of PBS options to use
wd: {None} | str: Folder to enter when starting the job

Versions:

2015-09-30 @ddalle: v1.0, fork WritePBS()
2016-09-25 @ddalle: v1.1, “BatchPBS”
2016-12-20 @ddalle: v1.2
- Consolidated to opts
- Added prefix
2024-08-15 @ddalle: v1.3
- Use cntl.opts.name as prefix
- User-controlled job name length, longer default

abspath(fname: str) → str¶

Absolutize a file name

Call:

>>> fabs = cntl.abspath(fname)

Inputs:

cntl: Cntl: CAPE main control instance
fname: str: A file name

Outputs:

fabs: str: Absolute file path

Versions:

2021-10-25 @ddalle: v1.0

cli(*a, **kw)¶

Command-line interface to cape

Call:

>>> cntl.cli(*a, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
kw: dict[True | False | str]: Unprocessed keyword arguments

Outputs:

cmd: None | str: Name of command that was processed, if any

Versions:

2018-10-19 @ddalle: v1.0

cli_cape(*a, **kw)¶

Common command-line interface

This function is applied after the command-line arguments are parsed using cape.argread.readflagstar() and the control interface has already been read according to the -f flag.

Call:

>>> cmd = cntl.cli_cape(*a, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
kw: dict: Preprocessed command-line keyword arguments

Outputs:

cmd: None | str: Name of command that was processed, if any

Versions:

2018-10-19 @ddalle: v1.0
2023-06-21 @aburkhea: v1.1; add –report options

cli_preprocess(*a, **kw)¶

Preprocess command-line arguments and flags/keywords

Call:

>>> a, kw = cntl.cli_preprocess(*a, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
kw: dict[True | False | str]: Command-line keyword arguments and flags

Outputs:

a: tuple: List of sequential command-line parameters
kw: dict: Flags with any additional preprocessing performed

Versions:

2018-10-19 @ddalle: v1.0

exec_modfunction(funcname: str, a=None, kw=None, name=None)¶

Execute a function from cntl.modules

Call:

>>> v = cntl.exec_modfunction(funcname, a, kw, name=None)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall control interface
func: str: Name of function to execute, e.g. "mymod.myfunc"
a: {None} | tuple: Positional arguments to called function
kw: {None} | dict: Keyworkd arguments to called function
name: {None} | str: Hook name to use in status update

Outputs:

v: any: Output from execution of function

Versions:

2022-04-12 @ddalle: v1.0

get_pbs_jobs(force: bool = False, jobs: dict | None = None, u: str | None = None, qstat: bool = True)¶

Get dictionary of current jobs active by one user

Call:

>>> jobs = cntl.get_pbs_jobs(force=False, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
force: True | {False}: Query current queue even if cntl.jobs exists
jobs: {None} | dict: Preexisting PBS/Slurm job information
u: {None} | str: User name (defaults to process username)

Outputs:

jobs:dict: Information on each job by ID number

Versions:

2024-01-12 @ddalle: v1.0
2024-08-22 @ddalle: v1.1; add qstat option

init_post()¶

Do py{x} specific initialization actions

Call:

>>> cntl.init_post()

Inputs:

cntl: cape.cfdx.cntl.Cntl: CAPE run matrix control instance

Versions:

2023-05-31 @ddalle: v1.0

make_case_folder(i: int)¶

Create folder(s) if needed for case i

Call:

>>> cntl.make_case_folder(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
i: int: Index of case to analyze

Versions:

2023-08-25 @ddalle: v1.0 (CreateFolder)
2023-10-20 @ddalle: v2.0; support arbitrary depth

mkdir(fdir: str)¶

Make a directory with the correct permissions

Call:

>>> cntl.mkdir(fdir)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
fdir: str: Directory to create

Versions:

2015-09-27 @ddalle: v1.0

preprocess_kwargs(kw: dict)¶

Preprocess command-line arguments and flags/keywords

This will effect the following CLI options:

--cons CONS: Comma-separated constraints split into a list
-x FPY: Each -x argument is executed (can be repeated)
-I INDS: Convert INDS like 3-6,8 to [3, 4, 5, 8]

Call:

>>> opts = cntl.cli_preprocess(*a, **kw)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Overall CAPE control instance
kw: dict[True | False | str]: CLI keyword arguments and flags, modified in-place

Versions:

2024-12-19 @ddalle: v1.0

read_case_json(i)¶

Read case.json file from case i if possible

Call:

>>> rc = cntl.read_case_json(i)

Inputs:

cntl: cape.cfdx.cntl.Cntl: Instance of control class
i: int: Case index

Outputs:

rc: None | dict: Run control interface read from case.json file

Versions:

2016-12-12 @ddalle: v1.0
2017-04-12 @ddalle: v1.1; add to cape.cfdx
2023-06-29 @ddalle: v2.0; use _case_mod
2023-07-07 @ddalle: v2.1; use CaseRunner

read_options(fjson: str)¶

Read options using appropriate class

This allows users to set warning mode via an environment variable.

Call:

>>> cntl.read_options(fjson)

Inputs:

cntl: cape.cfdx.cntl.Cntl: CAPE run matrix control instance
fjson: str: Name of JSON file to read

Versions:

2023-05-26 @ddalle: v1.0; forked from __init__()
2023-12-13 @ddalle: v1.1; add RootDir and JSONFile

run_batch(argv: list)¶

Write and submit PBS/Slurm script for a CLI

Call:

>>> cntl.run_batch(argv)

Inputs:

argv: list[str]: List of command-line inputs

Versions:

2024-12-20 @ddalle: v1.0

class cape.cfdx.cntl.UgridCntl(fname=None)¶

Subclass of Cntl for unstructured-mesh solvers

Call:

>>> cntl = UgridCntl(fname=None)

Inputs:

fname: {None} | str: Name of main CAPE input (JSON) file

Outputs:

cntl: UgridCntl: Run matrix control instance for unstructured-mesh solver

GetCaseMeshFolder(i: int) → str¶

Get relative path to folder where mesh should be copied

Call:

>>> fdir = cntl.GetCaseMeshFolder(i)

Inputs:

cntl: UgridCntl: CAPE run matrix control instance
i: {0} | int: Case index

Outputs:

fdir: str: Folder to copy file, relative to cntl.RootDir

Versions:

2024-11-06 @ddalle: v1.0

GetInputMeshFileNames() → list¶

Return the list of mesh files from file

Call:

>>> fnames = cntl.GetInputMeshFileNames()

Inputs:

cntl: UgridCntl: Run matrix control instance for unstructured-mesh solver

Outputs:

fnames: list[str]: List of file names read from root directory

Versions:

2015-10-19 @ddalle: v1.0 (pyfun)
2024-10-22 @ddalle: v1.0

GetProcessedMeshFileNames()¶

Return the list of mesh files that are written

Call:

>>> fname = cntl.GetProcessedMeshFileNames()

Inputs:

cntl: UgridCntl: Run matrix control instance for unstructured-mesh solver

Outputs:

fname: list[str]: List of file names written to case folders

Versions:

2015-10-19 @ddalle: v1.0

GetProjectRootName(j: int = 0) → str¶

Get the project root name

The JSON file overrides the value from the namelist file if appropriate

Call:

>>> name = cntl.GetProjectName(j=0)

Inputs:

cntl: UgridCntl: CAPE run matrix control instance
j: {0} | int: Phase number

Outputs:

name: str: Project root name

Versions:

2015-10-18 @ddalle: v1.0 (pyfun)
2023-06-15 @ddalle: v1.1; cleaner logic
2024-10-22 @ddalle: v2.0; moved to cfdx

PrepareMesh(i: int)¶

Prepare the mesh for case i if necessary

Call:

>>> cntl.PrepareMesh(i)

Inputs:

cntl: cape.pyfun.cntl.Cntl: Instance of control class
i: int: Case index

Versions:

2015-10-19 @ddalle: v1.0 (pyfun)
2024-11-04 @ddalle: v1.3 (pyfun)
2024-11-07 @ddalle: v1.0

PrepareMeshFiles(i: int) → int¶

Copy main unstructured mesh files to case folder

Call:

>>> n = cntl.PrepareMeshFiles(i)

Inputs:

cntl: UgridCntl: CAPE run matrix control instance
i: int: Case index

Outputs:

n: int: Number of files copied

Versions:

2024-11-05 @ddalle: v1.0

PrepareMeshTri(i: int)¶

Prepare surface triangulation for AFLR3, if appropriate

Call:

>>> cntl.PrepareMeshTri(i)

Inputs:

cntl: Cntl: CAPE run matrix control instance
i: int: Case index

Versions:

2024-11-01 @ddalle: v1.0 (from pyfun’s PrepareMesh())

PrepareMeshWarmStart(i: int) → bool¶

Prepare WarmStart files for case, if appropriate

Call:

>>> warmstart = cntl.PrepareMeshWarmStart(i)

Inputs:

cntl: UgridCntl: Name of main CAPE input (JSON) file
i: int: Case index

Outputs:

warmstart: bool: Whether or not case was warm-started

Versions:

2024-11-04 @ddalle: v1.0

ProcessMeshFileName(fname: str, fproj: str | None = None) → str¶

Return a mesh file name using the project root name

Call:

>>> fout = cntl.ProcessMeshFileName(fname, fproj=None)

Inputs:

cntl: UgridCntl: Run matrix control instance for unstructured-mesh solver
fname: str: Raw file name to be converted to case-folder file name
fproj: {None} | :class;`str`: Project root name

Outputs:

fout: str: Name of file name using project name as prefix

Versions:

2016-04-05 @ddalle: v1.0 (pyfun)
2023-03-15 @ddalle: v1.1; add fproj
2024-10-22 @ddalle: v2.0; move to cfdx

cape.cfdx.cntl.run_rootdir(func)¶

Decorator to run a function within a specified folder

Call:

>>> func = run_rootdir(func)

Wrapper Signature:

>>> v = cntl.func(*a, **kw)

Inputs:

func: func: Name of function
cntl: Cntl: Control instance from which to use cntl.RootDir
a: tuple: Positional args to cntl.func()
kw: dict: Keyword args to cntl.func()

Versions:

2018-11-20 @ddalle: v1.0
2020-02-25 @ddalle: v1.1: better exceptions
2023-06-16 @ddalle: v1.2; use finally

`cape.cntl`: Base module for CFD operations and processing¶

Previous topic

Next topic

This Page

cape.cntl: Base module for CFD operations and processing¶

`cape.cntl`: Base module for CFD operations and processing¶