<tt>mapfi()</tt>



next up previous contents index
Next: Other Utilities Up: Expression Management Previous: Expression Management

mapfi()

  mapfi() To re-evaluate each of the components of the metric and its inverse and actually change the stored components the function mapfi()gif is used. In its simplest form, mapfi() takes an indexed object name and re-evaluates in-place each component of the object. We can apply the new let rule to the metric and its inverse by

 
#: mapfi(g);

 g2

#: mapfi(g_inv);

 g2_inv
If the switch showindices is on, the index of each component is displayed during the computation. A side effect of mapfi() is that the multiplier of an object is combined with each of its components, and the multiplier property is reset to 1. The old values of the object are saved, and can be recovered if the user immediately executes the restoreobj() command. Only one object is saved by the system at a time, hence the need to immediately recover. If in doubt, the user can also make a backup by copying the object with the icopy() function (see below).

The mapfi() function is not limited to such simple things as re-evaluating an indexed object in a new environment, it can also be used to apply specific functions to specific portions of the object. The most general format of the call to mapfi() is

 
  mapfi(function(name{index},{args}));
where <function> is some function that operates on algebraic expressions. The indexed object can either be just a name (so that the function is applied to the whole object) or an index that isolates part of the object, or even a fixed index, so that a single element is affected. mapfi() works by inserting each component of the indexed object into the input expression and evaluating it. The input can in fact be any expression but is most often a sub() command or occasionally a Taylor series function such as ps().

For example, if the user entered a general static spherically symmetric metric, and then wanted to substitute , it could be done in two ways. First, an actual assignment to the variable f could be made, followed by an application of mapfi() similar to that demonstrated above. However, other objects involving f would also be affected if they were involved in indexed assignments, or if mapfi() were applied. To make the substitution into only a single object can be done as follows:

 
#: mapfi(sub(f=1-2*m/r,g3));  % g3 is a metric defined in terms of f

   g3
If it were necessary to use a series approximation to the metric coefficients about , this could be done via
 
#: mapfi(ps(g3,r,2*m));

   g3

Continuing with the Kerr metric example, we can define the derivatives of the as yet unevaluated symbols rho2 and delta, and compute the Ricci tensor:

 
#: depend delta,r;

#: depend rho2,r,th;

#: let df(rho2,r) = 2*r;

#: let df(delta,r) = 2*r-2*m;

#: let df(rho2,th) = -2*a^2*sin(th)*cos(th);

#: ricci();

computing g2_ric
  computing g2_R
    computing g2_c1
    christoffel1 finished. 
    computing g2_c2
    christoffel2 finished.
  riemann finished.

 g2_ric
At this point in the calculation, the Ricci tensor g2_ric will still appear to have non-zero components, since rho2 and delta remain unevaluated. For other metrics it may be found that it is better to not evaluate the derivatives, or it may be best to fully evaluate everything from the start. It is a matter of trying different possibilities to determine which allows the successful completion of the calculation. If certain terms remain unevaluated, then sooner or later they must be given their actual values; the issue is when to do this so as to balance the growth of expressions. Evaluating too soon may mean the expressions swell (especially if a sum in a denominator is formed in the metric inverse), whereas delayed evaluation may mean that many cancellations have not occurred, and a large amount of work must now be done to insert the terms. For another example of this sort of work, see the Sato metric in Appendix B.  

It is in all cases, however, best to avoid the occurrence of radicals such as would be formed if the substitution in the Kerr metric were for rather than . Many algebraic systems seem to have difficulties where radicals are concerned, and since the computation of the higher order tensors involves differentiation more radicals will be formed. It is almost always best to make a substitution for the radical since its derivatives can be defined in terms of itself, and this often reduces the complexity of expressions.

The final simplication of the Ricci tensor for the Kerr metric can be done with a single mapfi() command:

 
#: clear r^2;

#: mapfi(sub(delta = r^2+a^2-2*m*r,rho2=r^2+a^2*cos(th)^2,ric));

 g2_ric
Note that is was necessary to clear the substitution rule for r^2, since otherwise this would result in a circular evaluation for rho2. A package for managing the various let rules and assignments in the system is described in §7.1.

It may be observed that attempting to evaluate the Ricci tensor for this metric when delta and rho2 are given their actual values at the outset results in a Heap space exhausted fatal error on some systems. The value of carefully controlling evaluations is therefore apparent. It is useful to turn on the showindices switch when working with an unfamiliar metric, because a judgement can then be made as to whether the calculations are proceeding at an acceptable rate, and whether a different approach might be more profitable. The switch peek when on acts like showindices, but causes the system to indicate whether a component has evaluated to zero or not. The user can then immediately see if the calculation is proceeding correctly (assuming, as is often the case, that zero is the expected answer).



next up previous contents index
Next: Other Utilities Up: Expression Management Previous: Expression Management



John Harper
Wed Nov 16 13:34:23 EST 1994