/** * Changes index type to specified, represented by byte. * <p/> * <br/>Expression used by this method is: <b><code>(0x80FFFFFF & index) | ((0x7F & type) << 24)</code></b> * * @param type IndexType * @param index index to change type in * @return index with new type */ public static int setType(IndexType type, int index) { return setType(type.getType(), index); }
protected Tensor[] createLine(final int length) { Tensor[] gammas = new Tensor[length]; int matrixIndex, u = matrixIndex = setType(matrixType, 0); for (int i = 0; i < length; ++i) gammas[i] = Tensors.simpleTensor(gammaName, createSimple(null, u | 0x80000000, u = ++matrixIndex, setType(metricType, i))); return gammas; }
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; }
/** * {@inheritDoc} * * @throws IndexOutOfBoundsException if no more allowed indices exist */ @Override public int generate(byte type) { IntProvider ig = generators.get(type); if (ig == null) throw new IndexOutOfBoundsException("No allowed indices with specified type: " + IndexType.getType(type)); return setType(type, ig.getNext()); }
private Tensor[] createArray(final int[] permutation) { int[] metricIndices = new int[permutation.length]; for (int i = 0; i < permutation.length; ++i) metricIndices[i] = setType(metricType, i); metricIndices = Permutations.permute(metricIndices, Permutations.inverse(permutation)); Tensor[] gammas = new Tensor[permutation.length]; int matrixIndex, u = matrixIndex = setType(matrixType, 0); for (int i = 0; i < permutation.length; ++i) { gammas[i] = Tensors.simpleTensor(gammaName, createSimple(null, u | 0x80000000, u = ++matrixIndex, metricIndices[i])); } return gammas; }
private Tensor[] createLine(final int length, final IntArrayList g5s) { Tensor[] gammas = new Tensor[length]; int matrixIndex, metricIndex = 0, u = matrixIndex = setType(matrixType, 0); int j = 0; for (int i = 0; i < length; ++i) { if (j < g5s.size() && g5s.get(j) == i) { gammas[i] = Tensors.simpleTensor(gamma5Name, createSimple(null, u | 0x80000000, u = ++matrixIndex)); ++j; } else gammas[i] = Tensors.simpleTensor(gammaName, createSimple(null, u | 0x80000000, u = ++matrixIndex, setType(metricType, metricIndex++))); } return gammas; }
/** * Generates new index of a particular type. * * @param type index type * @return new index of a particular type */ @Override public int generate(byte type) { IntGenerator ig = generators.get(type); if (ig == null) generators.put(type, ig = new IntGenerator()); return setType(type, ig.getNext()); }
byte btype = type.getType(); samples.add(Tensors.createKronecker(setType(btype, 0), 0x80000000 | setType(btype, 1))); if (CC.isMetric(btype)) { samples.add(Tensors.createMetric(setType(btype, 0), setType(btype, 1))); samples.add(Tensors.createMetric(0x80000000 | setType(btype, 0), 0x80000000 | setType(btype, 1)));
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; }
private Tensor order(Tensor[] gammas) { int numberOfGammas = gammas.length; Tensor tensor = cache.get(numberOfGammas); if (tensor == null) cache.put(numberOfGammas, tensor = order0(createLine(numberOfGammas))); int[] iFrom = new int[numberOfGammas + 2], iTo = new int[numberOfGammas + 2]; for (int i = 0; i < numberOfGammas; ++i) { iFrom[i] = setType(metricType, i); iTo[i] = gammas[i].getIndices().get(metricType, 0); } iFrom[numberOfGammas] = setType(matrixType, 0) | 0x80000000; iTo[numberOfGammas] = gammas[0].getIndices().getUpper().get(matrixType, 0); iFrom[numberOfGammas + 1] = setType(matrixType, numberOfGammas); iTo[numberOfGammas + 1] = gammas[numberOfGammas - 1].getIndices().getLower().get(matrixType, 0); return eliminate(ApplyIndexMapping.applyIndexMapping(tensor, new Mapping(iFrom, iTo))); }
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 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); } }
public int[] nextIndices(StructureOfIndices structureOfIndices) { int[] indices = new int[structureOfIndices.size()]; int[] typeInd; int p = 0; for (byte b : TYPES) { StructureOfIndices.TypeData typeData = structureOfIndices.getTypeData(b); if (typeData == null || typeData.length == 0) continue; typeInd = new int[typeData.length]; if (typeData.states != null) { //in the case of matrix indices int[] names = nextPermutation(typeInd.length); for (int i = 0; i < typeInd.length; ++i) typeInd[i] = IndicesUtils.createIndex(names[i], b, typeData.states.get(i)); } else { int i; int contracted = (contracted = nextInt(indices.length / 2)) == 0 ? 1 : contracted; for (i = 0; i < typeInd.length / contracted; ++i) typeInd[i] = IndicesUtils.setType(b, i); if (i - contracted < 0) contracted = i; for (; i < typeInd.length; ++i) typeInd[i] = IndicesUtils.createIndex(i - contracted, b, true); shuffle(typeInd); } System.arraycopy(typeInd, 0, indices, p, typeInd.length); p += typeInd.length; } return indices; }
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)}; }
Tensor move0(Tensor[] gammas, int index, boolean left) { if (gammas.length == 1) return gammas[0]; if ((index == 0 && left) || (index == gammas.length - 1 && !left)) return multiply(gammas); int numberOfGammas = gammas.length; IntArrayList iFrom = new IntArrayList(numberOfGammas + 2), iTo = new IntArrayList(numberOfGammas + 2), g5s = new IntArrayList(); for (int i = 0; i < numberOfGammas; ++i) { if (isGamma5(gammas[i])) g5s.add(i); else { iFrom.add(setType(metricType, i)); iTo.add(gammas[i].getIndices().get(metricType, 0)); } } iFrom.add(setType(matrixType, 0) | 0x80000000); iTo.add(gammas[0].getIndices().getUpper().get(matrixType, 0)); iFrom.add(setType(matrixType, numberOfGammas)); iTo.add(gammas[numberOfGammas - 1].getIndices().getLower().get(matrixType, 0)); Holder key = new Holder(index, numberOfGammas, g5s, left); Tensor tensor = cache.get(key); if (tensor == null) cache.put(key, tensor = left ? toLeft0(createLine(numberOfGammas, g5s), index) : toRight0(createLine(numberOfGammas, g5s), index)); return eliminate(ApplyIndexMapping.applyIndexMapping(tensor, new Mapping(iFrom.toArray(), iTo.toArray()))); }
int[] indicesArray = new int[order]; for (int i = 0; i < order; i++) indicesArray[i] = setType(indexType, i); SimpleIndices indices = IndicesFactory.createSimple(null, indicesArray); ArraysUtils.addAll(externalMomentums, createMetric(setType(indexType, 0), setType(indexType, 1))), true, true, true); SimpleTensor[] params = genTensor.coefficients;