public async Task <IDictionary <string, double> > GetDimensionMetricsCountCoreAsync(string metricsName, TimeSpan backTime, string dimension)
{
IDictionary <string, double> result = new Dictionary <string, double>();
var connectionInfo = new ConnectionInfo(_certificate, _mdmEnvironment);
var metricReader = new MetricReader(connectionInfo);
var metricId = GenMetricId(metricsName);
var dimensionFilters = new List <DimensionFilter>
{
DimensionFilter.CreateIncludeFilter(dimension)
};
try
{
var now = DateTime.UtcNow;
var results = await metricReader.GetTimeSeriesAsync(
metricId,
dimensionFilters,
now - backTime,
now,
new[] { SamplingType.Count },
new SelectionClauseV3(new PropertyDefinition(PropertyAggregationType.Sum, SamplingType.Count), 100_000, OrderBy.Descending),
outputDimensionNames : new List <string> {
dimension
}
);
return(results.Results.ToDictionary(r => r.DimensionList.First().Value, r => r.EvaluatedResult));
}
catch (Exception ex)
{
Console.WriteLine("Failed to get metrics data from Geneva", ex);
return(null);
}
}
/// <summary>
/// Gets the known dimension combinations that match the query criteria. In this example, we are checking for available memory
/// on all our roles and datacenters.
/// </summary>
public static void GetFilteredDimensionValues()
{
// Replace 31280E2F2D2220808315C212DF8062A295B28325 with your cert thumbprint,
// install it to the "Personal\Certificates" folder in the "Local Computer" certificate store,
// and grant the permission of reading the private key to the service/application using the MDM consumption APIs.
string testCertificateThumbprint = "31280E2F2D2220808315C212DF8062A295B28325";
var connectionInfo = new ConnectionInfo(testCertificateThumbprint, StoreLocation.LocalMachine, MdmEnvironment.Int);
var reader = new MetricReader(connectionInfo);
var id = new MetricIdentifier("MetricTeamInternalMetrics", "PlatformMetrics", "\\Memory\\Available MBytes");
var dimensionFilters = new DimensionFilter[] { "__Role", "Datacenter" };
IEnumerable <IQueryResult> results = reader.GetFilteredDimensionValuesAsync(
id,
dimensionFilters,
DateTime.UtcNow.AddMinutes(-60),
DateTime.UtcNow,
SamplingType.Sum,
Reducer.Average,
new QueryFilter(Operator.GreaterThan, 5000),
false,
new SelectionClause(SelectionType.TopValues, 10, OrderBy.Descending)
).Result;
foreach (var series in results)
{
IEnumerable <string> dimensions = series.DimensionList.Select(x => string.Format("[{0}, {1}]", x.Key, x.Value));
Console.WriteLine("Dimensions: {0}, Evaluated Result: {1:N0}", string.Join(", ", dimensions), series.EvaluatedResult);
}
Console.WriteLine("############################ END OF GetFilteredDimensionValues ##############################");
}
/// <summary>
/// Gets the known dimension combinations that match the query criteria and the associated time series.
/// In this example, we are checking the sum and count for available memory on all our roles and datacenters.
/// </summary>
public static void GetFilteredDimensionValuesV3()
{
var connectionInfo = new ConnectionInfo(MdmEnvironment.Int);
var reader = new MetricReader(connectionInfo);
var id = new MetricIdentifier("MetricTeamInternalMetrics", "PlatformMetrics", "\\Memory\\Available MBytes");
var dimensionFilters = new DimensionFilter[] { "__Role", "Datacenter" };
IQueryResultListV3 results = reader.GetFilteredDimensionValuesAsyncV3(
id,
dimensionFilters,
DateTime.UtcNow.AddMinutes(-10),
DateTime.UtcNow,
new[] { SamplingType.Sum, SamplingType.Count },
new SelectionClauseV3(new PropertyDefinition(PropertyAggregationType.Average, SamplingType.Sum), 10, OrderBy.Descending)).Result;
foreach (var series in results.Results)
{
IEnumerable <string> dimensions = series.DimensionList.Select(x => string.Format("[{0}, {1}]", x.Key, x.Value));
var sumSeries = $"[{string.Join(",", series.GetTimeSeriesValues(SamplingType.Sum))}]";
var countSeries = $"[{string.Join(",", series.GetTimeSeriesValues(SamplingType.Count))}]";
Console.WriteLine("Dimensions: {0}, \n\tSum: {1}, \n\tCount: {2}.", string.Join(", ", dimensions), sumSeries, countSeries);
}
Console.WriteLine("############################ END OF GetFilteredDimensionValues ##############################");
}
public static List <LogicalModel.Dimension> ToLogicalDimensions(DimensionFilter item)
{
var toitem = new List <LogicalModel.Dimension>();
var dimensionitem = item.Dimension;
if (item is ExplicitDimensionFilter)
{
var citem = item as ExplicitDimensionFilter;
foreach (var member in citem.Members)
{
var dimension = new LogicalModel.Dimension();
dimension.DimensionItem = dimensionitem.QName.Content;
dimension.Domain = member.QName.Domain;
dimension.DomainMember = member.QName.Value;
toitem.Add(dimension);
}
}
if (item is TypedDimensionFilter)
{
var dimension = new LogicalModel.Dimension();
dimension.DimensionItem = dimensionitem.QName.Content;
dimension.IsTyped = true;
toitem.Add(dimension);
}
return(toitem);
}
public void Init(DimensionManager manager, DimensionFilter filter)
{
Manager = manager;
Filter = filter;
Text.text = filter.Attribute;
}
public void AddDimension()
{
string attribute = Dropdown.options[Dropdown.value].text;
DimensionFilter filter = Filters.Where(x => x.Attribute == attribute).FirstOrDefault();
Instantiate(DimensionObj, transform)?.Init(this, filter);
}
public static void CloudWatchMetricsTest()
{
var logGroupName = "LogGroupName";
DimensionFilter dimensionFilter = new DimensionFilter()
{
Name = logGroupName
};
var dimensionFilterList = new List <DimensionFilter>();
dimensionFilterList.Add(dimensionFilter);
var dimension = new Dimension
{
Name = "UniquePages",
Value = "URLs"
};
using (var cw = new AmazonCloudWatchClient(RegionEndpoint.USWest2))
{
var listMetricsResponse = cw.ListMetrics(new ListMetricsRequest
{
Dimensions = dimensionFilterList,
MetricName = "IncomingLogEvents",
Namespace = "AWS/Logs"
});
Console.WriteLine(listMetricsResponse.Metrics);
cw.PutMetricData(new PutMetricDataRequest
{
MetricData = new List <MetricDatum> {
new MetricDatum
{
MetricName = "PagesVisited",
Dimensions = new List <Dimension> {
dimension
},
Unit = "None",
Value = 1.0
}
},
Namespace = "SITE/TRAFFIC"
});
var describeMetricsResponse = cw.DescribeAlarmsForMetric(new DescribeAlarmsForMetricRequest
{
MetricName = "PagesVisited",
Dimensions = new List <Dimension>()
{
dimension
},
Namespace = "SITE/TRAFFIC"
});
Console.WriteLine(describeMetricsResponse.MetricAlarms);
}
}
/// <summary>
/// Enums the popup.
/// </summary>
/// <param name="label">Label.</param>
/// <param name="enumArray">Enum array.</param>
/// <param name="selected">Selected.</param>
private bool EnumPopup(string label, string[] enumArray, DimensionFilter selected)
{
string oldSelected = selected.Attribute;
if (enumArray.Length > 0)
{
selected.Attribute = enumArray[EditorGUILayout.Popup(label, enumIndexOf(enumArray, selected.Attribute), enumArray)];
}
return(selected.Attribute != oldSelected);
}
public static void CWListMetrics()
{
#region CWListMetrics
var client = new AmazonCloudWatchClient();
var filter = new DimensionFilter
{
Name = "InstanceType",
Value = "t1.micro"
};
var request = new ListMetricsRequest
{
Dimensions = new List <DimensionFilter>()
{
filter
},
MetricName = "CPUUtilization",
Namespace = "AWS/EC2"
};
var response = new ListMetricsResponse();
do
{
response = client.ListMetrics(request);
if (response.Metrics.Count > 0)
{
foreach (var metric in response.Metrics)
{
Console.WriteLine(metric.MetricName +
" (" + metric.Namespace + ")");
foreach (var dimension in metric.Dimensions)
{
Console.WriteLine(" " + dimension.Name + ": "
+ dimension.Value);
}
}
}
else
{
Console.WriteLine("No metrics found.");
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(response.NextToken));
#endregion
Console.ReadLine();
}
public void DeSerialize(string serializedObjectPath, CreationConfiguration cf)
{
SerializableCreationConfiguration scc = JsonUtility.FromJson <SerializableCreationConfiguration>(File.ReadAllText(serializedObjectPath));
cf.VisualisationType = (AbstractVisualisation.VisualisationTypes)System.Enum.Parse(typeof(AbstractVisualisation.VisualisationTypes), scc.VisualisationType);
//rebuild the parallel coordinates dimensions filtering
string[] attributesPCP = scc.parallelCoordinatesDimensionsAttributes;
float[] minFiltersPCP = scc.parallelCoordinatesDimensionsMinFilter;
float[] maxFiltersPCP = scc.parallelCoordinatesDimensionsMaxFilter;
float[] minScalesPCP = scc.parallelCoordinatesDimensionsMinScale;
float[] maxScalesPCP = scc.parallelCoordinatesDimensionsMaxScale;
DimensionFilter[] parallelCoordinatesDimensions = new DimensionFilter[attributesPCP.Length];
for (int i = 0; i < parallelCoordinatesDimensions.Length; i++)
{
DimensionFilter df = new DimensionFilter();
df.Attribute = attributesPCP[i];
df.minFilter = minFiltersPCP[i];
df.maxFilter = maxFiltersPCP[i];
df.minScale = minScalesPCP[i];
df.maxScale = maxScalesPCP[i];
parallelCoordinatesDimensions[i] = df;
}
cf.parallelCoordinatesDimensions = parallelCoordinatesDimensions;
cf.Geometry = scc.Geometry;
cf.Axies = new Dictionary <CreationConfiguration.Axis, string>();
for (int i = 0; i < scc.AxiesKeys.Length; i++)
{
if (!cf.Axies.ContainsKey(scc.AxiesKeys[i]))
{
cf.Axies.Add(scc.AxiesKeys[i], scc.AxiesValues[i]);
}
}
cf.ColourDimension = scc.ColourDimension;
cf.SizeDimension = scc.SizeDimension;
cf.LinkingDimension = scc.LinkingDimension;
cf.colourKeys = scc.colourKeys;
cf.colour = scc.colour;
cf.Size = scc.Size;
cf.MinSize = scc.MinSize;
cf.MaxSize = scc.MaxSize;
cf.VisualisationWidth = scc.VisualisationWidth;
cf.VisualisationHeight = scc.VisualisationHeight;
cf.VisualisationDepth = scc.VisualisationDepth;
}
public static async Task Main()
{
IAmazonCloudWatch cwClient = new AmazonCloudWatchClient();
var filter = new DimensionFilter
{
Name = "InstanceType",
Value = "t1.micro",
};
string metricName = "CPUUtilization";
string namespaceName = "AWS/EC2";
await ListMetricsAsync(cwClient, filter, metricName, namespaceName);
}
// ******************************************************
// COMMON METHODS THAT VISUALISATIONS USE
// ******************************************************
/// <summary>
/// Binds metadata to an axis component
/// </summary>
/// <param name="axis"></param>
/// <param name="dim"></param>
protected void BindMinMaxAxisValues(Axis axis, DimensionFilter dim)
{
object minvalue = visualisationReference.dataSource.getOriginalValue(dim.minFilter, dim.Attribute);
object maxvalue = visualisationReference.dataSource.getOriginalValue(dim.maxFilter, dim.Attribute);
object minScaledvalue = visualisationReference.dataSource.getOriginalValue(dim.minScale, dim.Attribute);
object maxScaledvalue = visualisationReference.dataSource.getOriginalValue(dim.maxScale, dim.Attribute);
axis.AttributeFilter = dim;
axis.UpdateLabelAttribute(dim.Attribute);
axis.SetMinNormalizer(dim.minScale);
axis.SetMaxNormalizer(dim.maxScale);
}
/// <summary>
/// Gets the known time series definitions.
/// </summary>
public static void GetKnownTimeSeriesDefinitions()
{
// Replace 31280E2F2D2220808315C212DF8062A295B28325 with your cert thumbprint,
// install it to the "Personal\Certificates" folder in the "Local Computer" certificate store,
// and grant the permission of reading the private key to the service/application using the MDM consumption APIs.
string testCertificateThumbprint = "31280E2F2D2220808315C212DF8062A295B28325";
var connectionInfo = new ConnectionInfo(testCertificateThumbprint, StoreLocation.LocalMachine, TimeSpan.FromSeconds(300), MdmEnvironment.Int);
var reader = new MetricReader(connectionInfo);
string monitoringAccount = "MetricTeamInternalMetrics";
IReadOnlyList <string> namespaces = reader.GetNamespacesAsync(monitoringAccount).Result;
string metricNamespace = "PlatformMetrics";
IReadOnlyList <string> metricNames = reader.GetMetricNamesAsync(monitoringAccount, metricNamespace).Result;
string metric = "\\Memory\\Available MBytes";
var id = new MetricIdentifier(monitoringAccount, metricNamespace, metric);
var dimensions = reader.GetDimensionNamesAsync(id).Result;
Console.WriteLine("Dimensions are: {0}", string.Join(", ", dimensions));
var preaggregates = reader.GetPreAggregateConfigurationsAsync(id).Result;
foreach (var preAggregateConfiguration in preaggregates)
{
Console.WriteLine("Pre-aggregate: {0}", JsonConvert.SerializeObject(preAggregateConfiguration));
}
var knownTimeSeriesDefinitions =
reader.GetKnownTimeSeriesDefinitionsAsync(id, "__Role", DimensionFilter.CreateExcludeFilter("Datacenter", "eastus2")).Result;
var roleIndex = knownTimeSeriesDefinitions.GetIndexInDimensionCombination("__Role");
Console.WriteLine("The index of the '__Role' dimension is {0}.", roleIndex);
foreach (var value in knownTimeSeriesDefinitions)
{
Console.WriteLine("Known time series definition: {0}", JsonConvert.SerializeObject(value.DimensionCombination));
}
Console.WriteLine("############################ END OF GetKnownTimeSeriesDefinitions ##############################");
}
private void Update()
{
if (Application.IsPlaying(gameObject))
{
Destroy(this);
}
if (partnerBlock)
{
GameObject partnerPartner = partnerBlock.GetComponent <EditorInfo>().partnerBlock;
if (!partnerPartner) //assign partners.
{
partnerPartner = gameObject;
}
DimensionFilter dimensionFilter = GetComponent <DimensionFilter>();
if (dimensionFilter)
{
if (dimensionFilter.dimension != lastDimension) //keep the partners in opposite dimensions
{
partnerBlock.GetComponent <DimensionFilter>().dimension = lastDimension;
}
lastDimension = dimensionFilter.dimension;
}
Vector2 pSize = partnerBlock.GetComponent <BoxCollider2D>().size;
Vector2 size = GetComponent <BoxCollider2D>().size;
Debug.Log($"Size: {size}\n" + $"pSize: {pSize}\n" +
$"LastSize: {lastSize}\n");
//Debug.Log($"pPos: {partnerBlock.transform.position}, " + $"Pos: {transform.position}\n"+
// $"LastPos: {lastPos}");
if (size != lastSize) // if my size changes, adjust the size of my partner
{
Debug.Log("size changed");
pSize = size;
}
if (transform.position != lastPos) // same for pos
{
Debug.Log("pos changed");
partnerBlock.transform.position = transform.position;
}
lastPos = transform.position;
lastSize = size;
}
}
/// <summary>
/// Retrieve CloudWatch metrics using the supplied filter, metrics name,
/// and namespace.
/// </summary>
/// <param name="client">An initialized CloudWatch client.</param>
/// <param name="filter">The filter to apply in retrieving metrics.</param>
/// <param name="metricName">The metric name for which to retrieve
/// information.</param>
/// <param name="nameSpaceName">The name of the namespace from which
/// to retrieve metric information.</param>
public static async Task ListMetricsAsync(
IAmazonCloudWatch client,
DimensionFilter filter,
string metricName,
string nameSpaceName)
{
var request = new ListMetricsRequest
{
Dimensions = new List <DimensionFilter>()
{
filter
},
MetricName = metricName,
Namespace = nameSpaceName,
};
var response = new ListMetricsResponse();
do
{
response = await client.ListMetricsAsync(request);
if (response.Metrics.Count > 0)
{
foreach (var metric in response.Metrics)
{
Console.WriteLine(metric.MetricName +
" (" + metric.Namespace + ")");
foreach (var dimension in metric.Dimensions)
{
Console.WriteLine(" " + dimension.Name + ": "
+ dimension.Value);
}
}
}
else
{
Console.WriteLine("No metrics found.");
}
request.NextToken = response.NextToken;
} while (!string.IsNullOrEmpty(response.NextToken));
}
protected GameObject CreateAxis(AbstractVisualisation.PropertyType propertyType, DimensionFilter dimensionFilter, Vector3 position, Vector3 rotation, int index, CSVDataSource csvds, Visualisation vis, GameObject go)
{
GameObject AxisHolder;
AxisHolder = (GameObject)Instantiate(Resources.Load("Axis"));
AxisHolder.transform.parent = go.transform;
AxisHolder.name = propertyType.ToString();
AxisHolder.transform.eulerAngles = (rotation);
AxisHolder.transform.localPosition = position;
Axis axis = AxisHolder.GetComponent <Axis>();
axis.SetDirection((int)propertyType);
axis.Init(csvds, dimensionFilter, vis);
BindMinMaxAxisValues(axis, dimensionFilter, vis);
return(AxisHolder);
}
static void OnSelectionChange()
{
if (Selection.gameObjects.Length > 0)
{
selection = Selection.gameObjects[0];
transform = selection.transform;
renderer = selection.GetComponent <SpriteRenderer>();
collider = selection.GetComponent <BoxCollider2D>();
selectionInfo = selection.GetComponent <EditorInfo>();
dfilter = selection.GetComponent <DimensionFilter>();
if (autoGetFromSelection)
{
GetFromSelection();
}
if (renderer)
{
lastSize = renderer.size;
lastPosition = transform.position;
}
}
}
internal PreaggregateFilters(
string monitoringAccount,
string metricNamespace,
string metricName,
IEnumerable <string> preaggregateDimensionNames,
IReadOnlyList <PreaggregateDimensionFilterValues> filterValues)
{
this.MonitoringAccount = monitoringAccount;
this.MetricNamespace = metricNamespace;
this.MetricName = metricName;
var preaggregateDimensionNamesSet = new SortedSet <string>(preaggregateDimensionNames, StringComparer.OrdinalIgnoreCase);
this.PreaggregateDimensionNames = preaggregateDimensionNamesSet;
this.FilterValues = filterValues;
var dimensionFilters = new List <DimensionFilter>(this.FilterValues.Count);
foreach (PreaggregateDimensionFilterValues filter in this.FilterValues)
{
dimensionFilters.Add(DimensionFilter.CreateIncludeFilter(filter.FilterDimensionName, filter.FilterValues));
}
this.DimensionFilters = dimensionFilters;
}
// PUBLIC
public void CreateVisualisation(AbstractVisualisation.VisualisationTypes visualizationType)
{
//destroy the previous visualisations
AbstractVisualisation[] previousVisualizations = GetComponentsInChildren<AbstractVisualisation>();
foreach (var item in previousVisualizations)
{
item.destroyView();
DestroyImmediate(item);
}
//destroy the previous axes
Axis[] previousAxes = GetComponentsInChildren<Axis>();
foreach (var item in previousAxes)
{
DestroyImmediate(item.gameObject);
}
//destroy previous key
if(key!=null)
DestroyImmediate(key.gameObject);
visualisationType = visualizationType;
switch (visualisationType)
{
case AbstractVisualisation.VisualisationTypes.SCATTERPLOT:
theVisualizationObject = gameObject.AddComponent<ScatterplotVisualisation>();// new Simple2D3DVisualisation();
theVisualizationObject.visualisationReference = this;
theVisualizationObject.CreateVisualisation();
break;
case AbstractVisualisation.VisualisationTypes.SCATTERPLOT_MATRIX:
int dimensionCount = dataSource.DimensionCount;
if (dimensionCount > MAX_INIT_SCATTERPLOTMATRIX) dimensionCount = MAX_INIT_SCATTERPLOTMATRIX;
xScatterplotMatrixDimensions = new DimensionFilter[dimensionCount];
yScatterplotMatrixDimensions = new DimensionFilter[dimensionCount];
for (int i = 0; i < dimensionCount; i++)
{
xScatterplotMatrixDimensions[i] = new DimensionFilter { Attribute = dataSource[i].Identifier };
yScatterplotMatrixDimensions[i] = new DimensionFilter { Attribute = dataSource[i].Identifier };
}
theVisualizationObject = gameObject.AddComponent<ScatterplotMatrixVisualisation>();// new Simple2D3DVisualisation();
theVisualizationObject.visualisationReference = this;
theVisualizationObject.CreateVisualisation();
break;
case AbstractVisualisation.VisualisationTypes.PARALLEL_COORDINATES:
parallelCoordinatesDimensions = new DimensionFilter[dataSource.DimensionCount];
for (int i = 0; i < dataSource.DimensionCount; i++)
{
parallelCoordinatesDimensions[i] = new DimensionFilter { Attribute = dataSource[i].Identifier };
}
theVisualizationObject = gameObject.AddComponent<ParallelCoordinatesVisualisation>();// new ParrallelCoordinates();
theVisualizationObject.visualisationReference = this;
theVisualizationObject.UpdateVisualisation(AbstractVisualisation.PropertyType.DimensionChange);
theVisualizationObject.CreateVisualisation();
break;
case AbstractVisualisation.VisualisationTypes.GRAPH_LAYOUT:
break;
default:
break;
}
theVisualizationObject.UpdateVisualisation(AbstractVisualisation.PropertyType.None);
RuntimeEditorLoadAndSaveConfiguration();
key = (GameObject)Instantiate(Resources.Load("Key"));
key.transform.parent = transform;
key.transform.localPosition = new Vector3(0.15f, 1.165f, 0f);
}
// a space time cube
View CreateBarchart(CSVDataSource csvds, GameObject go, int count)
{
// header
// Date,Time,Lat,Lon,Base
Gradient g = new Gradient();
GradientColorKey[] gck = new GradientColorKey[2];
gck[0] = new GradientColorKey(Color.blue, 0);
gck[1] = new GradientColorKey(Color.red, 1);
g.colorKeys = gck;
// create a view builder with the point topology
ViewBuilder vb = new ViewBuilder(MeshTopology.Points, "BarCharts-" + count).
initialiseDataView(csvds.DataCount).
setDataDimension(csvds["Country"].Data, ViewBuilder.VIEW_DIMENSION.X).
setDataDimension(csvds["Value"].Data, ViewBuilder.VIEW_DIMENSION.Y).
setDataDimension(csvds["Year"].Data, ViewBuilder.VIEW_DIMENSION.Z);
//setSize(csvds["Maximum"].Data).
// setSingleColor(Color.white);
//setColors(csvds["Time"].Data.Select(x => g.Evaluate(x)).ToArray());
// initialise the view builder wiith thhe number of data points and parent GameOBject
//Enumerable.Repeat(1f, dataSource[0].Data.Length).ToArray()
Material mt = IATKUtil.GetMaterialFromTopology(AbstractVisualisation.GeometryType.Bars);
mt.SetFloat("_MinSize", 0.01f);
mt.SetFloat("_MaxSize", 0.05f);
View v = vb.updateView().apply(go, mt);
Visualisation visualisation = new Visualisation();
visualisation.dataSource = csvds;
// Visualisation
Vector3 posx = Vector3.zero;
posx.y = -0.05f;
DimensionFilter xDimension = new DimensionFilter {
Attribute = "Country"
};
//xDimension.minFilter;
GameObject X_AXIS = CreateAxis(AbstractVisualisation.PropertyType.X, xDimension, posx, new Vector3(0f, 0f, 0f), 0, csvds, visualisation, go);
Vector3 posy = Vector3.zero;
posy.x = -0.05f;
DimensionFilter yDimension = new DimensionFilter {
Attribute = "Value"
};
GameObject Y_AXIS = CreateAxis(AbstractVisualisation.PropertyType.Y, yDimension, posy, new Vector3(0f, 0f, 0f), 1, csvds, visualisation, go);
Vector3 posz = Vector3.zero;
posz.y = -0.05f;
posz.x = -0.05f;
DimensionFilter zDimension = new DimensionFilter {
Attribute = "Year"
};
GameObject Z_AXIS = CreateAxis(AbstractVisualisation.PropertyType.Z, zDimension, posz, new Vector3(90f, 0f, 0f), 2, csvds, visualisation, go);
return(v);
}
