How Cubewise Code will shape the future of IBM TM1/Planning Analytics in 2018

2018 v2.png

A lot happened in the TM1/Planning Analytics world in 2017. Canvas has been endorsed by many customers as their new way to build modern web planning and reporting applications. TM1py brought together for the first time, the TM1 and Python communities in order to find new ways to integrate external systems with your TM1 application. 

In 2018, we continue mastering the TM1 REST API by introducing a brand new product:

Something that all TM1 developers have been asking for! A new way to build your TM1 models which takes advantage of all the new features of TM1 11 / Planning Analytics. More information to come on this blog or you can contact your local Cubewise office.

Pulse goes Big Data with Kibana and Elasticsearch

Buiding reports and analysing the core of your TM1 application such as your TM1 user sessions, TM1 process errors, TM1 process/chore runtime... will become even easier now with Kibana and Elastic Search.

Kibana is probably the most exciting new feature of Pulse since migration was added. With Pulse v5.7, Pulse can now send data to Elasticsearch, one of the best and most popular Big Data stores. Kibana provides dashboarding / reporting on top of the Pulse data stored in Elasticsearch enabling you to develop your own metrics and share them with your TM1 community.

Canvas Cube Viewer and Subset Editor

Canvas will continue revolutioning the way TM1 planning and dashboarding applications are built. Canvas has proven in 2017 that it is a mature, scalable and stable solution for many customers. In 2018, we will make Canvas even better by introducing a lot of new exciting features such as the brand new Cube Viewer, Subset Editor and new samples.

A new version of Bedrock and TM1py

In 2018, there will be a new version of Bedrock (v4) which will be designed for IBM Planning Analytics. This will support hierarchies and all the new functions introduced with Planning Analytics Local. We will continue improving TM1py as well, with a lot of new features and articles to inform the TM1 Community about what you can do with Python.

Exciting IBM TM1/Planning Analytics conferences coming close to you

This year TM1 and Planning Analytics conferences will be held in four locations:

  • London in April
  • Sydney and Melbourne in August
  • Las Vegas in September

We will also be at Think conference in March so if you are in Las Vegas drop by and say hello.

Read more:



How Cubewise CODE has revolutionized TM1 Planning Analytics in 2017

A lot happened in 2017 in the IBM Planning Analytics (TM1) world. Here is a quick recap from Cubewise CODE.

Pulse: Centralized Database Architecture

Pulse take up continues to grow beyond 150 customers globally allowing our customers to watch over a combined total of well over 50 million lines of TM1 code. Accordingly, the number of “large enterprise” TM1 implementations has increased necessitating support for MS SQL Server. The latest version,  Pulse v5.6,  incorporates a centralized database architecture which brings downstream benefits such as forensic TM1 server and user reporting via Big Data provider, Elasticsearch. This version is a big step forward for Pulse in the cloud.

Canvas v2 Released

Canvas v2 was a major milestone in the maturity, scalability and stability of the product. This new version introduced lots of new features such as:

A new way to integrate systems with your IBM TM1 Planning Analytics application

TM1py is a free Python package that wraps the TM1 REST API in a simple to use library. Making it easier to integrate systems more effectively with IBM Planning Analytics.

Speed up your IBM Planning Analytics development with our free products

Bedrock, TM1Kill, Hustle and many more other free products will save you lots of time as a TM1 developer:

Cubewise EDU Conferences and Training

In 2017, we hosted more than 500 paying delegates at our IBM Planning Analytics conferences in Sydney, London, NYC and Los Angeles. To learn more about our products, training is now available from the Cubewise EDU page.


Looking forward to 2018

2017 was a great year for the TM1 community and Cubewise Code. We are looking forward to 2018 and making IBM Planning Analytics even better!


How to find over feeding in your TM1 model

Feeders are a crucial part of IBM TM1/Planning Analytics, giving us ad-hoc rule calculations without loss of performance or requiring pre-calculations of results. However, getting feeders right takes a good understanding of the model and how values influence a calculation.

How to check if a value is fed?

The first hurdle when working with feeders, is making sure that every calculation that results in a value is fed. This is so important, as in TM1 only fed cells roll up in a consolidation. If a system is underfed, it means that you most likely have missing values when looking at aggregations. Luckily, TM1 has a tool to check for missing feeders, which can be accessed by right clicking on a cell and select “Check feeders”. Any cell not being fed will show up and you can then work on fixing it.

How to find overfed cells?

However, the opposite result is overfeeding a system. In this case, rule based cells that result in a zero value are flagged with a feeder. While a small amount of overfeeding might not have an impact, large cubes with a lot of overfed cells will result in much slower end user performance, as the consolidation engine has to check the cells only to find out that the result is zero and does not have an impact on the overall consolidation.

In order to assess, how many cells are overfed and which feeder statement is the likely candidate, you can apply the following simple trick.

For the cube you want to analyse, create a shadow cube with the same dimensionality. In our example, we work with the standard demo model from IBM and analyse the SalesCube. The shadow cube we have created is called SalesCube - Overfeeding.

For the SalesCube - Overfeeding, create a new rule file and add three statements to it.


[] = N: IF(
        DB('SalesCube',!actvsbud,!region,!model,!account1,!month) = 0


The last step in our preparation is to add one additional feeder to the initial SalesCube pointing to our SalesCube - Overfeeding.

[] => DB('SalesCube - Overfeeding',!actvsbud,!region,!model,!account1,!month);

Once this is completed you can open the SalesCube - Overfeeding and browse the data:

Any cell showing up with a 1 is overfed and a candidate to be fixed.

The idea behind this trick is to check if a cell in SalesCube - Overfeeding is fed even though the value in the same intersection in SalesCube equals 0. 
If the value is fed in SalesCube - Overfeeding, the value at a consolidation level will be equal to 1. In this case a cell which has the value equals to 0 in SalesCube sends a feeder flag to a cell in SalesCube - Overfeeding cube, meaning that the cell in SalesCube is fed even though the value equals 0.

How to fix it?

To understand why this cell is overfed we need to drill down to the lowest level:

We can see that Gross Margin % has a 1 in the SalesCube - Overfeeding even though the Gross Margin% is equal to 0 in SalesCube. If we have a look at the rule:

['Gross Margin%'] = ['Gross Margin'] \ ['Sales'] * 100;

Instead of being fed by Sales or Gross Margin, Gross Margin% is fed by Units:

['Units'] => ['Gross Margin%'];

In this scenario Gross Margin % is overfed because it is fed by Units. Even though Gross Margin % equals 0, it is still fed because Units equals 10 in Feb.

Use feeder-less rules

Feeders can take lots of memory if you work with large cubes. In this scenario where Gross Margin % is always a calculation for N and C levels, you can get rid of the feeder by adding Gross Margin as a children of Gross Margin %:

Now Gross Margin % is a consolidation and will be "fed" when Gross Margin has a value without having to write a feeder. Using this method to remove feeders will speed up the TM1 server startup time and reduce the size of the cubes or feeders files.


Determine the version of IBM Planning Analytics

It is not easy to know which IBM TM1/Planning Analytics version is installed on your server, even if you know the TM1 server version number it is difficult to tell from the version number if you are using the RTM (first release) or an interim fix or a fix pack. This article shows all versions number from TM1 9.5.2 to help you to find out what is the exact IBM TM1/Planning Analytics version installed on your server.

How to find the TM1 server version number

To find out what IBM TM1/Planning Analytics version you are using, you need to check the version of the TM1 server. There are two ways to find the TM1 server version number:

1. Open cmplst.txt file

Depending on the TM1 version, the default location of the cmplst.txt file could be:

  • C:\Program Files\ibm\cognos\tm1: TM1 9.5.2 and lower
  • C:\Program Files\ibm\cognos\tm1_64: TM1 10.1 and higher version
  • C:\Program Files\ibm\cognos\pa_64: PAL 2.0

Once you have opened the file, look for TM1SERVER_version and you will get the TM1 server version number:

2. Go to properties of tm1s.exe

Another way to find the TM1 server version number is to open the properties of the bin64\tm1s.exe file and look for the File version:

Check the version number with Pulse

A quicker way to check the TM1 version number is to open the Pulse dashboard, in the server section you will find the TM1 server version which matches the version number in the cmplst.txt:

Once you know the version number you can check the list below to find out what version, RTM (first release) or interim fix or fix pack is installed in your environment:

Determine the version of IBM Cognos TM1

If your TM1 server version number is between 9.5.20000.x and  10.2.20700.x, you should check this IBM article which lists all IBM Cognos TM1 versions from 9.5.2 to 10.2.

Determine the version of IBM Planning Analytics

If your TM1 server version number starts with 11, it means that you have installed one of the IBM Planning Analytics version below:

 Planning Analytics Local 2.0

  • tm1s.exe = 11.0.00000.918
  • cmplst = 11.0.00000.918

 Planning Analytics Local 2.0.1

  • tm1s.exe =
  • cmplst = 11.0.00100.927-0

 Planning Analytics Local 2.0.1 IF1

  • tm1s.exe =
  • cmplst = 11.0.00101.931

 Planning Analytics Local 2.0.2

  • tm1s.exe =
  • cmplst = 11.0.00200.998

 Planning Analytics Local 2.0.2 IF2

  • tm1s.exe =
  • cmplst = 11.0.00202.1014

 Planning Analytics Local 2.0.2 IF4

  • tm1s.exe = 
  • cmplst = 11.0.00204.1030

 Planning Analytics Local 2.0.3

  • tm1s.exe =
  • cmplst = 11.1.00000.30

 Planning Analytics Local 2.0.3 (Version number updated by IBM in Dec 2017)

  • tm1s.exe =
  • cmplst = 11.1.00004.2

For more information about all IBM Planning Analytics version you should check this IBM link.


Getting started with TM1py

TM1py is a free Python package that wraps the TM1 REST API in a simple to use library. Making it easier to integrate systems more effectively with IBM Planning Analytics.

Why you should use it?

  • Load FX rates from web services such as FRED into the TM1 Server.
  • Greater automation of your forecast models with Pandas for Data Analysis and Statistics.
  • Advanced integration with machine learning and forecasting algorithms with Python, scikit-learn and the TM1 Server.

Getting Started!

TM1py is really quick and easy to setup, just follow these steps and you will be able to run your first Python script in less than 5 min!

1. Install TM1py

The first step is to install Python and TM1py. These steps are explained on the TM1py-samples github page.

2. Enable the TM1 REST API

TM1py uses the TM1 REST API to connect to the TM1 Server, you will need to enable the TM1 REST API on each instance where you want TM1py to connect to.

3. Download TM1py samples

TM1py includes a lot of ready to use samples that you can download on Github.

4. Run your first Python script

Ever wondered which of the dimensions in your TM1 instance are not used in cubes? TM1py can help to answer this questions with 8 Lines of code! Just follow these steps to know which dimensions are not used in your TM1 application.

5. Learn More

The differences between IBM Planning Analytics Workspace and Canvas

The world has changed, user experience is now the most decisive factor in the success of any business application that is built for people, and TM1-based applications are no exception. Despite inferior modelling capability and performance, other (non-TM1) software solutions have become popular almost solely on the fact that they meet modern user expectations for user experience.


In other words, companies are choosing their budgeting and reporting solutions based on look and feel and not based on whether it gets the job done - and done well.

To address this, at the end of last year IBM released Planning Analytics Workspace (PAW). PAW is a completely new, modern, web-based self-service user interface for TM1.

With Cubewise Code’s Canvas for TM1 and IBM’s Planning Analytics Workspace, TM1 customers thankfully now have two options to offer users to give them a modern TM1 user experience.

But there has been some confusion about where customers should best use PAW and where best to use Canvas. Let’s dig into that.


Canvas and Planning Analytics Workspace are both designed to build web applications natively on TM1 using the TM1 REST API. This means that both are very fast and require no other data layer (no “connector”, no flat file interface, etc.) to access TM1. They both are focused on TM1-specific functionality which means they feature the rich, high-performance write-back capabilities that underpin business planning applications.


SELF SERVICE vs Curated Apps

PAW has been designed as a powerful ad-hoc self-service data discovery tool with which business users can easily build and share their own reports and dashboards. The main advantage of such drag-and-drop tools is that any user with minimal to no training can create a report or dashboard quickly. The disadvantage is that the user is inherently limited to whatever the software allows them to drag and drop and corresponding “right click” options. If you want to do something you have been able to do in Excel or have seen in another application and it is not “in the box”, the best you can do is request the new feature from IBM and hope they prioritise it.

Canvas is not a drag-and-drop tool. Canvas was designed to finally bring the freedom and power of modern web application development to TM1 developers. The core benefit of Canvas is that for the very first time, a TM1 Developer can produce a modern web-based application and match the modern user experience “wow factor” expectations of end users.
Some people have shied away from Canvas because they do not know HTML. But Canvas has been designed with this in mind – we have seen that any TM1 Developer that can write rules and TI is able to easily learn enough HTML to be able to build rich, modern web applications for TM1 with Canvas. In short, it allows TM1 developers to embed DBR and SUBNM functions (among many other familiar TM1 pieces) into their web applications in a way they are already familiar with in Excel.


PAW and Canvas are built on fundamentally different concepts in regards to how a report is built

PAW is a view-based application. It allows a user to easily drag and drop a TM1 cube view onto a workspace and then display it as a range of charts. So whatever a user wants to have in the chart, they must have in the view – which may lead to design decisions regarding what you put in a cube in order to display it in PAW.

Canvas, on the other hand has adopted a cell-based approach to application building similar to Excel, and TM1 Perspectives.  This means each cell in Canvas has its own DBR formula to retrieve data and to update TM1, which is exactly how TM1 Developers are used to working with TM1. So with Canvas, you can easily combine data from two different cubes into one table or chart as you can in Excel and TM1 Perspectives.


As it turns out it is not Canvas versus PAW - Canvas and PAW are complementary products. PAW is much better suited for ad-hoc TM1 reporting while Canvas is definitely the product of choice for those who want to build a sophisticated custom TM1 application for planning or reporting.

Pulse v5.6 Released

The best TM1 management system just got better thanks to the great feedback we have received from our 150+ customers worldwide.

MS SQL Server can optionally be used

To achieve better performance on large Pulse installations and concurrent active Pulse users, we now support MS SQL Server. Importantly this centralized database architecture is a needed and big step in the cloud enablement of Pulse. 

Pause and rewind up to 10 min of your TM1 history

With Pulse v5.6, you can now navigate through 10 min of your TM1 history. For example, you receive a Pulse alert that someone is waiting, you can then go back to the beginning of the event to find out what is causing the lock.

Canvas logging

With Pulse v5.6, you are now able to see which Canvas pages have been opened and who opened them.

Pulse self-usage tracking

Pulse is monitoring itself, you will be able to know who logs in and which features are used:

Migration Packages can be refreshed/recreated.

Migration Packages can be refreshed with the latest version of their contained TM1 objects. When you click the recreate button, Pulse is going to create a new migration package based on the same list of TM1 objects but it is going to take the current version from the TM1 data folder.

A new lighter Excel logger

Pulse v5.6 introduces a new Excel Add-ins to track Excel. This new logger is written in .NET. This new silent add-in, which logs Excel usage to Pulse and has no user interface.



Canvas v2 Released

The unique IBM TM1/Planning Analytics REST API framework just got even better! Some of the highlights of the great new features of Canvas version 2 below.

Email Bursting

With Canvas v2, you can now burst PDF reports by email. There are 5 ways to drive your bursting either based on a Dimension Subset, Dimension MDX, Cubeview, CSV file or a path to a CSV file. 

Even more exciting is that you can schedule to run a TM1 process or TM1 chore just before the bursting via the Task Scheduler.

Alternate hierarchies are now supported

Canvas v2 also supports the exciting new alternate hierarchies feature found in IBM Planning Analytics. To get values using alternate hierarchies, you can now use the following syntax:

  • "Hierarchy1::Element1 && Hierarchy2::Element2"

For example, to get the value from 2010 Jan from the Time dimension, you will need to use the following:

  • "Year::2010 && Month::Jan"

As you can see in the following screenshot which is using the cell reference feature in Canvas:

A new way to upload Excel files into TM1

Canvas includes the SheetJS library which will help you read data from a spreadsheet and display it in your browser.

Once the data is in the browser and after clicking on the Save button. Canvas will batch the query and send the data into the TM1 cube using the TM1 REST API.

Canvas usage tracking is now available

With Canvas, you can track which pages your users are using. This data can be viewed in Pulse and/or stored in a file system.

Refresh only a specific group of DBRs

You can now make your page even more responsive by grouping your DBRs so they do not all refresh when you input a value into one DBR.

Upload data into TM1 from an Excel file

No matter which tool your company uses for planning, if finance users have to choose one tool to input lots of data, they will choose Excel.

With IBM TM1/Planning Analytics, you can give your users the freedom to do all their input into Excel and then upload the Excel file into the TM1 cubes. This article explains the different methods that you can implement in your TM1 application to upload data from an Excel file into your IBM TM1/Planning Analytics cubes.

Option 1: DBS or PAx

The most common way to send data from Excel to TM1 is to use the DBS formula. The DBS takes a value from a cell and sends it to the TM1 cube. With PAx, the new Excel Add-in, a simple copy paste can send the value into the TM1 cube. 

The advantage of this method is that it is straight forward, you just need to refresh Excel or press the commit button in PAx to upload the data into the TM1 cube. But the challenging part is that you rely on Excel and this is not the best option to upload lots of data. The other main challenge is that there is no governance or transparency. Any TM1 user could upload any data from any Excel spreadsheets.

Option 2: TM1 processes

The second option is to use a TM1 process. TM1 processes are very powerful, they can load data from many types of data sources, albeit Excel is unfortunately not one of them. In order to load data from an Excel file, you will need first to convert the file into a CSV or text format.

To upload data using this method you will need to follow these steps:

  1. User copy their Excel file into a specific folder.
  2. A script converts Excel file into CSV.
  3. TM1 process uploads the CSV file into TM1.

The advantage of this method is that users do not need to log in to TM1 and they can work offline. But this method is not straight forward, in theory it works, but in real life applications there are lots of moving parts.

Option 3: Canvas

The third option is to use the TM1 REST API, in just two steps you can load lots of data from your web browser into TM1:

1. Upload File into your web browser

Canvas includes the SheetJS library which helps working with spreadsheets on the web. With a simple button you can upload an Excel file and then display the data into your browser.

This step allows you to do validations before sending the data into TM1:

2. Send the data into TM1

Once the data is in the browser and after clicking on the Save button. Canvas will batch the query and send the data into the TM1 cube using the TM1 REST API.

This method gives you an extra step where you can validate automatically your users input and add greater governance, controls and transparency so you know who has updated which cells and when.

Once the Excel file is uploaded, all the work is happening on your web browser. You can then continue working on Excel while your data is uploading.

Do more with TM1 with Python

TM1py (pronounced "TM1-pie") is a Python package that wraps the TM1 REST API in a simple to use library. That makes it easy to build stuff with TM1 and Python.

Python is a widely-used general-purpose high-level programming language that lets you work quickly and integrate systems more effectively. We believe Python can be a valuable extension to the TM1 ecosystem.

Get the best of TM1 and Python

Leverage TM1 with Python

Do statistical analysis and write machine learning on top of your TM1 application, these and many more are now easy to achieve with TM1py:

  • Use Pandas for Data Analysis and Statistics on top of your TM1 model.
  • Build Machine Learning and Forecasting Algorithms with Python and scikit-learn based on your TM1 data.
  • Load data (e.g. FX, stock data) from webservices into TM1.
  • Synchronize cubes throughout TM1 instances.
  • Get insights from your TM1 model. (e.g. Which views use this subset?, which process has an ODBC Datasource?).
  • Export TM1 data to XML, JSON, YAML, XLSX, …
  • Generate MDX Queries from cube views.

Get started

TM1py is licensed through an MIT license and can easily be downloaded though the python packaging system. To get started we recommend downloading the samples from Github and play around with it.
If you have questions or remarks on TM1py it’s best to communicate through Github. 

With a few lines of codes you can achieve a lot. For example the code below reschedule all chores for one instance by -1 hour:

with TM1Service(address='localhost', port=8001, user='admin', password='apple', ssl=True) as tm1:
    for chore in tm1.chores.get_all():


TM1py is an open source project, just like Bedrock. It thrives on contribution from the TM1 community.
If you find a bug or feel like you can contribute please fork the repository, update the code and then create a pull request so we can merge in the changes.

Understand relationships between your IBM TM1 objects

As your IBM TM1/ Planning Analytics application grows, your number of TM1 objects is likely to increase as well. It is good practice to clean up all objects which are not used anymore. In a complex TM1 model, knowing which TM1 objects can be deleted could be time consuming.

This article shows the different features of Pulse which will help you to understand quickly all relationships between your TM1 objects and to determine which objects are not relevant anymore.

bensemail2 copy.png

Interactive Flow Diagram

The Flow diagram gives you an overview of your application, you can easily identify which cubes or TM1 processes are not linked to the others.

You can then highlight a specific object by clicking on it or you can zoom on a specific area to see the object names:

Relationship Diagram

With the relationship diagram, you can focus on specific TM1 objects by including or excluding some objects you do not want to see. It creates a PDF report which you can then share with others:

Technical Documentation

To get more details about your TM1 objects, you can run the technical documentation. It will create a PDF document with lots of information about each object such as description, statistics and all relations to the other objects:

Explore the Pulse databases

To dig even deeper, you can access the Pulse database and with a simple SQL find all relationships. You can then export the table to Excel for further analysis:

What if Heimdall was part of your IBM TM1 team?

Heimdall is a main character in the Thor comic books and movies. He is the guardian of Asgard which is the home of Thor. More importantly he is the gate keeper, he knows the difference between what is good or bad.

What will Heimdall do in your IBM TM1 team?

Heimdall could be your IBM TM1 gatekeeper. He could block everything which should not go into production. Data reconciliation and user requirements should not be the only two criteria to take into account before pushing a release into production. There are other criteria that you should consider such as:

  • Check Best Practice in TM1 rules and TM1 processes.
  • Check naming convention.
  • Check increase in memory consumption.
  • Check the speed performance.

Checking all these criteria is time consuming even for Heimdall unless you give him the right tool.

'Twilight sword' vs Pulse for TM1

Heimdall is in possession of the 'Twillight Sword', it is a weapon that could destroy the 'known worlds'. It sounds amazing and all powerful but it is not going to help you with your IBM TM1 application.

Pulse has lots of features which could help him to make sure that everything that you migrate into production meets user requirements, SOX compliance and IBM TM1 Best Practices such as:

Every IBM TM1 team needs a Heimdall who should be in charge of quality and consistency.

Find the biggest impact on your budget in an instant

Finding which cost center, product or project has the biggest impact on your budget can be time consuming if you have to drill down to the lowest level of a large dimension.

Have you already thought about using Treemaps?

Crossing two types of data will speed-up your analysis, for example while you analyse the % of margin, the Treemap can help you to analyse the impact as well. A product could have a high % of a margin but a low impact or a low margin but high impact.

    Why you should use it?

    A Treemap is a great way to display hierarchical data. It simultaneously shows the big picture, comparisons of related items, and allows easy navigation.

    In a Treemap, you analyse two types of data with one visualization. A quantity measure such as revenue which will determine the size of the boxes and a measure of performance such as % revenue compared to last year which will be represented by the colors.

    Dynamic Treemap with Canvas

    The Treemap in Canvas is dynamic, you can navigate intuitively through the hierarchy, starting from the top consolidation and then drilling down quickly to the lowest levels:

    Customize it the way you like

    With Canvas, you are not limited, you can customize colors, fonts of the Treemap the way you like:

    Meet the Cubewise Code team in Sydney

    The 2017 Sydney TM1 & Planning Analytics User Conference is coming very soon, the 15th of August. The Cubewise Code team will be there.

    For the first time this year, there will be two hands-on sessions where you will be able to try Pulse and Canvas.

    There will be plenty of opportunities to meet us:

    Pulse user group

    On Day 1, It is a customer feedback sessions where you will get the latest news on Pulse, learn a new way to access Pulse databases and Customer stories.

    Pulse Hands-On

    On Day 3, Try Pulse and learn in this session how to improve your Change Management process by using the change tracking, migration and user analytics features.

    Canvas Hands-On

    On Day 3, Try Canvas and learn how to build a TM1 data entry template using the modern web technology. Take the opportunity to learn the basics of HTML, Bootstrap and Angular.

    Booth for demo

    You can meet us at our demo booth where we can show you all our products.

    Book your ticket

    If you haven't booked your ticket yet, you can see the full agenda and book your ticket on the cubewise website:

    5 simple ways to be more productive as a TM1 Administrator

    The following article describes how TM1 Administrators using Pulse for TM1, can be more productive and deliver better outcomes for their business users.

    1. Be Pro-Active

    Do no wait for an issue to happen. Pulse for TM1 can send you email alerts before an issue happen. For instance if a TM1 process or chore is taking longer than usual or if the data do not reconcile and many more...

    Do not wait that your TM1 users complain to take action, with Pulse you will be the first to know when and where there is an issue.

    2. Know all possible impacts

    Always keep an overview of even the most complex TM1 models with Pulse’s magic documentation feature including all dependencies. Having current documentation and the ability to view a TM1 model visually via relationship diagrams also means your team can feel confident changing the system knowing all possible impacts.

    3. Be confident before a new release

    Never forget a TM1 object. When migrating a TM1 object, Pulse finds all dependencies which should be included during the migration.

    View changes before migration. It tells you exactly what is going to be updated in the target instance. You can view in details the exact lines of code which are going to be updated.

    4. Easily roll-back changes

    Pulse gives you total transparency about what changed. Every time an object is changed by either a user or system process, it is tracked and logged by Pulse. There is no need to keep lists of what has been changed in your development environments and in production Pulse can provide the needed governance and transparency.  

    Quickly rollback changes, Use the rollback feature to retrieve a previous version of TM1 process or rule file.

    5. Improve testing procedures

    It is fair to say that testing phases are painful for business users. In addition to their daily tasks they have to find some times to test new features before a new release. Unfortunately it often happens that they do not have time to do proper testing. Pulse helps you to ensure that testing procedures have been strictly adhered to by monitoring and tracking the test user’s activity.

    Sending Email Alerts from TM1

    There are many situations where you would like IBM TM1/Planning Analytics to send an email to the TM1 administrators or to TM1 users.

    For example if a chore runs longer than expected, if some users are waiting or if the data does not reconciled.

    IBM TM1/Planning Analytics does not include any tools to help you to send emails to your users. There are some workarounds but they are not very easy to set up.

    You can overcome this by using Pulse for TM1, which is full of features that can help you in your day to day TM1 jobs, one of them is pro-active alerting. Pulse has lots of alert types that you can set-up such as memory alert, if the instance is offline and many more.

    Use case: In most TM1 applications, chores run every night to load data, a chore can run successfully but it does not mean the data will reconcile. This article describes how Pulse can send you an email when the data between two cubes do not reconcile.

    1. Write into the TM1 message log

    From TM1 v10.2.2, a new function LogOutput has been included, it enables you to write to the tm1server.log from a TM1 process:

    • LogOutput('SeverityLevel', 'MessageString');

    In the example below if the value is not the same between the General Ledger and Retail cubes, a message will be written the message log:

    # Check Reconciliation
    IF( nValueGL <> nValueRetail );
     message = 'Cost of Sales reconciliation failed between GL ( '| sValueGL | ' ) and Retail ( '| sValueRetail | ' ) for ' | cVersion | ' - ' | cYear ;
     LogOutput ('INFO', message);

    2. Define an Alert in Pulse

    In Pulse we would need to define a "Message in Log" alert. This will generate an alert every time a parameterized filter pattern is found in the tm1server.log.

    For this example, we will set the filter  "*failed*" as the pattern to be detected by Pulse and a Notification Group (TM1Admin), in order to email those users that could be interested in receiving this notification.

    You can also set this alert to be triggered by one instance or for all (leave instance blank), in this case, the alert will only applied for cxmd. 





    Email Alert Sent

    As a result, every time the TM1 process writes the “failure” message in the tm1server.log, Pulse will alert via email:

    The email alert will report that the text pattern “failed”  has been found within the message log and will also include a snapshot of the instance’s TM1Top data:

    Analyse your data with Google Map and IBM TM1/Planning Analytics

    Canvas for TM1 gives your company the freedom to easily create modern, sophisticated IBM TM1/Planning Analytics applications. There is almost no limit with the things you can do now, such as displaying your business data by locations with Google Map. For example we have seen sales field rep benefiting from this new type of visualization:

    Integrate Google Map into your application

    With Canvas for TM1, it is really easy to link Google Map with your IBM TM1/Planning Analytics data. All you need to do is query your cube using MDX Query and then use Canvas for TM1 to display it in Google Map:

    Create your own Google Map

    Even better, you can customize Google Map to the way you want it. Show/Hide roads, parks or monuments. There are lots of settings that you can play with! Google Map has a Google Maps APIs Styling Wizard which will help you create your own style:

    Canvas for TM1 at IBM Vision

    This year at IBM Vision in Orlando, there will be two great examples of Canvas applications presented by Jabil Circuit and Apliqo C3.

    Jabil Circuit

    Jabil Circuit is building a refreshed web-based user interface for its 2,500+ Cognos TM1 users leveraging Canvas for TM1. Jabil will be presenting on stage, the session code is FPM-1205.

    Apliqo C3

    Apliqo C3 provides a pre-built Performance Management Solution with unified reporting, analysis and planning in ten different modules. They have chosen Canvas to rebuild their existing Cognos TM1 Web application into a whole new modern interface. The Apliqo team will be presenting on stage, the session code is FPM-1281.

    Meet us at our booths 13 & 14

    You can meet the Cubewise and the Apliqo team at their booths 13 & 14. Swing past our booths and get a selfie with Manny Perez, Cubewise CTO and the inventor of TM1!

    Canvas examples

    TM1 migration has never been so convenient

    At first sight, the TM1's file-based architectural makes TM1 migration from one instance to another quite straight forward: 

    Even if it looks easy, you have to make sure that you picked all the files from the source instance. For example if you are migrating a cube, all dimensions have to be included and to migrate a dimension with its attributes you have to include all control objects.

    If you miss one TM1 object, you will have to restart the target instance again. It might not be a big deal if you are working on development but if you are in production it might be difficult to find a new time-slot.

    The Pulse migration feature overcomes TM1's file-based architectural limitations with a centralized model that reduces risk of mistakes.

    Advantages of using Pulse for TM1 migration

    • Never forget a TM1 object: When migrating a TM1 object, Pulse finds all dependencies which should be included during the migration.
    • View changes before migration: Pulse tells you exactly what is going to be updated in the target instance. You can view in details the exact lines of code which are going to be updated.
    • Automatically back-up the database folder.
    • Very robust: It is used by many clients for the past years. With Pulse v5.5, we optimized the migration to make it even faster.

    How it works?

    Pulse provides a structured approach to migration, which follows two important steps: 

    1.  Create migration package: Gather all TM1 objects you want to migrate into one package from one source instance.
    2. Execute migration package: Import all TM1 objects from the package to the target instance.

    Each package contains all the information and files required to update a target instance.

    Migration methods

    Pulse has several methods for creating a migration package. The two main methods are source control and manual migration:

    • The Source Control option allows you to query for a list of changes based on a date range and also by developer/user (leave this blank for all users) and then select the items you want to migrate.
    • The Manual option allows you to pick the objects you want to migrate manually. It is not restricted by changes that have been made, any object can be migrated (except views and subsets). Pulse will then find all dependencies of the TM1 objects selected:

    Types of packages

    Once you picked which methods you want to use to create the package, you will then have to decide the package type:

    • Live Update: The execution of packages can be performed while the server is still running.
    • Offline Update: Pulse will create a folder with the TM1 object files. You can then copy the files manually into the target instance.

    Pulse provides enterprise grade migration features allowing you to easily move changes in your TM1 models between servers.

    Read more:

    Responsive design with Canvas and Bootstrap

    Excel vs HTML

    The first thing you notice when you start building a web page is that the layout is not defined. You literally start from a blank page. First you have to create the containers before adding some contents. 

    In Excel, when you create a new sheet, you can easily add some contents into the cells. The advantage is that you don't have to worry about defining the containers but the downside is that the layout is fixed. The size of the cells will always be the same no matter the screen-size. It is not responsive, on a small screen it is likely that you will have to use the scroll bar to see all the contents.

    Building a webpage takes a bit more time at the beginning because you have to define the layout. The advantage is that it offers you the freedom to set your layout as you want. To help you to define a responsive design for your TM1 applications, Canvas includes the Bootstrap framework.

    What is Bootstrap?

    Bootstrap is a pretty nice HTML and CSS framework for developing responsive web applications. In other words it helps to create a layout which will adjust depending on the screen size.

    The bootstrap grid system allows for up to 12 columns on the page. You can group multiple columns to create bigger containers:

    For example if you want to show 4 columns of the same size in the same row, you will need to create 4 containers with a width of "col-md-3", you define a container by using div tag:

      <div class="row">
        <div class="col-md-3">
             Column 1
        <div class="col-md-3">
             Column 2
        <div class="col-md-3">
            Column 3
        <div class="col-md-3">
            Column 4

    This is what your page will look like, 4 columns with the same width:

    If you work on a smaller device where the 12 columns cannot fit, instead of staying on the same row and use the scroll bar to see them, the columns will be pushed to the next rows:

    Bootstrap allows you to manage the look and feel of your TM1 applications as you resize your web browser or switch from a tablet to a smart phone.

    Dashboard with responsive design in Canvas

    In the following video, you can see an example of dashboard with a responsive design:

    With Canvas and Bootstrap you have the freedom to define the look and feel of your TM1 applications. You do not need to know Bootstrap or HTML before starting to build Canvas pages. Canvas comes with a complete set of samples which will give you plenty of ideas on how to build out your own TM1 applications, and if you want to go even further there are plenty of contents online such as forum and training courses.