projects-jenz/ArtificialAutism/src/main/java/FunctionLayer/StanfordParser/SentimentAnalyzerTest.java

package FunctionLayer.StanfordParser;

import FunctionLayer.LevenshteinDistance;
import FunctionLayer.Datahandler;
import FunctionLayer.SimilarityMatrix;
import FunctionLayer.StopwordAnnotator;
import com.google.common.collect.MapMaker;
import edu.mit.jmwe.data.IMWE;
import edu.mit.jmwe.data.IMWEDesc;
import edu.mit.jmwe.data.IToken;
import edu.stanford.nlp.ie.AbstractSequenceClassifier;
import edu.stanford.nlp.ling.CoreAnnotations;
import edu.stanford.nlp.ling.CoreLabel;
import edu.stanford.nlp.ling.HasWord;
import edu.stanford.nlp.ling.IndexedWord;
import edu.stanford.nlp.ling.JMWEAnnotation;
import edu.stanford.nlp.ling.TaggedWord;
import edu.stanford.nlp.neural.rnn.RNNCoreAnnotations;
import edu.stanford.nlp.pipeline.Annotation;
import edu.stanford.nlp.pipeline.CoreDocument;
import edu.stanford.nlp.pipeline.CoreEntityMention;
import edu.stanford.nlp.pipeline.StanfordCoreNLP;
import edu.stanford.nlp.process.CoreLabelTokenFactory;
import edu.stanford.nlp.process.DocumentPreprocessor;
import edu.stanford.nlp.process.PTBTokenizer;
import edu.stanford.nlp.process.TokenizerFactory;
import edu.stanford.nlp.sentiment.SentimentCoreAnnotations;
import edu.stanford.nlp.sequences.DocumentReaderAndWriter;
import edu.stanford.nlp.tagger.maxent.MaxentTagger;
import edu.stanford.nlp.trees.Constituent;
import edu.stanford.nlp.trees.GrammaticalRelation;
import edu.stanford.nlp.trees.GrammaticalStructure;
import edu.stanford.nlp.trees.GrammaticalStructureFactory;
import edu.stanford.nlp.trees.Tree;
import edu.stanford.nlp.trees.TreeCoreAnnotations;
import edu.stanford.nlp.trees.TypedDependency;
import edu.stanford.nlp.trees.tregex.gui.Tdiff;
import edu.stanford.nlp.util.CoreMap;
import edu.stanford.nlp.util.Pair;
import java.io.StringReader;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.OptionalDouble;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.lucene.analysis.core.StopAnalyzer;
import org.ejml.simple.SimpleMatrix;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author install1
 */
public class SentimentAnalyzerTest implements Callable<SimilarityMatrix> {

    private final SimilarityMatrix smxParam;
    private final String str;
    private final String str1;
    private final MaxentTagger tagger;
    private final GrammaticalStructureFactory gsf;
    private final StanfordCoreNLP pipeline;
    private final StanfordCoreNLP pipelineSentiment;
    private final AbstractSequenceClassifier classifier;
    private final Annotation jmweStrAnnotation1;
    private final Annotation jmweStrAnnotation2;
    private final Annotation pipelineAnnotation1;
    private final Annotation pipelineAnnotation2;
    private final Annotation pipelineAnnotation1Sentiment;
    private final Annotation pipelineAnnotation2Sentiment;
    private final CoreDocument pipelineCoreDcoument1;
    private final CoreDocument pipelineCoreDcoument2;
    private static SentimentValueCache cacheSentiment1;
    private static SentimentValueCache cacheSentiment2;

    public final SentimentValueCache getCacheSentiment1() {
        return cacheSentiment1;
    }

    public final SentimentValueCache getCacheSentiment2() {
        return cacheSentiment2;
    }

    public SentimentAnalyzerTest(String str, String str1, SimilarityMatrix smxParam, Annotation str1Annotation, Annotation str2Annotation,
            Annotation strPipeline1, Annotation strPipeline2, Annotation strPipeSentiment1, Annotation strPipeSentiment2,
            CoreDocument pipelineCoreDcoument1, CoreDocument pipelineCoreDcoument2, SentimentValueCache cacheValue1, SentimentValueCache cacheValue2) {
        this.str = str;
        this.str1 = str1;
        this.smxParam = smxParam;
        this.tagger = Datahandler.getTagger();
        this.pipeline = Datahandler.getPipeline();
        this.pipelineSentiment = Datahandler.getPipelineSentiment();
        this.gsf = Datahandler.getGsf();
        this.classifier = Datahandler.getClassifier();
        this.jmweStrAnnotation1 = str1Annotation;
        this.jmweStrAnnotation2 = str2Annotation;
        this.pipelineAnnotation1 = strPipeline1;
        this.pipelineAnnotation2 = strPipeline2;
        this.pipelineAnnotation1Sentiment = strPipeSentiment1;
        this.pipelineAnnotation2Sentiment = strPipeSentiment2;
        this.pipelineCoreDcoument1 = pipelineCoreDcoument1;
        this.pipelineCoreDcoument2 = pipelineCoreDcoument2;
        this.cacheSentiment1 = cacheValue1;
        this.cacheSentiment2 = cacheValue2;
    }

    private List<List<TaggedWord>> getTaggedWordList(String message) {
        List<List<TaggedWord>> taggedwordlist = new ArrayList();
        DocumentPreprocessor tokenizer = new DocumentPreprocessor(new StringReader(message));
        TokenizerFactory<CoreLabel> ptbTokenizerFactory = PTBTokenizer.factory(new CoreLabelTokenFactory(), "untokenizable=firstDelete"); //noneDelete
        tokenizer.setTokenizerFactory(ptbTokenizerFactory);
        for (final List<HasWord> sentence : tokenizer) {
            taggedwordlist.add(tagger.tagSentence(sentence));
        }
        return taggedwordlist;
    }

    private int tokenizeCounting(List<List<TaggedWord>> taggedwordlist) {
        int counter = 0;
        return taggedwordlist.stream().map((taggedlist2) -> taggedlist2.size()).reduce(counter, Integer::sum);
    }

    private ConcurrentMap<Integer, String> retrieveTGWListIndex(List<List<TaggedWord>> taggedwordlist) {
        ConcurrentMap<Integer, String> tgwlistIndex = new MapMaker().concurrencyLevel(2).makeMap();
        taggedwordlist.forEach((TGWList) -> {
            TGWList.forEach((TaggedWord) -> {
                if (!tgwlistIndex.values().contains(TaggedWord.tag()) && !TaggedWord.tag().equals(":")) {
                    tgwlistIndex.put(tgwlistIndex.size() + 1, TaggedWord.tag());
                }
            });
        });
        return tgwlistIndex;
    }

    private final Double iterateTrees(ConcurrentMap<Integer, Tree> sentenceConstituencyParseList2, ConcurrentMap<Integer, Tree> sentenceConstituencyParseList1, Double score) {
        for (final Tree sentenceConstituencyParse2 : sentenceConstituencyParseList2.values()) {
            int constiRelationsize = 0;
            for (final Tree sentenceConstituencyParse1 : sentenceConstituencyParseList1.values()) {
                Set<Constituent> constinuent1 = Tdiff.markDiff(sentenceConstituencyParse1, sentenceConstituencyParse2);
                Set<Constituent> constinuent2 = Tdiff.markDiff(sentenceConstituencyParse2, sentenceConstituencyParse1);
                ConcurrentMap<Integer, String> constiLabels = new MapMaker().concurrencyLevel(2).makeMap();
                for (final Constituent consti : constinuent1) {
                    for (final Constituent consti1 : constinuent2) {
                        if (consti.value().equals(consti1.value()) && !constiLabels.values().contains(consti.value())) {
                            constiLabels.put(constiLabels.size(), consti.value());
                            constiRelationsize++;
                        }
                    }
                }
                int constituents1 = constinuent1.size() - constiRelationsize;
                int constituents2 = constinuent2.size() - constiRelationsize;
                if (constituents1 * 5 < constituents2 || constituents2 * 5 < constituents1) {
                    score -= (constituents1 + constituents2) * 200;
                } else if (constituents1 == 0 || constituents2 == 0) {
                    score -= constiRelationsize * 200;
                } else {
                    score += constiRelationsize * 160;
                    //System.out.println("score post constiRelationsize: " + score + "\nconstituents1: " + constituents1
                    //       + "\nconstituents2: " + constituents2 + "\nconstiRelationsize: " + constiRelationsize + "\n");
                }
            }
        }
        return score;
    }

    private Double typeDependenciesGrammaticalRelation(Collection<TypedDependency> allTypedDependencies1, Collection<TypedDependency> allTypedDependencies2,
            Double score, ConcurrentMap<Integer, GrammaticalStructure> grammaticalMap1, ConcurrentMap<Integer, GrammaticalStructure> grammaticalMap2,
            ConcurrentMap<Integer, Tree> sentenceConstituencyParseList1, ConcurrentMap<Integer, Tree> sentenceConstituencyParseList2) {
        ConcurrentMap<Integer, Integer> alltypeDepsSizeMap = new MapMaker().concurrencyLevel(2).makeMap();
        ConcurrentMap<Integer, Integer> summationMap = new MapMaker().concurrencyLevel(2).makeMap();
        int relationApplicable1 = 0;
        int relationApplicable2 = 0;
        int grammaticalRelation1 = 0;
        int grammaticalRelation2 = 0;
        //believe in faith
        for (TypedDependency TDY1 : allTypedDependencies1) {
            IndexedWord dep = TDY1.dep();
            IndexedWord gov = TDY1.gov();
            for (GrammaticalStructure gs : grammaticalMap1.values()) {
                GrammaticalRelation grammaticalRelation = gs.getGrammaticalRelation(gov, dep);
                for (Tree sentenceConstituencyParse2 : sentenceConstituencyParseList2.values()) {
                    if (grammaticalRelation.isApplicable(sentenceConstituencyParse2)) {
                        score += 700;
                        //System.out.println("grammaticalRelation applicable score: " + score + "\n");
                        grammaticalRelation1++;
                    }
                    GrammaticalRelation reln = TDY1.reln();
                    //sentenceConstituencyParse1
                    if (reln.isApplicable(sentenceConstituencyParse2)) {
                        score += 525;
                        relationApplicable1++;
                    }
                }
            }
        }
        for (TypedDependency TDY : allTypedDependencies2) {
            IndexedWord dep = TDY.dep();
            IndexedWord gov = TDY.gov();
            for (GrammaticalStructure gs : grammaticalMap2.values()) {
                GrammaticalRelation grammaticalRelation = gs.getGrammaticalRelation(gov, dep);
                for (Tree sentenceConstituencyParse1 : sentenceConstituencyParseList1.values()) {
                    if (grammaticalRelation.isApplicable(sentenceConstituencyParse1)) {
                        score += 700;
                        //System.out.println("grammaticalRelation applicable score: " + score + "\n");
                        grammaticalRelation2++;
                    }
                    GrammaticalRelation reln = TDY.reln();
                    //sentenceConstituencyParse1
                    if (reln.isApplicable(sentenceConstituencyParse1)) {
                        score += 525;
                        relationApplicable2++;
                    }
                }
            }
        }
        if ((grammaticalRelation1 == 0 && grammaticalRelation2 > 4) || (grammaticalRelation2 == 0 && grammaticalRelation1 > 4)) {
            score -= 3450;
            //System.out.println("grammaticalRelation1 score trim: " + score + "\ngrammaticalRelation1: " + grammaticalRelation1
            //   + "\ngrammaticalRelation2: " + grammaticalRelation2 + "\n");
        }
        if (!allTypedDependencies1.isEmpty() || !allTypedDependencies2.isEmpty()) {
            int allTypeDep1 = allTypedDependencies1.size();
            int allTypeDep2 = allTypedDependencies2.size();
            if (allTypeDep1 <= allTypeDep2 * 5 && allTypeDep2 <= allTypeDep1 * 5) {
                if (allTypeDep1 > 0 && allTypeDep2 > 0) {
                    if (allTypeDep1 * 2 <= allTypeDep2 || allTypeDep2 * 2 <= allTypeDep1) {
                        score -= allTypeDep1 > allTypeDep2 ? (allTypeDep1 - allTypeDep2) * 160 : (allTypeDep2 - allTypeDep1) * 160;
                        //System.out.println(" allTypeDep score: " + score + "\nallTypeDep1: " + allTypeDep1 + "\nallTypeDep2: "
                        //   + allTypeDep2 + "\n");
                    } else {
                        score += allTypeDep1 > allTypeDep2 ? (allTypeDep1 - allTypeDep2) * 600 : (allTypeDep2 - allTypeDep1) * 600;
                        //System.out.println(" allTypeDep score: " + score + "\nallTypeDep1: " + allTypeDep1 + "\nallTypeDep2: "
                        //    + allTypeDep2 + "\n");
                    }
                    alltypeDepsSizeMap.put(alltypeDepsSizeMap.size() + 1, allTypeDep1);
                    alltypeDepsSizeMap.put(alltypeDepsSizeMap.size() + 1, allTypeDep2);
                }
            }
            if (allTypeDep1 >= 5 && allTypeDep2 >= 5) {
                int largerTypeDep = allTypeDep1 > allTypeDep2 ? allTypeDep1 : allTypeDep2;
                int smallerTypeDep = allTypeDep1 < allTypeDep2 ? allTypeDep1 : allTypeDep2;
                int summation = (largerTypeDep * largerTypeDep) - (smallerTypeDep * smallerTypeDep);
                if (summation / largerTypeDep < 15.0 && summation / largerTypeDep > 10.0 && smallerTypeDep * 2 > largerTypeDep
                        && !summationMap.values().contains(summation)) {
                    score += summation * 80;
                    summationMap.put(summationMap.size() + 1, summation);
                    //System.out.println("score post summation: " + score + "\nsummation: " + summation + "\n");
                } else if (largerTypeDep == smallerTypeDep) {
                    score += 2500;
                    //System.out.println("score largerTypeDep equals smallerTypeDep: " + score + "\nlargerTypeDep: " + largerTypeDep + "\n");
                }
            }
            if (relationApplicable1 > 0 && relationApplicable2 > 0 && relationApplicable1 == relationApplicable2
                    && grammaticalRelation1 > 0 && grammaticalRelation2 > 0 && grammaticalRelation1 == grammaticalRelation2) {
                score += 3500;
                //System.out.println("score relationApplicable equal: " + score + "\n");
            } else if (allTypeDep1 * 5 < allTypeDep2 || allTypeDep2 * 5 < allTypeDep1) {
                score -= allTypeDep1 > allTypeDep2 ? (allTypeDep1 - allTypeDep2) * (allTypeDep2 * 450)
                        : (allTypeDep2 - allTypeDep1) * (allTypeDep1 * 450);
                //System.out.println("score minus grammaticalRelation equal: " + score + "\n");
            }
            if (relationApplicable1 > 1 && relationApplicable2 > 1 && relationApplicable1 * 3 > relationApplicable2
                    && relationApplicable2 * 3 > relationApplicable1) {
                score += relationApplicable1 > relationApplicable2 ? (relationApplicable1 - relationApplicable2) * 1500
                        : (relationApplicable2 - relationApplicable1) * 1500;
                //System.out.println("score relationApplicable plus: " + score + "\n");
            } else if (relationApplicable1 * 5 < relationApplicable2 || relationApplicable2 * 5 < relationApplicable1) {
                score -= relationApplicable1 > relationApplicable2 ? (relationApplicable1 - relationApplicable2) * 500
                        : (relationApplicable2 - relationApplicable1) * 500;
                //System.out.println("score relationApplicable minus: " + score + "\n");
            }
            if (grammaticalRelation1 > 0 && grammaticalRelation2 > 0 && grammaticalRelation1 * 3 > grammaticalRelation2
                    && grammaticalRelation2 * 3 > grammaticalRelation1) {
                score += grammaticalRelation1 > grammaticalRelation2 ? (grammaticalRelation1 - grammaticalRelation2) * 1500
                        : (grammaticalRelation2 - grammaticalRelation1) * 1500;
                //System.out.println("score grammaticalRelation plus: " + score + "\n");
            } else if (grammaticalRelation1 * 5 < grammaticalRelation2 || grammaticalRelation2 * 5 < grammaticalRelation1) {
                score -= grammaticalRelation1 > grammaticalRelation2 ? (grammaticalRelation1 - grammaticalRelation2) * 500
                        : (grammaticalRelation2 - grammaticalRelation1) * 500;
                //System.out.println("score grammaticalRelation minus: " + score + "\n");
            }
            //System.out.println("score post relationApplicable1 veri: " + score + "\nrelationApplicable1: " + relationApplicable1
            //  + "\nrelationApplicable2: " + relationApplicable2 + "\ngrammaticalRelation1: " + grammaticalRelation1 + "\n"
            //   + "grammaticalRelation2: " + grammaticalRelation2 + "\n");
        }
        ConcurrentMap<Integer, String> filerTreeContent = new MapMaker().concurrencyLevel(2).makeMap();
        AtomicInteger runCount1 = new AtomicInteger(0);
        for (Tree sentenceConstituencyParse1 : sentenceConstituencyParseList1.values()) {
            for (Tree sentenceConstituencyParse2 : sentenceConstituencyParseList2.values()) {
                sentenceConstituencyParse1.taggedLabeledYield().forEach((LBW) -> {
                    sentenceConstituencyParse2.taggedLabeledYield().stream().filter((LBW1) -> (LBW.lemma().equals(LBW1.lemma())
                            && !filerTreeContent.values().contains(LBW.lemma()))).map((_item) -> {
                        filerTreeContent.put(filerTreeContent.size() + 1, LBW.lemma());
                        return _item;
                    }).forEachOrdered((_item) -> {
                        runCount1.getAndIncrement();
                    });
                });
            }
        }
        score += runCount1.get() * 250;
        //System.out.println("score pre typeSizeSmallest: " + score + "\n");
        int typeSizeSmallest = 100;
        int typeSizeLargest = 0;
        for (Integer i : alltypeDepsSizeMap.values()) {
            if (i > typeSizeLargest) {
                typeSizeLargest = i;
            }
            if (i < typeSizeSmallest) {
                typeSizeSmallest = i;
            }
        }
        if (typeSizeLargest >= typeSizeSmallest * 3) {
            score -= typeSizeLargest * 160;
        }
        typeSizeLargest = 0;
        typeSizeSmallest = 100;
        for (int i : summationMap.values()) {
            if (i > typeSizeLargest) {
                typeSizeLargest = i;
            }
            if (i < typeSizeSmallest) {
                typeSizeSmallest = i;
            }
        }
        if (typeSizeLargest >= typeSizeSmallest * 3) {
            score -= typeSizeLargest * 160;
        }
        return score;
    }

    private final Double simpleRNNMatrixCalculations(Double score, ConcurrentMap<Integer, SimpleMatrix> simpleSMXlist1, ConcurrentMap<Integer, SimpleMatrix> simpleSMXlist2) {
        for (SimpleMatrix simpleSMX2 : simpleSMXlist2.values()) {
            ConcurrentMap<Integer, Double> AccumulateDotMap = new MapMaker().concurrencyLevel(2).makeMap();
            ConcurrentMap<Integer, Double> subtractorMap = new MapMaker().concurrencyLevel(2).makeMap();
            ConcurrentMap<Integer, Double> dotPredictions = new MapMaker().concurrencyLevel(2).makeMap();
            ConcurrentMap<Integer, Double> DotOverTransfer = dotPredictions;
            dotPredictions = new MapMaker().concurrencyLevel(2).makeMap();
            Double totalSubtraction = 0.0;
            Double largest = 10.0;
            Double shortest = 100.0;
            for (SimpleMatrix simpleSMX1 : simpleSMXlist1.values()) {
                double dotPrediction2 = simpleSMX2.dot(simpleSMX1) * 100;
                double dotPrediction1 = simpleSMX1.dot(simpleSMX2) * 100;
                AccumulateDotMap.put(AccumulateDotMap.size() + 1, dotPrediction1);
                AccumulateDotMap.put(AccumulateDotMap.size() + 1, dotPrediction2);
                double subtracter1 = dotPrediction1 > 50 ? dotPrediction1 - 100 : dotPrediction1 > 0 ? 100 - dotPrediction1 : 0;
                double subtracter2 = dotPrediction2 > 50 ? dotPrediction2 - 100 : dotPrediction2 > 0 ? 100 - dotPrediction2 : 0;
                subtractorMap.put(subtractorMap.size() + 1, subtracter1);
                subtractorMap.put(subtractorMap.size() + 1, subtracter2);
                //System.out.println("dotPrediction: " + dotPrediction + "\nsubtracter: " + subtracter + "\n");
                if (!dotPredictions.values().contains(dotPrediction1)) {
                    for (Double transferDots : DotOverTransfer.values()) {
                        if (transferDots == dotPrediction1) {
                            totalSubtraction += transferDots;
                        } else {
                            score -= subtracter1 * 25;
                            //System.out.println("score minus subtracter: " + score + "\nsubtracter: " + subtracter + "\n");
                        }
                        //System.out.println("transferDots: " + transferDots + "\n");
                    }
                } else {
                    subtracter1 -= 100;
                    subtracter1 *= 25;
                    score -= subtracter1 * dotPrediction1;
                    //System.out.println("score minus subtracter * dotPrediction 2: " + score + "\ndotPrediction: "
                    //  + dotPrediction + "\n");
                }
                dotPredictions.put(dotPredictions.size() + 1, dotPrediction1);
                if (!dotPredictions.values().contains(dotPrediction2)) {
                    if (dotPrediction2 > largest) {
                        largest = dotPrediction2;
                    }
                    if (dotPrediction2 < shortest) {
                        shortest = dotPrediction2;
                    }
                    Double dotPredictionIntervalDifference = largest - shortest;
                    subtracter2 *= 25;
                    //System.out.println("subtracter: " + subtracter + "\n");
                    if (dotPredictionIntervalDifference < 5.0) {
                        if (dotPredictions.values().size() > 0) {
                            if (subtracter2 > 0) {
                                score -= subtracter2;
                            } else {
                                score += subtracter2;
                                //System.out.println("score + subtracter: " + score + "\nsubtracter: " + subtracter + "\n");
                            }
                        }
                    } else {
                        score -= subtracter2 / 10;
                    }
                } else {
                    subtracter2 -= 100;
                    subtracter2 *= 25;
                    score += subtracter2 * dotPrediction2;
                    //System.out.println("score + subtracter * dotPrediction: " + score + "\nsubtracter: " + subtracter + "\ndotPrediction: "
                    //+ dotPrediction + "\n");
                }
                dotPredictions.put(dotPredictions.size() + 1, dotPrediction2);
            }
            //System.out.println("score post subtracter1: " + score + "\n");
            Double subTracPre = 0.0;
            for (Double subtractors : subtractorMap.values()) {
                if (Objects.equals(subTracPre, subtractors)) {
                    score -= 1500;
                    //System.out.println("score minus subTracPre equals: " + score + "\nsubTracPre: " + subTracPre + "\n");
                }
                subTracPre = subtractors;
            }
            if (totalSubtraction > 45.0) {
                score -= totalSubtraction * 25;
            } else {
                score += totalSubtraction * 25;
            }
            //System.out.println("score post totalSubtraction: " + score + "\ntotalSubtraction: " + totalSubtraction + "\n");
            Double preAccumulatorDot = 0.0;
            Double postAccumulatorDot = 0.0;
            for (Double accumulators : AccumulateDotMap.values()) {
                if (Objects.equals(preAccumulatorDot, accumulators)) {
                    if (Objects.equals(postAccumulatorDot, accumulators)) {
                        score -= 1400;
                    }
                    postAccumulatorDot = accumulators;
                }
                preAccumulatorDot = accumulators;
            }
            subTracPre = 0.0;
            for (Double subtractors : subtractorMap.values()) {
                if (Objects.equals(subTracPre, subtractors)) {
                    score -= 500;
                }
                subTracPre = subtractors;
            }
        }
        return score;
    }

    private final Double simpleRNNMaxtrixVectors(Double score, ConcurrentMap<Integer, SimpleMatrix> simpleSMXlistVector1, ConcurrentMap<Integer, SimpleMatrix> simpleSMXlistVector2) {
        final ConcurrentMap<Integer, Double> elementSumCounter = new MapMaker().concurrencyLevel(3).makeMap();
        final ConcurrentMap<Integer, Double> dotMap = new MapMaker().concurrencyLevel(3).makeMap();
        final ConcurrentMap<Integer, Double> elementSumMap = new MapMaker().concurrencyLevel(3).makeMap();
        final ConcurrentMap<Integer, Double> dotSumMap = new MapMaker().concurrencyLevel(3).makeMap();
        Double preDot = 0.0;
        Double postDot = 0.0;
        for (SimpleMatrix simpleSMX2 : simpleSMXlistVector2.values()) {
            for (SimpleMatrix simpleSMX1 : simpleSMXlistVector1.values()) {
                double dot2 = simpleSMX2.dot(simpleSMX1);
                double elementSum2 = simpleSMX2.kron(simpleSMX1).elementSum();
                double dot1 = simpleSMX1.dot(simpleSMX2);
                double elementSum1 = simpleSMX1.kron(simpleSMX2).elementSum();
                if (preDot == dot2) {
                    if (postDot == dot2) {
                        score -= 500;
                    }
                    postDot = dot2;
                }
                if (preDot == dot1) {
                    if (postDot == dot1) {
                        score -= 500;
                    }
                    postDot = dot1;
                }
                preDot = dot1;
                elementSum1 = Math.round(elementSum1 * 100.0) / 100.0;
                elementSumCounter.put(elementSumCounter.size() + 1, elementSum1);
                dotMap.put(dotMap.size() + 1, dot1);
                preDot = dot2;
                elementSum2 = Math.round(elementSum2 * 100.0) / 100.0;
                elementSumCounter.put(elementSumCounter.size() + 1, elementSum2);
                dotMap.put(dotMap.size() + 1, dot2);
                if (!dotSumMap.values().contains(dot1)) {
                    if (dot1 < 0.1) {
                        score += 256;
                        //System.out.println("score dot < 0.1: " + score + "\ndot: "
                        //    + dot + "\n");
                    }
                    if (dot1 > 0.50) {
                        score -= 1400;
                    }
                    dotSumMap.put(dotSumMap.size() + 1, dot1);
                } else {
                    score -= 250;
                }
                if (!elementSumMap.values().contains(elementSum1)) {
                    if (elementSum1 < 0.01 && elementSum1 > 0.00) {
                        score += 1300;
                        //System.out.println("score elementSum < 0.01 && elementSum > 0.00: " + score + "\nelementSum: "
                        // + elementSum + "\n");
                    } else if (elementSum1 > 0.1 && elementSum1 < 1.0) {
                        score += 1100;
                        //System.out.println("score elementSum < 0.01 && elementSum > 0.00: " + score + "\nelementSum: "
                        // + elementSum + "\n");
                    } else {
                        score -= elementSum1 * 1024;
                    }
                    elementSumMap.put(elementSumMap.size() + 1, elementSum1);
                } else {
                    score -= 250;
                }
                if (!dotSumMap.values().contains(dot2)) {
                    if (dot2 < 0.000) {
                        score += dot2 * 500;
                        //System.out.println("score + dot * 500: " + score + "\ndot: " + dot + "\n");
                    } else if (dot2 < 0.1) {
                        score += 256;
                        //System.out.println("score + 256: " + score + "\ndot: " + dot + "<n");
                    }
                    if (dot2 > 0.50) {
                        score -= 1200;
                    }
                    dotSumMap.put(dotSumMap.size() + 1, dot2);
                } else {
                    score -= 250;
                }
                if (!elementSumMap.values().contains(elementSum2)) {
                    if (elementSum2 < 0.01 && elementSum2 > 0.00) {
                        score += 3300;
                        //System.out.println("score elementSum < 0.01 && elementSum > 0.00: " + score + "\nelementSum: "
                        // + elementSum + "\n");
                    } else if (elementSum2 > 0.1 && elementSum2 < 0.2) {
                        score += 1100;
                        //System.out.println("score elementSum < 0.01 && elementSum > 0.00: " + score + "\nelementSum: "
                        // + elementSum + "\n");
                    } else {
                        score -= elementSum2 * 1024;
                    }
                    elementSumMap.put(elementSumMap.size() + 1, elementSum2);
                } else {
                    score -= 250;
                }
            }
        }
        score = elementsAndDotsRelation(score, dotMap, elementSumCounter);
        return score;
    }

    private final Double elementsAndDotsRelation(Double score, ConcurrentMap<Integer, Double> dotMap, ConcurrentMap<Integer, Double> elementSumCounter) {
        //System.out.println("score post sentiment analyzer2: " + score + "\n");
        OptionalDouble minvalueDots = dotMap.values().stream().mapToDouble(Double::doubleValue).min();
        OptionalDouble maxvalueDots = dotMap.values().stream().mapToDouble(Double::doubleValue).max();
        double total = minvalueDots.getAsDouble() + maxvalueDots.getAsDouble();
        boolean permitted = false;
        if (minvalueDots.getAsDouble() != maxvalueDots.getAsDouble()) {
            permitted = true;
        }
        if (permitted) {
            Double dotsVariance = maxvalueDots.getAsDouble() - minvalueDots.getAsDouble();
            //System.out.println("maxvalueDots.getAsDouble():" + maxvalueDots.getAsDouble() + "\nminvalueDots.getAsDouble():"
            //   + minvalueDots.getAsDouble() + "\ndotsVariance: " + dotsVariance + "\n");
            if (maxvalueDots.getAsDouble() > minvalueDots.getAsDouble() * 10) {
                score -= 5500;
            } else if (minvalueDots.getAsDouble() < -0.10) {
                score -= 3500;
            } else if (dotsVariance < 0.5 && dotsVariance > 0.1) {
                score -= 3500;
            } else if (dotsVariance > minvalueDots.getAsDouble() * 2) {
                score += 3500;
                //System.out.println("varians 4 score. " + score + "\n");
            } else if (minvalueDots.getAsDouble() * 3 > maxvalueDots.getAsDouble() && maxvalueDots.getAsDouble() < 0.1001) {
                score += dotsVariance * 200000;
            }
        }
        //System.out.println("score post dotsVariance: " + score + "\n");
        OptionalDouble minvalueElements = elementSumCounter.values().stream().mapToDouble(Double::doubleValue).min();
        OptionalDouble maxvalueElements = elementSumCounter.values().stream().mapToDouble(Double::doubleValue).max();
        Double elementsVariance = maxvalueElements.getAsDouble() - minvalueElements.getAsDouble();
        //System.out.println("elementsVariance: " + elementsVariance + "\nmaxvalueElements.getAsDouble(): "
        //   + maxvalueElements.getAsDouble() + "\nminvalueElements.getAsDouble(): " + minvalueElements.getAsDouble() + "\n");
        if (elementsVariance == 0.0) {
            score -= 550;
        } else if (elementsVariance < 0.02 && elementsVariance > -0.01) {
            score += 3500;
        } else if (minvalueElements.getAsDouble() < 0.0 && minvalueElements.getAsDouble() - maxvalueElements.getAsDouble() < 0.50) {
            score -= 2500;
        } else if (elementsVariance * 2 >= maxvalueElements.getAsDouble() && elementsVariance < 0.1) {
            score -= elementsVariance * 86000;
        }
        return score;
    }

    private final Double sentimentMatrixVariances(Double score, int longest1, int longest2, int mainSentiment1, int mainSentiment2) {
        //System.out.println("score post pipelineAnnotation2Sentiment: " + score + "\n");
        if (longest1 != longest2) {
            long deffLongest = longest1 > longest2 ? longest1 : longest2;
            long deffshorter = longest1 < longest2 ? longest1 : longest2;
            if (deffLongest > deffshorter * 5) {
                score -= 5500;
            } else if (deffLongest < (deffshorter * 2) - 1 && deffLongest - deffshorter <= 45) {
                score += (deffLongest - deffshorter) * 20;
            } else if (mainSentiment1 != mainSentiment2 && deffLongest - deffshorter > 20 && deffLongest - deffshorter < 45) {
                score += (deffLongest - deffshorter) * 20;
            } else if (deffLongest - deffshorter < 2) {
                score += (deffLongest - deffshorter) * 20;
            } else if (deffshorter * 2 >= deffLongest && deffshorter * 2 < deffLongest + 5) {
                score += (deffLongest - deffshorter) * 20;
            } else {
                score -= (deffLongest - deffshorter) * 50;
            }
            if (deffLongest - deffshorter <= 5) {
                score += 250;
            }
        }
        return score;
    }

    private final Map.Entry<Double, Map.Entry<SentimentValueCache, SentimentValueCache>> classifyRawEvaluation(Double score, SentimentValueCache cacheSentimentLocal1,
            SentimentValueCache cacheSentimentLocal2) {
        if (cacheSentiment1 == null || cacheSentiment2 == null) {
            DocumentReaderAndWriter<CoreLabel> readerAndWriter = classifier.makePlainTextReaderAndWriter();
            if (cacheSentiment1 == null) {
                cacheSentimentLocal1.setClassifyRaw(classifier.classifyRaw(str, readerAndWriter));
            }
            if (cacheSentiment2 == null) {
                cacheSentimentLocal2.setClassifyRaw(classifier.classifyRaw(str1, readerAndWriter));
            }
        }
        final List classifyRaw1 = cacheSentiment1 == null ? cacheSentimentLocal1.getClassifyRaw() : cacheSentiment1.getClassifyRaw();
        final List classifyRaw2 = cacheSentiment2 == null ? cacheSentimentLocal2.getClassifyRaw() : cacheSentiment2.getClassifyRaw();
        score -= (classifyRaw1.size() > classifyRaw2.size() ? classifyRaw1.size() - classifyRaw2.size() : classifyRaw2.size() - classifyRaw1.size()) * 200;
        Map.Entry< Double, Map.Entry<SentimentValueCache, SentimentValueCache>> entry
                = new AbstractMap.SimpleEntry(score, new AbstractMap.SimpleEntry(cacheSentimentLocal1, cacheSentimentLocal2));
        return entry;
    }

    private final Double entryCountsRelation(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        int entry1 = cacheSentiment1 == null ? cacheSentimentLocal1.getEntryCounts().values().size() : cacheSentiment1.getEntryCounts().values().size();
        int entry2 = cacheSentiment2 == null ? cacheSentimentLocal2.getEntryCounts().values().size() : cacheSentiment2.getEntryCounts().values().size();
        //System.out.println("score post JMWEAnnotation: " + score + "\nentry1: " + entry1 + "\nentry2: " + entry2 + "\n");
        if (entry1 > 0 && entry2 > 0) {
            if ((entry1 >= entry2 * 5) || (entry2 >= entry1 * 5)) {
                score -= entry1 > entry2 ? (entry1 - entry2) * 450 : (entry2 - entry1) * 450;
                //System.out.println("1");
            } else if ((entry1 >= entry2 * 50 || entry2 >= entry1 * 50)) {
                score -= entry1 > entry2 ? entry1 * 180 : entry2 * 180;
                //System.out.println("2");
            } else if (entry1 >= entry2 * 2 || entry2 >= entry1 * 2) {
                score += entry1 > entry2 ? (entry1 - entry2) * 450 : (entry2 - entry1) * 450;
                //System.out.println("3");
            } else if (entry1 > 10 && entry2 > 10 && entry1 * 2 > entry2 && entry2 * 2 > entry1) {
                score += entry1 > entry2 ? entry2 * 600 : entry1 * 600;
                //System.out.println("6");
            }
        }
        return score;
    }

    private SentimentValueCache GrammaticStructureSetup(SentimentValueCache cacheSentimentLocal, Annotation pipelineAnnotation) {
        for (CoreMap sentence : pipelineAnnotation.get(CoreAnnotations.SentencesAnnotation.class)) {
            Tree sentenceConstituencyParse = sentence.get(TreeCoreAnnotations.TreeAnnotation.class);
            cacheSentimentLocal.addSentenceConstituencyParse(sentenceConstituencyParse);
            GrammaticalStructure gs = gsf.newGrammaticalStructure(sentenceConstituencyParse);
            cacheSentimentLocal.addTypedDependencies(gs.allTypedDependencies());
            cacheSentimentLocal.addGS(gs);
        }
        return cacheSentimentLocal;
    }

    private SentimentValueCache initializeCacheSetup(String str, SentimentValueCache cacheSentimentLocal) {
        cacheSentimentLocal = new SentimentValueCache(str);
        cacheSentimentLocal.setTaggedwords(getTaggedWordList(str));
        cacheSentimentLocal.setCounter(tokenizeCounting(cacheSentimentLocal.getTaggedwordlist()));
        return cacheSentimentLocal;
    }

    private SentimentValueCache sentimentCoreAnnotationSetup(Annotation pipelineAnnotationSentiment, SentimentValueCache cacheSentimentLocal) {
        for (CoreMap sentence : pipelineAnnotationSentiment.get(CoreAnnotations.SentencesAnnotation.class)) {
            Tree tree = sentence.get(SentimentCoreAnnotations.SentimentAnnotatedTree.class);
            int predictedClass = RNNCoreAnnotations.getPredictedClass(tree);
            SimpleMatrix predictions = RNNCoreAnnotations.getPredictions(tree);
            SimpleMatrix nodeVector = RNNCoreAnnotations.getNodeVector(tree);
            try {
                cacheSentimentLocal.addRNNPredictClass(predictedClass);
                cacheSentimentLocal.addSimpleMatrix(predictions);
                cacheSentimentLocal.addSimpleMatrixVector(nodeVector);
            } catch (Exception ex) {
                System.out.println("ex: " + ex.getLocalizedMessage() + "\n");
            }
        }
        return cacheSentimentLocal;
    }

    private SentimentValueCache setupMainSentimentandLongestVal(Annotation pipelineAnnotationSentiment, SentimentValueCache cacheSentimentLocal) {
        for (CoreMap sentence : pipelineAnnotationSentiment.get(CoreAnnotations.SentencesAnnotation.class)) {
            Tree tree = sentence.get(SentimentCoreAnnotations.SentimentAnnotatedTree.class);
            int sentiment = RNNCoreAnnotations.getPredictedClass(tree);
            String partText = sentence.toString();
            //SimpleMatrix predictions = RNNCoreAnnotations.getPredictions(tree);
            if (partText.length() > cacheSentimentLocal.getLongest()) {
                cacheSentimentLocal.setMainSentiment(sentiment);
                cacheSentimentLocal.setLongest(partText.length());
            }
        }
        return cacheSentimentLocal;
    }

    private SentimentValueCache jmweAnnotationSetup(Annotation jmweStrAnnotation, SentimentValueCache cacheSentimentLocal) {
        List<CoreMap> sentences = jmweStrAnnotation.get(CoreAnnotations.SentencesAnnotation.class);
        for (CoreMap sentence : sentences) {
            for (IMWE<IToken> token : sentence.get(JMWEAnnotation.class)) {
                if (token.isInflected()) {
                    cacheSentimentLocal.setInflectedCounterPositive(cacheSentimentLocal.getInflectedCounterPositive() + 1);
                } else {
                    cacheSentimentLocal.setInflectedCounterNegative(cacheSentimentLocal.getInflectedCounterNegative() + 1);
                }
                cacheSentimentLocal.addstrTokenForm(token.getForm());
                cacheSentimentLocal.addstrTokenGetEntry(token.getEntry().toString().substring(token.getEntry().toString().length() - 1));
                Collection<IMWEDesc.IPart> values = token.getPartMap().values();
                IMWEDesc entry = token.getEntry();
                cacheSentimentLocal.setMarkedContinuousCounter(cacheSentimentLocal.getMarkedContinuousCounter() + entry.getMarkedContinuous());
                cacheSentimentLocal.setUnmarkedPatternCounter(cacheSentimentLocal.getUnmarkedPatternCounter() + entry.getUnmarkedPattern());
                for (IMWEDesc.IPart iPart : values) {
                    cacheSentimentLocal.addstrTokenGetiPart(iPart.getForm());
                }
                for (String strPostPrefix : entry.getPOS().getPrefixes()) {
                    cacheSentimentLocal.addstrTokenEntryPOS(strPostPrefix);
                }
                for (int counts : entry.getCounts()) {
                    cacheSentimentLocal.addEntryCounts(counts);
                }
                for (IToken tokens : token.getTokens()) {
                    cacheSentimentLocal.addITokenMapTag(tokens.getTag());
                    for (String strtoken : tokens.getStems()) {
                        cacheSentimentLocal.addstrTokenStems(strtoken);
                        cacheSentimentLocal.setMarkedContiniousCounterEntries(cacheSentimentLocal.getMarkedContiniousCounterEntries() + 1);
                    }
                }
                cacheSentimentLocal.setTokensCounter(cacheSentimentLocal.getTokensCounter() + 1);
            }
            cacheSentimentLocal.setAnotatorcounter(cacheSentimentLocal.getAnotatorcounter() + 1);
        }
        return cacheSentimentLocal;
    }

    private Double entryCountsScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        ConcurrentMap<Integer, Integer> countsMap = new MapMaker().concurrencyLevel(2).makeMap();
        for (int counts : cacheSentimentLocal1.getEntryCounts().values()) {
            for (int counts1 : cacheSentimentLocal2.getEntryCounts().values()) {
                if (counts == counts1 && counts > 0 && !countsMap.values().contains(counts)) {
                    score += counts * 250;
                    //System.out.println("score post counts: " + score + "\nCounts: " + counts + "\n");
                    countsMap.put(countsMap.size() + 1, counts);
                }
            }
        }
        return score;
    }

    private Double tokenEntryPosScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        if (cacheSentimentLocal1.getstrTokenEntryPOS().values().size() > 1 && cacheSentimentLocal2.getstrTokenEntryPOS().values().size() > 1) {
            for (String strTokenPos1 : cacheSentimentLocal1.getstrTokenEntryPOS().values()) {
                for (String strTokenPos2 : cacheSentimentLocal2.getstrTokenEntryPOS().values()) {
                    if (strTokenPos1.equals(strTokenPos2)) {
                        score += 500;
                    } else {
                        score -= 650;
                        //System.out.println("strTokenEntryPOS score: " + score + "\n");
                    }
                }
            }
        }
        return score;
    }

    private Double unmarkedPatternCounterScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        int UnmarkedPatternCounter1 = cacheSentimentLocal1.getUnmarkedPatternCounter();
        int UnmarkedPatternCounter2 = cacheSentimentLocal2.getUnmarkedPatternCounter();
        if (UnmarkedPatternCounter1 > 0 && UnmarkedPatternCounter2 > 0) {
            if (UnmarkedPatternCounter1 * 2 > UnmarkedPatternCounter2 && UnmarkedPatternCounter2 * 2 > UnmarkedPatternCounter1) {
                score += 2500;
            } else if (UnmarkedPatternCounter1 * 5 < UnmarkedPatternCounter2 || UnmarkedPatternCounter2 * 5 < UnmarkedPatternCounter1) {
                score -= 4000;
            }
        }
        return score;
    }

    private Double markedContiniousCounterScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        int MarkedContinuousCounter1 = cacheSentimentLocal1.getMarkedContinuousCounter();
        int MarkedContinuousCounter2 = cacheSentimentLocal2.getMarkedContinuousCounter();
        int MarkedContiniousCounter1Entries = cacheSentimentLocal1.getMarkedContiniousCounterEntries();
        int MarkedContiniousCounter2Entries = cacheSentimentLocal2.getMarkedContiniousCounterEntries();
        if (MarkedContinuousCounter1 > 0 && MarkedContinuousCounter2 > 0) {
            if (MarkedContinuousCounter1 > MarkedContinuousCounter2 * 50 || MarkedContinuousCounter2 > MarkedContinuousCounter1 * 50) {
                score -= MarkedContinuousCounter1 > MarkedContinuousCounter2 ? MarkedContinuousCounter1 * 120 : MarkedContinuousCounter2 * 120;
                //System.out.println("score post MarkedContinuousCounter too big: " + score + "\n");
            } else if (!Objects.equals(MarkedContiniousCounter1Entries, MarkedContiniousCounter2Entries)
                    && (MarkedContinuousCounter1 * 2 >= MarkedContinuousCounter2 * MarkedContinuousCounter1)
                    || (MarkedContinuousCounter2 * 2 >= MarkedContinuousCounter1 * MarkedContinuousCounter2)) {
                score += 4500;
            } else if (MarkedContiniousCounter1Entries == 0 || MarkedContiniousCounter2Entries == 0) {
                score += MarkedContinuousCounter1 > MarkedContinuousCounter2 ? (MarkedContinuousCounter2 - MarkedContinuousCounter1) * 500
                        : (MarkedContinuousCounter1 - MarkedContinuousCounter2) * 500;
            }
            if (MarkedContiniousCounter1Entries > 0 && MarkedContiniousCounter2Entries > 0 && MarkedContinuousCounter1 > 0
                    && MarkedContinuousCounter2 > 0 && MarkedContinuousCounter1 < MarkedContinuousCounter2 * 10
                    && MarkedContinuousCounter2 < MarkedContinuousCounter1 * 10) {
                if (MarkedContiniousCounter1Entries > MarkedContiniousCounter2Entries * 5
                        || MarkedContiniousCounter2Entries > MarkedContiniousCounter1Entries * 5
                        || MarkedContiniousCounter1Entries * 5 < MarkedContinuousCounter1
                        || MarkedContiniousCounter1Entries * 5 < MarkedContinuousCounter2
                        || MarkedContiniousCounter2Entries * 5 < MarkedContinuousCounter1
                        || MarkedContiniousCounter2Entries * 5 < MarkedContinuousCounter2) {
                    score -= MarkedContinuousCounter1 > MarkedContinuousCounter2 ? MarkedContinuousCounter1 * 400 : MarkedContinuousCounter2 * 400;
                    //System.out.println("score post MarkedContinuousCounter: " + score + "\n");
                }
            }
        }
        return score;
    }

    private Double strTokensMapScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        ConcurrentMap<Integer, String> strtokensMap = new MapMaker().concurrencyLevel(2).makeMap();
        for (String strTokeniPart1 : cacheSentimentLocal1.getstrTokenGetiPart().values()) {
            for (String strTokeniPart2 : cacheSentimentLocal2.getstrTokenGetiPart().values()) {
                if (strTokeniPart1.equals(strTokeniPart2) && !strtokensMap.values().contains(strTokeniPart2)) {
                    strtokensMap.put(strtokensMap.size() + 1, strTokeniPart2);
                    score += 400;
                } else {
                    score -= 200;
                    //System.out.println("score minus strTokenGetiPart: " + score + "\n");
                }
            }
        }
        return score;
    }

    private Double strTokenEntryScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        int tokenEntry1 = cacheSentimentLocal1.getstrTokenGetEntry().values().size();
        int tokenEntry2 = cacheSentimentLocal2.getstrTokenGetEntry().values().size();
        boolean boundaryLeaks = false;
        int remnantCounter = 0;
        if (tokenEntry1 * 2 != tokenEntry2 && tokenEntry2 * 2 != tokenEntry1) {
            boundaryLeaks = true;
        }
        ConcurrentMap<Integer, String> entryTokenMap = new MapMaker().concurrencyLevel(2).makeMap();
        for (String strTokenEntry1 : cacheSentimentLocal1.getstrTokenGetEntry().values()) {
            for (String strTokenEntry2 : cacheSentimentLocal2.getstrTokenGetEntry().values()) {
                if (!entryTokenMap.values().contains(strTokenEntry2)) {
                    if (strTokenEntry1.equals(strTokenEntry2)) {
                        score += boundaryLeaks ? 2500 : 2500 / 2;
                    } else if (!boundaryLeaks) {
                        score -= 450;
                        //System.out.println("boundariyLeacks score: " + score + "\n");
                    } else {
                        remnantCounter++;
                    }
                }
                entryTokenMap.put(entryTokenMap.size() + 1, strTokenEntry2);
            }
        }
        //System.out.println("score pre remnantCounter: " + score + "\n");
        score += remnantCounter * 250;
        return score;
    }

    private Double strTokenMapTagsScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        ConcurrentMap<Integer, String> iTokenMapTagsMap = new MapMaker().concurrencyLevel(2).makeMap();
        for (String strmapTag : cacheSentimentLocal1.getITokenMapTag().values()) {
            for (String strmapTag1 : cacheSentimentLocal2.getITokenMapTag().values()) {
                if (strmapTag.equals(strmapTag1)) {
                    score -= 1450;
                } else if (!iTokenMapTagsMap.values().contains(strmapTag)) {
                    score += 725;
                    iTokenMapTagsMap.put(iTokenMapTagsMap.size() + 1, strmapTag);
                }
            }
        }
        return score;
    }

    private Double tokenformSizeScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        int tokenform1size = cacheSentimentLocal1.getstrTokenForm().values().size();
        int tokenform2size = cacheSentimentLocal2.getstrTokenForm().values().size();
        if (tokenform1size > 0 || tokenform2size > 0) {
            if (tokenform1size < tokenform2size * 5 && tokenform2size < tokenform1size * 5) {
                for (String strTokenForm1itr1 : cacheSentimentLocal1.getstrTokenForm().values()) {
                    for (String strTokenForm1itr2 : cacheSentimentLocal2.getstrTokenForm().values()) {
                        if (strTokenForm1itr1.equals(strTokenForm1itr2)) {
                            score -= 1600;
                        } else {
                            score += 500;
                            //System.out.println("tokenform1size score500: " + score + "\n");
                        }
                    }
                }
            } else if (tokenform1size > 0 && tokenform2size > 0) {
                if (tokenform1size * 2 >= tokenform2size && tokenform2size * 2 >= tokenform1size) {
                    score += tokenform1size > tokenform2size ? tokenform1size * 600 : tokenform2size * 600;
                } else if (tokenform1size * 4 <= tokenform2size || tokenform2size * 4 <= tokenform1size) {
                    score -= tokenform1size > tokenform2size ? (tokenform1size - tokenform2size) * 600 : (tokenform2size - tokenform1size) * 600;
                }
                //System.out.println("tokenform1size score: " + score + "\ntokenform1size: " + tokenform1size + "\ntokenform2size: "
                //  + tokenform2size + "\n");
            }
        }
        return score;
    }

    private Double tokenStemmingMapScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        ConcurrentMap<Integer, String> tokenStemmingMap = new MapMaker().concurrencyLevel(2).makeMap();
        for (String strTokenStem : cacheSentimentLocal1.getstrTokenStems().values()) {
            for (String strTokenStem1 : cacheSentimentLocal2.getstrTokenStems().values()) {
                if (strTokenStem.equals(strTokenStem1) && !tokenStemmingMap.values().contains(strTokenStem)) {
                    score += 1500;
                    tokenStemmingMap.put(tokenStemmingMap.size() + 1, strTokenStem);
                }
                //System.out.println("score strTokenStem: " + score + "\n");
            }
        }
        return score;
    }

    private Double inflectedCounterScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        int inflectedCounterPositive1 = cacheSentimentLocal1.getInflectedCounterPositive();
        int inflectedCounterPositive2 = cacheSentimentLocal2.getInflectedCounterPositive();
        int inflectedCounterNegative = cacheSentimentLocal1.getInflectedCounterNegative() + cacheSentimentLocal2.getInflectedCounterNegative();
        //System.out.println("inflectedCounterPositive1: " + inflectedCounterPositive1 + "\ninflectedCounterPositive2: "
        //  + inflectedCounterPositive2 + "\ninflectedCounterNegative: " + inflectedCounterNegative + "\n");
        if (inflectedCounterPositive1 + inflectedCounterPositive2 > inflectedCounterNegative && inflectedCounterNegative > 0) {
            score += ((inflectedCounterPositive1 + inflectedCounterPositive2) - inflectedCounterNegative) * 650;
            //System.out.println("score inflectedCounterPositive plus: " + score + "\n");
        }
        if (inflectedCounterPositive1 > 0 && inflectedCounterPositive2 > 0) {
            if (inflectedCounterPositive1 * 2 > inflectedCounterPositive2 && inflectedCounterPositive2 * 2 > inflectedCounterPositive1) {
                score += ((inflectedCounterPositive1 + inflectedCounterPositive2) - inflectedCounterNegative) * 550;
                //System.out.println("score plus inflectedCounterPositive * 2: " + score + "\n");
            } else if (inflectedCounterPositive1 * 5 < inflectedCounterPositive2 || inflectedCounterPositive2 * 5 < inflectedCounterPositive1) {
                score -= inflectedCounterPositive1 > inflectedCounterPositive2 ? (inflectedCounterPositive1 - inflectedCounterPositive2) * 400
                        : (inflectedCounterPositive2 - inflectedCounterPositive1) * 400;
                //System.out.println("score minus inflectedCounterPositive * 2: " + score + "\n");
            }
        }
        return score;
    }

    private Double annotatorCountScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        int anotatorcounter1 = cacheSentimentLocal1.getAnotatorcounter();
        int anotatorcounter2 = cacheSentimentLocal2.getAnotatorcounter();
        //System.out.println("anotatorcounter1: " + anotatorcounter1 + "\nanotatorcounter2: " + anotatorcounter2 + "\n");
        if (anotatorcounter1 > 1 && anotatorcounter2 > 1) {
            if (anotatorcounter1 * 2 > anotatorcounter2 && anotatorcounter2 * 2 > anotatorcounter1) {
                score += anotatorcounter1 > anotatorcounter2 ? (anotatorcounter1 - anotatorcounter2) * 700
                        : (anotatorcounter2 - anotatorcounter1) * 700;
                //System.out.println("score plus anotatorcounter: " + score + "\n");
            } else if (anotatorcounter1 * 5 < anotatorcounter2 || anotatorcounter2 * 5 < anotatorcounter1) {
                score -= anotatorcounter1 > anotatorcounter2 ? (anotatorcounter1 - anotatorcounter2) * 400 : (anotatorcounter2 - anotatorcounter1) * 400;
                //System.out.println("score minus anotatorcounter: " + score + "\n");
            }
        }
        return score;
    }

    private Double tokensCounterScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        int tokensCounter1 = cacheSentimentLocal1.getTokensCounter();
        int tokensCounter2 = cacheSentimentLocal2.getTokensCounter();
        //System.out.println("tokensCounter1: " + tokensCounter1 + "\ntokensCounter2: " + tokensCounter2 + "\n");
        if ((tokensCounter1 > 1 && tokensCounter2 > 1) && tokensCounter1 < tokensCounter2 * 5 && tokensCounter2 < tokensCounter1 * 5) {
            if (tokensCounter1 > tokensCounter2 / 2 && tokensCounter2 > tokensCounter1 / 2) {
                score += (tokensCounter1 + tokensCounter2) * 1400;
                //System.out.println("score plus tokensCounter: " + score + "\n");
            } else {
                score -= 3500;
                //System.out.println("score minus tokensCounter: " + score + "\n");
            }
        } else {
            int elseint = tokensCounter1 >= tokensCounter2 ? (tokensCounter1 - tokensCounter2) * 500 : (tokensCounter2 - tokensCounter1) * 500;
            //System.out.println("elseint: " + elseint + "<n");
            if ((tokensCounter1 > tokensCounter2 * 5 || tokensCounter2 > tokensCounter1 * 5)
                    && tokensCounter1 > 0 && tokensCounter2 > 0) {
                score -= tokensCounter1 > tokensCounter2 ? (tokensCounter1 - tokensCounter2) * 500 : (tokensCounter2 - tokensCounter1) * 500;
                //System.out.println("score post tokensCounter: " + score + "\n");
            } else if (elseint > 0 && tokensCounter1 > 0 && tokensCounter2 > 0) {
                score -= elseint * 2;
                //System.out.println("score post elseint: " + elseint + "\n");
            }
        }
        return score;
    }

    private SentimentValueCache setupNEREntitiesAndTokenTags(CoreDocument pipelineCoreDcoument, SentimentValueCache cacheSentimentLocal) {
        for (CoreEntityMention em : pipelineCoreDcoument.entityMentions()) {
            Set<Map.Entry<String, Double>> entrySet = em.entityTypeConfidences().entrySet();
            String entityType = em.entityType();
            Double EntityConfidences = 0.0;
            for (Map.Entry<String, Double> entries : entrySet) {
                EntityConfidences = entries.getValue();
            }
            List<CoreLabel> tokens = em.tokens();
            for (CoreLabel token : tokens) {
                try {
                    if (!cacheSentimentLocal.getnerEntityTokenTags().values().contains(token.tag())) {
                        if (entityType.equals("PERSON") && EntityConfidences > 0.80) {
                            cacheSentimentLocal.addnerEntityTokenTags(token.tag());
                        }
                    }
                } catch (Exception ex) {
                    //System.out.println("failed corelabel ex: " + ex.getLocalizedMessage() + "\n" + ex.getCause() + "\n");
                }
            }
            if (!cacheSentimentLocal.getnerEntities1().values().contains(em.text())) {
                cacheSentimentLocal.addNEREntities1(em.text());
                cacheSentimentLocal.addNEREntities2(em.entityType());
            }
        }
        return cacheSentimentLocal;
    }

    private Double nerEntitiesAndTokenScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        for (String strEnts1 : cacheSentimentLocal1.getnerEntities1().values()) {
            Collection<String> values = cacheSentimentLocal2.getnerEntities1().values();
            for (String strEnts2 : values) {
                if (strEnts1.equalsIgnoreCase(strEnts2)) {
                    score += 2500;
                    //System.out.println("score strEnts1 plus: " + score + "\n");
                } else {
                    score -= 150;
                }
            }
        }
        for (String strEnts1 : cacheSentimentLocal1.getnerEntities2().values()) {
            if (cacheSentimentLocal2.getnerEntities2().values().contains(strEnts1)) {
                score -= 1500;
                //System.out.println("score nerEntities4 minus: " + score + "\n");
            } else {
                score -= 150;
            }
        }
        for (String strToken : cacheSentimentLocal1.getnerEntityTokenTags().values()) {
            if (cacheSentimentLocal2.getnerEntityTokenTags().values().contains(strToken)) {
                score += 2000;
                //System.out.println("score nerEntities4 plus: " + score + "\n");
            } else {
                score -= 150;
            }
        }
        return score;
    }

    private SentimentValueCache setupStoWordTokensLemma(Annotation pipelineAnnotationSentiment, SentimentValueCache cacheSentimentLocal) {
        String customStopWordList = "start,starts,period,periods,a,an,and,are,as,at,be,but,by,for,if,in,into,is,it,no,not,of,on,or,such,that,the,their,then,there,these,they,this,to,was,will,with";
        List<CoreLabel> tokensSentiment = pipelineAnnotationSentiment.get(CoreAnnotations.TokensAnnotation.class);
        Set<?> stopWords = StopAnalyzer.ENGLISH_STOP_WORDS_SET;
        Set<?> stopWordsCustom = StopwordAnnotator.getStopWordList(customStopWordList, true);
        for (CoreLabel token : tokensSentiment) {
            Pair<Boolean, Boolean> stopword = token.get(StopwordAnnotator.class);
            String word = token.word().toLowerCase();
            if (stopWords.contains(word) || stopWordsCustom.contains(word)) {
                cacheSentimentLocal.addstopwordTokens(word);
            }
            String lemma = token.lemma().toLowerCase();
            if (stopWords.contains(lemma) || stopWordsCustom.contains(lemma)) {
                cacheSentimentLocal.addStopWordLemma(lemma);
            }
            if (stopword.first() && stopword.second()) {
                cacheSentimentLocal.setPairCounter(cacheSentimentLocal.getPairCounter() + 1);
            }
            //System.out.println("stopword Pair: " + stopword.first() + " " + stopword.second() + "\nword: "
            //  + word + "\nlemma: " + lemma + "\n");
        }
        return cacheSentimentLocal;
    }

    private Double stopWordTokenLemmaScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        for (String stopwords1 : cacheSentimentLocal1.getStopwordTokens().values()) {
            for (String stopwords2 : cacheSentimentLocal2.getStopwordTokens().values()) {
                if (stopwords1.equals(stopwords2)) {
                    score -= 500;
                    //System.out.println("score stopwordsToken: " + score + "\n");
                }
            }
        }
        for (String stopwords1 : cacheSentimentLocal1.getStopWordLemma().values()) {
            for (String stopwords2 : cacheSentimentLocal2.getStopWordLemma().values()) {
                if (stopwords1.equals(stopwords2)) {
                    score -= 500;
                    //System.out.println("score stopwords Lemma: " + score + "\n");
                }
            }
        }
        return score;
    }

    private Double stopwordTokenPairCounterScoring(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        if (!cacheSentimentLocal1.getStopwordTokens().values().isEmpty() && !cacheSentimentLocal2.getStopwordTokens().values().isEmpty()) {
            int stopwordsize1 = cacheSentimentLocal1.getStopwordTokens().values().size();
            int stopwordsize2 = cacheSentimentLocal2.getStopwordTokens().values().size();
            if (stopwordsize1 * 5 < stopwordsize2 || stopwordsize2 * 5 < stopwordsize1) {
                score -= stopwordsize1 > stopwordsize2 ? (stopwordsize1 - stopwordsize2) * 850 : (stopwordsize2 - stopwordsize1) * 850;
            } else {
                score += stopwordsize1 > stopwordsize2 ? (stopwordsize1 - stopwordsize2) * 850 : (stopwordsize2 - stopwordsize1) * 850;;
            }
            //System.out.println("score post stopwordsize: " + score + "\nstopwordsize1: " + stopwordsize1 + "\nstopwordsize2: "
            // + stopwordsize2 + "\n");
        }
        int pairCounter1 = cacheSentimentLocal1.getPairCounter();
        int pairCounter2 = cacheSentimentLocal2.getPairCounter();
        if (pairCounter1 > 0 && pairCounter2 > 0) {
            if (pairCounter1 * 3 <= pairCounter2 || pairCounter2 * 3 <= pairCounter1) {
                score -= pairCounter1 > pairCounter2 ? (pairCounter1 - pairCounter2) * 1500 : (pairCounter2 - pairCounter1) * 1500;
            } else {
                score += pairCounter1 > pairCounter2 ? (pairCounter1 - pairCounter2) * 700 : (pairCounter2 - pairCounter1) * 700;
            }
            //System.out.println("score post pairCounter: " + score + "\npairCounter1: " + pairCounter1 + "\npairCounter2: " + pairCounter2 + "\n");
        }
        return score;
    }

    private Double tgwListScoreIncrementer(Double score, SentimentValueCache cacheSentimentLocal1, SentimentValueCache cacheSentimentLocal2) {
        AtomicInteger runCount = new AtomicInteger(0);
        cacheSentimentLocal1.getTgwlistIndex().values().forEach(TaggedWord -> {
            if (!cacheSentimentLocal2.getTgwlistIndex().values().contains(TaggedWord)) {
                cacheSentimentLocal2.addTgwlistIndex(TaggedWord);
                runCount.getAndIncrement();
            }
        });
        score += runCount.get() * 64;
        return score;
    }

    @Override
    public final SimilarityMatrix call() {
        Double score = -100.0;
        SentimentValueCache cacheSentimentLocal1 = null;
        SentimentValueCache cacheSentimentLocal2 = null;
        int counter1;
        int counter2;
        if (cacheSentiment1 == null) {
            cacheSentimentLocal1 = initializeCacheSetup(str, cacheSentimentLocal1);
        }
        if (cacheSentiment2 == null) {
            cacheSentimentLocal2 = initializeCacheSetup(str1, cacheSentimentLocal2);
        }
        counter1 = cacheSentiment1 == null ? cacheSentimentLocal1.getCounter() : cacheSentiment1.getCounter();
        counter2 = cacheSentiment2 == null ? cacheSentimentLocal2.getCounter() : cacheSentiment2.getCounter();
        final int overValue = (counter1 >= counter2 ? counter1 - counter2 : counter2 - counter1) * 32;
        score -= overValue;
        if (cacheSentiment1 == null) {
            ConcurrentMap<Integer, String> retrieveTGWListIndex = retrieveTGWListIndex(cacheSentimentLocal1.getTaggedwordlist());
            for (String str : retrieveTGWListIndex.values()) {
                cacheSentimentLocal1.addTgwlistIndex(str);
            }
        }
        if (cacheSentiment2 == null) {
            ConcurrentMap<Integer, String> retrieveTGWListIndex = retrieveTGWListIndex(cacheSentimentLocal2.getTaggedwordlist());
            for (String str : retrieveTGWListIndex.values()) {
                cacheSentimentLocal2.addTgwlistIndex(str);
            }
        }
        score = tgwListScoreIncrementer(score, cacheSentiment1 == null
                ? cacheSentimentLocal1 : cacheSentiment1, cacheSentiment2 == null ? cacheSentimentLocal2 : cacheSentiment2);
       // System.out.println("score post runCountGet: " + score + "\n");
        if (cacheSentiment1 == null) {
            cacheSentimentLocal1 = GrammaticStructureSetup(cacheSentimentLocal1, pipelineAnnotation1);
        }
        if (cacheSentiment2 == null) {
            cacheSentimentLocal2 = GrammaticStructureSetup(cacheSentimentLocal2, pipelineAnnotation2);
        }
        ConcurrentMap<Integer, Tree> sentenceConstituencyParseList2 = cacheSentiment2 == null
                ? cacheSentimentLocal2.getSentenceConstituencyParseList() : cacheSentiment2.getSentenceConstituencyParseList();
        ConcurrentMap<Integer, Tree> sentenceConstituencyParseList1 = cacheSentiment1 == null
                ? cacheSentimentLocal1.getSentenceConstituencyParseList() : cacheSentiment1.getSentenceConstituencyParseList();
        score = iterateTrees(sentenceConstituencyParseList2, sentenceConstituencyParseList1, score);
        Collection<TypedDependency> allTypedDependencies2 = cacheSentiment2 == null ? cacheSentimentLocal2.getAllTypedDependencies()
                : cacheSentiment2.getAllTypedDependencies();
        Collection<TypedDependency> allTypedDependencies1 = cacheSentiment1 == null ? cacheSentimentLocal1.getAllTypedDependencies()
                : cacheSentiment1.getAllTypedDependencies();
        ConcurrentMap<Integer, GrammaticalStructure> grammaticalMap1 = cacheSentiment1 == null ? cacheSentimentLocal1.getGs() : cacheSentiment1.getGs();
        ConcurrentMap<Integer, GrammaticalStructure> grammaticalMap2 = cacheSentiment2 == null ? cacheSentimentLocal2.getGs() : cacheSentiment2.getGs();
        score = typeDependenciesGrammaticalRelation(allTypedDependencies1, allTypedDependencies2, score, grammaticalMap1, grammaticalMap2,
                sentenceConstituencyParseList1, sentenceConstituencyParseList2);
        if (cacheSentiment1 == null) {
            cacheSentimentLocal1 = sentimentCoreAnnotationSetup(pipelineAnnotation1Sentiment, cacheSentimentLocal1);
        }
        if (cacheSentiment2 == null) {
            cacheSentimentLocal2 = sentimentCoreAnnotationSetup(pipelineAnnotation2Sentiment, cacheSentimentLocal2);
        }
        final ConcurrentMap<Integer, SimpleMatrix> simpleSMXlist1 = cacheSentiment1 == null
                ? cacheSentimentLocal1.getSimpleSMXlist() : cacheSentiment1.getSimpleSMXlist();
        final ConcurrentMap<Integer, SimpleMatrix> simpleSMXlist2 = cacheSentiment2 == null
                ? cacheSentimentLocal2.getSimpleSMXlist() : cacheSentiment2.getSimpleSMXlist();
        final ConcurrentMap<Integer, SimpleMatrix> simpleSMXlistVector1 = cacheSentiment1 == null
                ? cacheSentimentLocal1.getSimpleSMXlistVector() : cacheSentiment1.getSimpleSMXlistVector();
        final ConcurrentMap<Integer, SimpleMatrix> simpleSMXlistVector2 = cacheSentiment2 == null
                ? cacheSentimentLocal2.getSimpleSMXlistVector() : cacheSentiment2.getSimpleSMXlistVector();
        //System.out.println("score pre pipelineAnnotation2Sentiment: " + score + "\n");
        score = simpleRNNMatrixCalculations(score, simpleSMXlist1, simpleSMXlist2);
        score = simpleRNNMaxtrixVectors(score, simpleSMXlistVector1, simpleSMXlistVector2);
        int sentiment1 = cacheSentiment1 == null ? cacheSentimentLocal1.getRnnPrediectClassMap().size() : cacheSentiment1.getRnnPrediectClassMap().size();
        int sentiment2 = cacheSentiment2 == null ? cacheSentimentLocal2.getRnnPrediectClassMap().size() : cacheSentiment2.getRnnPrediectClassMap().size();
        //System.out.println("score post elementsVariance: " + score + "\n");
        score -= (sentiment1 > sentiment2 ? sentiment1 - sentiment2 : sentiment2 - sentiment1) * 500;
        Map.Entry<Double, Map.Entry<SentimentValueCache, SentimentValueCache>> classifyRawEvaluationEntry = classifyRawEvaluation(score, cacheSentimentLocal1,
                cacheSentimentLocal2);
        score = classifyRawEvaluationEntry.getKey();
        if (cacheSentiment1 == null) {
            cacheSentimentLocal1 = classifyRawEvaluationEntry.getValue().getKey();
        }
        if (cacheSentiment2 == null) {
            cacheSentimentLocal2 = classifyRawEvaluationEntry.getValue().getValue();
        }
        //System.out.println("score post classifyRaw: " + score + "\n");
        if (cacheSentiment1 == null) {
            cacheSentimentLocal1 = setupMainSentimentandLongestVal(pipelineAnnotation1Sentiment, cacheSentimentLocal1);
        }
        if (cacheSentiment2 == null) {
            cacheSentimentLocal2 = setupMainSentimentandLongestVal(pipelineAnnotation2Sentiment, cacheSentimentLocal2);
        }
        score = sentimentMatrixVariances(score, cacheSentiment1 == null ? cacheSentimentLocal1.getLongest() : cacheSentiment1.getLongest(),
                cacheSentiment2 == null ? cacheSentimentLocal2.getLongest() : cacheSentiment2.getLongest(), cacheSentiment1 == null
                ? cacheSentimentLocal1.getMainSentiment() : cacheSentiment1.getMainSentiment(), cacheSentiment2 == null
                ? cacheSentimentLocal2.getMainSentiment() : cacheSentiment2.getMainSentiment());
        if (cacheSentiment1 == null) {
            cacheSentimentLocal1 = jmweAnnotationSetup(jmweStrAnnotation1, cacheSentimentLocal1);
        }
        if (cacheSentiment2 == null) {
            cacheSentimentLocal2 = jmweAnnotationSetup(jmweStrAnnotation2, cacheSentimentLocal2);
        }
        SentimentValueCache scoringCache1 = cacheSentiment1 == null ? cacheSentimentLocal1 : cacheSentiment1;
        SentimentValueCache scoringCache2 = cacheSentiment2 == null ? cacheSentimentLocal2 : cacheSentiment2;
        score = entryCountsRelation(score, scoringCache1, scoringCache2);
        score = entryCountsScoring(score, scoringCache1, scoringCache2);
        score = tokenEntryPosScoring(score, scoringCache1, scoringCache2);
        score = unmarkedPatternCounterScoring(score, scoringCache1, scoringCache2);
        //System.out.println("score post UnmarkedPatternCounter: " + score + "\n");
        score = markedContiniousCounterScoring(score, scoringCache1, scoringCache2);
        score = strTokensMapScoring(score, scoringCache1, scoringCache2);
        score = strTokenEntryScoring(score, scoringCache1, scoringCache2);
        score = strTokenMapTagsScoring(score, scoringCache1, scoringCache2);
        //System.out.println("score post strmapTag: " + score + "\n");
        score = tokenformSizeScoring(score, scoringCache1, scoringCache2);
        //System.out.println("Score pre tokenStemmingMap: " + score + "\n");
        score = tokenStemmingMapScoring(score, scoringCache1, scoringCache2);
        //System.out.println("Score pre inflected: " + score + "\n");
        score = inflectedCounterScoring(score, scoringCache1, scoringCache2);
        score = annotatorCountScoring(score, scoringCache1, scoringCache2);
        score = tokensCounterScoring(score, scoringCache1, scoringCache2);
        //System.out.println("Score Pre levenhstein: " + score + "\n");
        LevenshteinDistance leven = new LevenshteinDistance(str, str1);
        double SentenceScoreDiff = leven.computeLevenshteinDistance();
        SentenceScoreDiff *= 15;
        score -= SentenceScoreDiff;
        if (cacheSentiment1 == null) {
            cacheSentimentLocal1 = setupNEREntitiesAndTokenTags(pipelineCoreDcoument1, cacheSentimentLocal1);
        }
        if (cacheSentiment2 == null) {
            cacheSentimentLocal2 = setupNEREntitiesAndTokenTags(pipelineCoreDcoument2, cacheSentimentLocal2);
        }
        //System.out.println("score post PERSON trim: " + score + "\n");
        score = nerEntitiesAndTokenScoring(score, cacheSentiment1 == null ? cacheSentimentLocal1 : cacheSentiment1, cacheSentiment2 == null
                ? cacheSentimentLocal2 : cacheSentiment2);
        //System.out.println("score pre stopwordTokens: " + score + "\n");
        if (cacheSentiment1 == null) {
            cacheSentimentLocal1 = setupStoWordTokensLemma(pipelineAnnotation1Sentiment, cacheSentimentLocal1);
        }
        if (cacheSentiment2 == null) {
            cacheSentimentLocal2 = setupStoWordTokensLemma(pipelineAnnotation2Sentiment, cacheSentimentLocal2);
        }
        score = stopWordTokenLemmaScoring(score, cacheSentiment1 == null ? cacheSentimentLocal1 : cacheSentiment1, cacheSentiment2 == null
                ? cacheSentimentLocal2 : cacheSentiment2);
        score = stopwordTokenPairCounterScoring(score, cacheSentiment1 == null ? cacheSentimentLocal1 : cacheSentiment1, cacheSentiment2 == null
                ? cacheSentimentLocal2 : cacheSentiment2);
       // System.out.println("Final current score: " + score + "\nSentence 1: " + str + "\nSentence 2: " + str1 + "\n");
        smxParam.setDistance(score);
        if (cacheSentiment1 == null) {
            smxParam.setCacheValue1(cacheSentimentLocal1);
        }
        if (cacheSentiment2 == null) {
            smxParam.setCacheValue2(cacheSentimentLocal2);
        }
        return smxParam;
    }
}