@Override public Tensor toTensor() { Tensor expression = Tensors.expression(content[0].toTensor(), content[1].toTensor()); if (preprocess) { for (Transformation tr : Context.get().getParseManager().defaultTensorPreprocessors) expression = tr.transform(expression); Context.get().getParseManager().defaultTensorPreprocessors.add((Transformation) expression); } return expression; } }
private Expression[] getLeviCivitaSubstitutions() { Expression[] substitutions = new Expression[2]; //Levi-Civita self-contraction substitutions[0] = getLeviCivitaSelfContraction(); //d^a_a = numberOfIndices substitutions[1] = expression(createKronecker( setType(typeOfLeviCivitaIndices, 0), setType(typeOfLeviCivitaIndices, 0x80000000)), new Complex(numberOfIndices)); return substitutions; }
private Expression createP2Subs() { return expression(multiply(momentum, setIndices(momentum, momentum.getIndices().getInverted())), pow(mass, 2)); }
i = -1; for (Map.Entry<Tensor, Tensor> entry : tensorSubstitutions.entrySet()) scalarSubs[++i] = Tensors.expression(entry.getKey(), entry.getValue()); SubstitutionTransformation fullSub = new SubstitutionTransformation(scalarSubs, true); for (i = 0; i < equations.length; ++i) if (coef.isIdentity() && !keepFreeParameters)//if current coefficient is free parameter zeroSubs.add(Tensors.expression(coef.get(0), Complex.ZERO)); } else { for (int si = solution.length - 1; si >= 0; --si)
SimpleTensor nVar = CC.generateNewSymbol(); unknownCoefficients.add(nVar); generalSolutions[i] = Tensors.expression(vars[i], nVar); } else { generatedTensor = TensorGenerator.generateStructure(vars[i].getIndices(), samples, symmetricForm[i], true, true); for (SimpleTensor st : generatedTensor.coefficients) unknownCoefficients.add(st); generalSolutions[i] = Tensors.expression(vars[i], generatedTensor.generatedTensor); reducedSystem.add(Tensors.expression(equation, Complex.ZERO)); } else { if (equation instanceof Sum) for (Tensor t : equation) reducedSystem.add(Tensors.expression(Split.splitScalars(t).summand, Complex.ZERO)); else reducedSystem.add(Tensors.expression(Split.splitScalars(equation).summand, Complex.ZERO));
unknownCoefficients = generatedTensor.coefficients; generalInverse = Tensors.expression(inverseLhs, generatedTensor.generatedTensor); for (Split split : rightSplit) if (TensorUtils.equals(current.factor, split.factor)) { equationsList.add(Tensors.expression(current.summand, split.summand)); one = true; break; equationsList.add(Tensors.expression(current.summand, Complex.ZERO));
/** * Generates a set of replacement rules for all scalar (but not symbolic) sub-tensors appearing in the specified * tensor. * * @param tensor tensor * @param generatedCoefficients allows to control how coefficients are generated * @return set of replacement rules for all scalar (but not symbolic) sub-tensors appearing in the specified * tensor * @see LocalSymbolsProvider */ public static Expression[] generateReplacementsOfScalars(Tensor tensor, OutputPort<SimpleTensor> generatedCoefficients) { THashSet<Tensor> scalars = new THashSet<>(); FromChildToParentIterator iterator = new FromChildToParentIterator(tensor); Tensor c; while ((c = iterator.next()) != null) if (c instanceof Product) scalars.addAll(Arrays.asList(((Product) c).getContent().getScalars())); Expression[] replacements = new Expression[scalars.size()]; int i = -1; for (Tensor scalar : scalars) replacements[++i] = expression(scalar, generatedCoefficients.take()); return replacements; }
Expression createSubstitution(int length) { if (length <= 2) return subs[length - 2]; Expression expr = substitutions.get(length); if (expr == null) { Tensor[] line = createLine(length); line[length - 1] = setMetricIndex((SimpleTensor) line[length - 1], IndicesUtils.inverseIndexState(line[0].getIndices().get(metricType, 0))); substitutions.put(length, expr = expression(multiply(line), createSubstitution0(line))); } return expr; }
private static Expression compileExpr0(Tensor lhs, Tensor rhs) { return expression(lhs, ApplyIndexMapping.applyIndexMapping(rhs, new Mapping(rhs.getIndices().getFree().toArray(), lhs.getIndices().getFree().toArray()))); } }
private Expression[] createOrtIdentities(SimpleTensor bar, SimpleTensor spinor) { if (bar == null || spinor == null) return null; int dummy = setState(false, bar.getIndices().get(matrixType, 0)); Tensor lhs0 = multiply(setMatrixIndices0(bar, dummy), setMatrixIndices0(spinor, inverseIndexState(dummy))); Tensor lhs1 = multiply( setMatrixIndices0(bar, dummy), simpleTensor(gammaName, createSimple(null, inverseIndexState(dummy), dummy + 1, setType(metricType, 0))), setIndices(momentum, createSimple(null, setState(true, setType(metricType, 0)))), setMatrixIndices0(spinor, inverseIndexState(dummy + 1))); return new Expression[]{expression(lhs0, Complex.ZERO), expression(lhs1, Complex.ZERO)}; }
public static Expression[] setMandelstam(Tensor[][] momentums, Tensor s, Tensor t, Tensor u) { checkMandelstamInput(momentums, 4); if (s.getIndices().getFree().size() != 0 || t.getIndices().getFree().size() != 0 || u.getIndices().getFree().size() != 0) throw new IllegalArgumentException("Mandelstam variables should be scalar."); Expression[] result = new Expression[10]; int i; // (k1,k1) = m1^2, (k2,k2) = m2^2, (k3,k3) = m3^2, (k4,k4) = m4^2 for (i = 0; i < 4; ++i) result[i] = expression(square(momentums[i][0]), pow(momentums[i][1], 2)); //2(k1, k2) = s - k1^2 - k2^2 //2(k3, k4) = s - k3^2 - k4^2 result[i++] = expression(multiply(Complex.TWO, contract(momentums[0][0], momentums[1][0])), sum(s, negate(sum(pow(momentums[0][1], 2), pow(momentums[1][1], 2))))); result[i++] = expression(multiply(Complex.TWO, contract(momentums[2][0], momentums[3][0])), sum(s, negate(sum(pow(momentums[2][1], 2), pow(momentums[3][1], 2))))); //-2(k1, k3) = t - k1^2 - k3^2 //-2(k2, k4) = t - k2^2 - k4^2 result[i++] = expression(multiply(Complex.MINUS_TWO, contract(momentums[0][0], momentums[2][0])), sum(t, negate(sum(pow(momentums[0][1], 2), pow(momentums[2][1], 2))))); result[i++] = expression(multiply(Complex.MINUS_TWO, contract(momentums[1][0], momentums[3][0])), sum(t, negate(sum(pow(momentums[1][1], 2), pow(momentums[3][1], 2))))); //-2(k1, k4) = u - k1^2 - k4^2 //-2(k2, k3) = u - k2^2 - k3^2 result[i++] = expression(multiply(Complex.MINUS_TWO, contract(momentums[0][0], momentums[3][0])), sum(u, negate(sum(pow(momentums[0][1], 2), pow(momentums[3][1], 2))))); result[i++] = expression(multiply(Complex.MINUS_TWO, contract(momentums[1][0], momentums[2][0])), sum(u, negate(sum(pow(momentums[1][1], 2), pow(momentums[2][1], 2))))); return result; }
private Expression getTraceSubstitution(int length) { Expression trace = cachedTraces.get(length); if (trace == null) { //product of gamma matrices as array Tensor[] data = new Tensor[length]; int matrixIndex = setType(matrixType, 0) - 1, metricIndex = -1; int firstUpper, u = firstUpper = ++matrixIndex, i; for (i = 0; i < length; ++i) { data[i] = Tensors.simpleTensor(gammaMatrixStringName, createSimple(null, u | 0x80000000, i == length - 1 ? firstUpper : (u = ++matrixIndex), setType(metricType, ++metricIndex))); } Tensor rhs = traceOfArray(data); rhs = expandAndEliminate.transform(rhs); cachedTraces.put(length, trace = expression(multiply(data), rhs)); } return trace; }
this.L = Tensors.expression(Tensors.parse("L"), new Complex(operatorOrder)); this.hatQuantities = new Expression[HAT_QUANTITIES_GENERAL_COUNT][]; this.matrixIndicesCount = inputValues[1].get(0).getIndices().size() - operatorOrder;
Expression substitution = expression(lhs, rhs); substitution = expression(substitution.get(0), negate(substitution.get(1))); return substitution;
private Expression createBarSubs(SimpleTensor spinor, boolean negate) { if (spinor == null) return null; int dummy = spinor.getIndices().get(matrixType, 0), free = dummy + 1; SimpleTensor gamma = simpleTensor(gammaName, createSimple(null, setState(true, dummy), free, setType(metricType, 0))); SimpleTensor mom = setIndices(momentum, createSimple(null, setState(true, setType(metricType, 0)))); SimpleTensor rhs = setMatrixIndices0(spinor, free); return expression(multiply(spinor, gamma, mom), negate ? negate(multiply(mass, rhs)) : multiply(mass, rhs)); }
private Expression createSubs(SimpleTensor spinor, boolean negate) { if (spinor == null) return null; int dummy = setState(false, spinor.getIndices().get(matrixType, 0)), free = setState(true, dummy + 1); SimpleTensor gamma = simpleTensor(gammaName, createSimple(null, free, dummy, setType(metricType, 0))); SimpleTensor mom = setIndices(momentum, createSimple(null, setState(true, setType(metricType, 0)))); SimpleTensor rhs = setMatrixIndices0(spinor, free); return expression(multiply(spinor, gamma, mom), negate ? negate(multiply(mass, rhs)) : multiply(mass, rhs)); }
result[i] = expression(square(momentums[i][0]), pow(momentums[i][1], 2)); parseExpression("u2 = " + u2.toString(Redberry)), expression(parse("m1"), momentums[0][1]), expression(parse("m2"), momentums[1][1]), expression(parse("m3"), momentums[2][1]), expression(parse("m4"), momentums[3][1]),
return tensor; return Tensors.expression(newLhs, newRhs);
return expression(loopProduct, solution.build());
newRhs = applyIndexMapping(tensor.get(1), indexMapper, contract); if (newLhs != tensor.get(0) || newRhs != tensor.get(1)) return Tensors.expression(newLhs, newRhs); else return tensor;