package com.yahoo.labs.samoa.evaluation.measures;

/*
 * #%L
 * SAMOA
 * %%
 * Copyright (C) 2011 RWTH Aachen University, Germany
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */

import com.yahoo.labs.samoa.instances.Instance;
import com.yahoo.labs.samoa.moa.cluster.Clustering;
import com.yahoo.labs.samoa.moa.core.AutoExpandVector;
import com.yahoo.labs.samoa.moa.core.DataPoint;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

/**
 * [CMM_GTAnalysis.java]
 * 
 * CMM: Ground truth analysis
 * 
 * Reference: Kremer et al.,
 * "An Effective Evaluation Measure for Clustering on Evolving Data Streams",
 * KDD, 2011
 * 
 * @author Timm jansen Data Management and Data Exploration Group, RWTH Aachen
 *         University
 */

/*
 * TODO: - try to avoid calcualting the radius multiple times - avoid the full
 * distance map? - knn functionality in clusters - noise error
 */
public class CMM_GTAnalysis {

  /**
   * the given ground truth clustering
   */
  private Clustering gtClustering;

  /**
   * list of given points within the horizon
   */
  private ArrayList<CMMPoint> cmmpoints;

  /**
   * the newly calculate ground truth clustering
   */
  private ArrayList<GTCluster> gt0Clusters;

  /**
   * IDs of noise points
   */
  private ArrayList<Integer> noise;

  /**
   * total number of points
   */
  private int numPoints;

  /**
   * number of clusters of the original ground truth
   */
  private int numGTClusters;

  /**
   * number of classes of the original ground truth, in case of a micro
   * clustering ground truth this differs from numGTClusters
   */
  private int numGTClasses;

  /**
   * number of classes after we are done with the analysis
   */
  private int numGT0Classes;

  /**
   * number of dimensions
   */
  private int numDims;

  /**
   * mapping between true cluster ID/class label of the original ground truth
   * and the internal cluster ID/working class label.
   * 
   * different original cluster IDs might map to the same new cluster ID due to
   * merging of two clusters
   */
  private HashMap<Integer, Integer> mapTrueLabelToWorkLabel;

  /**
   * log of how clusters have been merged (for debugging)
   */
  private int[] mergeMap;

  /**
   * number of non-noise points that will create an error due to the underlying
   * clustering model (e.g. point being covered by two clusters representing
   * different classes)
   */
  private int noiseErrorByModel;

  /**
   * number of noise points that will create an error due to the underlying
   * clustering model (e.g. noise point being covered by a cluster)
   */
  private int pointErrorByModel;

  /**
   * CMM debug mode
   */
  private boolean debug = false;

  /******* CMM parameter ***********/

  /**
   * defines how many nearest neighbors will be used
   */
  private int knnNeighbourhood = 2;

  /**
   * the threshold which defines when ground truth clusters will be merged. set
   * to 1 to disable merging
   */
  private double tauConnection = 0.5;

  /**
   * experimental (default: disabled) separate k for points to cluster and
   * cluster to cluster
   */
  private double clusterConnectionMaxPoints = knnNeighbourhood;

  /**
   * experimental (default: disabled) use exponential connectivity function to
   * model different behavior: closer points will have a stronger connection
   * compared to the linear function. Use ConnRefXValue and ConnX to better
   * parameterize lambda, which controls the decay of the connectivity
   */
  private boolean useExpConnectivity = false;
  private double lambdaConnRefXValue = 0.01;
  private double lambdaConnX = 4;
  private double lamdaConn;

  /******************************************/

  /**
   * Wrapper class for data points to store CMM relevant attributes
   * 
   */
  protected class CMMPoint extends DataPoint {
    /**
     * Reference to original point
     */
    protected DataPoint p = null;

    /**
     * point ID
     */
    protected int pID = 0;

    /**
     * true class label
     */
    protected int trueClass = -1;

    /**
     * the connectivity of the point to its cluster
     */
    protected double connectivity = 1.0;

    /**
     * knn distnace within own cluster
     */
    protected double knnInCluster = 0.0;

    /**
     * knn indices (for debugging only)
     */
    protected ArrayList<Integer> knnIndices;

    public CMMPoint(DataPoint point, int id) {
      // make a copy, but keep reference
      super(point, point.getTimestamp());
      p = point;
      pID = id;
      trueClass = (int) point.classValue();
    }

    /**
     * Retruns the current working label of the cluster the point belongs to.
     * The label can change due to merging of clusters.
     * 
     * @return the current working class label
     */
    protected int workclass() {
      if (trueClass == -1)
        return -1;
      else
        return mapTrueLabelToWorkLabel.get(trueClass);
    }
  }

  /**
   * Main class to model the new clusters that will be the output of the cluster
   * analysis
   * 
   */
  protected class GTCluster {
    /** points that are per definition in the cluster */
    private ArrayList<Integer> points = new ArrayList<Integer>();

    /**
     * a new GT cluster consists of one or more "old" GT clusters.
     * Connected/overlapping clusters cannot be merged directly because of the
     * underlying cluster model. E.g. for merging two spherical clusters the new
     * cluster sphere can cover a lot more space then two separate smaller
     * spheres. To keep the original coverage we need to keep the orignal
     * clusters and merge them on an abstract level.
     */
    private ArrayList<Integer> clusterRepresentations = new ArrayList<Integer>();

    /** current work class (changes when merging) */
    private int workclass;

    /** original work class */
    private final int orgWorkClass;

    /** original class label */
    private final int label;

    /** clusters that have been merged into this cluster (debugging) */
    private ArrayList<Integer> mergedWorkLabels = null;

    /** average knn distance of all points in the cluster */
    private double knnMeanAvg = 0;

    /** average deviation of knn distance of all points */
    private double knnDevAvg = 0;

    /** connectivity of the cluster to all other clusters */
    private ArrayList<Double> connections = new ArrayList<Double>();

    private GTCluster(int workclass, int label, int gtClusteringID) {
      this.orgWorkClass = workclass;
      this.workclass = workclass;
      this.label = label;
      this.clusterRepresentations.add(gtClusteringID);
    }

    /**
     * The original class label the cluster represents
     * 
     * @return original class label
     */
    protected int getLabel() {
      return label;
    }

    /**
     * Calculate the probability of the point being covered through the cluster
     * 
     * @param point
     *          to calculate the probability for
     * @return probability of the point being covered through the cluster
     */
    protected double getInclusionProbability(CMMPoint point) {
      double prob = Double.MIN_VALUE;
      // check all cluster representatives for coverage
      for (int c = 0; c < clusterRepresentations.size(); c++) {
        double tmp_prob = gtClustering.get(clusterRepresentations.get(c)).getInclusionProbability(point);
        if (tmp_prob > prob)
          prob = tmp_prob;
      }
      return prob;
    }

    /**
     * calculate knn distances of points within own cluster + average knn
     * distance and average knn distance deviation of all points
     */
    private void calculateKnn() {
      for (int p0 : points) {
        CMMPoint cmdp = cmmpoints.get(p0);
        if (!cmdp.isNoise()) {
          AutoExpandVector<Double> knnDist = new AutoExpandVector<Double>();
          AutoExpandVector<Integer> knnPointIndex = new AutoExpandVector<Integer>();

          // calculate nearest neighbours
          getKnnInCluster(cmdp, knnNeighbourhood, points, knnDist, knnPointIndex);

          // TODO: What to do if we have less then k neighbours?
          double avgKnn = 0;
          for (int i = 0; i < knnDist.size(); i++) {
            avgKnn += knnDist.get(i);
          }
          if (knnDist.size() != 0)
            avgKnn /= knnDist.size();
          cmdp.knnInCluster = avgKnn;
          cmdp.knnIndices = knnPointIndex;
          cmdp.p.setMeasureValue("knnAvg", cmdp.knnInCluster);

          knnMeanAvg += avgKnn;
          knnDevAvg += Math.pow(avgKnn, 2);
        }
      }
      knnMeanAvg = knnMeanAvg / (double) points.size();
      knnDevAvg = knnDevAvg / (double) points.size();

      double variance = knnDevAvg - Math.pow(knnMeanAvg, 2.0);
      // Due to numerical errors, small negative values can occur.
      if (variance <= 0.0)
        variance = 1e-50;
      knnDevAvg = Math.sqrt(variance);

    }

    /**
     * Calculate the connection of a cluster to this cluster
     * 
     * @param otherCid
     *          cluster id of the other cluster
     * @param initial
     *          flag for initial run
     */
    private void calculateClusterConnection(int otherCid, boolean initial) {
      double avgConnection = 0;
      if (workclass == otherCid) {
        avgConnection = 1;
      }
      else {
        AutoExpandVector<Double> kmax = new AutoExpandVector<Double>();
        AutoExpandVector<Integer> kmaxIndexes = new AutoExpandVector<Integer>();

        for (int p : points) {
          CMMPoint cmdp = cmmpoints.get(p);
          double con_p_Cj = getConnectionValue(cmmpoints.get(p), otherCid);
          double connection = cmdp.connectivity * con_p_Cj;
          if (initial) {
            cmdp.p.setMeasureValue("Connection to C" + otherCid, con_p_Cj);
          }

          // connection
          if (kmax.size() < clusterConnectionMaxPoints || connection > kmax.get(kmax.size() - 1)) {
            int index = 0;
            while (index < kmax.size() && connection < kmax.get(index)) {
              index++;
            }
            kmax.add(index, connection);
            kmaxIndexes.add(index, p);
            if (kmax.size() > clusterConnectionMaxPoints) {
              kmax.remove(kmax.size() - 1);
              kmaxIndexes.add(kmaxIndexes.size() - 1);
            }
          }
        }
        // connection
        for (int k = 0; k < kmax.size(); k++) {
          avgConnection += kmax.get(k);
        }
        avgConnection /= kmax.size();
      }

      if (otherCid < connections.size()) {
        connections.set(otherCid, avgConnection);
      }
      else if (connections.size() == otherCid) {
        connections.add(avgConnection);
      }
      else
        System.out.println("Something is going really wrong with the connection listing!" + knnNeighbourhood + " "
            + tauConnection);
    }

    /**
     * Merge a cluster into this cluster
     * 
     * @param mergeID
     *          the ID of the cluster to be merged
     */
    private void mergeCluster(int mergeID) {
      if (mergeID < gt0Clusters.size()) {
        // track merging (debugging)
        for (int i = 0; i < numGTClasses; i++) {
          if (mergeMap[i] == mergeID)
            mergeMap[i] = workclass;
          if (mergeMap[i] > mergeID)
            mergeMap[i]--;
        }
        GTCluster gtcMerge = gt0Clusters.get(mergeID);
        if (debug)
          System.out.println("Merging C" + gtcMerge.workclass + " into C" + workclass +
              " with Con " + connections.get(mergeID) + " / " + gtcMerge.connections.get(workclass));

        // update mapTrueLabelToWorkLabel
        mapTrueLabelToWorkLabel.put(gtcMerge.label, workclass);
        Iterator iterator = mapTrueLabelToWorkLabel.keySet().iterator();
        while (iterator.hasNext()) {
          Integer key = (Integer) iterator.next();
          // update pointer of already merged cluster
          int value = mapTrueLabelToWorkLabel.get(key);
          if (value == mergeID)
            mapTrueLabelToWorkLabel.put(key, workclass);
          if (value > mergeID)
            mapTrueLabelToWorkLabel.put(key, value - 1);
        }

        // merge points from B into A
        points.addAll(gtcMerge.points);
        clusterRepresentations.addAll(gtcMerge.clusterRepresentations);
        if (mergedWorkLabels == null) {
          mergedWorkLabels = new ArrayList<Integer>();
        }
        mergedWorkLabels.add(gtcMerge.orgWorkClass);
        if (gtcMerge.mergedWorkLabels != null)
          mergedWorkLabels.addAll(gtcMerge.mergedWorkLabels);

        gt0Clusters.remove(mergeID);

        // update workclass labels
        for (int c = mergeID; c < gt0Clusters.size(); c++) {
          gt0Clusters.get(c).workclass = c;
        }

        // update knn distances
        calculateKnn();
        for (int c = 0; c < gt0Clusters.size(); c++) {
          gt0Clusters.get(c).connections.remove(mergeID);

          // recalculate connection from other clusters to the new merged one
          gt0Clusters.get(c).calculateClusterConnection(workclass, false);
          // and from new merged one to other clusters
          gt0Clusters.get(workclass).calculateClusterConnection(c, false);
        }
      }
      else {
        System.out.println("Merge indices are not valid");
      }
    }
  }

  /**
   * @param trueClustering
   *          the ground truth clustering
   * @param points
   *          data points
   * @param enableClassMerge
   *          allow class merging (should be set to true on default)
   */
  public CMM_GTAnalysis(Clustering trueClustering, ArrayList<DataPoint> points, boolean enableClassMerge) {
    if (debug)
      System.out.println("GT Analysis Debug Output");

    noiseErrorByModel = 0;
    pointErrorByModel = 0;
    if (!enableClassMerge) {
      tauConnection = 1.0;
    }

    lamdaConn = -Math.log(lambdaConnRefXValue) / Math.log(2) / lambdaConnX;

    this.gtClustering = trueClustering;

    numPoints = points.size();
    numDims = points.get(0).numAttributes() - 1;
    numGTClusters = gtClustering.size();

    // init mappings between work and true labels
    mapTrueLabelToWorkLabel = new HashMap<Integer, Integer>();

    // set up base of new clustering
    gt0Clusters = new ArrayList<GTCluster>();
    int numWorkClasses = 0;
    // create label to worklabel mapping as real labels can be just a set of
    // unordered integers
    for (int i = 0; i < numGTClusters; i++) {
      int label = (int) gtClustering.get(i).getGroundTruth();
      if (!mapTrueLabelToWorkLabel.containsKey(label)) {
        gt0Clusters.add(new GTCluster(numWorkClasses, label, i));
        mapTrueLabelToWorkLabel.put(label, numWorkClasses);
        numWorkClasses++;
      }
      else {
        gt0Clusters.get(mapTrueLabelToWorkLabel.get(label)).clusterRepresentations.add(i);
      }
    }
    numGTClasses = numWorkClasses;

    mergeMap = new int[numGTClasses];
    for (int i = 0; i < numGTClasses; i++) {
      mergeMap[i] = i;
    }

    // create cmd point wrapper instances
    cmmpoints = new ArrayList<CMMPoint>();
    for (int p = 0; p < points.size(); p++) {
      CMMPoint cmdp = new CMMPoint(points.get(p), p);
      cmmpoints.add(cmdp);
    }

    // split points up into their GTClusters and Noise (according to class
    // labels)
    noise = new ArrayList<Integer>();
    for (int p = 0; p < numPoints; p++) {
      if (cmmpoints.get(p).isNoise()) {
        noise.add(p);
      }
      else {
        gt0Clusters.get(cmmpoints.get(p).workclass()).points.add(p);
      }
    }

    // calculate initial knnMean and knnDev
    for (GTCluster gtc : gt0Clusters) {
      gtc.calculateKnn();
    }

    // calculate cluster connections
    calculateGTClusterConnections();

    // calculate point connections with own clusters
    calculateGTPointQualities();

    if (debug)
      System.out.println("GT Analysis Debug End");

  }

  /**
   * Calculate the connection of a point to a cluster
   * 
   * @param cmmp
   *          the point to calculate the connection for
   * @param clusterID
   *          the corresponding cluster
   * @return the connection value
   */
  // TODO: Cache the connection value for a point to the different clusters???
  protected double getConnectionValue(CMMPoint cmmp, int clusterID) {
    AutoExpandVector<Double> knnDist = new AutoExpandVector<Double>();
    AutoExpandVector<Integer> knnPointIndex = new AutoExpandVector<Integer>();

    // calculate the knn distance of the point to the cluster
    getKnnInCluster(cmmp, knnNeighbourhood, gt0Clusters.get(clusterID).points, knnDist, knnPointIndex);

    // TODO: What to do if we have less then k neighbors?
    double avgDist = 0;
    for (int i = 0; i < knnDist.size(); i++) {
      avgDist += knnDist.get(i);
    }
    // what to do if we only have a single point???
    if (knnDist.size() != 0)
      avgDist /= knnDist.size();
    else
      return 0;

    // get the upper knn distance of the cluster
    double upperKnn = gt0Clusters.get(clusterID).knnMeanAvg + gt0Clusters.get(clusterID).knnDevAvg;

    /*
     * calculate the connectivity based on knn distance of the point within the
     * cluster and the upper knn distance of the cluster
     */
    if (avgDist < upperKnn) {
      return 1;
    }
    else {
      // value that should be reached at upperKnn distance
      // Choose connection formula
      double conn;
      if (useExpConnectivity)
        conn = Math.pow(2, -lamdaConn * (avgDist - upperKnn) / upperKnn);
      else
        conn = upperKnn / avgDist;

      if (Double.isNaN(conn))
        System.out.println("Connectivity NaN at " + cmmp.p.getTimestamp());

      return conn;
    }
  }

  /**
   * @param cmmp
   *          point to calculate knn distance for
   * @param k
   *          number of nearest neighbors to look for
   * @param pointIDs
   *          list of point IDs to check
   * @param knnDist
   *          sorted list of smallest knn distances (can already be filled to
   *          make updates possible)
   * @param knnPointIndex
   *          list of corresponding knn indices
   */
  private void getKnnInCluster(CMMPoint cmmp, int k,
      ArrayList<Integer> pointIDs,
      AutoExpandVector<Double> knnDist,
      AutoExpandVector<Integer> knnPointIndex) {

    // iterate over every point in the choosen cluster, cal distance and insert
    // into list
    for (int p1 = 0; p1 < pointIDs.size(); p1++) {
      int pid = pointIDs.get(p1);
      if (cmmp.pID == pid)
        continue;
      double dist = distance(cmmp, cmmpoints.get(pid));
      if (knnDist.size() < k || dist < knnDist.get(knnDist.size() - 1)) {
        int index = 0;
        while (index < knnDist.size() && dist > knnDist.get(index)) {
          index++;
        }
        knnDist.add(index, dist);
        knnPointIndex.add(index, pid);
        if (knnDist.size() > k) {
          knnDist.remove(knnDist.size() - 1);
          knnPointIndex.remove(knnPointIndex.size() - 1);
        }
      }
    }
  }

  /**
   * calculate initial connectivities
   */
  private void calculateGTPointQualities() {
    for (int p = 0; p < numPoints; p++) {
      CMMPoint cmdp = cmmpoints.get(p);
      if (!cmdp.isNoise()) {
        cmdp.connectivity = getConnectionValue(cmdp, cmdp.workclass());
        cmdp.p.setMeasureValue("Connectivity", cmdp.connectivity);
      }
    }
  }

  /**
   * Calculate connections between clusters and merge clusters accordingly as
   * long as connections exceed threshold
   */
  private void calculateGTClusterConnections() {
    for (int c0 = 0; c0 < gt0Clusters.size(); c0++) {
      for (int c1 = 0; c1 < gt0Clusters.size(); c1++) {
        gt0Clusters.get(c0).calculateClusterConnection(c1, true);
      }
    }

    boolean changedConnection = true;
    while (changedConnection) {
      if (debug) {
        System.out.println("Cluster Connection");
        for (int c = 0; c < gt0Clusters.size(); c++) {
          System.out.print("C" + gt0Clusters.get(c).label + " --> ");
          for (int c1 = 0; c1 < gt0Clusters.get(c).connections.size(); c1++) {
            System.out.print(" C" + gt0Clusters.get(c1).label + ": " + gt0Clusters.get(c).connections.get(c1));
          }
          System.out.println("");
        }
        System.out.println("");
      }

      double max = 0;
      int maxIndexI = -1;
      int maxIndexJ = -1;

      changedConnection = false;
      for (int c0 = 0; c0 < gt0Clusters.size(); c0++) {
        for (int c1 = c0 + 1; c1 < gt0Clusters.size(); c1++) {
          if (c0 == c1)
            continue;
          double min = Math.min(gt0Clusters.get(c0).connections.get(c1), gt0Clusters.get(c1).connections.get(c0));
          if (min > max) {
            max = min;
            maxIndexI = c0;
            maxIndexJ = c1;
          }
        }
      }
      if (maxIndexI != -1 && max > tauConnection) {
        gt0Clusters.get(maxIndexI).mergeCluster(maxIndexJ);
        if (debug)
          System.out.println("Merging " + maxIndexI + " and " + maxIndexJ + " because of connection " + max);

        changedConnection = true;
      }
    }
    numGT0Classes = gt0Clusters.size();
  }

  /**
   * Calculates how well the original clusters are separable. Small values
   * indicate bad separability, values close to 1 indicate good separability
   * 
   * @return index of seperability
   */
  public double getClassSeparability() {
    // int totalConn = numGTClasses*(numGTClasses-1)/2;
    // int mergedConn = 0;
    // for(GTCluster gt : gt0Clusters){
    // int merged = gt.clusterRepresentations.size();
    // if(merged > 1)
    // mergedConn+=merged * (merged-1)/2;
    // }
    // if(totalConn == 0)
    // return 0;
    // else
    // return 1-mergedConn/(double)totalConn;
    return numGT0Classes / (double) numGTClasses;

  }

  /**
   * Calculates how well noise is separable from the given clusters Small values
   * indicate bad separability, values close to 1 indicate good separability
   * 
   * @return index of noise separability
   */
  public double getNoiseSeparability() {
    if (noise.isEmpty())
      return 1;

    double connectivity = 0;
    for (int p : noise) {
      CMMPoint npoint = cmmpoints.get(p);
      double maxConnection = 0;

      // TODO: some kind of pruning possible. what about weighting?
      for (int c = 0; c < gt0Clusters.size(); c++) {
        double connection = getConnectionValue(npoint, c);
        if (connection > maxConnection)
          maxConnection = connection;
      }
      connectivity += maxConnection;
      npoint.p.setMeasureValue("MaxConnection", maxConnection);
    }

    return 1 - (connectivity / noise.size());
  }

  /**
   * Calculates the relative number of errors being caused by the underlying
   * cluster model
   * 
   * @return quality of the model
   */
  public double getModelQuality() {
    for (int p = 0; p < numPoints; p++) {
      CMMPoint cmdp = cmmpoints.get(p);
      for (int hc = 0; hc < numGTClusters; hc++) {
        if (gtClustering.get(hc).getGroundTruth() != cmdp.trueClass) {
          if (gtClustering.get(hc).getInclusionProbability(cmdp) >= 1) {
            if (!cmdp.isNoise())
              pointErrorByModel++;
            else
              noiseErrorByModel++;
            break;
          }
        }
      }
    }
    if (debug)
      System.out.println("Error by model: noise " + noiseErrorByModel + " point " + pointErrorByModel);

    return 1 - ((pointErrorByModel + noiseErrorByModel) / (double) numPoints);
  }

  /**
   * Get CMM internal point
   * 
   * @param index
   *          of the point
   * @return cmm point
   */
  protected CMMPoint getPoint(int index) {
    return cmmpoints.get(index);
  }

  /**
   * Return cluster
   * 
   * @param index
   *          of the cluster to return
   * @return cluster
   */
  protected GTCluster getGT0Cluster(int index) {
    return gt0Clusters.get(index);
  }

  /**
   * Number of classes/clusters of the new clustering
   * 
   * @return number of new clusters
   */
  protected int getNumberOfGT0Classes() {
    return numGT0Classes;
  }

  /**
   * Calculates Euclidian distance
   * 
   * @param inst1
   *          point as double array
   * @param inst2
   *          point as double array
   * @return euclidian distance
   */
  private double distance(Instance inst1, Instance inst2) {
    return distance(inst1, inst2.toDoubleArray());

  }

  /**
   * Calculates Euclidian distance
   * 
   * @param inst1
   *          point as an instance
   * @param inst2
   *          point as double array
   * @return euclidian distance
   */
  private double distance(Instance inst1, double[] inst2) {
    double distance = 0.0;
    for (int i = 0; i < numDims; i++) {
      double d = inst1.value(i) - inst2[i];
      distance += d * d;
    }
    return Math.sqrt(distance);
  }

  /**
   * String with main CMM parameters
   * 
   * @return main CMM parameter
   */
  public String getParameterString() {
    String para = "";
    para += "k=" + knnNeighbourhood + ";";
    if (useExpConnectivity) {
      para += "lambdaConnX=" + lambdaConnX + ";";
      para += "lambdaConn=" + lamdaConn + ";";
      para += "lambdaConnRef=" + lambdaConnRefXValue + ";";
    }
    para += "m=" + clusterConnectionMaxPoints + ";";
    para += "tauConn=" + tauConnection + ";";

    return para;
  }
}