cc.redberry.core.context.ContextSettings Maven / Gradle / Ivy

Go to download
/*
 * Redberry: symbolic tensor computations.
 *
 * Copyright (c) 2010-2012:
 *   Stanislav Poslavsky   
 *   Bolotin Dmitriy       
 *
 * This file is part of Redberry.
 *
 * Redberry is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Redberry is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Redberry. If not, see .
 */
package cc.redberry.core.context;

import cc.redberry.core.context.Context.Regim;
import cc.redberry.core.indices.IndexType;
import cc.redberry.core.parser.*;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;

/**
 * @author Dmitry Bolotin
 * @author Stanislav Poslavsky
 */
public class ContextSettings {
    //bindings
    private String imageOne;
    private ToStringMode defaultToStringMode;
    private String kronecker;
    //optional
    private String metricName = null;
    private EnumSet merticTypes = EnumSet.noneOf(IndexType.class);
    private EnumSet types = EnumSet.noneOf(IndexType.class);
    private List parsers = new ArrayList<>();
    private Context.Regim regim = Regim.NORMAL;
    private String workingFolder;
    private String mapleDirectory;
    private Long nameManagerSeed;

    public ContextSettings(String imageOne, ToStringMode defaultToStringMode, String kronecker) {
        this.imageOne = imageOne;
        this.defaultToStringMode = defaultToStringMode;
        this.kronecker = kronecker;
    }

    TensorParser[] getParsers() {
        return parsers.toArray(new TensorParser[parsers.size()]);
    }

    IndexSymbolConverter[] getConverters() {
        IndexSymbolConverter[] converters = new IndexSymbolConverter[types.size()];
        int i = 0;
        for (IndexType type : types)
            converters[i++] = type.getSymbolConverter();
        return converters;
    }

    byte[] getMetricTypes() {
        byte[] mTypes = new byte[merticTypes.size()];
        int i = 0;
        for (IndexType type : merticTypes)
            mTypes[i++] = type.getType();
        Arrays.sort(mTypes);
        return mTypes;
    }

    public void addIndexType(IndexType type) {
        types.add(type);
    }

    public void addMetricIndexType(IndexType type) {
        if (!types.contains(type))
            throw new IllegalStateException("This type is not registered. "
                    + "Use addIndexType(..) before invoking this method.");
        if (metricName == null)
            throw new IllegalStateException("Metric name not set.");
        merticTypes.add(type);
    }

    public void addTensorParser(TensorParser parser) {
        parsers.add(parser);
    }

    public void addTensorParsers(List parsers) {
        parsers.addAll(parsers);
    }

    public ToStringMode getDefaultToStringMode() {
        return defaultToStringMode;
    }

    public void setDefaultToStringMode(ToStringMode defaultToStringMode) {
        this.defaultToStringMode = defaultToStringMode;
    }

    public String getImageOne() {
        return imageOne;
    }

    public void setImageOne(String imageOne) {
        this.imageOne = imageOne;
    }

    public String getKronecker() {
        return kronecker;
    }

    public void setKronecker(String kronecker) {
        this.kronecker = kronecker;
    }

    public String getMetricName() {
        return metricName;
    }

    public void setMetricName(String metricName) {
        this.metricName = metricName;
    }

    public Regim getRegim() {
        return regim;
    }

    public void setRegim(Regim regim) {
        this.regim = regim;
    }

    public String getMapleDirectory() {
        return mapleDirectory;
    }

    public String getWorkingFolder() {
        return workingFolder;
    }

    public Long getNameManagerSeed() {
        return nameManagerSeed;
    }

    public void setNameManagerSeed(Long nameManagerSeed) {
        this.nameManagerSeed = nameManagerSeed;
    }

    public void setMapleDirectory(String mapleDirectory) {
        this.mapleDirectory = mapleDirectory;
    }

    public void setWorkingFolder(String workingFolder) {
        this.workingFolder = workingFolder;
    }

    public static ContextSettings createDefault() {
        return DEFAULT;
    }

    private static final ContextSettings DEFAULT = new ContextSettings("I", ToStringMode.REDBERRY, "d");

    static {
        DEFAULT.setMetricName("g");
        DEFAULT.addIndexType(IndexType.LatinUpper);
        DEFAULT.addIndexType(IndexType.LatinLower);
        DEFAULT.addIndexType(IndexType.GreekLower);
        DEFAULT.addIndexType(IndexType.GreekUpper);

        DEFAULT.addMetricIndexType(IndexType.LatinLower);
        DEFAULT.addMetricIndexType(IndexType.GreekLower);
        DEFAULT.addMetricIndexType(IndexType.LatinUpper);
        DEFAULT.addMetricIndexType(IndexType.GreekUpper);

        DEFAULT.addTensorParser(ParserSimpleTensor.INSTANCE);
        DEFAULT.addTensorParser(ParserTensorField.INSTANCE);
        DEFAULT.addTensorParser(ParserBrackets.INSTANCE);
        DEFAULT.addTensorParser(ParserProduct.INSTANCE);
        DEFAULT.addTensorParser(ParserSum.INSTANCE);
        DEFAULT.addTensorParser(ParserTensorNumber.INSTANCE);
        DEFAULT.addTensorParser(ParserDerivative.INSTANCE);
        DEFAULT.addTensorParser(ParserIntegral.INSTANCE);
        DEFAULT.addTensorParser(ParserPower.INSTANCE);
        DEFAULT.addTensorParser(ParserFunction.INSTANCE);

        //DEFAULT.setMapleDirectory(System.getenv("MAPLE"));
        DEFAULT.setMapleDirectory("/home/stas/maple14");
        DEFAULT.setWorkingFolder(System.getProperty("user.dir"));

        //REading seed from property if exists
        if (System.getProperty("redberry.nmseed") != null)
            //FIXME temorary variant for physics (netbeans bug)
//            DEFAULT.setNameManagerSeed(27182818284590L);
            DEFAULT.setNameManagerSeed(Long.parseLong(System.getProperty("redberry.nmseed"), 10));

        //creating current working folder
        if (DEFAULT.getWorkingFolder() != null)
            try {
                String strDirectoy = DEFAULT.getWorkingFolder() + "/work";
                DEFAULT.setWorkingFolder(strDirectoy);
                (new File(strDirectoy)).mkdir();
            } catch (Exception e) {
                System.err.println("Error: cannot create working folder" + e.getMessage());
                DEFAULT.setWorkingFolder(null);
            }

        ClassLoader.getSystemClassLoader().setDefaultAssertionStatus(true);
    }
}