Process and Operation Taxonomy

Taxonomy modules contain the heart of a cost model’s logic. They calculate the costs in various categories (such as tooling costs, labor costs, and overhead costs), associated with performing a process or operation. In order to calculate costs, these modules calculate times (such as cycle times), material utilization, and other physical and monetary quantities. The outputs of a taxonomy module are specified in the module’s associated formula table (see Navigating to the Data for a Given Node), and are presented in aPriori ’s Part Details tab.

The Site Cost Model taxonomy file (see Root and Site Cost Model Formulas in the Cost Model Guide) aggregates the costs across processes, for presentation in aPriori Cost Summary, Part Details, Investment tabs. Each process or operation aggregates the costs and other physical quantities across its children in the process-operation hierarchy (for example, by using the CSL standard input childOps).

This section includes the following subsections:

Context of Evaluation

Process taxonomy modules are evaluated for each feasible process in the context of a particular stock selection, process routing, and machine selection. A routing’s process taxonomy modules are evaluated after costing of all the routing’s descendent operations.

Operation taxonomy modules are evaluated (if present) for each feasible operation in the context of a particular stock selection, process routing, machine selection, GCD, operation sequence, and tool selection. Costing proceeds in a bottom-up fashion; an operation’s taxonomy module is evaluated after costing of all the operation’s descendant operations. That way, an operation taxonomy module can access the results of the modules associated with its children in the process-operation hierarchy, in order, for example, to aggregate their costs.

Example

Below is a taxonomy module portion for the Bar&Tube operation that creates a simple hole with a tube laser. This portion calculates the output cycleTime, the time required for creation of a simple hole. The main formula sums three quantities:

  • holeRapidTraverseTime: Time required for positioning the part so that the machine’s laser is directed at a point along the desired location for the hole’s perimeter. Calculated based on the average distance between holes and the current machine’s feed rate (machine.tubeAxialBarFeedRate).

  • holePierceTime: Time required for the initial penetration of the part through the stock’s entire thickness. Obtained from a lookup table, based on material, machine power, and part thickness. If the part is thicker than maximum thickness handled by the lookup table, a failure message is issued, and the table’s longest pierce time is used.

  • holeCutTime: Cutting along the perimeter of the hole, starting and ending at the pierce location. Calculated based on the hole circumference and machine feed rate. The machine’s small feature feed rate is used for holes that are considered small features as determined by machine attributes and hole radius; the machine’s large feature feed rate us used otherwise.

Here is the code:

Copy 
cycleTime = cycleTimePerOp
 
cycleTimePerOp = holeRapidTraverseTime + holePierceTime + holeCutTime  //secs
                                                                
holeRapidTraverseTime = _
    (averageDistanceBetweenHoles / machine.tubeAxialBarFeedRate) //secs
 
averageDistanceBetweenHoles = divZero( part.minStockLength, numHoles )  
 
numHoles = _
    select count(a) from part.childArtifacts a where _
            a.artifactType.name=='SimpleHole' or _
                a.artifactType.name=='ComplexHole' or _
                    a.artifactType.name=='MultiStepHole'
 
holePierceTime = pierceTime 
 
smallFeatureRadius = max( _
    machine.smallFeatureFeedRadius, _
    machine.smallFeatureThicknessRatio * part.crossSection.thickness _
)
 
perimeter = gcd.perimeter
holeRadius = gcd.diameter / 2 
 
holeCutTime = { _
    (perimeter * secsPerMin /feedRateLargeFeatures) if _
            (holeRadius > smallFeatureRadius)
    (perimeter * secsPerMin / feedRateSmallFeatures) otherwise _
}
 
// Get pierce time depending on material composition and type
pierceTime = { _
    cutRateEntry.pierceTime if cutRateEntry != null 
    fail(msg(FLT, 'Cutting rate not available for the selected material, _
            ', material.name, _
            ' , in tubeLaserCutting table.',     FRT)) _
            if cutRateEntry == null and useSlowestEntry == null
    useSlowestEntry.pierceTime otherwise _
} //secs units

 

The code uses the following predefined functions:

  • divZero: Returns the quotient of the arguments; return 0 if the second argument is 0.

  • max: Returns the larger of the arguments.

  • fail: Halts evaluation, causes costing to fail, and issues a failure message to the aPriori message pane.

 

The code uses the following auxiliary formulas:

  • numHoles, the number of holes (used together with part.minStockLength to calculate the average distance between holes) is determined with a query that counts the number of each type of hole (not just simple holes).

  • smallFeatureRadius (used to determine the cutoff between large and small features) is the larger of the following:

    • Machine attribute smallFeatureRadius

    • Product of the machine attribute smallFeatureThicknessRatio and the thickness attribute of the part cross section

Code not shown above uses the lookup table tubeLaserCutting to retrieve the table entries cutRateEntry and useSlowestEntry.

To access this operation’s cycle time results (along with the times for other operations), the laser cutting process taxonomy file uses the following formula:

sumOpsCycleTime = select sum(operation.cycleTime) from childOps operation

Here, childOps is a CSL standard input whose value is the collection the current process’s children in the process operation hierarchy. Each element of the collection has a field for each output of the element’s associated CSL modules. The query designates the sum of the cycle times calculated by each child operation’s taxonomy module.