Manual do Maxima 5.43.0.6.g081e76c: 28. ctensor

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

# 28. ctensor

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 28.1 Introdução a ctensor

`ctensor` é um pacote de manipulação de componentes. Para usar o pacote `ctensor`, digite `load(ctensor)`. Para começar uma sessão iterativa com `ctensor`, digite `csetup()`. O primeiro que será pedido pelo pacote é a dimensão a ser manipulada. Se a dimensão for 2, 3 ou 4 então a lista de coordenadas padrão é `[x,y]`, `[x,y,z]` ou `[x,y,z,t]` respectivamente. Esses nomes podem ser mudados através da atribuição de uma nova lista de coordenadas para a variável `ct_coords` (descrita abaixo) e o utilizador é questionado sobre isso. Deve ter o cuidado de evitar conflitos de nomes de coordenadas com outras definições de objectos.

No próximo passo, o utilizador informa a métrica ou directamente ou de um ficheiro especificando sua posição ordinal. Como um exemplo de um ficheiro de métrica comum, veja ``share/tensor/metrics.mac'`. A métrica é armazenada na matriz LG. Finalmente, o inverso da métrica é calculado e armazenado na matriz UG. Se tem a opção de realizar todos os cálculos em séries de potência.

A seguir, mostramos um exemplo de protocolo para a métrica estática, esfericamente simétrica (coordenadas padrão) que será aplicada ao problema de derivação das equações de vácuo de Einstein (que levam à solução de Schwarzschild). Muitas das funções em `ctensor` irão ser mostradas como exemplos para a métrica padrão.

    (%i1) load(ctensor);
    (%o1)      /usr/local/lib/maxima/share/tensor/ctensor.mac
    (%i2) csetup();
    Enter the dimension of the coordinate system:
    4;
    Do you wish to change the coordinate names?
    n;
    Do you want to
    1. Enter a new metric?

    2. Enter a metric from a file?

    3. Approximate a metric with a Taylor series?
    1;

    Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric  4. General
    Answer 1, 2, 3 or 4
    1;
    Row 1 Column 1:
    a;
    Row 2 Column 2:
    x^2;
    Row 3 Column 3:
    x^2*sin(y)^2;
    Row 4 Column 4:
    -d;

    Matrix entered.
    Enter functional dependencies with the DEPENDS function or 'N' if none
    depends([a,d],x);
    Do you wish to see the metric?
    y;
                              [ a  0       0        0  ]
                              [                        ]
                              [     2                  ]
                              [ 0  x       0        0  ]
                              [                        ]
                              [         2    2         ]
                              [ 0  0   x  sin (y)   0  ]
                              [                        ]
                              [ 0  0       0       - d ]
    (%o2)                                done
    (%i3) christof(mcs);
                                                a
                                                 x
    (%t3)                          mcs        = ---
                                      1, 1, 1   2 a

                                                 1
    (%t4)                           mcs        = -
                                       1, 2, 2   x

                                                 1
    (%t5)                           mcs        = -
                                       1, 3, 3   x

                                                d
                                                 x
    (%t6)                          mcs        = ---
                                      1, 4, 4   2 d

                                                  x
    (%t7)                          mcs        = - -
                                      2, 2, 1     a

                                               cos(y)
    (%t8)                         mcs        = ------
                                     2, 3, 3   sin(y)

                                                   2
                                              x sin (y)
    (%t9)                      mcs        = - ---------
                                  3, 3, 1         a

    (%t10)                   mcs        = - cos(y) sin(y)
                                3, 3, 2

                                                d
                                                 x
    (%t11)                         mcs        = ---
                                      4, 4, 1   2 a
    (%o11)                               done

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 28.2 Definições para ctensor

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.1 Inicialização e configuração

Função: csetup ()

  É uma função no pacote `ctensor` (component tensor) que inicializa o pacote e permite ao utilizador inserir uma métrica interativamente. Veja `ctensor` para mais detalhes.

Função: cmetric (dis)
Função: cmetric ()

  É uma função no pacote `ctensor` que calcula o inverso da métrica e prepara o pacote para cálculos adiante.

  Se `cframe_flag` for `false`, a função calcula a métrica inversa `ug` a partir da matriz `lg` (definida pelo utilizador). O determinante da métrica é também calculado e armazenado na variável `gdet`. Mais adiante, o pacote determina se a métrica é diagonal e escolhe o valor de `diagmetric` conforme a determinação. Se o argumento opcional dis estiver presente e não for `false`, a saída é mostrada ao utilizador pela linha de comando para que ele possa ver o inverso da métrica.

  Se `cframe_flag` for `true`, a função espera que o valor de `fri` (a matriz referencial inversa) e `lfg` (a métrica do referencial) sejam definidas. A partir dessas, a matriz do referencial `fr` e a métrica do referencial inverso `ufg` são calculadas.

Função: ct_coordsys (sistema_de_coordenadas, extra_arg)
Função: ct_coordsys (sistema_de_coordenadas)

  Escolhe um sistema de coordenadas predefinido e uma métrica. O argumento sistema_de_coordenadas pode ser um dos seguintes símbolos:

        SYMBOL               Dim Coordenadas       Descrição/comentários
        --------------------------------------------------------------------------
        cartesian2d           2  [x,y]             Sist. de coord. cartesianas 2D
        polar                 2  [r,phi]           Sist. de coord. Polare
        elliptic              2  [u,v]
        confocalelliptic      2  [u,v]
        bipolar               2  [u,v]
        parabolic             2  [u,v]
        cartesian3d           3  [x,y,z]           Sist. de coord. cartesianas 3D
        polarcylindrical      3  [r,theta,z]
        ellipticcylindrical   3  [u,v,z]           Elíptica 2D com Z cilíndrico
        confocalellipsoidal   3  [u,v,w]
        bipolarcylindrical    3  [u,v,z]           Bipolar 2D com Z cilíndrico
        paraboliccylindrical  3  [u,v,z]           Parabólico 2D com Z cilíndrico
        paraboloidal          3  [u,v,phi]
        conical               3  [u,v,w]
        toroidal              3  [u,v,phi]
        spherical             3  [r,theta,phi]     Sist. de coord. Esféricas
        oblatespheroidal      3  [u,v,phi]
        oblatespheroidalsqrt  3  [u,v,phi]
        prolatespheroidal     3  [u,v,phi]
        prolatespheroidalsqrt 3  [u,v,phi]
        ellipsoidal           3  [r,theta,phi]
        cartesian4d           4  [x,y,z,t]         Sist. de coord. 4D
        spherical4d           4  [r,theta,eta,phi]
        exteriorschwarzschild 4  [t,r,theta,phi]   Métrica de Schwarzschild
        interiorschwarzschild 4  [t,z,u,v]        Métrica de Schwarzschild Interior
        kerr_newman           4  [t,r,theta,phi]   Métrica simétrica axialmente alterada

  `sistema_de_coordenadas` pode também ser uma lista de funções de transformação, seguida por uma lista contendo as varáveis coordenadas. Por exemplo, pode especificar uma métrica esférica como segue:

      (%i1) load(ctensor);
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
            r*sin(theta),[r,theta,phi]]);
      (%o2)                                done
      (%i3) lg:trigsimp(lg);
                                 [ 1  0         0        ]
                                 [                       ]
                                 [     2                 ]
      (%o3)                      [ 0  r         0        ]
                                 [                       ]
                                 [         2    2        ]
                                 [ 0  0   r  cos (theta) ]
      (%i4) ct_coords;
      (%o4)                           [r, theta, phi]
      (%i5) dim;
      (%o5)                                  3

  Funções de transformação podem também serem usadas quando `cframe_flag` for `true`:

      (%i1) load(ctensor);
      (%o1)       /share/tensor/ctensor.mac
      (%i2) cframe_flag:true;
      (%o2)                                true
      (%i3) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
            r*sin(theta),[r,theta,phi]]);
      (%o3)                                done
      (%i4) fri;
            [ cos(phi) cos(theta)  - cos(phi) r sin(theta)  - sin(phi) r cos(theta) ]
            [                                                                       ]
      (%o4) [ sin(phi) cos(theta)  - sin(phi) r sin(theta)   cos(phi) r cos(theta)  ]
            [                                                                       ]
            [     sin(theta)            r cos(theta)                   0            ]
      (%i5) cmetric();
      (%o5)                                false
      (%i6) lg:trigsimp(lg);
                                 [ 1  0         0        ]
                                 [                       ]
                                 [     2                 ]
      (%o6)                      [ 0  r         0        ]
                                 [                       ]
                                 [         2    2        ]
                                 [ 0  0   r  cos (theta) ]

  O argumento opcional extra_arg pode ser qualquer um dos seguintes:

  `cylindrical` diz a `ct_coordsys` para anexar uma coordenada adicional cilíndrica.

  `minkowski` diz a `ct_coordsys` para anexar uma coordenada com assinatura métrica negativa.

  `all` diz a `ct_coordsys` para chamar `cmetric` e `christof(false)` após escolher a métrica.

  Se a variável global `verbose` for escolhida para `true`, `ct_coordsys` mostra os valores de `dim`, `ct_coords`, e ou `lg` ou `lfg` e `fri`, dependendo do valor de `cframe_flag`.

Função: init_ctensor ()

  Inicializa o pacote `ctensor`.

  A função `init_ctensor` reinicializa o pacote `ctensor`. Essa função remove todos os arrays e matrizes usados por `ctensor`, coloca todos os sinalizadores de volta a seus valores padrão, retorna `dim` para 4, e retorna a métrica do referencial para a métrica do referencial de Lorentz.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.2 Os tensores do espaço curvo

O principal propósito do pacote `ctensor` é calcular os tensores do espaç(tempo) curvo, mais notavelmente os tensores usados na relatividade geral.

Quando uma base métrica é usada, `ctensor` pode calcular os seguintes tensores:

     lg  -- ug
       \      \
        lcs -- mcs -- ric -- uric
                  \      \       \
                   \      tracer - ein -- lein
                    \
                     riem -- lriem -- weyl
                         \
                          uriem

`ctensor` pode também usar referenciais móveis. Quando `cframe_flag` for escolhida para `true`, os seguintes tensores podem ser calculados:

     lfg -- ufg
         \
     fri -- fr -- lcs -- mcs -- lriem -- ric -- uric
          \                       |  \      \       \
           lg -- ug               |   weyl   tracer - ein -- lein
                                  |\
                                  | riem
                                  |
                                  \uriem

Função: christof (dis)

  Uma função no pacote `ctensor`. Essa função calcula os símbolos de Christoffel de ambos os tipos. O argumento dis determina quais resultados são para serem imediatamente mostrados. Os símbolos de Christoffel de primeiro e de segundo tipo são armazenados nos arrays `lcs[i,j,k]` e `mcs[i,j,k]` respectivamente e definidos para serem simétricos nos primeiros dois índices. Se o argumento para `christof` for `lcs` ou for `mcs` então o único valor não nulo de `lcs[i,j,k]` ou de `mcs[i,j,k]`, respectivamente, será mostrado. Se o argumento for `all` então o único valor não nulo de `lcs[i,j,k]` e o único valor não nulo de `mcs[i,j,k]` serão mostrados. Se o argumento for `false` então a exibição dos elementos não acontecerá. Os elementos do array `mcs[i,j,k]` são definidos de uma tal maneira que o índice final é contravariante.

Função: ricci (dis)

  Uma função no pacote `ctensor`. `ricci` calcula as componentes contravariantes (simétricas) `ric[i,j]` do tensor de Ricci. Se o argumento dis for `true`, então as componentes não nulas são mostradas.

Função: uricci (dis)

  Essa função primeiro calcula as componentes contravariantes `ric[i,j]` do tensor de Ricci. Então o tensor misto de Ricci é calculado usando o tensor métrico contravariante. Se o valor do argumento dis for `true`, então essas componentes mistas, `uric[i,j]` (o índice "i" é covariante e o índice "j" é contravariante), serão mostradas directamente. De outra forma, `ricci(false)` irá simplesmente calcular as entradas do array `uric[i,j]` sem mostrar os resultados.

Função: scurvature ()

  Retorna a curvatura escalar (obtida através da contração do tensor de Ricci) do Riemaniano multiplicado com a métrica dada.

Função: einstein (dis)

  Uma função no pacote `ctensor`. `einstein` calcula o tensor misto de Einstein após os símbolos de Christoffel e o tensor de Ricci terem sido obtidos (com as funções `christof` e `ricci`). Se o argumento dis for `true`, então os valores não nulos do tensor misto de Einstein `ein[i,j]` serão mostrados quando `j` for o índice contravariante. A variável `rateinstein` fará com que a simplificação racional ocorra sobre esses componentes. Se `ratfac` for `true` então as componentes irão também ser factoradas.

Função: leinstein (dis)

  Tensor covariante de Einstein. `leinstein` armazena o valor do tensor covariante de Einstein no array `lein`. O tensor covariante de Einstein é calculado a partir tensor misto de Einstein `ein` através da multiplicação desse pelo tensor métrico. Se o argumento dis for `true`, então os valores não nulos do tensor covariante de Einstein são mostrados.

Função: riemann (dis)

  Uma função no pacote `ctensor`. `riemann` calcula o tensor de curvatura de Riemann a partir da métrica dada e correspondendo aos símbolos de Christoffel. As seguintes convenções de índice são usadas:

                      l      _l       _l       _l   _m    _l   _m
       R[i,j,k,l] =  R    = |      - |      + |    |   - |    |
                      ijk     ij,k     ik,j     mk   ij    mj   ik

  Essa notação é consistente com a notação usada por no pacote `itensor` e sua função `icurvature`. Se o argumento opcional dis for `true`, as componentes não nulas `riem[i,j,k,l]` serão mostradas. Como com o tensor de Einstein, vários comutadores escolhidos pelo utilizador controlam a simplificação de componentes do tensor de Riemann. Se `ratriemann` for `true`, então simplificação racional será feita. Se `ratfac` for `true` então cada uma das componentes irá também ser factorada.

  Se a variável `cframe_flag` for `false`, o tensor de Riemann é calculado directamente dos símbolos de Christoffel. Se `cframe_flag` for `true`, o tensor covariante de Riemann é calculado primeiro dos coeficientes de campo do referencial.

Função: lriemann (dis)

  Tensor covariante de Riemann (`lriem[]`).

  Calcula o tensor covariante de Riemann como o array `lriem`. Se o argumento dis for `true`, únicos valores não nulos são mostrados.

  Se a variável `cframe_flag` for `true`, o tensor covariante de Riemann é calculado directamente dos coeficientes de campo do referencial. De outra forma, o tensor (3,1) de Riemann é calculado primeiro.

  Para informação sobre a ordenação de índice, veja `riemann`.

Função: uriemann (dis)

  Calcula as componentes contravariantes do tensor de curvatura de Riemann como elementos do array `uriem[i,j,k,l]`. Esses são mostrados se dis for `true`.

Função: rinvariant ()

  Compõe o invariante de Kretchmann (`kinvariant`) obtido através da contração dos tensores

      lriem[i,j,k,l]*uriem[i,j,k,l].

  Esse objecto não é automaticamente simplificado devido ao facto de poder ser muito largo.

Função: weyl (dis)

  Calcula o tensor conformal de Weyl. Se o argumento dis for `true`, as componentes não nulas `weyl[i,j,k,l]` irão ser mostradas para o utilizador. De outra forma, essas componentes irão simplesmente serem calculadas e armazenadas. Se o comutador `ratweyl` é escolhido para `true`, então as componentes irão ser racionalmente simplificadas; se `ratfac` for `true` então os resultados irão ser factorados também.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.3 Expansão das séries de Taylor

O pacote `ctensor` possui a habilidade para truncar resultados assumindo que eles são aproximações das séries de Taylor. Esse comportamenteo é controlado através da variável `ctayswitch`; quando escolhida para `true`, `ctensor` faz uso internamente da função `ctaylor` quando simplifica resultados.

A função `ctaylor` é invocada pelas seguintes funções de `ctensor`:

        Function     Comments
        ---------------------------------
        christof()   só para mcs
        ricci()
        uricci()
        einstein()
        riemann()
        weyl()
        checkdiv()

Função: ctaylor ()

  A função `ctaylor` trunca seus argumentos através da conversão destes para uma série de Taylor usando `taylor`, e então chamando `ratdisrep`. Isso tem efeito combinado de abandonar termos de ordem mais alta na variável de expansão `ctayvar`. A ordem dos termos que podem ser abandonados é definida através de `ctaypov`; o ponto em torno do qual a expansão da série é realizada está especificado em `ctaypt`.

  Como um exemplo, considere uma métrica simples que é uma perturbação da métrica de Minkowski. Sem restrições adicionais, mesmo uma métrica diagonal produz expressões para o tensor de Einstein que são de longe muito complexas:

      (%i1) load(ctensor);
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ratfac:true;
      (%o2)                                true
      (%i3) derivabbrev:true;
      (%o3)                                true
      (%i4) ct_coords:[t,r,theta,phi];
      (%o4)                         [t, r, theta, phi]
      (%i5) lg:matrix([-1,0,0,0],[0,1,0,0],[0,0,r^2,0],[0,0,0,r^2*sin(theta)^2]);
                              [ - 1  0  0         0        ]
                              [                            ]
                              [  0   1  0         0        ]
                              [                            ]
      (%o5)                   [          2                 ]
                              [  0   0  r         0        ]
                              [                            ]
                              [              2    2        ]
                              [  0   0  0   r  sin (theta) ]
      (%i6) h:matrix([h11,0,0,0],[0,h22,0,0],[0,0,h33,0],[0,0,0,h44]);
                                  [ h11   0    0    0  ]
                                  [                    ]
                                  [  0   h22   0    0  ]
      (%o6)                       [                    ]
                                  [  0    0   h33   0  ]
                                  [                    ]
                                  [  0    0    0   h44 ]
      (%i7) depends(l,r);
      (%o7)                               [l(r)]
      (%i8) lg:lg+l*h;
               [ h11 l - 1      0          0                 0            ]
               [                                                          ]
               [     0      h22 l + 1      0                 0            ]
               [                                                          ]
      (%o8)    [                        2                                 ]
               [     0          0      r  + h33 l            0            ]
               [                                                          ]
               [                                    2    2                ]
               [     0          0          0       r  sin (theta) + h44 l ]
      (%i9) cmetric(false);
      (%o9)                                done
      (%i10) einstein(false);
      (%o10)                               done
      (%i11) ntermst(ein);
      [[1, 1], 62]
      [[1, 2], 0]
      [[1, 3], 0]
      [[1, 4], 0]
      [[2, 1], 0]
      [[2, 2], 24]
      [[2, 3], 0]
      [[2, 4], 0]
      [[3, 1], 0]
      [[3, 2], 0]
      [[3, 3], 46]
      [[3, 4], 0]
      [[4, 1], 0]
      [[4, 2], 0]
      [[4, 3], 0]
      [[4, 4], 46]
      (%o12)                               done

  Todavia, se nós recalcularmos esse exemplo como uma aproximação que é linear na variável `l`, pegamos expressões muito simples:

      (%i14) ctayswitch:true;
      (%o14)                               true
      (%i15) ctayvar:l;
      (%o15)                                 l
      (%i16) ctaypov:1;
      (%o16)                                 1
      (%i17) ctaypt:0;
      (%o17)                                 0
      (%i18) christof(false);
      (%o18)                               done
      (%i19) ricci(false);
      (%o19)                               done
      (%i20) einstein(false);
      (%o20)                               done
      (%i21) ntermst(ein);
      [[1, 1], 6]
      [[1, 2], 0]
      [[1, 3], 0]
      [[1, 4], 0]
      [[2, 1], 0]
      [[2, 2], 13]
      [[2, 3], 2]
      [[2, 4], 0]
      [[3, 1], 0]
      [[3, 2], 2]
      [[3, 3], 9]
      [[3, 4], 0]
      [[4, 1], 0]
      [[4, 2], 0]
      [[4, 3], 0]
      [[4, 4], 9]
      (%o21)                               done
      (%i22) ratsimp(ein[1,1]);
                               2      2  4               2     2
      (%o22) - (((h11 h22 - h11 ) (l )  r  - 2 h33 l    r ) sin (theta)
                                    r               r r

                                      2               2      4    2
                        - 2 h44 l    r  - h33 h44 (l ) )/(4 r  sin (theta))
                                 r r                r

  Essa compatibilidade pode ser útil, por exemplo, quando trabalhamos no limite do campo fraco longe de uma fonte gravitacional.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.4 Campos de referencial

Quando a variável `cframe_flag` for escolhida para `true`, o pacote `ctensor` executa seus cálculos usando um referencial móvel.

Função: frame_bracket (fr, fri, diagframe)

  O delimitador do referencial (`fb[]`).

  Calcula o delimitador do referencial conforme a seguinte definição:

         c          c         c        d     e
      ifb   = ( ifri    - ifri    ) ifr   ifr
         ab         d,e       e,d      a     b

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.5 Classificação Algébrica

Um novo recurso (a partir de November de 2004) de `ctensor` é sua habilidade para calcular a classificação de Petrov de uma métrica espaço tempo tetradimensional. Para uma demonstração dessa compatibilidade, veja o ficheiro `share/tensor/petrov.dem`.

Função: nptetrad ()

  Calcula um tetrad nulo de Newman-Penrose (`np`) e seus índices ascendentes em contrapartida (`npi`). Veja `petrov` para um exemplo.

  O tetrad nulo é construído assumindo que um referencial métrico ortonormal tetradimensional com assinatura métrica (-,+,+,+) está sendo usada. As componentes do tetrad nulo são relacionadas para a matriz referencial inversa como segue:

      np  = (fri  + fri ) / sqrt(2)
        1       1      2

      np  = (fri  - fri ) / sqrt(2)
        2       1      2

      np  = (fri  + %i fri ) / sqrt(2)
        3       3         4

      np  = (fri  - %i fri ) / sqrt(2)
        4       3         4

Função: psi (dis)

  Calcula os cinco coeficientes de Newman-Penrose `psi[0]`...`psi[4]`. Se `psi` for escolhida para `true`, os coeficientes são mostrados. Veja `petrov` para um exemplo.

  Esses coeficientes são calculados a partir do tensor de Weyl em uma base de coordenada. Se uma base de referencial for usada, o tensor de Weyl é primeiro convertido para a base de coordenada, que pode ser um procedimento computacional expansível. Por essa razão, em alguns casos pode ser mais vantajoso usar uma base de coordenada em primeiro lugar antes que o tensor de Weyl seja calculado. Note todavia, que para a construção de um tetrad nulo de Newman-Penrose é necessário uma base de referencial. Portanto, uma sequência de cálculo expressiva pode começar com uma base de referencial, que é então usada para calcular `lg` (calculada automaticamente através de `cmetric`) e em seguida calcula `ug`. Nesse ponto, pode comutar de volta para uma base de coordenada escolhendo `cframe_flag` para `false` antes de começar a calcular os símbolos de Christoffel. Mudando para uma base de referencial num estágio posterior pode retornar resultados inconsistentes, já que pode terminar com uma grande mistura de tensores, alguns calculados numa base de referencial, e outros numa base de coordenada, sem nenhum modo para distinguir entre os dois tipos.

Função: petrov ()

  Calcula a classificação de petrov da métrica caracterizada através de `psi[0]`...`psi[4]`.

  Por exemplo, o seguinte demonstra como obter a classificação de Petrov da métrica de Kerr:

      (%i1) load(ctensor);
      (%o1)       /share/tensor/ctensor.mac
      (%i2) (cframe_flag:true,gcd:spmod,ctrgsimp:true,ratfac:true);
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) ug:invert(lg)$
      (%i5) weyl(false);
      (%o5)                                done
      (%i6) nptetrad(true);
      (%t6) np =

             [  sqrt(r - 2 m)           sqrt(r)                                     ]
             [ ---------------   ---------------------      0             0         ]
             [ sqrt(2) sqrt(r)   sqrt(2) sqrt(r - 2 m)                              ]
             [                                                                      ]
             [  sqrt(r - 2 m)            sqrt(r)                                    ]
             [ ---------------  - ---------------------     0             0         ]
             [ sqrt(2) sqrt(r)    sqrt(2) sqrt(r - 2 m)                             ]
             [                                                                      ]
             [                                              r      %i r sin(theta)  ]
             [        0                    0             -------   ---------------  ]
             [                                           sqrt(2)       sqrt(2)      ]
             [                                                                      ]
             [                                              r       %i r sin(theta) ]
             [        0                    0             -------  - --------------- ]
             [                                           sqrt(2)        sqrt(2)     ]

                                   sqrt(r)          sqrt(r - 2 m)
      (%t7) npi = matrix([- ---------------------, ---------------, 0, 0],
                            sqrt(2) sqrt(r - 2 m)  sqrt(2) sqrt(r)

                sqrt(r)            sqrt(r - 2 m)
      [- ---------------------, - ---------------, 0, 0],
         sqrt(2) sqrt(r - 2 m)    sqrt(2) sqrt(r)

                 1               %i
      [0, 0, ---------, --------------------],
             sqrt(2) r  sqrt(2) r sin(theta)

                 1                 %i
      [0, 0, ---------, - --------------------])
             sqrt(2) r    sqrt(2) r sin(theta)

      (%o7)                                done
      (%i7) psi(true);
      (%t8)                              psi  = 0
                                            0

      (%t9)                              psi  = 0
                                            1

                                                m
      (%t10)                             psi  = --
                                            2    3
                                                r

      (%t11)                             psi  = 0
                                            3

      (%t12)                             psi  = 0
                                            4
      (%o12)                               done
      (%i12) petrov();
      (%o12)                                 D

  A função de classificação Petrov é baseada no algoritmo publicado em "Classifying geometries in general relativity: III Classification in practice" por Pollney, Skea, e d'Inverno, Class. Quant. Grav. 17 2885-2902 (2000). Exceto para alguns casos de teste simples, a implementação não está testada até 19 de Dezembro de 2004, e é provável que contenha erros.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.6 Torsão e não metricidade

`ctensor` possui a habilidade de calcular e incluir coeficientes de torsão e não metricidade nos coeficientes de conecção.

Os coeficientes de torsão são calculados a partir de um tensor fornecido pelo utilizador `tr`, que pode ser um tensor de categoria (2,1). A partir disso, os coeficientes de torsão `kt` são calculados de acordo com a seguinte fórmula:

                  m          m      m
           - g  tr   - g   tr   - tr   g
              im  kj    jm   ki     ij  km
    kt   = -------------------------------
      ijk                 2

      k     km
    kt   = g   kt
      ij         ijm

Note que somente o tensor de índice misto é calculao e armazenado no array `kt`.

Os coeficientes de não metricidade são calculados a partir do vector de não metricidade fornecido pelo utilizador `nm`. A partir disso, os coeficientes de não metricidade `nmc` são calculados como segue:

                 k    k        km
           -nm  D  - D  nm  + g   nm  g
       k      i  j    i   j         m  ij
    nmc  = ------------------------------
       ij                2

onde D simboliza o delta de Kronecker.

Quando `ctorsion_flag` for escolhida para `true`, os valores de `kt` são subtraídos dos coeficientes de conecção indexados mistos calculados através de `christof` e armazenados em `mcs`. Similarmente, se `cnonmet_flag` for escolhida para `true`, os valores de `nmc` são subtraídos dos coeficientes de conecção indexados mistos.

Se necessário, `christof` chama as funções `contortion` e `nonmetricity` com o objectivo de calcular `kt` e `nm`.

Função: contortion (tr)

  Calcula os coeficientes de contorsão de categoria (2,1) a partir do tensor de torsão tr.

Função: nonmetricity (nm)

  Calcula o coeficiente de não metricidade de categoria (2,1) a partir do vector de não metricidade nm.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.7 Recursos diversos

Função: ctransform (M)

  Uma função no pacote `ctensor` que irá executar uma transformação de coordenadas sobre uma matriz simétrica quadrada arbitrária M. O utilizador deve informar as funçãoes que definem a transformação. (Formalmente chamada `transform`.)

Função: findde (A, n)

  Retorna uma lista de equações diferenciais únicas (expressões) correspondendo aos elementos do array quadrado n dimensional A. Actualmente, n pode ser 2 ou 3. `deindex` é uma lista global contendo os índices de A correspondendo a essas únicas equações diferenciais. Para o tensor de Einstein (`ein`), que é um array dimensional, se calculado para a métrica no exemplo abaixo, `findde` fornece as seguintes equações diferenciais independentes:

      (%i1) load(ctensor);
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) dim:4;
      (%o3)                                  4
      (%i4) lg:matrix([a,0,0,0],[0,x^2,0,0],[0,0,x^2*sin(y)^2,0],[0,0,0,-d]);
                                [ a  0       0        0  ]
                                [                        ]
                                [     2                  ]
                                [ 0  x       0        0  ]
      (%o4)                     [                        ]
                                [         2    2         ]
                                [ 0  0   x  sin (y)   0  ]
                                [                        ]
                                [ 0  0       0       - d ]
      (%i5) depends([a,d],x);
      (%o5)                            [a(x), d(x)]
      (%i6) ct_coords:[x,y,z,t];
      (%o6)                            [x, y, z, t]
      (%i7) cmetric();
      (%o7)                                done
      (%i8) einstein(false);
      (%o8)                                done
      (%i9) findde(ein,2);
                                                  2
      (%o9) [d  x - a d + d, 2 a d d    x - a (d )  x - a  d d  x + 2 a d d
              x                     x x         x        x    x            x

                                                              2          2
                                                      - 2 a  d , a  x + a  - a]
                                                           x      x
      (%i10) deindex;
      (%o10)                     [[1, 1], [2, 2], [4, 4]]

Função: cograd ()

  Calcula o gradiente covariante de uma função escalar permitindo ao utilizador escolher o nome do vector correspondente como o exemplo sob `contragrad` ilustra.

Função: contragrad ()

  Calcula o gradiente contravariante de uma função escalar permitindo ao utilizador escolher o nome do vector correspondente como o exemplo abaixo como ilustra a métrica de Schwarzschild:

      (%i1) load(ctensor);
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) depends(f,r);
      (%o4)                               [f(r)]
      (%i5) cograd(f,g1);
      (%o5)                                done
      (%i6) listarray(g1);
      (%o6)                            [0, f , 0, 0]
                                            r
      (%i7) contragrad(f,g2);
      (%o7)                                done
      (%i8) listarray(g2);
                                     f  r - 2 f  m
                                      r        r
      (%o8)                      [0, -------------, 0, 0]
                                           r

Função: dscalar ()

  Calcula o tensor d'Alembertiano da função escalar assim que as dependências tiverem sido declaradas sobre a função. Po exemplo:

      (%i1) load(ctensor);
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) depends(p,r);
      (%o4)                               [p(r)]
      (%i5) factor(dscalar(p));
                                2
                          p    r  - 2 m p    r + 2 p  r - 2 m p
                           r r           r r        r          r
      (%o5)               --------------------------------------
                                             2
                                            r

Função: checkdiv ()

  Calcula a divergência covariante do tensor de segunda categoria misto (cujo primeiro índice deve ser covariante) imprimindo as correspondentes n componentes do campo do vector (a divergência) onde n = `dim`. Se o argumento para a função for `g` então a divergência do tensor de Einstein será formada e pode ser zero. Adicionalmente, a divergência (vector) é dada no array chamado `div`.

Função: cgeodesic (dis)

  Uma função no pacote `ctensor`. `cgeodesic` calcula as equações geodésicas de movimento para uma dada métrica. Elas são armazenadas no array `geod[i]`. Se o argumento dis for `true` então essas equações são mostradas.

Função: bdvac (f)

  Gera as componentes covariantes das equações de campo de vácuo da teoria de gravitação de Brans-Dicke. O campo escalar é especificado através do argumento f, que pode ser um nome de função (com apóstrofo) com dependências funcionais, e.g., `'p(x)`.

  As componentes de segunda categoria do tensor campo covariante são as componentes de segunda categoria representadas pelo array `bd`.

Função: invariant1 ()

  Gera o tensor misto de Euler-Lagrange (equações de campo) para a densidade invariante de R^2. As equações de campo são componentes de um array chamado `inv1`.

Função: invariant2 ()

  *** NOT YET IMPLEMENTED ***

  Gera o tensor misto de Euler-Lagrange (equações de campo) para a densidade invariante de `ric[i,j]*uriem[i,j]`. As equações de campo são as componentes de um array chamado `inv2`.

Função: bimetric ()

  *** NOT YET IMPLEMENTED ***

  Gera as euauações de campo da teoria bimétrica de Rosen. As equações de campo são as componentes de um array chamado `rosen`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.8 Funções utilitárias

Função: diagmatrixp (M)

  Retorna `true` se M for uma matriz diagonal ou um array (2D).

Função: symmetricp (M)

  Retorna `true` se M for uma matriz simétrica ou um array (2D).

Função: ntermst (f)

  Fornece ao utilizador um rápido quadro do "tamanho" do tensor duplamente subscrito (array) f. Imprime uma lista de dois elementos onde o segundo elemento corresponde a N-TERMOS de componentes especificadas através dos primeiros elementos. Nesse caminho, é possível rapidamente encontrar as expressões não nulas e tentar simplificação.

Função: cdisplay (ten)

  Mostra todos os elementos do tensor ten, como representados por um array multidimensional. Tensores de categoria 0 e 1, assim como outros tipos de variáveis, são mostrados com `ldisplay`. Tensores de categoria 2 são mostrados como matrizes bidimensionais, enquanto tensores de alta categoria são mostrados como uma lista de matrizes bidimensionais. Por exemplo, o tensor de Riemann da métrica de Schwarzschild pode ser visto como:

      (%i1) load(ctensor);
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ratfac:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) riemann(false);
      (%o4)                                done
      (%i5) cdisplay(riem);
                     [ 0               0                    0            0      ]
                     [                                                          ]
                     [                              2                           ]
                     [      3 m (r - 2 m)   m    2 m                            ]
                     [ 0  - ------------- + -- - ----       0            0      ]
                     [            4          3     4                            ]
                     [           r          r     r                             ]
                     [                                                          ]
          riem     = [                                 m (r - 2 m)              ]
              1, 1   [ 0               0               -----------       0      ]
                     [                                      4                   ]
                     [                                     r                    ]
                     [                                                          ]
                     [                                              m (r - 2 m) ]
                     [ 0               0                    0       ----------- ]
                     [                                                   4      ]
                     [                                                  r       ]

                                      [    2 m (r - 2 m)       ]
                                      [ 0  -------------  0  0 ]
                                      [          4             ]
                                      [         r              ]
                           riem     = [                        ]
                               1, 2   [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]

                                      [         m (r - 2 m)    ]
                                      [ 0  0  - -----------  0 ]
                                      [              4         ]
                                      [             r          ]
                           riem     = [                        ]
                               1, 3   [ 0  0        0        0 ]
                                      [                        ]
                                      [ 0  0        0        0 ]
                                      [                        ]
                                      [ 0  0        0        0 ]

                                      [            m (r - 2 m) ]
                                      [ 0  0  0  - ----------- ]
                                      [                 4      ]
                                      [                r       ]
                           riem     = [                        ]
                               1, 4   [ 0  0  0        0       ]
                                      [                        ]
                                      [ 0  0  0        0       ]
                                      [                        ]
                                      [ 0  0  0        0       ]

                                     [       0         0  0  0 ]
                                     [                         ]
                                     [       2 m               ]
                                     [ - ------------  0  0  0 ]
                          riem     = [    2                    ]
                              2, 1   [   r  (r - 2 m)          ]
                                     [                         ]
                                     [       0         0  0  0 ]
                                     [                         ]
                                     [       0         0  0  0 ]

                         [     2 m                                         ]
                         [ ------------  0        0               0        ]
                         [  2                                              ]
                         [ r  (r - 2 m)                                    ]
                         [                                                 ]
                         [      0        0        0               0        ]
                         [                                                 ]
              riem     = [                         m                       ]
                  2, 2   [      0        0  - ------------        0        ]
                         [                     2                           ]
                         [                    r  (r - 2 m)                 ]
                         [                                                 ]
                         [                                         m       ]
                         [      0        0        0         - ------------ ]
                         [                                     2           ]
                         [                                    r  (r - 2 m) ]

                                      [ 0  0       0        0 ]
                                      [                       ]
                                      [            m          ]
                                      [ 0  0  ------------  0 ]
                           riem     = [        2              ]
                               2, 3   [       r  (r - 2 m)    ]
                                      [                       ]
                                      [ 0  0       0        0 ]
                                      [                       ]
                                      [ 0  0       0        0 ]

                                      [ 0  0  0       0       ]
                                      [                       ]
                                      [               m       ]
                                      [ 0  0  0  ------------ ]
                           riem     = [           2           ]
                               2, 4   [          r  (r - 2 m) ]
                                      [                       ]
                                      [ 0  0  0       0       ]
                                      [                       ]
                                      [ 0  0  0       0       ]

                                            [ 0  0  0  0 ]
                                            [            ]
                                            [ 0  0  0  0 ]
                                            [            ]
                                 riem     = [ m          ]
                                     3, 1   [ -  0  0  0 ]
                                            [ r          ]
                                            [            ]
                                            [ 0  0  0  0 ]

                                            [ 0  0  0  0 ]
                                            [            ]
                                            [ 0  0  0  0 ]
                                            [            ]
                                 riem     = [    m       ]
                                     3, 2   [ 0  -  0  0 ]
                                            [    r       ]
                                            [            ]
                                            [ 0  0  0  0 ]

                                     [   m                      ]
                                     [ - -   0   0       0      ]
                                     [   r                      ]
                                     [                          ]
                                     [        m                 ]
                                     [  0   - -  0       0      ]
                          riem     = [        r                 ]
                              3, 3   [                          ]
                                     [  0    0   0       0      ]
                                     [                          ]
                                     [              2 m - r     ]
                                     [  0    0   0  ------- + 1 ]
                                     [                 r        ]

                                          [ 0  0  0    0   ]
                                          [                ]
                                          [ 0  0  0    0   ]
                                          [                ]
                               riem     = [            2 m ]
                                   3, 4   [ 0  0  0  - --- ]
                                          [             r  ]
                                          [                ]
                                          [ 0  0  0    0   ]

                                      [       0        0  0  0 ]
                                      [                        ]
                                      [       0        0  0  0 ]
                                      [                        ]
                           riem     = [       0        0  0  0 ]
                               4, 1   [                        ]
                                      [      2                 ]
                                      [ m sin (theta)          ]
                                      [ -------------  0  0  0 ]
                                      [       r                ]

                                      [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]
                                      [                        ]
                           riem     = [ 0        0        0  0 ]
                               4, 2   [                        ]
                                      [         2              ]
                                      [    m sin (theta)       ]
                                      [ 0  -------------  0  0 ]
                                      [          r             ]

                                    [ 0  0          0          0 ]
                                    [                            ]
                                    [ 0  0          0          0 ]
                                    [                            ]
                         riem     = [ 0  0          0          0 ]
                             4, 3   [                            ]
                                    [                2           ]
                                    [         2 m sin (theta)    ]
                                    [ 0  0  - ---------------  0 ]
                                    [                r           ]

                       [        2                                             ]
                       [   m sin (theta)                                      ]
                       [ - -------------         0                0         0 ]
                       [         r                                            ]
                       [                                                      ]
                       [                         2                            ]
                       [                    m sin (theta)                     ]
            riem     = [        0         - -------------         0         0 ]
                4, 4   [                          r                           ]
                       [                                                      ]
                       [                                          2           ]
                       [                                   2 m sin (theta)    ]
                       [        0                0         ---------------  0 ]
                       [                                          r           ]
                       [                                                      ]
                       [        0                0                0         0 ]

      (%o5)                                done

Função: deleten (L, n)

  Retorna uma nova lista consistindo de L com o n'ésimo elemento apagado.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.9 Variáveis usadas por `ctensor`

Variável de opção: dim

  Valor por omissão: 4

  Uma opção no pacote `ctensor`. `dim` é a dimensão de multiplicação com o padrão 4. O comando `dim: n` irá escolher a dimensão para qualquer outro valor `n`.

Variável de opção: diagmetric

  Valor por omissão: `false`

  Uma opção no pacote `ctensor`. Se `diagmetric` for `true` rotinas especiais calculam todos os objectos geométricos (que possuem o tensor métrico explicitamente) levando em consideração a diagonalidade da métrica. Tempo de execuçào reduzido irá, com certeza, resultar dessa escolha. Nota: essa opção é escolhida automaticamente por `csetup` se uma métrica diagonal for especificada.

Variável de opção: ctrgsimp

  Faz com que simplificações trigonométricas sejam usadas quando tensores forem calculados. Actualmente, `ctrgsimp` afecta somente cálculos envolvendo um referencial móvel.

Variável de opção: cframe_flag

  Faz com que cálculos sejam executados relativamente a um referencial móvel em oposição a uma métrica holonómica. O referencial é definido através do array do referencial inverso `fri` e da métrica do referencial `lfg`. Para cálculos usando um referencial Cartesiano, `lfg` pode ser a matriz unitária de dimensão apropriada; para cálculos num referencial de Lorentz, `lfg` pode ter a assinatura apropriada.

Variável de opção: ctorsion_flag

  Faz com que o tensor de contorsão seja incluído no cálculo dos coeficientes de conecção. O tensor de contorsão por si mesmo é calculado através de `contortion` a partir do tensor `tr` fornecido pelo utilizador.

Variável de opção: cnonmet_flag

  Faz com que os coeficientes de não metricidade sejam incluídos no cálculo dos coeficientes de conecção. Os coeficientes de não metricidade são calculados a partir do vector de não metricidade `nm` fornecido pelo utilizador através da função `nonmetricity`.

Variável de opção: ctayswitch

  Se escolhida para `true`, faz com que alguns cálculos de `ctensor` sejam realizados usando expansões das séries de Taylor. actualmente, `christof`, `ricci`, `uricci`, `einstein`, e `weyl` levam em conta essa escolha.

Variável de opção: ctayvar

  Variável usada pela expansão de séries de Taylor se `ctayswitch` é escolhida para `true`.

Variável de opção: ctaypov

  Maximo expoente usado em expansões de séries de Taylor quando `ctayswitch` for escolhida para `true`.

Variável de opção: ctaypt

  Ponto em torno do qual expansões de séries de Taylor sao realizadas quando `ctayswitch` for escolhida para `true`.

Variável de sistema: gdet

  O determinante do tensor métrico `lg`. Calculado através de `cmetric` quando `cframe_flag` for escolhido para `false`.

Variável de opção: ratchristof

  Faz com que simplificações racionais sejam aplicadas através de `christof`.

Variável de opção: rateinstein

  Valor por omissão: `true`

  Se `true` simplificação racional será executada sobre as componentes não nulas de tensores de Einstein; se `ratfac` for `true` então as componentes irão também ser factoradas.

Variável de opção: ratriemann

  Valor por omissão: `true`

  Um dos comutadores que controlam simplificações dos tensores de Riemann; se `true`, então simplificações racionais irão ser concluídas; se `ratfac` for `true` então cada uma das componentes irá também ser factorada.

Variável de opção: ratweyl

  Valor por omissão: `true`

  Se `true`, esse comutador faz com que a função de `weyl` aplique simplificações racionais aos valores do tensor de Weyl. Se `ratfac` for `true`, então as componentes irão também ser factoradas.

Variável: lfg

  O referencial métrico covariante. Por padrão, é inicializado para o referencial tetradimensional de Lorentz com assinatura (+,+,+,-). Usada quando `cframe_flag` for `true`.

Variável: ufg

  A métrica do referencial inverso. Calculada de `lfg` quando `cmetric` for chamada enquanto `cframe_flag` for escolhida para `true`.

Variável: riem

  O tensor de categoria (3,1) de Riemann. Calculado quando a função `riemann` é invocada. Para informação sobre ordenação de índices, veja a descrição de `riemann`.

  Se `cframe_flag` for `true`, `riem` é calculado a partir do tensor covariante de Riemann `lriem`.

Variável: lriem

  O tensor covariante de Riemann. Calculado através de `lriemann`.

Variável: uriem

  O tensor contravariante de Riemann. Calculado através de `uriemann`.

Variável: ric

  O tensor misto de Ricci. Calculado através de `ricci`.

Variável: uric

  O tensor contravariante de Ricci. Calculado através de `uricci`.

Variável: lg

  O tensor métrico. Esse tensor deve ser especificado (como uma `dim` através da matriz `dim`) antes que outro cálculo possa ser executado.

Variável: ug

  O inverso do tensor métrico. Calculado através de `cmetric`.

Variável: weyl

  O tensor de Weyl. Calculado através de `weyl`.

Variável: fb

  Coeficientes delimitadores do referencial, como calculado através de `frame_bracket`.

Variável: kinvariant

  O invariante de Kretchmann. Calculado através de `rinvariant`.

Variável: np

  Um tetrad nulo de Newman-Penrose. Calculado através de `nptetrad`.

Variável: npi

  O índice ascendente do tetrad nulo de Newman-Penrose. Calculado através de `nptetrad`. Definido como `ug.np`. O produto `np.transpose(npi)` é constante:

      (%i39) trigsimp(np.transpose(npi));
                                    [  0   - 1  0  0 ]
                                    [                ]
                                    [ - 1   0   0  0 ]
      (%o39)                        [                ]
                                    [  0    0   0  1 ]
                                    [                ]
                                    [  0    0   1  0 ]

Variável: tr

  Tensor de categoria 3 fornecido pelo utilizador representando torsão. Usado por `contortion`.

Variável: kt

  O tensor de contorsão, calculado a partir de `tr` através de `contortion`.

Variável: nm

  Vetor de não metrcidade fornecido pelo utilizador. Usado por `nonmetricity`.

Variável: nmc

  Os coeficientes de não metricidade, calculados a partir de `nm` por `nonmetricity`.

Variável de sistema: tensorkill

  Variável indicando se o pacote tensor foi inicializado. Escolhida e usada por `csetup`, retornada ao seu valor original através de `init_ctensor`.

Variável de opção: ct_coords

  Valor por omissão: `[]`

  Uma opção no pacote `ctensor`. `ct_coords` contém uma lista de coordenadas. Enquanto normalmente definida quando a função `csetup` for chamada, se pode redefinir as coordenadas com a atribuição `ct_coords: [j1, j2, ..., jn]` onde os j's são os novos nomes de coordenadas. Veja também `csetup`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.10 Nomes reservados

Os seguintes nomes são usados internamente pelo pacote `ctensor` e não devem ser redefinidos:

      Name         Description
      ---------------------------------------
      _lg()        Avalia para lfg se for usado o referencial métrico,
                        para lg de outra forma
      _ug()        Avalia para ufg se for usado o referencial métrico,
                        para ug de outra forma
      cleanup()    Remove ítens da lista deindex
      contract4()  Usado por psi()
      filemet()    Usado por csetup() quando lendo a métrica de um ficheiro
      findde1()    Usado por findde()
      findde2()    Usado por findde()
      findde3()    Usado por findde()
      kdelt()      Delta de Kronecker (não generalizado)
      newmet()     Usado por csetup() para escolher uma métrica
                        interativamente
      setflags()   Usado por init_ctensor()
      readvalue()
      resimp()
      sermet()     Usado por csetup() para informar uma métricacom série
                        de Taylor
      txyzsum()
      tmetric()    Referencial métrico, usado por cmetric() quando
                        cframe_flag:true
      triemann()   Tensor de Riemann na base do referencial, usado quando
                        cframe_flag:true
      tricci()     Tensor de Ricci na base do referencial, usado quando
                        cframe_flag:true
      trrc()       Coeficientes de rotação de Ricci, usado por
                        christof()
      yesp()

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

### 28.2.11 Modificações

Em Novembro de 2004, o pacote `ctensor` foi extensivamente reescrito. Muitas funções e variáveis foram renomeadas com o objectivo de tornar o pacote com a versão comercial do Macsyma.

      Novo Nome    Nome Antigo     Descrição
      --------------------------------------------------------------------
      ctaylor()    DLGTAYLOR()     Expansão da série de Taylor de uma
      -----------------------------expressão
      lgeod[]      EM              Equações geodésicas
      ein[]        G[]             Tensor misto de Einstein
      ric[]        LR[]            Tensor misto de Ricci
      ricci()      LRICCICOM()     Calcula o tensor misto de Ricci
      ctaypov      MINP            Maximo expoente em expansões de séries de
      -----------------------------Taylor
      cgeodesic()  MOTION          Calcula as equações geodésicas
      ct_coords    OMEGA           Coordenadas métricas
      ctayvar      PARAM           Variável de expansão de séries de
      -----------------------------Taylor
      lriem[]      R[]             Tensor covariante de Riemann
      uriemann()   RAISERIEMANN()  Calcula o tensor contravariante de
      -----------------------------Riemann
      ratriemann   RATRIEMAN       Simplificação racional do tensor de
      -----------------------------Riemann
      uric[]       RICCI[]         Tensor de Ricci contravariante
      uricci()     RICCICOM()      Calcula o tensor de Ricci contravariante
      cmetric()    SETMETRIC()     Escolhe a métrica
      ctaypt       TAYPT           Ponto para expansões de séries de Taylor
      ctayswitch   TAYSWITCH       Escolhe o comutador de séries de Taylor
      csetup()     TSETUP()        Inicia sessão interativa de configuração
      ctransform() TTRANSFORM()    Transformação de coordenadas interativa
      uriem[]      UR[]            Tensor contravariante de Riemann
      weyl[]       W[]             Tensor (3,1) de Weyl

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

This document was generated by Robert Dodier on Dezembro, 29 2019 using texi2html 1.76.