Apolemia

Hidden BADIs

2009-10-26T21:52:00.006Z

There is a very practical BADI in R3 for developing custom ATP scenarios, named ATP_PUBLISH_RESULTS. But one strange thing is this BADI does not show up in the SE18 queries, for example when doing a query for ATP*. So until recently I did not know about this BADI at all.

But it will show when inputting the full name.

So why is it hidden in SE18 queries? With some debugging it is easy to see that a F4 query in SE18 will go to table SXS_ATTR with ATP* as the pattern for the EXIT_NAME field and with INTERNAL different from X. It turns out that this INTERNAL field marks the BADI as internal (only to be used by SAP) so it becomes hidden from the F4 query in SE18.

So next question was: are there many internal BADIs? It turns out there are about 200 in APO and 400 in R3. So I suppose that it is well worth digging on this table if nothing can be found in the “external” BADIs and exits. Although one should avoid using the internal BADIs I suppose it makes a better option than standard code changes or some extreme hacks.

OnSAP.com - questions and answers on SAP topics

2009-09-23T14:30:00.006+01:00

I've been working on SAP for a long time. Of course there is still a lot to learn, but on the specific topics I specialize and focus most of my work on, after some time there is no book or SAP documentation with new knowledge. The best and maybe only way to continue learning is getting new challenges and finding solutions, and learning how other people solved hard problems.

Internet forums are great places to find good questions and answers. Unfortunately sometimes the forums have too much noise, bad questions and bad answers. One site that I think does the right thing is stackoverflow. Although it is a forum, it has some mechanisms to increase visibility of the best questions, give credit to the right answers and to the people that write the good questions and answers. The OnSAP website tries to be the same for SAP questions and answers.

It is a place where I will post my questions and hopefully my answers when I find them. It starts with a small community but at least on APO and ABAP there will be enough knowledgeable people to make it a good place to discuss hard topics. I also invite all of you to post your questions there, and give some answers if you feel like helping and improving the open knowledge (both the software and the contents of the site are open licensed).

Typical projects

2009-07-16T21:27:00.005+01:00

Typical project of the 90's: FI, CO, SD, MM, PP, sales organizations, warehouses, distribution centers and maybe factories.

Typical project of this decade: trade company in Luxemburg, Switzerland or other low tax country; stocks owned by the trade company but physically in a different location; outsource production but control the planning of raw materials and possibly reorder from a central location; have the outsourcing partner stocks and in-process productions in the system as if it was a standard plant.

It's amazing the base model continues to be the same. But in the past it was clean and now it looks quite twisted.

And now? Going back to ABAP?

2009-04-25T23:04:00.003+01:00

So Oracle buys Sun and gets Solaris, Mysql, MaxDB and Java. The first is a very important database but not very relevant to enterprise and SAP world (although it is used in SAP xMII). The second (previously named SAP DB) is the core to SAP APO LiveCache. And the last, the Java programming language, is the programming environment on which most new SAP products are developed and is also used for the cross platform GUI. And I would guess a lot of customers run on Solaris.

Before this purchase Oracle already had the most used database in SAP deployments. Is it me, or this is too much Oracle on SAP's backyard? If it was in my house, I would start doing some cleaning.

Marked Cell in Demand Planning Macros

2009-03-22T12:14:00.017Z

I wanted to allow the users to choose a planning book cell, then click on a macro button to open a pop-up window with additional information related to the cell. But it does not seem to be possible to get the marked cell when developing planning book macros.

The standard macro functions PLOB_MARKED and COLUMN_MARKED work when selecting full rows and columns. Consider the following example macro:

It is possible to use that macro to identify a cell if the user selects both the row and column (pressing the control key to allow that kind of selection). But that is very user-unfriendly.

It turns out that most of the functionality for getting the marked cell in the macros is already available in the lower level macro functions. The standard function /SAPAPO/MARKED_ELEMENTS is used in the macro functions that return the marked row and column. That function also has information on the marked cell, so with some simple modifications it can be used for returning the selected cell.

It was easy to develop new functions to check the row (PLOB) for the marked cell and a function to check the column for the marked cell. Both call internally the modified /SAPAPO/MARKED_ELEMENTS and are based on the standard functions.

Then it is possible to develop macros that act on cells, to put the toolbar button for the macro and to open an ALV with cell detail information.

I still find it strange that marked cell macro is not available in the standard. Perhaps it is in some recent release. IMHO is a must have for planning books.

No more smiles

2009-01-23T10:13:00.003Z

No more smiles in ATP. Why SAP why?

Another spell for the hacker book

2009-01-12T19:01:00.007Z

The object oriented programming in APO uses in many cases the singleton pattern. An object static method (class method in standard object oriented talk) is used to obtain the object instance. If it is the first time the object is created and stored in a static attribute (class attribute). Then further calls to the method return the instance stored in the attribute. A practical result of this coding logic is that these objects become global structures of data because as long they were initialized at a given point of time, they are can be accessed at any later time just by calling the static method. For example, the object /SAPAPO/CL_ATPFIELD_BUF can be called in ATP user-exits to get the field catalog (some user-exits don’t have the field catalog available in the input parameters).


CALL METHOD /sapapo/cl_atpfield_buf=>get_atpfield
   EXPORTING
      iv_ordid =  lv_ordid 
      iv_delps = lv_delps
   IMPORTING
      et_atpfield = lt_atpfield.

This works because the field catalog is stored in a static attribute of the object.

For global classes (like /SAPAPO/CL_ATPFIELD_BUF) this is very simple, but ABAP also allows the definition of local classes. For example, the main objects for the ATP calculation (LCL_REQUIREMENT_ATP, etc) are classes defined inside program /SAPAPO/SAPLATPT. I always wanted to have access to these objects inside user-exits (because it means having access to all ATP information). Something like this trick for global variables but able to access the objects.

After many failed attempts, this one works fine.


DATA:
    l_name(150)    TYPE c,
    l_tabtype(150) TYPE c,
    ldr_reqref     TYPE REF TO data.

  FIELD-SYMBOLS:
    <reqref_t> TYPE ANY TABLE.

  l_name = '\PROGRAM=/SAPAPO/SAPLATPT\CLASS=LCL_REQUIREMENT_ATP'.
  l_tabtype = '\PROGRAM=/SAPAPO/SAPLATPT\TYPE=TBL_REQREF'.

  CREATE DATA ldr_reqref TYPE (l_tabtype).
  ASSIGN ldr_reqref->* TO <reqref_t> CASTING TYPE (l_tabtype).

  CALL METHOD (l_name)=>get_instances
    RECEIVING rt_reqref = <reqref_t>.

Now this pointer <reqref_t> is a pointer to a list of all LCL_REQUIREMENT_ATP object instances relevant for the current ATP check.

A Simple Controller

2009-01-12T16:42:00.012Z

There are many ways to design a PAL model. The design that comes naturally to our minds is the one that splits the available quantity over a number of buckets (markets, plants, customers, etc).

This design is simple to understand, but from the point of view of automatic control it faces serious challenges. A control system would have to compute where to deallocate and where to allocate quantity. It becomes an optimization problem.

But let's see a different design (that was also part of this discussion). It checks first the capacity on the main buckets and then checks on a second level a capacity that is available for all orders (sequence of procedures).

Let's suppose we use monthly buckets and that at the start of the month the first procedure has 100% of total capacity and the second procedure has zero capacity. This is exactly as having just one level. Then as time passes the control system can read each bucket and compare the available capacity to some expected target value. If there is more free capacity than the target the system can reduce the bucket capacity and allocate the remaining to the second procedure.

The target open quantity can be one of many functions that return a profile of consumption over time. For example it could just be linear, linear within an internal interval or exponential as shown bellow.

This will make a control algorithm that is simple to understand and implement. And for many practical purposes it does what business expects (if a market is not consuming the quota, then it becomes available for the other markets).

Happy Lunar New Year

2009-01-12T16:32:00.002Z

Happy new year everybody!

Yes I should have posted it in time, but hey, today is the lunar new year and that makes a great excuse :-)

From Water Distribution to Product Allocation

2008-12-27T21:53:00.008Z

The water distribution control system is quite similar to gATP product allocation. What is available in vanilla PAL is something like the open loop control system.

A common development in PAL implementations is to use sales forecast to create the allocation plan. By frequently updating the allocation plan, PAL will become a feedback controller.

The key piece of technology to have a good control system is the controller. In this case the controller is the logic that calculates the bucket capacities from the sales forecast and user defined constraints. It is a bit amazing that SAP APO, probably the most advanced supply chain planning system, left this key piece of technology out of the software. It is up to the people doing the implementation to build the controller. And that is something ~~hard~~ interesting to do.

Similar Control System

2008-12-27T21:44:00.006Z

I tried to find some real work control problems that are similar in objective to PAL . So far, the one I like more is the control of water allocation in regions of limited water and power supply.

The water distribution is done using a network of reservoirs. In dry regions, planning and controlling the level of water in each reservoir is quite important since it may not be possible to pump more water into each tank. For each time period (day, week, etc) there is a planned level of water for each tank in the network. If everybody tries to consume more water than available then all will have shortages. In that scenario the planned tank level corresponds to the fair share of water available for each node in the network.

On the other hand, if there is some tank that experiences more consumption than planned and other tanks have excess capacity, then water needs to be pumped from one place to the other. If power is limited in the region it is also important to plan the pumping of water because it may be more expensive (or not possible at all) to transfer the water only when the tank becomes empty.

The water network control system will probably plan the consumption of water in each node of the network based on historic values. Then, based of the available water capacity, will define the level that will be loaded on each tank (or the quantity to be pumped).

The system could just wait for the end of the period and do the same operation again for the next period. Of course this will have the risk of unexpected consumption making some tanks empty. If that happens, and if water is available, someone will have to try to pump water from some node to the empty tanks. This is not a very good system because there will be a penalty for users that run out of water, it needs manual intervention, and it may be more expensive to pump water. This is like the open loop system described before.

A more advanced system will do real-time monitoring of the water level in each tank. Using that information will recalculate the forecasted consumption. Using the new forecast it is possible to define the values for the tank levels so that quotas are enforced in case of drought but at the same time all available water will reach consumers. This is a supervisory control system with a feedback loop.

Product Allocation Controller

2008-12-21T18:22:00.003Z

In this last post I wrote that PAL is an open loop controller. That statement implies that information from the evolution of the desired objective is not used to compute the control actions. At this stage I need to try to answer the question: what is the objective function for product allocation controlling?

It is easier to start by looking at what comes with vanilla PAL (what comes with standard SAP). Many designs are possible (this previous post shows some possibilities), but in each case there is a capacity that is constrained. For each time period and allocation characteristics (market, customer, etc) there is a bucket with a defined capacity. When the capacity is reached no more orders can be confirmed on the bucket.

This control system is quite similar to something I have at home - the flush toilet. When water reaches the capacity of the tank, the valve is closed and the inflow of water stops. Same with PAL, only that the tank capacity is defined by the user.

The flush toilet is an on-off feedback controller (uses the information of water level to decide on closing the valve). So PAL should also be an on-off feedback controller if the objective was to control the maximal capacity of the bucket.

But this is business software, the natural objective function should somehow relate to maximizing profit. And of course, it will always be profit related and only on few exceptions profit will be equivalent to bucket capacity limitation.

If the goal is to split the available capacity and it is guaranteed that there will be demand to fill each bucket, then capacity limitation and profit are equivalent. This happens because sales profit is constant (all available capacity will be sold) and the additional strategic value related to allocating the products to the desired customers is maximized. This scenario happens, for example when new and over-hyped products are launched or when short time promotions are done.

But it would be surprising, even in fast growing economies, that demand is always so much large than supply that whatever buckets are defined all capacity is sold. Because when that happens prices are increased to restore balance to the market and increase the profit. So most of the times, for sales allocation purpose, demand is only slightly larger than supply and the goal of PAL controlling has to be different - it must be maximizing capacity usage (all material must be sold) while minimizing the difference between actual and planned bucket allocation.

So if the control objective is not used for the control actions, it is an open loop controller. At home I have to check the temperature and manually change the controller set-point for the inflow of energy. Some PAL users have to manually change the bucket capacities (quotas) to reach the objective.

From experience I know that a vanilla PAL works quite well with peak demand (promotions, etc) and it is more problematic in the most common balanced market scenario. I find it interesting that it works well when it is a feedback controller and not so well when it is an open loop controller. So making sure that PAL is always a feedback controller should be a design goal.

Open loop controller at home

2008-12-18T23:13:00.004Z

In my house the heating system is made of electrical heaters that are mainly connected during the night (electricity is cheaper at night where I live). And during the day the heat accumulated in ceramic materials is slowly released.

To control when the heater should be connected I have a clock timers in the electrical plugs with the scheduled night hours.

This clock device is an open loop controller (a controler that makes decisions without information of the controlled variable). It is also a good example of the disadvantages of such systems. Since there is no feedback loop, the temperature will vary depending on the external conditions, since the heat input will remain constant. Sometimes it becomes too cold in the house and I need to connect it manually some more hours. When the winter is coming to an end temperature increases, and then I know it is time to reduce the programmed number of hours.

This system has some advantages but it's terrible if one wants to have good control of the temperature. And it would be expensive if I was to spend time analyzing the measured temperatures and manually trying to adjust the number of hours to adjust the system to the external conditions changes. It would be expensive because my time is limited.

Looking at what comes with the SAP standard, gATP PAL is an open loop controller (to be continued).

Product Allocation

2008-12-18T23:11:00.003Z

When I think of science I always think of something exciting like invention. But truth is that many times it is not more than transfering knowledge between similar areas. Like moving furniture between rooms. It's not exciting but it is much more effective than building something new from scratch on the other room.

So I've been moving some furniture between control theory and gATP product allocation. I'll try to write down my findings in a series of posts.

Data references

2008-12-15T14:48:00.004Z

The following is the data reference equivalent to the example code using an object. It's shorter but less clear (IMHO).


TYPES:
  BEGIN OF t_place,
    place TYPE char30,
  END OF t_place,
  t_place_tab TYPE TABLE OF t_place,
  BEGIN OF t_city,
    city_name TYPE char20,
    places_ref TYPE REF TO data,
  END OF t_city.

FIELD-SYMBOLS:
  <ref> TYPE t_place_tab.

DATA:
  gt_city TYPE HASHED TABLE OF t_city WITH UNIQUE KEY city_name,
  gs_city TYPE t_city,
  gs_place TYPE t_place.

START-OF-SELECTION.
  gs_city-city_name = 'Porto'.
  CREATE DATA gs_city-places_ref TYPE t_place_tab.
  ASSIGN gs_city-places_ref->* TO <ref>.
  gs_place-place = 'Torre dos Clerigos'.
  APPEND gs_place TO <ref>.
  gs_place-place = 'Casa da Musica'.
  APPEND gs_place TO <ref>.
  gs_place-place = 'Serralves'.
  APPEND gs_place TO <ref>.

  INSERT gs_city INTO TABLE gt_city.

  gs_city-city_name = 'New York'.
  CREATE DATA gs_city-places_ref TYPE t_place_tab.
  ASSIGN gs_city-places_ref->* TO <ref>.
  gs_place-place = 'Empire State Building'.
  APPEND gs_place TO <ref>.
  gs_place-place = 'Central Park'.
  APPEND gs_place TO <ref>.

  INSERT gs_city INTO TABLE gt_city.

  READ TABLE gt_city INTO gs_city WITH KEY city_name = 'Porto'.
  IF sy-subrc = 0.
    ASSIGN gs_city-places_ref->* TO <ref>.
    SORT <ref> BY place.
    LOOP AT <ref> INTO gs_place.
      WRITE: / gs_city-city_name, gs_place-place.
    ENDLOOP.
  ENDIF.

Objects instead of references

2008-10-31T19:11:00.002Z

The ABAP syntax for working with tables is really good. But the syntax for working with references is crap.

Many times, for the sake of efficiency, I need to mix references and tables. And I never found an easy way to do that in ABAP.

For example, I want to have a table with thousands of city names and for each city I want to have a table of dozens of places. Then, for a given city I want to get the list of places and do some actions on that data (sorting, removing, changing, etc). Notice that it is not a good idea to have just one table with both cities and places because each sublist operation would have a big penalty because of the big size of the full table.

In python it is so easy:


cities = {'Porto':['Casa da Musica','Serralves','Torre dos Clerigos'],
   'New York': ['Empire State Building','Central Park'] }

#print the sorted list of places in Porto
cities['Porto'].sort()
print cities['Porto']

In ABAP I find myself using objects because the resulting syntax is cleaner. It looks something like this:


TYPES:
  BEGIN OF t_place,
    place TYPE char30,
  END OF t_place.

TYPES:
  t_tab_places TYPE TABLE OF t_place.

CLASS place_obj DEFINITION.
  PUBLIC SECTION.
    DATA places_table TYPE t_tab_places.
    METHODS add_place IMPORTING place_name TYPE char30.
  PRIVATE SECTION.
ENDCLASS.                    "place DEFINITION

CLASS place_obj IMPLEMENTATION.
  METHOD add_place.
    DATA ls_place TYPE t_place.
    ls_place-place = place_name.
    APPEND ls_place TO places_table.
  ENDMETHOD.                 
ENDCLASS.                    

TYPES:
  BEGIN OF t_city,
    city_name TYPE char20,
    places_ref TYPE REF TO place_obj,
  END OF t_city.

DATA:
  gt_city TYPE HASHED TABLE OF t_city WITH UNIQUE KEY city_name,
  gs_city TYPE t_city,
  gs_place TYPE t_place.

DATA oref TYPE REF TO place_obj.

START-OF-SELECTION.
  gs_city-city_name = 'Porto'.
  CREATE OBJECT oref.
  gs_city-places_ref = oref.
  CALL METHOD oref->add_place( 'Torre dos Clerigos' ).
  CALL METHOD oref->add_place( 'Casa da Musica' ).
  CALL METHOD oref->add_place( 'Serralves' ).
  INSERT gs_city INTO TABLE gt_city.

  gs_city-city_name = 'New York'.
  CREATE OBJECT oref.
  gs_city-places_ref = oref.
  CALL METHOD oref->add_place( 'Empire State Building' ).
  CALL METHOD oref->add_place( 'Central Park' ).
  INSERT gs_city INTO TABLE gt_city.

  READ TABLE gt_city INTO gs_city WITH KEY city_name = 'Porto'.
  IF sy-subrc = 0.
    oref = gs_city-places_ref.
    SORT oref->places_table BY place.
    LOOP AT oref->places_table INTO gs_place.
      WRITE: / gs_city-city_name, gs_place-place.
    ENDLOOP.

But it's still far from perfect. Dear lazy web, is there a better way?

Modeling Limits and Reservations with gATP Product Allocation

2008-09-01T11:57:00.014+01:00

Product Allocation (PAL), is the APO tool that enables quota definition for the ATP process. With this tool it is possible, for example, to setup quotas for customers to have more control in the distribution of the stock or plant production capacity. For more on product allocation see here and here.

Although PAL can be used to model quotas for any characteristic in the sales order, here I will use the simple scenario of modeling quotas for customers to highlight two major topics: limits and reservations.

A very standard way of using the PAL tool is to set limits for the quantity a customer can buy in a given time period (for example month). Suppose we have a plant that can make 1000 M3 of material, and we have three main customers (A, B, and C) that every month need 400, 300 and 300 M3. We can define the quotas in a single procedure with a single step (the graphic represents a step and each color in the graphic a characteristic combination in the step).

This means that customer A can take at most 400 M3, but it also means that customer A will have reserved 400 M3 of production capacity, because all others together cannot take more than 600 M3.

This last model works well when there is almost fixed demand. But it does not allow any new customer to place and order and have ATP confirmation. A different scenario for a company with many customers is to model two or three important customers and have some quota for all the others (PAL has a wildcard that represents all the other elements in the set). For example:

Again this model is a both a limit and a reservation of the quantity the customers can get. It works well when the demand is greater than the production capacity, so the result will be equal to the quotas and the excess orders will be rejected or postponed.

Still with this simple model, it is possible to have some interesting variants. Let's suppose the company is interested in putting a limit on the quantity A and B can get in a given month, but it does not want to reserve them capacity. It should be possible for the other customers to take all the capacity. In this case quotas are defined as limits, and for each element we define the limit we want to impose. And for others we give the total plant capacity (this assumes there will be limitations on the ATP product check, or in alternative a new step can be added with the plant capacity constraint).

But there are other common scenarios that this simple model does not represent well. Considering again the last model, let's say customer A is a good customer that usually buys from 200 M3 to 500 M3. The plant wants to reserve 200 M3 of capacity but wants to allow him to allocate up to 600 M3. And for customer B reserve 100 M3 and allow up to 500 M3. This kind of business rule is not modeled adequately by the single step, single procedure model we have been using.

Product allocation modeling is done by a combination of procedures. Each procedure is made of one or several steps and each step has one or several characteristic combinations. These are the modeling building blocks of PAL and they allow a large number of possibilities.

The characteristic combinations are the customers we have been using (A, B and others, for example). The sequence of steps means the PAL check will go to each step in sequence and will use the resulting quantity and date from one step as the input of the next step. On the other hand, when using several procedures the PAL check gets a confirmed quantity from each of the procedures and uses the one that first confirms the requested quantity or the one that allows a larger confirmation.

I usually like to think of the steps as mathematical sets, the characteristics combinations are elements in the set. In this analogy the sequence of steps represent set intersections and the different procedures are set unions.

Getting back to the modeling scenario, if we model each customer in a step, we can set the limit (the customer quota) and also reserve quantity (the difference between the "others" quota and the plant capacity).

For the last example, let's suppose the company just wants to have some minimal capacity reservations (100M3 for customer A and B). The remaining capacity is to be given on first come first served basis. This is better modeled as a sequence of procedures (set union). The first procedure has the capacities for A and B. The system first checks on the first procedure, if quantity is missing it goes to the second procedure, that, in this case has the quantities available for all customers.

Although the documentation only highlights the standard "limits" model definition, with PAL it's possible to design many different allocation strategies.

SAP on Mac

2008-04-29T20:47:00.001+01:00

SAP with that annoying windows bug fixed.

* Not really fixed, windows is running inside a virtual machine (VMWare). But since it allows to run applications outside the VM box, SAP feels like a OSX application.

Tutorial on ABAP functions for DP macros

2008-02-20T15:09:00.008Z

It seems that there is no standard function to calculate the statistical mode. So I thought it would make a good example for a short tutorial on creation of ABAP functions to be used in planning macros.

The macro functions are standard functions created with SE37 that must have a specific call signature (input and output parameters and tables). The base parameters are the ones shown in the following figure (later other options are presented).

The VALUE_TAB structure has two fields, one for numbers and one for strings. All input parameters set in the macro are added to this table in the same order as defined in the macro, in the number or string field depending on the data type.

For our exemple the function will receive a list of numbers. The goal is to calculate the mode of the integer part of the numbers. Since the mode can be a list of several numbers, we intend to return the largest integer number of the list.

Bellow is the code for such a function. It just counts the frequency of the numbers (after convertion to integers). The final list is sorted and the mode (or maximum of modes) is returned on the output parameter field F_ARGUMENT. The other parameter F_CALC_ERROR is a flag that should be set in case of errors that cannot be handled (the equivalent of raising an exception).


FUNCTION z_macro_maxmode .
*"----------------------------------------------------------------------
*"*"Local interface:
*"  TABLES
*"      VALUE_TAB STRUCTURE  /SAPAPO/VALUE_TAB
*"  CHANGING
*"     REFERENCE(F_CALC_ERROR) TYPE  C
*"     REFERENCE(F_ARGUMENT) TYPE  /SAPAPO/MXSOP-V
*"----------------------------------------------------------------------

 TYPES:
   BEGIN OF t_histogram,
     value   TYPE i,
     counter TYPE i,
   END OF t_histogram.

 DATA:
   lv_value TYPE i,
   ls_hist  TYPE t_histogram,
   lt_hist  TYPE TABLE OF t_histogram WITH KEY value.

 LOOP AT value_tab.
   IF value_tab-string IS INITIAL.
     CLEAR ls_hist.
*     just truncated integers to make it simpler
     lv_value = trunc( value_tab-value ).
     READ TABLE lt_hist WITH TABLE KEY value = lv_value INTO ls_hist.
     IF sy-subrc = 0.
*     already in the table, increase the counter
       ls_hist-counter = ls_hist-counter + 1.
       MODIFY TABLE lt_hist FROM ls_hist TRANSPORTING counter.
     ELSE.
*     insert value for the first time in the table
       ls_hist-value = lv_value.
       ls_hist-counter = 1.
       INSERT ls_hist INTO TABLE lt_hist.
     ENDIF.
   ENDIF.
 ENDLOOP.

* return the integer with largest counter (if more than one return the
* largest integer)
 SORT lt_hist BY counter DESCENDING value DESCENDING.
 READ TABLE lt_hist INDEX 1 INTO ls_hist.

 f_argument = ls_hist-value.

ENDFUNCTION.

Now this function can be added to the macro builder (/sapapo/advm). First one registers the function using the following menu option.

A list of parameters is shown. The previous macro only uses the base parameters so no other checkbox is flagged, but here is the place to choose the parameter options.

Then the macro is created with the new function being called like the standard ones.

I've found that moving logic to ABAP functions can be a good way to simplify complex macros.

I'm using the wrong APO

2007-12-15T18:57:00.000Z

First this post opened my eyes. Maybe I was using the wrong APO. Then Google sent me the answer on an adsense link (I'm both amazed and scared on how Google makes these guesses). I should be using APO reef!

On Debugging Planning Macros

2007-12-07T11:20:00.001Z

Lately I have been dealing with some planning macros. I am a newbie with these macros but I have a lot of experience with ABAP debugging. That's why I was quite happy with the following trick that allows ABAP debugging of planning macros.

In the macro builder, for a given macro just put the command ADVA in the command window.

It will jump to the ABAP source generated for the macro.

It is a big source file so it may be hard to find the right section to place the breakpoint. I found it helpful to set a stop point in the macro in the step I want to debug.

Then I search the code for PERFORM RESULTS_SHOW.

That's it.

Quickies

2007-11-20T15:47:00.000Z

From searchSAP a very useful tip to find BADIs (quick instructions: break on SXV_GET_CLIF_BY_NAME, use the TA and check the name in EXIT_NAME when it stops).

I have to highlight this comment posted by Zoltan with a finding in the BOP source code. I won't say more, you must check it :-)

In the same spirit, this post by Nigel James has a funny finding on CRM source.

Hello World

2007-10-11T16:08:00.000+01:00

One of the joys of having a blog is being able to connect to people all over the world. Today I checked the blog statistics (more or less one year of data since I installed google analytics), and it made be very happy. No less than 98 countries, including some exotic places I would really like to visit some day: Mauritius, Trinidad and Tobago, Yemen, Namibia, Uruguay, Peru, Moldova, Panama, and many others (click to enlarge the picture).

The world is a great place.

How to use ABAP HTTP_POST

2007-09-29T19:30:00.000+01:00

SAP has the function modules HTTP_GET and HTTP_POST to call remote urls. With HTTP_GET one can just had parameters in the URL to send information to the external system. For example, setting the url to


http://myserver.com/mypage?x=1&y=10

sends x=1 and y=10 as parameters to mypage. The problem with HTTP GET is that there is a limit on the ammount of data that can be sent (technically it is unlimited in the new specification, but there are still servers that impose the old limit).

To send large ammounts of data using HTTP one should use the POST method (ABAP function HTTP_POST). To accomplish the same call with HTTP_POST first the length of the data must be calculated


len("x=1&y=10") = 8

then the function must be called with the following parameters


ABSOLUTE_URI                  http://myserver.com/mypage
REQUEST_ENTITY_BODY_LENGTH    8
REQUEST_ENTITY_BODY           x=1&y=10

The function group URL_GENERATION has some data quoting functions to help build valid URLs. Also, the introspector tool is helpful to debug the HTTP calls.

PS. This post was originally in pvl.freezope.org, but that site is down most of the time so I'm moving it here.

Very interesting new ATP BADI

2007-09-28T09:17:00.000+01:00

The parameter dependent safety stock (PASS) is a very interesting functionality introduced in SCM 5. In its standard form one can use the forecasted demand to calculate a safety stock requirement during the ATP process. But the calculation of the safety stock value can use any other logic we want if we use the extension BADI /SAPAPO/ATP_PSS.

The process flow is very simple:

1) In the sales order we make sure that all information need for the calculation is transfered to APO through the field catalogue.

2) In the BADI we calculate the value we want for the PASS.

3) The ATP introduced the PASS dummy requirement as the first requirement in the list .

4) The ATP information returned to the user shows the amount of PASS that was used (which the user should read as: there is this amount of product/capacity, but its reserved for other kind of orders)

5) At the end of the ATP process the PASS requirement is removed.

This functionality has many use cases. The one described in the documentation is quite typical. The company wants to keep some quantity always available for rush orders, so a PASS value is defined and the user exit changes the PASS value to zero when the order type is of type "rush order".

A slightly more complex use case is to use PASS to enforce the allocation quotas at the product availability level. Product allocation is decoupled from the product availability check in ATP, so if a customer has consumed all allocation for the current period the system will shift the availability date to first day of the next period. But it will still be consuming stock/receipts from the previous period if such elements exist. For example, in the picture bellow the red customer places two orders of 100 in month 1. Since he only has 100 of allocation in each month the second order date is shifted for the first day of month 2. But it still uses the receipt from month 1.

When the orange customer places an order of 200 on month 1 it fails. It is possible from the point of view of allocation, but since the red customer orders are both using the receipt of month 1 the system can only confirm the orange order in month 2.

This is the typical problem and with PASS this scenario can be improved. Based on the allocation data (quota and consumption) a PASS value can be calculated to protect the allocation receipts. That way, when the latter customers place their orders the system will still have both allocation and receipts to confirm the orders in the expected periods. The picture bellow shows the same process when using PASS to protect the open allocation of the orange customer.

A last remark on using PASS with the R3. The documentation makes a reference that it is only supported by CRM and it seems to be because there is no user interface to define the PASS type parameter that APO is expecting to receive from R3. But using the BADI APO_BAPI_BUS10400 we can change the parameters coming from R3 and, in this case, we just need to put something like:


METHOD if_ex_apo_bapi_bus10400~change_inputparamextern.
  DATA: ls_req TYPE bapi10400req.
  LOOP AT requirements INTO ls_req.
    ls_req-safety_stock_parameter = 'P'.
    MODIFY requirements INDEX sy-tabix FROM ls_req.
  ENDLOOP.
ENDMETHOD.