| blob | 09bbff55baa81001447a478c4d19dba5fd142378 |
1 @c /Ctensor.texi/1.31/Sun Jul 30 08:49:51 2006/-ko/
2 @menu
3 * Introdução a ctensor::
4 * Definições para ctensor::
5 @end menu
7 @node Introdução a ctensor, Definições para ctensor, ctensor, ctensor
8 @section Introdução a ctensor
10 @code{ctensor} é um pacote de manipulação de
11 componentes. Para usar o pacote @code{ctensor}, digite
12 @code{load("ctensor")}. Para começar uma sessão iterativa
13 com @code{ctensor}, digite @code{csetup()}. O primeiro que será pedido
14 pelo pacote é a dimensão a ser manipulada. Se a dimensão for 2, 3
15 ou 4 então a lista de coordenadas padrão é @code{[x,y]},
16 @code{[x,y,z]} ou @code{[x,y,z,t]} respectivamente. Esses nomes podem
17 ser mudados através da atribuição de uma nova lista de
18 coordenadas para a variável @code{ct_coords} (descrita abaixo) e o
19 utilizador é questionado sobre isso. Deve ter o cuidado de evitar
20 conflitos de nomes de coordenadas com outras definições
21 de objectos.
23 No próximo passo, o utilizador informa a métrica ou directamente ou
24 de um ficheiro especificando sua posição ordinal. Como
25 um exemplo de um ficheiro de métrica comum, veja
26 @file{share/tensor/metrics.mac}. A métrica é armazenada na matriz
27 LG. Finalmente, o inverso da métrica é calculado e armazenado na
28 matriz UG. Se tem a opção de realizar todos os
29 cálculos em séries de potência.
31 A seguir, mostramos um exemplo de protocolo para a métrica estática,
32 esfericamente simétrica (coordenadas padrão) que será aplicada ao
33 problema de derivação das equações de
34 vácuo de Einstein (que levam à solução de
35 Schwarzschild). Muitas das funções em @code{ctensor}
36 irão ser mostradas como exemplos para a métrica padrão.
38 @example
39 (%i1) load("ctensor");
40 (%o1) /usr/local/lib/maxima/share/tensor/ctensor.mac
41 (%i2) csetup();
42 Enter the dimension of the coordinate system:
43 4;
44 Do you wish to change the coordinate names?
45 n;
46 Do you want to
47 1. Enter a new metric?
49 2. Enter a metric from a file?
51 3. Approximate a metric with a Taylor series?
52 1;
54 Is the matrix 1. Diagonal 2. Symmetric 3. Antisymmetric 4. General
55 Answer 1, 2, 3 or 4
56 1;
57 Row 1 Column 1:
58 a;
59 Row 2 Column 2:
60 x^2;
61 Row 3 Column 3:
62 x^2*sin(y)^2;
63 Row 4 Column 4:
64 -d;
66 Matrix entered.
67 Enter functional dependencies with the DEPENDS function or 'N' if none
68 depends([a,d],x);
69 Do you wish to see the metric?
70 y;
71 [ a 0 0 0 ]
72 [ ]
73 [ 2 ]
74 [ 0 x 0 0 ]
75 [ ]
76 [ 2 2 ]
77 [ 0 0 x sin (y) 0 ]
78 [ ]
79 [ 0 0 0 - d ]
80 (%o2) done
81 (%i3) christof(mcs);
82 a
83 x
84 (%t3) mcs = ---
85 1, 1, 1 2 a
87 1
88 (%t4) mcs = -
89 1, 2, 2 x
91 1
92 (%t5) mcs = -
93 1, 3, 3 x
95 d
96 x
97 (%t6) mcs = ---
98 1, 4, 4 2 d
100 x
101 (%t7) mcs = - -
102 2, 2, 1 a
104 cos(y)
105 (%t8) mcs = ------
106 2, 3, 3 sin(y)
108 2
109 x sin (y)
110 (%t9) mcs = - ---------
111 3, 3, 1 a
113 (%t10) mcs = - cos(y) sin(y)
114 3, 3, 2
116 d
117 x
118 (%t11) mcs = ---
119 4, 4, 1 2 a
120 (%o11) done
122 @end example
124 @c end concepts ctensor
125 @node Definições para ctensor, , Introdução a ctensor, ctensor
127 @section Definições para ctensor
129 @subsection Inicialização e configuração
131 @deffn {Função} csetup ()
132 É uma função no pacote @code{ctensor} (component
133 tensor) que inicializa o pacote e permite ao utilizador inserir uma
134 métrica interativamente. Veja @code{ctensor} para mais detalhes.
135 @end deffn
137 @deffn {Função} cmetric (@var{dis})
138 @deffnx {Função} cmetric ()
139 É uma função no pacote @code{ctensor} que calcula o
140 inverso da métrica e prepara o pacote para cálculos adiante.
142 Se @code{cframe_flag} for @code{false}, a função calcula
143 a métrica inversa @code{ug} a partir da matriz @code{lg} (definida
144 pelo utilizador). O determinante da métrica é também calculado e
145 armazenado na variável @code{gdet}. Mais adiante, o pacote determina
146 se a métrica é diagonal e escolhe o valor de @code{diagmetric}
147 conforme a determinação. Se o argumento opcional
148 @var{dis} estiver presente e não for @code{false}, a
149 saída é mostrada ao utilizador pela linha de comando
150 para que ele possa ver o inverso da métrica.
152 Se @code{cframe_flag} for @code{true}, a função espera
153 que o valor de @code{fri} (a matriz referencial inversa) e @code{lfg} (a
154 métrica do referencial) sejam definidas. A partir dessas, a matriz do
155 referencial @code{fr} e a métrica do referencial inverso @code{ufg}
156 são calculadas.
158 @end deffn
160 @deffn {Função} ct_coordsys (@var{sistema_de_coordenadas}, @var{extra_arg})
161 @deffnx {Função} ct_coordsys (@var{sistema_de_coordenadas})
162 Escolhe um sistema de coordenadas predefinido e uma métrica. O
163 argumento @var{sistema_de_coordenadas} pode ser um dos seguintes
164 símbolos:
166 @example
168 SYMBOL Dim Coordenadas Descrição/comentários
169 --------------------------------------------------------------------------
170 cartesian2d 2 [x,y] Sist. de coord. cartesianas 2D
171 polar 2 [r,phi] Sist. de coord. Polare
172 elliptic 2 [u,v]
173 confocalelliptic 2 [u,v]
174 bipolar 2 [u,v]
175 parabolic 2 [u,v]
176 cartesian3d 3 [x,y,z] Sist. de coord. cartesianas 3D
177 polarcylindrical 3 [r,theta,z]
178 ellipticcylindrical 3 [u,v,z] Elíptica 2D com Z cilíndrico
179 confocalellipsoidal 3 [u,v,w]
180 bipolarcylindrical 3 [u,v,z] Bipolar 2D com Z cilíndrico
181 paraboliccylindrical 3 [u,v,z] Parabólico 2D com Z cilíndrico
182 paraboloidal 3 [u,v,phi]
183 conical 3 [u,v,w]
184 toroidal 3 [u,v,phi]
185 spherical 3 [r,theta,phi] Sist. de coord. Esféricas
186 oblatespheroidal 3 [u,v,phi]
187 oblatespheroidalsqrt 3 [u,v,phi]
188 prolatespheroidal 3 [u,v,phi]
189 prolatespheroidalsqrt 3 [u,v,phi]
190 ellipsoidal 3 [r,theta,phi]
191 cartesian4d 4 [x,y,z,t] Sist. de coord. 4D
192 spherical4d 4 [r,theta,eta,phi]
193 exteriorschwarzschild 4 [t,r,theta,phi] Métrica de Schwarzschild
194 interiorschwarzschild 4 [t,z,u,v] Métrica de Schwarzschild Interior
195 kerr_newman 4 [t,r,theta,phi] Métrica simétrica axialmente alterada
197 @end example
199 @code{sistema_de_coordenadas} pode também ser uma lista de funções de transformação,
200 seguida por uma lista contendo as varáveis coordenadas. Por exemplo,
201 pode especificar uma métrica esférica como segue:
203 @example
205 (%i1) load("ctensor");
206 (%o1) /share/tensor/ctensor.mac
207 (%i2) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
208 r*sin(theta),[r,theta,phi]]);
209 (%o2) done
210 (%i3) lg:trigsimp(lg);
211 [ 1 0 0 ]
212 [ ]
213 [ 2 ]
214 (%o3) [ 0 r 0 ]
215 [ ]
216 [ 2 2 ]
217 [ 0 0 r cos (theta) ]
218 (%i4) ct_coords;
219 (%o4) [r, theta, phi]
220 (%i5) dim;
221 (%o5) 3
223 @end example
225 Funções de transformação podem também
226 serem usadas quando @code{cframe_flag} for @code{true}:
228 @example
230 (%i1) load("ctensor");
231 (%o1) /share/tensor/ctensor.mac
232 (%i2) cframe_flag:true;
233 (%o2) true
234 (%i3) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
235 r*sin(theta),[r,theta,phi]]);
236 (%o3) done
237 (%i4) fri;
238 [ cos(phi) cos(theta) - cos(phi) r sin(theta) - sin(phi) r cos(theta) ]
239 [ ]
240 (%o4) [ sin(phi) cos(theta) - sin(phi) r sin(theta) cos(phi) r cos(theta) ]
241 [ ]
242 [ sin(theta) r cos(theta) 0 ]
243 (%i5) cmetric();
244 (%o5) false
245 (%i6) lg:trigsimp(lg);
246 [ 1 0 0 ]
247 [ ]
248 [ 2 ]
249 (%o6) [ 0 r 0 ]
250 [ ]
251 [ 2 2 ]
252 [ 0 0 r cos (theta) ]
254 @end example
256 O argumento opcional @var{extra_arg} pode ser qualquer um dos seguintes:
257 @c LOOKING AT share/tensor/ctensor.mac CIRCA LINE 837, misner IS RECOGNIZED ALSO; WHAT EFFECT DOES IT HAVE ??
259 @code{cylindrical} diz a @code{ct_coordsys} para anexar uma coordenada
260 adicional cilíndrica.
262 @code{minkowski} diz a @code{ct_coordsys} para anexar uma coordenada com
263 assinatura métrica negativa.
265 @code{all} diz a @code{ct_coordsys} para chamar @code{cmetric} e
266 @code{christof(false)} após escolher a métrica.
268 @c GLOBAL VARIABLE verbose IS USED IN ctensor.mac IN JUST THIS ONE CONTEXT
269 Se a variável global @code{verbose} for escolhida para @code{true},
270 @code{ct_coordsys} mostra os valores de @code{dim}, @code{ct_coords}, e
271 ou @code{lg} ou @code{lfg} e @code{fri}, dependendo do valor de
272 @code{cframe_flag}.
274 @end deffn
276 @deffn {Função} init_ctensor ()
277 Inicializa o pacote @code{ctensor}.
279 A função @code{init_ctensor} reinicializa o pacote
280 @code{ctensor}. Essa função remove todos os arrays e
281 matrizes usados por @code{ctensor}, coloca todos os sinalizadores de
282 volta a seus valores padrão, retorna @code{dim} para 4, e retorna a
283 métrica do referencial para a métrica do referencial de Lorentz.
285 @end deffn
288 @subsection Os tensores do espaço curvo
290 O principal propósito do pacote @code{ctensor} é calcular os
291 tensores do espaç(tempo) curvo, mais notavelmente os
292 tensores usados na relatividade geral.
294 Quando uma base métrica é usada, @code{ctensor} pode calcular os
295 seguintes tensores:
297 @example
299 lg -- ug
300 \ \
301 lcs -- mcs -- ric -- uric
302 \ \ \
303 \ tracer - ein -- lein
304 \
305 riem -- lriem -- weyl
306 \
307 uriem
310 @end example
312 @code{ctensor} pode também usar referenciais móveis. Quando
313 @code{cframe_flag} for escolhida para @code{true}, os seguintes tensores
314 podem ser calculados:
316 @example
318 lfg -- ufg
319 \
320 fri -- fr -- lcs -- mcs -- lriem -- ric -- uric
321 \ | \ \ \
322 lg -- ug | weyl tracer - ein -- lein
323 |\
324 | riem
325 |
326 \uriem
328 @end example
330 @deffn {Função} christof (@var{dis})
331 Uma função no pacote @code{ctensor}. Essa
332 função calcula os símbolos de Christoffel
333 de ambos os tipos. O argumento @var{dis} determina quais resultados
334 são para serem imediatamente mostrados. Os símbolos de
335 Christoffel de primeiro e de segundo tipo são armazenados nos arrays
336 @code{lcs[i,j,k]} e @code{mcs[i,j,k]} respectivamente e definidos para
337 serem simétricos nos primeiros dois índices. Se o
338 argumento para @code{christof} for @code{lcs} ou for @code{mcs} então
339 o único valor não nulo de @code{lcs[i,j,k]} ou de @code{mcs[i,j,k]},
340 respectivamente, será mostrado. Se o argumento for @code{all} então
341 o único valor não nulo de @code{lcs[i,j,k]} e o único valor não
342 nulo de @code{mcs[i,j,k]} serão mostrados. Se o argumento for
343 @code{false} então a exibição dos elementos não
344 acontecerá. Os elementos do array @code{mcs[i,j,k]} são definidos de
345 uma tal maneira que o índice final é contravariante.
346 @end deffn
348 @deffn {Função} ricci (@var{dis})
349 Uma função no pacote @code{ctensor}. @code{ricci}
350 calcula as componentes contravariantes (simétricas) @code{ric[i,j]} do
351 tensor de Ricci. Se o argumento @var{dis} for @code{true}, então as
352 componentes não nulas são mostradas.
353 @end deffn
355 @deffn {Função} uricci (@var{dis})
356 Essa função primeiro calcula as componentes
357 contravariantes @code{ric[i,j]} do tensor de Ricci. Então o tensor
358 misto de Ricci é calculado usando o tensor métrico contravariante.
359 Se o valor do argumento @var{dis} for @code{true}, então essas
360 componentes mistas, @code{uric[i,j]} (o índice "i" é
361 covariante e o índice "j" é contravariante), serão
362 mostradas directamente. De outra forma, @code{ricci(false)} irá
363 simplesmente calcular as entradas do array @code{uric[i,j]} sem mostrar
364 os resultados.
366 @end deffn
367 @deffn {Função} scurvature ()
369 Retorna a curvatura escalar (obtida através da
370 contração do tensor de Ricci) do Riemaniano multiplicado
371 com a métrica dada.
373 @end deffn
374 @deffn {Função} einstein (@var{dis})
375 Uma função no pacote @code{ctensor}. @code{einstein}
376 calcula o tensor misto de Einstein após os símbolos de
377 Christoffel e o tensor de Ricci terem sido obtidos (com as
378 funções @code{christof} e @code{ricci}). Se o argumento
379 @var{dis} for @code{true}, então os valores não nulos do tensor
380 misto de Einstein @code{ein[i,j]} serão mostrados quando @code{j} for
381 o índice contravariante. A variável @code{rateinstein}
382 fará com que a simplificação racional ocorra sobre
383 esses componentes. Se @code{ratfac} for @code{true} então as
384 componentes irão também ser factoradas.
386 @end deffn
387 @deffn {Função} leinstein (@var{dis})
388 Tensor covariante de Einstein. @code{leinstein} armazena o valor do
389 tensor covariante de Einstein no array @code{lein}. O tensor covariante
390 de Einstein é calculado a partir tensor misto de Einstein @code{ein}
391 através da multiplicação desse pelo tensor
392 métrico. Se o argumento @var{dis} for @code{true}, então os valores
393 não nulos do tensor covariante de Einstein são mostrados.
395 @end deffn
397 @deffn {Função} riemann (@var{dis})
398 Uma função no pacote @code{ctensor}. @code{riemann}
399 calcula o tensor de curvatura de Riemann a partir da métrica dada e
400 correspondendo aos símbolos de Christoffel. As seguintes
401 convenções de índice são usadas:
403 @example
404 l _l _l _l _m _l _m
405 R[i,j,k,l] = R = | - | + | | - | |
406 ijk ij,k ik,j mk ij mj ik
407 @end example
409 Essa notação é consistente com a
410 notação usada por no pacote @code{itensor} e sua
411 função @code{icurvature}. Se o argumento opcional
412 @var{dis} for @code{true}, as componentes não nulas
413 @code{riem[i,j,k,l]} serão mostradas. Como com o tensor de Einstein,
414 vários comutadores escolhidos pelo utilizador controlam a
415 simplificação de componentes do tensor de Riemann. Se
416 @code{ratriemann} for @code{true}, então simplificação
417 racional será feita. Se @code{ratfac} for @code{true} então cada uma
418 das componentes irá também ser factorada.
420 Se a variável @code{cframe_flag} for @code{false}, o tensor de Riemann
421 é calculado directamente dos símbolos de Christoffel. Se
422 @code{cframe_flag} for @code{true}, o tensor covariante de Riemann é
423 calculado primeiro dos coeficientes de campo do referencial.
425 @end deffn
427 @deffn {Função} lriemann (@var{dis})
428 Tensor covariante de Riemann (@code{lriem[]}).
430 Calcula o tensor covariante de Riemann como o array @code{lriem}. Se o
431 argumento @var{dis} for @code{true}, únicos valores não nulos são
432 mostrados.
434 Se a variável @code{cframe_flag} for @code{true}, o tensor covariante
435 de Riemann é calculado directamente dos coeficientes de campo do
436 referencial. De outra forma, o tensor (3,1) de Riemann é calculado
437 primeiro.
439 Para informação sobre a ordenação de
440 índice, veja @code{riemann}.
442 @end deffn
444 @deffn {Função} uriemann (@var{dis})
445 Calcula as componentes contravariantes do tensor de curvatura
446 de Riemann como elementos do array @code{uriem[i,j,k,l]}. Esses são
447 mostrados se @var{dis} for @code{true}.
449 @end deffn
451 @deffn {Função} rinvariant ()
452 Compõe o invariante de Kretchmann (@code{kinvariant}) obtido através
453 da contração dos tensores
455 @example
456 lriem[i,j,k,l]*uriem[i,j,k,l].
457 @end example
459 Esse objecto não é automaticamente simplificado devido ao facto de
460 poder ser muito largo.
462 @end deffn
464 @deffn {Função} weyl (@var{dis})
465 Calcula o tensor conformal de Weyl. Se o argumento @var{dis} for
466 @code{true}, as componentes não nulas @code{weyl[i,j,k,l]} irão ser
467 mostradas para o utilizador. De outra forma, essas componentes irão
468 simplesmente serem calculadas e armazenadas. Se o comutador
469 @code{ratweyl} é escolhido para @code{true}, então as componentes
470 irão ser racionalmente simplificadas; se @code{ratfac} for @code{true}
471 então os resultados irão ser factorados também.
473 @end deffn
475 @subsection Expansão das séries de Taylor
477 O pacote @code{ctensor} possui a habilidade para truncar resultados
478 assumindo que eles são aproximações das séries de
479 Taylor. Esse comportamenteo é controlado através da variável
480 @code{ctayswitch}; quando escolhida para @code{true}, @code{ctensor} faz
481 uso internamente da função @code{ctaylor} quando
482 simplifica resultados.
484 A função @code{ctaylor} é invocada pelas seguintes funções de @code{ctensor}:
486 @example
488 Function Comments
489 ---------------------------------
490 christof() só para mcs
491 ricci()
492 uricci()
493 einstein()
494 riemann()
495 weyl()
496 checkdiv()
497 @end example
499 @deffn {Função} ctaylor ()
501 A função @code{ctaylor} trunca seus argumentos através
502 da conversão destes para uma série de Taylor usando @code{taylor}, e
503 então chamando @code{ratdisrep}. Isso tem efeito combinado de
504 abandonar termos de ordem mais alta na variável de expansão
505 @code{ctayvar}. A ordem dos termos que podem ser abandonados é
506 definida através de @code{ctaypov}; o ponto em torno do qual a
507 expansão da série é realizada está especificado em
508 @code{ctaypt}.
510 Como um exemplo, considere uma métrica simples que é uma
511 perturbação da métrica de Minkowski. Sem
512 restrições adicionais, mesmo uma métrica diagonal
513 produz expressões para o tensor de Einstein que são de longe muito
514 complexas:
516 @example
518 (%i1) load("ctensor");
519 (%o1) /share/tensor/ctensor.mac
520 (%i2) ratfac:true;
521 (%o2) true
522 (%i3) derivabbrev:true;
523 (%o3) true
524 (%i4) ct_coords:[t,r,theta,phi];
525 (%o4) [t, r, theta, phi]
526 (%i5) lg:matrix([-1,0,0,0],[0,1,0,0],[0,0,r^2,0],[0,0,0,r^2*sin(theta)^2]);
527 [ - 1 0 0 0 ]
528 [ ]
529 [ 0 1 0 0 ]
530 [ ]
531 (%o5) [ 2 ]
532 [ 0 0 r 0 ]
533 [ ]
534 [ 2 2 ]
535 [ 0 0 0 r sin (theta) ]
536 (%i6) h:matrix([h11,0,0,0],[0,h22,0,0],[0,0,h33,0],[0,0,0,h44]);
537 [ h11 0 0 0 ]
538 [ ]
539 [ 0 h22 0 0 ]
540 (%o6) [ ]
541 [ 0 0 h33 0 ]
542 [ ]
543 [ 0 0 0 h44 ]
544 (%i7) depends(l,r);
545 (%o7) [l(r)]
546 (%i8) lg:lg+l*h;
547 [ h11 l - 1 0 0 0 ]
548 [ ]
549 [ 0 h22 l + 1 0 0 ]
550 [ ]
551 (%o8) [ 2 ]
552 [ 0 0 r + h33 l 0 ]
553 [ ]
554 [ 2 2 ]
555 [ 0 0 0 r sin (theta) + h44 l ]
556 (%i9) cmetric(false);
557 (%o9) done
558 (%i10) einstein(false);
559 (%o10) done
560 (%i11) ntermst(ein);
561 [[1, 1], 62]
562 [[1, 2], 0]
563 [[1, 3], 0]
564 [[1, 4], 0]
565 [[2, 1], 0]
566 [[2, 2], 24]
567 [[2, 3], 0]
568 [[2, 4], 0]
569 [[3, 1], 0]
570 [[3, 2], 0]
571 [[3, 3], 46]
572 [[3, 4], 0]
573 [[4, 1], 0]
574 [[4, 2], 0]
575 [[4, 3], 0]
576 [[4, 4], 46]
577 (%o12) done
579 @end example
581 Todavia, se nós recalcularmos esse exemplo como uma
582 aproximação que é linear na variável @code{l},
583 pegamos expressões muito simples:
585 @example
587 (%i14) ctayswitch:true;
588 (%o14) true
589 (%i15) ctayvar:l;
590 (%o15) l
591 (%i16) ctaypov:1;
592 (%o16) 1
593 (%i17) ctaypt:0;
594 (%o17) 0
595 (%i18) christof(false);
596 (%o18) done
597 (%i19) ricci(false);
598 (%o19) done
599 (%i20) einstein(false);
600 (%o20) done
601 (%i21) ntermst(ein);
602 [[1, 1], 6]
603 [[1, 2], 0]
604 [[1, 3], 0]
605 [[1, 4], 0]
606 [[2, 1], 0]
607 [[2, 2], 13]
608 [[2, 3], 2]
609 [[2, 4], 0]
610 [[3, 1], 0]
611 [[3, 2], 2]
612 [[3, 3], 9]
613 [[3, 4], 0]
614 [[4, 1], 0]
615 [[4, 2], 0]
616 [[4, 3], 0]
617 [[4, 4], 9]
618 (%o21) done
619 (%i22) ratsimp(ein[1,1]);
620 2 2 4 2 2
621 (%o22) - (((h11 h22 - h11 ) (l ) r - 2 h33 l r ) sin (theta)
622 r r r
624 2 2 4 2
625 - 2 h44 l r - h33 h44 (l ) )/(4 r sin (theta))
626 r r r
630 @end example
632 Essa compatibilidade pode ser útil, por exemplo, quando trabalhamos no
633 limite do campo fraco longe de uma fonte gravitacional.
635 @end deffn
638 @subsection Campos de referencial
640 Quando a variável @code{cframe_flag} for escolhida para @code{true}, o
641 pacote @code{ctensor} executa seus cálculos usando um referencial
642 móvel.
644 @deffn {Função} frame_bracket (@var{fr}, @var{fri}, @var{diagframe})
645 O delimitador do referencial (@code{fb[]}).
647 Calcula o delimitador do referencial conforme a seguinte
648 definição:
650 @example
651 c c c d e
652 ifb = ( ifri - ifri ) ifr ifr
653 ab d,e e,d a b
654 @end example
656 @end deffn
658 @subsection Classificação Algébrica
660 Um novo recurso (a partir de November de 2004) de @code{ctensor} é sua habilidade para
661 calcular a classificação de Petrov de uma métrica espaço tempo tetradimensional.
662 Para uma demonstração dessa compatibilidade, veja o ficheiro
663 @code{share/tensor/petrov.dem}.
665 @deffn {Função} nptetrad ()
666 Calcula um tetrad nulo de Newman-Penrose (@code{np}) e seus índices ascendentes
667 em contrapartida (@code{npi}). Veja @code{petrov} para um exemplo.
669 O tetrad nulo é construído assumindo que um referencial
670 métrico ortonormal tetradimensional com assinatura métrica (-,+,+,+)
671 está sendo usada. As componentes do tetrad nulo são relacionadas
672 para a matriz referencial inversa como segue:
674 @example
676 np = (fri + fri ) / sqrt(2)
677 1 1 2
679 np = (fri - fri ) / sqrt(2)
680 2 1 2
682 np = (fri + %i fri ) / sqrt(2)
683 3 3 4
685 np = (fri - %i fri ) / sqrt(2)
686 4 3 4
688 @end example
690 @end deffn
692 @deffn {Função} psi (@var{dis})
693 Calcula os cinco coeficientes de Newman-Penrose @code{psi[0]}...@code{psi[4]}.
694 Se @code{psi} for escolhida para @code{true}, os coeficientes são mostrados.
695 Veja @code{petrov} para um exemplo.
697 Esses coeficientes são calculados a partir do tensor de Weyl em uma
698 base de coordenada. Se uma base de referencial for usada, o tensor de Weyl
699 é primeiro convertido para a base de coordenada, que pode ser um
700 procedimento computacional expansível. Por essa razão,
701 em alguns casos pode ser mais vantajoso usar uma base de coordenada em
702 primeiro lugar antes que o tensor de Weyl seja calculado. Note todavia,
703 que para a construção de um tetrad nulo de
704 Newman-Penrose é necessário uma base de referencial. Portanto, uma
705 sequência de cálculo expressiva pode começar com uma
706 base de referencial, que é então usada para calcular @code{lg}
707 (calculada automaticamente através de @code{cmetric}) e em seguida
708 calcula @code{ug}. Nesse ponto, pode comutar de volta para uma base de
709 coordenada escolhendo @code{cframe_flag} para @code{false} antes de
710 começar a calcular os símbolos de
711 Christoffel. Mudando para uma base de referencial num estágio posterior
712 pode retornar resultados inconsistentes, já que pode terminar com uma
713 grande mistura de tensores, alguns calculados numa base de referencial, e
714 outros numa base de coordenada, sem nenhum modo para distinguir entre os
715 dois tipos.
717 @end deffn
719 @deffn {Função} petrov ()
720 Calcula a classificação de petrov da métrica caracterizada através de @code{psi[0]}...@code{psi[4]}.
722 Por exemplo, o seguinte demonstra como obter a classificação de Petrov
723 da métrica de Kerr:
725 @example
726 (%i1) load("ctensor");
727 (%o1) /share/tensor/ctensor.mac
728 (%i2) (cframe_flag:true,gcd:spmod,ctrgsimp:true,ratfac:true);
729 (%o2) true
730 (%i3) ct_coordsys(exteriorschwarzschild,all);
731 (%o3) done
732 (%i4) ug:invert(lg)$
733 (%i5) weyl(false);
734 (%o5) done
735 (%i6) nptetrad(true);
736 (%t6) np =
738 [ sqrt(r - 2 m) sqrt(r) ]
739 [ --------------- --------------------- 0 0 ]
740 [ sqrt(2) sqrt(r) sqrt(2) sqrt(r - 2 m) ]
741 [ ]
742 [ sqrt(r - 2 m) sqrt(r) ]
743 [ --------------- - --------------------- 0 0 ]
744 [ sqrt(2) sqrt(r) sqrt(2) sqrt(r - 2 m) ]
745 [ ]
746 [ r %i r sin(theta) ]
747 [ 0 0 ------- --------------- ]
748 [ sqrt(2) sqrt(2) ]
749 [ ]
750 [ r %i r sin(theta) ]
751 [ 0 0 ------- - --------------- ]
752 [ sqrt(2) sqrt(2) ]
754 sqrt(r) sqrt(r - 2 m)
755 (%t7) npi = matrix([- ---------------------, ---------------, 0, 0],
756 sqrt(2) sqrt(r - 2 m) sqrt(2) sqrt(r)
758 sqrt(r) sqrt(r - 2 m)
759 [- ---------------------, - ---------------, 0, 0],
760 sqrt(2) sqrt(r - 2 m) sqrt(2) sqrt(r)
762 1 %i
763 [0, 0, ---------, --------------------],
764 sqrt(2) r sqrt(2) r sin(theta)
766 1 %i
767 [0, 0, ---------, - --------------------])
768 sqrt(2) r sqrt(2) r sin(theta)
770 (%o7) done
771 (%i7) psi(true);
772 (%t8) psi = 0
773 0
775 (%t9) psi = 0
776 1
778 m
779 (%t10) psi = --
780 2 3
781 r
783 (%t11) psi = 0
784 3
786 (%t12) psi = 0
787 4
788 (%o12) done
789 (%i12) petrov();
790 (%o12) D
792 @end example
794 A função de classificação Petrov é baseada no algoritmo publicado em
795 "Classifying geometries in general relativity: III Classification in practice"
796 por Pollney, Skea, e d'Inverno, Class. Quant. Grav. 17 2885-2902 (2000).
797 Exceto para alguns casos de teste simples, a implementação não está testada até
798 19 de Dezembro de 2004, e é provável que contenha erros.
800 @end deffn
803 @subsection Torsão e não metricidade
805 @code{ctensor} possui a habilidade de calcular e incluir coeficientes de torsão e não
806 metricidade nos coeficientes de conecção.
808 Os coeficientes de torsão são calculados a partir de um tensor fornecido pelo utilizador
809 @code{tr}, que pode ser um tensor de categoria (2,1). A partir disso, os coeficientes de
810 torsão @code{kt} são calculados de acordo com a seguinte fórmula:
812 @example
814 m m m
815 - g tr - g tr - tr g
816 im kj jm ki ij km
817 kt = -------------------------------
818 ijk 2
821 k km
822 kt = g kt
823 ij ijm
825 @end example
827 Note que somente o tensor de índice misto é calculao e armazenado no
828 array @code{kt}.
830 Os coeficientes de não metricidade são calculados a partir do vector de não metricidade
831 fornecido pelo utilizador @code{nm}. A partir disso, os coeficientes de não metricidade
832 @code{nmc} são calculados como segue:
834 @example
836 k k km
837 -nm D - D nm + g nm g
838 k i j i j m ij
839 nmc = ------------------------------
840 ij 2
842 @end example
844 onde D simboliza o delta de Kronecker.
846 Quando @code{ctorsion_flag} for escolhida para @code{true}, os valores de @code{kt}
847 são subtraídos dos coeficientes de conecção indexados mistos calculados através de
848 @code{christof} e armazenados em @code{mcs}. Similarmente, se @code{cnonmet_flag}
849 for escolhida para @code{true}, os valores de @code{nmc} são subtraídos dos
850 coeficientes de conecção indexados mistos.
852 Se necessário, @code{christof} chama as funções @code{contortion} e
853 @code{nonmetricity} com o objectivo de calcular @code{kt} e @code{nm}.
855 @deffn {Função} contortion (@var{tr})
857 Calcula os coeficientes de contorsão de categoria (2,1) a partir do tensor de torsão @var{tr}.
859 @end deffn
861 @deffn {Função} nonmetricity (@var{nm})
863 Calcula o coeficiente de não metricidade de categoria (2,1) a partir do vector de
864 não metricidade @var{nm}.
866 @end deffn
870 @subsection Recursos diversos
872 @deffn {Função} ctransform (@var{M})
873 Uma função no pacote @code{ctensor}
874 que irá executar uma transformação de coordenadas
875 sobre uma matriz simétrica quadrada arbitrária @var{M}. O utilizador deve informar as
876 funçãoes que definem a transformação. (Formalmente chamada @code{transform}.)
878 @end deffn
880 @deffn {Função} findde (@var{A}, @var{n})
882 Retorna uma lista de equações diferenciais únicas (expressões)
883 correspondendo aos elementos do array quadrado @var{n} dimensional
884 @var{A}. Actualmente, @var{n} pode ser 2 ou 3. @code{deindex} é uma lista global
885 contendo os índices de @var{A} correspondendo a essas únicas
886 equações diferenciais. Para o tensor de Einstein (@code{ein}), que
887 é um array dimensional, se calculado para a métrica no exemplo
888 abaixo, @code{findde} fornece as seguintes equações diferenciais independentes:
891 @example
892 (%i1) load("ctensor");
893 (%o1) /share/tensor/ctensor.mac
894 (%i2) derivabbrev:true;
895 (%o2) true
896 (%i3) dim:4;
897 (%o3) 4
898 (%i4) lg:matrix([a,0,0,0],[0,x^2,0,0],[0,0,x^2*sin(y)^2,0],[0,0,0,-d]);
899 [ a 0 0 0 ]
900 [ ]
901 [ 2 ]
902 [ 0 x 0 0 ]
903 (%o4) [ ]
904 [ 2 2 ]
905 [ 0 0 x sin (y) 0 ]
906 [ ]
907 [ 0 0 0 - d ]
908 (%i5) depends([a,d],x);
909 (%o5) [a(x), d(x)]
910 (%i6) ct_coords:[x,y,z,t];
911 (%o6) [x, y, z, t]
912 (%i7) cmetric();
913 (%o7) done
914 (%i8) einstein(false);
915 (%o8) done
916 (%i9) findde(ein,2);
917 2
918 (%o9) [d x - a d + d, 2 a d d x - a (d ) x - a d d x + 2 a d d
919 x x x x x x x
921 2 2
922 - 2 a d , a x + a - a]
923 x x
924 (%i10) deindex;
925 (%o10) [[1, 1], [2, 2], [4, 4]]
927 @end example
930 @end deffn
931 @deffn {Função} cograd ()
932 Calcula o gradiente covariante de uma função escalar permitindo ao
933 utilizador escolher o nome do vector correspondente como o exemplo sob
934 @code{contragrad} ilustra.
935 @end deffn
936 @deffn {Função} contragrad ()
938 Calcula o gradiente contravariante de uma função escalar permitindo
939 @c "vector^F2name^F*" LOOKS LIKE IT NEEDS TO BE FIXED UP, NOT SURE HOW THOUGH
940 ao utilizador escolher o nome do vector correspondente como o exemplo
941 abaixo como ilustra a métrica de Schwarzschild:
943 @example
945 (%i1) load("ctensor");
946 (%o1) /share/tensor/ctensor.mac
947 (%i2) derivabbrev:true;
948 (%o2) true
949 (%i3) ct_coordsys(exteriorschwarzschild,all);
950 (%o3) done
951 (%i4) depends(f,r);
952 (%o4) [f(r)]
953 (%i5) cograd(f,g1);
954 (%o5) done
955 (%i6) listarray(g1);
956 (%o6) [0, f , 0, 0]
957 r
958 (%i7) contragrad(f,g2);
959 (%o7) done
960 (%i8) listarray(g2);
961 f r - 2 f m
962 r r
963 (%o8) [0, -------------, 0, 0]
964 r
966 @end example
968 @end deffn
969 @deffn {Função} dscalar ()
970 Calcula o tensor d'Alembertiano da função escalar assim que
971 as dependências tiverem sido declaradas sobre a função. Po exemplo:
973 @example
974 (%i1) load("ctensor");
975 (%o1) /share/tensor/ctensor.mac
976 (%i2) derivabbrev:true;
977 (%o2) true
978 (%i3) ct_coordsys(exteriorschwarzschild,all);
979 (%o3) done
980 (%i4) depends(p,r);
981 (%o4) [p(r)]
982 (%i5) factor(dscalar(p));
983 2
984 p r - 2 m p r + 2 p r - 2 m p
985 r r r r r r
986 (%o5) --------------------------------------
987 2
988 r
989 @end example
991 @end deffn
992 @deffn {Função} checkdiv ()
994 Calcula a divergência covariante do tensor de segunda categoria misto
995 (cujo primeiro índice deve ser covariante) imprimindo as
996 correspondentes n componentes do campo do vector (a divergência) onde
997 n = @code{dim}. Se o argumento para a função for @code{g} então a
998 divergência do tensor de Einstein será formada e pode ser zero.
999 Adicionalmente, a divergência (vector) é dada no array chamado @code{div}.
1000 @end deffn
1002 @deffn {Função} cgeodesic (@var{dis})
1003 Uma função no pacote @code{ctensor}.
1004 @code{cgeodesic} calcula as equações geodésicas de
1005 movimento para uma dada métrica. Elas são armazenadas no array @code{geod[i]}. Se
1006 o argumento @var{dis} for @code{true} então essas equações são mostradas.
1008 @end deffn
1011 @deffn {Função} bdvac (@var{f})
1013 Gera as componentes covariantes das equações de campo de vácuo da
1014 teoria de gravitação de Brans-Dicke. O campo escalar é especificado
1015 através do argumento @var{f}, que pode ser um nome de função (com apóstrofo)
1016 com dependências funcionais, e.g., @code{'p(x)}.
1018 As componentes de segunda categoria do tensor campo covariante são as componentes de segunda categoria
1019 representadas pelo array @code{bd}.
1021 @end deffn
1023 @deffn {Função} invariant1 ()
1025 Gera o tensor misto de Euler-Lagrange (equações de campo) para a
1026 densidade invariante de R^2. As equações de campo são componentes de um
1027 array chamado @code{inv1}.
1029 @end deffn
1031 @deffn {Função} invariant2 ()
1033 *** NOT YET IMPLEMENTED ***
1035 Gera o tensor misto de Euler-Lagrange (equações de campo) para a
1036 densidade invariante de @code{ric[i,j]*uriem[i,j]}. As equações de campo são as
1037 componentes de um array chamado @code{inv2}.
1040 @end deffn
1041 @deffn {Função} bimetric ()
1043 *** NOT YET IMPLEMENTED ***
1045 Gera as euauações de campo da teoria bimétrica de Rosen. As equações
1046 de campo são as componentes de um array chamado @code{rosen}.
1048 @end deffn
1050 @subsection Funções utilitárias
1052 @deffn {Função} diagmatrixp (@var{M})
1054 Retorna @code{true} se @var{M} for uma matriz diagonal ou um array (2D).
1056 @end deffn
1058 @deffn {Função} symmetricp (@var{M})
1060 Retorna @code{true} se @var{M} for uma matriz simétrica ou um array (2D).
1062 @end deffn
1064 @deffn {Função} ntermst (@var{f})
1065 Fornece ao utilizador um rápido quadro do "tamanho" do tensor duplamente
1066 subscrito (array) @var{f}. Imprime uma lista de dois elementos onde o segundo
1067 elemento corresponde a N-TERMOS de componentes especificadas através dos primeiros
1068 elementos. Nesse caminho, é possível rapidamente encontrar as expressões
1069 não nulas e tentar simplificação.
1071 @end deffn
1073 @deffn {Função} cdisplay (@var{ten})
1074 Mostra todos os elementos do tensor @var{ten}, como representados por
1075 um array multidimensional. Tensores de categoria 0 e 1, assim como outros tipos de
1076 variáveis, são mostrados com @code{ldisplay}. Tensores de categoria 2 são
1077 mostrados como matrizes bidimensionais, enquanto tensores de alta categoria são mostrados
1078 como uma lista de matrizes bidimensionais. Por exemplo, o tensor de Riemann da
1079 métrica de Schwarzschild pode ser visto como:
1081 @example
1082 (%i1) load("ctensor");
1083 (%o1) /share/tensor/ctensor.mac
1084 (%i2) ratfac:true;
1085 (%o2) true
1086 (%i3) ct_coordsys(exteriorschwarzschild,all);
1087 (%o3) done
1088 (%i4) riemann(false);
1089 (%o4) done
1090 (%i5) cdisplay(riem);
1091 [ 0 0 0 0 ]
1092 [ ]
1093 [ 2 ]
1094 [ 3 m (r - 2 m) m 2 m ]
1095 [ 0 - ------------- + -- - ---- 0 0 ]
1096 [ 4 3 4 ]
1097 [ r r r ]
1098 [ ]
1099 riem = [ m (r - 2 m) ]
1100 1, 1 [ 0 0 ----------- 0 ]
1101 [ 4 ]
1102 [ r ]
1103 [ ]
1104 [ m (r - 2 m) ]
1105 [ 0 0 0 ----------- ]
1106 [ 4 ]
1107 [ r ]
1109 [ 2 m (r - 2 m) ]
1110 [ 0 ------------- 0 0 ]
1111 [ 4 ]
1112 [ r ]
1113 riem = [ ]
1114 1, 2 [ 0 0 0 0 ]
1115 [ ]
1116 [ 0 0 0 0 ]
1117 [ ]
1118 [ 0 0 0 0 ]
1120 [ m (r - 2 m) ]
1121 [ 0 0 - ----------- 0 ]
1122 [ 4 ]
1123 [ r ]
1124 riem = [ ]
1125 1, 3 [ 0 0 0 0 ]
1126 [ ]
1127 [ 0 0 0 0 ]
1128 [ ]
1129 [ 0 0 0 0 ]
1131 [ m (r - 2 m) ]
1132 [ 0 0 0 - ----------- ]
1133 [ 4 ]
1134 [ r ]
1135 riem = [ ]
1136 1, 4 [ 0 0 0 0 ]
1137 [ ]
1138 [ 0 0 0 0 ]
1139 [ ]
1140 [ 0 0 0 0 ]
1142 [ 0 0 0 0 ]
1143 [ ]
1144 [ 2 m ]
1145 [ - ------------ 0 0 0 ]
1146 riem = [ 2 ]
1147 2, 1 [ r (r - 2 m) ]
1148 [ ]
1149 [ 0 0 0 0 ]
1150 [ ]
1151 [ 0 0 0 0 ]
1153 [ 2 m ]
1154 [ ------------ 0 0 0 ]
1155 [ 2 ]
1156 [ r (r - 2 m) ]
1157 [ ]
1158 [ 0 0 0 0 ]
1159 [ ]
1160 riem = [ m ]
1161 2, 2 [ 0 0 - ------------ 0 ]
1162 [ 2 ]
1163 [ r (r - 2 m) ]
1164 [ ]
1165 [ m ]
1166 [ 0 0 0 - ------------ ]
1167 [ 2 ]
1168 [ r (r - 2 m) ]
1170 [ 0 0 0 0 ]
1171 [ ]
1172 [ m ]
1173 [ 0 0 ------------ 0 ]
1174 riem = [ 2 ]
1175 2, 3 [ r (r - 2 m) ]
1176 [ ]
1177 [ 0 0 0 0 ]
1178 [ ]
1179 [ 0 0 0 0 ]
1181 [ 0 0 0 0 ]
1182 [ ]
1183 [ m ]
1184 [ 0 0 0 ------------ ]
1185 riem = [ 2 ]
1186 2, 4 [ r (r - 2 m) ]
1187 [ ]
1188 [ 0 0 0 0 ]
1189 [ ]
1190 [ 0 0 0 0 ]
1192 [ 0 0 0 0 ]
1193 [ ]
1194 [ 0 0 0 0 ]
1195 [ ]
1196 riem = [ m ]
1197 3, 1 [ - 0 0 0 ]
1198 [ r ]
1199 [ ]
1200 [ 0 0 0 0 ]
1202 [ 0 0 0 0 ]
1203 [ ]
1204 [ 0 0 0 0 ]
1205 [ ]
1206 riem = [ m ]
1207 3, 2 [ 0 - 0 0 ]
1208 [ r ]
1209 [ ]
1210 [ 0 0 0 0 ]
1212 [ m ]
1213 [ - - 0 0 0 ]
1214 [ r ]
1215 [ ]
1216 [ m ]
1217 [ 0 - - 0 0 ]
1218 riem = [ r ]
1219 3, 3 [ ]
1220 [ 0 0 0 0 ]
1221 [ ]
1222 [ 2 m - r ]
1223 [ 0 0 0 ------- + 1 ]
1224 [ r ]
1226 [ 0 0 0 0 ]
1227 [ ]
1228 [ 0 0 0 0 ]
1229 [ ]
1230 riem = [ 2 m ]
1231 3, 4 [ 0 0 0 - --- ]
1232 [ r ]
1233 [ ]
1234 [ 0 0 0 0 ]
1236 [ 0 0 0 0 ]
1237 [ ]
1238 [ 0 0 0 0 ]
1239 [ ]
1240 riem = [ 0 0 0 0 ]
1241 4, 1 [ ]
1242 [ 2 ]
1243 [ m sin (theta) ]
1244 [ ------------- 0 0 0 ]
1245 [ r ]
1247 [ 0 0 0 0 ]
1248 [ ]
1249 [ 0 0 0 0 ]
1250 [ ]
1251 riem = [ 0 0 0 0 ]
1252 4, 2 [ ]
1253 [ 2 ]
1254 [ m sin (theta) ]
1255 [ 0 ------------- 0 0 ]
1256 [ r ]
1258 [ 0 0 0 0 ]
1259 [ ]
1260 [ 0 0 0 0 ]
1261 [ ]
1262 riem = [ 0 0 0 0 ]
1263 4, 3 [ ]
1264 [ 2 ]
1265 [ 2 m sin (theta) ]
1266 [ 0 0 - --------------- 0 ]
1267 [ r ]
1269 [ 2 ]
1270 [ m sin (theta) ]
1271 [ - ------------- 0 0 0 ]
1272 [ r ]
1273 [ ]
1274 [ 2 ]
1275 [ m sin (theta) ]
1276 riem = [ 0 - ------------- 0 0 ]
1277 4, 4 [ r ]
1278 [ ]
1279 [ 2 ]
1280 [ 2 m sin (theta) ]
1281 [ 0 0 --------------- 0 ]
1282 [ r ]
1283 [ ]
1284 [ 0 0 0 0 ]
1286 (%o5) done
1288 @end example
1289 @end deffn
1291 @deffn {Função} deleten (@var{L}, @var{n})
1292 Retorna uma nova lista consistindo de @var{L} com o @var{n}'ésimo elemento
1293 apagado.
1294 @end deffn
1296 @subsection Variáveis usadas por @code{ctensor}
1299 @defvr {Variável de opção} dim
1300 Valor por omissão: 4
1302 Uma opção no pacote @code{ctensor}.
1303 @code{dim} é a dimensão de multiplicação com o
1304 padrão 4. O comando @code{dim: n} irá escolher a dimensão para qualquer outro
1305 valor @code{n}.
1307 @end defvr
1309 @defvr {Variável de opção} diagmetric
1310 Valor por omissão: @code{false}
1312 Uma opção no pacote @code{ctensor}.
1313 Se @code{diagmetric} for @code{true} rotinas especiais calculam
1314 todos os objectos geométricos (que possuem o tensor métrico explicitamente)
1315 levando em consideração a diagonalidade da métrica. Tempo de
1316 execuçào reduzido irá, com certeza, resultar dessa escolha. Nota: essa opção é escolhida
1317 automaticamente por @code{csetup} se uma métrica diagonal for especificada.
1319 @end defvr
1321 @defvr {Variável de opção} ctrgsimp
1323 Faz com que simplificações trigonométricas sejam usadas quando tensores forem calculados. Actualmente,
1324 @code{ctrgsimp} afecta somente cálculos envolvendo um referencial móvel.
1326 @end defvr
1328 @defvr {Variável de opção} cframe_flag
1330 Faz com que cálculos sejam executados relativamente a um referencial
1331 móvel em oposição a uma métrica holonómica. O
1332 referencial é definido através do array do referencial inverso
1333 @code{fri} e da métrica do referencial @code{lfg}. Para cálculos
1334 usando um referencial Cartesiano, @code{lfg} pode ser a matriz
1335 unitária de dimensão apropriada; para cálculos num referencial
1336 de Lorentz, @code{lfg} pode ter a assinatura apropriada.
1338 @end defvr
1340 @defvr {Variável de opção} ctorsion_flag
1342 Faz com que o tensor de contorsão seja incluído no cálculo dos
1343 coeficientes de conecção. O tensor de contorsão por si mesmo é calculado através de
1344 @code{contortion} a partir do tensor @code{tr} fornecido pelo utilizador.
1346 @end defvr
1348 @defvr {Variável de opção} cnonmet_flag
1350 Faz com que os coeficientes de não metricidade sejam incluídos no cálculo dos
1351 coeficientes de conecção. Os coeficientes de não metricidade são calculados
1352 a partir do vector de não metricidade @code{nm} fornecido pelo utilizador através da função
1353 @code{nonmetricity}.
1355 @end defvr
1357 @defvr {Variável de opção} ctayswitch
1359 Se escolhida para @code{true}, faz com que alguns cálculos de @code{ctensor} sejam realizados usando
1360 expansões das séries de Taylor. actualmente, @code{christof}, @code{ricci},
1361 @code{uricci}, @code{einstein}, e @code{weyl} levam em conta essa
1362 escolha.
1364 @end defvr
1366 @defvr {Variável de opção} ctayvar
1368 Variável usada pela expansão de séries de Taylor se @code{ctayswitch} é escolhida para
1369 @code{true}.
1371 @end defvr
1373 @defvr {Variável de opção} ctaypov
1375 Maximo expoente usado em expansões de séries de Taylor quando @code{ctayswitch} for
1376 escolhida para @code{true}.
1378 @end defvr
1380 @defvr {Variável de opção} ctaypt
1382 Ponto em torno do qual expansões de séries de Taylor sao realizadas quando
1383 @code{ctayswitch} for escolhida para @code{true}.
1385 @end defvr
1387 @defvr {Variável de sistema} gdet
1389 O determinante do tensor métrico @code{lg}. Calculado através de @code{cmetric} quando
1390 @code{cframe_flag} for escolhido para @code{false}.
1392 @end defvr
1394 @defvr {Variável de opção} ratchristof
1396 Faz com que simplificações racionais sejam aplicadas através de @code{christof}.
1398 @end defvr
1400 @defvr {Variável de opção} rateinstein
1401 Valor por omissão: @code{true}
1403 Se @code{true} simplificação racional será
1404 executada sobre as componentes não nulas de tensores de Einstein; se
1405 @code{ratfac} for @code{true} então as componentes irão também ser factoradas.
1407 @end defvr
1408 @defvr {Variável de opção} ratriemann
1409 Valor por omissão: @code{true}
1411 Um dos comutadores que controlam
1412 simplificações dos tensores de Riemann; se @code{true}, então simplificações
1413 racionais irão ser concluídas; se @code{ratfac} for @code{true} então cada uma das
1414 componentes irá também ser factorada.
1416 @end defvr
1418 @defvr {Variável de opção} ratweyl
1419 Valor por omissão: @code{true}
1421 Se @code{true}, esse comutador faz com que a função de @code{weyl}
1422 aplique simplificações racionais aos valores do tensor de Weyl. Se
1423 @code{ratfac} for @code{true}, então as componentes irão também ser factoradas.
1424 @end defvr
1426 @defvr {Variável} lfg
1427 O referencial métrico covariante. Por padrão, é inicializado para
1428 o referencial tetradimensional de Lorentz com assinatura
1429 (+,+,+,-). Usada quando @code{cframe_flag} for @code{true}.
1430 @end defvr
1432 @defvr {Variável} ufg
1433 A métrica do referencial inverso. Calculada de @code{lfg} quando @code{cmetric} for chamada enquanto @code{cframe_flag} for escolhida para @code{true}.
1434 @end defvr
1436 @defvr {Variável} riem
1437 O tensor de categoria (3,1) de Riemann. Calculado quando a função @code{riemann} é invocada. Para informação sobre ordenação de índices, veja a descrição de @code{riemann}.
1439 Se @code{cframe_flag} for @code{true}, @code{riem} é calculado a partir do tensor covariante de Riemann @code{lriem}.
1441 @end defvr
1443 @defvr {Variável} lriem
1445 O tensor covariante de Riemann. Calculado através de @code{lriemann}.
1447 @end defvr
1449 @defvr {Variável} uriem
1451 O tensor contravariante de Riemann. Calculado através de @code{uriemann}.
1453 @end defvr
1455 @defvr {Variável} ric
1457 O tensor misto de Ricci. Calculado através de @code{ricci}.
1459 @end defvr
1461 @defvr {Variável} uric
1463 O tensor contravariante de Ricci. Calculado através de @code{uricci}.
1465 @end defvr
1467 @defvr {Variável} lg
1469 O tensor métrico. Esse tensor deve ser especificado (como uma @code{dim} através da matriz @code{dim})
1470 antes que outro cálculo possa ser executado.
1472 @end defvr
1474 @defvr {Variável} ug
1476 O inverso do tensor métrico. Calculado através de @code{cmetric}.
1478 @end defvr
1480 @defvr {Variável} weyl
1482 O tensor de Weyl. Calculado através de @code{weyl}.
1484 @end defvr
1486 @defvr {Variável} fb
1488 Coeficientes delimitadores do referencial, como calculado através de @code{frame_bracket}.
1490 @end defvr
1492 @defvr {Variável} kinvariant
1494 O invariante de Kretchmann. Calculado através de @code{rinvariant}.
1496 @end defvr
1498 @defvr {Variável} np
1500 Um tetrad nulo de Newman-Penrose. Calculado através de @code{nptetrad}.
1502 @end defvr
1504 @defvr {Variável} npi
1506 O índice ascendente do tetrad nulo de Newman-Penrose. Calculado através de @code{nptetrad}.
1507 Definido como @code{ug.np}. O produto @code{np.transpose(npi)} é constante:
1509 @example
1510 (%i39) trigsimp(np.transpose(npi));
1511 [ 0 - 1 0 0 ]
1512 [ ]
1513 [ - 1 0 0 0 ]
1514 (%o39) [ ]
1515 [ 0 0 0 1 ]
1516 [ ]
1517 [ 0 0 1 0 ]
1518 @end example
1520 @end defvr
1522 @defvr {Variável} tr
1524 Tensor de categoria 3 fornecido pelo utilizador representando torsão. Usado por @code{contortion}.
1525 @end defvr
1527 @defvr {Variável} kt
1529 O tensor de contorsão, calculado a partir de @code{tr} através de @code{contortion}.
1530 @end defvr
1532 @defvr {Variável} nm
1534 Vetor de não metrcidade fornecido pelo utilizador. Usado por @code{nonmetricity}.
1535 @end defvr
1537 @defvr {Variável} nmc
1539 Os coeficientes de não metricidade, calculados a partir de @code{nm} por @code{nonmetricity}.
1541 @end defvr
1543 @defvr {Variável de sistema} tensorkill
1545 Variável indicando se o pacote tensor foi inicializado. Escolhida e usada por
1546 @code{csetup}, retornada ao seu valor original através de @code{init_ctensor}.
1548 @end defvr
1550 @defvr {Variável de opção} ct_coords
1551 Valor por omissão: @code{[]}
1553 Uma opção no pacote @code{ctensor}.
1554 @code{ct_coords} contém uma lista de coordenadas.
1555 Enquanto normalmente definida quando a função @code{csetup} for chamada,
1556 se pode redefinir as coordenadas com a atribuição
1557 @code{ct_coords: [j1, j2, ..., jn]} onde os j's são os novos nomes de coordenadas.
1558 Veja também @code{csetup}.
1560 @end defvr
1562 @subsection Nomes reservados
1564 Os seguintes nomes são usados internamente pelo pacote @code{ctensor} e
1565 não devem ser redefinidos:
1567 @example
1568 Name Description
1569 ---------------------------------------
1570 _lg() Avalia para @code{lfg} se for usado o referencial métrico,
1571 para @code{lg} de outra forma
1572 _ug() Avalia para @code{ufg} se for usado o referencial métrico,
1573 para @code{ug} de outra forma
1574 cleanup() Remove ítens da lista @code{deindex}
1575 contract4() Usado por psi()
1576 filemet() Usado por csetup() quando lendo a métrica de um ficheiro
1577 findde1() Usado por findde()
1578 findde2() Usado por findde()
1579 findde3() Usado por findde()
1580 kdelt() Delta de Kronecker (não generalizado)
1581 newmet() Usado por csetup() para escolher uma métrica
1582 interativamente
1583 setflags() Usado por init_ctensor()
1584 readvalue()
1585 resimp()
1586 sermet() Usado por csetup() para informar uma métricacom série
1587 de Taylor
1588 txyzsum()
1589 tmetric() Referencial métrico, usado por cmetric() quando
1590 cframe_flag:true
1591 triemann() Tensor de Riemann na base do referencial, usado quando
1592 cframe_flag:true
1593 tricci() Tensor de Ricci na base do referencial, usado quando
1594 cframe_flag:true
1595 trrc() Coeficientes de rotação de Ricci, usado por
1596 christof()
1597 yesp()
1598 @end example
1601 @subsection Modificações
1603 Em Novembro de 2004, o pacote @code{ctensor} foi extensivamente reescrito.
1604 Muitas funções e variáveis foram renomeadas com o objectivo de tornar o
1605 pacote com a versão comercial do Macsyma.
1608 @example
1609 Novo Nome Nome Antigo Descrição
1610 --------------------------------------------------------------------
1611 ctaylor() DLGTAYLOR() Expansão da série de Taylor de uma
1612 -----------------------------expressão
1613 lgeod[] EM Equações geodésicas
1614 ein[] G[] Tensor misto de Einstein
1615 ric[] LR[] Tensor misto de Ricci
1616 ricci() LRICCICOM() Calcula o tensor misto de Ricci
1617 ctaypov MINP Maximo expoente em expansões de séries de
1618 -----------------------------Taylor
1619 cgeodesic() MOTION Calcula as equações geodésicas
1620 ct_coords OMEGA Coordenadas métricas
1621 ctayvar PARAM Variável de expansão de séries de
1622 -----------------------------Taylor
1623 lriem[] R[] Tensor covariante de Riemann
1624 uriemann() RAISERIEMANN() Calcula o tensor contravariante de
1625 -----------------------------Riemann
1626 ratriemann RATRIEMAN Simplificação racional do tensor de
1627 -----------------------------Riemann
1628 uric[] RICCI[] Tensor de Ricci contravariante
1629 uricci() RICCICOM() Calcula o tensor de Ricci contravariante
1630 cmetric() SETMETRIC() Escolhe a métrica
1631 ctaypt TAYPT Ponto para expansões de séries de Taylor
1632 ctayswitch TAYSWITCH Escolhe o comutador de séries de Taylor
1633 csetup() TSETUP() Inicia sessão interativa de configuração
1634 ctransform() TTRANSFORM() Transformação de coordenadas interativa
1635 uriem[] UR[] Tensor contravariante de Riemann
1636 weyl[] W[] Tensor (3,1) de Weyl
1638 @end example