Chaque type de message s’écrit à partir de tables, à raison d’un fichier par événement. Les principes sont communs aux trois messages :
evt_id désigne l’événement,
donc le fichier ; rum_id (PMSI) relie les RUM à leurs
diagnostics et actes ;entete
(version, emetteur,
destinataire…), dont chaque clé peut aussi être une colonne
de evenements, prioritaire ;/ ou commence par @ est un chemin XML
relatif au noeud que décrit la table (`patient/@anonyme`,
`@classant`) ; tout le XSD reste ainsi accessible sans
colonne dédiée ;Les exemples ci-dessous sont les scripts de
inst/exemples/, exécutés tels quels.
Chaque type de message a une unité atomique :
l’objet que le standard sait créer, modifier ou supprimer, parce qu’il
porte l’attribut action et un identifiant. Un message
atomique transporte une seule de ces unités : il peut être accepté,
rejeté ou renvoyé indépendamment des autres.
| message | unité atomique | argument |
|---|---|---|
ePMSI (evenementsPMSI) |
le RUM | par_rum = TRUE |
serveur d’actes (evenementsServeurActes) |
l’acte (acteCCAM) |
par_acte = TRUE |
états patient (evenementsServeurEtatsPatient) |
le diagnostic | par_diagnostic = TRUE |
Par défaut (FALSE), un message porte tout l’événement :
le séjour et ses RUM, l’intervention et ses actes, l’observation et ses
diagnostics. En mode atomique, le contexte (patient, venue…) est répété
dans chaque message, evt_id devient
{evt_id}_{rang} ({evt_id}_{rum_id} pour le
PMSI), et le gabarit filename dispose aussi de
{evt_origine}, {rang} et
{acte_id}.
Pour le PMSI, les diagnostics et les actes d’un RUM n’ont ni action ni identifiant : un message par diagnostic ou par acte n’y aurait pas de sens propre. Pour transmettre des diagnostics un par un, le canal naturel est le message états patient ; pour des actes, le serveur d’actes.
# Atomicité : un message par unité atomique, l'objet qui porte l'attribut `action` et un
# identifiant. Le RUM pour le PMSI, l'acte pour le serveur d'actes, le diagnostic pour les
# états patient. Le contexte (patient, venue…) est répété dans chaque message.
library(hprimxml)
library(tibble)
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "DIM",
destinataire = "DPI",
date_heure_production = as.POSIXct("2024-03-10 08:00:00", tz = "UTC")
)
# contexte commun : patient et venue
contexte <- function(evt_id, ...) {
tibble(evt_id = evt_id, ipp = "190101337", sexe = "F", date_naissance = as.Date("1958-03-12"),
nda = "240000123", venue_date_entree = as.Date("2024-03-04"), ...)
}
# PMSI : un séjour, deux RUM -> deux messages (par_rum)
sejours <- contexte("S1")
rum <- tibble(
evt_id = "S1", rum_id = 1:2, rum_emetteur = c("S1_1", "S1_2"),
um = c("1201", "3405"), um_date_entree = as.Date(c("2024-03-04", "2024-03-06")),
um_mode_entree = c("8", "6"), dp = c("I21.0", "I50.1")
)
write_evenements_pmsi(sejours, rum, entete = entete, out_dir = "sortie/rum", par_rum = TRUE)
# Serveur d'actes : une intervention, trois actes -> trois messages (par_acte)
interventions <- contexte("A1", intervention_id = "INT0001", intervention_uf = "1201")
actes_ccam <- tibble(
evt_id = "A1", acte_id = c("ACT01", "ACT02", "ACT03"),
code = c("DEQP003", "ZBQK002", "YYYY033"), activite = 1L, phase = 0L,
date_execution = as.Date("2024-03-04"), medecin = "01234567"
)
write_evenements_serveur_actes(interventions, actes_ccam, entete = entete, out_dir = "sortie/actes",
par_acte = TRUE, filename = "{evt_origine}_{acte_id}.xml")
# États patient : une observation, deux diagnostics -> deux messages (par_diagnostic)
observations <- contexte("D1", recueil_id = "REC01", recueil_date = as.Date("2024-03-04"),
recueil_uf = "1201")
diagnostics <- tibble(
evt_id = "D1", type = c("dp", "da"), code = c("I21.0", "E11.9"),
date_action = as.POSIXct("2024-03-04 12:00:00", tz = "UTC")
)
write_evenements_etat_patient(observations, diagnostics, entete = entete,
out_dir = "sortie/diagnostics", par_diagnostic = TRUE)
# Bilan : un fichier par unité atomique
compte <- function(fichier, balise) {
x <- paste(readLines(file.path("sortie", fichier), warn = FALSE), collapse = "\n")
lengths(regmatches(x, gregexpr(paste0("<", balise), x, fixed = TRUE)))
}
fichiers <- sort(list.files("sortie", pattern = "\\.xml$", recursive = TRUE))
produits <- tibble(
fichier = fichiers,
RUM = vapply(fichiers, compte, integer(1), balise = "rum ", USE.NAMES = FALSE),
actes_ccam = vapply(fichiers, compte, integer(1), balise = "acteCCAM", USE.NAMES = FALSE),
diagnostics = vapply(fichiers, compte, integer(1), balise = "diagnostic ", USE.NAMES = FALSE)
)| fichier | RUM | actes_ccam | diagnostics |
|---|---|---|---|
| actes/A1_ACT01.xml | 0 | 1 | 0 |
| actes/A1_ACT02.xml | 0 | 1 | 0 |
| actes/A1_ACT03.xml | 0 | 1 | 0 |
| diagnostics/D1_1.xml | 0 | 0 | 1 |
| diagnostics/D1_2.xml | 0 | 0 | 1 |
| rum/S1_1.xml | 1 | 0 | 0 |
| rum/S1_2.xml | 1 | 0 | 0 |
Un rejet porte alors sur une seule unité, qu’on corrige et renvoie
seule ; une suppression se fait en renvoyant l’unité avec
action = "suppression" (colonne action de la
table de l’unité), le même identifiant d’unité et un nouvel identifiant
de message.
write_evenements_pmsi()Entrée par les urgences en cardiologie, mutation en médecine, sortie à domicile : un RSS de deux RUM. Le script écrit le séjour en un fichier, puis en RUM unitaires, et le relit.
# Séjour avec mutation : entrée par les urgences en cardiologie (UM 1201), puis mutation
# en médecine (UM 3405), sortie au domicile. Un RSS de deux RUM, écrit sans namespace,
# d'abord en un fichier par séjour, puis en RUM unitaires (un fichier par RUM).
library(hprimxml)
library(tibble)
ts <- function(x) as.POSIXct(x, tz = "UTC")
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "DIM",
destinataire = "DPI",
date_heure_production = ts("2024-03-10 08:00:00") # par défaut : maintenant
)
# Une ligne par séjour
evenements <- tibble(
evt_id = "S240001", # -> S240001.xml, identifiantMessage S240001
ipp = "190101337",
sexe = "F",
date_naissance = as.Date("1958-03-12"),
nda = "240000123",
venue_date_entree = as.Date("2024-03-04"),
venue_heure_entree = hms::as_hms("10:20:00"),
venue_date_sortie = as.Date("2024-03-09"),
rss_emetteur = "240000123"
)
# Une ligne par RUM
rum <- tibble(
evt_id = "S240001",
rum_id = 1:2,
rum_emetteur = c("S240001_1", "S240001_2"), # identifiant XML du RUM
um = c("1201", "3405"),
um_date_entree = as.Date(c("2024-03-04", "2024-03-06")),
um_heure_entree = hms::as_hms(c("10:20:00", "14:00:00")),
um_mode_entree = c("8", "6"), # domicile, puis mutation
um_provenance = c("5", "1"), # urgences, puis MCO
um_date_sortie = as.Date(c("2024-03-06", "2024-03-09")),
um_mode_sortie = c("6", "8"), # mutation, puis domicile
um_destination = c("1", NA), # vers MCO
`medecinResponsable/noRPPS` = c("10003456789", "10009876543")
)
# Une ligne par diagnostic (le point des codes CIM-10 est retiré à l'écriture)
diagnostics <- tibble(
evt_id = "S240001",
rum_id = c(1L, 1L, 1L, 1L, 2L, 2L, 2L),
type = c("DP", "DAS", "DAS", "DAS", "DP", "DAS", "DAS"),
code = c("I21.0", "E11.9", "I10", "E78.0", "I50.1", "N18.3", "E11.9")
)
# Une ligne par acte CCAM
actes_ccam <- tibble(
evt_id = "S240001",
rum_id = c(1L, 1L, 2L),
code = c("DEQP003", "ZBQK002", "DEQP003"),
phase = 0L,
activite = 1L,
date_realisation = ts(c("2024-03-04 10:45:00", "2024-03-04 11:30:00", "2024-03-06 15:00:00"))
)
# Un fichier par séjour : sortie/sejour/S240001.xml
write_evenements_pmsi(
evenements, rum, diagnostics, actes_ccam,
entete = entete, out_dir = "sortie/sejour", xmlns = NULL
)
# RUM unitaires, avec marqueur de dépôt complet :
# sortie/rum/S240001_1.xml puis S240001_1.ok, sortie/rum/S240001_2.xml puis S240001_2.ok
write_evenements_pmsi(
evenements, rum, diagnostics, actes_ccam,
entete = entete, out_dir = "sortie/rum", xmlns = NULL, par_rum = TRUE, fichier_ok = TRUE
)
# Relecture : les mêmes tables (ici, diagnostics en colonnes de `rum`)
relu <- read_evenements_pmsi("sortie/sejour", format_diagnostics = "colonnes")
rum_relu <- relu$rum[, c("evt_id", "rum_id", "rum_emetteur", "um", "dp", "das")]Les quatre tables : evenements (une ligne par séjour),
rum (une ligne par RUM), diagnostics (format
long) et actes_ccam (une ligne par acte CCAM).
| evt_id | ipp | sexe | date_naissance | nda | venue_date_entree | venue_heure_entree | venue_date_sortie | rss_emetteur |
|---|---|---|---|---|---|---|---|---|
| S240001 | 190101337 | F | 1958-03-12 | 240000123 | 2024-03-04 | 10:20:00 | 2024-03-09 | 240000123 |
| evt_id | rum_id | rum_emetteur | um | um_date_entree | um_heure_entree | um_mode_entree | um_provenance | um_date_sortie | um_mode_sortie | um_destination | medecinResponsable/noRPPS |
|---|---|---|---|---|---|---|---|---|---|---|---|
| S240001 | 1 | S240001_1 | 1201 | 2024-03-04 | 10:20:00 | 8 | 5 | 2024-03-06 | 6 | 1 | 10003456789 |
| S240001 | 2 | S240001_2 | 3405 | 2024-03-06 | 14:00:00 | 6 | 1 | 2024-03-09 | 8 | 10009876543 |
| evt_id | rum_id | type | code |
|---|---|---|---|
| S240001 | 1 | DP | I21.0 |
| S240001 | 1 | DAS | E11.9 |
| S240001 | 1 | DAS | I10 |
| S240001 | 1 | DAS | E78.0 |
| S240001 | 2 | DP | I50.1 |
| S240001 | 2 | DAS | N18.3 |
| S240001 | 2 | DAS | E11.9 |
| evt_id | rum_id | code | phase | activite | date_realisation |
|---|---|---|---|---|---|
| S240001 | 1 | DEQP003 | 0 | 1 | 2024-03-04 10:45:00 |
| S240001 | 1 | ZBQK002 | 0 | 1 | 2024-03-04 11:30:00 |
| S240001 | 2 | DEQP003 | 0 | 1 | 2024-03-06 15:00:00 |
Le second RUM, en RUM unitaire :
<rum action="creation">
<dateAction>2024-03-06T00:00:00</dateAction>
<identifiant>
<emetteur>S240001_2</emetteur>
</identifiant>
<medecinResponsable>
<noRPPS>10009876543</noRPPS>
</medecinResponsable>
<uniteMedicale>
<code>3405</code>
<entree mode="6" complementMode="1">
<date>2024-03-06</date>
<heure>14:00:00</heure>
</entree>
<sortie mode="8">
<date>2024-03-09</date>
</sortie>
</uniteMedicale>
<diagnostics>
<diagnosticPrincipal>
<codeCim10>I501</codeCim10>
</diagnosticPrincipal>
<diagnosticsSignificatifs>
<diagnosticSignificatif>
<codeCim10>N183</codeCim10>
</diagnosticSignificatif>
<diagnosticSignificatif>
<codeCim10>E119</codeCim10>
</diagnosticSignificatif>
</diagnosticsSignificatifs>
</diagnostics>
<actes>
<acte>
<CCAM>
<codeActe>DEQP003</codeActe>
<codePhase>0</codePhase>
<codeActivite>1</codeActivite>
<quantite>1</quantite>
<dateRealisation>2024-03-06T15:00:00</dateRealisation>
</CCAM>
</acte>
</actes>
</rum>Trois formes équivalentes, qui produisent le même fichier : la table
diagnostics en format long ; des colonnes dp,
dr, das, dad dans
rum, avec das et dad en colonne
liste ; ou ces mêmes colonnes avec das en chaîne séparée
par des virgules.
# Trois façons équivalentes de fournir les diagnostics d'un RUM avec plusieurs DAS.
# Les trois écritures produisent exactement le même fichier XML.
library(hprimxml)
library(tibble)
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "DIM",
destinataire = "DPI",
date_heure_production = as.POSIXct("2024-03-10 08:00:00", tz = "UTC")
)
evenements <- tibble(
evt_id = "S240002", ipp = "190101338", sexe = "M",
date_naissance = as.Date("1951-07-02"), nda = "240000124",
venue_date_entree = as.Date("2024-03-04"), rss_emetteur = "240000124"
)
rum <- tibble(
evt_id = "S240002", rum_id = 1L, um = "1201",
um_date_entree = as.Date("2024-03-04"), um_mode_entree = "8"
)
# 1. Format long : une table `diagnostics`, une ligne par code
diagnostics <- tibble(
evt_id = "S240002",
rum_id = 1L,
type = c("DP", "DAS", "DAS", "DAS", "DAS"),
code = c("I21.0", "E11.9", "I10", "E78.0", "N18.3")
)
write_evenements_pmsi(evenements, rum, diagnostics, entete = entete, out_dir = "sortie/long")
# 2. Colonnes dans `rum`, DAS en colonne liste
rum_liste <- rum
rum_liste$dp <- "I21.0"
rum_liste$das <- list(c("E11.9", "I10", "E78.0", "N18.3"))
write_evenements_pmsi(evenements, rum_liste, entete = entete, out_dir = "sortie/liste")
# 3. Colonnes dans `rum`, DAS en chaîne séparée par des virgules
rum_chaine <- rum
rum_chaine$dp <- "I21.0"
rum_chaine$das <- "E11.9, I10, E78.0, N18.3"
write_evenements_pmsi(evenements, rum_chaine, entete = entete, out_dir = "sortie/chaine")
# Une chaîne se convertit aussi en liste d'une ligne : strsplit(rum_chaine$das, ", ")
fichiers <- lapply(c("long", "liste", "chaine"), function(f)
readBin(file.path("sortie", f, "S240002.xml"), "raw", 1e6))
stopifnot(identical(fichiers[[1]], fichiers[[2]]), identical(fichiers[[1]], fichiers[[3]]))Les deux approches se combinent (DP en colonne, DAS en format long…), mais un DP ou un DR donné deux fois est refusé.
.okAvec par_rum = TRUE, chaque RUM devient un message. On
reprend ici les tables du séjour avec mutation, conservées dans la liste
sejour. Trois règles encadrent le nommage :
{evt_id}_{rum_id} par défaut, ou le
résultat du gabarit filename, qui dispose aussi de
{rss_id} et {rum_id} ;-, ,, _)
;write_evenements_pmsi(sejour$evenements, sejour$rum, sejour$diagnostics, sejour$actes_ccam,
entete = sejour$entete, out_dir = "depot", xmlns = NULL, par_rum = TRUE,
filename = "R{rss_id}_{rum_id}.xml", fichier_ok = TRUE)
list.files("depot")
#> [1] "RS240001_1.ok" "RS240001_1.xml" "RS240001_2.ok" "RS240001_2.xml"Avec fichier_ok = TRUE, chaque .xml est
d’abord écrit sous un nom temporaire puis renommé, et son
.ok vide est déposé en dernier : le destinataire ne voit
jamais un fichier incomplet.
colmapcolmap renomme les colonnes d’une extraction existante
vers les noms attendus :
rum_source <- tibble::tibble(NAS = "S240001", NORUM = 1:2, CDURM = c("1201", "3405"),
D8EEUE = as.Date(c("2024-03-04", "2024-03-06")), MDEEUE = c("8", "6"),
DP = c("I21.0", "I50.1"))
f <- write_evenements_pmsi(
sejour$evenements, rum_source, entete = sejour$entete, out_dir = "colmap", xmlns = NULL,
colmap = list(NAS = "evt_id", NORUM = "rum_id", CDURM = "um", D8EEUE = "um_date_entree",
MDEEUE = "um_mode_entree", DP = "dp")
)
basename(f)
#> [1] "S240001.xml"write_evenements_serveur_actes()Deux tables : evenements (patient, venue, intervention
et demande) et actes_ccam (une ligne par acte CCAM, avec
son exécutant). Le script régénère le fichier d’exemple du projet.
# Régénère data/xml_tests/actes/00001.xml : une intervention et quatre actes CCAM.
library(hprimxml)
library(tibble)
ts <- function(x) as.POSIXct(x, tz = "UTC")
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "TEST",
destinataire = NULL,
acquittement_attendu = "oui",
commentaire = "HPRIM-TEST",
date_heure_production = ts("2024-01-01 01:01:01")
)
# Une ligne par événement : patient, venue, intervention et demande
evenements <- tibble(
evt_id = "00001_acte",
ipp = "123456789", ipp_recepteur = "123456789",
sexe = "M", nom_usuel = "SANDWICK", prenom = "JOHN",
date_naissance = as.Date("1970-01-01"),
nda = "987654321", nda_recepteur = "987654321",
venue_date_entree = as.Date("2024-01-01"), venue_heure_entree = hms::as_hms("08:00:00"),
venue_uf_responsable = "4321",
`venue/@prive` = "non",
intervention_id = "000000000001",
intervention_date_debut = as.Date("2024-01-01"), intervention_heure_debut = hms::as_hms("08:10:00"),
intervention_date_fin = as.Date("2024-01-01"), intervention_heure_fin = hms::as_hms("09:00:00"),
intervention_uf = "4321",
demande_date = as.Date("2023-12-25"), demande_heure = hms::as_hms("02:30:00"), demande_uf = "4321"
)
# Une ligne par acte CCAM
actes_ccam <- tibble(
evt_id = "00001_acte",
acte_id = c("121212", "121213", "121214", "121215"),
code = c("EBLA003", "YYYY033", "EPLF002", "NFKA006"),
activite = 1L, phase = 0L,
date_execution = as.Date("2024-01-01"), heure_execution = hms::as_hms("08:10:00"),
medecin = "01234567", uf = "4321",
quantite = "1", # nombre5 : chaîne de chiffres dans le XSD
facturable = "oui", valide = "oui"
)
fichiers <- write_evenements_serveur_actes(
evenements, actes_ccam,
entete = entete,
out_dir = "sortie/actes", # -> sortie/actes/00001_acte.xml
validate_xsd = "warn"
)| evt_id | acte_id | code | activite | phase | date_execution | heure_execution | medecin | uf | quantite | facturable | valide |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 00001_acte | 121212 | EBLA003 | 1 | 0 | 2024-01-01 | 08:10:00 | 01234567 | 4321 | 1 | oui | oui |
| 00001_acte | 121213 | YYYY033 | 1 | 0 | 2024-01-01 | 08:10:00 | 01234567 | 4321 | 1 | oui | oui |
| 00001_acte | 121214 | EPLF002 | 1 | 0 | 2024-01-01 | 08:10:00 | 01234567 | 4321 | 1 | oui | oui |
| 00001_acte | 121215 | NFKA006 | 1 | 0 | 2024-01-01 | 08:10:00 | 01234567 | 4321 | 1 | oui | oui |
Le premier acte produit :
<acteCCAM action="creation" facturable="oui" valide="oui">
<identifiant>
<emetteur>121212</emetteur>
</identifiant>
<codeActe>EBLA003</codeActe>
<codeActivite>1</codeActivite>
<codePhase>0</codePhase>
<execute>
<date>2024-01-01</date>
<heure>08:10:00</heure>
</execute>
<executant>
<medecins>
<medecinExecutant principal="oui">
<medecin>
<identification>
<code>01234567</code>
</identification>
</medecin>
</medecinExecutant>
</medecins>
<uniteFonctionnelle>
<code>4321</code>
</uniteFonctionnelle>
</executant>
<quantite>1</quantite>
</acteCCAM>quantite est ici une chaîne : le XSD la définit comme
nombre5, une chaîne de chiffres.
Un message serveur d’actes peut aussi porter des actes NGAP, seuls ou
à côté des actes CCAM : table actes_ngap, une ligne par
acte, passée par l’argument actes_ngap (la table
actes_ccam devient alors facultative). Colonnes
obligatoires : evt_id, acte_id,
lettre_cle, coefficient,
date_execution, medecin ; facultatives :
heure_execution, uf, quantite,
denombrement, nabm (codes NABM : colonne liste
ou chaîne séparée par des virgules), montant_total,
numero_forfait_technique,
numero_agrement_appareil (forfaits techniques),
action, facturable, valide. Le
reste passe par des colonnes-chemins relatives à acteNGAP.
Chaque acte NGAP porte sa propre action : avec
par_acte = TRUE, les actes CCAM puis NGAP d’un événement
donnent chacun un message.
Exemple (lettres-clés et codes illustratifs) :
# Actes NGAP dans un message serveur d'actes : une consultation, un forfait technique et un
# acte de biologie avec ses codes NABM. Lettres-clés, coefficients, codes et montants sont
# illustratifs : à remplacer par ceux de vos référentiels.
library(hprimxml)
library(tibble)
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "DIM",
destinataire = "DPI",
date_heure_production = as.POSIXct("2024-03-10 08:00:00", tz = "UTC")
)
# Contexte : une ligne par événement (patient, venue)
evenements <- tibble(
evt_id = "EXT0001",
ipp = "190101337", sexe = "F", date_naissance = as.Date("1958-03-12"),
nda = "240000125", venue_date_entree = as.Date("2024-03-08")
)
# Actes NGAP : une ligne par acte
actes_ngap <- tibble(
evt_id = "EXT0001",
acte_id = c("NG01", "NG02", "NG03"),
lettre_cle = c("CS", "FTN", "B"), # consultation, forfait technique, biologie
coefficient = c("1", "1", "26"),
date_execution = as.Date("2024-03-08"),
heure_execution = hms::as_hms(c("09:30:00", "10:15:00", "11:00:00")),
medecin = "10003456789",
uf = c("2101", "3301", "5201"),
montant_total = c("30.00", "70.00", "7.02"), # montants en euros (illustratifs)
numero_forfait_technique = c(NA, "1", NA), # forfait technique
numero_agrement_appareil = c(NA, "12345678901234", NA),
nabm = list(NULL, NULL, c(1104L, 593L)) # codes NABM de l'acte de biologie
)
# Un message avec les trois actes : sortie/ngap/EXT0001.xml
write_evenements_serveur_actes(evenements, actes_ngap = actes_ngap, entete = entete,
out_dir = "sortie/ngap")
# Un message par acte (unité atomique) : sortie/ngap_atomique/EXT0001_1.xml… _3.xml
write_evenements_serveur_actes(evenements, actes_ngap = actes_ngap, entete = entete,
out_dir = "sortie/ngap_atomique", par_acte = TRUE)
# Relecture : la table actes_ngap, codes NABM compris
relu <- read_evenements_serveur_actes("sortie/ngap")$actes_ngapLa table actes_ngap relue :
| evt_id | acte_id | lettre_cle | coefficient | quantite | denombrement | date_execution | heure_execution | medecin | uf | nabm | montant_total | numero_forfait_technique | numero_agrement_appareil | action | facturable | valide |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| EXT0001 | NG01 | CS | 1 | 2024-03-08 | 09:30:00 | 10003456789 | 2101 | [] | 30.00 | creation | ||||||
| EXT0001 | NG02 | FTN | 1 | 2024-03-08 | 10:15:00 | 10003456789 | 3301 | [] | 70.00 | 1 | 12345678901234 | creation | ||||
| EXT0001 | NG03 | B | 26 | 2024-03-08 | 11:00:00 | 10003456789 | 5201 | [1104, 593] | 7.02 | creation |
write_evenements_etat_patient()Le message porte, au choix, des diagnostics, un IGS2, des
dépendances… mais un seul de ces contenus à la fois. Il exige aussi un
repère : une intervention (intervention_*), une date
d’observation (date_observation) ou un recueil
(recueil_id, recueil_date,
recueil_heure, recueil_uf). Le recueil est le
plus précis : il porte l’UF où les états ont été observés, qui permet au
récepteur de retrouver le RUM, même un jour de mutation. En 2.4, un
élément <divers/> est émis automatiquement.
# Régénère data/xml_tests/etat_patient/00001.xml : diagnostics DP et DR.
library(hprimxml)
library(tibble)
ts <- function(x) as.POSIXct(x, tz = "UTC")
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "TEST",
destinataire = NULL,
acquittement_attendu = "non",
commentaire = "HPRIM-TEST",
date_heure_production = ts("2024-01-01 01:01:01")
)
# Une ligne par événement : patient, venue, intervention
# (ici, les colonnes-chemins sont relatives à la racine du message)
evenements <- tibble(
evt_id = "00001_esep",
ipp = "123456789", ipp_recepteur = "123456789",
sexe = "M", nom_usuel = "SANDWICK", prenom = "JOHN",
date_naissance = as.Date("1970-01-01"),
nda = "987654321", nda_recepteur = "987654321",
venue_date_entree = as.Date("2024-01-01"), venue_heure_entree = hms::as_hms("08:00:00"),
venue_uf_responsable = "4321",
intervention_id = "000000000001", intervention_uf = "4321",
`patient/@confidentiel` = "non", `venue/@prive` = "non",
`patient/identifiant/emetteur/@etat` = "permanent",
`patient/identifiant/emetteur/@portee` = "local",
`patient/identifiant/emetteur/@referent` = "non",
`patient/identifiant/recepteur/@etat` = "permanent",
`patient/identifiant/recepteur/@portee` = "local",
`patient/identifiant/recepteur/@referent` = "non"
)
# Une ligne par diagnostic ; type dans dp, dr, da, ds, dd, fpc, mm, ae
diagnostics <- tibble(
evt_id = "00001_esep",
type = c("dp", "dr"),
code = c("Z511", "C10"),
date_action = ts("2024-01-01 08:10:00")
)
fichiers <- write_evenements_etat_patient(
evenements, diagnostics,
entete = entete,
out_dir = "sortie/etat_patient", # -> sortie/etat_patient/00001_esep.xml
validate_xsd = "warn"
)Chaque item de l’IGS2 est un attribut de <igs2>
portant une classe (age="60A69"…), plus le
score global valeurGlobale. Le script part des pires
valeurs des 24 premières heures et applique la grille de la SFAR (https://sfar.org/scores/igs2.php, d’après Le Gall JR et
coll., JAMA 1993; 270: 2957-2963). L’IGS2 passe entièrement par
des colonnes-chemins (`igs2/@age`,
`igs2/valeurGlobale`…) ; le repère est un recueil dans l’UF
de réanimation.
# IGS2 détaillé dans un message états patient (evenementsServeurEtatsPatient).
# Des mesures brutes (pires valeurs des 24 premières heures), on déduit pour chaque item
# la classe attendue par le XSD (attribut de <igs2>) et ses points, puis le score global.
# Un fichier par patient : l'élément <igs2> n'est pas répétable dans un message.
library(hprimxml)
library(tibble)
ts <- function(x) as.POSIXct(x, tz = "UTC")
entete <- list(
version = "2.00", # version HPRIM XML des messages
emetteur = "REA",
destinataire = "DIM",
date_heure_production = ts("2024-03-06 09:00:00")
)
# Pires valeurs des 24 premières heures, une ligne par patient
mesures <- tibble(
evt_id = c("IGS240001", "IGS240002"),
age = c(67, 82),
frequence_cardiaque = c(128, 105), # /min
pas = c(85, 210), # pression artérielle systolique, mmHg
temperature = c(38.2, 39.4), # °C
ventile = c(TRUE, FALSE), # ventilation mécanique ou CPAP
pao2_fio2 = c(180, NA), # mmHg, si ventilé
diurese = c(0.8, 1.6), # L/24 h
uree = c(18, 8), # mmol/L
leucocytes = c(14, 22), # 10³/mm³
kaliemie = c(4.1, 5.4), # mmol/L
natremie = c(132, 147), # mmol/L
hco3 = c(17, 22), # mmol/L
bilirubine = c(25, 110), # µmol/L
ictere = c(FALSE, TRUE), # la bilirubine ne compte que si ictère
glasgow = c(13, 15),
maladie_chronique = c("aucune", "cancerMetastatique"),
mode_admission = c("medecine", "chirUrgente")
)
# Barème IGS2 : attribut XSD -> mesure, bornes, points par classe XSD
# Source : grille et définitions de la SFAR, https://sfar.org/scores/igs2.php
# (Le Gall JR et coll., JAMA 1993; 270: 2957-2963). Recueil sur les 24 heures suivant
# l'admission : valeur la plus défavorable de chaque item ; Glasgow estimé avant sédation ;
# diurèse ramenée à 24 h si le séjour est plus court ; en cas d'arrêt cardiaque, FC 0,
# PAS 0 et Glasgow < 6. Unités : urée en mmol/L (seuils SFAR en g/L : 0,6 et 1,8),
# leucocytes en 10³/mm³, bilirubine en µmol/L (seuils en mg/L : 40 et 60).
# Les bornes sont fermées à gauche : 40 tombe dans « 40A59 ».
BAREME <- list(
age = list("age", c(40, 60, 70, 75, 80),
c(inferieurA40 = 0, `40A59` = 7, `60A69` = 12, `70A74` = 15, `75A79` = 16,
superieurEgalA80 = 18)),
frequenceCardiaque = list("frequence_cardiaque", c(40, 70, 120, 160),
c(inferieurA40 = 11, `40A69` = 2, `70A119` = 0, `120A159` = 4, superieurEgalA160 = 7)),
tensionArterielleSystolique = list("pas", c(70, 100, 200),
c(inferieurA70 = 13, `70A99` = 5, `100A199` = 0, superieurEgalA200 = 2)),
temperature = list("temperature", 39, c(inferieurA39 = 0, superieurEgalA39 = 3)),
paO2_FIO2 = list("pao2_fio2", c(100, 200), c(inferieurA100 = 11, `100A199` = 9, superieurEgalA200 = 6)),
diurese = list("diurese", c(0.5, 1), c(`inferieurA0,5` = 11, `0,5A0,999` = 4, superieurA1 = 0)),
ureeSanguine = list("uree", c(10, 30), c(inferieurA10 = 0, `10A29,9` = 6, superieurA30 = 10)),
leucocytes = list("leucocytes", c(1, 20), c(inferieurA1 = 12, `1A19,9` = 0, superieurEgalA20 = 3)),
kaliemie = list("kaliemie", c(3, 5), c(inferieurA3 = 3, `3A4,9` = 0, superieurEgalA5 = 3)),
natremie = list("natremie", c(125, 145), c(inferieurA125 = 5, `125A144` = 0, superieurEgalA145 = 1)),
HCO3 = list("hco3", c(15, 20), c(inferieurA15 = 6, `15A19` = 3, superieurEgalA20 = 0)),
bilirubine = list("bilirubine", c(68.4, 102.6),
c(`inferieurA68,4` = 0, `68,4A102,5` = 4, `superieurA102,6` = 9)),
scoreGlasgow = list("glasgow", c(6, 9, 11, 14),
c(inferieurA6 = 26, `6A8` = 13, `9A10` = 7, `11A13` = 5, `14A18` = 0))
)
POINTS_QUALITATIFS <- list(
maladieChronique = list("maladie_chronique",
c(aucune = 0, cancerMetastatique = 9, maladieHematologiqueMaligne = 10, sida = 17)),
modeAdmission = list("mode_admission", c(chirProgrammee = 0, medecine = 6, chirUrgente = 8))
)
# Classe d'une mesure : libelles[i] si bornes[i-1] <= mesure < bornes[i]
classer <- function(x, bornes, libelles) {
as.character(cut(x, c(-Inf, bornes, Inf), labels = libelles, right = FALSE))
}
igs2 <- mesures
for (attr in names(BAREME)) {
b <- BAREME[[attr]]
classe <- classer(mesures[[b[[1]]]], b[[2]], names(b[[3]]))
if (attr == "paO2_FIO2") classe <- ifelse(mesures$ventile, classe, "rien") # ni ventilé ni CPAP
if (attr == "bilirubine") classe <- ifelse(mesures$ictere, classe, "inferieurA68,4") # non ictérique
igs2[[attr]] <- classe
igs2[[paste0("points_", attr)]] <- as.integer(c(b[[3]], rien = 0)[classe])
}
for (attr in names(POINTS_QUALITATIFS)) {
q <- POINTS_QUALITATIFS[[attr]]
igs2[[attr]] <- mesures[[q[[1]]]]
igs2[[paste0("points_", attr)]] <- as.integer(q[[2]][mesures[[q[[1]]]]])
}
igs2$valeurGlobale <- as.integer(rowSums(igs2[grep("^points_", names(igs2))]))
attributs <- c(names(BAREME), names(POINTS_QUALITATIFS))
# Patient et venue, une ligne par message
evenements <- tibble(
evt_id = c("IGS240001", "IGS240002"),
ipp = c("190101337", "190101338"), sexe = c("M", "F"),
date_naissance = as.Date(c("1956-05-14", "1941-11-02")),
nda = c("240000123", "240000124"), venue_date_entree = as.Date("2024-03-05"),
# repère du message : le recueil, avec sa date et l'UF de réanimation où les états ont
# été observés (le récepteur retrouve ainsi le RUM, même un jour de mutation)
recueil_id = c("REC240001", "REC240002"),
recueil_date = as.Date("2024-03-06"),
recueil_uf = "4501"
)
# L'IGS2 passe par des colonnes-chemins relatives à la racine du message
evenements$`igs2/@action` <- "creation"
for (a in attributs) evenements[[paste0("igs2/@", a)]] <- igs2[[a]]
evenements$`igs2/dateAction` <- ts("2024-03-06 08:00:00")
evenements$`igs2/valeurGlobale` <- igs2$valeurGlobale
fichiers <- write_evenements_etat_patient(
evenements, NULL, # pas de table de diagnostics ici
entete = entete,
out_dir = "sortie/igs2", # -> sortie/igs2/IGS240001.xml, IGS240002.xml
xmlns = NULL
)
# Contrôle : une ligne par item, avec la classe et les points de chaque patient
controle <- tibble(item = attributs)
for (i in seq_len(nrow(igs2))) {
controle[[paste0("classe_", igs2$evt_id[i])]] <- unlist(igs2[i, attributs])
}
for (i in seq_len(nrow(igs2))) {
controle[[paste0("points_", igs2$evt_id[i])]] <- unlist(igs2[i, paste0("points_", attributs)])
}La table de contrôle, avec la classe et les points de chaque item :
| item | classe_IGS240001 | classe_IGS240002 | points_IGS240001 | points_IGS240002 |
|---|---|---|---|---|
| age | 60A69 | superieurEgalA80 | 12 | 18 |
| frequenceCardiaque | 120A159 | 70A119 | 4 | 0 |
| tensionArterielleSystolique | 70A99 | superieurEgalA200 | 5 | 2 |
| temperature | inferieurA39 | superieurEgalA39 | 0 | 3 |
| paO2_FIO2 | 100A199 | rien | 9 | 0 |
| diurese | 0,5A0,999 | superieurA1 | 4 | 0 |
| ureeSanguine | 10A29,9 | inferieurA10 | 6 | 0 |
| leucocytes | 1A19,9 | superieurEgalA20 | 0 | 3 |
| kaliemie | 3A4,9 | superieurEgalA5 | 0 | 3 |
| natremie | 125A144 | superieurEgalA145 | 0 | 1 |
| HCO3 | 15A19 | superieurEgalA20 | 3 | 0 |
| bilirubine | inferieurA68,4 | superieurA102,6 | 0 | 9 |
| scoreGlasgow | 11A13 | 14A18 | 5 | 0 |
| maladieChronique | aucune | cancerMetastatique | 0 | 9 |
| modeAdmission | medecine | chirUrgente | 6 | 8 |
<recueil>
<identifiant>
<emetteur>REC240001</emetteur>
</identifiant>
<date>2024-03-06</date>
<uniteFonctionnelle>
<code>4501</code>
</uniteFonctionnelle>
</recueil>
<igs2 action="creation" modeAdmission="medecine" maladieChronique="aucune" scoreGlasgow="11A13" age="60A69" tensionArterielleSystolique="70A99" frequenceCardiaque="120A159" temperature="inferieurA39" paO2_FIO2="100A199" diurese="0,5A0,999" ureeSanguine="10A29,9" leucocytes="1A19,9" kaliemie="3A4,9" natremie="125A144" HCO3="15A19" bilirubine="inferieurA68,4">
<dateAction>2024-03-06T08:00:00</dateAction>
<valeurGlobale>54</valeurGlobale>
</igs2>Les règles de recueil (pires valeurs, Glasgow avant sédation, bilirubine seulement en cas d’ictère…) restent celles de votre service.
| argument | valeurs | effet |
|---|---|---|
xmlns |
HPRIM_NS (défaut), NULL,
"" |
namespace HPRIM ; aucune déclaration ; xmlns=""
littéral |
validate_xsd |
"error" (défaut), "warn",
FALSE |
contrôle de chaque fichier contre son XSD |
version |
"2.4", "2.00"… |
version du schéma ; sinon entete$version, sinon
2.4 |
filename |
gabarit ou fonction | nom de chaque fichier |
fichier_ok |
FALSE (défaut), TRUE |
dépose un .ok vide une fois chaque .xml
complet |
identifiant_egal_nom_fichier |
TRUE (défaut), FALSE |
identifiantMessage = nom du fichier |
colmap |
list(ancien = "nouveau") |
renommage de colonnes |
encoding |
"UTF-8" (défaut), "ISO-8859-1" |
encodage des fichiers |
par_rum (PMSI), par_acte (actes),
par_diagnostic (états patient) |
FALSE (défaut), TRUE |
un message par unité atomique |