diff --git a/backend_py/primary/poetry.lock b/backend_py/primary/poetry.lock
index 23b7a2c27..c0f418289 100644
--- a/backend_py/primary/poetry.lock
+++ b/backend_py/primary/poetry.lock
@@ -793,13 +793,13 @@ files = [
 
 [[package]]
 name = "fmu-sumo"
-version = "1.2.2"
+version = "1.2.4"
 description = "Python package for interacting with Sumo in an FMU setting"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "fmu_sumo-1.2.2-py3-none-any.whl", hash = "sha256:51d72b145cc1d9db6f7a4fb41de67ceddd75ba3c2285b776358aa63aaa145a54"},
-    {file = "fmu_sumo-1.2.2.tar.gz", hash = "sha256:54b2ede5db007f99a37a47c60d7f5fb91417fb604388299db7d3002f04516041"},
+    {file = "fmu_sumo-1.2.4-py3-none-any.whl", hash = "sha256:d76ce6de25fe1009a78fcbbe6bf9b4cfd3c410398a81d9f4c073bd3a8b29d6a5"},
+    {file = "fmu_sumo-1.2.4.tar.gz", hash = "sha256:a9b422e08af271dca4e6293ae94b343329d59f302bbd44c8430a670e0b4be5c7"},
 ]
 
 [package.dependencies]
@@ -3513,4 +3513,4 @@ testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "p
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.11"
-content-hash = "0b37065931c0e13b53edfaab07550535df47242b20f989cac83cfbaff515d2a2"
+content-hash = "9c20526602b7ab84f5102041476f2af5da6763caba9935954c67db132b3a38ba"
diff --git a/backend_py/primary/primary/routers/group_tree/schemas.py b/backend_py/primary/primary/routers/group_tree/schemas.py
index 49c6e4dbb..d1372d1c3 100644
--- a/backend_py/primary/primary/routers/group_tree/schemas.py
+++ b/backend_py/primary/primary/routers/group_tree/schemas.py
@@ -1,6 +1,7 @@
 from typing import List
 from enum import Enum
-from primary.services.sumo_access.group_tree_types import GroupTreeMetadata, DatedTree
+from primary.services.sumo_access.group_tree_types import DatedTree, GroupTreeMetadata
+
 from pydantic import BaseModel
 
 
diff --git a/backend_py/primary/primary/services/group_tree_assembler/group_tree_assembler.py b/backend_py/primary/primary/services/group_tree_assembler/group_tree_assembler.py
index 7ac40a249..7d6c0082a 100644
--- a/backend_py/primary/primary/services/group_tree_assembler/group_tree_assembler.py
+++ b/backend_py/primary/primary/services/group_tree_assembler/group_tree_assembler.py
@@ -11,6 +11,7 @@
 from primary.services.sumo_access.group_tree_access import GroupTreeAccess
 from primary.services.sumo_access.group_tree_types import (
     DataType,
+    DataTypeToStringLabelMap,
     DatedTree,
     EdgeOrNode,
     GroupTreeMetadata,
@@ -654,17 +655,7 @@ def _create_leaf_node_classification_map(
 
 def _get_label(datatype: DataType) -> str:
     """Returns a more readable label for the summary datatypes"""
-    labels = {
-        DataType.OILRATE: "Oil Rate",
-        DataType.GASRATE: "Gas Rate",
-        DataType.WATERRATE: "Water Rate",
-        DataType.WATERINJRATE: "Water Inj Rate",
-        DataType.GASINJRATE: "Gas Inj Rate",
-        DataType.PRESSURE: "Pressure",
-        DataType.BHP: "BHP",
-        DataType.WMCTL: "WMCTL",
-    }
-    label = labels.get(datatype)
+    label = DataTypeToStringLabelMap.get(datatype)
     if label is None:
         raise ValueError(f"Label for datatype {datatype.value} not implemented.")
     return label
diff --git a/backend_py/primary/primary/services/sumo_access/queries/grid3d.py b/backend_py/primary/primary/services/sumo_access/queries/grid3d.py
index 3d0b51e14..f9f4ab2cb 100644
--- a/backend_py/primary/primary/services/sumo_access/queries/grid3d.py
+++ b/backend_py/primary/primary/services/sumo_access/queries/grid3d.py
@@ -78,23 +78,23 @@ async def get_grid_geometry_and_property_blob_ids_async(
                 {
                     "bool": {
                         "must": [
-                            {"match": {"_sumo.parent_object.keyword": case_id}},
-                            {"match": {"class": "cpgrid"}},
-                            {"match": {"fmu.iteration.name": iteration}},
-                            {"match": {"fmu.realization.id": realization}},
-                            {"match": {"data.name.keyword": grid_name}},
+                            {"term": {"_sumo.parent_object.keyword": case_id}},
+                            {"term": {"class.keyword": "cpgrid"}},
+                            {"term": {"fmu.iteration.name.keyword": iteration}},
+                            {"term": {"fmu.realization.id": realization}},
+                            {"term": {"data.name.keyword": grid_name}},
                         ]
                     }
                 },
                 {
                     "bool": {
                         "must": [
-                            {"match": {"_sumo.parent_object.keyword": case_id}},
-                            {"match": {"class": "cpgrid_property"}},
-                            {"match": {"fmu.iteration.name": iteration}},
-                            {"match": {"fmu.realization.id": realization}},
-                            {"match": {"data.name.keyword": parameter_name}},
-                            {"match": {"data.tagname.keyword": grid_name}},
+                            {"term": {"_sumo.parent_object.keyword": case_id}},
+                            {"term": {"class.keyword": "cpgrid_property"}},
+                            {"term": {"fmu.iteration.name.keyword": iteration}},
+                            {"term": {"fmu.realization.id": realization}},
+                            {"term": {"data.name.keyword": parameter_name}},
+                            {"term": {"data.tagname.keyword": grid_name}},
                         ]
                     }
                 },
@@ -102,7 +102,6 @@ async def get_grid_geometry_and_property_blob_ids_async(
             "minimum_should_match": 1,
         }
     }
-
     time_filter = get_time_filter(parameter_time_or_interval_str)
 
     if time_filter.time_type != TimeType.NONE:
@@ -118,7 +117,6 @@ async def get_grid_geometry_and_property_blob_ids_async(
 
     result = response.json()
     hits = result["hits"]["hits"]
-
     if len(hits) != 2:
         raise InvalidDataError(f"Expected 2 hits, got {len(hits)}", service=Service.SUMO)
 
diff --git a/backend_py/primary/pyproject.toml b/backend_py/primary/pyproject.toml
index b2ce7e7f4..5d4d11e2e 100644
--- a/backend_py/primary/pyproject.toml
+++ b/backend_py/primary/pyproject.toml
@@ -20,7 +20,7 @@ numpy = "^1.24.1"
 orjson = "^3.8.10"
 pandas = {version = "2.0.1", extras = ["performance"]}
 httpx = "^0.24.0"
-fmu-sumo = "1.2.2"
+fmu-sumo = "1.2.4"
 sumo-wrapper-python = "1.0.9"
 azure-monitor-opentelemetry = "^1.1.0"
 requests-toolbelt = "^1.0.0"
diff --git a/frontend/src/framework/GlobalAtoms.ts b/frontend/src/framework/GlobalAtoms.ts
index 8b6a45214..501932bf7 100644
--- a/frontend/src/framework/GlobalAtoms.ts
+++ b/frontend/src/framework/GlobalAtoms.ts
@@ -11,7 +11,7 @@ import { atomWithCompare } from "./utils/atomUtils";
 export const EnsembleSetAtom = atomWithCompare<EnsembleSet>(new EnsembleSet([]), isEqual);
 
 export const EnsembleRealizationFilterFunctionAtom = atom<EnsembleRealizationFilterFunction | null>((get) => {
-    const realizationFilterSet = get(RealizationFilterSetAtom);
+    const realizationFilterSet = get(RealizationFilterSetAtom)?.filterSet;
 
     if (!realizationFilterSet) {
         return null;
@@ -21,19 +21,8 @@ export const EnsembleRealizationFilterFunctionAtom = atom<EnsembleRealizationFil
         realizationFilterSet.getRealizationFilterForEnsembleIdent(ensembleIdent).getFilteredRealizations();
 });
 
-function areRealizationFilterSetsEqual(a: RealizationFilterSet | null, b: RealizationFilterSet | null): boolean {
-    if (a === null && b === null) {
-        return true;
-    }
-
-    if (a === null || b === null) {
-        return false;
-    }
-
-    return a.isEqual(b);
-}
-
-export const RealizationFilterSetAtom = atomWithCompare<RealizationFilterSet | null>(
-    null,
-    areRealizationFilterSetsEqual
-);
+// RealizationFilterSetAtom needs to be packed into an object such that we can shallow-compare it with its previous value
+// as the class instance of RealizationFilterSet will never change in the lifetime of the application.
+export const RealizationFilterSetAtom = atom<{
+    filterSet: RealizationFilterSet;
+} | null>(null);
diff --git a/frontend/src/framework/internal/WorkbenchSessionPrivate.ts b/frontend/src/framework/internal/WorkbenchSessionPrivate.ts
index 97877ca6e..1bc9f6575 100644
--- a/frontend/src/framework/internal/WorkbenchSessionPrivate.ts
+++ b/frontend/src/framework/internal/WorkbenchSessionPrivate.ts
@@ -26,6 +26,9 @@ export class WorkbenchSessionPrivate extends WorkbenchSession {
     }
 
     notifyAboutEnsembleRealizationFilterChange(): void {
+        this._atomStoreMaster.setAtomValue(RealizationFilterSetAtom, {
+            filterSet: this._realizationFilterSet,
+        });
         this.notifySubscribers(WorkbenchSessionEvent.RealizationFilterSetChanged);
     }
 }
diff --git a/frontend/src/modules/FlowNetwork/settings/atoms/derivedAtoms.ts b/frontend/src/modules/FlowNetwork/settings/atoms/derivedAtoms.ts
index 3b3d83102..166298583 100644
--- a/frontend/src/modules/FlowNetwork/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/FlowNetwork/settings/atoms/derivedAtoms.ts
@@ -89,16 +89,23 @@ export const selectedDateTimeAtom = atom<string | null>((get) => {
     return userSelectedDateTime;
 });
 
-export const availableEdgeKeysAtom = atom<string[]>((get) => {
+export const edgeMetadataListAtom = atom<EdgeMetadata[]>((get) => {
     const groupTreeQueryResult = get(groupTreeQueryResultAtom);
-    return groupTreeQueryResult.data?.edge_metadata_list.map((item) => item.key) ?? [];
+
+    const data = groupTreeQueryResult.data;
+    if (!data) {
+        return [];
+    }
+
+    return data.edge_metadata_list.map((elm) => ({ key: elm.key, label: elm.label }));
 });
 
 export const selectedEdgeKeyAtom = atom<string | null>((get) => {
-    const availableEdgeKeys = get(availableEdgeKeysAtom);
+    const availableEdgesMetadataList = get(edgeMetadataListAtom);
+    const availableEdgeKeys = availableEdgesMetadataList.map((item) => item.key);
     const userSelectedEdgeKey = get(userSelectedEdgeKeyAtom);
 
-    if (availableEdgeKeys.length === 0) {
+    if (availableEdgesMetadataList.length === 0) {
         return null;
     }
     if (!userSelectedEdgeKey || !availableEdgeKeys.includes(userSelectedEdgeKey)) {
@@ -108,16 +115,23 @@ export const selectedEdgeKeyAtom = atom<string | null>((get) => {
     return userSelectedEdgeKey;
 });
 
-export const availableNodeKeysAtom = atom<string[]>((get) => {
+export const nodeMetadataListAtom = atom<NodeMetadata[]>((get) => {
     const groupTreeQueryResult = get(groupTreeQueryResultAtom);
-    return groupTreeQueryResult.data?.node_metadata_list.map((item) => item.key) ?? [];
+
+    const data = groupTreeQueryResult.data;
+    if (!data) {
+        return [];
+    }
+
+    return data.node_metadata_list.map((elm) => ({ key: elm.key, label: elm.label }));
 });
 
 export const selectedNodeKeyAtom = atom<string | null>((get) => {
-    const availableNodeKeys = get(availableNodeKeysAtom);
+    const availableNodesMetadataList = get(nodeMetadataListAtom);
+    const availableNodeKeys = availableNodesMetadataList.map((item) => item.key);
     const userSelectedNodeKey = get(userSelectedNodeKeyAtom);
 
-    if (availableNodeKeys.length === 0) {
+    if (availableNodesMetadataList.length === 0) {
         return null;
     }
     if (!userSelectedNodeKey || !availableNodeKeys.includes(userSelectedNodeKey)) {
@@ -127,17 +141,13 @@ export const selectedNodeKeyAtom = atom<string | null>((get) => {
     return userSelectedNodeKey;
 });
 
-export const edgeMetadataListAtom = atom<EdgeMetadata[]>((get) => {
+export const datedTreesAtom = atom<DatedTree[]>((get) => {
     const groupTreeQueryResult = get(groupTreeQueryResultAtom);
-    return groupTreeQueryResult.data?.edge_metadata_list ?? [];
-});
 
-export const nodeMetadataListAtom = atom<NodeMetadata[]>((get) => {
-    const groupTreeQueryResult = get(groupTreeQueryResultAtom);
-    return groupTreeQueryResult.data?.node_metadata_list ?? [];
-});
+    const data = groupTreeQueryResult.data;
+    if (!data) {
+        return [];
+    }
 
-export const datedTreesAtom = atom<DatedTree[]>((get) => {
-    const groupTreeQueryResult = get(groupTreeQueryResultAtom);
-    return groupTreeQueryResult.data?.dated_trees ?? [];
+    return data.dated_trees;
 });
diff --git a/frontend/src/modules/FlowNetwork/settings/settings.tsx b/frontend/src/modules/FlowNetwork/settings/settings.tsx
index 47e1e6637..056f2c959 100644
--- a/frontend/src/modules/FlowNetwork/settings/settings.tsx
+++ b/frontend/src/modules/FlowNetwork/settings/settings.tsx
@@ -29,9 +29,9 @@ import {
 } from "./atoms/baseAtoms";
 import {
     availableDateTimesAtom,
-    availableEdgeKeysAtom,
-    availableNodeKeysAtom,
+    edgeMetadataListAtom,
     groupTreeQueryResultAtom,
+    nodeMetadataListAtom,
     selectedDateTimeAtom,
     selectedEdgeKeyAtom,
     selectedEnsembleIdentAtom,
@@ -47,8 +47,8 @@ export function Settings({ workbenchSession, settingsContext }: ModuleSettingsPr
     const statusWriter = useSettingsStatusWriter(settingsContext);
 
     const availableDateTimes = useAtomValue(availableDateTimesAtom);
-    const availableEdgeKeys = useAtomValue(availableEdgeKeysAtom);
-    const availableNodeKeys = useAtomValue(availableNodeKeysAtom);
+    const edgeMetadataList = useAtomValue(edgeMetadataListAtom);
+    const nodeMetadataList = useAtomValue(nodeMetadataListAtom);
 
     const [selectedResamplingFrequency, setSelectedResamplingFrequency] = useAtom(selectedResamplingFrequencyAtom);
     const [selectedNodeTypes, setSelectedNodeTypes] = useAtom(selectedNodeTypesAtom);
@@ -191,8 +191,8 @@ export function Settings({ workbenchSession, settingsContext }: ModuleSettingsPr
                     <div className="flex flex-col gap-2">
                         <Label text="Edge options">
                             <Dropdown
-                                options={availableEdgeKeys.map((item) => {
-                                    return { label: item, value: item };
+                                options={edgeMetadataList.map((item) => {
+                                    return { label: item.label, value: item.key };
                                 })}
                                 value={selectedEdgeKey ?? ""}
                                 onChange={handleSelectedEdgeKeyChange}
@@ -200,8 +200,8 @@ export function Settings({ workbenchSession, settingsContext }: ModuleSettingsPr
                         </Label>
                         <Label text="Node options">
                             <Dropdown
-                                options={availableNodeKeys.map((item) => {
-                                    return { label: item, value: item };
+                                options={nodeMetadataList.map((item) => {
+                                    return { label: item.label, value: item.key };
                                 })}
                                 value={selectedNodeKey ?? ""}
                                 onChange={handleSelectedNodeKeyChange}
diff --git a/frontend/src/modules/Intersection/settings/atoms/derivedAtoms.ts b/frontend/src/modules/Intersection/settings/atoms/derivedAtoms.ts
index 9ab9954a7..0432d8f8b 100644
--- a/frontend/src/modules/Intersection/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/Intersection/settings/atoms/derivedAtoms.ts
@@ -1,6 +1,6 @@
 import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
-import { EnsembleRealizationFilterFunctionAtom, EnsembleSetAtom } from "@framework/GlobalAtoms";
+import { EnsembleSetAtom } from "@framework/GlobalAtoms";
 import { IntersectionPolylinesAtom } from "@framework/userCreatedItems/IntersectionPolylines";
 import { LayerManager } from "@modules/Intersection/utils/layers/LayerManager";
 
@@ -37,25 +37,6 @@ export const selectedFieldIdentifierAtom = atom((get) => {
     return selectedFieldIdentifier;
 });
 
-export const availableRealizationsAtom = atom((get) => {
-    const ensembleSet = get(EnsembleSetAtom);
-    const selectedEnsembleIdent = get(selectedEnsembleIdentAtom);
-
-    if (selectedEnsembleIdent === null) {
-        return [];
-    }
-
-    let ensembleRealizationFilterFunction = get(EnsembleRealizationFilterFunctionAtom);
-
-    if (ensembleRealizationFilterFunction === null) {
-        ensembleRealizationFilterFunction = (ensembleIdent: EnsembleIdent) => {
-            return ensembleSet.findEnsemble(ensembleIdent)?.getRealizations() ?? [];
-        };
-    }
-
-    return ensembleRealizationFilterFunction(selectedEnsembleIdent);
-});
-
 export const availableUserCreatedIntersectionPolylinesAtom = atom((get) => {
     const intersectionPolylines = get(IntersectionPolylinesAtom);
     return intersectionPolylines;
diff --git a/frontend/src/modules/SimulationTimeSeries/view/atoms/atomDefinitions.ts b/frontend/src/modules/SimulationTimeSeries/view/atoms/atomDefinitions.ts
new file mode 100644
index 000000000..970af41ac
--- /dev/null
+++ b/frontend/src/modules/SimulationTimeSeries/view/atoms/atomDefinitions.ts
@@ -0,0 +1,372 @@
+import {
+    Frequency_api,
+    Observations_api,
+    VectorHistoricalData_api,
+    VectorRealizationData_api,
+    VectorStatisticData_api,
+} from "@api";
+import { apiService } from "@framework/ApiService";
+import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { EnsembleRealizationFilterFunctionAtom, EnsembleSetAtom } from "@framework/GlobalAtoms";
+import { ModuleAtoms } from "@framework/Module";
+import { UniDirectionalModuleComponentsInterface } from "@framework/UniDirectionalModuleComponentsInterface";
+import { atomWithQueries } from "@framework/utils/atomUtils";
+import { SettingsToViewInterface } from "@modules/SimulationTimeSeries/settingsToViewInterface";
+import {
+    EnsembleVectorObservationDataMap,
+    VectorSpec,
+    VisualizationMode,
+} from "@modules/SimulationTimeSeries/typesAndEnums";
+import { QueryObserverResult } from "@tanstack/react-query";
+
+import { atom } from "jotai";
+
+import { createLoadedVectorSpecificationAndDataArray } from "../utils/vectorSpecificationsAndQueriesUtils";
+
+export type ViewAtoms = {
+    userSelectedActiveTimestampUtcMs: number | null;
+    activeTimestampUtcMs: number | null;
+    vectorDataQueries: QueryObserverResult<VectorRealizationData_api[], Error>[];
+    vectorStatisticsQueries: QueryObserverResult<VectorStatisticData_api, Error>[];
+    historicalVectorDataQueries: QueryObserverResult<VectorHistoricalData_api, Error>[];
+    vectorObservationsQueries: {
+        isFetching: boolean;
+        isError: boolean;
+        ensembleVectorObservationDataMap: EnsembleVectorObservationDataMap;
+    };
+    queryIsFetching: boolean;
+    realizationsQueryHasError: boolean;
+    statisticsQueryHasError: boolean;
+    historicalDataQueryHasError: boolean;
+    loadedVectorSpecificationsAndRealizationData: {
+        vectorSpecification: VectorSpec;
+        data: VectorRealizationData_api[];
+    }[];
+    loadedVectorSpecificationsAndStatisticsData: {
+        vectorSpecification: VectorSpec;
+        data: VectorStatisticData_api;
+    }[];
+    loadedVectorSpecificationsAndHistoricalData: {
+        vectorSpecification: VectorSpec;
+        data: VectorHistoricalData_api;
+    }[];
+    colorByParameter: boolean;
+};
+
+const STALE_TIME = 60 * 1000;
+const CACHE_TIME = 60 * 1000;
+
+export function viewAtomsInitialization(
+    settingsToViewInterface: UniDirectionalModuleComponentsInterface<SettingsToViewInterface>
+): ModuleAtoms<ViewAtoms> {
+    const userSelectedActiveTimestampUtcMsAtom = atom<number | null>(null);
+
+    const validEnsembleRealizationsFunctionAtom = atom((get) => {
+        const ensembleSet = get(EnsembleSetAtom);
+        let validEnsembleRealizationsFunction = get(EnsembleRealizationFilterFunctionAtom);
+
+        if (validEnsembleRealizationsFunction === null) {
+            validEnsembleRealizationsFunction = (ensembleIdent: EnsembleIdent) => {
+                return ensembleSet.findEnsemble(ensembleIdent)?.getRealizations() ?? [];
+            };
+        }
+
+        return validEnsembleRealizationsFunction;
+    });
+
+    const vectorDataQueriesAtom = atomWithQueries((get) => {
+        const vectorSpecifications = get(settingsToViewInterface.getAtom("vectorSpecifications"));
+        const resampleFrequency = get(settingsToViewInterface.getAtom("resampleFrequency"));
+        const visualizationMode = get(settingsToViewInterface.getAtom("visualizationMode"));
+        const validEnsembleRealizationsFunction = get(validEnsembleRealizationsFunctionAtom);
+
+        const enabled =
+            visualizationMode === VisualizationMode.INDIVIDUAL_REALIZATIONS ||
+            visualizationMode === VisualizationMode.STATISTICS_AND_REALIZATIONS;
+
+        const queries = vectorSpecifications.map((item) => {
+            const realizations = [...validEnsembleRealizationsFunction(item.ensembleIdent)];
+            return () => ({
+                queryKey: [
+                    "getRealizationsVectorData",
+                    item.ensembleIdent.getCaseUuid(),
+                    item.ensembleIdent.getEnsembleName(),
+                    item.vectorName,
+                    resampleFrequency,
+                    realizations,
+                ],
+                queryFn: () =>
+                    apiService.timeseries.getRealizationsVectorData(
+                        item.ensembleIdent.getCaseUuid() ?? "",
+                        item.ensembleIdent.getEnsembleName() ?? "",
+                        item.vectorName ?? "",
+                        resampleFrequency,
+                        realizations
+                    ),
+                staleTime: STALE_TIME,
+                gcTime: CACHE_TIME,
+                enabled: !!(
+                    enabled &&
+                    item.vectorName &&
+                    item.ensembleIdent.getCaseUuid() &&
+                    item.ensembleIdent.getEnsembleName()
+                ),
+            });
+        });
+
+        return {
+            queries,
+        };
+    });
+
+    const vectorStatisticsQueriesAtom = atomWithQueries((get) => {
+        const vectorSpecifications = get(settingsToViewInterface.getAtom("vectorSpecifications"));
+        const resampleFrequency = get(settingsToViewInterface.getAtom("resampleFrequency"));
+        const visualizationMode = get(settingsToViewInterface.getAtom("visualizationMode"));
+        const validEnsembleRealizationsFunction = get(validEnsembleRealizationsFunctionAtom);
+
+        const enabled =
+            visualizationMode === VisualizationMode.STATISTICAL_FANCHART ||
+            visualizationMode === VisualizationMode.STATISTICAL_LINES ||
+            visualizationMode === VisualizationMode.STATISTICS_AND_REALIZATIONS;
+
+        const queries = vectorSpecifications.map((item) => {
+            const realizations = [...validEnsembleRealizationsFunction(item.ensembleIdent)];
+            return () => ({
+                queryKey: [
+                    "getStatisticalVectorData",
+                    item.ensembleIdent.getCaseUuid(),
+                    item.ensembleIdent.getEnsembleName(),
+                    item.vectorName,
+                    resampleFrequency,
+                    realizations,
+                ],
+                queryFn: () =>
+                    apiService.timeseries.getStatisticalVectorData(
+                        item.ensembleIdent.getCaseUuid() ?? "",
+                        item.ensembleIdent.getEnsembleName() ?? "",
+                        item.vectorName ?? "",
+                        resampleFrequency ?? Frequency_api.MONTHLY,
+                        undefined,
+                        realizations
+                    ),
+                staleTime: STALE_TIME,
+                gcTime: CACHE_TIME,
+                enabled: !!(
+                    enabled &&
+                    item.vectorName &&
+                    item.ensembleIdent.getCaseUuid() &&
+                    item.ensembleIdent.getEnsembleName()
+                ),
+            });
+        });
+
+        return {
+            queries,
+        };
+    });
+
+    const historicalVectorDataQueriesAtom = atomWithQueries((get) => {
+        const vectorSpecifications = get(settingsToViewInterface.getAtom("vectorSpecifications"));
+        const resampleFrequency = get(settingsToViewInterface.getAtom("resampleFrequency"));
+
+        const vectorSpecificationsWithHistoricalData = vectorSpecifications?.filter((vec) => vec.hasHistoricalVector);
+        const enabled = vectorSpecificationsWithHistoricalData?.some((vec) => vec.hasHistoricalVector) ?? false;
+
+        const queries = vectorSpecifications.map((item) => {
+            return () => ({
+                queryKey: [
+                    "getHistoricalVectorData",
+                    item.ensembleIdent.getCaseUuid(),
+                    item.ensembleIdent.getEnsembleName(),
+                    item.vectorName,
+                    resampleFrequency,
+                ],
+                queryFn: () =>
+                    apiService.timeseries.getHistoricalVectorData(
+                        item.ensembleIdent.getCaseUuid() ?? "",
+                        item.ensembleIdent.getEnsembleName() ?? "",
+                        item.vectorName ?? "",
+                        resampleFrequency ?? Frequency_api.MONTHLY
+                    ),
+                staleTime: STALE_TIME,
+                gcTime: CACHE_TIME,
+                enabled: !!(
+                    enabled &&
+                    item.vectorName &&
+                    item.ensembleIdent.getCaseUuid() &&
+                    item.ensembleIdent.getEnsembleName()
+                ),
+            });
+        });
+
+        return {
+            queries,
+        };
+    });
+
+    const vectorObservationsQueriesAtom = atomWithQueries((get) => {
+        const showObservations = get(settingsToViewInterface.getAtom("showObservations"));
+        const vectorSpecifications = get(settingsToViewInterface.getAtom("vectorSpecifications"));
+
+        const uniqueEnsembleIdents = [...new Set(vectorSpecifications?.map((item) => item.ensembleIdent) ?? [])];
+
+        const queries = uniqueEnsembleIdents.map((item) => {
+            return () => ({
+                queryKey: ["getObservations", item.getCaseUuid()],
+                queryFn: () => apiService.observations.getObservations(item.getCaseUuid() ?? ""),
+                staleTime: STALE_TIME,
+                gcTime: CACHE_TIME,
+                enabled: !!(showObservations && item.getCaseUuid()),
+            });
+        });
+
+        return {
+            queries,
+            combine: (results: QueryObserverResult<Observations_api>[]) => {
+                const combinedResult: EnsembleVectorObservationDataMap = new Map();
+                if (!vectorSpecifications)
+                    return { isFetching: false, isError: false, ensembleVectorObservationDataMap: combinedResult };
+
+                results.forEach((result, index) => {
+                    const ensembleIdent = uniqueEnsembleIdents.at(index);
+                    if (!ensembleIdent) return;
+
+                    const ensembleVectorSpecifications = vectorSpecifications.filter(
+                        (item) => item.ensembleIdent === ensembleIdent
+                    );
+
+                    const ensembleHasObservations = result.data?.summary.length !== 0;
+                    combinedResult.set(ensembleIdent, {
+                        hasSummaryObservations: ensembleHasObservations,
+                        vectorsObservationData: [],
+                    });
+                    for (const vectorSpec of ensembleVectorSpecifications) {
+                        const vectorObservationsData =
+                            result.data?.summary.find((elm) => elm.vector_name === vectorSpec.vectorName) ?? null;
+                        if (!vectorObservationsData) continue;
+
+                        combinedResult.get(ensembleIdent)?.vectorsObservationData.push({
+                            vectorSpecification: vectorSpec,
+                            data: vectorObservationsData,
+                        });
+                    }
+                });
+
+                return {
+                    isFetching: results.some((result) => result.isFetching),
+                    isError: results.some((result) => result.isError),
+                    ensembleVectorObservationDataMap: combinedResult,
+                };
+            },
+        };
+    });
+
+    const queryIsFetchingAtom = atom((get) => {
+        const vectorDataQueries = get(vectorDataQueriesAtom);
+        const vectorStatisticsQueries = get(vectorStatisticsQueriesAtom);
+        const historicalVectorDataQueries = get(historicalVectorDataQueriesAtom);
+        const vectorObservationsQueries = get(vectorObservationsQueriesAtom);
+
+        const vectorDataIsFetching = vectorDataQueries.some((query) => query.isFetching);
+        const vectorStatisticsIsFetching = vectorStatisticsQueries.some((query) => query.isFetching);
+        const historicalVectorDataIsFetching = historicalVectorDataQueries.some((query) => query.isFetching);
+        const vectorObservationsIsFetching = vectorObservationsQueries.isFetching;
+
+        const isFetching =
+            vectorDataIsFetching ||
+            vectorStatisticsIsFetching ||
+            historicalVectorDataIsFetching ||
+            vectorObservationsIsFetching;
+
+        return isFetching;
+    });
+
+    const realizationsQueryHasErrorAtom = atom((get) => {
+        const vectorDataQueries = get(vectorDataQueriesAtom);
+
+        return vectorDataQueries.some((query) => query.isError);
+    });
+
+    const statisticsQueryHasErrorAtom = atom((get) => {
+        const vectorStatisticsQueries = get(vectorStatisticsQueriesAtom);
+
+        return vectorStatisticsQueries.some((query) => query.isError);
+    });
+
+    const historicalDataQueryHasErrorAtom = atom((get) => {
+        const historicalVectorDataQueries = get(historicalVectorDataQueriesAtom);
+
+        return historicalVectorDataQueries.some((query) => query.isError);
+    });
+
+    const loadedVectorSpecificationsAndRealizationDataAtom = atom((get) => {
+        const vectorDataQueries = get(vectorDataQueriesAtom);
+        const vectorSpecifications = get(settingsToViewInterface.getAtom("vectorSpecifications"));
+
+        return createLoadedVectorSpecificationAndDataArray(vectorSpecifications, vectorDataQueries);
+    });
+
+    const loadedVectorSpecificationsAndStatisticsDataAtom = atom((get) => {
+        const vectorStatisticsQueries = get(vectorStatisticsQueriesAtom);
+        const vectorSpecifications = get(settingsToViewInterface.getAtom("vectorSpecifications"));
+
+        return createLoadedVectorSpecificationAndDataArray(vectorSpecifications, vectorStatisticsQueries);
+    });
+
+    const loadedVectorSpecificationsAndHistoricalDataAtom = atom((get) => {
+        const historicalVectorDataQueries = get(historicalVectorDataQueriesAtom);
+        const vectorSpecifications = get(settingsToViewInterface.getAtom("vectorSpecifications"));
+
+        return createLoadedVectorSpecificationAndDataArray(vectorSpecifications, historicalVectorDataQueries);
+    });
+
+    const activeTimestampUtcMsAtom = atom<number | null>((get) => {
+        const loadedVectorSpecificationsAndRealizationData = get(loadedVectorSpecificationsAndRealizationDataAtom);
+        const isQueryFetching = get(queryIsFetchingAtom);
+        const userSelectedActiveTimestampUtcMs = get(userSelectedActiveTimestampUtcMsAtom);
+
+        if (
+            !isQueryFetching &&
+            userSelectedActiveTimestampUtcMs === null &&
+            loadedVectorSpecificationsAndRealizationData.length > 0
+        ) {
+            const firstTimeStamp =
+                loadedVectorSpecificationsAndRealizationData.at(0)?.data.at(0)?.timestamps_utc_ms[0] ?? null;
+            return firstTimeStamp;
+        }
+
+        return userSelectedActiveTimestampUtcMs;
+    });
+
+    const colorByParameterAtom = atom<boolean>((get) => {
+        const colorRealizationsByParameter = get(settingsToViewInterface.getAtom("colorByParameter"));
+        const visualizationMode = get(settingsToViewInterface.getAtom("visualizationMode"));
+        const parameterIdent = get(settingsToViewInterface.getAtom("parameterIdent"));
+        const selectedEnsembles = get(settingsToViewInterface.getAtom("selectedEnsembles"));
+
+        return (
+            colorRealizationsByParameter &&
+            visualizationMode === VisualizationMode.INDIVIDUAL_REALIZATIONS &&
+            parameterIdent !== null &&
+            selectedEnsembles.some((ensemble) => ensemble.getParameters().hasParameter(parameterIdent))
+        );
+    });
+
+    return {
+        userSelectedActiveTimestampUtcMs: userSelectedActiveTimestampUtcMsAtom,
+        activeTimestampUtcMs: activeTimestampUtcMsAtom,
+        vectorDataQueries: vectorDataQueriesAtom,
+        vectorStatisticsQueries: vectorStatisticsQueriesAtom,
+        historicalVectorDataQueries: historicalVectorDataQueriesAtom,
+        vectorObservationsQueries: vectorObservationsQueriesAtom,
+        queryIsFetching: queryIsFetchingAtom,
+        realizationsQueryHasError: realizationsQueryHasErrorAtom,
+        statisticsQueryHasError: statisticsQueryHasErrorAtom,
+        historicalDataQueryHasError: historicalDataQueryHasErrorAtom,
+        loadedVectorSpecificationsAndRealizationData: loadedVectorSpecificationsAndRealizationDataAtom,
+        loadedVectorSpecificationsAndStatisticsData: loadedVectorSpecificationsAndStatisticsDataAtom,
+        loadedVectorSpecificationsAndHistoricalData: loadedVectorSpecificationsAndHistoricalDataAtom,
+        colorByParameter: colorByParameterAtom,
+    };
+}