protected final SimpleTensor setLowerMatrixIndex(SimpleTensor gamma, int matrixLower) { return setMatrixIndices(gamma, gamma.getIndices().getUpper().get(matrixType, 0), matrixLower); }
protected final SimpleTensor setUpperMatrixIndex(SimpleTensor gamma, int matrixUpper) { return setMatrixIndices(gamma, matrixUpper, gamma.getIndices().getLower().get(matrixType, 0)); }
private void checkSpinorNotation(SimpleTensor spinor, boolean bar) { if (spinor == null) return; SimpleIndices m = spinor.getIndices().getOfType(matrixType); if (m.size() != 1 || bar == getState(m.get(0))) throw new IllegalArgumentException("Illegal notation for spinor " + spinor); }
public IndicesInsertion(SimpleIndices upper, SimpleIndices lower, Indicator<ParseTokenSimpleTensor> indicator) { checkIndices(upper, lower); int[] upperArray = new int[upper.size()]; for (int i = upper.size() - 1; i >= 0; --i) upperArray[i] = IndicesUtils.getNameWithType(upper.get(i)); this.upper = upperArray; this.lower = lower.getAllIndices().copy(); this.indicator = indicator; }
private PermutationGroup conjugatedSymmetriesOfSubIndices(SimpleIndices allIndices) { //positions of indices in allIndices that should be stabilized int[] stabilizedPoints = new int[allIndices.size() - indices.size()]; int[] nonStabilizedPoints = new int[indices.size()]; int[] mapping = new int[indices.size()]; int sPointer = 0, nPointer = 0, index; for (int s = 0; s < allIndices.size(); ++s) { index = Arrays.binarySearch(sortedIndicesNames, getNameWithType(allIndices.get(s))); if (index < 0) stabilizedPoints[sPointer++] = s; else { nonStabilizedPoints[nPointer] = s; mapping[nPointer++] = index; } } PermutationGroup result = allIndices.getSymmetries().getPermutationGroup(). pointwiseStabilizerRestricted(stabilizedPoints); return result.conjugate(Permutations.createPermutation(mapping)); }
private static void checkIndices(SimpleIndices upper, SimpleIndices lower) { if (upper.size() != lower.size()) throw new IllegalArgumentException("Upper indices size not equal to lower indices size."); int size = upper.size(); for (int i = 0; i < size; ++i) { if (!IndicesUtils.getState(upper.get(i)) || IndicesUtils.getState(lower.get(i))) throw new IllegalArgumentException(); if (IndicesUtils.getType(upper.get(i)) != IndicesUtils.getType(lower.get(i))) throw new IllegalArgumentException(); if (i != 0) if (IndicesUtils.getType(upper.get(i - 1)) != IndicesUtils.getType(upper.get(i))) throw new IllegalArgumentException("Many types."); } }
private static void checkLeviCivita(SimpleTensor LeviCivita) { SimpleIndices indices = LeviCivita.getIndices(); if (indices.size() <= 1) throw new IllegalArgumentException("Levi-Civita cannot be a scalar."); byte type = getType(indices.get(0)); for (int i = 1; i < indices.size(); ++i) if (type != getType(indices.get(i))) throw new IllegalArgumentException("Levi-Civita have indices with different types."); } }
/** * Returns {@code true} if specified tensor is a metric tensor * * @param t tensor * @return {@code true} if specified tensor is a metric tensor */ public boolean isMetric(SimpleTensor t) { return nameManager.isKroneckerOrMetric(t.getName()) && IndicesUtils.haveEqualStates(t.getIndices().get(0), t.getIndices().get(1)); }
/** * Returns {@code true} if specified tensor is a Kronecker tensor * * @param t tensor * @return {@code true} if specified tensor is a Kronecker tensor */ public boolean isKronecker(SimpleTensor t) { return nameManager.isKroneckerOrMetric(t.getName()) && !IndicesUtils.haveEqualStates(t.getIndices().get(0), t.getIndices().get(1)); }
private static void check(IndexType type, SimpleTensor momentum) { if (momentum.getIndices().size() != 1) throw new IllegalArgumentException("Not a momentum: " + momentum); if (type != null && type != getTypeEnum(momentum.getIndices().get(0))) throw new IllegalArgumentException("Not a momentum: " + momentum + " wrong index type"); }
private SimpleIndices transformIndices(SimpleIndices old, NameAndStructureOfIndices oldDescriptor) { int[] newIndices = new int[old.size()]; for (int i = old.size() - 1; i >= 0; --i) { newIndices[i] = IndicesUtils.setType(transformer.newType(IndicesUtils.getTypeEnum(old.get(i)), oldDescriptor), old.get(i)); newIndices[i] = transformer.newIndex(newIndices[i], oldDescriptor); } return IndicesFactory.createSimple(null, newIndices); } }
private static void check(SimpleTensor loopMomentum, SimpleTensor[] externalMomentums) { check(null, loopMomentum); IndexType type = getTypeEnum(loopMomentum.getIndices().get(0)); for (SimpleTensor externalMomentum : externalMomentums) check(type, externalMomentum); }
@Override public void apply(IndexMapper indexMapper, IGWrapper generator, int[] upper, int[] lower) { SimpleIndices oldIndices = node.indices; int[] _newIndices = new int[oldIndices.size() + 2 * upper.length]; int i; for (i = 0; i < oldIndices.size(); ++i) _newIndices[i] = indexMapper.map(oldIndices.get(i)); System.arraycopy(upper, 0, _newIndices, oldIndices.size(), upper.length); System.arraycopy(lower, 0, _newIndices, oldIndices.size() + upper.length, lower.length); for (i = 0; i < upper.length; ++i) _newIndices[i + oldIndices.size()] |= 0x80000000; node.indices = IndicesFactory.createSimple(null, _newIndices); } }
private SimpleTensor setMatrixIndices0(SimpleTensor tensor, int... indices) { int[] newIndices = new int[tensor.getIndices().size()]; int j = 0; for (int i = 0; i < tensor.getIndices().size(); ++i) if (getType(tensor.getIndices().get(i)) == matrixType.getType()) newIndices[i] = indices[j++]; else newIndices[i] = tensor.getIndices().get(i); return setIndices(tensor, createSimple(null, newIndices)); }
private static void revertIndex(ParseToken token, int index) { if (token instanceof ParseTokenSimpleTensor) { ParseTokenSimpleTensor pToken = (ParseTokenSimpleTensor) token; SimpleIndices indices = pToken.indices; for (int i = 0; i < indices.size(); i++) { if (indices.get(i) == index) { int[] inds = indices.toArray(); inds[i] = IndicesUtils.inverseIndexState(index); pToken.indices = IndicesFactory.createSimple(null, inds); break; } } } else if (token.tokenType == TokenType.Product || token.tokenType == TokenType.Trace || token.tokenType == TokenType.Sum) for (ParseToken c : token.content) revertIndex(c, index); } }
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)); }
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 SchoutenIdentities4(SimpleTensor leviCivita) { this.leviCivita = leviCivita; ChangeIndicesTypesAndTensorNames tokenTransformer = new ChangeIndicesTypesAndTensorNames(TypesAndNamesTransformer.Utils.and( TypesAndNamesTransformer.Utils.changeName(new String[]{"e"}, new String[]{leviCivita.getStringName()}), TypesAndNamesTransformer.Utils.changeType(IndexType.LatinLower, IndicesUtils.getTypeEnum(leviCivita.getIndices().get(0))))); this.schouten1 = new Tensor[schoutenCombinations1.length]; for (int i = 0; i < schouten1.length; i++) schouten1[i] = tokenTransformer.transform(CC.current().getParseManager().getParser().parse(schoutenCombinations1[i])).toTensor(); this.schouten2 = new Tensor[schoutenCombinations2.length]; for (int i = 0; i < schouten2.length; i++) schouten2[i] = tokenTransformer.transform(CC.current().getParseManager().getParser().parse(schoutenCombinations2[i])).toTensor(); this.schouten3 = new Tensor[schoutenCombinations3.length]; for (int i = 0; i < schouten3.length; i++) schouten3[i] = tokenTransformer.transform(CC.current().getParseManager().getParser().parse(schoutenCombinations3[i])).toTensor(); allSchouten = new Tensor[][]{schouten1, schouten2, schouten3}; }