Hot spot finder in scripting examples. How to restrict operations on selected result object

I am referring to this scripting example
https://ansyshelp.ansys.com/public/account/secured?returnurl=//Views/Secured/corp/v251/en/act_script/act_script_examples_hot_spot.html

I have slightly modyfied it, to assign the currently selected result object to the variable 'resultObject'. However, the operations performed in the script do not seem to be limit to the underlying result data associated with 'resultObject'.
My small test model consists of two bodies. If I run the code and have a result object selected which is scoped to only one of the bodies the script creates probes for the nodes of other body which is not part of the scoping.

Find more posts tagged with

AnsysACT

scripting

DPF

Accepted answers

All comments

Matthias

All bodies

Result after running the script with object name "Equivalent Stress 2"

Matthias

# https://ansyshelp.ansys.com/public/account/secured?returnurl=//Views/Secured/corp/v251/en/act_script/act_script_examples_hot_spot.html


# For a solved Static Structural that includes an Equivalent Stress result, this script finds the locations where high stresses occur and places a label on them. Here is an illustrated example. The script specifies the insertion of seven labels. The script places the first label at the result' maximum value, and each subsequent label is placed at a distance of 0.01 (script line 25) in between each node. This distance between labels makes sure that all labels will not be clustered around the maximum value. The unit for this distance is based on what you have selected in your analysis. For the example above, the selected unit is meters. In addition, and again based on the currently selected unit of measure, the result threshold is 20 (script line 27). This means that no result value (or label) below this threshold is included.




import mech_dpf

import Ans.DataProcessing as dpf




# Number of labels to display

numLabels=7

# Minimal distance between two labels (in current Mechanical unit)

minDistBetweenNodes=0.1

# Minimal stress value for which label should be displayed (in current Mechanical Unit)

thresholdStress=4


resultObject = Tree.FirstActiveObject


analysis = resultObject.Parent.Parent


print("Selected result object: " + resultObject.Name)


# Dictionaries to store results

maxPairs={}

maxNodes={}


# # Retrieve 'Static Structural' analysis - replace analysis name

# # based on your current model

# analysis=ExtAPI.DataModel.AnalysisByName('Static Structural')

# # Retrieve first 'Equivalent Stress' object. replace object name

# # based on your current model

# resultObject=ExtAPI.DataModel.GetObjectsByName('Equivalent Stress')[0]


# Define datasources (rst from analysis)

dataSource = dpf.DataSources(analysis.ResultFileName)

# Create Mises operator

vmises = dpf.operators.result.stress_von_mises()

vmises.inputs.data_sources.Connect(dataSource)


# retrieve mesh from rst

model=dpf.Model(dataSource)

mesh=model.Mesh


# Min_max operator will be used to identify hotspots

min_max = dpf.operators.min_max.min_max() # operator instanciation


# Temporary operator

currentMises = vmises.outputs.getfields_container()


# Filter used to progressively filter data when maxima are found

tempFilter = dpf.operators.filter.field_low_pass() # operator instanciation


# Filter out stresses below thresholdStress

initFilter = dpf.operators.filter.field_high_pass() # operator instanciation

initFilter.inputs.field.Connect(currentMises)

initFilter.inputs.threshold.Connect(thresholdStress)


# update currentMises with results from filter

currentMises = initFilter.outputs.getfield()


def nodeDist(cur_node,nodes_dict,test_dist):

    # Compute distance between a reference node (cur_node) and 

    # a set of nodes nodes_dict and check vs a test distance (test_dist)

    # if any of the nodes in nodes_dict is close to cur_node within

    # less than test_dist, then return False. Otherwise cur_node is 

    # away from each node in nodes_dict by at least test_dist

    test=True

    for nodeId in nodes_dict.keys():

        test_node=nodes_dict[nodeId]

        dist=0.

        for i in range(0,3):

            dist+=(test_node[i]-cur_node[i])**2

        if (dist<=test_dist**2):

            test=False

            break


    return test


if not(currentMises.Data):

    ExtAPI.Application.LogWarning('Threshold value exceeds maximum stress. Please set a lower value for "thresholdStress" variable ')


# Start looking for hotspots

numFound=0

while numFound<numLabels and currentMises.Data:

    # in current stress field, search for max value

    min_max.inputs.field.Connect(currentMises)

    maxData = min_max.outputs.field_max.GetData()


    # Check whether scoping node is far from other nodes

    if numFound>0:

        # at least one label was found, we need to check for distance

        maxNodeId=maxData.ScopingIds[0]

        maxValue=maxData.Data[0]

        # Retrieve information from node at max value out of result mesh 

        node=mesh.NodeById(maxNodeId)

        nodeCoord=[node.X, node.Y,node.Z]        

        if nodeDist(nodeCoord,maxNodes,minDistBetweenNodes): 

            # node if node is far enough from all other nodes, add to labels

            # otherwise, we simply ignore this maximum

            maxNodes[maxNodeId]=nodeCoord

            maxPairs[maxValue]=maxNodeId

            numFound+=1

    else:

        # first label at maximum value

        # Retrieve max value and corresponding node from maxData operator

        maxValue=maxData.Data[0]

        maxNodeId=maxData.ScopingIds[0]

        # Start population data in maxPairs (maxvalue:node id)

        # and maxNodes (node id: x,y,z)

        maxPairs[maxValue]=maxNodeId

        node=mesh.NodeById(maxNodeId)

        maxNodes[maxNodeId]=[node.X, node.Y,node.Z]

        numFound+=1


    # Filter out anything above last max value from currentMises

    tempFilter.inputs.field.Connect(currentMises)

    tempFilter.inputs.threshold.Connect(maxValue)    

    currentMises = tempFilter.outputs.getfield()


if numFound<numLabels and numFound>0:

    ExtAPI.Application.LogWarning('Could not find more than '+str(numFound)+' hotspots. You should set "thresholdStress" variable or "minDistBetweenNodes" to lower values')


if numFound==0:

    ExtAPI.Application.LogWarning('Could not find any hotspots. You should set "thresholdStress" variable or "minDistBetweenNodes" to lower values')

else:

    # Create labels on result object    

    with Transaction():

        labelsForRes = Graphics.LabelManager.GetObjectLabels(resultObject)

        Graphics.LabelManager.DeleteLabels(labelsForRes)

        for node in maxPairs.values():

            probeLabel = Graphics.LabelManager.CreateProbeLabel(resultObject)

            probeLabel.Scoping.Node = node