clinFHIR stock take

I’ve been asked to give a short talk about clinFHIR to a course at Johns Hopkins this month – what it is and what you’d use it for, so to organize my thoughts I decided to write a ‘stock take’ of clinFHIR modules. This is actually part of a project I’ve been working on for a little while – learning FHIR with clinFHIR – so it’s a perfect time to be doing it.

The idea for clinFHIR started shortly after FHIR started to gain prominence within HL7 – coming up to 10 years ago now. The technical folk understood what the developers were trying to do – utilize internet standards to share healthcare data – but it was harder for the clinical folk to gain that understanding and appreciate the significance.

clinFHIR (Clinical FHIR) was envisaged as a way to visualize FHIR – particularly resources and the references between them – so that the committees within HL7 responsible for authoring resources could advance their development. We worked closely with the members of the ‘Patient Care’ committee in particular – they had sessions at most Working Group Meetings called ‘Clinicians on FHIR’, and we developed clinFHIR as one of the main tools for them.

(And I’d like to recognize all the work they put into this – it was an on-going balance between evolving the application to meet identified needs, and dealing with the bugs that a rapid development cycle brings!)

Read more of this post

Using Logical Models with conman Scenario Builder

The scenario builder in conman is intended to allow you to build ‘graphs’ of resources to tell some clinical story – or scenario. By default it uses instances of core resource types (though profile support is on the road map), but you can also use instances of logical models that have been created in the clinFHIR Logical Modeller as well.

The main reason why you would do this, to to be able to add elements to a resource instance that is not in the core resource. This will become an extension in a ‘real’ resource, but it’s handy to be able to do this ahead of creating the extension (and the definition) to make sure that the new element is needed – and validate properties like the data type, multiplicity & so forth. You might also do this is proposing a change to the core specification as well.

However, it’s important to remember that instances of these models will not be saved on a FHIR server – the elements will either be dropped or the instance rejected, depending on the server.

The overall process to do this is as follows:

  1. Build the model using the clinFHIR Logical Modeler. Generally, you’d base the model on a core type and amend as desired.
  2. Add the model to the scenario
  3. Build the scenario

Lets look at each of these steps.

1. Build the model

2. Add the model to the scenario

This is done in the scenario definition (and must be added here before being used in a graph). In the ‘types’ tab, there is a section for Logical models just below the core types. There’s a plus (‘+’) symbol to the right, clicking that will bring up the following dialog:

Screen Shot 2018-09-05 at 8.43.45 AM


The drop down will show all the Logical models that have been created on the conformance server defined in the track description. Selecting one of these, along with a brief description is the easiest way to add the model.

However, if the model you want is not on the conformance server, then you can add a url to it manually in the second box. Note this is the direct url to the model – conman will attempt to load it directly from that location. This has the advantage that it doesn’t need to be on a FHIR server, as long as it is directly accessible (Though you do need the full url).

If you update the model after adding it to the scenario, then you don’t need to add it again – the most recent version is always used when adding an instance to a graph (see note below).

3. Build the scenario

This is the same as using core types – you just select the model rather than the core type in the selector, and it works in the same way as a core type with respect to adding data and creating references. But there are a few things to watch out for.

  • The structure of the model in the graph is the structure as it exists when it is added to the graph. If you update the model after adding it, it will NOT be updated.


Making comments on Logical Models in conMan

When using the conMan Logical model review application, it’s possible for a user to make a note against an element in the form (in fact, collecting these comments is a primary purpose for perfoming the review. Here’s an example where a note has been entered against the reportIdentifier field:


If you want to review the notes that users have made, then select the ‘Summary of LM Review’ tab. There are 2 views possible:

  • A combined view of all notes made by all reviewers for all scenarios
  • Notes by all reviewers for a single scenario

In either case, the first thing to do is to click the ‘Refresh’ button to the upper right. This will collect the appropriate reviews from the server, and collate the display. This can be a lengthy process, especially for the combined view. Here’s an example from the New Zealand ‘Adverse Reactions’ project:

You can see that this is presented as a table with the elements that had had notes made as rows, and individual reviewers notes in columns. Note that in the combined view (which is the first tab) the comments are ‘aggregated’ by the element path – regardless of which scenario the user entered the comment into.

It is possible for someone to make a comment against a note. This is useful when the note requires clarification or can be explained. If comments have been made for a note, then the number of comments is displayed as a ‘badge’ to the right of the note. To see the comments, simply move the mouse over the cell and the comments will be displayed in a popup like this:

There can be any number of comments against a note. To see more detail of the comment (like when it was made) click the mouse while the popover is displayed, and an edit dialog appears.

This shows the further details, and also allows a new comment to be entered.



A simple map

In the previous post, we described a simple application to help develop transformation maps conformant with the FHIR mapping language. Let’s now take a look at using that app to actually develop a simple map.

Read more of this post

FHIR enabling an Immunization registry – part 4

So we’ve talked about how to represent an immunization program both in the abstract (the overall definition of a national plan) and the specific (the plan applied to an individual). In addition, we discussed how to submit the actual administrations to the registry.

What we haven’t really talked about is how to measure the performance of an individual against the plan.

Read more of this post

FHIR enabling an immunization registry

In New Zealand (and other places as well I expect) we’ve had a national registry for immunizations for a number of years – the National Immunization Register or NIR

It’s currently fed by HL7 version 2 messages and there’s a User Interface for authorized users, but there was always a plan to introduce a FHIR interface to some point – something that has been accelerated by the current COVID pandemic of course.

Read more of this post

Creating models with the Logical Modeler

It’s been a while since we talked about the clinFHIR Logical Modeler, and I’ve had a few questions about it, so I thought an update might be in order.

The term ‘Logical Model’ can be used in different ways (much like ‘Profile’) so let’s first define just what we are talking about. Basically, it’s just a hierarchical model of data – much like you see in any of the core FHIR resource types – with the exception that the model does not have to align with any of the core types. Other than the requirement that you must use the FHIR datatypes, there are no limits on the complexity of the model you create (though overly complex models can be hard to understand – or use).

In this post we’ll talk about the general aspects of using the modeler – subsequent posts will go into more detail about how to build them.

Read more of this post

FHIR enabling an immunization registry – part 2

In the previous post we discussed how an immunization registry might receive Immunization resources documenting the administration of vaccines to an individual (complicated), and how to expose those resources to a client (easy).

But vaccine administrations don’t exist in a vacuum – they’re generally related to some particular plan consisting of multiple administrations of different vaccines over a period of time with the intent of providing the recipient with protection against specific diseases. (And, as COVID has emphasized, protection of the planetary population as a whole).

So we need a way to represent that general plan, customize it for an individual – and then a way to link individual vaccine administrations back to that plan so we can be sure that an individual is receiving the vaccinations they should be. And we want to be able to report on this administration at a population level as well as the individual.

That’s a bit more complicated than it might appear.

Read more of this post

Using prototypes in app design

I’ve always been fond of creating functional prototypes when designing apps. There are a number of advantages over simply documenting what the app should do:

  • It means that the users (e.g. clinicians) get to try out something that actually works (sort of) before ‘signing off’ on the requirements. This reduces the chance of delivering something that doesn’t quite meet their needs.
  • It helps significantly with the FHIR design. Assuming that the app actually communicates with a FHIR back end (which can be one of the freely available reference servers such as HAPI), then it validates the resource design (which resources are needed and their profiling) as well as the API’s that are going to be needed. This can be quite a tricky step to implement depending on what the real back end is going to be.
  • It’s much simpler and quicker to develop than anything that needs to be ‘production ready’. For example, you don’t generally need to implement any security or handle the errors that need to be allowed for in a real application.
  • It delivers solid requirements to the development team, as well as a test app that they can use as the API is developed.

Read more of this post

Creating a resources model

This is the third post in a mini series on using the Logical modeler. In the first post we talked in generalities of models (admitting that this is very much a work in progress), and then we discussed the Information Model – a model that is used to capture clinical requirements for information exchange. Now, it’s time to think about how we can design real FHIR artifacts from the work so far.

Read more of this post