Difference between revisions of "MediaWiki:Gadget-calculator-drugs-core.js"

Revision as of 19:21, 11 August 2021

/**
 * @author Chris Rishel
 */
( function() {
    var DEFAULT_DRUG_COLOR = 'default';
    var DEFAULT_DRUG_POPULATION = 'general';

    mw.calculators.isValueDependent = function( value, variableId ) {
        // This may need generalized to support other variables in the future
        if( variableId === 'weight' ) {
            return value && value.formatUnits().match( /\/[\s(]*?kg/ );
        } else {
            throw new Error( 'Dependence "' + variableId + '" not supported by isValueDependent' );
        }
    };

    /**
     * Define units
     */
    mw.calculators.addUnitsBases( {
        concentration: {
            toString: function( units ) {
                units = units.replace( ' pct', '%' );

                return units;
            }
        }
    } );

    mw.calculators.addUnits( {
        pct: {
            baseName: 'concentration',
            definition: '10 mg/mL'
        },
        vial: {
            baseName: 'VOLUME'
        }
    } );



    /**
     * DrugColor
     */
    mw.calculators.drugColors = {};

    mw.calculators.addDrugColors = function( drugColorData ) {
        var drugColors = mw.calculators.createCalculatorObjects( 'DrugColor', drugColorData );

        for( var drugColorId in drugColors ) {
            mw.calculators.drugColors[ drugColorId ] = drugColors[ drugColorId ];
        }
    };

    mw.calculators.getDrugColor = function( drugColorId ) {
        if( mw.calculators.drugColors.hasOwnProperty( drugColorId ) ) {
            return mw.calculators.drugColors[ drugColorId ];
        } else {
            return null;
        }
    };

    /**
     * Class DrugColor
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.DrugColor}
     * @constructor
     */
    mw.calculators.objectClasses.DrugColor = function( propertyValues ) {
        var properties = {
            required: [
                'id'
            ],
            optional: [
                'parentColor',
                'primaryColor',
                'highlightColor',
                'striped'
            ]
        };

        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );

        this.parentColor = this.parentColor || this.id === DEFAULT_DRUG_COLOR ? this.parentColor : DEFAULT_DRUG_COLOR;
    };

    mw.calculators.objectClasses.DrugColor.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );

    mw.calculators.objectClasses.DrugColor.prototype.getParentDrugColor = function() {
        if( !this.parentColor ) {
            return null;
        }

        var parentDrugColor = mw.calculators.getDrugColor( this.parentColor );

        if( !parentDrugColor ) {
            throw new Error( 'Parent drug color "' + this.parentColor + '" not found for drug color "' + this.id + '"' );
        }

        return parentDrugColor;
    };

    mw.calculators.objectClasses.DrugColor.prototype.getHighlightColor = function() {
        if( this.highlightColor ) {
            return this.highlightColor;
        } else if( this.parentColor ) {
            return this.getParentDrugColor().getHighlightColor();
        }
    };

    mw.calculators.objectClasses.DrugColor.prototype.getPrimaryColor = function() {
        if( this.primaryColor ) {
            return this.primaryColor;
        } else if( this.parentColor ) {
            return this.getParentDrugColor().getPrimaryColor();
        }
    };

    mw.calculators.objectClasses.DrugColor.prototype.isStriped = function() {
        if( this.striped !== null ) {
            return this.striped;
        } else if( this.parentColor ) {
            return this.getParentDrugColor().isStriped();
        }
    };





    /**
     * DrugPopulation
     */

    mw.calculators.drugPopulations = {};

    mw.calculators.addDrugPopulations = function( drugPopulationData ) {
        var drugPopulations = mw.calculators.createCalculatorObjects( 'DrugPopulation', drugPopulationData );

        for( var drugPopulationId in drugPopulations ) {
            mw.calculators.drugPopulations[ drugPopulationId ] = drugPopulations[ drugPopulationId ];
        }
    };

    mw.calculators.getDrugPopulation = function( drugPopulationId ) {
        if( mw.calculators.drugPopulations.hasOwnProperty( drugPopulationId ) ) {
            return mw.calculators.drugPopulations[ drugPopulationId ];
        } else {
            return null;
        }
    };



    /**
     * Class DrugPopulation
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.DrugPopulation}
     * @constructor
     */
    mw.calculators.objectClasses.DrugPopulation = function( propertyValues ) {
        var properties = {
            required: [
                'id',
                'name'
            ],
            optional: [
                'abbreviation',
                'variables'
            ]
        };

        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );

        if( this.variables ) {
            for( var variableId in this.variables ) {
                if( !mw.calculators.getVariable( variableId ) ) {
                    throw new Error( 'DrugPopulation variable "' + variableId + '" not defined' );
                }

                this.variables[ variableId ].min = this.variables[ variableId ].hasOwnProperty( 'min' ) ?
                    math.unit( this.variables[ variableId ].min ) : null;

                this.variables[ variableId ].max = this.variables[ variableId ].hasOwnProperty( 'max' ) ?
                    math.unit( this.variables[ variableId ].max ) : null;
            }
        } else {
            this.variables = {};
        }
    };

    mw.calculators.objectClasses.DrugPopulation.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );

    mw.calculators.objectClasses.DrugPopulation.prototype.getCalculationData = function() {
        var inputData = new mw.calculators.objectClasses.CalculationData();

        for( var variableId in this.variables ) {
            inputData.variables.required.push( variableId );
        }

        return inputData;
    };

    mw.calculators.objectClasses.DrugPopulation.prototype.getCalculationDataScore = function( dataValues ) {
        // A return value of -1 indicates the data did not match the population definition

        for( var variableId in this.variables ) {
            if( !dataValues.hasOwnProperty( variableId ) ) {
                return -1;
            }

            if( this.variables[ variableId ].min &&
                !math.largerEq( dataValues[ variableId ], this.variables[ variableId ].min ) ) {
                return -1;
            }

            if( this.variables[ variableId ].max &&
                !math.smallerEq( dataValues[ variableId ], this.variables[ variableId ].max ) ) {
                return -1;
            }
        }

        // If the data matches the population definition, the score corresponds to the number of variables in the
        // population definition. This should roughly correspond to the specificity of the population.
        return Object.keys( this.variables ).length;
    };

    mw.calculators.objectClasses.DrugPopulation.prototype.toString = function() {
        return mw.calculators.isMobile() && this.abbreviation ? this.abbreviation : this.name;
    }





    /**
     * DrugIndication
     */
    mw.calculators.drugIndications = {};

    mw.calculators.addDrugIndications = function( drugIndicationData ) {
        var drugIndications = mw.calculators.createCalculatorObjects( 'DrugIndication', drugIndicationData );

        for( var drugIndicationId in drugIndications ) {
            mw.calculators.drugIndications[ drugIndicationId ] = drugIndications[ drugIndicationId ];
        }
    };

    mw.calculators.getDrugIndication = function( drugIndicationId ) {
        if( mw.calculators.drugIndications.hasOwnProperty( drugIndicationId ) ) {
            return mw.calculators.drugIndications[ drugIndicationId ];
        } else {
            return null;
        }
    };



    /**
     * Class DrugIndication
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.DrugIndication}
     * @constructor
     */
    mw.calculators.objectClasses.DrugIndication = function( propertyValues ) {
        var properties = {
            required: [
                'id',
                'name'
            ],
            optional: [
                'abbreviation'
            ]
        };

        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
    };

    mw.calculators.objectClasses.DrugIndication.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );

    mw.calculators.objectClasses.DrugIndication.prototype.toString = function() {
        return mw.calculators.isMobile() && this.abbreviation ? this.abbreviation : this.name;
    };





    /**
     * Drug
     */
    mw.calculators.drugs = {};

    mw.calculators.addDrugs = function( drugData ) {
        var drugs = mw.calculators.createCalculatorObjects( 'Drug', drugData );

        for( var drugId in drugs ) {
            mw.calculators.drugs[ drugId ] = drugs[ drugId ];
        }
    };

    mw.calculators.addDrugDosages = function( drugId, drugDosageData ) {
        var drug = mw.calculators.getDrug( drugId );

        if( !drug ) {
            throw new Error( 'DrugDosage references drug "' + drugId + '" which is not defined' );
        }

        drug.addDosages( drugDosageData );

        var calculationId = 'drugDosage-' + drugId;
        var calculation = mw.calculators.getCalculation( calculationId );

        if( !calculation ) {
            var calculationData = {};

            calculationData[ calculationId ] = {
                calculate: mw.calculators.objectClasses.DrugDosageCalculation.prototype.calculate,
                drug: drugId,
                type: 'drug'
            };

            mw.calculators.addCalculations( calculationData, 'DrugDosageCalculation' );

            calculation = mw.calculators.getCalculation( calculationId );
        }

        calculation.setDependencies();
    };

    mw.calculators.getDrug = function( drugId ) {
        if( mw.calculators.drugs.hasOwnProperty( drugId ) ) {
            return mw.calculators.drugs[ drugId ];
        } else {
            return null;
        }
    };



    /**
     * Class Drug
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.Drug}
     * @constructor
     */
    mw.calculators.objectClasses.Drug = function( propertyValues ) {
        var properties = {
            required: [
                'id',
                'name'
            ],
            optional: [
                'color'
            ]
        };

        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );

        if( !this.color ) {
            this.color = DEFAULT_DRUG_COLOR;
        }

        var color = mw.calculators.getDrugColor( this.color );

        if( !color ) {
            throw new Error( 'Invalid drug color "' + this.color + '" for drug "' + this.id + '"' );
        }

        this.color = color;

        this.dosages = [];
        this.preparations = [];
    };

    mw.calculators.objectClasses.Drug.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );

    mw.calculators.objectClasses.Drug.prototype.addDosages = function( drugDosageData ) {
        var dosages = mw.calculators.createCalculatorObjects( 'DrugDosage', drugDosageData );

        for( var dosageId in dosages ) {
            dosages[ dosageId ].id = this.dosages.length;

            this.dosages.push( dosages[ dosageId ] );
        }
    };

    mw.calculators.objectClasses.Drug.prototype.getIndications = function() {
        var indications = [];

        for( var iDosage in this.dosages ) {
            if( this.dosages[ iDosage ].indication ) {
                indications.push( this.dosages[ iDosage ].indication );
            }
        }

        return indications.filter( mw.calculators.uniqueValues );
    };

    mw.calculators.objectClasses.Drug.prototype.getPopulations = function( indicationId ) {
        var populations = [];

        for( var iDosage in this.dosages ) {
            if( this.dosages[ iDosage ].population &&
                ( !indicationId || ( this.dosages[ iDosage ].indication && this.dosages[ iDosage ].indication.id === indicationId ) ) ) {
                populations.push( this.dosages[ iDosage ].population );
            }
        }

        return populations.filter( mw.calculators.uniqueValues );
    };

    mw.calculators.objectClasses.Drug.prototype.getPreparations = function() {
        return this.preparations.filter( mw.calculators.uniqueValues );
    };





    /**
     * DrugPreparation
     */
    mw.calculators.addDrugPreparations = function( drugId, drugPreparationData ) {
        if( !mw.calculators.getDrug( drugId ) ) {
            throw new Error( 'DrugPreparation references drug "' + drugId + '" which is not defined' );
        }

        for( var drugPreparationId in drugPreparationData ) {
            drugPreparationData[ drugPreparationId ].drug = drugId;
        }

        var drugPreparations = mw.calculators.createCalculatorObjects( 'DrugPreparation', drugPreparationData );

        for( var drugPreparationId in drugPreparations ) {
            mw.calculators.drugs[ drugId ].preparations[ drugPreparationId ] = drugPreparations[ drugPreparationId ];
        }
    };



    /**
     * Class DrugPreparation
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.DrugPreparation}
     * @constructor
     */
    mw.calculators.objectClasses.DrugPreparation = function( propertyValues ) {
        var properties = {
            required: [
                'drug',
                'id',
                'concentration'
            ],
            optional: [
                'dilutionRequired',
                'commonDilution'
            ]
        };

        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );


        this.concentration = this.concentration.replace( 'mcg', 'ug' );

        this.concentration = math.unit( this.concentration );
    };

    mw.calculators.objectClasses.DrugPreparation.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );





    /**
     * Class DrugDosage
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.DrugDosage}
     * @constructor
     */
    mw.calculators.objectClasses.DrugDosage = function( propertyValues ) {
        mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );

        var drugIndication = mw.calculators.getDrugIndication( this.indication );

        if( !drugIndication ) {
            throw new Error( 'Invalid indication "' + this.indication + '" for drug dosage' );
        }

        this.indication = drugIndication;

        this.population = this.population ? this.population : DEFAULT_DRUG_POPULATION;

        var drugPopulation = mw.calculators.getDrugPopulation( this.population );

        if( !drugPopulation ) {
            throw new Error( 'Invalid population "' + this.population + '" for drug dosage' );
        }

        this.population = drugPopulation;

        this.route = this.route ? this.route : 'IV';

        var drugDoseData = this.dose;
        this.dose = [];

        this.addDoses( drugDoseData );
    };

    mw.calculators.objectClasses.DrugDosage.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );

    mw.calculators.objectClasses.DrugDosage.prototype.addDoses = function( drugDoseData ) {
        // Each dosage can have one or more associated doses. Ensure this value is an array.
        if( !Array.isArray( drugDoseData ) ) {
            drugDoseData = [ drugDoseData ];
        }

        var doses = mw.calculators.createCalculatorObjects( 'DrugDose', drugDoseData );

        for( var doseId in doses ) {
            doses[ doseId ].id = this.dose.length;

            this.dose.push( doses[ doseId ] );
        }
    };

    mw.calculators.objectClasses.DrugDosage.prototype.getCalculationData = function() {
        var inputData = new mw.calculators.objectClasses.CalculationData();

        inputData = inputData.merge( this.population.getCalculationData() );

        for( var iDose in this.dose ) {
            inputData = inputData.merge( this.dose[ iDose ].getCalculationData() );
        }

        return inputData;
    };

    mw.calculators.objectClasses.DrugDosage.prototype.getProperties = function() {
        return {
            required: [
                'dose',
                'id',
                'indication'
            ],
            optional: [
                'description',
                'population',
                'route'
            ]
        };
    }





    /**
     * Class DrugDose
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.DrugDose}
     * @constructor
     */
    mw.calculators.objectClasses.DrugDose = function( propertyValues ) {
        mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );

        var mathProperties = this.getMathProperties();

        for( var iMathProperty in mathProperties ) {
            var mathProperty = mathProperties[ iMathProperty ];

            if( this[ mathProperty ] ) {
                // TODO consider making a UnitsBase.weight.fromString()
                this[ mathProperty ] = this[ mathProperty ].replace( 'kg', 'kgwt' );
                this[ mathProperty ] = this[ mathProperty ].replace( 'mcg', 'ug' );

                this[ mathProperty ] = math.unit( this[ mathProperty ] );
            } else {
                this[ mathProperty ] = null;
            }
        }

        if( this.weightCalculation ) {
            var weightCalculation = mw.calculators.getCalculation( this.weightCalculation );

            if( !weightCalculation ) {
                throw new Error( 'Drug dose references weight calculation "' + this.weightCalculation + '" which is not defined' );
            }

            this.weightCalculation = weightCalculation;
        }
    };

    mw.calculators.objectClasses.DrugDose.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );

    mw.calculators.objectClasses.DrugDose.prototype.getCalculationData = function() {
        var calculationData = new mw.calculators.objectClasses.CalculationData();

        var mathProperties = this.getMathProperties();

        // Look at dose properties to identify any variable dependence (e.g. weight-dependence)
        for( var iMathProperty in mathProperties ) {
            var mathProperty = mathProperties[ iMathProperty ];

            var dosePropertyValue = this[ mathProperty ];

            // For now, this only supports weight dependence, unclear if it will need to be more generalizable in the future
            if( mw.calculators.isValueDependent( dosePropertyValue, 'weight' ) &&
                calculationData.variables.optional.indexOf( 'weight' ) === -1 ) {
                calculationData.variables.optional.push( 'weight' );
            }
        }

        if( this.weightCalculation ) {
            calculationData.calculations.optional.push( this.weightCalculation.id );
        }

        return calculationData;
    };

    mw.calculators.objectClasses.DrugDose.prototype.getMathProperties = function() {
        return [
            'dose',
            'min',
            'max',
            'absoluteMin',
            'absoluteMax',
            'frequency'
        ];
    };

    mw.calculators.objectClasses.DrugDose.prototype.getProperties = function() {
        return {
            required: [
                'id'
            ],
            optional: [
                'absoluteMin',
                'absoluteMax',
                'dose',
                'min',
                'max',
                'name',
                'weightCalculation'
            ]
        };
    };




    /**
     * Class DrugDosageCalculation
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.DrugDosageCalculation}
     * @constructor
     */
    mw.calculators.objectClasses.DrugDosageCalculation = function( propertyValues ) {
        mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );

        this.initialize();
    };

    mw.calculators.objectClasses.DrugDosageCalculation.prototype = Object.create( mw.calculators.objectClasses.AbstractCalculation.prototype );

    mw.calculators.objectClasses.DrugDosageCalculation.prototype.calculate = function( data ) {
        var value = {
            population: null,
            dose: []
        };

        // Determine which dosage to use
        var populationScores = [];

        for( var iDosage in data.drug.dosages ) {
            var drugDosage = data.drug.dosages[ iDosage ];

            // If the indication does not match, set the score to -1
            var populationScore = ( drugDosage.indication.id === data.indication.id ) ?
                drugDosage.population.getCalculationDataScore( data ) : -1;

            populationScores.push( populationScore );
        }

        var maxPopulationScore = Math.max.apply( null, populationScores );

        if( maxPopulationScore < 0 ) {
            return value;
        }

        // If there is more than one dosage with the same score, take the first.
        // This allows the data editor to decide which is most important.
        var dosageId = populationScores.indexOf( maxPopulationScore );

        var dosage = data.drug.dosages[ dosageId ];

        value.population = dosage.population;

        // A dosage may contain multiple doses (e.g. induction and maintenance)
        for( var iDose in dosage.dose ) {
            var dose = dosage.dose[ iDose ];
            var mathProperties = dose.getMathProperties();

            // Initialize value properties for dose
            value.dose[ iDose ] = {
                massPerWeight: {},
                mass: {},
                name: dose.name,
                volume: {},
                weightCalculation: dose.weightCalculation ? dose.weightCalculation : null
            };

            var weightValue = dose.weightCalculation ? dose.weightCalculation.value : data.weight;

            for( var iMathProperty in mathProperties ) {
                var mathProperty = mathProperties[ iMathProperty ];

                var doseValue = dose[ mathProperty ];

                if( doseValue ) {
                    if( mw.calculators.isValueDependent( doseValue, 'weight' ) ) {
                        value.dose[ iDose ].massPerWeight[ mathProperty ] = doseValue;

                        // For whatever reason math.format will simplify the units, but math.formatUnits will not
                        // as a hack, we recreate a new unit value with the correct formatting of the result
                        value.dose[ iDose ].mass[ mathProperty ] = weightValue ? math.unit( math.multiply( doseValue, weightValue ).format() ) : null;
                    } else {
                        value.dose[ iDose ].mass[ mathProperty ] = doseValue;
                    }

                    if( data.preparation && value.dose[ iDose ].mass[ mathProperty ] ) {
                        // Same hack as above to get units to simplify correctly
                        value.dose[ iDose ].volume[ mathProperty ] = math.unit( math.multiply( value.dose[ iDose ].mass[ mathProperty ], math.divide( 1, data.preparation.concentration ) ).format() );
                    }
                }
            }
        }

        return value;
    };

    mw.calculators.objectClasses.DrugDosageCalculation.prototype.doRender = function() {
        var $calculationContainer = $( '.' + this.getContainerClass() );

        if( !$calculationContainer.length ) {
            return;
        }

        $calculationContainer.empty();

        // Label column
        var labelAttributes = {};
        var labelCss = {};

        if( this.drug.color.isStriped() ) {
            labelCss[ 'background' ] = 'repeating-linear-gradient(135deg,rgba(0,0,0,0),rgba(0,0,0,0)10px,rgba(255,255,255,1)10px,rgba(255,255,255,1)20px),' + this.drug.color.getPrimaryColor();
        } else {
            labelCss[ 'background-color'] = this.drug.color.getPrimaryColor();
        }

        var $label = $( '<th>', labelAttributes ).css( labelCss );

        $label.append( this.getLabelHtml() );

        var $infoButton = null;

        if( this.hasInfo() ) {
            $infoButton = $( '<a>', {
                'data-toggle': 'collapse',
                href: '#' + this.getContainerClass() + '-info',
                role: 'button',
                'aria-expanded': 'false',
                'aria-controls': this.getContainerClass() + '-info'
            } )
                .append( $( '<i>', {
                    class: 'far fa-question-circle'
                } ) );

            $label
                .append( $( '<span>', {
                    class: 'calculator-calculation-column-label-info'
                } )
                    .append( $infoButton )
                );
        }

        // Indication column
        var $indication = $( '<td>' );

        var indications = this.drug.getIndications();

        if( indications.length > 1 ) {
            $indication.append( mw.calculators.getVariable( this.getVariableIds().indication  ).createInput( true ) );
        } else {
            $indication.append( String( indications[ 0 ] ) );
        }

        // Dosage column
        var dosageHtml = '';

        var dash = '&ndash;';

        if( this.value.population && this.value.population.id !== DEFAULT_DRUG_POPULATION ) {
            dosageHtml += String( this.value.population ) + '<br />';
        }

        for( var iDose in this.value.dose ) {
            var doseValue = this.value.dose[ iDose ];

            if( doseValue.name ) {
                dosageHtml += doseValue.name + '<br />';
            }

            if( !$.isEmptyObject( doseValue.massPerWeight ) ) {
                if( doseValue.massPerWeight.hasOwnProperty( 'dose' ) ) {
                    dosageHtml += mw.calculators.getValueString( doseValue.massPerWeight.dose );
                } else if( doseValue.massPerWeight.hasOwnProperty( 'min' ) &&
                    doseValue.massPerWeight.hasOwnProperty( 'max' ) ) {
                    dosageHtml += mw.calculators.getValueString( doseValue.massPerWeight.min );
                    dosageHtml += dash;
                    dosageHtml += mw.calculators.getValueString( doseValue.massPerWeight.max );
                }

                if( doseValue.weightCalculation ) {
                    dosageHtml += ' (' + doseValue.weightCalculation.getLabelString() + ')';
                }

                dosageHtml += '<br />';
            }

            if( !$.isEmptyObject( doseValue.mass ) ) {
                if( doseValue.mass.hasOwnProperty( 'dose' ) ) {
                    dosageHtml += mw.calculators.getValueString( doseValue.mass.dose );
                } else if( doseValue.mass.hasOwnProperty( 'min' ) &&
                    doseValue.mass.hasOwnProperty( 'max' ) ) {
                    dosageHtml += mw.calculators.getValueString( doseValue.mass.min );
                    dosageHtml += dash;
                    dosageHtml += mw.calculators.getValueString( doseValue.mass.max );
                }

                dosageHtml += '<br />';
            }

            if( !$.isEmptyObject( doseValue.volume ) ) {
                if( doseValue.volume.hasOwnProperty( 'dose' ) ) {
                    dosageHtml += mw.calculators.getValueString( doseValue.volume.dose );
                } else if( doseValue.volume.hasOwnProperty( 'min' ) &&
                    doseValue.volume.hasOwnProperty( 'max' ) ) {
                    dosageHtml += mw.calculators.getValueString( doseValue.volume.min );
                    dosageHtml += dash;
                    dosageHtml += mw.calculators.getValueString( doseValue.volume.max );
                }

                dosageHtml += '<br />';
            }

            dosageHtml += '<br />';
        }


        $calculationContainer
            .append(
                $label,
                $indication,
                $( '<td>' ).html( dosageHtml )
            );


        return;



        var calculation = this;

        $calculationContainer.each( function() {
            $( this ).empty();




            if( calculation.hasInfo() ) {
                var infoHtml = '';

                if( calculation.description ) {
                    infoHtml += $( '<p>', {
                        html: calculation.description
                    } )[ 0 ].outerHTML;
                }

                if( calculation.formula ) {
                    infoHtml += $( '<span>', {
                        class: calculation.getContainerClass() + '-formula'
                    } )[ 0 ].outerHTML;

                    var api = new mw.Api();

                    api.parse( calculation.formula ).then( function( result ) {
                        $( '.' + calculation.getContainerClass() + '-formula' ).html( result );
                    } );
                }

                if( calculation.references.length ) {
                    var $references = $( '<ol>' );

                    for( var iReference in calculation.references ) {
                        $references.append( $( '<li>', {
                            text: calculation.references[ iReference ]
                        } ) );
                    }

                    infoHtml += $references[ 0 ].outerHTML;
                }

                var infoContainerId = calculation.getContainerClass() + '-info';
                var $infoContainer = $( '#' + infoContainerId );

                if( $infoContainer.length ) {
                    $infoContainer.empty();
                }

                $infoContainer = $( '<tr>', {
                    id: infoContainerId,
                    class: 'collapse'
                } )
                    .append( $( '<td>', {
                        colspan: 2
                    } ).append( infoHtml ) );


                $( this ).after( $infoContainer );
            }
        } );
    };

    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getCalculationData = function() {
        var inputData = new mw.calculators.objectClasses.CalculationData();

        // Add variables created by this calculation
        var variableIds = this.getVariableIds();

        for( var variableType in variableIds ) {
            inputData.variables.optional.push( variableIds[ variableType ] );
        }

        var dataTypes = inputData.getDataTypes();

        // Data is only actually required if it is required by every dosage for the drug.
        // Data marked as required by an individual dosage that does not appear in every
        // dosage will be converted to optional.
        var requiredInputData = new mw.calculators.objectClasses.CalculationData();

        // Need a way to tell the first iteration of the loop to initialize the required variables to a value that
        // is distinct from the empty array (populated across loop using array intersect, so could become [] and shouldn't
        // reinitialize).
        var initializeRequiredData = true;

        // Iterate through each dosage to determine variable dependency
        for( var iDosage in this.drug.dosages ) {
            var dosageInputData = this.drug.dosages[ iDosage ].getCalculationData();

            inputData = inputData.merge( dosageInputData );

            for( var iDataType in dataTypes ) {
                var dataType = dataTypes[ iDataType ];

                if( initializeRequiredData ) {
                    requiredInputData[ dataType ].required = inputData[ dataType ].required;
                } else {
                    // Data is only truly required if it is required by all dosage calculations, so use array intersection
                    requiredInputData[ dataType ].required = requiredInputData[ dataType ].required.filter( function( index ) {
                        return dosageInputData[ dataType ].required.indexOf( index ) !== -1;
                    } );
                }
            }

            initializeRequiredData = false;
        }

        for( var iDataType in dataTypes ) {
            var dataType = dataTypes[ iDataType ];

            // Move any data marked required in inputData to optional if it not actually required (i.e. doesn't appear
            // in requiredInputData).
            inputData[ dataType ].optional = inputData[ dataType ].optional.concat( inputData[ dataType ].required.filter( function( index ) {
                return requiredInputData[ dataType ].required.indexOf( index ) === -1;
            } ) ).filter( mw.calculators.uniqueValues );

            inputData[ dataType ].required = requiredInputData[ dataType ].required;
        }

        return inputData;
    };

    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getCalculationDataValues = function() {
        var data = mw.calculators.objectClasses.AbstractCalculation.prototype.getCalculationDataValues.call( this );

        data.drug = this.drug;

        data.indication = data[ this.getVariablePrefix() + 'indication' ] ?
            mw.calculators.getDrugIndication( mw.calculators.getVariable( this.getVariableIds().indication ).value ) :
            null;

        delete data[ this.getVariablePrefix() + 'indication' ];

        data.preparation = data[ this.getVariablePrefix() + 'preparation' ] ?
            this.drug.preparations[ mw.calculators.getVariable( this.getVariableIds().preparation ).value ] :
            null;

        delete data[ this.getVariablePrefix() + 'preparation' ];

        return data;
    };


    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getLabelHtml = function() {
        var labelHtml = this.drug.name;

        var $label = $( '<a>', {
            href: mw.util.getUrl( this.drug.name ),
            text: labelHtml
        } );

        var highlightColor = this.drug.color.getHighlightColor();

        if( highlightColor ) {
            $label.css( 'background-color', highlightColor );
        }

        labelHtml = $label[ 0 ].outerHTML;

        return labelHtml;
    };

    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getProperties = function() {
        var inheritedProperties = mw.calculators.objectClasses.AbstractCalculation.prototype.getProperties();

        return this.mergeProperties( inheritedProperties, {
            required: [
                'drug'
            ],
            optional: []
        } );
    };

    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getVariableIds = function() {
        return {
            indication: this.getVariablePrefix() + 'indication',
            preparation: this.getVariablePrefix() + 'preparation'
        };
    };

    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getVariablePrefix = function() {
        return this.drug.id + '-';
    }

    mw.calculators.objectClasses.DrugDosageCalculation.prototype.initialize = function() {
        mw.calculators.objectClasses.AbstractCalculation.prototype.initialize.call( this );

        var drug = mw.calculators.getDrug( this.drug );

        if( !drug ) {
            throw new Error( 'DrugDosage references drug "' + this.drug + '" which is not defined' );
        }

        this.drug = drug;

        var variableIds = this.getVariableIds();

        // Create variables for indication, population?, preparation select boxes? Here or m.c.addDosages() or elsewhere?
        // Will have to add them to getCalculationData too.
        var drugVariables = {};

        var indications = this.drug.getIndications();
        var indicationOptions = {};

        for( var iIndication in indications ) {
            var indication = indications[ iIndication ];

            indicationOptions[ indication.id ] = String( indication );
        }

        drugVariables[ variableIds.indication ] = {
            name: 'Indication',
            type: 'string',
            defaultValue: indications.length ? indications[ 0 ].id : null,
            options: indicationOptions
        };

        var preparations = this.drug.getPreparations();
        var preparationOptions = {};

        for( var iPreparation in preparations ) {
            var preparation = preparations[ iPreparation ];

            preparationOptions[ preparation.id ] = String( preparation );
        }

        drugVariables[ variableIds.preparation ] = {
            name: 'Preparation',
            type: 'string',
            defaultValue: preparations.length ? preparations[ 0 ].id : null,
            options: preparationOptions
        };

        mw.calculators.addVariables( drugVariables );
    };





    /**
     * Class DrugDosageCalculator
     * @param {Object} propertyValues
     * @returns {mw.calculators.objectClasses.DrugDosageCalculator}
     * @constructor
     */
    mw.calculators.objectClasses.DrugDosageCalculator = function( propertyValues ) {
        mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
    };

    mw.calculators.objectClasses.DrugDosageCalculator.prototype = Object.create( mw.calculators.objectClasses.AbstractCalculator.prototype );

    mw.calculators.objectClasses.DrugDosageCalculator.prototype.doRender = function() {
        var $calculatorContainer = $( '.' + this.getContainerClass() );

        if( !$calculatorContainer.length ) {
            return;
        }

        $calculatorContainer.empty();

        $calculatorContainer.append( $( '<h4>', {
            text: this.name
        } ) );

        var $calculationsContainer = $( '<table>', {
            class: 'wikitable'
        } ).append( '<tbody>' );

        $calculatorContainer.append( $calculationsContainer );

        $calculationsContainer
            .append( $( '<tr>' )
                .append(
                    $( '<th>' ).text( 'Drug' ),
                    $( '<th>' ).text( 'Indication' ),
                    $( '<th>' ).text( 'Dose' )
                )
            );

        for( var iCalculationId in this.calculations ) {
            var calculation = mw.calculators.getCalculation( this.calculations[ iCalculationId ] );
            var calculationContainerClass = calculation.getContainerClass();

            var $calculationContainer = $( '<tr>', {
                class: calculationContainerClass
            } );

            $calculationsContainer.append( $calculationContainer );

            calculation.render();
        }
    };

    mw.calculators.objectClasses.DrugDosageCalculator.prototype.getProperties = function() {
        var inheritedProperties = mw.calculators.objectClasses.AbstractCalculator.prototype.getProperties();

        return this.mergeProperties( inheritedProperties, {
            required: [],
            optional: []
        } );
    };

}() );

@@ Line 3: / Line 3: @@
   */
 ( function() {
+    var DEFAULT_DRUG_COLOR = 'default';
+    var DEFAULT_DRUG_POPULATION = 'general';
+    mw.calculators.isValueDependent = function( value, variableId ) {
+        // This may need generalized to support other variables in the future
+        if( variableId === 'weight' ) {
+            return value && value.formatUnits().match( /\/[\s(]*?kg/ );
+        } else {
+            throw new Error( 'Dependence "' + variableId + '" not supported by isValueDependent' );
+        }
+    };
      /**
-      * DrugColor data
+      * Define units
       */
-     mw.calculators.addDrugColors( {
+     mw.calculators.addUnitsBases( {
-         anticholinergic: {
+         concentration: {
-             primaryColor: '#00ac8c'
+             toString: function( units ) {
-        },
+                units = units.replace( ' pct', '%' );
-        benzodiazepine: {
-            primaryColor: '#ff6c2f'
+                return units;
-        },
+             }
-        benzodiazepineReversal: {
+         }
-            parentColor: 'benzodiazepine',
+    } );
-            striped: true
-        },
+    mw.calculators.addUnits( {
-        cardiovascularAgonist: {
+         pct: {
-             primaryColor: '#ba93df'
+             baseName: 'concentration',
-         },
+             definition: '10 mg/mL'
-        cardiovascularAntagonist: {
-            parentColor: 'cardiovascularAgonist',
-            striped: true
-        },
-        default: {
-            primaryColor: '#fff',
-            highlightColor: '#fff'
-         },
-        desflurane: {
-             primaryColor: '#0ab8fd'
-        },
-        enflurane: {
-             primaryColor: '#f58733'
          },
-         epinephrine: {
+         vial: {
-             parentColor: 'cardiovascularAntagonist',
+             baseName: 'VOLUME'
-            highlightColor: '#000'
-        },
-        halothane: {
-            primaryColor: '#b20107'
-        },
-        isoflurane: {
-            primaryColor: '#ca7fc0'
-        },
-        localAnesthetic: {
-            primaryColor: '#dad9d6'
-        },
-        neuromuscularBlocker: {
-            primaryColor: '#fe5442'
-        },
-        neuromuscularBlockerReversal: {
-            parentColor: 'neuromuscularBlocker',
-            striped: true
-        },
-        nitrousOxide: {
-            primaryColor: '#2d549f'
-        },
-        opioid: {
-            primaryColor: '#6cd1ef'
-        },
-        opioidReversal: {
-            parentColor: 'opioid',
-            striped: true
-        },
-        sedativeHypnotic: {
-            primaryColor: '#ffe800'
-        },
-        sevoflurane: {
-            primaryColor: '#f8da00'
-        },
-        succinylcholine: {
-            parentColor: 'neuromuscularBlocker',
-            highlightColor: '#000'
          }
      } );
@@ Line 79: / Line 41: @@
      /**
-      * DrugPopulation data
+      * DrugColor
       */
-     mw.calculators.addDrugPopulations( {
+     mw.calculators.drugColors = {};
-         general: {
-             name: 'General',
+    mw.calculators.addDrugColors = function( drugColorData ) {
-             abbreviation: 'Gen.'
+        var drugColors = mw.calculators.createCalculatorObjects( 'DrugColor', drugColorData );
-         },
-         neonatal: {
+        for( var drugColorId in drugColors ) {
-             name: 'Neonatal',
+            mw.calculators.drugColors[ drugColorId ] = drugColors[ drugColorId ];
-             abbreviation: 'Neo.',
+        }
-             variables: {
+    };
-                 age: {
-                     max: '0 yo'
+    mw.calculators.getDrugColor = function( drugColorId ) {
+        if( mw.calculators.drugColors.hasOwnProperty( drugColorId ) ) {
+            return mw.calculators.drugColors[ drugColorId ];
+        } else {
+            return null;
+        }
+    };
+    /**
+     * Class DrugColor
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.DrugColor}
+     * @constructor
+     */
+    mw.calculators.objectClasses.DrugColor = function( propertyValues ) {
+         var properties = {
+            required: [
+                'id'
+            ],
+             optional: [
+                'parentColor',
+                'primaryColor',
+                'highlightColor',
+                'striped'
+             ]
+        };
+        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
+        this.parentColor = this.parentColor || this.id === DEFAULT_DRUG_COLOR ? this.parentColor : DEFAULT_DRUG_COLOR;
+    };
+    mw.calculators.objectClasses.DrugColor.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
+    mw.calculators.objectClasses.DrugColor.prototype.getParentDrugColor = function() {
+        if( !this.parentColor ) {
+            return null;
+        }
+        var parentDrugColor = mw.calculators.getDrugColor( this.parentColor );
+        if( !parentDrugColor ) {
+            throw new Error( 'Parent drug color "' + this.parentColor + '" not found for drug color "' + this.id + '"' );
+        }
+        return parentDrugColor;
+    };
+    mw.calculators.objectClasses.DrugColor.prototype.getHighlightColor = function() {
+        if( this.highlightColor ) {
+            return this.highlightColor;
+        } else if( this.parentColor ) {
+            return this.getParentDrugColor().getHighlightColor();
+        }
+    };
+    mw.calculators.objectClasses.DrugColor.prototype.getPrimaryColor = function() {
+        if( this.primaryColor ) {
+            return this.primaryColor;
+         } else if( this.parentColor ) {
+            return this.getParentDrugColor().getPrimaryColor();
+        }
+    };
+    mw.calculators.objectClasses.DrugColor.prototype.isStriped = function() {
+        if( this.striped !== null ) {
+            return this.striped;
+        } else if( this.parentColor ) {
+            return this.getParentDrugColor().isStriped();
+        }
+    };
+    /**
+     * DrugPopulation
+     */
+    mw.calculators.drugPopulations = {};
+    mw.calculators.addDrugPopulations = function( drugPopulationData ) {
+        var drugPopulations = mw.calculators.createCalculatorObjects( 'DrugPopulation', drugPopulationData );
+        for( var drugPopulationId in drugPopulations ) {
+            mw.calculators.drugPopulations[ drugPopulationId ] = drugPopulations[ drugPopulationId ];
+        }
+    };
+    mw.calculators.getDrugPopulation = function( drugPopulationId ) {
+        if( mw.calculators.drugPopulations.hasOwnProperty( drugPopulationId ) ) {
+            return mw.calculators.drugPopulations[ drugPopulationId ];
+        } else {
+            return null;
+         }
+    };
+    /**
+     * Class DrugPopulation
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.DrugPopulation}
+     * @constructor
+     */
+    mw.calculators.objectClasses.DrugPopulation = function( propertyValues ) {
+        var properties = {
+             required: [
+                'id',
+                'name'
+            ],
+             optional: [
+                'abbreviation',
+                'variables'
+            ]
+        };
+        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
+        if( this.variables ) {
+             for( var variableId in this.variables ) {
+                 if( !mw.calculators.getVariable( variableId ) ) {
+                     throw new Error( 'DrugPopulation variable "' + variableId + '" not defined' );
                  }
+                this.variables[ variableId ].min = this.variables[ variableId ].hasOwnProperty( 'min' ) ?
+                    math.unit( this.variables[ variableId ].min ) : null;
+                this.variables[ variableId ].max = this.variables[ variableId ].hasOwnProperty( 'max' ) ?
+                    math.unit( this.variables[ variableId ].max ) : null;
              }
-         },
+         } else {
-         pediatric: {
+            this.variables = {};
-             name: 'Pediatric',
+        }
-            abbreviation: 'Ped.',
+    };
-             variables: {
-                 age: {
+    mw.calculators.objectClasses.DrugPopulation.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
-                    min: '0 yo',
-                    max: '17.9 yo'
+    mw.calculators.objectClasses.DrugPopulation.prototype.getCalculationData = function() {
-                 }
+        var inputData = new mw.calculators.objectClasses.CalculationData();
+         for( var variableId in this.variables ) {
+             inputData.variables.required.push( variableId );
+        }
+        return inputData;
+    };
+    mw.calculators.objectClasses.DrugPopulation.prototype.getCalculationDataScore = function( dataValues ) {
+        // A return value of -1 indicates the data did not match the population definition
+        for( var variableId in this.variables ) {
+             if( !dataValues.hasOwnProperty( variableId ) ) {
+                 return -1;
+            }
+            if( this.variables[ variableId ].min &&
+                !math.largerEq( dataValues[ variableId ], this.variables[ variableId ].min ) ) {
+                 return -1;
              }
-        },
-        elderly: {
+             if( this.variables[ variableId ].max &&
-             name: 'Elderly',
+                !math.smallerEq( dataValues[ variableId ], this.variables[ variableId ].max ) ) {
-            abbreviation: 'Eld.',
+                 return -1;
-            variables: {
-                age: {
-                    min: '65 yo'
-                 }
              }
          }
-     } );
+        // If the data matches the population definition, the score corresponds to the number of variables in the
+        // population definition. This should roughly correspond to the specificity of the population.
+        return Object.keys( this.variables ).length;
+     };
+    mw.calculators.objectClasses.DrugPopulation.prototype.toString = function() {
+        return mw.calculators.isMobile() && this.abbreviation ? this.abbreviation : this.name;
+    }
      /**
-      * DrugIndication data
+      * DrugIndication
       */
-     mw.calculators.addDrugIndications( {
+    mw.calculators.drugIndications = {};
-         abxProphylaxis: {
-            name: 'Antimicrobial prophylaxis',
+     mw.calculators.addDrugIndications = function( drugIndicationData ) {
-            abbreviation: 'Abx.'
+         var drugIndications = mw.calculators.createCalculatorObjects( 'DrugIndication', drugIndicationData );
-        },
-        anxiolysis: {
+         for( var drugIndicationId in drugIndications ) {
-            name: 'Anxiolysis',
+             mw.calculators.drugIndications[ drugIndicationId ] = drugIndications[ drugIndicationId ];
-            abbreviation: 'Anxiety'
+         }
-        },
+    };
-         generalAnesthesiaInduction: {
-            name: 'General anesthesia (induction)',
+    mw.calculators.getDrugIndication = function( drugIndicationId ) {
-             abbreviation: 'GA ind.'
+        if( mw.calculators.drugIndications.hasOwnProperty( drugIndicationId ) ) {
-         },
+             return mw.calculators.drugIndications[ drugIndicationId ];
-        generalAnesthesiaMaintenance: {
+         } else {
-            name: 'General anesthesia (maintenance)',
+             return null;
-            abbreviation: 'GA maint.'
-        },
-        neuromuscularBlockade: {
-            name: 'Neuromuscular blockade (non-RSI)',
-            abbreviation: 'NMB (non-RSI)'
-        },
-        neuromuscularBlockadeRsi: {
-            name: 'Neuromuscular blockade (rapid sequence induction)',
-            abbreviation: 'NMB (RSI)'
-        },
-        neuromuscularBlockadeReversal: {
-             name: 'Neuromuscular blockade reversal',
-            abbreviation: 'NMB reversal'
-        },
-        mac: {
-            name: 'Monitored anesthesia care',
-            abbreviation: 'MAC'
-        },
-        ponv: {
-            name: 'Postoperative nausea & vomiting',
-            abbreviation: 'PONV'
-        },
-        tivaLoad: {
-            name: 'Total intravenous anesthesia (loading dose)',
-            abbreviation: 'TIVA load'
-         },
-        tivaMaintenance: {
-             name: 'Total intravenous anesthesia (maintenance)',
-            abbreviation: 'TIVA maint.'
          }
-     } );
+     };
      /**
-      * Drug data
+      * Class DrugIndication
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.DrugIndication}
+     * @constructor
       */
-     var drugId;
+     mw.calculators.objectClasses.DrugIndication = function( propertyValues ) {
+        var properties = {
+            required: [
+                'id',
+                'name'
+            ],
+            optional: [
+                'abbreviation'
+            ]
+        };
+        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
+    };
+    mw.calculators.objectClasses.DrugIndication.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
+    mw.calculators.objectClasses.DrugIndication.prototype.toString = function() {
+        return mw.calculators.isMobile() && this.abbreviation ? this.abbreviation : this.name;
+    };
      /**
-      * Cefazolin
+      * Drug
       */
-     drugId = 'cefazolin';
+     mw.calculators.drugs = {};
-     mw.calculators.addDrugs( [
+     mw.calculators.addDrugs = function( drugData ) {
-         {
+        var drugs = mw.calculators.createCalculatorObjects( 'Drug', drugData );
-             id: drugId,
-            name: 'Cefazolin'
+         for( var drugId in drugs ) {
+             mw.calculators.drugs[ drugId ] = drugs[ drugId ];
          }
-     ] );
+     };
-     mw.calculators.addDrugDosages( drugId, [
+     mw.calculators.addDrugDosages = function( drugId, drugDosageData ) {
-         {
+        var drug = mw.calculators.getDrug( drugId );
-             indication: 'abxProphylaxis',
-            population: 'general',
+         if( !drug ) {
-             dose: {
+             throw new Error( 'DrugDosage references drug "' + drugId + '" which is not defined' );
-                 dose: '2 g',
+        }
-                 frequency: 'q4h'
-             }
+        drug.addDosages( drugDosageData );
+        var calculationId = 'drugDosage-' + drugId;
+        var calculation = mw.calculators.getCalculation( calculationId );
+        if( !calculation ) {
+            var calculationData = {};
+             calculationData[ calculationId ] = {
+                calculate: mw.calculators.objectClasses.DrugDosageCalculation.prototype.calculate,
+                 drug: drugId,
+                 type: 'drug'
+             };
+            mw.calculators.addCalculations( calculationData, 'DrugDosageCalculation' );
+            calculation = mw.calculators.getCalculation( calculationId );
          }
-    ] );
-     mw.calculators.addDrugPreparations( drugId, [
+        calculation.setDependencies();
-         {
+     };
-             concentration: '1 g/vial'
+    mw.calculators.getDrug = function( drugId ) {
+        if( mw.calculators.drugs.hasOwnProperty( drugId ) ) {
+            return mw.calculators.drugs[ drugId ];
+         } else {
+             return null;
          }
-     ] );
+     };
      /**
-      * Ketamine
+      * Class Drug
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.Drug}
+     * @constructor
       */
-     drugId = 'ketamine';
+     mw.calculators.objectClasses.Drug = function( propertyValues ) {
+        var properties = {
+            required: [
+                'id',
+                'name'
+            ],
+            optional: [
+                'color'
+            ]
+        };
+        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
-    mw.calculators.addDrugs( [
+        if( !this.color ) {
-        {
+             this.color = DEFAULT_DRUG_COLOR;
-             id: drugId,
-            name: 'Ketamine',
-            color: 'sedativeHypnotic'
          }
-    ] );
-    mw.calculators.addDrugPreparations( drugId, [
+        var color = mw.calculators.getDrugColor( this.color );
-         {
-             concentration: '10 mg/mL'
+         if( !color ) {
-        }, {
+             throw new Error( 'Invalid drug color "' + this.color + '" for drug "' + this.id + '"' );
-            concentration: '50 mg/mL'
-        }, {
-            concentration: '100 mg/mL'
          }
-    ] );
-     mw.calculators.addDrugDosages( drugId, [
+        this.color = color;
-        {
-            indication: 'generalAnesthesiaInduction',
+        this.dosages = [];
-             population: 'general',
+        this.preparations = [];
-             dose: {
+    };
-                min: '1 mg/kg',
-                max: '2 mg/kg',
+     mw.calculators.objectClasses.Drug.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
-                 weightCalculation: 'lbw'
+    mw.calculators.objectClasses.Drug.prototype.addDosages = function( drugDosageData ) {
+        var dosages = mw.calculators.createCalculatorObjects( 'DrugDosage', drugDosageData );
+        for( var dosageId in dosages ) {
+             dosages[ dosageId ].id = this.dosages.length;
+             this.dosages.push( dosages[ dosageId ] );
+        }
+    };
+    mw.calculators.objectClasses.Drug.prototype.getIndications = function() {
+        var indications = [];
+        for( var iDosage in this.dosages ) {
+            if( this.dosages[ iDosage ].indication ) {
+                 indications.push( this.dosages[ iDosage ].indication );
              }
-         }, {
+         }
-            indication: 'generalAnesthesiaInduction',
-            population: 'general',
+        return indications.filter( mw.calculators.uniqueValues );
-            route: 'im',
+    };
-             dose: {
-                 min: '4 mg/kg',
+    mw.calculators.objectClasses.Drug.prototype.getPopulations = function( indicationId ) {
-                 max: '6 mg/kg'
+        var populations = [];
+        for( var iDosage in this.dosages ) {
+             if( this.dosages[ iDosage ].population &&
+                 ( !indicationId || ( this.dosages[ iDosage ].indication && this.dosages[ iDosage ].indication.id === indicationId ) ) ) {
+                 populations.push( this.dosages[ iDosage ].population );
              }
          }
-     ] );
+        return populations.filter( mw.calculators.uniqueValues );
+    };
+     mw.calculators.objectClasses.Drug.prototype.getPreparations = function() {
+        return this.preparations.filter( mw.calculators.uniqueValues );
+    };
      /**
-      * Lidocaine
+      * DrugPreparation
       */
-     drugId = 'lidocaine';
+     mw.calculators.addDrugPreparations = function( drugId, drugPreparationData ) {
+        if( !mw.calculators.getDrug( drugId ) ) {
+            throw new Error( 'DrugPreparation references drug "' + drugId + '" which is not defined' );
+        }
-    mw.calculators.addDrugs( [
+        for( var drugPreparationId in drugPreparationData ) {
-        {
+             drugPreparationData[ drugPreparationId ].drug = drugId;
-             id: drugId,
-            name: 'Lidocaine',
-            color: 'localAnesthetic'
          }
-    ] );
-    mw.calculators.addDrugPreparations( drugId, [
+        var drugPreparations = mw.calculators.createCalculatorObjects( 'DrugPreparation', drugPreparationData );
-        {
-            concentration: '1 pct'
+         for( var drugPreparationId in drugPreparations ) {
-         }, {
+             mw.calculators.drugs[ drugId ].preparations[ drugPreparationId ] = drugPreparations[ drugPreparationId ];
-             concentration: '2 pct'
          }
-     ] );
+     };
+    /**
+     * Class DrugPreparation
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.DrugPreparation}
+     * @constructor
+     */
+    mw.calculators.objectClasses.DrugPreparation = function( propertyValues ) {
+        var properties = {
+            required: [
+                'drug',
+                'id',
+                'concentration'
+            ],
+            optional: [
+                'dilutionRequired',
+                'commonDilution'
+            ]
+        };
+        mw.calculators.objectClasses.CalculatorObject.call( this, properties, propertyValues );
+        this.concentration = this.concentration.replace( 'mcg', 'ug' );
+        this.concentration = math.unit( this.concentration );
+    };
+    mw.calculators.objectClasses.DrugPreparation.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
      /**
-      * Midazolam
+      * Class DrugDosage
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.DrugDosage}
+     * @constructor
       */
-     drugId = 'midazolam';
+     mw.calculators.objectClasses.DrugDosage = function( propertyValues ) {
+        mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
-    mw.calculators.addDrugs( [
+        var drugIndication = mw.calculators.getDrugIndication( this.indication );
-         {
-             id: drugId,
+         if( !drugIndication ) {
-            name: 'Midazolam',
+             throw new Error( 'Invalid indication "' + this.indication + '" for drug dosage' );
-            color: 'benzodiazepine'
          }
-    ] );
-    mw.calculators.addDrugDosages( drugId, [
+        this.indication = drugIndication;
-         {
-            indication: 'anxiolysis',
+         this.population = this.population ? this.population : DEFAULT_DRUG_POPULATION;
-            population: 'general',
-            dose: {
+        var drugPopulation = mw.calculators.getDrugPopulation( this.population );
-                min: '0.01 mg/kg',
-                max: '0.03 mg/kg'
+         if( !drugPopulation ) {
-            }
+             throw new Error( 'Invalid population "' + this.population + '" for drug dosage' );
-        }, {
-            indication: 'anxiolysis',
-            population: 'general',
-            route: 'im',
-            dose: {
-                min: '0.07 mg/kg',
-                max: '0.08 mg/kg'
-            }
-         }, {
-             indication: 'anxiolysis',
-            population: 'general',
-            route: 'po',
-            dose: {
-                dose: '0.5 mg/kg',
-                absoluteMax: '20 mg'
-            }
-        }, {
-            indication: 'generalAnesthesiaInduction',
-            population: 'general',
-            dose: {
-                min: '0.1 mg/kg',
-                max: '0.3 mg/kg',
-                weightCalculation: 'lbw'
-            }
          }
-    ] );
-    mw.calculators.addDrugPreparations( drugId, [
+        this.population = drugPopulation;
-        {
-            concentration: '1 mg/mL'
+         this.route = this.route ? this.route : 'IV';
-         }, {
-            concentration: '5 mg/mL'
-        }
-    ] );
+        var drugDoseData = this.dose;
+        this.dose = [];
+        this.addDoses( drugDoseData );
+    };
-     /**
+     mw.calculators.objectClasses.DrugDosage.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
-     * Neostigmine
-     */
-    drugId = 'neostigmine';
-     mw.calculators.addDrugs( [
+     mw.calculators.objectClasses.DrugDosage.prototype.addDoses = function( drugDoseData ) {
-         {
+        // Each dosage can have one or more associated doses. Ensure this value is an array.
-             id: drugId,
+         if( !Array.isArray( drugDoseData ) ) {
-            name: 'Neostigmine',
+             drugDoseData = [ drugDoseData ];
-            color: 'neuromuscularBlockerReversal'
          }
-    ] );
-    mw.calculators.addDrugDosages( drugId, [
+        var doses = mw.calculators.createCalculatorObjects( 'DrugDose', drugDoseData );
-        {
-            indication: 'neuromuscularBlockadeReversal',
+        for( var doseId in doses ) {
-            population: 'general',
+            doses[ doseId ].id = this.dose.length;
-            dose: {
-                min: '0.03 mg/kg',
+             this.dose.push( doses[ doseId ] );
-                max: '0.07 mg/kg',
-                absoluteMax: '5 mg'
-             },
-            description: 'For each 1 mg of neostigmine, give 0.2 mg of glycopyrrolate to avoid bradycardia'
          }
-     ] );
+     };
+    mw.calculators.objectClasses.DrugDosage.prototype.getCalculationData = function() {
+        var inputData = new mw.calculators.objectClasses.CalculationData();
+        inputData = inputData.merge( this.population.getCalculationData() );
-    mw.calculators.addDrugPreparations( drugId, [
+        for( var iDose in this.dose ) {
-        {
+            inputData = inputData.merge( this.dose[ iDose ].getCalculationData() );
-            concentration: '0.5 mg/mL'
-        }, {
-            concentration: '1 mg/mL'
          }
-     ] );
+        return inputData;
+    };
+     mw.calculators.objectClasses.DrugDosage.prototype.getProperties = function() {
+        return {
+            required: [
+                'dose',
+                'id',
+                'indication'
+            ],
+            optional: [
+                'description',
+                'population',
+                'route'
+            ]
+        };
+    }
      /**
-      * Ondansetron
+      * Class DrugDose
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.DrugDose}
+     * @constructor
       */
-     drugId = 'ondansetron';
+     mw.calculators.objectClasses.DrugDose = function( propertyValues ) {
+        mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
-    mw.calculators.addDrugs( [
+        var mathProperties = this.getMathProperties();
-         {
-             id: drugId,
+         for( var iMathProperty in mathProperties ) {
-            name: 'Ondansetron'
+             var mathProperty = mathProperties[ iMathProperty ];
+            if( this[ mathProperty ] ) {
+                // TODO consider making a UnitsBase.weight.fromString()
+                this[ mathProperty ] = this[ mathProperty ].replace( 'kg', 'kgwt' );
+                this[ mathProperty ] = this[ mathProperty ].replace( 'mcg', 'ug' );
+                this[ mathProperty ] = math.unit( this[ mathProperty ] );
+            } else {
+                this[ mathProperty ] = null;
+            }
          }
-    ] );
-    mw.calculators.addDrugDosages( drugId, [
+        if( this.weightCalculation ) {
-        {
+            var weightCalculation = mw.calculators.getCalculation( this.weightCalculation );
-             indication: 'ponv',
-            population: 'general',
+             if( !weightCalculation ) {
-            dose: {
+                 throw new Error( 'Drug dose references weight calculation "' + this.weightCalculation + '" which is not defined' );
-                 dose: '4 mg'
              }
-         }, {
-             indication: 'ponv',
+            this.weightCalculation = weightCalculation;
-             population: 'pediatric',
+         }
-            dose: {
+    };
-                 dose: '0.1 mg/kg',
-                 absoluteMax: '4 mg'
+    mw.calculators.objectClasses.DrugDose.prototype = Object.create( mw.calculators.objectClasses.CalculatorObject.prototype );
+    mw.calculators.objectClasses.DrugDose.prototype.getCalculationData = function() {
+        var calculationData = new mw.calculators.objectClasses.CalculationData();
+        var mathProperties = this.getMathProperties();
+        // Look at dose properties to identify any variable dependence (e.g. weight-dependence)
+        for( var iMathProperty in mathProperties ) {
+             var mathProperty = mathProperties[ iMathProperty ];
+            var dosePropertyValue = this[ mathProperty ];
+            // For now, this only supports weight dependence, unclear if it will need to be more generalizable in the future
+             if( mw.calculators.isValueDependent( dosePropertyValue, 'weight' ) &&
+                 calculationData.variables.optional.indexOf( 'weight' ) === -1 ) {
+                 calculationData.variables.optional.push( 'weight' );
              }
          }
-    ] );
-    mw.calculators.addDrugPreparations( drugId, [
+        if( this.weightCalculation ) {
-        {
+             calculationData.calculations.optional.push( this.weightCalculation.id );
-             concentration: '2 mg/mL'
          }
-     ] );
+        return calculationData;
+    };
+     mw.calculators.objectClasses.DrugDose.prototype.getMathProperties = function() {
+        return [
+            'dose',
+            'min',
+            'max',
+            'absoluteMin',
+            'absoluteMax',
+            'frequency'
+        ];
+    };
+    mw.calculators.objectClasses.DrugDose.prototype.getProperties = function() {
+        return {
+            required: [
+                'id'
+            ],
+            optional: [
+                'absoluteMin',
+                'absoluteMax',
+                'dose',
+                'min',
+                'max',
+                'name',
+                'weightCalculation'
+            ]
+        };
+    };
      /**
-      * Propofol
+      * Class DrugDosageCalculation
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.DrugDosageCalculation}
+     * @constructor
       */
-     drugId = 'propofol';
+     mw.calculators.objectClasses.DrugDosageCalculation = function( propertyValues ) {
+        mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
-     mw.calculators.addDrugs( [
+        this.initialize();
-         {
+    };
-             id: drugId,
-             name: 'Propofol',
+     mw.calculators.objectClasses.DrugDosageCalculation.prototype = Object.create( mw.calculators.objectClasses.AbstractCalculation.prototype );
-             color: 'sedativeHypnotic'
+    mw.calculators.objectClasses.DrugDosageCalculation.prototype.calculate = function( data ) {
+         var value = {
+             population: null,
+             dose: []
+        };
+        // Determine which dosage to use
+        var populationScores = [];
+        for( var iDosage in data.drug.dosages ) {
+            var drugDosage = data.drug.dosages[ iDosage ];
+            // If the indication does not match, set the score to -1
+             var populationScore = ( drugDosage.indication.id === data.indication.id ) ?
+                drugDosage.population.getCalculationDataScore( data ) : -1;
+            populationScores.push( populationScore );
          }
-    ] );
-    mw.calculators.addDrugPreparations( drugId, [
+        var maxPopulationScore = Math.max.apply( null, populationScores );
-         {
-             concentration: '10 mg/mL'
+         if( maxPopulationScore < 0 ) {
+             return value;
          }
-    ] );
-    mw.calculators.addDrugDosages( drugId, [
+        // If there is more than one dosage with the same score, take the first.
-         {
+        // This allows the data editor to decide which is most important.
-             indication: 'generalAnesthesiaInduction',
+        var dosageId = populationScores.indexOf( maxPopulationScore );
-            population: 'general',
-             dose: {
+        var dosage = data.drug.dosages[ dosageId ];
-                 min: '1 mg/kg',
-                max: '2.5 mg/kg',
+        value.population = dosage.population;
-                 weightCalculation: 'lbw'
+         // A dosage may contain multiple doses (e.g. induction and maintenance)
+        for( var iDose in dosage.dose ) {
+             var dose = dosage.dose[ iDose ];
+            var mathProperties = dose.getMathProperties();
+            // Initialize value properties for dose
+            value.dose[ iDose ] = {
+                massPerWeight: {},
+                mass: {},
+                name: dose.name,
+                volume: {},
+                weightCalculation: dose.weightCalculation ? dose.weightCalculation : null
+            };
+             var weightValue = dose.weightCalculation ? dose.weightCalculation.value : data.weight;
+            for( var iMathProperty in mathProperties ) {
+                 var mathProperty = mathProperties[ iMathProperty ];
+                var doseValue = dose[ mathProperty ];
+                if( doseValue ) {
+                    if( mw.calculators.isValueDependent( doseValue, 'weight' ) ) {
+                        value.dose[ iDose ].massPerWeight[ mathProperty ] = doseValue;
+                        // For whatever reason math.format will simplify the units, but math.formatUnits will not
+                        // as a hack, we recreate a new unit value with the correct formatting of the result
+                        value.dose[ iDose ].mass[ mathProperty ] = weightValue ? math.unit( math.multiply( doseValue, weightValue ).format() ) : null;
+                    } else {
+                        value.dose[ iDose ].mass[ mathProperty ] = doseValue;
+                    }
+                    if( data.preparation && value.dose[ iDose ].mass[ mathProperty ] ) {
+                        // Same hack as above to get units to simplify correctly
+                        value.dose[ iDose ].volume[ mathProperty ] = math.unit( math.multiply( value.dose[ iDose ].mass[ mathProperty ], math.divide( 1, data.preparation.concentration ) ).format() );
+                    }
+                 }
              }
-         }, {
+         }
-             indication: 'generalAnesthesiaInduction',
-            population: 'pediatric',
+        return value;
-            dose: {
+    };
-                 min: '2.5 mg/kg',
-                 max: '3.5 mg/kg',
+    mw.calculators.objectClasses.DrugDosageCalculation.prototype.doRender = function() {
-                 weightCalculation: 'lbw'
+        var $calculationContainer = $( '.' + this.getContainerClass() );
+        if( !$calculationContainer.length ) {
+            return;
+        }
+        $calculationContainer.empty();
+        // Label column
+        var labelAttributes = {};
+        var labelCss = {};
+        if( this.drug.color.isStriped() ) {
+            labelCss[ 'background' ] = 'repeating-linear-gradient(135deg,rgba(0,0,0,0),rgba(0,0,0,0)10px,rgba(255,255,255,1)10px,rgba(255,255,255,1)20px),' + this.drug.color.getPrimaryColor();
+        } else {
+            labelCss[ 'background-color'] = this.drug.color.getPrimaryColor();
+        }
+        var $label = $( '<th>', labelAttributes ).css( labelCss );
+        $label.append( this.getLabelHtml() );
+        var $infoButton = null;
+        if( this.hasInfo() ) {
+             $infoButton = $( '<a>', {
+                'data-toggle': 'collapse',
+                href: '#' + this.getContainerClass() + '-info',
+                role: 'button',
+                'aria-expanded': 'false',
+                 'aria-controls': this.getContainerClass() + '-info'
+            } )
+                .append( $( '<i>', {
+                    class: 'far fa-question-circle'
+                } ) );
+            $label
+                 .append( $( '<span>', {
+                    class: 'calculator-calculation-column-label-info'
+                } )
+                    .append( $infoButton )
+                );
+        }
+        // Indication column
+        var $indication = $( '<td>' );
+        var indications = this.drug.getIndications();
+        if( indications.length > 1 ) {
+            $indication.append( mw.calculators.getVariable( this.getVariableIds().indication  ).createInput( true ) );
+        } else {
+            $indication.append( String( indications[ 0 ] ) );
+        }
+        // Dosage column
+        var dosageHtml = '';
+        var dash = '&ndash;';
+        if( this.value.population && this.value.population.id !== DEFAULT_DRUG_POPULATION ) {
+            dosageHtml += String( this.value.population ) + '<br />';
+        }
+        for( var iDose in this.value.dose ) {
+            var doseValue = this.value.dose[ iDose ];
+            if( doseValue.name ) {
+                 dosageHtml += doseValue.name + '<br />';
              }
-        }, {
-             indication: 'generalAnesthesiaInduction',
+             if( !$.isEmptyObject( doseValue.massPerWeight ) ) {
-            population: 'elderly',
+                if( doseValue.massPerWeight.hasOwnProperty( 'dose' ) ) {
-            dose: {
+                    dosageHtml += mw.calculators.getValueString( doseValue.massPerWeight.dose );
-                 min: '1 mg/kg',
+                 } else if( doseValue.massPerWeight.hasOwnProperty( 'min' ) &&
-                 max: '1.5 mg/kg',
+                    doseValue.massPerWeight.hasOwnProperty( 'max' ) ) {
-                 weightCalculation: 'lbw'
+                    dosageHtml += mw.calculators.getValueString( doseValue.massPerWeight.min );
+                    dosageHtml += dash;
+                    dosageHtml += mw.calculators.getValueString( doseValue.massPerWeight.max );
+                }
+                 if( doseValue.weightCalculation ) {
+                    dosageHtml += ' (' + doseValue.weightCalculation.getLabelString() + ')';
+                 }
+                dosageHtml += '<br />';
              }
-        }, {
-             indication: 'generalAnesthesiaMaintenance',
+             if( !$.isEmptyObject( doseValue.mass ) ) {
-            population: 'general',
+                if( doseValue.mass.hasOwnProperty( 'dose' ) ) {
-            dose: {
+                    dosageHtml += mw.calculators.getValueString( doseValue.mass.dose );
-                 min: '100 mcg/kg/min',
+                 } else if( doseValue.mass.hasOwnProperty( 'min' ) &&
-                 max: '200 mcg/kg/min'
+                    doseValue.mass.hasOwnProperty( 'max' ) ) {
+                    dosageHtml += mw.calculators.getValueString( doseValue.mass.min );
+                    dosageHtml += dash;
+                    dosageHtml += mw.calculators.getValueString( doseValue.mass.max );
+                }
+                 dosageHtml += '<br />';
              }
-        }, {
-             indication: 'generalAnesthesiaMaintenance',
+             if( !$.isEmptyObject( doseValue.volume ) ) {
-            population: 'pediatric',
+                if( doseValue.volume.hasOwnProperty( 'dose' ) ) {
-            dose: {
+                    dosageHtml += mw.calculators.getValueString( doseValue.volume.dose );
-                 min: '125 mcg/kg/min',
+                 } else if( doseValue.volume.hasOwnProperty( 'min' ) &&
-                 max: '300 mcg/kg/min'
+                    doseValue.volume.hasOwnProperty( 'max' ) ) {
+                    dosageHtml += mw.calculators.getValueString( doseValue.volume.min );
+                    dosageHtml += dash;
+                    dosageHtml += mw.calculators.getValueString( doseValue.volume.max );
+                }
+                 dosageHtml += '<br />';
              }
-         }, {
-             indication: 'generalAnesthesiaMaintenance',
+            dosageHtml += '<br />';
-            population: 'elderly',
+         }
-            dose: {
-                min: '50 mcg/kg/min',
-                max: '100 mcg/kg/min'
+        $calculationContainer
-            }
+            .append(
-        }, {
+                $label,
-            indication: 'mac',
+                $indication,
-            population: 'general',
+                $( '<td>' ).html( dosageHtml )
-            dose: {
+            );
-                min: '25 mcg/kg/min',
-                 max: '75 mcg/kg/min'
+        return;
+        var calculation = this;
+        $calculationContainer.each( function() {
+             $( this ).empty();
+            if( calculation.hasInfo() ) {
+                var infoHtml = '';
+                if( calculation.description ) {
+                    infoHtml += $( '<p>', {
+                        html: calculation.description
+                    } )[ 0 ].outerHTML;
+                }
+                if( calculation.formula ) {
+                    infoHtml += $( '<span>', {
+                        class: calculation.getContainerClass() + '-formula'
+                    } )[ 0 ].outerHTML;
+                    var api = new mw.Api();
+                    api.parse( calculation.formula ).then( function( result ) {
+                        $( '.' + calculation.getContainerClass() + '-formula' ).html( result );
+                    } );
+                }
+                if( calculation.references.length ) {
+                    var $references = $( '<ol>' );
+                    for( var iReference in calculation.references ) {
+                        $references.append( $( '<li>', {
+                            text: calculation.references[ iReference ]
+                        } ) );
+                    }
+                    infoHtml += $references[ 0 ].outerHTML;
+                }
+                var infoContainerId = calculation.getContainerClass() + '-info';
+                var $infoContainer = $( '#' + infoContainerId );
+                if( $infoContainer.length ) {
+                    $infoContainer.empty();
+                }
+                $infoContainer = $( '<tr>', {
+                    id: infoContainerId,
+                    class: 'collapse'
+                 } )
+                    .append( $( '<td>', {
+                        colspan: 2
+                    } ).append( infoHtml ) );
+                $( this ).after( $infoContainer );
              }
+        } );
+    };
+    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getCalculationData = function() {
+        var inputData = new mw.calculators.objectClasses.CalculationData();
+        // Add variables created by this calculation
+        var variableIds = this.getVariableIds();
+        for( var variableType in variableIds ) {
+            inputData.variables.optional.push( variableIds[ variableType ] );
          }
-    ] );
+        var dataTypes = inputData.getDataTypes();
+        // Data is only actually required if it is required by every dosage for the drug.
+        // Data marked as required by an individual dosage that does not appear in every
+        // dosage will be converted to optional.
+        var requiredInputData = new mw.calculators.objectClasses.CalculationData();
-    /**
+        // Need a way to tell the first iteration of the loop to initialize the required variables to a value that
-     * Rocuronium
+        // is distinct from the empty array (populated across loop using array intersect, so could become [] and shouldn't
-     */
+        // reinitialize).
-    drugId = 'rocuronium';
+        var initializeRequiredData = true;
+        // Iterate through each dosage to determine variable dependency
+        for( var iDosage in this.drug.dosages ) {
+            var dosageInputData = this.drug.dosages[ iDosage ].getCalculationData();
+            inputData = inputData.merge( dosageInputData );
+            for( var iDataType in dataTypes ) {
+                var dataType = dataTypes[ iDataType ];
+                if( initializeRequiredData ) {
+                    requiredInputData[ dataType ].required = inputData[ dataType ].required;
+                } else {
+                    // Data is only truly required if it is required by all dosage calculations, so use array intersection
+                    requiredInputData[ dataType ].required = requiredInputData[ dataType ].required.filter( function( index ) {
+                        return dosageInputData[ dataType ].required.indexOf( index ) !== -1;
+                    } );
+                }
+            }
-    mw.calculators.addDrugs( [
+             initializeRequiredData = false;
-        {
-             id: drugId,
-            name: 'Rocuronium',
-            color: 'neuromuscularBlocker'
          }
-    ] );
-    mw.calculators.addDrugPreparations( drugId, [
+        for( var iDataType in dataTypes ) {
-        {
+            var dataType = dataTypes[ iDataType ];
-             concentration: '10 mg/mL'
+            // Move any data marked required in inputData to optional if it not actually required (i.e. doesn't appear
+            // in requiredInputData).
+            inputData[ dataType ].optional = inputData[ dataType ].optional.concat( inputData[ dataType ].required.filter( function( index ) {
+                return requiredInputData[ dataType ].required.indexOf( index ) === -1;
+            } ) ).filter( mw.calculators.uniqueValues );
+             inputData[ dataType ].required = requiredInputData[ dataType ].required;
          }
-    ] );
-     mw.calculators.addDrugDosages( drugId, [
+        return inputData;
-         {
+    };
-             indication: 'neuromuscularBlockade',
-            population: 'general',
+     mw.calculators.objectClasses.DrugDosageCalculation.prototype.getCalculationDataValues = function() {
-             dose: {
+        var data = mw.calculators.objectClasses.AbstractCalculation.prototype.getCalculationDataValues.call( this );
-                dose: '0.6 mg/kg'
-            }
+        data.drug = this.drug;
-         }, {
-            indication: 'neuromuscularBlockadeRsi',
+         data.indication = data[ this.getVariablePrefix() + 'indication' ] ?
-             population: 'general',
+             mw.calculators.getDrugIndication( mw.calculators.getVariable( this.getVariableIds().indication ).value ) :
-             dose: {
+            null;
-                dose: '1.2 mg/kg'
-            }
+        delete data[ this.getVariablePrefix() + 'indication' ];
+        data.preparation = data[ this.getVariablePrefix() + 'preparation' ] ?
+             this.drug.preparations[ mw.calculators.getVariable( this.getVariableIds().preparation ).value ] :
+            null;
+        delete data[ this.getVariablePrefix() + 'preparation' ];
+         return data;
+    };
+    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getLabelHtml = function() {
+        var labelHtml = this.drug.name;
+        var $label = $( '<a>', {
+             href: mw.util.getUrl( this.drug.name ),
+             text: labelHtml
+        } );
+        var highlightColor = this.drug.color.getHighlightColor();
+        if( highlightColor ) {
+            $label.css( 'background-color', highlightColor );
          }
-    ] );
+        labelHtml = $label[ 0 ].outerHTML;
+        return labelHtml;
+    };
-     /**
+     mw.calculators.objectClasses.DrugDosageCalculation.prototype.getProperties = function() {
-     * Sufentanil
+        var inheritedProperties = mw.calculators.objectClasses.AbstractCalculation.prototype.getProperties();
-     */
-     drugId = 'sufentanil';
+        return this.mergeProperties( inheritedProperties, {
+            required: [
+                'drug'
+            ],
+            optional: []
+        } );
+    };
+    mw.calculators.objectClasses.DrugDosageCalculation.prototype.getVariableIds = function() {
+        return {
+            indication: this.getVariablePrefix() + 'indication',
+            preparation: this.getVariablePrefix() + 'preparation'
+        };
+    };
+     mw.calculators.objectClasses.DrugDosageCalculation.prototype.getVariablePrefix = function() {
+        return this.drug.id + '-';
+    }
+    mw.calculators.objectClasses.DrugDosageCalculation.prototype.initialize = function() {
+        mw.calculators.objectClasses.AbstractCalculation.prototype.initialize.call( this );
+        var drug = mw.calculators.getDrug( this.drug );
-    mw.calculators.addDrugs( [
+        if( !drug ) {
-        {
+             throw new Error( 'DrugDosage references drug "' + this.drug + '" which is not defined' );
-             id: drugId,
-            name: 'Sufentanil',
-            color: 'opioid'
          }
-    ] );
-    mw.calculators.addDrugPreparations( drugId, [
+        this.drug = drug;
-         {
-            concentration: '5 mcg/mL'
+        var variableIds = this.getVariableIds();
-         },
-         {
+        // Create variables for indication, population?, preparation select boxes? Here or m.c.addDosages() or elsewhere?
-             concentration: '50 mcg/mL'
+        // Will have to add them to getCalculationData too.
+         var drugVariables = {};
+         var indications = this.drug.getIndications();
+        var indicationOptions = {};
+         for( var iIndication in indications ) {
+             var indication = indications[ iIndication ];
+            indicationOptions[ indication.id ] = String( indication );
          }
-    ] );
-    mw.calculators.addDrugDosages( drugId, [
+        drugVariables[ variableIds.indication ] = {
-        {
+             name: 'Indication',
-             indication: 'tivaLoad',
+             type: 'string',
-             population: 'general',
+             defaultValue: indications.length ? indications[ 0 ].id : null,
-             dose: {
+            options: indicationOptions
-                min: '0.25 mcg/kg',
+        };
-                max: '2 mcg/kg',
-                weightCalculation: 'lbw'
+         var preparations = this.drug.getPreparations();
-            }
+        var preparationOptions = {};
-         }, {
-             indication: 'tivaMaintenance',
+        for( var iPreparation in preparations ) {
-            population: 'general',
+             var preparation = preparations[ iPreparation ];
-             dose: {
-                name: 'Maintenance',
+             preparationOptions[ preparation.id ] = String( preparation );
-                min: '0.5 mcg/kg/hr',
-                max: '1.5 mcg/kg/hr'
-            }
          }
-    ] );
+        drugVariables[ variableIds.preparation ] = {
+            name: 'Preparation',
+            type: 'string',
+            defaultValue: preparations.length ? preparations[ 0 ].id : null,
+            options: preparationOptions
+        };
+        mw.calculators.addVariables( drugVariables );
+    };
      /**
-      * Sugammadex
+      * Class DrugDosageCalculator
+     * @param {Object} propertyValues
+     * @returns {mw.calculators.objectClasses.DrugDosageCalculator}
+     * @constructor
       */
-     drugId = 'sugammadex';
+     mw.calculators.objectClasses.DrugDosageCalculator = function( propertyValues ) {
+        mw.calculators.objectClasses.CalculatorObject.call( this, this.getProperties(), propertyValues );
+    };
-     mw.calculators.addDrugs( [
+     mw.calculators.objectClasses.DrugDosageCalculator.prototype = Object.create( mw.calculators.objectClasses.AbstractCalculator.prototype );
-        {
-            id: drugId,
-            name: 'Sugammadex',
-            color: 'neuromuscularBlockerReversal'
-        }
-    ] );
-     mw.calculators.addDrugDosages( drugId, [
+     mw.calculators.objectClasses.DrugDosageCalculator.prototype.doRender = function() {
-         {
+         var $calculatorContainer = $( '.' + this.getContainerClass() );
-            indication: 'neuromuscularBlockadeReversal',
-            population: 'general',
-            dose: {
-                min: '2 mg/kg',
-                max: '4 mg/kg',
-                absoluteMax: '16 mg/kg'
-            }
-        }
-    ] );
-    mw.calculators.addDrugPreparations( drugId, [
+        if( !$calculatorContainer.length ) {
-        {
+             return;
-             concentration: '100 mg/mL'
          }
-    ] );
+        $calculatorContainer.empty();
+        $calculatorContainer.append( $( '<h4>', {
+            text: this.name
+        } ) );
+        var $calculationsContainer = $( '<table>', {
+            class: 'wikitable'
+        } ).append( '<tbody>' );
+        $calculatorContainer.append( $calculationsContainer );
+        $calculationsContainer
+            .append( $( '<tr>' )
+                .append(
+                    $( '<th>' ).text( 'Drug' ),
+                    $( '<th>' ).text( 'Indication' ),
+                    $( '<th>' ).text( 'Dose' )
+                )
+            );
+        for( var iCalculationId in this.calculations ) {
+            var calculation = mw.calculators.getCalculation( this.calculations[ iCalculationId ] );
+            var calculationContainerClass = calculation.getContainerClass();
+            var $calculationContainer = $( '<tr>', {
+                class: calculationContainerClass
+            } );
-    /**
+            $calculationsContainer.append( $calculationContainer );
-     * DrugDosage
-     *
-     * Structure is:
-     *
-     * drugId: {
-     *     indicationId: {
-     *         doseId: {
-     *
-     *         }
-     *     }
-     * }
-     */
-    var drugDosages = {
+             calculation.render();
-        cefazolin: {
-             abxProphylaxis: {
-                general: {
-                    population: 'general',
-                    dose: '2 g'
-                },
-                general120kg: {
-                    population: {
-                        id: 'general',
-                        variables: {
-                            weight: {
-                                min: '120 kg'
-                            }
-                        }
-                    },
-                    dose: '3 g'
-                },
-                pediatric: {
-                    dose: {
-                        absoluteMax: '2 g',
-                        dose: '30 mg/kg'
-                    }
-                },
-                pediatric120kg: {
-                    population: {
-                        id: 'pediatric',
-                        variables: {
-                            weight: {
-                                min: '120 kg'
-                            }
-                        }
-                    },
-                    dose: {
-                        dose: '3 g'
-                    }
-                }
-            }
          }
+    };
+    mw.calculators.objectClasses.DrugDosageCalculator.prototype.getProperties = function() {
+        var inheritedProperties = mw.calculators.objectClasses.AbstractCalculator.prototype.getProperties();
+        return this.mergeProperties( inheritedProperties, {
+            required: [],
+            optional: []
+        } );
      };
 }() );