cape.cfdx.options.isectopts: CLI options for intersect

This module interfaces options for two Cart3D triangulation tools called intersect and verify. This allows the user to intersect overlapping triangulated bodies and create a single water-tight body.

The verify executable tests for a well-defined water-tight triangulation. Intersections, missing triangles, holes, etc. all cause verify to fail.

The main option for both intersect and verify is simply whether or not to use them. The user can specify the following in the "RunControl" section of the JSON file.

"RunControl": {
    "intersect": True,
    "verfiy": False
}

There are a variety of input flags to those utilities, which are interfaced via the IntersectOpts and VerifyOpts classes defined here.

class cape.cfdx.options.isectopts.IntersectOpts(*args, **kw)

Class for Cart3D intersect command-line settings

Call:
>>> opts = intersect(**kw)
Inputs:
kw: dict

Dictionary of intersect command-line options

Outputs:
opts: InterseectOpts

Intersect utility options interface

Versions:

  • 2016-04-05 @ddalle: Version 1.0

  • 2022-10-29 @ddalle: Version 2.0; OptionsDict

get_intersect_T(j=None, i=None, **kw)

Get option to also write Tecplot file Components.i.plt

Call:
>>> T = opts.get_intersect_T(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
T: {False} | True

option to also write Tecplot file Components.i.plt

get_intersect_ascii(j=None, i=None, **kw)

Get flag that input file is ASCII

Call:
>>> ascii = opts.get_intersect_ascii(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
ascii: {None} | True | False

flag that input file is ASCII

get_intersect_cutout(j=None, i=None, **kw)

Get number of component to subtract

Call:
>>> cutout = opts.get_intersect_cutout(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
cutout: {None} | int

number of component to subtract

get_intersect_fast(j=None, i=None, **kw)

Get also write unformatted FAST file Components.i.fast

Call:
>>> fast = opts.get_intersect_fast(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
fast: {False} | True

also write unformatted FAST file Components.i.fast

get_intersect_i(j=None, i=None, **kw)

Get input file to intersect

Call:
>>> i = opts.get_intersect_i(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
i: {'Components.tri'} | str

input file to intersect

get_intersect_intersections(j=None, i=None, **kw)

Get option to write intersections to intersect.dat

Call:
>>> intersections = opts.get_intersect_intersections(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
intersections: {False} | True

option to write intersections to intersect.dat

get_intersect_o(j=None, i=None, **kw)

Get output file for intersect

Call:
>>> o = opts.get_intersect_o(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
o: {'Components.i.tri'} | str

output file for intersect

get_intersect_overlap(j=None, i=None, **kw)

Get perform boolean intersection of this comp number

Call:
>>> overlap = opts.get_intersect_overlap(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
overlap: {None} | int

perform boolean intersection of this comp number

get_intersect_rm(j=None, i=None, **kw)

Get option to remove small triangles from results

Call:
>>> rm = opts.get_intersect_rm(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
rm: {False} | True

option to remove small triangles from results

get_intersect_smalltri(j=None, i=None, **kw)

Get cutoff size for small triangles with rm

Call:
>>> smalltri = opts.get_intersect_smalltri(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
smalltri: {0.0001} | float

cutoff size for small triangles with rm

get_intersect_triged(j=None, i=None, **kw)

Get option to use CGT triged to clean output file

Call:
>>> triged = opts.get_intersect_triged(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
triged: {True} | False

option to use CGT triged to clean output file

get_intersect_v(j=None, i=None, **kw)

Get verbose mode

Call:
>>> v = opts.get_intersect_v(j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
v: {False} | True

verbose mode

set_intersect_T(v, j=None, mode=None)

Get option to also write Tecplot file Components.i.plt

Call:
>>> opts.set_intersect_T(T, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

T: {False} | True

option to also write Tecplot file Components.i.plt

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_ascii(v, j=None, mode=None)

Get flag that input file is ASCII

Call:
>>> opts.set_intersect_ascii(ascii, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

ascii: {None} | True | False

flag that input file is ASCII

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_cutout(v, j=None, mode=None)

Get number of component to subtract

Call:
>>> opts.set_intersect_cutout(cutout, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

cutout: {None} | int

number of component to subtract

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_fast(v, j=None, mode=None)

Get also write unformatted FAST file Components.i.fast

Call:
>>> opts.set_intersect_fast(fast, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

fast: {False} | True

also write unformatted FAST file Components.i.fast

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_i(v, j=None, mode=None)

Get input file to intersect

Call:
>>> opts.set_intersect_i(i, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

i: {'Components.tri'} | str

input file to intersect

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_intersections(v, j=None, mode=None)

Get option to write intersections to intersect.dat

Call:
>>> opts.set_intersect_intersections(intersections, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

intersections: {False} | True

option to write intersections to intersect.dat

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_o(v, j=None, mode=None)

Get output file for intersect

Call:
>>> opts.set_intersect_o(o, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

o: {'Components.i.tri'} | str

output file for intersect

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_overlap(v, j=None, mode=None)

Get perform boolean intersection of this comp number

Call:
>>> opts.set_intersect_overlap(overlap, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

overlap: {None} | int

perform boolean intersection of this comp number

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_rm(v, j=None, mode=None)

Get option to remove small triangles from results

Call:
>>> opts.set_intersect_rm(rm, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

rm: {False} | True

option to remove small triangles from results

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_smalltri(v, j=None, mode=None)

Get cutoff size for small triangles with rm

Call:
>>> opts.set_intersect_smalltri(smalltri, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

smalltri: {0.0001} | float

cutoff size for small triangles with rm

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_triged(v, j=None, mode=None)

Get option to use CGT triged to clean output file

Call:
>>> opts.set_intersect_triged(triged, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

triged: {True} | False

option to use CGT triged to clean output file

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_intersect_v(v, j=None, mode=None)

Get verbose mode

Call:
>>> opts.set_intersect_v(v, j=None, i=None, **kw)
Inputs:
opts: IntersectOpts

options interface

v: {False} | True

verbose mode

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

class cape.cfdx.options.isectopts.VerifyOpts(*args, **kw)

Options for command-line options to Cart3D verify tool

Call:
>>> opts = VerifyOpts(**kw)
Inputs:
kw: dict

Dictionary of verify command-line options

Outputs:
opts: VerifyOpts

Options interface for verify` options

Versions:

  • 2016-04-05 @ddalle: Version 1.0 (verify)

  • 2022-10-29 @ddalle: Version 2.0; OptionsDict

get_verify_ascii(j=None, i=None, **kw)

Get option for ASCII input file to verify

Call:
>>> ascii = opts.get_verify_ascii(j=None, i=None, **kw)
Inputs:
opts: VerifyOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
ascii: {True} | False

option for ASCII input file to verify

get_verify_i(j=None, i=None, **kw)

Get input file for verify

Call:
>>> i = opts.get_verify_i(j=None, i=None, **kw)
Inputs:
opts: VerifyOpts

options interface

j: {None} | int

Phase index; use None to just return v

i: {None} | int | np.ndarray

opts.x index(es) to use with @expr, @map, etc.

vdef: {None} | object

Manual default

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

ring: {opts._optring[key]} | True | False

Override option to loop through phase inputs

listdepth: {0} | int > 0

Depth of list to treat as a scalar

x: {None} | dict

Ref conditions to use with @expr, @map, etc.; often a run matrix; used in combination with i

sample: {True} | False

Apply j, i, and other settings recursively if output is a list or dict

Outputs:
i: {None} | str

input file for verify

set_verify_ascii(v, j=None, mode=None)

Get option for ASCII input file to verify

Call:
>>> opts.set_verify_ascii(ascii, j=None, i=None, **kw)
Inputs:
opts: VerifyOpts

options interface

ascii: {True} | False

option for ASCII input file to verify

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar

set_verify_i(v, j=None, mode=None)

Get input file for verify

Call:
>>> opts.set_verify_i(i, j=None, i=None, **kw)
Inputs:
opts: VerifyOpts

options interface

i: {None} | str

input file for verify

j: {None} | int

Phase index; use None to just return v

mode: {None} | 0 | 1 | 2 | 3

Warning mode code

0:

no checks

1:

validate silently

2:

validate and show warnings

3:

raise an exception if invalid

listdepth: {0} | int > 0

Depth of list to treat as a scalar