Data Standards – US Healthcare

Lets take three hospitals, A,B and C which uses different data standards for defining Gender in their hospitals

A uses 0,1 for male and female.
B uses 1,0 for male and female,
C uses M,F,U for male, female and unknown.

The data of A and B are different syntactically while the data standards of A and C are different semantically. To achieve uniformity in these, Data standards are proposed. The simplest data standards are as follows:

National Drug Code System:

National Drug Code System  Maintained by US Food and Drug Administration (FDA)
This is a three segment code, that says “who made it / who labelled it”, “what drug is in it”, “what is the package size of this drug”. There are many commercial databases available which provides the same information.

For Example : Please find the below image which is basically a NDC for some medication called “Prozac”. Prozac tablets are basically anti-depressant tablets that will be used for treating/helping patients with Obsessive-Compulsion-Disorder (OCD), or other depression that includes even Bi-polar disorders.

NDC example

The first 4 digits represents the makers of the product. Here Prozac tablets are made by Dista Products. The next 4 digits represents the type the medication will be used, like Prozac as a medication is consumed as Capsule based tablets, it will come in bottle and with 20 mg of each tablets. Then the last two digits represents the count of the tablets, so the Prozac in general will come with the volume of 100 tablets.

As time progress on, many commercial pharmacy databases also started to use the same kind of information or code standards.

RxNorm:

To avoid the complexity of commercial databases who produce same information again and again on the medicines.  Another Standard was initiated by National Library of Medicine (NLM). They created something called RxNorm, which gave much more standard to the medication been used by a particular patient.

These RxNorm codes use a special unique number called RxCUI. which will be unique for different drug. Not all medications will have the same RxCUI code. The RxCUI code for the same drug Prozac and its composition can be found here in this link – RxNorm  Prozac

 

MU – Meaningful Use (Why?)

Why Meaningful Use (MU)?

Meaningful Use encourages you to switch from paper charts to electronic records while giving the best care to your patients. It improves your practice’s efficiency, and will earn you incentives. Medicare penalties for lack of participation began in 2015, so be sure to get started with the

Meaningful use is using certified electronic health record (EHR) technology to:

  • Improve quality, safety, efficiency, and reduce health disparities
  • Engage patients and family
  • Improve care coordination, and population and public health
  • Maintain privacy and security of patient health information

Ultimately, it is hoped that the meaningful use compliance will result in:

  • Better clinical outcomes
  • Improved population health outcomes
  • Increased transparency and efficiency
  • Empowered individuals
  • More robust research data on health systems

About EHR Incentive Program:

The American Recovery and Reinvestment Act of 2009 (ARRA) (Pub.L. 111–5) was enacted on February 17, 2009. Title IV of Division B of ARRA amends Titles XVIII and XIX of the Social Security Act (the Act) by establishing incentive payments to eligible professionals (EPs), eligible hospitals, and critical access hospitals (CAHs), and Medicare Advantage Organizations to promote the adoption and meaningful use of interoperable health information technology (HIT) and qualified electronic health records (EHRs). These incentive payments are part of a broader effort under the HITECH Act to accelerate the adoption of HIT and utilization of qualified EHRs.

Beginning in 2011, the Medicare and Medicaid Electronic Health Record (EHR) Incentive Programs were established to encourage eligible professionals and eligible hospitals to adopt, implement, upgrade (AIU), and demonstrate meaningful use of certified EHR technology.

What is MU-1,MU-2 & MU-3 ?

  1. Stage 1 set the foundation for the EHR Incentive Programs by establishing requirements for the electronic capture of clinical data, including providing patients with electronic copies of health information.
  2. Stage 2 expanded upon the Stage 1 criteria with a focus on ensuring that the meaningful use of EHRs supported the aims and priorities of the National Quality Strategy. Stage 2 criteria encouraged the use of health IT for continuous quality improvement at the point of care and the exchange of information in the most structured format possible.
  3. Stage 3 In October 2015, CMS released a final rule that specifies criteria that eligible professionals, eligible hospitals and CAHs must meet in order to participate in the EHR Incentive Programs in 2015 through 2017 (Modified Stage 2) and in Stage 3 in 2017 and beyond.

MU Regulations with respect to years:

MU certifications

MU reporting periods:

MU Reporting Period

MU EHR Medicare Incentives:

MU Medicare Incentives

MU EHR Medicaid Incentives:

MU Medicaid Incentives

 

Connect Mirth with MongoDB

It is an essential feature to connect Mirth to any flat-file Database. The reason for the shift is because in future we are expecting data in the form of an non-aligned  structure like an API call.

Most of the business people now are using Healthcare market just to increase the care co-ordination they offer.To achieve this business need, they are targeting people with mobile applications. Looking at from this perspective, the front end of this mobile application depends on latest technologies like  ReactJS or AngularJS.  These technologies primarily focus on efficiently binding the received data. This data is usually in a JSON format.

From the interoperability perspective we can see the need for inserting incoming data to parse and provide them in the flat-file MongoDB.

I basically use Java to try out this and to implement them in Mirth.

Pre-requisite:

MongoDB – connectivity Jar : please download the jar file from here  Please  Download 2.11.1/  I was using this version as it a stable release. Download mongo-java-driver-2.11.1.jar This contains only the connectivity Jar to MongoDB

Install MongoDB : Make sure MongoDB is available in your system, if you are using Windows system then make sure you navigate to the MongoDB folder and open to run Mongod.exe this will make the mongo server to listen to the port 27017 by default. Then open run Mongo.exe this will open the MongoShell console.

——————————————————–

MongoDB :

—————– Create Database ————–

show dbs;
use FHIRtest
type : db;
you should get : FHIRtest

—————– Create Collection ————–

db.createCollection(“SampleFHIR”);
type : show collections;
you should get : SampleFHIR

—————– Insert Data ——————–

db.SampleFHIR.insertOne({“Data”:”PatientInfo- GETtest”});
type : db.SampleFHIR.find();
you should get : { “_id” : ObjectId(“57c45d8403114b848da5b516”), “Data” : “PatientInfo- GETtest”}

—————————————————

Now we have a Database ready with a collection in it, also it has one collection.

We will write a JAVA code, that will primarily read the data from the MongoDB and display it to check for the connection.

package com.fhir;

import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;

public class FhirConnector {
public static void main(String[] args){
try{
//Connect to MongoDB client
MongoClient mongoClient = new MongoClient(“localhost”, 27017);
DB db = mongoClient.getDB(“FHIRtest”);
System.out.println(“- Database: ” + db);
//get collection data
DBCollection col = db.getCollection(“SampleFHIR”);
System.out.println(“- Collections: ” + col);
//Print Data in MongoDB
DBCursor cursor = col.find();
while(cursor.hasNext()) {
System.out.println(cursor.next());
}

}catch(IOException e){
throw new RuntimeException(e);
}
}
}

Output :

You should be getting an output like this:
consoleJava
Note: I have used a different collection name in my code, so the collection name is different in the console screen.

Now Let’s try to insert some data inside the same collection and then try to read the output. My making a a new code change in the above existing code.

package com.fhir;

import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;

public class FhirConnector {
public static void main(String[] args){
try{
MongoClient mongoClient = new MongoClient(“localhost”, 27017);
DB db = mongoClient.getDB(“FHIRtest”);
System.out.println(“- Database: ” + db);

DBCollection col = db.getCollection(“FHIRdump”);
System.out.println(“- Collections: ” + col);

//Insert data into MongoDB
BasicDBObject document = new BasicDBObject();
document.put(“database”, “FHIRtest”);
document.put(“collection_mark”, “insertFHIR”);

BasicDBObject documentDetail = new BasicDBObject();
documentDetail.put(“records”, 99);
documentDetail.put(“index”, “vps_index1”);

document.put(“detail”, documentDetail);
col.insert(document);
System.out.println(“Inserted into DB”);

//Print Data in MongoDB
DBCursor cursor = col.find();
while(cursor.hasNext()) {
System.out.println(cursor.next());
}

}catch(IOException e){
throw new RuntimeException(e);
}
}
}

Output :

You should be getting a console output like this:
consoleJava2

In the Mongo shell you will get an output like this:

mongoshell output

Now we have written the Java code that will insert a data into MongoDB. Next step we will incorporate this into Mirth.To achieve this in Mirth, deploy the MongoDB connectivity Jar in Mirth custom-lib folder. and If you have the Mirth running, restart the service.

Channel :

Source : set the source as FHIR listener set the port of your convenience

Source Transformer : 
We will write a code here, that will fetch the incoming JSON data . We will send the data to Mirth via POSTMAN chrome application tool.

var jsonData = connectorMessage.getRawData();
var parseData = JSON.parse(jsonData)
// parsed Data contents
var status = parseData.text.status;
var resource= parseData.resourceType;
var identity = parseData.id;
var sex = parseData.gender;
var dob = parseData.birthDate;
logger.info(status+” “+resource+” “+identity+” “+sex+” “+dob);
channelMap.put(‘statusDetail’,status);
channelMap.put(‘resource’,resource);
channelMap.put(‘id’,identity);
channelMap.put(‘gender’,sex);
channelMap.put(‘DateofBirth’,dob);

Destination:
Now set the destination as Javasscript writer. and type the below code in the destination

try{
var mongoClient = new Packages.com.mongodb.MongoClient(“localhost”,27017);
var db = mongoClient.getDB(“FHIRtest”);
var col = db.getCollection(“SampleFHIR”);

// Insert data into MongoDB
var document = new Packages.com.mongodb.BasicDBObject();
document.put(“Status”,$(‘statusDetail’));
document.put(“resourceType”, $(‘resource’));

var documentDetail = new Packages.com.mongodb.BasicDBObject();
documentDetail.put(“identity”, $(‘id’));
documentDetail.put(“sex”, $(‘gender’));
documentDetail.put(“dob”, $(‘DateofBirth’));

document.put(“detail”, documentDetail);

col.insert(document);

//get Data from MongoDB
var cursor = col.find();
while(cursor.hasNext())
{
logger.info(“Inside Collection : “+cursor.next());
}

}catch(e){}

You can now deploy the channel, and pass the below JSON as the message in POSTMAN

{
“text”: {
“status”: “generated”
},
“resourceType”: “”,
“id”: “210321-120321”,
“gender”: “male”,
“birthDate”: “1994-01-04”
}

You will now get the following output in the Mongo Shell.

mongoshell output 2

You can see that data is a simple JSON. But you can see all the packages, databases  are named as FHIR, the reason behind this is, It is essential to put json to a flat-file format in a enhanced way. FHIR being transferred as both XML as well as JSON it is essential to know how well we handle this and store in a flatfile format.

In future any server side based codes can read this FHIR resources as it is from MongoDB put it as an API, from where all  the mobile technologies like AngularJS, ReactJS will parse the incoming API and publish it in a wonderful user viewing manner.

— Hope this is useful.

 

 

Blog at WordPress.com.

Up ↑