From 81bb1cd9106db15b73313845ddfe5c2cb9571d8e Mon Sep 17 00:00:00 2001 From: Shurong Cao Date: Tue, 25 Aug 2026 03:22:56 +0800 Subject: [PATCH 1/2] fix(sankey): restore node.pad clamp warning broken by d3-sankey v0.12 The warning compared the layout getter sankey.nodePadding() against the configured node.pad. Since @plotly/d3-sankey 0.12.3 (#7830) that getter returns the *configured* value (the post-clamp padding lives in an internal variable), so the comparison never fired and users no longer learn their pad was reduced. Measure the smallest gap between consecutive nodes sharing a column instead: it reflects the effective padding and works for both @plotly/d3-sankey and @plotly/d3-sankey-circular. Fixes #7832 --- draftlogs/7986_fix.md | 1 + src/traces/sankey/render.js | 37 +++++++++++++++++- test/jasmine/tests/sankey_test.js | 65 +++++++++++++++++++++++++++++++ 3 files changed, 101 insertions(+), 2 deletions(-) create mode 100644 draftlogs/7986_fix.md diff --git a/draftlogs/7986_fix.md b/draftlogs/7986_fix.md new file mode 100644 index 00000000000..482e6eb38f0 --- /dev/null +++ b/draftlogs/7986_fix.md @@ -0,0 +1 @@ +- Fix the `node.pad` clamp warning in Sankey traces: it never fired after the `@plotly/d3-sankey` v0.12 upgrade because the layout getter now returns the configured padding rather than the effective (post-clamp) value; the warning now measures the laid-out node gaps and fires with the effective padding [[#7986](https://github.com/plotly/plotly.js/pull/7986)] diff --git a/src/traces/sankey/render.js b/src/traces/sankey/render.js index 83f8bbb2f98..093317e0bdc 100644 --- a/src/traces/sankey/render.js +++ b/src/traces/sankey/render.js @@ -90,8 +90,41 @@ function sankeyModel(layout, d, traceIndex) { var graph = sankey(); - if(sankey.nodePadding() < nodePad) { - Lib.warn('node.pad was reduced to ', sankey.nodePadding(), ' to fit within the figure.'); + /* + * Detect a clamped node.pad from the laid-out node positions rather than + * from `sankey.nodePadding()`: since @plotly/d3-sankey v0.12 the getter + * returns the *configured* value (the post-clamp padding is kept in an + * internal variable), so comparing against it never fires. Measuring the + * smallest gap between consecutive nodes sharing a column works for both + * @plotly/d3-sankey and @plotly/d3-sankey-circular. + */ + var effectiveNodePad = null; + if(graph.nodes.length > 1) { + var colAttr = horizontal ? 'x0' : 'y0'; + var posAttr = horizontal ? 'y0' : 'x0'; + var columns = {}; + graph.nodes.forEach(function(n) { + var ck = n[colAttr]; + if(!columns[ck]) columns[ck] = []; + columns[ck].push(n); + }); + Object.keys(columns).forEach(function(ck) { + var col = columns[ck].sort(function(a, b) { return a[posAttr] - b[posAttr]; }); + for(var i = 1; i < col.length; i++) { + var gap = col[i][posAttr] - col[i - 1][posAttr]; + if(effectiveNodePad === null || gap < effectiveNodePad) { + effectiveNodePad = gap; + } + } + }); + } + + if(effectiveNodePad !== null && effectiveNodePad < nodePad) { + Lib.warn( + 'node.pad was reduced to ', + Math.round(effectiveNodePad * 100) / 100, + ' to fit within the figure.' + ); } // Counters for nested loops diff --git a/test/jasmine/tests/sankey_test.js b/test/jasmine/tests/sankey_test.js index d82ecdf9296..dbce9eb7422 100644 --- a/test/jasmine/tests/sankey_test.js +++ b/test/jasmine/tests/sankey_test.js @@ -389,6 +389,71 @@ describe('sankey tests', function () { }); }); + describe('node.pad clamp warning (issue 7832)', function() { + var gd; + beforeEach(function() { + gd = createGraphDiv(); + }); + afterEach(destroyGraphDiv); + + function padWarnings() { + var warnings = []; + spyOn(Lib, 'warn').and.callFake(function(msg) { + warnings.push(msg); + }); + return warnings; + } + + it('fires when node.pad is clamped to fit the figure', function(done) { + var warnings = padWarnings(); + var labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']; + // 8 sibling nodes cannot fit in a ~300px-high domain with + // node.pad: 40 -> d3-sankey clamps the padding + Plotly.newPlot(gd, [{ + type: 'sankey', + domain: { x: [0, 1], y: [0, 0.5] }, + node: { + label: labels, + pad: 40, + thickness: 15 + }, + link: { + source: [0, 0, 0, 0, 0, 0, 0, 0], + target: [1, 2, 3, 4, 5, 6, 7, 8], + value: [1, 1, 1, 1, 1, 1, 1, 1] + } + }]) + .then(function() { + expect(warnings.length).toBe(1); + expect(warnings[0]).toContain('node.pad was reduced'); + }) + .then(done, done.fail); + }); + + it('does not fire when node.pad fits', function(done) { + var warnings = padWarnings(); + + Plotly.newPlot(gd, [{ + type: 'sankey', + domain: { x: [0, 1], y: [0, 1] }, + node: { + label: ['a', 'b', 'c', 'd'], + pad: 20, + thickness: 10 + }, + link: { + source: [0, 0, 0], + target: [1, 2, 3], + value: [1, 1, 1] + } + }]) + .then(function() { + expect(warnings.length).toBe(0); + }) + .then(done, done.fail); + }); + }); + describe('lifecycle methods', function () { var gd; beforeEach(function () { From d7504ababb3bfac08e609d2ed1932b3d0e8d3c16 Mon Sep 17 00:00:00 2001 From: Shurong Cao <170531907+CAOShurong@users.noreply.github.com> Date: Tue, 25 Aug 2026 08:32:38 +0800 Subject: [PATCH 2/2] docs(colorbar): document that log/date dtick string forms are not supported on color bars The colorbar tick axis is mocked with type 'linear' (mockColorBarAxis in src/components/colorbar/draw.js), and clean_ticks.dtick silently falls back to the default step for any non-numeric dtick on a linear axis. So the *L*, *D1*, *D2* (log) and *M* (date) special strings that the shared dtick description advertises have no effect on colorbar.dtick or coloraxis.colorbar.dtick - they even degrade to a 1-unit linear step, producing one garbage label per pixel of bar length (issue #7376). Give the colorbar dtick attribute its own accurate description: only positive numbers are honored. Regenerate test/plot-schema.json and the TS types accordingly. --- draftlogs/7991_fix.md | 1 + src/components/colorbar/attributes.js | 14 ++++- src/types/generated/schema.d.ts | 2 +- test/plot-schema.json | 74 +++++++++++++-------------- 4 files changed, 52 insertions(+), 39 deletions(-) create mode 100644 draftlogs/7991_fix.md diff --git a/draftlogs/7991_fix.md b/draftlogs/7991_fix.md new file mode 100644 index 00000000000..479b049062c --- /dev/null +++ b/draftlogs/7991_fix.md @@ -0,0 +1 @@ +- Correct the `colorbar.dtick` (and `coloraxis.colorbar.dtick`) description: the special *log*/*date* string forms (*L*, *D1*, *D2*, *M*) are not supported on color bars - the internal color-bar axis is always linear, so such strings are silently ignored. The attribute now documents that only positive numbers are honored [[#7376](https://github.com/plotly/plotly.js/issues/7376)] diff --git a/src/components/colorbar/attributes.js b/src/components/colorbar/attributes.js index 384701253a6..16e02597b63 100644 --- a/src/components/colorbar/attributes.js +++ b/src/components/colorbar/attributes.js @@ -153,10 +153,22 @@ module.exports = overrideAll( description: 'Sets the color of padded area.' }, // tick and title properties named and function exactly as in axes + // (except dtick: the colorbar axis is mocked as type *linear*, so the + // special *log*/*date* string forms documented on `dtick` - *L*, + // *D1*, *D2*, *M* - are silently discarded, see #7376) tickmode: axesAttrs.minor.tickmode, nticks: axesAttrs.nticks, tick0: axesAttrs.tick0, - dtick: axesAttrs.dtick, + dtick: extendFlat({}, axesAttrs.dtick, { + description: [ + 'Sets the step in-between ticks on this color bar. Use with `tick0`.', + 'Must be a positive number.', + 'Unlike on x/y axes, the special *log* and *date* string forms', + '(*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is', + 'always linear, so such strings are silently ignored and the step', + 'falls back to its default.' + ].join(' ') + }), tickvals: axesAttrs.tickvals, ticktext: axesAttrs.ticktext, ticks: extendFlat({}, axesAttrs.ticks, { dflt: '' }), diff --git a/src/types/generated/schema.d.ts b/src/types/generated/schema.d.ts index b01d6d9185c..7a3bbc2f6b9 100644 --- a/src/types/generated/schema.d.ts +++ b/src/types/generated/schema.d.ts @@ -239,7 +239,7 @@ export interface ColorBar { */ borderwidth?: number; /** - * Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48* + * Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default. * Setting this also sets: tickmode = "linear" */ dtick?: any; diff --git a/test/plot-schema.json b/test/plot-schema.json index 0412ea47de0..5637b71d56b 100644 --- a/test/plot-schema.json +++ b/test/plot-schema.json @@ -1220,7 +1220,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -16464,7 +16464,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -18223,7 +18223,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -22837,7 +22837,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -23983,7 +23983,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -25158,7 +25158,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -26357,7 +26357,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -28039,7 +28039,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -29207,7 +29207,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -30825,7 +30825,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -32981,7 +32981,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -35100,7 +35100,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -36465,7 +36465,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -37843,7 +37843,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -39956,7 +39956,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -42939,7 +42939,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear" @@ -44308,7 +44308,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -46609,7 +46609,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -47835,7 +47835,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -50292,7 +50292,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -53161,7 +53161,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -55556,7 +55556,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear" @@ -56251,7 +56251,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear" @@ -57873,7 +57873,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -59945,7 +59945,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear" @@ -62127,7 +62127,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear" @@ -64224,7 +64224,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear" @@ -65599,7 +65599,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -67649,7 +67649,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear" @@ -69648,7 +69648,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -71722,7 +71722,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -73747,7 +73747,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -75200,7 +75200,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -76966,7 +76966,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -78065,7 +78065,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear" @@ -80849,7 +80849,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" @@ -83544,7 +83544,7 @@ "valType": "number" }, "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", + "description": "Sets the step in-between ticks on this color bar. Use with `tick0`. Must be a positive number. Unlike on x/y axes, the special *log* and *date* string forms (*L*, *D1*, *D2*, *M*) are NOT supported here: this axis is always linear, so such strings are silently ignored and the step falls back to its default.", "editType": "calc", "impliedEdits": { "tickmode": "linear"