John Cox

Hello, this sounds like a good use case for Seeq. I suggest you sign up for an upcoming Office Hours time slot: Seeq Office Hours

In the Office Hours session, you can share your screen and an Analytics Engineer can assist with these questions. 

Thanks for the update. As additional information, I confirmed that currently, even though you see the scroll wheel in Organizer when hovering over the y-axis, it is not possible to change the y-axis scale from within the view in Organizer (no matter if you have view only or full edit access). If you would like, I can create a support ticket for you in our system, this is a "feature request" that other customers have asked for. Creating a support ticket would have 2 benefits: increases the likelihood it gets worked on by our team and automatically notifies you when the new feature is made available. Let me know if you'd like me to create a ticket for you - if yes, then email me at john.cox@seeq.com with your name and company name. 

Hello KantianKinetics,

I agree that you should be able to adjust the Y-axis in view-only mode, but even if you were able to do so, those changes are only temporary and would not carry over to the Organizer. The person with edit access would have to change the axis for you to be able to see the updated axis in your Organizer, AND you would have to click on "Update from worksheet" from within Organizer for the axis changes to update in your Organizer view. I hope this helps!

Hello Francesco, 
If this issue has not been resolved, I'd recommend you sign up for an upcoming Seeq Office Hours (link) where a Seeq analytics engineer can get more information and help determine a path forward. 

 

Hello,

Notifications are sent when the capsule is detected (allowing for the 15 minute default or other chosen "check for new capsules" frequency time window). So, at the point in time that the capsule forms (which can be complex logic depending on other signals or conditions involved), you should receive a notification within 15 minutes or within whatever the "check for new capsules" time setting is. The notification does not wait until the capsule closes. 

Hello Learning_in_progress,

I have a few suggestions for you to try. After trying these suggestions, if you need additional help, please sign up for an upcoming Seeq Office Hours (link) where a Seeq analytics engineer can help with your remaining questions. Here are my suggestions:

1. Create a new signal which is the maximum of the blue and green signals, using this formula:

$signal1.max($signal2)

2. An easier way to create capsules for each change in the step signal is to use this formula, or the "Condition with Properties" tool located under Identify in Workbench:

$StepSignal.toCondition()

3. To get the maximum value of the 2 signals over each step capsule, use the result from suggestion #1 above as "MaxOfTwoSignals" in the formula shown below. Also, if you use durationKey() instead of maxKey() as shown below, you should get a result which matches with the original step signal. 

$MaxOfTwoSignals.aggregate(maxValue(), $StepCapsules.removeLongerThan(5d), durationKey()).toStep()

Hello,

This is the approach I suggest:

1. Create a new formula for "Weight of Bag Being Packed" using your existing 25kg, 50lb, and 46 lb conditions. I converted 25kg to lbs as the "default weight" but you can do this however is best, and use kg or lbs as desired (I used lbs):

// Default to 25 kg and substitute in other weights when those conditions are present

(55.12).splice(50,$FiftyLbCondition).splice(46,$FortySixLbCondition)

2. Calculate "Amount Packed" with a new formula, using the result from step 1:

// use .max(0) in case the bag counter ever resets

($BagCounterSignal.runningDelta().max(0))*$WeightBagBeingPacked

3. Calculate the "Daily Running Sum of Amount Packaged" with a new formula, using a daily condition and the result from step 2:

$AmountPacked.runningSum($DailyCondition)

Hi David, 

There have been significant OData export enhancements in the R62-R64 versions of Seeq, related to performance, export options, managing exports, etc. (more here at the What's New link). 

If you are wanting to do a single OData Export to Power BI across all assets, the approach outlined above may still be your best option (and note that the formulas can be created programmatically using Data Lab).

Before going down that path though, I would strongly recommend you sign up for an upcoming Office Hours slot and discuss the export use case details with a Seeq Analytics Engineer - there may be other options to consider. 

The correlationOffset() Formula function can be a useful tool for identifying the time shift which maximizes the correlation between two signals: see this post for additional background. In some situations, a user will have a condition defined for time periods of interest (startups, process runs, specific product grades, specific modes of operation, etc.). The user then wants to analyze how the correlation offset varies for each time period of interest (each capsule in the condition). The key to this calculation is applying the transform() function to the condition in Seeq Formula, in combination with the correlationOffset() function. 

Let's say we have a temperature sensor in a reactor. At some point, well downstream of this temperature measurement, we have a relative humidity sensor that is sensing the same volume of air, but due to the locations of the two sensors, we know that the inverse correlation between the two signals is offset by a significant amount of time delay (at least 2 hours, as visually estimated with the dashed regions in the trend below).

 

As a reminder, for this use case, the objective is to calculate the correlation offset separately for the data contained within each capsule in a condition of interest (shown as Time Periods to Calculate Correlation in the trend below):

 

The formula approach for this is shown below, with comments to describe the details. The transform() function enables the correlationOffset() function to be applied separately to each capsule in the Time Periods to Calculate Correlation condition, and the correlation offset time is stored as a capsule property of the condition generated by the formula:

 

The resulting calculated offset (in units of seconds) is shown in the capsules pane at the lower right and also at the top of the screen as labels. Optionally, the "Offset" capsule property can be converted to a signal (see Max Correlation Offset in lane 2) for trending purposes, and here the units were converted to hours. Looking at the final results, the time shift which maximizes the correlation between the 2 signals varies between 2.1 and 2.5 hours over the 3 time periods of interest shown in chain view, and this variation may offer valuable insights to the user. The time shift is a negative value which means that the relative humidity (downstream signal) would need to be shifted to the left by that time amount to maximize its correlation with the temperature signal. 

 

This is the formula to create a signal for the max correlation offset, based on the "Offset" capsule property. In this example the time shift is more meaningful in units of hours, so we convert from seconds to hours:

 

Note that in this use case we wanted to calculate the correlation offset separately for each capsule in a condition. If the goal is to calculate the correlation offset over rolling window time periods, there are other functions in Formula expressly for this purpose, such as CrossCorrelations_timeShifts(). 

Hi Lucas,

In a future version of Seeq, pivot table functionality will enable you to easily create the tables you want, and you could do a table sort to see the top 5, but it would not quite allow you to filter to only the top 5. 

In the current version of the software, here are some options to consider, depending on the details of your analysis and how many different types of machine alarms are possible. 

1. You could use the Histogram tool in Workbench, along with your condition with properties that has the alarm description as a capsule property, to create count of alarms and duration of alarms histograms. This would be very quick/easy to do, but will of course show ALL alarms that have occurred and without pareto sorting, and the results are not in tabular form. 

2. If the number of potential alarm descriptions is relatively low and you don't expect new descriptions to be added in the future, you could manually create conditions representing each unique alarm description (via the .keep() function in Formula, using your existing condition with properties). Then you could create a table of counts and a table of durations for each of the created alarm description conditions, sort the table, etc. It will not limit the table results to the top 5, but you could filter the table based on count and duration to limit the rows displayed. 

3. Pull the alarm signal into Seeq Data Lab using the Spy.pull() function, and create your desired tables using Python code. 

Seeq's .inverse() Formula function creates a new condition that is the inverse of the capsules of another condition. It is often used for identifying time periods between the capsules in an event related condition. For example, a user may create an "event" condition which represents equipment changes or maintenance events, and they then want to quantify the time duration in between the events, as well as the time elapsed from the last event to the current time. It may be important to statistically analyze the historical time between events, or they may want to be notified if the time since the most recent event exceeds some guideline value. 

A common and possibly confusing issue encountered by users is that the most recent "Time Since...." capsule (created with $EventCondition.inverse()) may extend indefinitely into the future, making it impossible to quantify the time elapsed from the last event to the current time. This issue is easily resolved with the approach shown in step 3 in the example below.

1. The user already has an event condition created named "Filter Changes", which represents maintenance events on a process filter which removes particulates. The user wants to monitor the time elapsed between filter changes and therefore creates a "Time Since Filter Change" condition using $FilterChanges.inverse():

2. Signal from Condition is used to create the "Calculated Time Since Filter Change" signal, and the user chooses to place the result at the end of each capsule. Because the most recent capsule in the "Time Since Filter Change" condition extends past the current time and indefinitely into the future, the duration of that capsule can't be quantified (and it of course exceeds any specified maximum capsule duration). The user may be confused by the missing data point for the signal (see the trend screenshot below), and the missing value is an important result needed for monitoring.

 

3. The issue is easily resolved by clipping the most recent "Time Since Filter Change" capsule at the current time by adding .intersect(past()) to the Formula. This ensures the most recent "time since" capsule will not extend past the current time, by intersecting it with the "past" capsule. The "Calculated Time Since Filter Change" signal (lane 3 in screenshot, based on the clipped condition) updates dynamically as time moves forward, giving the user near real time information on the time elapsed. 

 

Hi Ivan,

It's also possible that this is related to a software bug in version 61. This bug is fixed in future versions (starting in R64), but in the event you are falling victim to that same bug, here is a quick workaround you can try. It may or may not help, but is something you can try quickly. Basically you need to apply a .round(12) to each numeric signal used in the Formula, prior to the .setProperty functionality:

$rounded_co = $co.round(12)
$rounded_o2 = $o2.round(12)
$condition.setProperty('CO (minimum)', $rounded_co, minValue())
                        .setProperty('CO (maximum)', $rounded_co, maxValue())
                        .setProperty('O2 (minimum)', $rounded_o2, minValue())
                        .setProperty('O2 (maximum)', $rounded_o2, maxValue()) 

Hi Ivan,

I would suggest clearing the cache on all the raw signals and conditions that are inputs to your Formula, as well as clearing cache on the Formula itself. You can clear the cache on an item using Item Properties in the Details Pane ("Clear Cached Values" under the Advanced section).

If this does not resolve the issue, I would suggest making an Office Hours appointment, so that a Seeq analytics engineer can assist you further: https://info.seeq.com/office-hours

Hi Marcelo,

I'll add a few suggestions below, but I would most recommend you sign up for an upcoming Seeq Office Hours where you can work through the calculations with a Seeq Analytics Engineer: https://info.seeq.com/office-hours

If you simply want to count regenerations, you could do a running sum of your regeneration signal over a specified time period or a Periodic Condition. If you want to break the sum into groups of 3, you could divide the running sum by 3 and look for time periods where the result is an integer. 

If you already have a cleanup condition, it would be easy to identify all the cleanup events (capsules) when a cleanup is performed and the number of regenerations just before the cleanup is not equal to 3. You could do this by doing a running sum of regenerations based on a condition that is the time between cleanups (which would be $Cleanups.inverse()). 

It is also possible that the Formula functions below may be useful to you, as they allow you to focus on a specific number of recent sample values or capsules. 

Hi Marcelo,

I am not certain I understand but I think you want to count the number of regenerations in between each "cleanup". If this is the case then you likely need to define a condition for when "cleanups" actually occur, and then you can create a condition for "time in between cleanups" using the .inverse() Formula function (there are several relatively easy you might find the "time in between cleanups"). Once you have the condition for "time in between cleanups", then a runningSum() Formula function would be one way to count the current number of regenerations. 

I'm happy to try to help iterate with your solution here on the forum, but because I'm not certain about the calculations you want to do, the most efficient way to get a solution for your questions would be to sign up for an upcoming Seeq Office Hours where you can share your screen and get help: https://info.seeq.com/office-hours

John

Hi Ross,

The same approach should work when dealing with string signals. This sounds like a potential bug that I would suggest you create a support ticket for by going to https://support.seeq.com/, then clicking on Support Portal in the lower right, then creating an "Analytics Help" support ticket. When investigating the support ticket, Seeq support will also try to determine if there is an alternate approach that will eliminate the Treemap error. 

As a much easier alternative to having to manage string delimiters, apostrophe escape characters, line continuation characters, etc. with the approach above, Python offers a multiline string literal feature (3 double or single quotes). We use this approach below (note the 3 double quotes on code lines 6 and 14). We also use the textwrap.dedent() function (link) to nicely indent our code without indenting the final result in Workbench. This alternate approach is much easier to code as well as being more readable on the Data Lab side.  

When pushing Formulas to Workbench from Data Lab, you can use "\" and "\n" in a few different ways in the Data Lab code, to create a nicely formatted, multi-line Formula in Workbench:

• For the Formula pushed to Workbench, a \n can be used for a line return. This is valuable for creating multi-line Formulas with intermediate variable assignments, or for making lengthy, single lines of code more readable. 
• For the Formula pushed to Workbench, a \ can be used just before a single quote, when you need to include a single quote in the Formula. This helps for example when working with string signals.
• On the Data Lab side, using a \ at the end of the line continues the code to the next line, helping with readability in Data Lab. 

These are illustrated in the Data Lab code below which pushes a condition Formula to Workbench:

 

Editing the Formula in Workbench, the Formula appears as we desired:

Proportional-integral-derivative (PID) control loops are essential to the automation and control of manufacturing processes and are foundational to the financial gains realized through advanced process control (APC) applications. Because poorly performing PID controllers can negatively impact production capacity, product quality, and energy consumption, implementing controller performance monitoring analytics leads to new data-driven insights and process optimization opportunities.

The following sections provide the essential steps for creating basic controller performance monitoring at scale in Seeq. More advanced CLPM solutions can be implemented by expanding the standard framework outlined below with additional metrics, customization features, and visualizations. Data Lab’s Spy library functionality is integral to creating large scale CLPM, but small scale CLPM is possible with no coding, using Asset Groups in Workbench. Key steps in creating a CLPM solution include:

1. Controller asset tree creation
2. Developing performance metric calculations and inserting them in the tree as formulas
3. Calculating advanced metrics via scheduled Data Lab notebooks (if needed)
4. Configuring asset scaled and individual controller visualizations in Seeq Workbench
5. Setting up site performance as well as individual controller monitoring in Seeq Organizer

Using these steps and starting from only the controller signals within Seeq, large scale CLPM monitoring can be developed relatively quickly, and a variety of visualizations can be made available to the manufacturing team for monitoring and improving performance. As a quick example of many end result possibilities, this loop health treemap color codes controller performance (green=good, yellow=questionable, red=poor):

 

The key steps in CLPM implementation, summarized above, are detailed below. Note: for use as templates for development of your own CLPM solution, the associated Data Lab notebooks containing the example code (for Steps 1-3) are included as file attachments to this article. The code and formulas described in Steps 1-3 can be adjusted and expanded to customize your CLPM solution as desired.

 

Example CLPM Solution: Detailed Steps

 

STEP 1: Controller asset tree creation

An asset tree is the key ingredient which enables scaling of the performance calculations across a large number of controllers. The desired structure is chosen and the pertinent controller tags (typically at a minimum SP, PV, OP and MODE) are mapped into the tree. For this example, we will create a structure with two manufacturing sites and a small number of controllers at each site. In most industrial applications, the number of controllers would be much higher, and additional asset levels (departments, units, equipment, etc.) could of course be included.

We use SPy.trees functionality within the Data Lab notebook to create the basic structure:

 

Controller tags for SP, PV, OP, and MODE are identified using SPy.search. Cleansed controller names are extracted and inserted as asset names within the tree:

 

Next, the controller tags (SP, PV, OP, and MODE), identified in the previous Data Lab code section using SPy.search, are mapped into the tree. At the same time, the second key step in creating the CLPM solution, developing basic performance metrics and calculations using Seeq Formula and inserting them into the asset tree, is completed. Note that in our example formulas, manual mode is detected when the numerical mode signal equals 0; this formula logic will need to be adjusted based on your mode signal conventions. While this second key step could be done just as easily as a separate code section later, it also works nicely to combine it with the mapping of the controller tag signals:

 

STEP 2: Developing performance metric calculations and inserting them in the tree as formulas

Several key points need to be mentioned related to this step in the CLPM process, which was implemented using the Data Lab code section above (see previous screenshot).

There are of course many possible performance metrics of varying complexity. A good approach is to start with basic metrics that are easily understood, and to incrementally layer on more complex ones if needed, as the CLPM solution is used and shortcomings are identified. The selection of metrics, parameters, and the extent of customization for individual controllers should be determined by those who understand the process operation, control strategy, process dynamics, and overall CLPM objectives. The asset structure and functionality provided with the Data Lab asset tree creation enables the user to implement the various calculation details that will work best for their objectives.

Above, we implemented Hourly Average Absolute Controller Error (as a percentage based on the PV value) and Hourly Percent Span Traveled as basic metrics for quantifying performance. When performance is poor (high variation), the average absolute controller error and percent span traveled will be abnormally high. Large percent span traveled values also lead to increased control valve maintenance costs. We chose to calculate these metrics on an hourly basis, but calculating more or less frequently is easily achieved, by substituting different recurring time period functions in place of the “hours()” function in the formulas for Hourly Average Absolute Controller Error and Hourly Percent Span Traveled.

The performance metric calculations are inserted as formula items in the asset tree. This is an important aspect as it allows calculation parameters to be customized as needed on an individual controller basis, using Data Lab code, to give more accurate performance metrics. There are many customization possibilities, for example controller specific PV ranges could be used to normalize the controller error, or loosely tuned level controllers intended to minimize OP movement could be assigned a value of 0 error when the PV is within a specified range of SP.

The Hourly Average Absolute Controller Error and Hourly Percent Span Traveled are then aggregated into an Hourly Loop Health Score using a simple weighting calculation to give a single numerical value (0-100) for categorizing overall performance. Higher values represent better performance. Another possible approach is to calculate loop health relative to historical variability indices for time periods of good performance specified by the user.

The magnitude of a loop health score comprised of multiple, generalized metrics is never going to generate a perfect measure of performance. As an alternative to using just the score value to flag issues, the loop health score can be monitored for significant decreasing trends to detect performance degradation and report controller issues.

While not part of the loop health score, note in the screenshot above that we create an Hourly Percent Time Manual Mode signal and an associated Excessive Time in Manual Mode condition, as another way to flag performance issues – where operators routinely intervene and adjust the controller OP manually to keep the process operating in desired ranges. Manual mode treemap visualizations can then be easily created for all site controllers.

With the asset tree signal mappings and performance metric calculations inserted, the tree is pushed to a Workbench Analysis and the push results are checked:

 

STEP 3: Calculating advanced metrics via scheduled Data Lab notebooks (if needed)

Basic performance metrics (using Seeq Formula) may be all that are needed to generate actionable CLPM, and there are advantages to keeping the calculations simple. If more advanced performance metrics are needed, scheduled Data Lab notebooks are a good approach to do the required math calculations, push the results as signals into Seeq, and then map/insert the advanced metrics as items in the existing asset tree. There are many possibilities for advanced metrics (oscillation index, valve stiction, non-linearity measures, etc.), but here as an example, we calculate an oscillation index and associated oscillation period using the asset tree Controller Error signal as input data. The oscillation index is calculated based on the zero crossings of the autocorrelation function. Note: the code below does not account for time periods when the controller is in manual, the process isn’t running, problems with calculating the oscillation index across potential data gaps, etc. – these issues would need to be considered for this and any advanced metric calculation.   

 

Initially, the code above would be executed to fill in historical data oscillation metric results for as far back in time as the user chooses, by adjusting the calculation range parameters. Going forward, this code would be run in a recurring fashion as a scheduled notebook, to calculate oscillation metrics as time moves forward and new data becomes available. The final dataframe result from the code above looks as follows:

 

After examining the results above for validity, we push the results as new signals into Seeq Workbench with tag names corresponding to the column names above. Note the new, pushed signals aren’t yet part of the asset tree:

 

There are two additional sections of code that need to be executed after oscillation tag results have been pushed for the first time, and when new controller tags are added into the tree. These code sections update the oscillation tag metadata, adding units of measure and descriptions, and most importantly, map the newly created oscillation tags into the existing CLPM asset tree:

 

STEP 4: Configuring asset scaled and individual controller visualizations in Seeq Workbench

The CLPM asset tree is now in place in the Workbench Analysis, with drilldown functionality from the “US Sites” level to the signals, formula-based performance metrics, and Data Lab calculated advanced metrics, all common to each controller:

 

The user can now use the tree to efficiently create monitoring and reporting visualizations in Seeq Workbench. Perhaps they start by setting up raw signal and performance metric trends for an individual controller. Here, performance degradation due to the onset of an oscillation in a level controller is clearly seen by a decrease in the loop health score and an oscillation index rising well above 1:

 

There are of course many insights to be gained by asset scaling loop health scores and excessive time in manual mode across all controllers at a site. Next, the user creates a sorted, simple table for average loop health, showing that 7LC155 is the worst performing controller at the Beech Island site over the time range:

 

The user then flags excessive time in manual mode for controller 2FC117 by creating a Lake Charles treemap based on the Excessive Time in Manual Mode condition:

 

A variety of other visualizations can also be created, including controller data for recent runs versus current in chain view, oscillation index and oscillation period tables, a table of derived control loop statistics (see screenshot below for Lake Charles controller 2FC117) that can be manually created within Workbench or added later as items within the asset tree, and many others.

 

Inspecting a trend in Workbench (see screenshot below) for a controller with significant time in manual mode, we of course see Excessive Time in Manual Mode capsules, created whenever the Hourly Percent Time Manual Mode was > 25% for at least 4 hours in a row. More importantly, we can see the effectiveness of including hours().intersect($Mode!=0) in the formulas for Hourly Average Absolute Controller Error and Hourly Percent Span Traveled. When the controller is in manual mode, that data is excluded from the metric calculations, resulting in the gaps shown in the trend. Controller error and OP travel have little meaning when the controller is in manual, so excluding data is necessary to keep the metrics accurate. It would also be very easy to modify the formulas to only calculate metrics for hourly time periods where the controller was in auto or cascade for the entire hour (using Composite Condition and finding hourly capsules that are “outside” manual mode capsules). The ability to accurately contextualize the metric calculations, to the time periods where they can be validly calculated, is a key feature in Seeq for doing effective CLPM implementations. Please also refer to the “Reminders and Other Considerations” section below for more advanced ideas on how to identify time periods for metric calculations.

 

STEP 5: Setting up site performance as well as individual controller monitoring in Seeq Organizer

As the final key step, the visualizations created in Workbench are inserted into Seeq Organizer to create a cohesive, auto-updating CLPM report with site overviews as well as individual controller visuals. With auto-updating date ranges applied, the CLPM reports can be “review ready” for recurring meetings. Asset selection functionality enables investigative workflows: poorly performing controllers are easily identified using the “Site CLPM” worksheet, and then the operating data and metrics for those specific controllers can be quickly investigated via asset selection in the site’s “Individual Controllers” worksheet – further details are described below.

An example “Site CLPM” Organizer worksheet (see screenshot below) begins with a loop health performance ranking for each site, highlighting the worst performing controllers at the top of the table and therefore enabling the manufacturing team to focus attention where needed; if monitoring hundreds of controllers, the team could filter the table to the top 10 or 20 worst performing controllers. The visualizations also include a treemap for controllers that are often switched to manual mode – the team can talk to operators on each crew to determine why the controllers are not trusted in auto or cascade mode, and then generate action items to resolve. Finally, oscillating controllers are flagged in red in the sorted Oscillation Metrics tables, with the oscillation period values also sorted – short oscillation periods may prematurely wear out equipment and valves due to high frequency cycling; long oscillation periods are more likely to negatively impact product quality, production rate, and energy consumption. Controllers often oscillate due to root causes such as tuning and valve stiction and this variability can often be eliminated once an oscillating controller has been identified. The oscillation period table can also be perused for controllers with similar periods, which may be evidence of an oscillation common to multiple controllers which is generating widespread process variation.

 

An example “Individual Controllers” Organizer worksheet is shown below, where detailed operating trends and performance metrics can be viewed for changes, patterns, etc., and chain view can be used to compare controller behavior for the current production run versus recent production runs.  Other controllers can be quickly investigated using the asset selection dropdown, and the heading labels (e.g., Beech Island >> 7LC155) change dynamically depending on which controller asset is selected. For example, the Beech Island 7LC155 controller which was identified as the worst performing controller in the “Site CLPM” view above, can be quickly investigated in the view below, where it is evident that the controller is oscillating regularly and the problem has been ongoing, as shown by the comparison of the current production run to the previous two runs:

 

 

Reminders and Other Considerations

 As evident with the key steps outlined above, a basic CLPM solution can be rapidly implemented in Seeq. While Seeq’s asset and contextualization features are ideal for efficiently creating CLPM, there are many details which go into developing and maintaining actionable CLPM dashboards for your process operation. A list of reminders and considerations is given below.

1. For accurate and actionable results, it is vital to only calculate performance metrics when it makes sense to do so, which typically means when the process is running at or near normal production rates. For example, a controller in manual during startup may be expected and part of the normal procedure. And of course, calculating average absolute controller error when the process is in an unusual state will likely lead to false indications of poor performance. Seeq is designed to enable finding those very specific time periods when the calculations should be performed. In the CLPM approach outlined in this article, we used time periods when the controller was not in manual by including hours().intersect($Mode!=0) in the formulas for Hourly Average Absolute Controller Error and Hourly Percent Span Traveled. When the controller is in manual mode, that data is excluded from the metric calculations. But of course, a controller might be in auto or cascade mode when the process is down, and there could be many other scenarios where only testing for manual mode isn’t enough. In the CLPM approach outlined above, we intentionally kept things simple by just calculating metrics when the controller was not in manual mode, but for real CLPM implementations you will need to use a more advanced method. Here are a few examples of finding “process running” related time periods using simple as well as more advanced ways. Similar approaches can be used with your process signals, in combination with value searches on controller mode, for excluding data from CLPM calculations:

• A simple Process Running condition can be created with a Value Search for when Process Feed Flow is > 1 for at least 2 hours.
• A 12 Hours after Process Running condition can be created with a formula based on the Process Running Condition: $ProcessRunning.afterStart(12hr)
• A Process Running (> 12 hours after first running) condition can then be created from the first two conditions with the formula: $ProcessRunning.subtract($TwelveHrsAfterRunning)
• Identifying time periods based on the value and variation of the production rate is also a possibility as shown in this Formula:

 

The conditions described above are shown in the trends below:

 

2. As previously mentioned, including metric formulas and calculations as items within the asset tree enables customization for individual controllers as needed, when controllers need unique weightings, or when unique values such as PV ranges are part of the calculations. It may also be beneficial to create a “DoCalcsFlag” signal (0 or 1 value) as an item under each controller asset and use that as the criteria to exclude data from metric calculations. This would allow customization of “process is running normally and controller is not in manual” on an individual controller basis, with the result common for each controller represented as the “DoCalcsFlag” value.

3. In the CLPM approach outlined above, we used SPy.trees in Data Lab to create the asset tree. This is the most efficient method for creating large scale CLPM. You can also efficiently create the basic tree (containing the raw signal mappings) from a CSV file. For small trees (<= 20 controllers), it is feasible to interactively create the CLPM asset tree (including basic metric calculation formulas) directly in Workbench using Asset Groups. The Asset Groups approach requires no Python coding and can be quite useful for a CLPM proof of concept, perhaps focused on a single unit at the manufacturing site. For more details on Asset Groups: https://www.seeq.org/index.php?/forums/topic/1333-asset-groups-101-part-1/).

4. In our basic CLPM approach, we scoped the CLPM asset tree and calculations to a single Workbench Analysis. This is often the best way to start for testing, creating a proof of concept, getting feedback from users, etc. You can always decide later to make the CLPM tree and calculations global, using the SPy.push option for workbook=None.

5. For long-term maintenance of the CLPM tree, you may want to consider developing an add-on for adding new controllers into the tree, or for removing deleted controllers from the tree. The add-on interface could also prompt the user for any needed customization parameters (e.g., PV ranges, health score weightings) and could use SPy.trees insert and remove functionality for modifying the tree elements. 

6. When evidence of more widespread variation is found (more than just variability in a single controller), and the root cause is not easily identified, CLPM findings can be used to generate a list of controllers (and perhaps measured process variables in close proximity) that are then fed as a dataset to Seeq’s Process Health Solution for advanced diagnostics.

7. For complex performance or diagnostic metrics (for example, stiction detection using PV and OP patterns), high quality data may be needed to generate accurate results. Therefore, some metric calculations may not be feasible depending on the sample frequency and compression levels inherent with archived and compressed historian data. The only viable options might be using raw data read directly from the distributed control system (DCS), or specifying high frequency scan rates and turning off compression for controller tags such as SP, PV, and OP in the historian. Another issue to be aware of is that some metric calculations will require evenly spaced data and therefore need interpolation (resampling) of historian data. Resampling should be carefully considered as it can be problematic in terms of result accuracy, depending on the nature of the calculation and the signal variability.

8. The purpose of this article was to show how to set up basic CLPM in Seeq but note that many types of process calculations to monitor “asset health” metrics could be created using a similar framework.

 

Summary

While there are of course many details and customizations to consider for generating actionable controller performance metrics for your manufacturing site, the basic CLPM approach above illustrates a general framework for getting started with controller performance monitoring in Seeq. The outlined approach is also widely applicable for health monitoring of other types of assets. Asset groups/trees are key to scaling performance calculations across all controllers, and Seeq Data Lab can be used as needed for implementing more complex metrics such as oscillation index, stiction detection, and others. Finally, Seeq Workbench tools and add-on applications like Seeq’s Process Health solution can be used for diagnosing the root cause of performance issues automatically identified via CLPM monitoring.  

CLPM Asset Tree Creation.ipynb

Advanced CLPM Metric Calculations.ipynb

A typical data cleansing workflow is to exclude equipment downtime data from calculations. This is easily done using the .remove() and .within() functions in Seeq formula. These functions remove or retain data when capsules are present in the condition that the user supplies as a parameter to the function. 

There is a distinct difference in the behavior of the .remove() and .within() functions that users should know about, so that they can use the best approach for their use case. 

• .remove() removes the data during the capsules in the input parameter condition. For step or linearly interpolated signals, interpolation will occur across those data gaps that are of shorter duration than the signal's maximum interpolation. (See Interpolation for more details concerning maximum interpolation.)
• .within() produces data gaps between the input parameter capsules. No interpolation will occur across data gaps (no matter what the maximum interpolation value is). 

Let's show this behavior with an example (see the first screenshot below, Data Cleansed Signal Trends), where an Equipment Down condition is identified with a simple Value Search for when Equipment Feedrate is < 500 lb/min. We then generate cleansed Feedrate signals which will only have data when the equipment is running. We do this 2 ways to show the different behaviors of the .remove() and .within() functions.  

1. $Feedrate.remove($EquipmentDown) interpolates across the downtime gaps because the gap durations are all less than the 40 hour max interpolation setting. 
2. $Feedrate.within($EquipmentDown.inverse()) does NOT interpolate across the downtime gaps. In the majority of cases, this result is more in line with what the user expects.  

As shown below, there is a noticeable visual difference in the trend results. Gaps are present in the green signal produced using the .within() function, wherever there is an Equipment Down capsule. A more significant difference is that depending on the nature of the data, the statistical calculation results for time weighted values like averages and standard deviations, can be very different. This is shown in the simple table (Signal Averages over the 4 Hour Time Period, second screenshot below). The effect of time weighting the very low, interpolated values across the Equipment Down capsules when averaging the Feedrate.remove($EquipmentDown) signal, gives a much lower average value compared to that for $Feedrate.within($EquipmentDown.inverse()) (1445 versus 1907). 
 

Data Cleansed Signal Trends 

 

Signal Averages over the 4 Hour Time Period

Content Verified DEC2023

Asset groups and asset trees (link) are used frequently in Seeq for asset swapping calculations, building treemap visualizations, and scaling tabular results across assets. In some cases, users want to export calculated results for assets from Seeq Workbench to Excel or perhaps to Power BI. The following example illustrates a technique for doing this efficiently with a single export. 

1. Asset group for 8 furnaces contains an "Outlet Temperature" signal that we want to calculate and export daily statistics (avg, std deviation, min, max) for:

2. Note that the "Daily Statistics" condition is created with a Formula that is part of the asset group. This is key to enabling the data export across all assets. See the formula for the "Daily Statistics" condition below for Furnace 1. Note that we create a daily condition and then add the temperature statistics as capsule properties, and assign an asset name property. These details are also essential in setting up an efficient export. As a reminder, we need to edit the "Daily Statistics" formula for each furnace to assign the correct furnace number to the Asset Name capsule property. For this example (only 8 assets), this is easy to do manually. For a large asset group (50, 100 or more), a better approach would be to create an asset tree using Data Lab, and programmatically create the individualized "Daily Statistics" conditions. 

 

 

3. Next, we navigate the asset group and add the Daily Statistics condition for each furnace to the trend display in Workbench, which makes it easy to set up the "Daily Furnace Statistics for Export" in step 4.

 

 

4. Create the "Daily Furnace Statistics for Export" condition which will have overlapping daily capsules for the 8 furnaces. Here, we combine the separate Daily Statistics conditions (for all 8 furnaces) into a single condition. For the export to work as expected in a later step, we need to slightly offset the capsules using the move() function, so that they do not have identical start times. 

 

5. Next, we visually check the capsules and their properties on the trend (Asset Name and Daily Avg) and in the capsules pane on the lower right. Everything looks as expected, we have a capsule for each furnace for the day of May 24.

 

6. The export to Excel or to other applications via OData can now be set up. The key is to export only the "Daily Furnace Statistics for Export" condition, and to set the time range appropriately based on your objectives. Here, we only want the results for 1 day:

7. Checking the export on the Excel side, all looks good. We have the daily statistics, scaled across all furnace assets, with one row for each furnace:

 

To summarize, the following are keys to this technique for exporting calculation results across all assets, from Seeq Workbench:

Store the calculation results as capsule properties in a condition that is an item in the asset group, and also assign an asset name property (see Step 2 above). In this example we used a daily time basis for calculations, but the techniques can be applied and extended for many scenarios. 

To store the results across all assets, create a single condition for export, which is a combination of all the individual asset "calculation results" conditions, and offset capsules slightly as needed to avoid capsules having identical start times (see Steps 3 and 4 above). 

In this example, we only had 8 assets so all formulas could be created interactively by the user. For large asset structures, the asset tree and formulas, including the final condition for export, can be created programmatically using Data Lab (link).  

Hello,
I'm going to attach an example Seeq Journal for this use case, which includes a few of the actual formulas used. Why don't you take a look at this and then let me know if there are specific steps that you need more information on? There are additional formulas that I can provide if needed. 

Hello Nicolas,

This is a great application for Seeq. The details of what you will actually need to do will depend on how the alarm data comes into Seeq (as signals or as capsules) and how you want to arrange/display it.

To get you started, here are 2 resources that may help specifically with your dashboard of alarms use case. I encourage you to review these resources and then reach out to a Seeq Analytics Engineer in Office Hours (https://info.seeq.com/office-hours) for further help as needed. 

1. A Seeq University video on creating tables for event based data (similar to alarms).

 

 

2. A Seeq.org post on turning a signal's values into table rows. 

 

 

Depending on the details of the use case, adding properties from one condition to another (during a join or some type of combination of the 2 conditions) can be achieved with at least 2 approaches:

1. The mergeProperties() Formula function, introduced in Seeq R56 can be used. You can look up example uses of mergeProperties() in Seeq Formula's documentation. Also note that mergeProperties() has functionality for quantitatively merging numerical property values (max, average, etc.) if the 2 conditions have conflicting values for the same property. 
2. The setProperty() Formula function can be used to add property values from one condition to another. It may be necessary to use getProperty() in conjunction with setProperty(): please see the highlighted sections in the screenshot below, which is included here only to show an example of using setProperty() inside of a transform(). Another alternative with setProperty(): you may also consider converting a property value (to be retained from the second condition) to a signal with $condition.toSignal(propertyName), and then use the signal result with setProperty(). You can see examples of adding a signal aggregation as a capsule property in Seeq's Formula documentation for setProperty().

I think one of these approaches should help with your use case. 

 

Summary/TLDR

Users commonly want to duplicate Seeq created items (Value Search, Formula, etc.) for different purposes, such as testing the effect of different calculation parameters, expanding calculations to similar areas/equipment, collaboration, etc. Guidance is summarized below to prevent unintended changes.  

Duplicating Seeq created items on a worksheet	Creates new/independent items that can be modified without affecting the original.
Duplicating worksheets within a Workbench Analysis	Duplicating a worksheet simply copies the worksheet but doesn't create new/independent items. A change to a Seeq created item on one sheet modifies the same item everywhere it appears, on all other worksheets.
Duplicating entire Workbench Analysis	Creates new/independent items in the duplicated Workbench Analysis. You can modify them without affecting the corresponding items in the original Workbench Analysis.

 

Details

Each worksheet in an analysis can be used to help tell the story of how you got to your conclusions or give a different view into a related part of your process. Worksheets can be added/renamed/duplicated, and entire analyses can also be duplicated: Worksheet and Document Organization

Confusion sometimes arises for Seeq users related to editing existing calculation items (Value Searches, Formulas, etc.) that appear on multiple worksheets, within the same analysis. Often a user will duplicate a worksheet within an analysis and not realize that editing existing items on the new worksheet also changes the same items everywhere else they are used within the analysis. They assume that each individual worksheet is independent of the others, but this is not the case. The intent of this post is to eliminate this confusion and to prevent users making unintended changes to calculations.

 

Working with the same item on a Duplicated Worksheet

When duplicating worksheets, remember that everything within a single Workbench Analysis, no matter what worksheet it is on, is "scoped" to the entire analysis. Duplicating a worksheet simply copies the worksheet but doesn't create new/independent items. A change to an item on one sheet modifies it everywhere it appears (on all other worksheets).

For some use cases, duplicating a worksheet is a quick way to expand the calculations further or to create alternate visualizations, and the user wants to continues working with the original items. In other situations, worksheet duplication may be a first step in creating new versions of existing items. 

To avoid modifying an original item on a duplicated worksheet, from the Item Properties (Detail Pane "i" symbol) for the calculated signal/condition of interest, click to DUPLICATE the item. You can edit the duplicated version without affecting the original.

 

Duplicating worksheets is often useful when you are doing multiple calculation steps on different worksheets, when you want trends on one worksheet and tables or other visualizations on another, when doing asset swapping and creating a worksheet for each unique asset, etc.

 

Working with Items in a Duplicated Workbench Analysis

If you duplicate the entire Workbench Analysis (for example, from the Seeq start page, see screenshot below), new/independent items are created in the duplicated Workbench Analysis. You can modify the items in the duplicated Workbench Analysis, without affecting the original (corresponding) items in the original Workbench Analysis. This is often a good approach when you have created a lengthy set of calculations and you would like to modify them or apply them in a similar way for another piece of equipment, processing line, etc., and an asset group approach isn’t applicable.

 

There is one exception to this: Seeq created items that have been made global. Global items can be searched for and accessed outside of an individual Workbench Analysis. Editing a global item in a duplicated analysis will change it everywhere else it appears.

There are many considerations for best practices when testing new parameter values and modifications for existing calculations. Keep in mind the differences between duplicating worksheets and duplicating entire analyses, and of course consider the potential use of asset groups when needing to scale similar calculations across many assets, pieces of equipment, process phases, etc. There are in-depth posts here with further information on asset groups:

Asset Groups 101 - Part 1

Asset Groups 101 - Part 2