#############################################################################

#

# (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.

#

# This sample script is not supported by Cadence Design Systems, Inc.

# It is provided freely for demonstration purposes only.

# SEE THE WARRANTY DISCLAIMER AT THE BOTTOM OF THIS FILE.

#

#############################################################################

""" This is an example script that generates the structured block topology

of the Backward Step from the Pointwise Tutorial Workbook. This

example uses the Glyph API for Python.

For demonstration purposes, many of the Python commands are preceded

by a comment that shows the equivalent Tcl command. This script can

be run in either Python 2.7+ or Python 3.6+.

To run this example in Python 3.6+:

- Start a Pointwise GUI instance

- Go to Script, Glyph Server...

- Set Listen Mode to Active

- OK

- Run 'python backstep.py' at a command prompt on the same host

as the Pointwise instance

"""

from pointwise import GlyphClient

from pointwise.glyphapi import *

# Connect to the Pointwise server listening on localhost at the default port

# with no authentication token...

# glf = GlyphClient()

# ... or create a pointwise server as a subprocess and connect to that.

# Note: this will consume a Pointwise license

def echo(line):

print("Script: {0}".format(line), end='') # Not Python 2.7 compatible

# Run in batch mode

glf = GlyphClient(port=0, callback=echo)

# Run in GUI, default port

# glf = GlyphClient(callback=echo)

glf.connect()

# Use the Glyph API for Python

pw = glf.get_glyphapi()

# Allow error messages to be printed on the server

pw.Database._setVerbosity("Errors")

pw.Application._setVerbosity("Errors")

# Reset the server's workspace

pw.Application.setUndoMaximumLevels(10)

pw.Application.reset()

pw.Application.markUndoLevel("Journal Reset")

# pw::Connector setDefault Dimension 30

pw.Connector.setDefault("Dimension", 30)

# set creator [pw::Application begin Create]

with pw.Application.begin("Create") as creator:

# set seg [pw::SegmentSpline create]

seg = pw.SegmentSpline()

# $seg addPoint {0 0 0}

seg.addPoint((0, 0, 0))

seg.addPoint((20, 0, 0))

# set con [pw::Connector create]

con = pw.Connector()

# $con addSegment $seg

con.addSegment(seg)

# $con calculateDimension

con.calculateDimension()

# "$creator end" is implied

pw.Application.markUndoLevel("Create 2 Point Connector")

with pw.Application.begin("Create") as creator:

seg = pw.SegmentSpline()

seg.addPoint((20, 0, 0))

seg.addPoint((60, 0, 0))

con = pw.Connector()

con.addSegment(seg)

con.calculateDimension()

pw.Application.markUndoLevel("Create 2 Point Connector")

# pw::Display resetView -Z

pw.Display.resetView("-Z")

cons = { }

# set cons(con-1) [pw::GridEntity getByName "con-1"]

cons["con-1"] = pw.GridEntity.getByName("con-1")

cons["con-2"] = pw.GridEntity.getByName("con-2")

# set coll [pw::Collection create]

coll = pw.Collection()

# foreach { k v } [array get cons] { lappend clist $v }

# $coll set $clist

coll.set(cons.values())

# $coll do setRenderAttribute RenderMode Intervals

coll.do("setRenderAttribute", "RenderMode", "Intervals")

# $coll delete

coll.delete()

pw.Application.markUndoLevel("Modify Entity Display")

# set modifier [pw::Application begin Modify]

with pw.Application.begin("Modify", cons["con-1"]) as modifier:

# [$cons(con-1) getDistribution 1] setBeginSpacing 1

cons["con-1"].getDistribution(1).setBeginSpacing(1)

# "$modifier end" is implied

pw.Application.markUndoLevel("Change Spacing")

with pw.Application.begin("Modify", cons.values()) as modifier:

cons["con-1"].getDistribution(1).setEndSpacing(0.1)

cons["con-2"].getDistribution(1).setEndSpacing(0.1)

pw.Application.markUndoLevel("Change Spacings")

with pw.Application.begin("Modify", cons["con-2"]) as modifier:

cons["con-2"].getDistribution(1).setEndSpacing(2)

pw.Application.markUndoLevel("Change Spacing")

with pw.Application.begin("Create") as creator:

# set edge [pw::Edge createFromConnectors -single $cons(con-2)]

edge = pw.Edge.createFromConnectors(cons["con-2"], single=True)

# set dom [pw::DomainuStructured create]

dom = pw.DomainStructured()

# $dom addEdge $edge

dom.addEdge(edge)

# set extruder [pw::Application begin ExtrusionSolver $dom]

with pw.Application.begin("ExtrusionSolver", dom) as extruder:

# $dom setExtrusionSolverAttribute Mode Translate

dom.setExtrusionSolverAttribute("Mode", "Translate")

# $dom setExtrusionSolverAttribute TranslateDirection {0 -1 0}

dom.setExtrusionSolverAttribute("TranslateDirection", (0, -1, 0))

# $dom setExtrusionSolverAttribute TranslateDistance 8

dom.setExtrusionSolverAttribute("TranslateDistance", 8)

# $extruder run 29

extruder.run(29)

# "$extruder end" is implied

pw.Application.markUndoLevel("Translate")

with pw.Application.begin("Create") as creator:

edge = pw.Edge.createFromConnectors(cons.values(), single=True)

dom = pw.DomainStructured()

dom.addEdge(edge)

with pw.Application.begin("ExtrusionSolver", dom) as extruder:

dom.setExtrusionSolverAttribute("Mode", "Translate")

dom.setExtrusionSolverAttribute("TranslateDirection", Vector3(0, -1, 0).negate())

dom.setExtrusionSolverAttribute("TranslateDistance", 20)

extruder.run(29)

pw.Application.markUndoLevel("Translate")

cons["con-3"] = pw.GridEntity.getByName("con-3")

cons["con-5"] = pw.GridEntity.getByName("con-5")

cons["con-6"] = pw.GridEntity.getByName("con-6")

cons["con-8"] = pw.GridEntity.getByName("con-8")

with pw.Application.begin("Modify", cons.values()) as modifier:

cons["con-3"].getDistribution(1).setBeginSpacing(0.1)

cons["con-5"].getDistribution(1).setEndSpacing(0.1)

cons["con-6"].getDistribution(1).setBeginSpacing(0.1)

cons["con-8"].getDistribution(1).setEndSpacing(0.1)

pw.Application.markUndoLevel("Change Spacings")

doms = { }

doms["dom-1"] = pw.GridEntity.getByName("dom-1")

doms["dom-2"] = pw.GridEntity.getByName("dom-2")

# foreach { k v } [array get doms] { lappend dlist $v }

# set solver [pw::Application begin EllipticSolver $dlist]

with pw.Application.begin("EllipticSolver", doms.values()) as solver:

# $solver Initialize

solver.run("Initialize")

# "$solver end" is implied

pw.Application.markUndoLevel("Initialize")

pw.Connector.setDefault("Dimension", 21)

# pw::Application setClipboard $dlist

pw.Application.setClipboard(doms.values())

# set paster [pw::Application begin Paste]

with pw.Application.begin("Paste") as paster:

# set ents [$paster getEntities]

ents = paster.getEntities()

# set modifier [pw::Application begin Modify $ents]

with pw.Application.begin("Modify", ents) as modifier:

# set xforments [$modifier getEntities]

xforments = modifier.getEntities()

# set coll [pw::Collection create]

coll = pw.Collection()

# $coll set $xforments

coll.set(xforments)

# set xform [pw::Transform translation {0 0 15}]

xform = Transform.translation((0, 0, 15))

# pw::Entity transform $xform [$coll list]

pw.Entity.transform(xform, coll.list())

# $coll delete

coll.delete()

# "$modifier end" is implied

# "$paster end" is implied

pw.Application.markUndoLevel("Paste")

pw.Display.setShowDomains(False)

with pw.Application.begin("Create") as creator:

seg = pw.SegmentSpline()

seg.addPoint(pw.GridEntity.getByName("con-13").getPosition(arc=0))

seg.addPoint(pw.GridEntity.getByName("con-1").getPosition(arc=0))

con = pw.Connector()

con.addSegment(seg)

con.calculateDimension()

pw.Application.markUndoLevel("Create 2 Point Connector")

with pw.Application.begin("Create") as creator:

seg = pw.SegmentSpline()

seg.addPoint(pw.GridEntity.getByName("con-9").getPosition(arc=0))

seg.addPoint(pw.GridEntity.getByName("con-1").getPosition(arc=1))

con = pw.Connector()

con.addSegment(seg)

con.calculateDimension()

pw.Application.markUndoLevel("Create 2 Point Connector")

with pw.Application.begin("Create") as creator:

seg = pw.SegmentSpline()

seg.addPoint(pw.GridEntity.getByName("con-4").getPosition(arc=1))

seg.addPoint(pw.GridEntity.getByName("con-11").getPosition(arc=1))

con = pw.Connector()

con.addSegment(seg)

con.calculateDimension()

pw.Application.markUndoLevel("Create 2 Point Connector")

with pw.Application.begin("Create") as creator:

seg = pw.SegmentSpline()

seg.addPoint(pw.GridEntity.getByName("con-10").getPosition(arc=1))

seg.addPoint(pw.GridEntity.getByName("con-4").getPosition(arc=0))

con = pw.Connector()

con.addSegment(seg)

con.calculateDimension()

pw.Application.markUndoLevel("Create 2 Point Connector")

with pw.Application.begin("Create") as creator:

seg = pw.SegmentSpline()

seg.addPoint(pw.GridEntity.getByName("con-2").getPosition(arc=1))

seg.addPoint(pw.GridEntity.getByName("con-9").getPosition(arc=1))

con = pw.Connector()

con.addSegment(seg)

con.calculateDimension()

pw.Application.markUndoLevel("Create 2 Point Connector")

with pw.Application.begin("Create") as creator:

seg = pw.SegmentSpline()

seg.addPoint(pw.GridEntity.getByName("con-14").getPosition(arc=1))

seg.addPoint(pw.GridEntity.getByName("con-7").getPosition(arc=0))

con = pw.Connector()

con.addSegment(seg)

con.calculateDimension()

pw.Application.markUndoLevel("Create 2 Point Connector")

with pw.Application.begin("Create") as creator:

seg = pw.SegmentSpline()

seg.addPoint(pw.GridEntity.getByName("con-7").getPosition(arc=1))

seg.addPoint(pw.GridEntity.getByName("con-15").getPosition(arc=1))

con = pw.Connector()

con.addSegment(seg)

con.calculateDimension()

pw.Application.markUndoLevel("Create 2 Point Connector")

pw.Display.setShowDomains(True)

pw.Display.resetView("-Z")

for con in pw.Grid.getAll(type="pw::Connector"):

cons[con.getName()] = con

unusedCons = GlyphVar("unusedCons")

poleDoms = GlyphVar()

unusedDoms = GlyphVar()

# pw::DomainStructured createFromConnectors -reject unusedCons -solid $clist

pw.DomainStructured.createFromConnectors(cons.values(), reject=unusedCons, solid=True)

# pw::BlockStructured createFromDomains -poleDomains poleDoms -reject unusedDoms [pw::Grid getAll -type pw::Domain]

pw.BlockStructured.createFromDomains(pw.Grid.getAll(type="pw::Domain"), poleDomains=poleDoms, reject=unusedDoms)

# GlyphVar usage: 'var.value' is the processed Tcl variable, which may

# contain string or numeric values, or Glyph objects

if len(unusedDoms.value) > 0:

glf.puts("First block assembly, some domains are unused:")

for ud in unusedDoms.value:

# print to the Pointwise message window

glf.puts(" %s" % ud.getName())

if len(poleDoms.value) > 0:

glf.puts("First block assembly, some domains are poles (fatal):")

# foreach pd $poleDoms { puts [format "Domain %s is a pole domain" [$pd getName]] }

for pd in poleDoms.value:

glf.puts(" %s is a pole domain" % pd.getName())

exit(1)

pw.Application.markUndoLevel("Assemble Blocks")

# The connection domain could not be automatically assembled from the full set of

# connectors, so we must isolate them and create the domain separately

connection_cons = []

for i in (2, 9, 18, 21): connection_cons.append(pw.GridEntity.getByName("con-%d" % i))

pw.DomainStructured.createFromConnectors(connection_cons, reject=unusedCons, solid=True)

pw.BlockStructured.createFromDomains(pw.Grid.getAll(type="pw::Domain"), poleDomains=poleDoms, reject=unusedDoms)

pw.Application.markUndoLevel("Assemble Blocks")

doms = { }

# foreach d [pw::Grid getAll -type pw::DomainStructured] { set doms([$d getName]) $d }

for d in pw.Grid.getAll(type="pw::DomainStructured"): doms[d.getName()] = d

blks = { }

# set blks(blk-1) [pw::GridEntity getByName "blk-1"]

blks["blk-1"] = pw.GridEntity.getByName("blk-1")

# set blks(blk-2) [pw::GridEntity getByName "blk-2"]

blks["blk-2"] = pw.GridEntity.getByName("blk-2")

# set bc [pw::BoundaryConditon create]

bc = pw.BoundaryCondition()

# $bc setName Inflow

bc.setName("Inflow")

# $bc setPhysicalType Inflow

bc.setPhysicalType("Inflow")

# $bc apply [list [list $blks(blk-2) $doms(dom-9)]]

bc.apply([[blks["blk-2"], doms["dom-9"]]])

bc = pw.BoundaryCondition()

bc.setName("Outflow")

bc.setPhysicalType("Outflow")

# $bc apply [list [list $blks(blk-2) $doms(dom-8)] [list $blks(blk-1) $doms(dom-5)]]

bc.apply([[blks["blk-2"], doms["dom-8"]], [blks["blk-1"], doms["dom-5"]]])

bc = pw.BoundaryCondition()

bc.setName("Wall")

bc.setPhysicalType("Wall")

bc.apply([[blks["blk-2"], doms["dom-7"]],

[blks["blk-1"], doms["dom-6"]],

[blks["blk-1"], doms["dom-10"]]])

bc = pw.BoundaryCondition()

bc.setName("Symmetry")

bc.setPhysicalType("Symmetry Plane")

bc.apply([[blks["blk-2"], doms["dom-4"]],

[blks["blk-2"], doms["dom-2"]],

[blks["blk-2"], doms["dom-11"]],

[blks["blk-1"], doms["dom-1"]],

[blks["blk-1"], doms["dom-3"]]])

pw.Application.markUndoLevel("Set BC")

# The remainder of this script is for demonstration purposes

# only, and is not part of the Back Step tutorial.

# set exam [pw::Examine create "BlockJacobian"]

with pw.Examine("BlockJacobian") as exam:

# $exam addEntity $blist

exam.addEntity(blks.values())

# $exam examine

exam.examine()

# puts [format "Min/Max Jacobian: %f/%f" [$exam getMinimum] [$exam getMaximum]]

glf.puts("Min/Max Jacobian: %f/%f" % (exam.getMinimum(), exam.getMaximum()))

# Note: exam.delete() is optional since exam doubles as a context manager

# pw::CutPlane applyMetric BlockJacobian

pw.CutPlane.applyMetric("BlockJacobian")

# set cut [pw::CutPlane create]

cut = pw.CutPlane()

# $cut setConstant -J 11

cut.setConstant(J=11)

# $cut addBlock $blks(blk-1)

cut.addBlock(blks.values())

# $cut setTransparency 0.25

cut.setTransparency(0.25)

# $cut setShrinkFactor 0.9

cut.setShrinkFactor(0.9)

# pw::Application save backstep.pw

pw.Application.save("backstep.pw")

# foreach { k v } [array get blks] { lappend blist $v }

# pw::Application export -precision Single $blist backstep.cgns

pw.Application.export(blks.values(), "backstep.cgns", precision="Single")

glf.close()

#############################################################################

#

# This file is licensed under the Cadence Public License Version 1.0 (the

# "License"), a copy of which is found in the included file named "LICENSE",

# and is distributed "AS IS." TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE

# LAW, CADENCE DISCLAIMS ALL WARRANTIES AND IN NO EVENT SHALL BE LIABLE TO

# ANY PARTY FOR ANY DAMAGES ARISING OUT OF OR RELATING TO USE OF THIS FILE.

# Please see the License for the full text of applicable terms.

#

#############################################################################