AutoCAD DevBlog

Custom Python Scripts for AutoCAD Plant 3D – Part 5

By David Wolfe (Contributor)

Get start with Part 1, Part 2, Part 3 and Part 4 of this series.

Python Script Nozzles in AutoCAD Plant 3D

This article will look at creating a nozzle to use in the nozzles catalog which AutoCAD Plant 3D equipment loads when putting nozzles on equipment.

The full sample is available at this link. The script should look like this:

# Embedded file name: varmain\pipesub\cpp_f_f_.pyc
from aqa.math import *
from varmain.flangesub.cpfwo import *
from varmain.pipesub.cpp_util import *
from varmain.primitiv import *
from varmain.var_basic import *
from varmain.custom import *

@activate(Group="StraightNozzle,Nozzle", TooltipShort="Long Weld Neck", TooltipLong="Long Weld Neck", LengthUnit="in", Ports="2")
@group("MainDimensions")
@param(D10=LENGTH, TooltipShort="Nominal Outside Diameter",TooltipLong="Nominal Outside Diameter")
@param(L1=LENGTH, TooltipShort="Overall Length.", TooltipLong="Overall Length")
@param(L2=LENGTH, TooltipShort="Hub Length", TooltipLong="Length of flange with weld neck.")
@param(OF=LENGTH, TooltipLong="Length between connection points.")
@param(B1=LENGTH, TooltipLong="Flange Thickness")
@param(D12=LENGTH, TooltipLong="Flange OD Width")
@param(D13=LENGTH, TooltipLong="OD of Weld neck")

def nozflange(s, D10 = 4.5, L1 = 9, L2 = 3, B1 = 0.94, D12 = 9, D13 = 5.31, OF = -1.0,**kw):
    xH1 = D12 + OF * 2.0
    if D12 < xH1:
        D12 = xH1
    W1 = D12
    DI = .25
    DO = .25
    #create the nozzle extension
    if L1 > 0:
        oTH = CYLINDER(s, R=D10 / 2.0, H=L1, O=D10 - (DO / 2.0)).rotateY(90.0)
    else:
        oTH = None
        L1 = -L1
    oF1 = CPFWO(s, L=L2, B=B1, D1=D12, D2=D10, D3=D13, W=W1, OF=OF)
    if oTH:
        oTH.uniteWith(oF1)
        oF1.erase()
    if W1 <= D12:
        WA1 = 0.0
    else:
        WA1 = 90.0
#set port points
    s.setPoint((0.0, 0.0, 0.0), (-1.0, 0.0, 0.0), WA1, 0.0, L2)
    s.setPoint((L1, 0.0, 0.0), (1.0, 0.0, 0.0), 0, 0.0, L2)
    return

Metadata

First we have the includes, this script the includes section is particular important because we are using some of the stock flange scripts (flangesub, pipesub).

# Embedded file name: varmain\pipesub\cpp_f_f_.pyc
from aqa.math import *
from varmain.flangesub.cpfwo import *
from varmain.pipesub.cpp_util import *
from varmain.primitiv import *
from varmain.var_basic import *
from varmain.custom import *

Second is the section declaring our tooltips and parameters.  One the first line here, because we want the script listed under the StraightNozzle and Nozzle categories, we include both.

@activate(Group="StraightNozzle,Nozzle", TooltipShort="Long Weld Neck", TooltipLong="Long Weld Neck", LengthUnit="in", Ports="2")
@group("MainDimensions")
@param(D10=LENGTH, TooltipShort="Nominal Outside Diameter",TooltipLong="Nominal Outside Diameter")
@param(L1=LENGTH, TooltipShort="Overall Length.", TooltipLong="Overall Length")
@param(L2=LENGTH, TooltipShort="Hub Length", TooltipLong="Length of flange with weld neck.")
@param(OF=LENGTH, TooltipLong="Length between connection points.")
@param(B1=LENGTH, TooltipLong="Flange Thickness")
@param(D12=LENGTH, TooltipLong="Flange OD Width")
@param(D13=LENGTH, TooltipLong="OD of Weld neck")

 
StraightNozzles

 
Nozzle class shown by clicking advanced shape options and selecting nozzle.

Testing

To test the script, I made a tool palette icon with this in the macro portion:
^C^CPLANTREGISTERCUSTOMSCRIPTS;^C^C(command "arx" "l" "Pnp3dacpadapter");(testacpscript "nozflange");

Once the script is tested, we need to be able to test it in a catalog.  For Plant 3D, all of the nozzles are read from a shared content folder path. You can find the path by running the spec editor as administrator, and then going to Tools > Modify Shared Content folder.

The default path is C:\AutoCAD Plant 3D 2016 Content\.

The default path for the nozzle catalog is "C:\AutoCAD Plant 3D 2016 Content\CPak Common\NOZZLE Catalog.acat"

To open the nozzle catalog, switch to the Catalogs tab, and go to open, and then browse to it.  Once in the catalog you can click create new component and select your script. Fill in some sample data and save your catalog component and the catalog. Note that for flanged nozzles, your end type and pressure class must be set.

In a project drawing, create a piece of equipment, and then pick your nozzle.

You can change the nozzle orientation in the Change location tab.

Note that if you want the user to override the nozzle length, you should use the L parameter in your script. In this case (using L1), for a long weld neck, the catalog data will drive the length, and the user won’t be able to change it.

Deployment

Because you can’t directly modify the nozzle catalog on a user’s computer without overwriting it, you should deploy a folder (eg CPak Custom Nozzles) with your nozzle catalog. The user then will be responsible to add the nozzles. Another option would be to deploy two catalogs, one with the stock nozzles + your custom nozzles, and one with just your custom nozzles.  You could write an installer that lets the user pick which of the two installs they want.  In either case, you should use a property like Design Pressure Factor to include unique information so that they can quickly filter to locate your nozzles.

Mimic Line Number > New feature on Plant 3D – 2.0

By Augusto Goncalves

This is an expanded version of what as previously posted here, hence the 2.0

But what was missing on version 1.0?

Actually it considered just one element at a time. Also, it ignored the related elements, like connectors, for instance. Now the sample below get a selection of entities, then find related elements (like P3dConnector and Universal) and add them all to the newly create group.

Thanks to Jens Dorstewitz (ADN Partner) for helping improve it.

[CommandMethod("customNewTag")]
public static void CmdCustomNewTag()
{
  Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
 
  PromptSelectionResult  per = ed.GetSelection();
  if (per.Status != PromptStatus.OK) return;
 
  PromptResult pr = ed.GetString("\nEnter new tag: ");
  if (pr.Status != PromptStatus.OK) return;
 
  ObjectIdCollection ids = new ObjectIdCollection();
  foreach (SelectedObject selObj in per.Value)
    ids.Add(selObj.ObjectId);
 
  CreateNewTag(ids, pr.StringResult);
}
 
private static void CreateNewTag(ObjectIdCollection itemIds, string newTagValue)
{
  PlantProject currentProj = PlantApplication.CurrentProject;
  PipingProject pipeProj = (PipingProject)currentProj.ProjectParts["Piping"];
  DataLinksManager dlm = pipeProj.DataLinksManager;
  PnPDatabase db = dlm.GetPnPDatabase();
 
  // create new line group
  PnPTable p3dLineGroupTable = db.Tables["P3dLineGroup"];
  PnPRow lgRow = p3dLineGroupTable.NewRow();
  lgRow["Tag"] = newTagValue;
  p3dLineGroupTable.Rows.Add(lgRow);
  int newLineGroupId = lgRow.RowId;
 
  // rowIds of the selected items
  List<int> rowIds = new List<int>();
  foreach (ObjectId itemId in itemIds)
    rowIds.Add(dlm.FindAcPpRowId(itemId));
 
  // now the rowIds list contain only the 
  // items selected on screen, but we need more
  // elements related to those
  List<int> relateRowIds = new List<int>();
  foreach (int itemRowId in rowIds)
  {
    // only Olet, skip others.
    if (db.GetRowTableName(itemRowId) != "Olet") continue;
 
    // get the P3dConnectors
    List<int> p3dConnectorIds = new List<int>();
    p3dConnectorIds.AddRange(
      dlm.GetRelatedRowIds("P3dPartConnection",
      "Part1", itemRowId, "Part2"));
    p3dConnectorIds.AddRange(
      dlm.GetRelatedRowIds("P3dPartConnection",
      "Part2", itemRowId, "Part1"));
 
    List<int> universals = new List<int>();
    foreach (int connectorId in p3dConnectorIds)
    {
      // now the Universal:
      // the PnPDataLinks table should contain both
      // P3dConnector and Universal, and both share the 
      // same DwgHandleLow value, so find the first and
      // use this value to find the second
      PnPTable datalinksTable = db.Tables["PnPDataLinks"];
      PnPRow[] rows = datalinksTable.Select(
        string.Format("\"RowId\"={0}", connectorId));
      foreach(PnPRow row in rows)
      {
        PnPRow[] universalRow = datalinksTable.Select(
          string.Format("\"DwgHandleLow\"={0} AND \"DwgSubIndex\"=1",
          row["DwgHandleLow"]));
        universals.Add(int.Parse(universalRow[0]["RowId"].ToString()));
      }
    }
 
    // add what we found to the main list
    relateRowIds.AddRange(p3dConnectorIds);
    relateRowIds.AddRange(universals);
  }
 
  // finally a list with the selected elements
  // plus all related elements
  // now the rowIds should contain everything
  // that needs to be added to the new line group
  rowIds.AddRange(relateRowIds);
 
  // .Distinct avoid duplicated
  foreach (int itemRowId in rowIds.Distinct<int>().ToList<int>()) 
  {
    // get all line groups related to the items we found
    PnPRowIdArray priorGroupIds = dlm.GetRelatedRowIds(
      "P3dLineGroupPartRelationship", "Part", itemRowId, "LineGroup");
 
    // remove them from any previous group
    if (priorGroupIds.Count != 1)
    {
      foreach (int id in priorGroupIds)
      {
        dlm.Unrelate("P3dLineGroupPartRelationship",
          "LineGroup", id, "Part", itemRowId);
      }
    }
 
    // make the new relation
    if (newLineGroupId != -1 && itemRowId != -1)
    {
      dlm.Relate("P3dLineGroupPartRelationship",
        "LineGroup", newLineGroupId, "Part", itemRowId);
    }
  }
 
  // relate the drawing to the line group
  int dwgId = dlm.GetDrawingId(
    Application.DocumentManager.MdiActiveDocument.Database);
  if (dwgId != -1)
  {
    dlm.Relate("P3dDrawingLineGroupRelationship",
                "Drawing", dwgId,
                "LineGroup", newLineGroupId);
  }
}

Custom Python Scripts for AutoCAD Plant 3D – Part 4

By David Wolfe (Contributor)

Get start with Part 1, Part 2 and Part 3 of this series.

Packaging and Deploying Custom Scripts

This article will demonstrate how to package and deploy your custom scripts. This process will follow these steps:

• Create images
• Build a catalog
• Build an installer (or zip)

In addition, your users will have to follow some installation steps.

• Extract to content folder (C:\AutoCAD Plant 3D 2016 Content\CPak Common\CustomScripts)

Creating Images

In order for users to have a relatively seamless experience, you should provide images that match the existing scripts as closely as possible.  Along with using similar parameter names, good images can boost the user experience by making the images blend with the OOTB content.

You should create 4 images:

• 32x32
• 64x64
• 240x240
• 640x 640 (Dimensions)

By default your AutoCAD environment may look like this:

If it does, you should turn UCSICON off, and then use F7 to turn the grid off.

Use the PLANTSNAPSHOT command to create images at 32,64, 200 px square.  Unfortunately, these images won’t exactly match the OOTB content, as the graphic engine has changed. Your images will be stored in the CustomScripts folder, and should have a file name that matches the script file name with the size appended. Shown below is our script (EXPJOINT1.py) with matching image files EXPJOINT1_32.png, EXPJOINT1_64.png, EXPJOINT1_200.png.

The program will automatically load them and use them as appropriate.

In order to provide dimension feedback, you also need to provide a 640x640 image. You can use a program like Jing, or SnagIt to create a screen clipping that is the correct dimensions.

To setup the dimension image, you’ll need to set your viewport to Hidden, create the dimensions, and override their text values and size.

You should turn your background white, by modifying your AutoCAD options.

Once the images are in place and you have run PLANTREGISTERCUSTOMSCRIPTS on your most recent version, you are ready to package the files.

Deploying the Scripts

Once you have everything ready, you can build your installer. One full-featured free installer is Inno Setup. When building your installer, you should handle the following:

• Multiple versions of Plant
• Custom Content Paths
• Previously loaded content

Multiple versions of Plant

The api for creating scripts hasn’t changed significantly since Plant was first released. Technically, you could deploy scripts for all version 2011 and higher.  However, Autodesk maintains support for the last 3 releases, so that may be a factor for your consideration as well.

Custom Content Paths

While C:\AutoCAD Plant 3D 2016 Content is the default content location, some users may have custom paths set. You can find these paths by checking the registry key for its default value.

HKEY_LOCAL_MACHINE\SOFTWARE\Autodesk\AutoCAD\R20.1\ACAD-F017\Variables\PLANTCONTENTFOLDER

The value R20.1 here is for 2016, and F017 is for Plant. See this page for more information on version identifiers.

You will need to check this registry value for any version of Plant that you want to install your scripts for.

Previous Content

Most users do not use CustomScripts, so unless they do, you will be able to put files at the CustomScripts folder location without worry. However, if a user does have custom scripts present, they will need to run PLANTREGISTERCUSTOMSCRIPTS after installation in order for your new scripts to be recognized along with existing scripts.

In addition, you should use file names that are not likely to be used by other developers. Every plant developer will have to use the same folder, so prepending your script names with a company abbreviation is a good idea (i.e. ABC_EXPJOINT1.py).

Resources

The scripts are available from an installer here:
http://www.pdoteam.com/download/sample-script-installer/
The installer script is available here:
http://www.pdoteam.com/download/custom-script-installer/

Snoop Plant 3D database with PnPTest

By Augusto Goncalves

Plant 3D database is actually a .dcf file, when stored locally. These files are stored at the project folder, at the same location of the Project.xml main file. 

Like other databases, we can read tables with columns and rows. Click here to download it.

Custom Python Scripts for AutoCAD Plant 3D – Part 3

By David Wolfe (Contributor)

Get start with Part 1 and Part 2 of this series.

Expansion Joint Script

This article will look at creating a completely new script, an expansion joint.
The script should look like this:

from varmain.primitiv import *
from varmain.custom import *
 
@activate(Group="Sleeve", TooltipShort="Expansion Joint", TooltipLong="Expansion Joint with Bellows", FirstPortEndtypes="FL", LengthUnit="in",  Ports="2")
@group("MainDimensions")
@param(D=LENGTH, TooltipShort="Pipe OD", TooltipLong="Pipe OD")
@param(D1=LENGTH, TooltipShort="Flange OD", TooltipLong="Flange OD")
@param(D31=LENGTH, TooltipShort="Bellows OD", TooltipLong="Bellows OD")
@param(L=LENGTH, TooltipShort="Length of the ExpansionJoint", TooltipLong="Overall Length of Expansion Joint")
@param(L31=LENGTH, TooltipShort="Flange Thickness", TooltipLong="Flange Thickness")
@param(T=LENGTH, TooltipShort="Bellows thickness", TooltipLong="Thickness of a bellow")
@param(B=LENGTH, TooltipShort="Number of Bolts", TooltipLong="Number of bolts")
@param(B1=LENGTH, TooltipShort="Bolt Size", TooltipLong="Bolt Thickness")
@param(B2=LENGTH, TooltipShort="Bolt Length (greater than L)", TooltipLong="Bolt Length")
@param(OF=LENGTH0)
 
 
#(arxload "PnP3dACPAdapter")
#(testacpscript "EXPJOINT1")
def EXPJOINT1(s, D=4.5, D31=5.5,D1 = 9.0, B=4, B1=0.75, B2=9.5, L=9.0, L31=0.25, T=0.5, K=1, OF=0, **kw ):
    NumOfBellow=round(((L - (2*L31))/ T)/2)-1
    #set a default hole size
    fhole = .95*D   
    #create a hole in the flange
    if OF > 0:
        fhole = (D-OF)
    #create our first flange
    Flange1=CYLINDER(s,R=D1/2, H=L31,O=0).rotateY(90)
    bellowlength = (T*2*NumOfBellow)-1
    nb = 0
    #overall length - belows length / 2 plus 1/4 the width of the bellow
    offset= ((L - bellowlength - (2*L31))/2)+L31
    expBody = CYLINDER(s,R=D31/2,H=L-L31,O=D).rotateY(90).translate((L31,0,0))
    #union the first flange and main body
    Flange1.uniteWith(expBody)
    expBody.erase()
    while (nb < NumOfBellow):       
        #create and offset our torus
        b=TORUS(s,R1=D31/2,R2=T/2).rotateY(90).translate((offset,0,0))
        #increment our offset distance
        offset = offset + T*2
        #union as we go
        Flange1.uniteWith(b)
        b.erase()
        nb = nb +1
    #create our end flange and offset it
    Flange2=CYLINDER(s,R=D1/2, H=L31,O=0).rotateY(90).translate((L - L31,0,0))
    Flange1.uniteWith(Flange2)
    Flange2.erase()
    #see if we need to create bolts, if there is a bolt cound and it's greater than 0
    if B > 1 and B1 > 0 and B2 > L:
        anglesplit = 360/B
        startangle = 0
    if B%2!=0:       
        startangle = anglesplit/2
    intbolt=0
    incangle=startangle
    platewidth=3*B1
    platelength=4*B1
    plateheight= 0.75*L31
    #make the bolts the length of the object + 2 flange thickness
    boltlength = L + 4*L31
    #calculate our offsets
    #plate on flg one offset
    pof1 = (L31 - plateheight/2,D1/2+platewidth/2,0)
    #translate the bolts
    bof1 = (-(B2-L),D1/2+platewidth/2,0)
    #translate the second plate
    pof2 = (L - (L31 - plateheight/2),D1/2+platewidth/2,0)
    #create a cylinder to subtract for the opening
    boreCy = CYLINDER(s,R=fhole/2, H=L,O=0).rotateY(90)
    Flange1.subtractFrom(boreCy)
    boreCy.erase()
    while (intbolt < B):
        #create a plate for the bolt, rotate it, and then move it to the edge and back to face of flange 1
        p = BOX(s,L=platewidth,W=platelength,H=plateheight).rotateX(90).translate(pof1).rotateX(incangle)
        #unite with flange 1 so we have a single body
        Flange1.uniteWith(p)
        p.erase()
        #create the bolt
        b = CYLINDER(s, R=B1/2, H=boltlength,O=0).rotateY(90).translate(bof1).rotateX(incangle)
        #join the flange and bolt
        Flange1.uniteWith(b)
        b.erase()
        #create our plate on flange 2
        p2 = BOX(s,L=platewidth,W=platelength,H=plateheight).rotateX(90).translate(pof2).rotateX(incangle)
        #merge the last plate
        Flange1.uniteWith(p2)
        p2.erase()
        incangle = incangle + anglesplit
        intbolt = intbolt + 1
    return

 

Metadata

The most interesting part of this script, other than the geometry, is the metadata.

 

Note that the group defines where the script shows up in the spec editor.

The tooltips show when the dimensions are hovered over in the editor as well.

Script Testing

While creating the script, you must be able to test it to see if your geometry can be generated.  Because these scripts are designed to be processed within AutoCAD, currently there is no IDE that you can use to debug the shapes. The process of testing the script looks like this.

1. Create your script file at C:\AutoCAD Plant 3D 2016 Content\CPak Common\CustomScripts (or wherever your Shared Content folder is for plant (MODIFYSHAREDCONTENTFOLDER).
2. Create your geometry functions, and metadata sections.
3. Start Plant 3D
4. Use PLANTREGISTERCUSTOMSCRIPTS. If there is an error in the script, you will get a warning at the command line with the line number. For most errors line of the script with the error will be listed.  If no errors are shown, the script compiled.
   
5. Load the PnP3dACPAdapter.arx. You can do this by pasting this at the command line (arxload "PnP3dACPAdapter")
6. Test the script. You can test with the default parameters by pasting this at the command line: (testacpscript "EXPJOINT1"). Fill in your script function where EXPJOINT1 is.
   You can also test the script from one of the other following options:
       (TESTACPSCRIPT "CPFLR")
       (TESTACPSCRIPT "CPFLR" "D1" "300.5")
       (TESTACPSCRIPT "CPFLR" "L" "40" "D1" "300.5" "D2" "88.9")
   Or
       (TESTACPSCRIPT1 "CPFLR")
       (TESTACPSCRIPT1 "CPFLR" "D1=300.5")
       (TESTACPSCRIPT1 "CPFLR" "L=40,D1=300.5,D2=88.9")
7. If you need to make changes, make them before closing Plant. That was you can try to register the script again to see if you still have breaking code.
8. If the script has been changed and registered, you must close Plant 3D in order to test the geometry again. Once the script is registered or run, the Python processor stores that script in memory until Plant 3D is closed, so starting a new session is the only way test new script changes.

Custom Python Scripts for AutoCAD Plant 3D – Part 2

By David Wolfe (Contributor)

Check here the Part 1 of this series.

The first example script is taken from an older Autodesk University class (AU Python PDF). The pdf is available here. Beginning on page 44, the pdf creates a sample script. The script should look like this:

from aqa.math import *
from varmain.primitiv import *
from varmain.custom import *
 
@activate(Group="Support",
 TooltipShort="Test script",
 TooltipLong="This is a custom Testscript", 
 LengthUnit="in",
 Ports=1)
@group("MainDimensions")
@param(D=LENGTH, TooltipShort="Cylinder Diameter", Ask4Dist=True)
@param(L=LENGTH, TooltipLong="Length of the Cylinder")
@param(OF=LENGTH0)
@group(Name="meaningless enum")
@param(K=ENUM)
@enum(1, "align X")
@enum(2, "align Y")
@enum(3, "align Z")
#--------------------------------------------------------
#(arxload "PnP3dACPAdapter")
#(testacpscript "TESTSCRIPT" "D" "4.5" "L" "12")
def TESTSCRIPT(s, D=80.0, L=150.0, OF=-1, K=1, **kw):
    CYLINDER(s, R=D/2, H=L, O=0.0).rotateY(90)

Scripts Parts

There are three sections to this script, the imports section, the metadata section, and the actual shape script.  In addition, you may create functions as needed for your shape generation.

Imports

The imports section lists other python classes and functions that may be used by the current script. In order to avoid having to tell Plant 3D what a cylinder is and how to draw it, we can simpler reference a function (CYLINDER) and use that in our scripts.  The imports section is resolved by the AutoCAD Plant 3D Python interpreter, and as such, doesn’t load into other IDE’s.  The imports shown here are basic ones, but others available in the actual product scripts. Some of the scripts used by Plant 3D are available upon request through ADN.

Metadata

The metadata section instructs the PLANTREGISTERCUSTOMSCRIPTS command how to treat the script being registered. One of the key pieces not shown in the original Python script sample is the number of Ports.  In order for the script to be used in the Spec Editor, the number of ports must be included in the metadata section.

Some of the other parameters referenced in the AU python documentation aren’t used. The image options will be explained in future posts.

Shape Scripts

Before getting into the script portion, notice the comments above the line that starts with def.  In Python, comment rows start with pound signs (#). It’s easier to test your script if you can copy the lines minus the comments to the command line to load the testing adapter, and then call the script with values.

In any case, the def line defines our shape function that will be called to create a script. The registration command looks for the function that matches the script file name.  If you create additional functions to use within your shape script, you must locate them above the script so the script will compile. For example, to use a function called FlangeSizeCalc, you would have to define it first and then reference it lower in the script file.

Shape scripts can get complicated, so you should contact ADN to view samples that work.  In addition the AU Python PDF gives more details on how to move objects and use Boolean operations to get the shape needed.

Finished Script

At the beginning you saw the finished script.  Here is a screenshot of the final product with images being used in the spec editor.

Figure 1: script thumbnail

Figure 2: dimension images and tool tips

Figure 3: register custom script files

Custom Python Scripts for AutoCAD Plant 3D – Part 1

By David Wolfe (Contributor)

In this series of posts, we will cover developing custom python scripts for AutoCAD Plant 3D.

Along with learning about the development environment, we will cover troubleshooting, template scripts, and deployment. The original AU course covering scripts and Plant 3D is available here.

This blog article is going to assume some familiarity with Python.  There are a lot of great resources for learning python on the internet. To get started learning the language syntax I suggest using Code Academy.
This introductory article will start off by covering the basics of:

• Description of the development process
• Programs are necessary for development
• Description of script types

Development Process

Unlike typical development done with .Net languages or even normal Python scripts, there is no integrated IDE for compiling, testing, and debugging.  The compiling is done by running a special command in Plant 3D, and then the scripts are loaded into memory for the AutoCAD session. Since the only way to test changes is to start a new AutoCAD session, the process of troubleshooting
The steps in the development process are:

• Define function(s) for modeling the custom part
• Define the metadata header
• Test the script
• Create the snapshots
• Build a script package (if necessary)
• Deploy the content

Through the rest of the articles, we’ll break down these steps even further so that you have an accurate understanding of the entire process. Along the way we will also develop a few custom scripts to help get you started.

Development Programs

Due to the prevalence of Python, there are many good free editors. Since we are not looking for an IDE (Integrated Development Environment), any of the text editors that highlight the Python syntax will work well.  I’ve used Komodo Edit, but my preference for text editors is TotalEdit Pro (now free).  Again, the main job here is just to color the text. All of the testing of the code will be done in AutoCAD Plant, and there is no debugger to step through.

When building scripts for Equipment, you will need to have a zip program. My personal favorite is 7-zip, as it integrates well with the Windows Explorer right-click menu.

With xml files, you can use Foxe which offers a customizable tree view of the xml beside the xml content with syntax highlighting. Here’s a quick article showing how to customize the tree.

Script Types

Plant 3D uses scripts in a couple different ways, for equipment and also for catalog content.  The scripts get stored in special folders inside the shared content folder.  The two special folders for scripts are:

• C:\AutoCAD Plant 3D 20XX Content\CPak Common\equipment
• C:\AutoCAD Plant 3D 20XX Content\CPak Common\CustomScripts

The paths are above are the default locations. If you are using a shared network location, these folder should be located there. You may have to create the CustomScripts folder as it is not present by default.

If you are going to create an object that will connect to piping, and show as an end connection on the isometric (and is not a nozzle), you should create an equipment script.  Any other type of script will be created as a custom script.

 

 

Equipment Scripts

These basic shapes (primitives) are hard coded into the program, and you cannot add your own routines to this list.

Another type of script is for generating a complete equipment item. For example, the Centrifugal Pump script generates the entire pump, and the user inputs values for the parameters.

Scripts of this type generate the entire equipment item without removable parts.

Synopsis

In this article you learned some high-level information about developing Python scripts for Plant 3D. You learned which program will be used to modify equipment packages and script files, as well as the key locations for developing and testing those files. The next article will describe the parts of a custom script and the custom equipment packages in more detail.

Validate Plant P&ID drawings

By Augusto Goncalves

Inside Plant P&ID we can Validate, via ribbon Home>Validate>Run Validation or right-click on a drawing and select “Validate”. More details here.

Using APIs there is a ValidationSingleton object that has a ValidateDrawings or ValidareProject method. After run this, the Errors property will contain a list of validation errors. Actually there is one class for each type, so you’ll need to cast or, like in the sample below, simply get the error name.

Important: this API method will *only* show the validation errors after you run it via built-in command.

[CommandMethod("validateDrawings")]
public static void CmdValidateDrawings()
{
  Editor ed = Application.DocumentManager.
    MdiActiveDocument.Editor;
 
  // Validation manager
  AcPpValidationManager vmgr = ValidationSingleton.Manager;
 
  // prepare a list of drawings
  AcPpValidationAllOpenedDrawingManager dsd =
    new AcPpValidationAllOpenedDrawingManager();
  foreach (Document doc in Application.DocumentManager)
  {
    dsd.Add(doc.Database);
  }
 
  // clear the list of error 
  // (in case you're running several times)
  vmgr.Errors.Clear();
 
  // the actual validation occurs here
  vmgr.ValidateProject(dsd);
 
  // now check the list of errors
  if (vmgr.Errors.Count > 0)
  {

    AcPpValidationErrorCollection errorList = vmgr.Errors;
    foreach (IAcPpValidationError item1 in errorList)
    {
      // can be classes from namespace
      // Autodesk.ProcessPower.PnIDDwgValidation          
 
 
      // for now, let's write the error class name
      ed.WriteMessage("\n{0}", 
        item1.GetType().Name.PascalCaseToText());
    }
  }
}

// nice sample Regular expression from here. 
public static string PascalCaseToText(this string text)
{
  return System.Text.RegularExpressions.Regex.Replace(
    text, "([a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))", "$1 ");
}

Track value change on Plant 3D Database

By Augusto Goncalves

On AutoCAD entities we cannot track changes, although we can simulate some sort of tracking mechanism, see this blog post. So if you need to track geometric properties, like position, you’ll probably need something as described.

Now on Plant 3D there is a actual database storing information: the PnPDatabase, which includes a list of tables (PnPTable), that represent the classes. And there are some interesting events, such as ColumnChanged event.

Below is a sample that uses this event to track changes on database values (in this case, the Manufacturer) of EngineeringItems.

[CommandMethod("trackTableChanges")]
public static void CmdTrackChanges()
{
  TrackDBTableChanges(
    "EngineeringItems",
    new string[] { "Manufacturer" });
}
 
private static void TrackDBTableChanges(
  string tableName, string[] columns)
{
  PlantProject currentProj =
    PlantApplication.CurrentProject;
  PipingProject pipeProj =
    (PipingProject)currentProj.ProjectParts["Piping"];
  DataLinksManager dlm = pipeProj.DataLinksManager;
  PnPDatabase db = dlm.GetPnPDatabase();
 
  // the table we want to track
  PnPTable engItemsTable = db.Tables[tableName];
 
  // just the columns we want to track
  _collunsToTrack = new List<string>(columns);
 
  // start tracking
  engItemsTable.ColumnChanged +=
    engItemsTable_ColumnChanged;
}
 
private static List<string> _collunsToTrack = null;
 
static void engItemsTable_ColumnChanged
  (object sender, PnPColumnChangeEventArgs e)
{
  // filter by column name
  if (!(_collunsToTrack.Contains(e.Column.Name))) return;
 
  // simple output
  Application.DocumentManager.MdiActiveDocument.
    Editor.WriteMessage(
    "{0} of item {1} changed from {2} to {3}",
    e.Column.Name, e.Row.RowId,
    e.CurrentValue, e.ProposedValue);
}

Mimic Line Number > New feature on Plant 3D

By Augusto Goncalves

This post is actually inspired on create a new line group previous post, but with some changes. This will actually mimic the Line Number >> New >> Assign Tag feature on Plant 3D.

First, remove previous group related to the pipe, in order to avoid belong to more than one line group, which can be a modeling error. Second, just make the code simpler to include on your code. Note this will run for individual pipe making each pipe into a different line group (therefore different ISO production from each of them), you may adjust to a group of pipes.

private static void CreateNewTag(ObjectId partId, string newTagValue)
{
  PlantProject currentProj = PlantApplication.CurrentProject;
  PipingProject pipeProj = (PipingProject)currentProj.ProjectParts["Piping"];
  DataLinksManager dlm = pipeProj.DataLinksManager;
  PnPDatabase db = dlm.GetPnPDatabase();
 
  PnPTable p3dLineGroupTable = db.Tables["P3dLineGroup"];
  PnPRow lgRow = p3dLineGroupTable.NewRow();
  lgRow["Tag"] = newTagValue;
  p3dLineGroupTable.Rows.Add(lgRow);
 
  int prRowId = dlm.FindAcPpRowId(partId);
  PnPRow prRow = db.GetRow(prRowId); // not used yet
 
  // remove all line groups already related 
  // to this pipe, if any, to avoid this pipe
  // belong to multiple line groups
  PnPRowIdArray priorGroupIds = dlm.GetRelatedRowIds(
    "P3dLineGroupPartRelationship", "Part",
    prRowId, "LineGroup");
  if (priorGroupIds.Count != 1)
  {
    foreach (int id in priorGroupIds)
    {
      dlm.Unrelate("P3dLineGroupPartRelationship",
        "LineGroup", id, "Part", prRowId);
    }
  }
 
  // make the relation
  if (lgRow.RowId != -1 && prRowId != -1)
  {
    dlm.Relate("P3dLineGroupPartRelationship",
      "LineGroup", lgRow.RowId, "Part", prRowId);
  }

}

And here is a simple command to invoke this routine

[CommandMethod("customNewTag")]
public static void CmdCustomNewTag()
{
  Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
 
  PromptEntityOptions peo = new PromptEntityOptions("\nSelect pipe: ");
  peo.SetRejectMessage("\nOnly pipes");
  peo.AddAllowedClass(typeof(Pipe), true);
  PromptEntityResult per = ed.GetEntity(peo);
  if (per.Status != PromptStatus.OK) return;
 
  PromptResult pr = ed.GetString("\nEnter new tag: ");
  if (pr.Status != PromptStatus.OK) return;
 
  CreateNewTag(per.ObjectId, pr.StringResult);
}