http://baldufa.upc.edu/xjaen/ttc/tutorial/esential.htm
Essential TTC
Sections in this chapter:
IntroductionHow to load the program
How to introduce a coordinate system
How to define tensor objects
How to introduce a metric tensor
For other chapters go to Index
Introduction
Here you will find a minimal set of TTC functions that allows you to make a lot of tensor operations. If you want to learn more things about TTC you could go to IndexHow to load the program
You must have at least the file ttc.m . Then input<<path/ttc.m
----------------------------------------
|TTC: Tools of Tensor Calculus 4.3.1|
| A.Balfagon,P.Castellvi and X.Jaen |
| http://baldufa.upc.edu/ttc |
| e-mail:Xavier.Jaen@upc.edu |
| version: june, 1, 2005 |
----------------------------------------
| TTC works correctly with |
| Cell menu options: |
| Default Input FormatType=InputForm |
| Default Output FormatType=OutputForm |
----------------------------------------
| Session started on |
| June, 5 , 2005 |
| at 17 h 50 min 6.981 s |
----------------------------------------
After, you can decide if you want to work with the Compact switch
On
or
Off
. The default value is
Off
which means that the dispaly of of results explicit (
E
) tensor calculus is full but big computation can run slowly. If
On
the dispaly is shorted (using
TTC
[
number
]) and the computation gain in time and memory
How to introduce a coordinate system
?InputCoordinates InputCoordinates[x, {x1, x2,...}] declares the coordinate system named x with symbols x1, x2,... Once the coordinates system named x has been declared x[x1,x3,...] can be used to input tensor basis InputCoordinates[XX, n], being n a positive number sets the dimension of the default system XX to n. InputCoordinates[cs,{z,t,x,q}] {XX, {X1, X2, X3}} {cs, {z, t, x, q}}To see how to input tensors using this coordinate system see How to define tensor objects
How to define tensor objects
There are two ways of define tensors in TTC . Explicit tensors ( E-tensors ) and symbolic tensors ( S-tensors )S-tensors
are tensors (/scalars) defined through a symbol which must be declared. First of use symbolic index calcultion you must declare a choosed list of symbols which will be used as index to output the results
?InputIndex InputIndex[indexlist] is the way to introduce or to change the index you want to use in the present session. The list must to have minimum one element, say {i}, then i1,i2,i3,...etc will be used us a index if nedeed. InputIndex[{i,j,k,l}] {i, j, k, l}Now we can define a tensor
?InputTensor InputTensor[T,basis,tensortype] is the way to input a symbolic tensor InputTensor[W,XX,{1,1}]; {W}
We can also define some symmetric properties for this tensor Here we define W as an antisymmetric tensor using InputSymmetries
?InputSymmetries InputSymmetries[T[i,j,a,b,m],{{i,m}}[1], {i,a,b}[2],{{i,j},{a,b}}[1]] will define the following symmetries for the indexes of the predefined tensor T: {{i,m}} (i,m) antisymmetrics {i,a,b} (i,a,b) symmetrics {{i,j},{a,b}} ((i,j)(a,b)) pairsymmetric Cyclic[i,a,b] (i,a,b) cyclic. The list of symetries specifications can be as long as you want. The numbers [1] [2]...[n]..indicates that the property will be used with BasicRules[n]. See examples in TTC tutorial. Example the Levi Civita like symmetries: InputSymmetries[s[i,j,k,l],{{i,j,k,l}}[1 ]] Example: the riemann like symmetries : InputSymmetries[R[i,j,k,l], {{i,j}}[1],{{k,l}}[1],{{i,j},{k,l}}[2],C yclic[j,k,l][2]] InputSymmetries[R[i,j,k,l,.;m],Cyclic[k, l,m][2]] See examples in TTC tutorial. InputSymmetries[W[a,b],{{a,b}}[1]]Now the tensor is ready to be used. We use the Index function with its first argument empty to indicate that the metric to be used when nedeed is the Euclidean one. The following input is the tranposed of the tensor W ( we use the tensor 0 in order to set a prefixed order of index)
?Index Index is the function used for doing computations in index notation. 0[a,-b]+W[-b,a]//Index[] i i 0 + W j j %//Index[,SimplifyAllIndex[2]] i i 0 - W j jHere we define the scalar field h and the constant M. Then input an expression which includes the characters ".; " used for covariant derivative. We use SuperIndexExpand to expand the expression. After we explicit the non constant scalar fields and reinput the same expression.
InputTensor[h,XX,{}] {W,h} InputTensor[M,XX,{},{Constant}] {W, h, M} (M h)[.;-l]//Index[] 0 + (M h) i .;i %//Index[,SuperIndexExpand] 0 + M h i .;i Compact[Off] Off h=X1^2+X2^2+X1 X2 X3 2 2 X1 + X2 + X1 X2 X3 (M h)[.;-l]//Index[] Storing AbsoluteD Tensor M (2 X1 + X2 X3) dX1 + M (2 X2 + X1 X3) dX2 + M X1 X2 dX3Other examples can be found in: RiemanRules
E-tensors
To write explicit tensors it is not necesary that previously there exist as a symbolic ones. That is you can use explicit (E )calculus without known nothing about symbolic calculus (S).
You can use the coordinates as usual to define scalar fields. Note that we have used the symbol "=>" instead of "=" . If you want you can use "=" but in general TTCprefer "=>"
Compact[On] On A=>z^2 t+q/(M+2 x) TTC[1]The symbol A is attached to a compact object TTC[1] which can be momentary displayed using UncompactTensor or permanently displayed (this and others) using Compact[Off]
A//UncompactTensor q 2 ------- + t z M + 2 x Compact[Off] Off A q 2 ------- + t z M + 2 x
The only thing you need to learn in order to handle explicit tensor fields is how to write the basis for vectors and forms ( related to our coordinates system cs)
the form dt
cs[t] dtthe vector
cs[-t] Dtnow using the symbol *. for the tensor product we can write all kind of tensor field as a linear combination of tensor basis elements
2 z q^2 cs[t]*.cs[-t]+3 q x cs[z]*. cs[-x] 2 3 q x dz*.Dx + 2 q z dt*.DtFor quickly inputs we can use cs[t,-t].... instead of cs[t]*.cs[-t]...
2 z a cs[t,-t]+z^2 cs[z,-q] 2 z dz*.Dq + 2 a z dt*.Dtwe can use this objects as usual in the context of Mathematica objects (use of % or Out[]...)
(cs[-q]*. 2 %%+cs[-x]*. %%)*. % 2 6 q x z Dq*.dz*.Dx*.dz*.Dq + 12 a q x z Dq*.dz*.Dx*.dt*.Dt + 2 3 4 q z Dq*.dt*.Dt*.dz*.Dq + 2 2 8 a q z Dq*.dt*.Dt*.dt*.Dt + 2 3 q x z Dx*.dz*.Dx*.dz*.Dq + 6 a q x z Dx*.dz*.Dx*.dt*.Dt + 2 3 2 q z Dx*.dt*.Dt*.dz*.Dq + 2 2 4 a q z Dx*.dt*.Dt*.dt*.DtAlso we can perform any kind of indexed operation (Now without metric)
?Index Index is the function used for doing computations in index notation. T=>%%%% 2 3 q x dz*.Dx + 2 q z dt*.Dt T[-i,j]//Index[] 2 3 q x dz*.Dx + 2 q z dt*.Dt T[-i,i]//Index[] Storing Contracted Tensor 2 2 q z T[-i,j] cs[t][-j]//Index[] 2 2 q z dt T[-i,j] cs[x][-j] cs[-z][i]//Index[] 3 q xWe use the symbols ".," in order to indicate the usual "," used for partial derivative operation
T[-i,j,.,-k]//Index[] 2 3 q dz*.Dx*.dx + 3 x dz*.Dx*.dq + 2 q dt*.Dt*.dz + 4 q z dt*.Dt*.dq
How to introduce a metric tensor
S-tensorsYou can make symbolic index calculations using a symbolic metric declared with InputSMetric. If later you need to explicit the calculations you would use InputMetric by using the same names for the metric and coordinates
?InputSMetric InputSMetric[metricname,coordinatename,outputstring,inputsymbol] Is the way to define a symbolic metric. metricname is the name of the metric we want to use, coordinatename is the name of the actual coordinates, outputstring is the symbol used to display the metric, inputsymbol is the symbol for the metric used in tensorial expressions. InputSMetric[gcs,cs,"g",g] {W, h, M, g} g[i,-i]//Index[gcs] 4 InputTensor[Q,cs,{1,1}] { W, h, M, g, Q} Q[i,-j] g[j,k]//Index[gcs] i j i j 0 + QE-tensors
?InputMetric InputMetric[g, b, t] declares the tensor t to be the metric named g in basis b. InputMetric[gcs,cs, z cs[t,t] + q cs[q,q]+ t q cs[x,x]+x q cs[z,z]] q x dz*.dz + z dt*.dt + q t dx*.dx + q dq*.dq Metric[gcs,cs] q x dz*.dz + z dt*.dt + q t dx*.dx + q dq*.dq
Now we can perform metric dependent operations
T[i,j]//Index[gcs] 2 2 q Dt*.Dt + 3 Dz*.Dx T[-i,-j]//Index[gcs] 2 2 2 3 q t x dz*.dx + 2 q z dt*.dt T[i,j] T[-i,-j]//Index[gcs] 2 4 2 9 q t x + 4 q z T[-i,-j,.,k]//Index[gcs] 6 t x dz*.dx*.Dq + 3 q dz*.dx*.Dx + 2 3 q x 2 ------ dz*.dx*.Dt + 4 z dt*.dt*.Dq + z 4 q z ----- dt*.dt*.Dz x
We use the symbols ".;" in order to indicate the usual ";" used for covariant derivative operation
T[-i,-j,.;-k]//Index[gcs] 2 3 q x 2 ------ dz*.dz*.dz - q z dz*.dt*.dt - 2 2 2 3 q x 3 q x ------ dz*.dt*.dx + ------ dz*.dx*.dt + 2 2 2 3 q t ------ dz*.dx*.dx + 3 q t x dz*.dx*.dq - 2 3 q t x 2 ------- dz*.dq*.dx - q z dt*.dz*.dt + 2 2 2 2 q z dt*.dt*.dz + 4 q z dt*.dt*.dq + 3 q t 3 ----- dt*.dx*.dt + q z dt*.dx*.dx + 2 2 3 3 q t q z dx*.dt*.dx - ------ dx*.dx*.dz - 2 3 q t x ------- dq*.dx*.dz 2 T[-i,-j,.;k]//Index[gcs] 3 q 3 q x 2 --- dz*.dz*.Dz - ----- dz*.dt*.Dx - q dz*.dt*.Dt + 2 2 t 3 q 3 t x dz*.dx*.Dq + --- dz*.dx*.Dx + 2 2 3 q x 3 x 2 ------ dz*.dx*.Dt - --- dz*.dq*.Dx - q dt*.dz*.Dt + 2 z 2 2 2 q z 4 z dt*.dt*.Dq + ----- dt*.dt*.Dz + x 2 q z 3 q t ---- dt*.dx*.Dx + ----- dt*.dx*.Dt + t 2 z 2 q z 3 q t 3 t ---- dx*.dt*.Dx - ----- dx*.dx*.Dz - --- dq*.dx*.Dz t 2 x 2 %[-i,-j,-k] T[i,k]//Index[gcs] 2 2 3 4 9 q x 3 (3 q t + 2 q t) -2 q z dz - ------ dt + ------------------- dx - 2 2 9 q t x ------- dq 2 Metric[gcs,cs][-i,-j]//Index[gcs] q x dz*.dz + z dt*.dt + q t dx*.dx + q dq*.dq Metric[gcs,cs][i,-j]//Index[gcs] Dq*.dq + Dx*.dx + Dt*.dt + Dz*.dz Metric[gcs,cs][-i,j]//Index[gcs] dz*.Dz + dt*.Dt + dx*.Dx + dq*.Dq Metric[gcs,cs][-i,-j,.;-k]//Index[gcs] 0 Metric[gcs,cs][-i,i]//Index[gcs] 4
This page is maintained by XavierJaén.