- Source
Methods
(inner) aggregateNestedDataLayers(layerData, resultKey, copyProperties, sumProperties, staticProperties) → {Array.<object>}
Combine the layers resulting from a d3.nest
operation into a single, aggregated layer.
This can be used to combine all sources of a single data type, for example to show all "power" sources as a single layer of chart data. The resulting object has the same structure as the input layerData
parameter, with just a single layer of data.
For example:
const layerData = [
{ key : 'A', values : [{watts : 123, foo : 1}, {watts : 234, foo : 2}] },
{ key : 'B', values : [{watts : 345, foo : 3}, {watts : 456, foo : 4}] }
];
const result = aggregateNestedDataLayers(layerData,
'A and B', ['foo'], ['watts'], {'combined' : true});
Then result
would look like this:
[
{ key : 'A and B', values : [{watts : 468, foo : 1, combined : true},
{watts : 690, foo : 2, combined : true}] }
]
Name | Type | Description | |||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
layerData | Array.<object> | An array of objects with Properties
| |||||||||
resultKey | string | The | |||||||||
copyProperties | Array.<string> | An array of string property names to copy as-is from the first layer's data values. | |||||||||
sumProperties | Array.<string> | An array of string property names to add together from all layer data. | |||||||||
staticProperties | object | Static properties to copy as-is to all output data values. |
- Source
An array of objects with key
and value
properties, the same structure as the provided layerData
argument
- Type:
- Array.<object>
(inner) groupedBySourceMetricDataArray(data, metricName, sourceIdMapopt, aggFnopt) → {Array.<object>}
Transform raw SolarNetwork timeseries data by combining datum from multiple sources into a single data per time key.
This method produces a single array of objects with metric properties derived by grouping that property within a single time slot across one or more source IDs. Conceptually this is similar to module:data~aggregateNestedDataLayers except groups of source IDs can be produced in the final result.
The data will be passed through module:data~normalizeNestedStackDataByDate so that every result object will contain every configured output group, but missing data will result in a null
value.
Here's an example where two sources A
and B
are combined into a single group Generation
and a third source C
is passed through as another group Consumption
:
const queryData = [
{localDate: '2018-05-05', localTime: '11:00', sourceId: 'A', watts : 123},
{localDate: '2018-05-05', localTime: '11:00', sourceId: 'B', watts : 234},
{localDate: '2018-05-05', localTime: '11:00', sourceId: 'C', watts : 345},
{localDate: '2018-05-05', localTime: '12:00', sourceId: 'A', watts : 456},
{localDate: '2018-05-05', localTime: '12:00', sourceId: 'B', watts : 567},
{localDate: '2018-05-05', localTime: '12:00', sourceId: 'C', watts : 678},
];
const sourceMap = new Map([
['A', 'Generation'],
['B', 'Generation'],
['C', 'Consumption'],
]);
const result = groupedBySourceMetricDataArray(queryData, 'watts', sourceMap);
Then result
would look like this:
[
{date : new Date('2018-05-05T11:00Z'), Generation : 357, Consumption: 345},
{date : new Date('2018-05-05T12:00Z'), Generation : 1023, Consumption: 678}
]
Name | Type | Attributes | Description |
---|---|---|---|
data | Array.<object> | the raw data returned from SolarNetwork | |
metricName | string | the datum property name to extract | |
sourceIdMap | Map | <optional> | an optional mapping of input source IDs to output source IDs; this can be used to control the grouping of data, by mapping multiple input source IDs to the same output source ID |
aggFn | function | <optional> | an optional aggregate function to apply to the metric values; defaults to |
- Source
array of datum objects, each with a date and one metric value per source ID
- Type:
- Array.<object>
(inner) normalizeNestedStackDataByDate(layerData, fillTemplateopt, fillFnopt) → {void}
Normalize the data arrays resulting from a d3.nest
operation so that all group value arrays have the same number of elements, based on a Date property named date
.
The data values are assumed to be sorted by date
already, and are modified in-place. This makes the data suitable to passing to d3.stack
, which expects all stack data arrays to have the same number of values, for the same keys. When querying for data in SolarNetwork there might be gaps in the results, so this function can be used to "fill in" those gaps with "dummy" values so that there are no more gaps.
Filled-in data objects are automatically populated with an appropriate date
property and a sourceId
property taken from the key
of the layer the gap if found in. You can pass a fillTemplate
object with static properties to also include on all filled-in data objects. You can also pass a fillFn
function to populate the filled-in objects with dynamic data.
For example, given:
const layerData = [
{ key : 'A', values : [{date : new Date('2011-12-02 12:00')}, {date : new Date('2011-12-02 12:10')}] },
{ key : 'B', values : [{date : new Date('2011-12-02 12:00')}] }
];
normalizeNestedStackDataByDate(layerData);
The layerData
would be modified in-place and look like this (notice the filled in second data value in the B group):
[
{ key : 'A', values : [{date : new Date('2011-12-02 12:00')}, {date : new Date('2011-12-02 12:10')}] },
{ key : 'B', values : [{date : new Date('2011-12-02 12:00')}, {date : new Date('2011-12-02 12:10'), sourceId : 'B'}] }
]
Name | Type | Attributes | Description | |||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
layerData | Array.<object> | An array of objects with Properties
| ||||||||||
fillTemplate | object | <optional> | An object to use as a template for any filled-in data objects. The | |||||||||
fillFn | module:data~NestedDataOperatorFunction | <optional> | An optional function to populate filled-in data objects with. This function is invoked after populating any |
- Source
- Type:
- void
(inner) timeNormalizeDataArray(data, aggregate) → {void}
Normalize a data array of time series data based on an aggregate time step.
This method is useful for "filling in" gaps of data in situations where something expects the data include placeholders for the gaps. Charting applications often expect this, for example.
Each element in the data
array is expected to provide a date
property that is a Date
object. When gaps are discovered in the array, "filler" objects will be inserted with an approprate date
value and all other properties copied from the previous element but set to null
.
Here's an example where a new element is added to an array to fill in a missing time slot:
const queryData = [
{date : new Date('2018-05-05T11:00Z'), Generation : 357, Consumption: 345},
{date : new Date('2018-05-05T12:00Z'), Generation : 1023, Consumption: 678}
]
timeNormalizeDataArray(queryData, Aggregations.ThirtyMinute);
Then queryData
would look like this:
[
{date : new Date('2018-05-05T11:00Z'), Generation : 357, Consumption: 345},
{date : new Date('2018-05-05T11:30Z'), Generation : null, Consumption: null},
{date : new Date('2018-05-05T12:00Z'), Generation : 1023, Consumption: 678}
]
Name | Type | Description |
---|---|---|
data | Array.<object> | the raw data returned from SolarNetwork; this array is modified in-place |
aggregate | module:domain~Aggregation | the expected aggregate level of the data |
- Source
- Type:
- void
Type Definitions
NestedDataOperatorFunction(datum, key, prevDatumopt) → {void}
A callback function that operates on a nested data layer datum object.
Name | Type | Attributes | Description |
---|---|---|---|
datum | object | the datum object being operated on | |
key | string | the layer key the datum object is a member of | |
prevDatum | object | <optional> | the previous datum object in the layer, if available |
- Source
- Type:
- void