Identify Vulnerability

import { makeChoropleth, mergeDataToBoundaries } from "/helpers/atlasMap.ojs";

import { downloadCsvButton, downloadPngButton } from "/helpers/uiComponents.ojs";

import { atlasTable } from "/helpers/atlasTable.ojs";

import {
  adminLevelLabel,
  adminSelect,
  adminSelections,
  adminTranslations,
  countries,
  selectedAdmin0,
  selectedAdmin1,
  selectedAdmin2,
} from "/helpers/adminSelectors.ojs";

import { chartStyle, formatUSD, inputTemplate } from "/helpers/std.ojs";

import { createSqlBindings, sqlAdminAt, sqlAdminWhere } from "/helpers/sql.js";

OverviewVue d’ensemble

Climate change doesn’t affect everyone equally. Not all communities are affected by climate change in the same way. Even when people and their farming systems face similar hazards like droughts, floods, or heatwaves—their ability to cope and recover can vary widely. Some communities recover quickly. Others face long-term setbacks—lost income, worsened health, disrupted education.

To design smart, inclusive adaptation strategies, we need to understand not just where hazards occur, but who they affect, and why. We define vulnerability through three key dimensions: exposure, sensitivity, and adaptive capacity. This notebook helps you explore each of these dimensions clearly. Use these insights to guide smarter investments, policies, and support systems especially for the people and places that need them most.

Le changement climatique n’affecte pas tout le monde de la même manière. Toutes les communautés ne sont pas touchées par le changement climatique de la même façon. Même lorsque les personnes et leurs systèmes agricoles sont confrontés à des dangers similaires tels que les sécheresses, les inondations ou les vagues de chaleur, leur capacité à faire face et à se rétablir peut varier considérablement. Certaines communautés se rétablissent rapidement. D’autres font face à des revers à long terme : perte de revenus, détérioration de la santé, perturbation de l’éducation.

Pour concevoir des stratégies d’adaptation intelligentes et inclusives, nous devons comprendre non seulement où se produisent les dangers, mais aussi qui ils affectent et pourquoi. Nous définissons la vulnérabilité à travers trois dimensions clés : l’exposition, la sensibilité et la capacité d’adaptation. Ce carnet vous aide à explorer chacune de ces dimensions de manière claire. Utilisez ces informations pour orienter des investissements, des politiques et des systèmes de soutien plus intelligents, en particulier pour les personnes et les lieux qui en ont le plus besoin.

Where are investments needed?Où les investissements sont-ils nécessaires ?

This map combines all three dimensions — exposure, sensitivity, and adaptive capacity — into one vulnerability score. Use it to identify the most at-risk areas overall.

The score is deliberately not a hazard map. Two places can face the same drought and end up in very different positions: what separates them is how many people are exposed, how much they were already carrying, and what services they can reach when the season fails. A high score means those two sides have come apart — pressure has outrun the capacity to absorb it.

The three smaller maps are the inputs, shown alongside so a score can be explained rather than just ranked. An area can reach the same score by being heavily exposed with reasonable services, or barely exposed with almost none, and those two situations call for different responses.

Cette carte combine les trois dimensions — exposition, sensibilité et capacité d’adaptation — en un score de vulnérabilité. Utilisez-la pour identifier les territoires les plus à risque.

Ce score n’est délibérément pas une carte des aléas. Deux territoires peuvent subir la même sécheresse et se retrouver dans des situations très différentes : ce qui les distingue, c’est le nombre de personnes exposées, ce qu’elles supportaient déjà et les services qu’elles peuvent atteindre lorsque la saison échoue. Un score élevé signifie que ces deux versants se sont écartés — la pression a dépassé la capacité à l’absorber.

Les trois cartes plus petites sont les composantes, présentées à côté afin qu’un score puisse être expliqué et non seulement classé. Un territoire peut atteindre le même score en étant fortement exposé avec des services corrects, ou à peine exposé avec presque aucun : ces deux situations appellent des réponses différentes.

How to read the vulnerability scoreComment lire l’indice de vulnérabilité

Vulnerability — Not a measure of hazard, but of pressure set against capacity. It runs from 0 to 100 and rises as the services a place has fall behind the pressures it faces, following the method ND-GAIN uses:

vulnerability = 100 − (adaptive capacity − urgency + 1) × 50

Urgency — The pressure on a place: the value of production exposed to severe hazard, rural population density, education, and poverty, averaged together.

Adaptive capacity — What the place has to respond with: electricity, piped water, travel time to a market, mobile phone access, and freedom from conflict, averaged together.

Reading the four maps — The large map is the composite score. The three beside it are the inputs behind it. Adaptive capacity is drawn inverted, so on that map alone a high value is the good outcome.

Ranks are local to your selection — The exposure input is rescaled across the areas currently on screen, so scores and ranks compare areas within a selection. Changing the selection changes the comparison, not the conditions on the ground.

Vulnérabilité — Ce n’est pas une mesure de l’aléa, mais de la pression rapportée aux moyens disponibles. L’indice varie de 0 à 100 et augmente à mesure que les services dont dispose un territoire prennent du retard sur les pressions qu’il subit, selon la méthode employée par ND-GAIN :

vulnérabilité = 100 − (capacité d'adaptation − urgence + 1) × 50

Urgence — La pression subie : la valeur de production exposée à un aléa sévère, la densité de population rurale, l’éducation et la pauvreté, moyennées.

Capacité d’adaptation — Les moyens de réponse : électricité, eau courante, temps de trajet vers un marché, téléphone portable et absence de conflits, moyennés.

Lire les quatre cartes — La grande carte est l’indice composite. Les trois autres en sont les composantes. La capacité d’adaptation est représentée en sens inverse : sur cette carte seule, une valeur élevée est le bon résultat.

Les rangs dépendent de votre sélection — La composante d’exposition est remise à l’échelle sur les territoires actuellement affichés : les scores et les rangs comparent donc les territoires au sein d’une sélection. Changer la sélection change la comparaison, pas la réalité du terrain.

adminControls()

viewof compositeView = viewToggle(["map", "table"])

compositeFigure = compositeView === "map"
  ? renderCompositeMaps()
  : atlasTable(compositeLongData, { header: adminHeaders })

downloads(
  compositeView === "map" ? compositeFigure : null,
  compositeLongData,
  "composite_vulnerability"
)

renderCompositeInsight()

exposureIndex = {
  const bind = createSqlBindings();

  return await db.query(
    `
    WITH totals AS (
      SELECT admin0_name, admin1_name, admin2_name, SUM(value) AS total_exposure
      FROM exposure
      WHERE isfinite(value) AND ${adminWhere(bind)}
      GROUP BY admin0_name, admin1_name, admin2_name
    )
    SELECT *,
      (total_exposure - MIN(total_exposure) OVER ())
        / NULLIF(MAX(total_exposure) OVER () - MIN(total_exposure) OVER (), 0) AS exposure_norm
    FROM totals
    ORDER BY total_exposure DESC
  `,
    bind.params
  );
}

enablingIndex = {
  const bind = createSqlBindings();
  const rows = await db.query(`SELECT * FROM enabling WHERE ${adminWhere(bind)}`, bind.params);

  return rows.map((row) => ({ ...row, enabling_index: meanNorm(row) }));
}

// Sensitivity indicators joined to exposure, then averaged.
urgencyIndex = {
  const bind = createSqlBindings();
  const rows = await db.query(
    `SELECT * FROM urgency WHERE ${adminWhere(bind)}`,
    bind.params
  );
  const exposureByAdmin = new Map(
    exposureIndex.map((d) => [adminView.adminKey(d), d.exposure_norm])
  );

  return rows.map((row) => {
    const area = { ...row, exposure_norm: exposureByAdmin.get(adminView.adminKey(row)) ?? null };
    area.urgency_index = meanNorm(area);

    return area;
  });
}

// ND-GAIN style: enabling conditions set against urgency, on a 0-100 scale.
// Urgency and enabling cover the same areas, so urgency is the spine.
vulnerabilityIndex = {
  const enablingByAdmin = new Map(enablingIndex.map((d) => [adminView.adminKey(d), d]));

  const rows = urgencyIndex.map(({ urgency_index, ...area }) => {
    const enabling_index = enablingByAdmin.get(adminView.adminKey(area))?.enabling_index ?? null;
    const gap = enabling_index - urgency_index;

    return {
      admin0_name: area.admin0_name,
      admin1_name: area.admin1_name,
      admin2_name: area.admin2_name,
      enabling_index,
      urgency_index,
      gap,
      vulnerability: Number.isFinite(gap) ? 100 - (gap + 1) * 50 : null,
    };
  });

  for (const [field, rank] of [
    ["vulnerability", "vuln_rank"],
    ["urgency_index", "urgency_rank"],
    ["enabling_index", "enabling_rank"],
  ]) {
    [...rows].sort((a, b) => b[field] - a[field]).forEach((row, index) => (row[rank] = index + 1));
  }

  return rows.sort((a, b) => b.vulnerability - a.vulnerability);
}

COMPOSITE_COMPONENTS = [
  { key: "vulnerability", label: nbText.Composite.components.vulnerability },
  { key: "exposure", label: nbText.Composite.components.exposure },
  { key: "urgency", label: nbText.Composite.components.urgency },
  { key: "enabling", label: nbText.Composite.components.enabling, invert: true },
]

compositeRows = {
  const scoresByAdmin = new Map(vulnerabilityIndex.map((d) => [adminView.adminKey(d), d]));

  return exposureIndex.map((area) => {
    const scores = scoresByAdmin.get(adminView.adminKey(area));

    return {
      admin0_name: area.admin0_name,
      admin1_name: area.admin1_name,
      admin2_name: area.admin2_name,
      exposure: area.exposure_norm,
      urgency: scores?.urgency_index ?? null,
      enabling: scores?.enabling_index ?? null,
      // The map reads every component on the same 0-1 scale.
      vulnerability: scores ? scores.vulnerability / 100 : null,
    };
  });
}

renderCompositeMaps = () => {
  const gap = 12;
  const totalWidth = Math.min(width, 1200);
  const componentWidth = Math.floor(totalWidth / 3.2);
  const componentHeight = Math.floor((600 - gap * 2) / 3);
  const features = featuresFor(compositeRows);

  const componentMap = ({ key, label, invert }, mapWidth, mapHeight) =>
    makeChoropleth({
      features,
      width: mapWidth,
      height: mapHeight,
      fill: (d) => d.properties.data?.[key],
      color: {
        type: "linear",
        range: invert ? RAMP_BETTER : RAMP_WORSE,
        label,
      },
      channels: {
        ...areaChannel,
        score: {
          label: nbText.General.score,
          value: (d) => d.properties.data?.[key]?.toFixed(3) ?? nbText.General.noData,
        },
      },
      tooltip: { area: true, score: true },
      adminHighlight,
    });

  const [featured, ...secondary] = COMPOSITE_COMPONENTS;

  return htl.html`<div style="display:grid; grid-template-columns:2.2fr 1fr; gap:${gap}px;">
    <div>${componentMap(featured, totalWidth - componentWidth - gap, componentHeight * 3 + gap * 2 + 80)}</div>
    <div style="display:flex; flex-direction:column; gap:${gap}px;">
      ${secondary.map((component) => componentMap(component, componentWidth, componentHeight))}
    </div>
  </div>`;
}

// Long format so the table and the download carry every input, not just the score.
compositeLongData = {
  const groups = [
    ["exposure", exposureIndex, ["total_exposure"]],
    ["urgency", urgencyIndex, ["population_dens", "education", "poverty"]],
    [
      "adaptive_capacity",
      enablingIndex,
      ["pct_electric", "pct_piped_water", "min_to_cities", "conflict_density", "pct_cellphone"],
    ],
    ["vulnerability", vulnerabilityIndex, ["vulnerability", "urgency_index", "enabling_index"]],
  ].map(([group, rows, variables]) => [
    group,
    new Map(rows.map((d) => [adminView.adminKey(d), d])),
    variables,
  ]);

  return exposureIndex.flatMap((area) => {
    const key = adminView.adminKey(area);

    return groups.flatMap(([group, byArea, variables]) =>
      variables.map((variable) => ({
        admin0_name: area.admin0_name,
        admin1_name: area.admin1_name,
        admin2_name: area.admin2_name,
        group,
        variable,
        value: byArea.get(key)?.[variable] ?? null,
      }))
    );
  });
}

renderCompositeInsight = () => {
  const t = nbText.Composite.insight;
  const balance = (gap) =>
    gap < 0
      ? t.balance.deficit
      : gap < 0.15
      ? t.balance.thin
      : gap < 0.35
      ? t.balance.moderate
      : t.balance.strong;

  const hotspots = vulnerabilityIndex.slice(0, 6).map(
    (d) =>
      `- ${tmpl(t.region, {
        admin: d.admin2_name ?? d.admin1_name ?? d.admin0_name,
        urgency_rank: d.urgency_rank,
        enabling_rank: d.enabling_rank,
        num_regions: vulnerabilityIndex.length,
        gapDirection: d.gap < 0 ? t.direction.below : t.direction.above,
        structural_balance: balance(d.gap),
      })}`
  );

  return quickInsight(`${tmpl(t.intro, { parent: breadcrumb })}\n\n${hotspots.join("\n")}`);
}

Where are climate hazards affecting people and livelihoods?Où les dangers climatiques affectent-ils les personnes et les moyens de subsistance ?

This map shows the value of agricultural production that coincides with a severe climate hazard, in constant 2015 US dollars, across 43 crop and livestock commodities. The more production value sits in hazard-affected areas, the more exposed the area is.

Three hazards are combined into a single “any hazard” layer over the historical baseline:

• Drought — days of crop water stress (NDWS).
• Heat — days above 35 °C for crops (NTx35); heat-and-humidity stress for livestock (THI-max).
• Waterlogging — days of soil saturation (NDWL0).

Only the severe class of each hazard counts, and hazards are not broken out separately here. Pick a single commodity to see where its production is exposed, or use the table view for the full commodity-by-commodity breakdown; see Methods and Sources for the definitions.

Every percentage quoted below is a share of the exposed value, not of total production. This layer records only the value that coincides with a hazard, so it cannot say what fraction of an area’s output is at risk.

Cette carte montre la valeur de la production agricole qui coïncide avec un aléa climatique sévère, en dollars US constants de 2015, pour 43 produits végétaux et animaux. Plus la valeur de production située en zone affectée est élevée, plus le territoire est exposé.

Trois aléas sont combinés en un seul « aléa quelconque » sur la période de référence historique :

• Sécheresse — jours de stress hydrique des cultures (NDWS).
• Chaleur — jours au-dessus de 35 °C pour les cultures (NTx35) ; stress thermique lié à l’humidité pour l’élevage (THI-max).
• Engorgement des sols — jours de saturation du sol (NDWL0).

Seule la classe sévère de chaque aléa est retenue, et les aléas ne sont pas présentés séparément ici. Choisissez un produit pour voir où sa production est exposée, ou passez à la vue tableau pour le détail complet par produit ; voir Méthodes et sources pour les définitions.

Tous les pourcentages cités ci-dessous sont des parts de la valeur exposée, et non de la production totale. Cette couche ne recense que la valeur coïncidant avec un aléa : elle ne peut donc pas indiquer quelle fraction de la production d’un territoire est à risque.

How to read exposed valueComment lire la valeur exposée

Value of production (VoP) — What a year’s output of a commodity is worth, in constant 2015 US dollars. It values production, not land: a small area of coffee can carry more value than a large area of grazing.

Exposed — The production value that sits where a severe hazard occurs over the historical baseline. It does not mean the production was lost, and it does not mean the hazard struck every year.

Severe — Only the severe class of each hazard counts here. A milder season that still hurt a harvest is not in these numbers.

Grey areas — No value-of-production data for that area, which is not the same as no exposure. An area with no crops or livestock recorded is grey rather than zero.

Commodity view — Selecting one commodity narrows every number on the page to that commodity, including the download. Areas with no recorded production of it turn grey.

Valeur de production (VoP) — Ce que vaut la production annuelle d’un produit, en dollars US constants de 2015. Elle valorise la production et non la surface : une petite parcelle de café peut porter plus de valeur qu’un vaste pâturage.

Exposée — La valeur de production située là où survient un aléa sévère sur la période de référence historique. Cela ne signifie pas que la production a été perdue, ni que l’aléa s’est produit chaque année.

Sévère — Seule la classe sévère de chaque aléa est retenue ici. Une saison plus clémente ayant néanmoins abîmé une récolte n’entre pas dans ces chiffres.

Zones grises — Absence de données de valeur de production pour ce territoire, ce qui n’équivaut pas à une absence d’exposition. Un territoire sans culture ni élevage recensé apparaît en gris et non comme un zéro.

Vue par produit — Sélectionner un produit restreint tous les chiffres de la page à ce produit, téléchargement compris. Les territoires sans production recensée de ce produit passent au gris.

adminControls()

viewof exposureView = viewToggle(["map", "table"])

viewof exposureCrop = Inputs.select([ALL_COMMODITIES, ...exposureCrops], {
  label: nbText.Exposure.commodity,
  value: ALL_COMMODITIES,
  format: cropLabel,
})

exposureFigure = exposureView === "map" ? renderExposureMap() : renderExposureTable()

// The commodity belongs in the name, or every crop downloads over the last one.
downloads(
  exposureView === "map" ? exposureFigure : null,
  exposureData,
  exposureCrop === ALL_COMMODITIES ? "exposure_any_hazard" : `exposure_${exposureCrop}`
)

renderExposureInsight()

ALL_COMMODITIES = "all"

exposureCrops = (await db.query(`SELECT DISTINCT crop FROM exposure ORDER BY crop`)).map(
  (d) => d.crop
)

// Slugs read "arabica-coffee"; sentence case matches how ROI labels the same
// commodities. //TODO: translate the names — ROI carries the same TODO.
cropLabel = (crop) =>
  crop === ALL_COMMODITIES
    ? nbText.Exposure.allCommodities
    : Lang.toSentenceCase(crop.replaceAll("-", " "))

exposureData = {
  const bind = createSqlBindings();
  const admin = adminWhere(bind);
  const crop =
    exposureCrop === ALL_COMMODITIES ? "" : ` AND crop = ${bind.value(exposureCrop)}`;

  // Six of the table's seventeen columns are read; the rest are either constant
  // for every row (scenario, severity, units) or codes nothing here joins on.
  //
  // Nearly half the rows are NaN; without this an area with no finite row for
  // the chosen commodity sums to zero and reads as low exposure, not no data.
  return await db.query(
    `SELECT admin0_name, admin1_name, admin2_name, value, crop, hazard_vars
     FROM exposure
     WHERE hazard = 'any' AND isfinite(value) AND ${admin}${crop}`,
    bind.params
  );
}

// The map needs one number per area; the table keeps the commodity detail.
exposureTotals = Array.from(
  d3.group(exposureData, (d) => adminView.adminKey(d)),
  ([, rows]) => ({
    admin0_name: rows[0].admin0_name,
    admin1_name: rows[0].admin1_name,
    admin2_name: rows[0].admin2_name,
    total_value: d3.sum(rows, (d) => d.value),
  })
)

exposureAreaTotal = {
  const bind = createSqlBindings();
  const rows = await db.query(
    `SELECT SUM(value) AS total FROM exposure
     WHERE hazard = 'any' AND isfinite(value) AND ${adminWhere(bind)}`,
    bind.params
  );

  return rows[0]?.total ?? 0;
}

// The parent area's commodity mix, to say what this area leans on more than the
// area above it. Only defined once a region is picked: above that there is no
// parent row to read, since this table carries no whole-area aggregate.
exposureParentMix = {
  if (!selectedAdmin1.length) return null;

  const bind = createSqlBindings();

  return await db.query(
    `SELECT crop, SUM(value) AS value FROM exposure
     WHERE hazard = 'any' AND isfinite(value) AND ${adminWhereParent(bind)}
     GROUP BY crop`,
    bind.params
  );
}

renderExposureMap = () =>
  makeChoropleth({
    features: featuresFor(exposureTotals),
    width: Math.min(width, 625),
    height: 600,
    caption: nbText.Exposure.caption,
    fill: (d) => d.properties.data?.total_value,
    color: {
      type: "linear",
      range: RAMP_BETTER,
      unknown: "#f0f0f0",
      label: nbText.Exposure.legend,
      tickFormat: usd,
    },
    channels: {
      ...areaChannel,
      vop: {
        label: nbText.Exposure.vop,
        value: (d) =>
          d.properties.data ? usd(d.properties.data.total_value) : nbText.General.noData,
      },
    },
    tooltip: { area: true, vop: true },
    adminHighlight,
  })

renderExposureTable = () =>
  atlasTable(exposureData, {
    columns: ["admin0_name", "admin1_name", "admin2_name", "value", "hazard_vars", "crop"],
    header: { ...adminHeaders, ...nbText.Exposure.table },
  })

renderExposureInsight = () => {
  const t = nbText.Exposure.insight;
  // Shares of exposed value, not of production: this table holds no unexposed
  // baseline, so a percentage of total output cannot be stated here.
  const share = (value) => (value >= 1 ? value.toFixed(0) : value.toFixed(1));
  const byCrop = d3
    .rollups(
      exposureData,
      (rows) => d3.sum(rows, (d) => d.value),
      (d) => d.crop
    )
    .sort(([, a], [, b]) => b - a);
  const total = d3.sum(byCrop, ([, value]) => value);

  if (!total) return quickInsight(tmpl(t.noData, { region: breadcrumb }));

  if (exposureCrop !== ALL_COMMODITIES) {
    const areas = exposureTotals
      .filter((d) => d.total_value > 0)
      .sort((a, b) => b.total_value - a.total_value)
      .slice(0, 3)
      .map((d) => d.admin2_name ?? d.admin1_name ?? d.admin0_name);

    return quickInsight(
      tmpl(t.commodity, {
        region: breadcrumb,
        commodity: cropLabel(exposureCrop),
        amount: usd(total),
        share_pct: share((100 * total) / exposureAreaTotal),
        areas: areas.join(", "),
      })
    );
  }

  const leading = byCrop.slice(0, 3);
  const livestock = exposureData.filter((d) => d.hazard_vars.includes("THI-max"));

  const lines = [
    tmpl(t.total, {
      region: breadcrumb,
      amount: usd(total),
      top_pct: share((100 * d3.sum(leading, ([, value]) => value)) / total),
      commodities: leading.map(([crop]) => cropLabel(crop)).join(", "),
    }),
    tmpl(t.livestock, {
      livestock_pct: share((100 * d3.sum(livestock, (d) => d.value)) / total),
    }),
  ];

  // What the area leans on more than the area containing it.
  const standout = exposureParentMix?.length && mostConcentrated(byCrop, total);

  if (standout) {
    lines.push(
      tmpl(t.concentration, {
        parent: parentName,
        commodity: cropLabel(standout.crop),
        here_pct: share(100 * standout.here),
        there_pct: share(100 * standout.there),
      })
    );
  }

  return quickInsight(lines.join("\n\n"));
}

// The commodity carrying a much larger share here than in the parent area.
// Ranked by how many points of share it adds rather than by ratio: a commodity
// at 6% against 1% beats one at 17% against 4% on ratio alone, but says less.
// Half a per cent of the parent is noise, and a 1.5x lead is worth a sentence.
mostConcentrated = (byCrop, total) => {
  const parentTotal = d3.sum(exposureParentMix, (d) => d.value);
  const parentShare = new Map(exposureParentMix.map((d) => [d.crop, d.value / parentTotal]));

  const [leader] = byCrop
    .map(([crop, value]) => ({ crop, here: value / total, there: parentShare.get(crop) ?? 0 }))
    .filter((d) => d.here >= 0.05 && d.there >= 0.005 && d.here > d.there * 1.5)
    .sort((a, b) => b.here - b.there - (a.here - a.there));

  return leader ?? null;
}

Who is most at risk?Qui est le plus à risque ?

Exposure to climate risks does not affect everyone equally. Larger structural inequalities decide who absorbs a shock and who is set back by it, raising the risk of harm and making recovery much harder.

This section describes who lives in the rural areas of your selection, broken down by gender, then poverty, then education — three of the things that most shape whether a household can weather a bad season. Read together with the exposure map, it separates two very different situations that a single vulnerability score cannot: production at risk in a place with the means to recover, and the same value at risk where most people have neither savings nor schooling to fall back on.

L’exposition aux risques climatiques n’affecte pas tout le monde de la même manière. De plus grandes inégalités structurelles déterminent qui absorbe un choc et qui en sort durablement affaibli, augmentant le risque de préjudice et rendant le rétablissement beaucoup plus difficile.

Cette section décrit qui vit dans les zones rurales du territoire sélectionné, ventilé par genre, puis par pauvreté, puis par éducation — trois des facteurs qui déterminent le plus la capacité d’un ménage à traverser une mauvaise saison. Lue avec la carte d’exposition, elle distingue deux situations très différentes qu’un score de vulnérabilité unique ne peut séparer : une production à risque dans un territoire ayant les moyens de se relever, et la même valeur à risque là où la plupart des personnes n’ont ni épargne ni scolarisation sur lesquelles s’appuyer.

How to read the icicle plotComment lire le graphique en cascade

Reading order — Top to bottom: gender, then poverty, then education. Each band is a share of the band directly above it, and the whole plot sums to the rural population of the selected area. Hovering traces a branch; clicking pins it until you click again.

Poverty classes — Cut from the modelled share of people living below the $2.15 a day line: low where fewer than 30% of the local population falls below it, moderate from 30 to 60%, high above 60%. This is a different line from the one behind the composite index.

Education classes — The modelled share of adults aged 15 to 49 with no schooling, with primary, and with secondary education. Those rates are applied to the whole rural population, so read the bands as shares at adult attainment rates rather than as counts of adults. The three shares are rescaled to sum to one before being applied to population counts, so modelling error cannot inflate or shrink an area’s population.

No data is a class, not a gap — Where a surface is missing for one gender, those people appear in that gender’s no-data band rather than being dropped, so the shares still add up.

Modelled, not measured — Population, poverty and education all come from modelled surfaces rather than from censuses or surveys reported at this level. The shares are spatial estimates with real error attached: they are reliable about the pattern, much less so about any single figure.

Ordre de lecture — De haut en bas : genre, puis pauvreté, puis éducation. Chaque bande est une part de la bande située juste au-dessus, et l’ensemble du graphique correspond à la population rurale du territoire sélectionné. Le survol trace une branche ; un clic la fige jusqu’au clic suivant.

Classes de pauvreté — Découpées à partir de la part modélisée de personnes vivant sous le seuil de 2,15 $ par jour : faible lorsque moins de 30 % de la population locale se situe sous ce seuil, modérée de 30 à 60 %, forte au-delà de 60 %. Ce seuil diffère de celui retenu pour l’indice composite.

Classes d’éducation — La part modélisée d’adultes de 15 à 49 ans sans scolarisation, avec une scolarisation primaire et avec une scolarisation secondaire. Ces taux sont appliqués à l’ensemble de la population rurale : les bandes se lisent donc comme des parts aux taux de scolarisation des adultes, et non comme des effectifs d’adultes. Les trois parts sont remises à l’échelle pour sommer à un avant d’être appliquées aux effectifs de population, afin que l’erreur de modélisation ne gonfle ni ne réduise la population d’un territoire.

L’absence de données est une classe, non un trou — Lorsqu’une surface manque pour un genre, ces personnes figurent dans la bande « pas de données » de ce genre plutôt que d’être écartées : les parts continuent donc de s’additionner.

Modélisé, et non mesuré — La population, la pauvreté et l’éducation proviennent toutes de surfaces modélisées et non de recensements ou d’enquêtes publiés à ce niveau. Les parts sont des estimations spatiales assorties d’une réelle marge d’erreur : fiables quant à la tendance, beaucoup moins quant à un chiffre isolé.

adminControls()

viewof sensitivityView = viewToggle(["plot", "table"])

sensitivityFigure = sensitivityView === "plot" ? renderIcicle() : renderSensitivityTable()

downloads(sensitivityView === "plot" ? sensitivityFigure : null, icicleTable, "sensitivity")

renderSensitivityInsight()

icicleRows = {
  const bind = createSqlBindings();
  const where = selectedAdmin0.length ? adminWhereExact(bind) : adminWhere(bind);

  return await db.query(
    `SELECT path, SUM(value) AS value FROM icicle WHERE ${where} GROUP BY path`,
    bind.params
  );
}

// Paths read `population_gender0_poverty1_education1`; the shared root is dropped.
icicleHierarchy = {
  const root = { name: "root", children: [] };

  for (const { path, value } of icicleRows) {
    let node = root;

    for (const name of path.split("_").slice(1)) {
      node.children ??= [];
      let child = node.children.find((candidate) => candidate.name === name);
      if (!child) node.children.push((child = { name }));
      node = child;
    }

    node.value = value;
  }

  return root;
}

// Labels are nested by dimension for the insight and flattened for the plot.
icicleLabels = Object.assign({}, ...Object.values(nbText.Sensitivity.keys))

// Poverty and education share one ramp: yellow better, red worse, grey no data.
ICICLE_COLORS = ({
  gender0: "#5b4b9c",
  gender1: "#0f7b8a",
  poverty1: "#f4bb21",
  poverty2: "#fc8a34",
  poverty3: "#ec5a47",
  povertyNA: "#a4a4a4",
  education3: "#f4bb21",
  education2: "#fc8a34",
  education1: "#ec5a47",
  educationNA: "#a4a4a4",
})

icicleColor = (name) => ICICLE_COLORS[name]

// Worst outcome first, no-data last. Gender is left in data order.
ICICLE_ORDER = ({
  poverty3: 0,
  poverty2: 1,
  poverty1: 2,
  povertyNA: 3,
  education1: 0,
  education2: 1,
  education3: 2,
  educationNA: 3,
})

// Keyed by segment, not by hex, so recolouring above needs no edit here.
ICICLE_DARK_TEXT = new Set([
  "gender0",
  "gender1",
  "poverty2",
  "poverty3",
  "education1",
  "education2",
])

icicleTextColor = (name) => (ICICLE_DARK_TEXT.has(name) ? "white" : "black")

icicleTable = {
  const root = d3.hierarchy(icicleHierarchy).sum((d) => d.value ?? 0);
  const levels = Object.keys(nbText.Sensitivity.keys);

  return root
    .descendants()
    .slice(1)
    .map((node) => {
      const path = node.ancestors().reverse().slice(1);

      return Object.fromEntries([
        ...levels.map((level, depth) => [
          level,
          path[depth] ? icicleLabels[path[depth].data.name] : null,
        ]),
        ["pct_total", (100 * node.value) / root.value],
        ["pct_of_gender", (100 * node.value) / node.ancestors().at(-2).value],
      ]);
    });
}

renderSensitivityTable = () =>
  atlasTable(icicleTable, {
    header: { ...nbText.Sensitivity.layers, ...nbText.Sensitivity.table },
  })

renderIcicle = () => {
  const height = 425;
  const breadcrumbHeight = 40;
  const breadcrumbWidth = 275;
  const legendHeight = 30;
  const gutter = 80;

  const root = d3.partition().padding(1).size([width, height])(
    d3
      .hierarchy(icicleHierarchy)
      .sum((d) => d.value ?? 0)
      .sort((a, b) => (ICICLE_ORDER[a.data.name] ?? 999) - (ICICLE_ORDER[b.data.name] ?? 999))
  );

  const svg = d3
    .create("svg")
    .attr("viewBox", `0 0 ${width + gutter} ${breadcrumbHeight + legendHeight + height}`)
    .style("font", "12px sans-serif");

  const crumbs = svg.append("g").attr("transform", "translate(10, 0)");
  const legend = svg
    .append("g")
    .attr("transform", `translate(${gutter}, ${breadcrumbHeight + 20})`);
  const plot = svg.append("g").attr("transform", `translate(${gutter}, 0)`);

  // Breadcrumb: one arrow per ancestor of the hovered or frozen segment.
  const arrow = breadcrumbHeight * 0.3;
  const arrowPoints = (_, index) =>
    [
      "0,0",
      `${breadcrumbWidth},0`,
      `${breadcrumbWidth + arrow},${breadcrumbHeight / 2}`,
      `${breadcrumbWidth},${breadcrumbHeight}`,
      `0,${breadcrumbHeight}`,
      ...(index > 0 ? [`${arrow},${breadcrumbHeight / 2}`] : []),
    ].join(" ");

  const drawCrumbs = (sequence) => {
    crumbs
      .selectAll("g")
      .data(sequence)
      .join((enter) => {
        const group = enter.append("g");
        group.append("polygon").attr("stroke", "white");
        group
          .append("text")
          .attr("text-anchor", "middle")
          .attr("font-size", "19px")
          .attr("dy", "0.35em")
          .attr("x", breadcrumbWidth / 2)
          .attr("y", breadcrumbHeight / 2);
        return group;
      })
      .attr("transform", (_, index) => `translate(${index * breadcrumbWidth}, 0)`)
      .call((group) =>
        group
          .select("polygon")
          .attr("points", arrowPoints)
          .attr("fill", (d) => icicleColor(d.data.name))
      )
      .call((group) =>
        group
          .select("text")
          .attr("fill", (d) => icicleTextColor(d.data.name))
          .text((d) => icicleLabels[d.data.name] ?? d.data.name)
      );

    // The share only means something once a branch is picked.
    crumbs
      .selectAll("text.percentage")
      .data(sequence.length > 1 ? [sequence.at(-1)] : [])
      .join("text")
      .attr("class", "percentage")
      .attr("x", (sequence.length + 0.1) * breadcrumbWidth)
      .attr("y", breadcrumbHeight / 2)
      .attr("dy", "0.35em")
      .attr("font-size", "19px")
      .text((d) => `${((100 * d.value) / root.value).toPrecision(3)}%`);
  };

  // The bands are the poverty ramp, so the swatches read from it rather than
  // repeating the hex codes.
  const legendItems = d3.zip(
    Object.values(nbText.Sensitivity.legend),
    ["poverty1", "poverty2", "poverty3", "povertyNA"].map(icicleColor)
  );

  legend
    .selectAll("g")
    .data(legendItems)
    .join("g")
    .attr("transform", (_, index) => `translate(${index * 170}, 0)`)
    .call((group) =>
      group
        .append("rect")
        .attr("width", 18)
        .attr("height", 18)
        .attr("fill", ([, color]) => color)
    )
    .call((group) =>
      group
        .append("text")
        .attr("x", 24)
        .attr("y", 9)
        .attr("dy", ".35em")
        .text(([label]) => label)
    );

  const nodes = root.descendants().slice(1);

  const segments = plot
    .selectAll("rect")
    .data(nodes)
    .join("rect")
    .attr("fill", (d) => icicleColor(d.data.name))
    .attr("x", (d) => d.x0)
    .attr("y", (d) => d.y0)
    .attr("width", (d) => d.x1 - d.x0)
    .attr("height", (d) => d.y1 - d.y0);

  // One label per depth, centred on the first segment at that depth.
  plot
    .selectAll("text.layer")
    .data(
      d3
        .rollups(
          nodes,
          (group) => group[0],
          (d) => d.depth
        )
        .sort(([a], [b]) => a - b)
    )
    .join("text")
    .attr("class", "layer")
    .attr("x", -12)
    .attr("y", ([, node]) => (node.y0 + node.y1) / 2)
    .attr("dy", "0.35em")
    .attr("text-anchor", "end")
    .attr("font-weight", "600")
    .text(([depth]) => Object.values(nbText.Sensitivity.layers)[depth - 1]);

  plot
    .selectAll("text.percentage")
    .data(nodes)
    .join("text")
    .attr("class", "percentage")
    .attr("x", (d) => (d.x0 + d.x1) / 2)
    .attr("y", (d) => (d.y0 + d.y1) / 2)
    .attr("dy", "0.35em")
    .attr("text-anchor", "middle")
    .attr("font-weight", "bold")
    .attr("fill", (d) => icicleTextColor(d.data.name))
    .attr("pointer-events", "none")
    .text((d) => {
      if (d.x1 - d.x0 <= 30 || d.y1 - d.y0 <= 15) return "";
      const gender = d.data.name.startsWith("gender") ? `${icicleLabels[d.data.name]} - ` : "";
      return `${gender}${((100 * d.value) / root.value).toFixed(1)}%`;
    });

  // Hover previews a branch; clicking pins it until the next click.
  let frozen = null;

  const highlight = (sequence) => {
    segments.attr("fill-opacity", (node) =>
      sequence.length === 0 || sequence.includes(node) ? 1 : 0.3
    );
    drawCrumbs(sequence);
  };

  segments
    .on("mouseenter", (event, d) => frozen || highlight(d.ancestors().reverse().slice(1)))
    .on("click", (event, d) => {
      event.stopPropagation();
      frozen = frozen ? null : d.ancestors().reverse().slice(1);
      highlight(frozen ?? []);
    });

  svg.on("mouseleave", () => frozen || highlight([]));
  svg.on("click", () => {
    if (!frozen) return;
    frozen = null;
    highlight([]);
  });

  return svg.node();
}

renderSensitivityInsight = () => {
  const t = nbText.Sensitivity.insight;
  const keys = nbText.Sensitivity.keys;
  const [male, female] = [keys.gender.gender0, keys.gender.gender1];
  const pct = (value) => (value >= 1 ? value.toFixed(0) : value.toFixed(1));
  // Only the deepest rows, or the poverty and gender levels above them would be
  // counted twice.
  const leaves = icicleTable.filter((d) => d.education !== null);
  // Share *of that gender*, not of everyone: pct_total would halve the figure.
  const ofGender = (gender, education) =>
    d3.sum(
      leaves.filter((d) => d.gender === gender && d.education === education),
      (d) => d.pct_of_gender
    );

  const noSchool = { [male]: ofGender(male, keys.education.education1), [female]: ofGender(female, keys.education.education1) };
  const secondary = { [male]: ofGender(male, keys.education.education3), [female]: ofGender(female, keys.education.education3) };

  const lines = [
    tmpl(t.education, {
      region: breadcrumb,
      femaleNoSchool: pct(noSchool[female]),
      maleNoSchool: pct(noSchool[male]),
      gap: pct(Math.abs(noSchool[female] - noSchool[male])),
    }),
    tmpl(t.secondary, {
      femaleSecondary: pct(secondary[female]),
      maleSecondary: pct(secondary[male]),
    }),
  ];

  // Empty in two countries out of five, so it is stated only where it exists.
  const hardest = leaves.filter(
    (d) => d.poverty === keys.poverty.poverty3 && d.education === keys.education.education1
  );
  const hardestPct = d3.sum(hardest, (d) => d.pct_total);

  if (hardestPct > 0) {
    lines.push(tmpl(t.poverty, { pct: pct(hardestPct) }));
  }

  // Percentages mislead where much of the area could not be modelled at all.
  const unknown = d3.sum(
    leaves.filter(
      (d) => d.poverty === keys.poverty.povertyNA || d.education === keys.education.educationNA
    ),
    (d) => d.pct_total
  );

  if (unknown >= 5) lines.push(tmpl(t.noData, { pct: pct(unknown) }));

  lines.push(t.caveat);

  return quickInsight(lines.join("\n\n"));
}

What helps people cope?Qu’est-ce qui aide les gens à faire face ?

Adaptive capacity is the set of systems and services that help communities prepare for, respond to, and recover from climate shocks. In this section, we look at key indicators that reflect a region’s ability to adapt. These indicators highlight what systems are in place and what gaps need to be addressed to reduce long-term vulnerability.

La capacité d’adaptation est l’ensemble des systèmes et services qui aident les communautés à se préparer, réagir et se remettre des chocs climatiques. Dans cette section, nous examinons les indicateurs clés qui reflètent la capacité d’adaptation d’une région. Ces indicateurs soulignent quels systèmes sont en place et quelles lacunes doivent être comblées pour réduire la vulnérabilité à long terme.

How to read these barsComment lire ces barres

Against the area above — Each service is drawn twice: the selected area in colour, and the area containing it behind in grey — a district against its region, a region against its country, a country against Sub-Saharan Africa.

Fixed scales, not rankings — A full bar means the same thing everywhere: universal access, no journey to a market, no recorded conflict. Bars are not ranks against other areas, so a district and its region can be read directly against each other.

Distance to market — Averaged over an area rather than over the people living in it, so the figure climbs with the size of the unit. It is shown only for regions and districts; at country and continent scale uninhabited land dominates it.

Conflict-free area — Reported as a band rather than a number. The source counts conflict events per square kilometre and stops distinguishing areas past roughly 0.1 events per km², so a figure would suggest a precision the indicator does not have.

Averages, not measurements — Every value is an average across the area shown, not a reading taken at one place in it.

Face au territoire supérieur — Chaque service est représenté deux fois : le territoire sélectionné en couleur, et le territoire qui le contient en gris à l’arrière — un district face à sa région, une région face à son pays, un pays face à l’Afrique subsaharienne.

Des échelles fixes, non des classements — Une barre pleine signifie partout la même chose : accès universel, aucun trajet vers un marché, aucun conflit enregistré. Les barres ne sont pas des rangs face aux autres territoires : un district et sa région peuvent donc être lus directement l’un face à l’autre.

Temps de trajet vers les villes — Moyenné sur la superficie et non sur la population qui y vit : le chiffre augmente donc avec la taille du territoire. Il n’est affiché que pour les régions et les districts ; aux échelles nationale et continentale, les espaces inhabités le dominent.

Zone sans conflit — Présentée par classe et non par un chiffre. La source compte les événements par kilomètre carré et cesse de distinguer les territoires au-delà d’environ 0,1 événement par km² : un chiffre suggérerait une précision que l’indicateur n’a pas.

Des moyennes, non des mesures — Chaque valeur est une moyenne sur le territoire affiché, et non un relevé effectué en un point donné.

adminControls()

viewof capacityView = viewToggle(["plot", "table"])

capacityFigure = capacityView === "plot" ? renderCapacityPlot() : renderCapacityTable()

downloads(capacityView === "plot" ? capacityFigure : null, capacityRows, "adaptive_capacity")

renderCapacityInsight()

enablingRow = async (where) => {
  const bind = createSqlBindings();
  const rows = await db.query(`SELECT * FROM enabling WHERE ${where(bind)}`, bind.params);

  return rows[0];
}

capacityArea = enablingRow(adminWhereExact)

capacityParent = enablingRow(adminWhereParent)

// At the top level the area is its own parent, so only one series is drawn.
capacityHasParent = selectedAdmin0.length > 0

capacityRows = capacityHasParent ? [capacityArea, capacityParent] : [capacityArea]

CAPACITY_INDICATORS = [
  { key: "pct_electric", bound: 100 },
  { key: "pct_piped_water", bound: 100 },
  // Four hours to a market is as bad as this reads; beyond that the bar floors.
  // The value is also a mean over area rather than over people, so above region
  // level uninhabited land dominates it — Sub-Saharan Africa reads 580 minutes.
  { key: "min_to_cities", bound: 240, digits: 0, lowerIsBetter: true, areaMean: true },
  { key: "pct_cellphone", bound: 100 },
  // Events per km². The source floors its own score around this density, and a
  // number here would imply precision the indicator lacks, hence a band.
  { key: "conflict_density", bound: 0.1, lowerIsBetter: true, band: true },
]

capacityScore = ({ bound, lowerIsBetter = false }, raw) => {
  if (!Number.isFinite(raw)) return null;

  const scaled = Math.min(Math.abs(raw), bound) / bound;

  return lowerIsBetter ? 1 - scaled : scaled;
}

// Same breaks as before, now read off a bound-scaled score rather than a
// level-ranked one, so the band means the same thing at every admin level.
conflictBand = (score) => {
  const t = nbText.AdaptiveCapacity.conflictBands;

  return score === 1 ? t.none : score > 0.9 ? t.low : score > 0 ? t.moderate : t.high;
}

// Travel time is a mean over area, not over people, so its value climbs with the
// size of the unit: a median of 32 minutes across districts against 580 for
// Sub-Saharan Africa. Past the four-hour bound the bar floors at zero, which
// would draw the continent as having no market access at all. Shown only where
// the area and its parent are both small enough for the number to mean something.
capacityShowsAreaMean = selectedAdmin1.length > 0

capacityPlotData = CAPACITY_INDICATORS.filter(
  (config) => !config.areaMean || capacityShowsAreaMean
).map((config) => {
  const { key, band = false, digits = 1 } = config;
  const areaRaw = capacityArea[key];
  const parentRaw = capacityParent[key];
  const area = capacityScore(config, areaRaw);
  const parent = capacityScore(config, parentRaw);
  const text = (raw, score) =>
    score === null
      ? nbText.General.noData
      : band
      ? conflictBand(score)
      : `${raw.toFixed(digits)}${nbText.AdaptiveCapacity.units[key]}`;

  return {
    ...config,
    indicator: nbText.AdaptiveCapacity.indicators[key],
    area,
    parent,
    areaRaw,
    parentRaw,
    areaText: text(areaRaw, area),
    parentText: text(parentRaw, parent),
  };
}).sort((a, b) => a.indicator.localeCompare(b.indicator))

// The other three sections name their columns; this one showed raw keys.
renderCapacityTable = () =>
  atlasTable(capacityRows, {
    columns: ["admin0_name", "admin1_name", "admin2_name", ...CAPACITY_INDICATORS.map((d) => d.key)],
    header: { ...adminHeaders, ...nbText.AdaptiveCapacity.indicators },
  })

capacityAreaLabel = tmpl(nbText.AdaptiveCapacity.areaValue, { area: breadcrumb })

capacityParentLabel = tmpl(nbText.AdaptiveCapacity.areaValue, { area: parentName })

renderCapacityPlot = () =>
  Plot.plot({
    style: chartStyle,
    caption: capacityShowsAreaMean ? undefined : nbText.AdaptiveCapacity.areaMeanNote,
    width,
    height: 400,
    marginLeft: 160,
    marginRight: 40,
    marginTop: 10,
    marginBottom: 40,
    color: {
      legend: capacityHasParent,
      domain: [capacityAreaLabel, capacityParentLabel],
      range: ["#4a90e2", "#e5e5e5"],
    },
    x: {
      label: nbText.AdaptiveCapacity.axis,
      labelAnchor: "center",
      labelOffset: 30,
      domain: [0, 1],
      ticks: [0, 0.5, 1],
      tickSize: 4,
      tickFormat: (d) =>
        d === 0 ? _lang(general_translations.low) : d === 1 ? _lang(general_translations.high) : "",
    },
    y: { label: null, tickSize: 0, grid: true },
    marks: [
      Plot.barX(capacityPlotData, { x: "parent", y: "indicator", fill: "#e5e5e5", opacity: 0.7 }),
      Plot.barX(capacityPlotData, {
        x: "area",
        y: "indicator",
        fill: "#4a90e2",
        insetTop: 15,
        insetBottom: 15,
        channels: {
          [capacityAreaLabel]: (d) => d.areaText,
          ...(capacityHasParent
            ? { [capacityParentLabel]: (d) => d.parentText }
            : {}),
        },
        tip: { format: { x: false } },
      }),
    ],
  })

capacityComparison = capacityPlotData
  .filter((d) => !d.band)
  .map((d) => {
    const gap = d.lowerIsBetter ? d.parentRaw - d.areaRaw : d.areaRaw - d.parentRaw;

    return {
      indicator: d.indicator,
      value: d.areaText,
      parentValue: d.parentText,
      relative: Number.isFinite(gap) && d.parentRaw ? gap / Math.abs(d.parentRaw) : null,
    };
  })
  .filter((d) => d.relative !== null)

// Conflict counts toward the tally like any other service — the chart draws it —
// but its density is not a figure worth quoting, so it is ranked on its own.
capacityConflict = {
  const row = capacityPlotData.find((d) => d.band);

  return row && row.area !== null && row.parent !== null
    ? { ...row, gap: row.area - row.parent }
    : null;
}

renderCapacityInsight = () => {
  const t = nbText.AdaptiveCapacity.insight;

  // Nothing to compare against at the top level, so report the area's own values.
  if (!capacityHasParent) {
    const values = capacityPlotData.map((d) => `- ${d.indicator}: **${d.areaText}**`);

    return quickInsight([tmpl(t.wholeArea, { region: breadcrumb }), values.join("\n")].join("\n\n"));
  }

  const behind = capacityComparison.filter((d) => d.relative < 0);
  const conflictBehind = capacityConflict?.gap < 0;
  const trailing = behind.length + (conflictBehind ? 1 : 0);

  const lines = [
    trailing
      ? tmpl(t.intro, {
          region: breadcrumb,
          parent: parentName,
          behind: trailing,
          total: capacityComparison.length + (capacityConflict ? 1 : 0),
        })
      : tmpl(t.introNone, { region: breadcrumb, parent: parentName }),
  ];

  // Every service, not just the extremes: these are raw values, so each one is
  // as readable as the next. Worst first, so what needs attention leads.
  lines.push(
    [...capacityComparison]
      .sort((a, b) => a.relative - b.relative)
      .map((d) => `- ${tmpl(t.row, { ...d })}`)
      .join("\n")
  );

  // Conflict is a band rather than a number. Naming it only on a change of band
  // stayed silent on gaps the chart shows plainly — a third of the axis can pass
  // inside one band — so a material gap gets a sentence either way.
  if (capacityConflict && Math.abs(capacityConflict.gap) >= 0.1) {
    const { areaText: here, parentText: there, gap } = capacityConflict;

    lines.push(
      here === there
        ? tmpl(t.conflictSameBand, {
            parent: parentName,
            band: here,
            direction: gap < 0 ? t.direction.more : t.direction.less,
          })
        : tmpl(t.conflict, { here, there, parent: parentName })
    );
  }

  return quickInsight(lines.join("\n\n"));
}

SummarySynthèse

Vulnerability is not one number. It is the production standing in the path of a hazard, set against who lives there and what they have to respond with. The composite index holds those together: an area scores badly when the pressure on it outruns the infrastructure, services and stability available to absorb that pressure — which is why the most exposed places and the most vulnerable ones are not the same list.

Read in order, the sections give the argument behind any single score. Exposure locates the value of production at risk. Sensitivity shows the population carrying that risk, split by gender, poverty and education. Adaptive capacity measures what is in place to respond, always against the area one level up, so a weak district inside a well-served country is visible as such rather than averaged away.

Two things to keep in mind when acting on this. The exposure component is normalised across the areas currently in view, and the ranks quoted in the insights are ranks among those same areas, so changing the selection changes the comparison rather than the conditions on the ground. And every layer here describes the historical baseline: it says where vulnerability already sits, not where climate change will move it next.

La vulnérabilité ne se résume pas à un chiffre. C’est la production exposée à un aléa, mise en regard de ceux qui vivent là et des moyens dont ils disposent pour réagir. L’indice composite réunit ces éléments : un territoire obtient un mauvais score lorsque la pression qu’il subit dépasse les infrastructures, les services et la stabilité disponibles pour l’absorber — c’est pourquoi les territoires les plus exposés et les plus vulnérables ne forment pas la même liste.

Lues dans l’ordre, les sections donnent le raisonnement derrière chaque score. L’exposition situe la valeur de production à risque. La sensibilité montre la population qui porte ce risque, par genre, pauvreté et éducation. La capacité d’adaptation mesure ce qui existe pour réagir, toujours comparée au territoire du niveau supérieur, afin qu’un district fragile au sein d’un pays bien doté apparaisse comme tel plutôt que d’être noyé dans la moyenne.

Deux points à garder à l’esprit. La composante d’exposition est normalisée sur les territoires actuellement affichés, et les rangs cités dans les aperçus sont des rangs parmi ces mêmes territoires : changer la sélection change donc la comparaison, pas la réalité du terrain. Par ailleurs, toutes les couches présentées décrivent la période de référence historique : elles indiquent où la vulnérabilité se situe déjà, non où le changement climatique la déplacera.

Methods and SourcesMéthodes et sources

Vulnerability

Vulnerability is a composite index built the way ND-GAIN builds its own: an urgency score, describing the pressure a place is under, set against an enabling score, describing what it has to respond with. Each score is the mean of its available normalised indicators, and the composite is

vulnerability = 100 − (enabling − urgency + 1) × 50

so it runs from 0 to 100 and rises as enabling conditions fall behind urgency. Ranks in the insights are ranks within the areas currently on screen.

• Urgency — exposure, rural population density, education, and poverty.
• Enabling — electricity access, piped water access, travel time to cities, mobile phone access, and freedom from conflict.

Indicators arrive already normalised to a roughly 0–1 scale, oriented so that higher always means more pressure (urgency) or more capacity (enabling); travel time and conflict density are therefore inverted at source. Each indicator is min–max scaled within its own administrative level, so districts are placed against districts and countries against countries; the Sub-Saharan Africa row is scaled against the country distribution rather than against itself. Where an indicator is heavily skewed, the tenth or ninetieth percentile stands in for the minimum or maximum so that a handful of extreme units cannot flatten the rest. Several indicators carry a policy target — 100% electricity and mobile phone access, 90% piped water, 60 minutes to a city, zero conflict, six years of schooling, a 10% poverty rate — and are measured as distance to that target rather than to the best-performing unit.

Exposure is the exception: it is min–max normalised across the areas returned by the current selection, so exposure-driven scores are comparable within a selection rather than across selections.

Exposure

Exposure is the value of production (VoP) that coincides with a severe climate hazard, in constant 2015 US dollars. Hazards are drought (NDWS), heat (NTx35 for crops, THI-max for livestock) and waterlogging (NDWL0), combined as “any hazard” over the historical baseline. Coverage spans 43 crop and livestock commodities. Areas without VoP data are drawn grey rather than as zero.

Sensitivity

Rural population is broken down by gender, then poverty, then education, and reported as a share of the rural population of the selected area. Every layer here is a modelled surface, so the shares are spatial estimates carrying real uncertainty rather than reported statistics. Poverty and education each have three classes plus a no-data class. The icicle plot reads top to bottom: each band is a share of the band above it.

The classes are cut from the underlying surfaces rather than from the population itself. Poverty is the modelled share of people below the $2.15 a day line: low where under 30% of the local population falls below it, moderate from 30 to 60%, high above 60%. Note this is a different line from the one the composite index uses. Education is the modelled share of adults aged 15 to 49 with no schooling, with primary, and with secondary — rates that are then applied to the whole rural population; the three shares are rescaled to sum to one in each grid cell before being applied to the population count, so that modelling error cannot inflate or deflate the population of an area. Cells where a surface is missing for one gender become that gender’s no-data class rather than being dropped.

Adaptive capacity

The five enabling indicators are shown against their parent area — a region against its country, a country against Sub-Saharan Africa — so a value can be read as better or worse than the area containing it. Bars are the normalised scores; tooltips give the underlying values in their own units (per cent, minutes of travel time).

Bars are scaled against fixed bounds, not against the other areas: universal access for the three percentage indicators, no travel time at all, and no recorded conflict. A full bar therefore means the same thing at every level, and an area can be read against the one containing it. The _norm columns the composite index uses cannot serve here — each is ranked within its own administrative level, so an area’s score and its parent’s are drawn from different distributions; on travel time that reverses the comparison for one district in five. Travel time floors at four hours to a market, and is averaged over an area rather than over its people, so above region level uninhabited land dominates it — the Sub-Saharan Africa figure is 580 minutes — and the insights do not quote it at that scale.

Conflict-free area is reported as a band rather than a number: its source is a count of events per km², floored at 0.1, and a figure would read as precision the indicator does not have. No recorded conflict, low, moderate or high.

Sources

Every layer is extracted from its source grid by area-weighted zonal statistics over the GAUL 2024 boundaries — counts summed, rates averaged — at all three levels plus a dissolved Sub-Saharan Africa total.

Indicator	Source	Detail
Exposed value of production	Atlas hazard-risk-exposure surfaces (CMIP6)	Constant 2015 USD, severe hazard class, historical baseline, 43 commodities
Rural population density	Atlas gridded rural population, 2024	~1 km counts summed per unit, over the unit’s geodesic area
Education	IHME educational attainment, ages 15–49	Composite: mean years, 2017. Icicle: no-schooling, primary and secondary shares
Poverty	Modelled subnational poverty surfaces	Share below the $3.65 a day line, women and men averaged
Electricity access	Global Data Lab	Share of the population with electricity
Mobile phone access	Global Data Lab	Share of households with a mobile phone
Piped water access	IHME LMIC water and sanitation surfaces	Share of the population with piped water, 2017
Travel time to cities	Modelled accessibility surface	Mean minutes to the nearest city
Conflict	ACLED event counts	Events summed per unit, over the unit’s area in km²
Population composition	Atlas rural population with the education and poverty surfaces above	Gender × poverty class × education class, on a ~5.5 km grid

Administrative units

All layers use GAUL 2024 boundaries at country, region and district level. The notebook covers the Atlas’ Sub-Saharan African countries; areas outside that scope are present in the source tables but are excluded from every query and map.

Data

File	Contents
notebook_exposure.parquet	Value of production exposed to severe hazard, by commodity
urgency_index.parquet	Rural population density, education and poverty
enabling_vars.parquet	The five enabling indicators, raw and normalised
vulnerability_icicledata.parquet	Population by gender × poverty × education

Vulnérabilité

La vulnérabilité est un indice composite construit selon la méthode ND-GAIN : un score d’urgence, qui décrit la pression subie par un territoire, opposé à un score de conditions favorables, qui décrit les moyens dont il dispose pour y répondre. Chaque score est la moyenne de ses indicateurs normalisés disponibles, et l’indice composite vaut

vulnérabilité = 100 − (conditions favorables − urgence + 1) × 50

Il varie donc de 0 à 100 et augmente à mesure que les conditions favorables prennent du retard sur l’urgence. Les rangs affichés dans les aperçus sont des rangs au sein des territoires actuellement affichés.

• Urgence — exposition, densité de population rurale, éducation et pauvreté.
• Conditions favorables — accès à l’électricité, accès à l’eau courante, temps de trajet vers les villes, accès au téléphone portable et absence de conflits.

Les indicateurs sont fournis déjà normalisés sur une échelle proche de 0–1, orientés de sorte qu’une valeur élevée signifie toujours plus de pression (urgence) ou plus de capacité (conditions favorables) ; le temps de trajet et la densité de conflits sont donc inversés à la source. Chaque indicateur est normalisé min–max au sein de son propre niveau administratif : les districts sont comparés aux districts et les pays aux pays ; la ligne Afrique subsaharienne est normalisée sur la distribution des pays plutôt que sur elle-même. Lorsqu’un indicateur est fortement asymétrique, le dixième ou le quatre-vingt-dixième centile remplace le minimum ou le maximum, afin qu’une poignée de territoires extrêmes n’écrase pas les autres. Plusieurs indicateurs portent une cible d’action publique — 100 % d’accès à l’électricité et au téléphone portable, 90 % d’eau courante, 60 minutes d’une ville, zéro conflit, six années de scolarité, un taux de pauvreté de 10 % — et sont mesurés comme la distance à cette cible plutôt qu’au territoire le mieux placé.

L’exposition fait exception : elle est normalisée min–max sur les territoires renvoyés par la sélection en cours, si bien que les scores qui en dépendent sont comparables au sein d’une sélection plutôt qu’entre sélections.

Exposition

L’exposition est la valeur de production (VoP) qui coïncide avec un aléa climatique sévère, en dollars US constants de 2015. Les aléas retenus sont la sécheresse (NDWS), la chaleur (NTx35 pour les cultures, THI-max pour l’élevage) et l’engorgement des sols (NDWL0), combinés en « aléa quelconque » sur la période de référence historique. La couverture porte sur 43 produits végétaux et animaux. Les territoires sans donnée de VoP sont représentés en gris et non comme des zéros.

Sensibilité

La population rurale est ventilée par genre, puis par pauvreté, puis par éducation, et exprimée en part de la population rurale du territoire sélectionné. Chaque couche est une surface modélisée : les parts sont donc des estimations spatiales entachées d’une réelle incertitude, et non des statistiques officielles. La pauvreté et l’éducation comptent chacune trois classes plus une classe sans donnée. Le graphique en cascade se lit de haut en bas : chaque bande est une part de la bande qui la précède.

Les classes sont découpées à partir des surfaces sous-jacentes et non de la population elle-même. La pauvreté correspond à la part modélisée de personnes sous le seuil de 2,15 $ par jour : faible lorsque moins de 30 % de la population locale se situe sous ce seuil, modérée de 30 à 60 %, forte au-delà de 60 %. Ce seuil diffère de celui utilisé par l’indice composite. L’éducation correspond à la part modélisée d’adultes de 15 à 49 ans sans scolarisation, avec une scolarisation primaire et avec une scolarisation secondaire, taux ensuite appliqués à l’ensemble de la population rurale ; les trois parts sont remises à l’échelle pour sommer à un dans chaque cellule avant d’être appliquées à l’effectif de population, afin que l’erreur de modélisation ne gonfle ni ne réduise la population d’un territoire. Les cellules où une surface manque pour un genre alimentent la classe « pas de données » de ce genre plutôt que d’être écartées.

Capacité d’adaptation

Les cinq indicateurs de conditions favorables sont comparés à ceux du territoire parent — une région face à son pays, un pays face à l’Afrique subsaharienne — de sorte qu’une valeur puisse se lire comme meilleure ou moins bonne que celle du territoire qui la contient. Les barres représentent les scores normalisés ; les info-bulles donnent les valeurs sous-jacentes dans leurs propres unités (pourcentage, minutes de trajet).

Les barres sont mises à l’échelle sur des bornes fixes et non sur les autres territoires : accès universel pour les trois indicateurs en pourcentage, temps de trajet nul, aucun conflit enregistré. Une barre pleine signifie donc la même chose à chaque niveau, et un territoire peut être lu face à celui qui le contient. Les colonnes _norm utilisées par l’indice composite ne conviennent pas ici : chacune est classée au sein de son propre niveau administratif, de sorte que le score d’un territoire et celui de son parent proviennent de distributions différentes ; sur le temps de trajet, cela inverse la comparaison pour un district sur cinq. Le temps de trajet est plafonné à quatre heures et moyenné sur la superficie plutôt que sur la population : au-dessus du niveau régional, les espaces inhabités le dominent — l’Afrique subsaharienne affiche 580 minutes — et les aperçus ne le citent donc pas à cette échelle.

Zone sans conflit est présentée par classe et non par un chiffre : la source est un effectif d’événements par km², plafonné à 0,1, et un chiffre suggérerait une précision que l’indicateur n’a pas. Aucun conflit enregistré, faible, modéré ou élevé.

Sources

Chaque couche est extraite de sa grille source par statistiques zonales pondérées par la surface sur les limites GAUL 2024 — effectifs sommés, taux moyennés — aux trois niveaux, plus un total Afrique subsaharienne dissous.

Indicateur	Source	Détail
Valeur de production exposée	Surfaces d’exposition aux aléas de l’Atlas (CMIP6)	USD constants de 2015, classe sévère, période de référence historique, 43 produits
Densité de population rurale	Population rurale maillée de l’Atlas, 2024	Effectifs à ~1 km sommés, rapportés à la surface géodésique du territoire
Éducation	Niveau d’instruction IHME, 15–49 ans	Composite : années moyennes, 2017. Cascade : parts sans scolarisation, primaire, secondaire
Pauvreté	Surfaces de pauvreté infranationales modélisées	Part sous le seuil de 3,65 $ par jour, femmes et hommes moyennés
Accès à l’électricité	Global Data Lab	Part de la population raccordée à l’électricité
Accès au téléphone portable	Global Data Lab	Part des ménages équipés d’un téléphone portable
Accès à l’eau courante	Surfaces eau et assainissement IHME	Part de la population disposant de l’eau courante, 2017
Temps de trajet vers les villes	Surface d’accessibilité modélisée	Minutes moyennes jusqu’à la ville la plus proche
Conflits	Effectifs d’événements ACLED	Événements sommés, rapportés à la surface du territoire en km²
Composition de la population	Population rurale de l’Atlas avec les surfaces d’éducation et de pauvreté ci-dessus	Genre × classe de pauvreté × classe d’éducation, sur une grille d’environ 5,5 km

Découpage administratif

Toutes les couches utilisent les limites GAUL 2024 aux niveaux pays, région et district. Le carnet couvre les pays d’Afrique subsaharienne de l’Atlas ; les territoires hors de ce périmètre figurent dans les tables sources mais sont exclus de toutes les requêtes et de toutes les cartes.

Données

Fichier	Contenu
notebook_exposure.parquet	Valeur de production exposée à un aléa sévère, par produit
urgency_index.parquet	Densité de population rurale, éducation et pauvreté
enabling_vars.parquet	Les cinq indicateurs de conditions favorables, bruts et normalisés
vulnerability_icicledata.parquet	Population par genre × pauvreté × éducation

ContributorsContributeurs

AuthorsAuteurs

Brayden Youngberg¹, Pete Steward¹, Shalika Vyas¹

Technical DevelopmentDéveloppement technique

Brayden Youngberg¹, Johnson Mwakazi²

AffiliationsAffiliations

¹ Alliance Bioversity and CIAT

² Snapp Africa

CitationRéférence

CGIAR. (2026). Identify VulnerabilityIdentifier la vulnérabilité. Africa Agriculture Adaptation Atlas. https://adaptationatlas.cgiar.org

AppendixAnnexe

Source code

Language

import { lang as Lang } from "/helpers/lang.js";

general_translations = await FileAttachment("/data/shared/generalTranslations.json").json()

languages = [
  { key: "en", label: "English", locale: "en-US" },
  { key: "fr", label: "Français", locale: "fr-FR" },
]

// Language state lives in the navbar switcher; this cell just subscribes.
langKey = Generators.observe((notify) => {
  notify(window.atlasLang ?? "en");
  const onChange = (e) => notify(e.detail);
  window.addEventListener("atlas:lang", onChange);
  return () => window.removeEventListener("atlas:lang", onChange);
})

language = languages.find((l) => l.key === langKey) ?? languages[0]

_lang = Lang.lg(language.key)

import { loadNotebookText, readNotebookConfig } from "/helpers/notebook.js";

notebookConfig = readNotebookConfig()

notebookText = await loadNotebookText(notebookConfig)

nbText = notebookText[language.key]

nbTitle = notebookConfig.title[language.key]

tmpl = (template, values) =>
  Lang.reduceReplaceTemplateItems(
    template,
    Object.entries(values).map(([name, value]) => ({ name, value }))
  )

Admin selectors

adminControls = () =>
  adminSelect([0, 1, 2], {
    langKey: language.key,
    searchable: { admin1: true, admin2: true },
  })

// The boundaries take `adminSelections` — the selector state — as it comes;
// SQL and the level checks take the same selection as plain names.
selectedNames = [...selectedAdmin0, ...selectedAdmin1, ...selectedAdmin2]

// How the selection is named in prose and file names.
breadcrumb = selectedNames.join(", ") || _lang(adminTranslations.ssa)

// The area one level up, named the way breadcrumb names the selection.
parentName = selectedNames.slice(0, -1).join(", ") || _lang(adminTranslations.ssa)

areaSlug = breadcrumb.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-")

Data

db = await DuckDBClient.of({
  exposure: FileAttachment("/data/vulnerability/notebook_exposure.parquet"),
  urgency: FileAttachment("/data/vulnerability/urgency_index.parquet"),
  enabling: FileAttachment("/data/vulnerability/enabling_vars.parquet"),
  icicle: FileAttachment("/data/vulnerability/vulnerability_icicledata.parquet"),
})

// The tables reach beyond the Atlas — North Africa, islands, an SSA aggregate —
// so queries are scoped to the same countries the selectors offer. These tables
// carry no iso3, which is what sqlAdminWhere would otherwise scope by.
atlasCountries = countries.map((d) => d.admin0_name)

// Rows one level below the selection: pick a country, list its regions.
adminWhere = (bind) =>
  `${sqlAdminWhere(
    { admin0: selectedAdmin0, admin1: selectedAdmin1 },
    bind
  )} AND admin0_name IN (${bind.list(atlasCountries)})`

// These tables carry a whole-continent row filed under the name 'SSA', so an
// empty selection is that row rather than an absent one.
WHOLE_AREA = ["SSA"]

// The selection's own row.
adminWhereExact = (bind) =>
  sqlAdminAt(
    {
      admin0: selectedAdmin0.length ? selectedAdmin0 : WHOLE_AREA,
      admin1: selectedAdmin1,
      admin2: selectedAdmin2,
    },
    bind
  )

// The same, one level up: a region's country, a country's SSA.
adminWhereParent = (bind) =>
  sqlAdminAt(
    {
      admin0: selectedAdmin1.length ? selectedAdmin0 : WHOLE_AREA,
      admin1: selectedAdmin2.length ? selectedAdmin1 : [],
    },
    bind
  )

// Indicators arrive pre-normalised, so a score is just their mean.
meanNorm = (row) =>
  d3.mean(
    Object.entries(row).filter(([key]) => key.endsWith("_norm")),
    ([, value]) => value
  ) ?? null

Boundaries

import { adminBoundariesForSelection, getAdminBoundaries } from "/components/_atlasBoundaries.ojs";

// Levels 0 and 1 are small and always drawn.
atlasBoundaries = await getAdminBoundaries([0, 1])

// Fetch deep geometry only when drill-down needs it.
admin2Boundaries = selectedAdmin1.length ? (await getAdminBoundaries(2)).admin2 : null

// Resolve the drawn level once; every table here reaches admin 2.
adminView = adminBoundariesForSelection({
  boundaries: { ...atlasBoundaries, admin2: admin2Boundaries },
  selection: adminSelections,
})

// A selection at the drawn level marks its unit rather than narrowing the map.
adminHighlight = adminView.selectedAtLevel && {
  filter: (feature) =>
    feature.properties[adminView.selectedAtLevel.field] === adminView.selectedAtLevel.names[0],
}

// Join rows to the boundaries at the drawn level.
featuresFor = (data) =>
  mergeDataToBoundaries({
    boundaries: adminView.boundaries,
    data,
    boundaryKey: (feature) => adminView.adminKey(feature.properties),
    dataKey: adminView.adminKey,
  }).features

// Name the unit drawn, whatever level that is.
areaChannel = ({
  area: {
    label: adminLevelLabel(adminView.level, _lang),
    value: (d) =>
      [d.properties.admin2_name, d.properties.admin1_name, d.properties.admin0_name]
        .filter(Boolean)
        .join(", "),
  },
})

Shared controls and formatting

viewToggle = (options) =>
  Inputs.radio(options, {
    value: options[0],
    label: _lang(general_translations.vizType.title),
    format: (option) => _lang(general_translations.vizType[option]),
  })

// One download row per section: the figure when one is on screen, always the data.
downloads = (figure, data, name) => {
  const filename = `${name}_${areaSlug}`;

  return inputTemplate({ gap: "0.5rem" })(
    [
      figure && downloadPngButton(figure, { filename, label: nbText.General.downloadFigure }),
      downloadCsvButton(data, { filename, label: _lang(general_translations.download) }),
    ].filter(Boolean)
  );
}

// Every section closes with the same heading over its own body.
quickInsight = (body) => md`### ${nbText.General.quickInsights}

${body}`

usd = formatUSD({ locale: language.locale })

// One ramp per direction, shared by every choropleth: yellow to red as a score
// worsens, green to yellow where a high value is the good outcome.
RAMP_WORSE = ["#f4bb21", "#ec5a47"]

RAMP_BETTER = ["#216729", "#f7d732"]

// Admin columns are named the same in every table view.
adminHeaders = ({
  admin0_name: adminLevelLabel(0, _lang),
  admin1_name: adminLevelLabel(1, _lang),
  admin2_name: adminLevelLabel(2, _lang),
})