phast.h

#ifndef AMO_TOOLS_SUITE_LOSSES_H
#define AMO_TOOLS_SUITE_LOSSES_H

#include <nan.h>
#include <node.h>
#include <iostream>
#include <string>
#include "calculator/furnace/EfficiencyImprovement.h"
#include "calculator/furnace/EnergyEquivalency.h"
#include "calculator/furnace/FlowCalculationsEnergyUse.h"
#include "calculator/furnace/O2Enrichment.h"
#include "calculator/losses/Atmosphere.h"
#include "calculator/losses/AuxiliaryPower.h"
#include "calculator/losses/EnergyInputExhaustGasLosses.h"
#include "calculator/losses/EnergyInputEAF.h"
#include "calculator/losses/ExhaustGasEAF.h"
#include "calculator/losses/FixtureLosses.h"
#include "calculator/losses/GasFlueGasMaterial.h"
#include "calculator/losses/SolidLiquidFlueGasMaterial.h"
#include "calculator/losses/LoadChargeMaterial.h"
#include "calculator/losses/GasCoolingLosses.h"
#include "calculator/losses/GasLoadChargeMaterial.h"
#include "calculator/losses/LeakageLosses.h"
#include "calculator/losses/LiquidCoolingLosses.h"
#include "calculator/losses/LiquidLoadChargeMaterial.h"
#include "calculator/losses/OpeningLosses.h"
#include "calculator/losses/SlagOtherMaterialLosses.h"
#include "calculator/losses/SolidLoadChargeMaterial.h"
#include "calculator/losses/WallLosses.h"
#include "calculator/losses/WaterCoolingLosses.h"
#include "calculator/furnace/HumidityRatio.h"
#include "calculator/util/Conversion.h"

using namespace Nan;
using namespace v8;

Local<Object> inp;
Local<Object> r;

double Get(std::string const & nm) {
    Local<String> getName = Nan::New<String>(nm).ToLocalChecked();
    v8::Isolate *isolate = v8::Isolate::GetCurrent();
    v8::Local<v8::Context> context = isolate->GetCurrentContext();
    Local<Value> rObj = Nan::To<Object>(inp).ToLocalChecked()->Get(context, getName).ToLocalChecked();
    if (rObj->IsUndefined()) {
        ThrowTypeError(std::string("Get method in phast.h: " + nm + " not present in object").c_str());
    }
    return Nan::To<double>(rObj).FromJust();
}

void SetR(std::string const &nm, double n)
{
    Local<String> getName = Nan::New<String>(nm).ToLocalChecked();
    Local<Number> getNum = Nan::New<Number>(n);
    Nan::Set(r, getName, getNum);
}

FlowCalculationsEnergyUse::Gas gas()
{
    return (FlowCalculationsEnergyUse::Gas)(int)Get("gasType");
}

FlowCalculationsEnergyUse::Section section()
{
    return (FlowCalculationsEnergyUse::Section)(int)Get("sectionType");
}

NAN_METHOD(atmosphere)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double inletTemperature = Get("inletTemperature");
    const double outletTemperature = Get("outletTemperature");
    const double flowRate = Get("flowRate");
    const double correctionFactor = Get("correctionFactor");
    const double specificHeat = Get("specificHeat");

    Atmosphere a(inletTemperature, outletTemperature, flowRate, correctionFactor, specificHeat);
    double heatLoss = a.getTotalHeat();
    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(auxiliaryPowerLoss)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double motorPhase = Get("motorPhase");
    const double supplyVoltage = Get("supplyVoltage");
    const double avgCurrent = Get("avgCurrent");
    const double powerFactor = Get("powerFactor");
    const double operatingTime = Get("operatingTime");

    auto const ap = AuxiliaryPower(motorPhase, supplyVoltage, avgCurrent, powerFactor, operatingTime);

    const double powerUsed = ap.getPowerUsed();
    Local<Number> retval = Nan::New(powerUsed);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(energyInputEAF)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double naturalGasHeatInput = Get("naturalGasHeatInput");
    const double coalCarbonInjection = Get("coalCarbonInjection");
    const double coalHeatingValue = Get("coalHeatingValue");
    const double electrodeUse = Get("electrodeUse");
    const double electrodeHeatingValue = Get("electrodeHeatingValue");
    const double otherFuels = Get("otherFuels");
    const double electricityInput = Get("electricityInput");

    EnergyInputEAF eaf(naturalGasHeatInput, coalCarbonInjection, coalHeatingValue, electrodeUse,
                       electrodeHeatingValue, otherFuels, electricityInput);
    const double heatDelivered = eaf.getHeatDelivered();
    const double totalChemicalEnergyInput = eaf.getTotalChemicalEnergyInput();

    SetR("heatDelivered", heatDelivered);
    SetR("totalChemicalEnergyInput", totalChemicalEnergyInput);
    info.GetReturnValue().Set(r);
}

NAN_METHOD(exhaustGasEAF)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double offGasTemp = Get("offGasTemp");
    const double CO = Get("CO");
    const double H2 = Get("H2");
    const double combustibleGases = Get("combustibleGases");
    const double vfr = Get("vfr");
    const double dustLoading = Get("dustLoading");

    ExhaustGasEAF eg(offGasTemp, CO, H2, combustibleGases, vfr, dustLoading);
    const double totalHeatExhaust = eg.getTotalHeatExhaust();

    Local<Number> retval = Nan::New(totalHeatExhaust);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(fixtureLosses)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double specificHeat = Get("specificHeat");
    const double feedRate = Get("feedRate");
    const double initialTemperature = Get("initialTemperature");
    const double finalTemperature = Get("finalTemperature");
    const double correctionFactor = Get("correctionFactor");

    FixtureLosses fl(specificHeat, feedRate, initialTemperature, finalTemperature, correctionFactor);
    double heatLoss = fl.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(gasCoolingLosses)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double flowRate = Get("flowRate");
    const double initialTemperature = Get("initialTemperature");
    const double finalTemperature = Get("finalTemperature");
    const double specificHeat = Get("specificHeat");
    const double correctionFactor = Get("correctionFactor");
    const double gasDensity = Get("gasDensity");

    GasCoolingLosses gcl(flowRate, initialTemperature, finalTemperature, specificHeat, correctionFactor,
                         gasDensity);
    const double heatLoss = gcl.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(gasLoadChargeMaterial)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double specificHeatGas = Get("specificHeatGas");
    const double feedRate = Get("feedRate");
    const double percentVapor = Get("percentVapor");
    const double initialTemperature = Get("initialTemperature");
    const double dischargeTemperature = Get("dischargeTemperature");
    const double specificHeatVapor = Get("specificHeatVapor");
    const double percentReacted = Get("percentReacted");
    const double reactionHeat = Get("reactionHeat");
    const double additionalHeat = Get("additionalHeat");
    const double thermicReactionTypeInput = Get("thermicReactionType");

    LoadChargeMaterial::ThermicReactionType thermicReactionType;
    if (thermicReactionTypeInput == 0)
    {
        thermicReactionType = LoadChargeMaterial::ThermicReactionType::ENDOTHERMIC;
    }
    else
    {
        thermicReactionType = LoadChargeMaterial::ThermicReactionType::EXOTHERMIC;
    }
    GasLoadChargeMaterial glcm(thermicReactionType, specificHeatGas, feedRate, percentVapor, initialTemperature,
                               dischargeTemperature, specificHeatVapor, percentReacted, reactionHeat, additionalHeat);
    double heatLoss = glcm.getTotalHeat();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(leakageLosses)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double draftPressure = Get("draftPressure");
    const double openingArea = Get("openingArea");
    const double leakageGasTemperature = Get("leakageGasTemperature");
    const double ambientTemperature = Get("ambientTemperature");
    const double coefficient = Get("coefficient");
    const double specificGravity = Get("specificGravity");
    const double correctionFactor = Get("correctionFactor");

    LeakageLosses ll(draftPressure, openingArea, leakageGasTemperature, ambientTemperature,
                     coefficient, specificGravity, correctionFactor);
    double heatLoss = ll.getExfiltratedGasesHeatContent();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(liquidCoolingLosses)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double flowRate = Get("flowRate");
    const double density = Get("density");
    const double initialTemperature = Get("initialTemperature");
    const double outletTemperature = Get("outletTemperature");
    const double specificHeat = Get("specificHeat");
    const double correctionFactor = Get("correctionFactor");

    LiquidCoolingLosses lcl(flowRate, density, initialTemperature, outletTemperature,
                            specificHeat, correctionFactor);
    double heatLoss = lcl.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(liquidLoadChargeMaterial)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double specificHeatLiquid = Get("specificHeatLiquid");
    const double vaporizingTemperature = Get("vaporizingTemperature");
    const double latentHeat = Get("latentHeat");
    const double specificHeatVapor = Get("specificHeatVapor");
    const double chargeFeedRate = Get("chargeFeedRate");
    const double initialTemperature = Get("initialTemperature");
    const double dischargeTemperature = Get("dischargeTemperature");
    const double percentVaporized = Get("percentVaporized");
    const double percentReacted = Get("percentReacted");
    const double reactionHeat = Get("reactionHeat");
    const double additionalHeat = Get("additionalHeat");
    const double thermicReactionTypeInput = Get("thermicReactionType");

    LoadChargeMaterial::ThermicReactionType thermicReactionType;
    if (thermicReactionTypeInput == 0)
    {
        thermicReactionType = LoadChargeMaterial::ThermicReactionType::ENDOTHERMIC;
    }
    else
    {
        thermicReactionType = LoadChargeMaterial::ThermicReactionType::EXOTHERMIC;
    }
    LiquidLoadChargeMaterial llcm(thermicReactionType, specificHeatLiquid, vaporizingTemperature, latentHeat,
                                  specificHeatVapor, chargeFeedRate, initialTemperature, dischargeTemperature,
                                  percentVaporized, percentReacted, reactionHeat, additionalHeat);
    double heatLoss = llcm.getTotalHeat();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(openingLossesCircular)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double emissivity = Get("emissivity");
    const double diameter = Get("diameter");
    const double thickness = Get("thickness");
    const double ratio = Get("ratio");
    const double ambientTemperature = Get("ambientTemperature");
    const double insideTemperature = Get("insideTemperature");
    const double percentTimeOpen = Get("percentTimeOpen");
    const double viewFactor = Get("viewFactor");

    OpeningLosses ol(emissivity, diameter, thickness, ratio, ambientTemperature,
                     insideTemperature, percentTimeOpen, viewFactor);
    double heatLoss = ol.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}
NAN_METHOD(openingLossesQuad)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double emissivity = Get("emissivity");
    const double length = Get("length");
    const double width = Get("width");
    const double thickness = Get("thickness");
    const double ratio = Get("ratio");
    const double ambientTemperature = Get("ambientTemperature");
    const double insideTemperature = Get("insideTemperature");
    const double percentTimeOpen = Get("percentTimeOpen");
    const double viewFactor = Get("viewFactor");

    OpeningLosses ol(emissivity, length, width, thickness, ratio,
                     ambientTemperature, insideTemperature, percentTimeOpen, viewFactor);
    double heatLoss = ol.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

OpeningLosses::OpeningShape getOpeningShape()
{
    unsigned val = static_cast<unsigned>(Get("openingShape"));
    return static_cast<OpeningLosses::OpeningShape>(val);
}

NAN_METHOD(viewFactorCalculation)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double thickness = Get("thickness");

    OpeningLosses opening;
    OpeningLosses::OpeningShape shape = getOpeningShape();
    if (shape == OpeningLosses::OpeningShape::CIRCULAR)
    {
        const double diameter = Get("diameter");
        Local<Number> rv = Nan::New(opening.calculateViewFactor(thickness, diameter));
        info.GetReturnValue().Set(rv);
    }
    else
    {
        const double length = Get("length");
        const double width = Get("width");
        Local<Number> rv = Nan::New(opening.calculateViewFactor(thickness, length, width));
        info.GetReturnValue().Set(rv);
    }
}

NAN_METHOD(slagOtherMaterialLosses)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double weight = Get("weight");
    const double inletTemperature = Get("inletTemperature");
    const double outletTemperature = Get("outletTemperature");
    const double specificHeat = Get("specificHeat");
    const double correctionFactor = Get("correctionFactor");

    SlagOtherMaterialLosses sl(weight, inletTemperature, outletTemperature, specificHeat, correctionFactor);
    double heatLoss = sl.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(solidLoadChargeMaterial)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double specificHeatSolid = Get("specificHeatSolid");
    const double latentHeat = Get("latentHeat");
    const double specificHeatLiquid = Get("specificHeatLiquid");
    const double meltingPoint = Get("meltingPoint");
    const double chargeFeedRate = Get("chargeFeedRate");
    const double waterContentCharged = Get("waterContentCharged");
    const double waterContentDischarged = Get("waterContentDischarged");
    const double initialTemperature = Get("initialTemperature");
    const double dischargeTemperature = Get("dischargeTemperature");
    const double waterVaporDischargeTemperature = Get("waterVaporDischargeTemperature");
    const double chargeMelted = Get("chargeMelted");
    const double chargeReacted = Get("chargeReacted");
    const double reactionHeat = Get("reactionHeat");
    const double additionalHeat = Get("additionalHeat");
    const double thermicReactionTypeInput = Get("thermicReactionType");

    LoadChargeMaterial::ThermicReactionType thermicReactionType;
    if (thermicReactionTypeInput == 0)
    {
        thermicReactionType = LoadChargeMaterial::ThermicReactionType::ENDOTHERMIC;
    }
    else
    {
        thermicReactionType = LoadChargeMaterial::ThermicReactionType::EXOTHERMIC;
    }
    SolidLoadChargeMaterial slcm(thermicReactionType, specificHeatSolid, latentHeat, specificHeatLiquid, meltingPoint, chargeFeedRate, waterContentCharged, waterContentDischarged,
                                 initialTemperature, dischargeTemperature, waterVaporDischargeTemperature, chargeMelted, chargeReacted, reactionHeat, additionalHeat);
    double heatLoss = slcm.getTotalHeat();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(wallLosses)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double surfaceArea = Get("surfaceArea");
    const double ambientTemperature = Get("ambientTemperature");
    const double surfaceTemperature = Get("surfaceTemperature");
    const double windVelocity = Get("windVelocity");
    const double surfaceEmissivity = Get("surfaceEmissivity");
    const double conditionFactor = Get("conditionFactor");
    const double correctionFactor = Get("correctionFactor");

    WallLosses wl(surfaceArea, ambientTemperature, surfaceTemperature, windVelocity,
                  surfaceEmissivity, conditionFactor, correctionFactor);
    double heatLoss = wl.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(waterCoolingLosses)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double flowRate = Get("flowRate");
    const double initialTemperature = Get("initialTemperature");
    const double outletTemperature = Get("outletTemperature");
    const double correctionFactor = Get("correctionFactor");

    WaterCoolingLosses wcl(flowRate, initialTemperature, outletTemperature, correctionFactor);
    double heatLoss = wcl.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

// Furnace calculators

NAN_METHOD(efficiencyImprovement)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double currentFlueGasOxygen = Get("currentFlueGasOxygen");
    const double newFlueGasOxygen = Get("newFlueGasOxygen");
    const double currentFlueGasTemp = Get("currentFlueGasTemp");
    const double newFlueGasTemp = Get("newFlueGasTemp");
    const double currentCombustionAirTemp = Get("currentCombustionAirTemp");
    const double newCombustionAirTemp = Get("newCombustionAirTemp");
    const double currentEnergyInput = Get("currentEnergyInput");

    EfficiencyImprovement ei(currentFlueGasOxygen, newFlueGasOxygen, currentFlueGasTemp, newFlueGasTemp,
                             currentCombustionAirTemp, newCombustionAirTemp, currentEnergyInput);
    double currentExcessAir = ei.getCurrentExcessAir();
    double newExcessAir = ei.getNewExcessAir();
    double currentAvailableHeat = ei.getCurrentAvailableHeat();
    double newAvailableHeat = ei.getNewAvailableHeat();
    double newFuelSavings = ei.getNewFuelSavings();
    double newEnergyInput = ei.getNewEnergyInput();

    SetR("currentExcessAir", currentExcessAir);
    SetR("newExcessAir", newExcessAir);
    SetR("currentAvailableHeat", currentAvailableHeat);
    SetR("newAvailableHeat", newAvailableHeat);
    SetR("newFuelSavings", newFuelSavings);
    SetR("newEnergyInput", newEnergyInput);
    info.GetReturnValue().Set(r);
}

NAN_METHOD(energyEquivalencyElectric)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double fuelFiredEfficiency = Get("fuelFiredEfficiency");
    const double electricallyHeatedEfficiency = Get("electricallyHeatedEfficiency");
    const double fuelFiredHeatInput = Get("fuelFiredHeatInput");

    ElectricalEnergyEquivalency eee(fuelFiredEfficiency, electricallyHeatedEfficiency, fuelFiredHeatInput);
    double electricalHeatInput = eee.getElectricalHeatInput();

    SetR("electricalHeatInput", electricalHeatInput);
    info.GetReturnValue().Set(r);
}

NAN_METHOD(energyEquivalencyFuel)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double electricallyHeatedEfficiency = Get("electricallyHeatedEfficiency");
    const double fuelFiredEfficiency = Get("fuelFiredEfficiency");
    const double electricalHeatInput = Get("electricalHeatInput");

    FuelFiredEnergyEquivalency ffee(electricallyHeatedEfficiency, fuelFiredEfficiency, electricalHeatInput);
    double fuelFiredHeatInput = ffee.getFuelFiredHeatInput();

    SetR("fuelFiredHeatInput", fuelFiredHeatInput);
    info.GetReturnValue().Set(r);
}

NAN_METHOD(flowCalculations)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double specificGravity = Get("specificGravity");
    const double orificeDiameter = Get("orificeDiameter");
    const double insidePipeDiameter = Get("insidePipeDiameter");
    const double dischargeCoefficient = Get("dischargeCoefficient");
    const double gasHeatingValue = Get("gasHeatingValue");
    const double gasTemperature = Get("gasTemperature");
    const double gasPressure = Get("gasPressure");
    const double orificePressureDrop = Get("orificePressureDrop");
    const double operatingTime = Get("operatingTime");

    FlowCalculationsEnergyUse::Gas gas1 = gas();
    FlowCalculationsEnergyUse::Section section1 = section();
    FlowCalculationsEnergyUse fceu(gas1, specificGravity, orificeDiameter, insidePipeDiameter, section1, dischargeCoefficient,
                                   gasHeatingValue, gasTemperature, gasPressure, orificePressureDrop, operatingTime);
    double flow = fceu.getFlow();
    double heatInput = fceu.getHeatInput();
    double totalFlow = fceu.getTotalFlow();

    SetR("flow", flow);
    SetR("heatInput", heatInput);
    SetR("totalFlow", totalFlow);
    info.GetReturnValue().Set(r);
}

NAN_METHOD(flueGasLossesByVolume)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double CH4 = Get("CH4");
    const double C2H6 = Get("C2H6");
    const double N2 = Get("N2");
    const double H2 = Get("H2");
    const double C3H8 = Get("C3H8");
    const double C4H10_CnH2n = Get("C4H10_CnH2n");
    const double H2O = Get("H2O");
    const double CO = Get("CO");
    const double CO2 = Get("CO2");
    const double SO2 = Get("SO2");
    const double O2 = Get("O2");

    const double flueGasTemperature = Get("flueGasTemperature");
    const double excessAirPercentage = Get("excessAirPercentage");
    const double combustionAirTemperature = Get("combustionAirTemperature");
    const double fuelTemperature = Get("fuelTemperature");

    GasCompositions comps("", CH4, C2H6, N2, H2, C3H8,
                          C4H10_CnH2n, H2O, CO, CO2, SO2, O2);
    GasFlueGasMaterial fg(flueGasTemperature, excessAirPercentage, combustionAirTemperature,
                          comps, fuelTemperature);
    double heatLoss = fg.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(flueGasByVolumeCalculateHeatingValue)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double CH4 = Get("CH4");
    const double C2H6 = Get("C2H6");
    const double N2 = Get("N2");
    const double H2 = Get("H2");
    const double C3H8 = Get("C3H8");
    const double C4H10_CnH2n = Get("C4H10_CnH2n");
    const double H2O = Get("H2O");
    const double CO = Get("CO");
    const double CO2 = Get("CO2");
    const double SO2 = Get("SO2");
    const double O2 = Get("O2");

    GasCompositions comps("", CH4, C2H6, N2, H2, C3H8,
                          C4H10_CnH2n, H2O, CO, CO2, SO2, O2);
    double heatingValue = comps.getHeatingValue();
    double heatingValueVolume = comps.getHeatingValueVolume();
    double specificGravity = comps.getSpecificGravity();

    SetR("heatingValue", heatingValue);
    SetR("heatingValueVolume", heatingValueVolume);
    SetR("specificGravity", specificGravity);
    info.GetReturnValue().Set(r);
}

NAN_METHOD(flueGasLossesByMass)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double flueGasTemperature = Get("flueGasTemperature");
    const double excessAirPercentage = Get("excessAirPercentage");
    const double combustionAirTemperature = Get("combustionAirTemperature");
    const double fuelTemperature = Get("fuelTemperature");
    const double moistureInAirComposition = Get("moistureInAirComposition");
    const double ashDischargeTemperature = Get("ashDischargeTemperature");
    const double unburnedCarbonInAsh = Get("unburnedCarbonInAsh");
    const double carbon = Get("carbon");
    const double hydrogen = Get("hydrogen");
    const double sulphur = Get("sulphur");
    const double inertAsh = Get("inertAsh");
    const double o2 = Get("o2");
    const double moisture = Get("moisture");
    const double nitrogen = Get("nitrogen");

    SolidLiquidFlueGasMaterial slfgm(flueGasTemperature, excessAirPercentage, combustionAirTemperature,
                                     fuelTemperature, moistureInAirComposition, ashDischargeTemperature,
                                     unburnedCarbonInAsh, carbon, hydrogen, sulphur, inertAsh, o2, moisture,
                                     nitrogen);
    double heatLoss = slfgm.getHeatLoss();

    Local<Number> retval = Nan::New(heatLoss);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(flueGasByMassCalculateHeatingValue)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double carbon = Get("carbon");
    const double hydrogen = Get("hydrogen");
    const double sulphur = Get("sulphur");
    const double inertAsh = Get("inertAsh");
    const double o2 = Get("o2");
    const double moisture = Get("moisture");
    const double nitrogen = Get("nitrogen");

    auto const hv = SolidLiquidFlueGasMaterial::calculateHeatingValueFuel(carbon, hydrogen,
                                                                          sulphur, inertAsh, o2,
                                                                          moisture, nitrogen);

    Local<Number> retval = Nan::New(hv);
    info.GetReturnValue().Set(retval);
}

NAN_METHOD(flueGasCalculateO2)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double CH4 = Get("CH4");
    const double C2H6 = Get("C2H6");
    const double N2 = Get("N2");
    const double H2 = Get("H2");
    const double C3H8 = Get("C3H8");
    const double C4H10_CnH2n = Get("C4H10_CnH2n");
    const double H2O = Get("H2O");
    const double CO = Get("CO");
    const double CO2 = Get("CO2");
    const double SO2 = Get("SO2");
    const double O2 = Get("O2");
    double excessAir = Get("excessAir");

    GasCompositions comp("", CH4, C2H6, N2, H2, C3H8,
                         C4H10_CnH2n, H2O, CO, CO2, SO2, O2);
    excessAir = Conversion(excessAir).percentToFraction();
    double result = comp.calculateO2(excessAir);
    result = Conversion(result).fractionToPercent();

    Local<Number> rv = Nan::New(result);
    info.GetReturnValue().Set(rv);
}

NAN_METHOD(flueGasCalculateExcessAir)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    const double CH4 = Get("CH4");
    const double C2H6 = Get("C2H6");
    const double N2 = Get("N2");
    const double H2 = Get("H2");
    const double C3H8 = Get("C3H8");
    const double C4H10_CnH2n = Get("C4H10_CnH2n");
    const double H2O = Get("H2O");
    const double CO = Get("CO");
    const double CO2 = Get("CO2");
    const double SO2 = Get("SO2");
    const double O2 = Get("O2");
    double o2InFlueGas = Get("o2InFlueGas");

    GasCompositions comp("", CH4, C2H6, N2, H2, C3H8,
                         C4H10_CnH2n, H2O, CO, CO2, SO2, O2);
    o2InFlueGas = Conversion(o2InFlueGas).percentToFraction();
    double result = comp.calculateExcessAir(o2InFlueGas);
    result = Conversion(result).fractionToPercent();

    Local<Number> rv = Nan::New(result);
    info.GetReturnValue().Set(rv);
}

NAN_METHOD(flueGasByMassCalculateO2)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    double excessAir = Get("excessAir");
    double carbon = Get("carbon");
    double hydrogen = Get("hydrogen");
    double sulphur = Get("sulphur");
    double inertAsh = Get("inertAsh");
    double o2 = Get("o2");
    double moisture = Get("moisture");
    double nitrogen = Get("nitrogen");
    const double moistureInAirCombustion = Get("moistureInAirCombustion");

    excessAir = Conversion(excessAir).percentToFraction();
    carbon = Conversion(carbon).percentToFraction();
    hydrogen = Conversion(hydrogen).percentToFraction();
    sulphur = Conversion(sulphur).percentToFraction();
    inertAsh = Conversion(inertAsh).percentToFraction();
    o2 = Conversion(o2).percentToFraction();
    moisture = Conversion(moisture).percentToFraction();
    nitrogen = Conversion(nitrogen).percentToFraction();

    double v = SolidLiquidFlueGasMaterial::calculateFlueGasO2(excessAir, carbon,
                                                              hydrogen, sulphur,
                                                              inertAsh, o2, moisture,
                                                              nitrogen, moistureInAirCombustion);
    v = Conversion(v).fractionToPercent();

    Local<Number> rv = Nan::New(v);
    info.GetReturnValue().Set(rv);
}

NAN_METHOD(flueGasByMassCalculateExcessAir)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();

    double o2InFlueGas = Get("o2InFlueGas");
    double carbon = Get("carbon");
    double hydrogen = Get("hydrogen");
    double sulphur = Get("sulphur");
    double inertAsh = Get("inertAsh");
    double o2 = Get("o2");
    double moisture = Get("moisture");
    double nitrogen = Get("nitrogen");
    const double moistureInAirCombustion = Get("moistureInAirCombustion");

    o2InFlueGas = Conversion(o2InFlueGas).percentToFraction();
    carbon = Conversion(carbon).percentToFraction();
    hydrogen = Conversion(hydrogen).percentToFraction();
    sulphur = Conversion(sulphur).percentToFraction();
    inertAsh = Conversion(inertAsh).percentToFraction();
    o2 = Conversion(o2).percentToFraction();
    moisture = Conversion(moisture).percentToFraction();
    nitrogen = Conversion(nitrogen).percentToFraction();

    double v = SolidLiquidFlueGasMaterial::calculateExcessAirFromFlueGasO2(o2InFlueGas, carbon,
                                                                         hydrogen, sulphur, inertAsh,
                                                                         o2, moisture, nitrogen,
                                                                         moistureInAirCombustion);
    v = Conversion(v).fractionToPercent();

    Local<Number> rv = Nan::New(v);
    info.GetReturnValue().Set(rv);
}

NAN_METHOD(o2Enrichment)
{

    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double o2CombAir = Get("o2CombAir");
    const double o2CombAirEnriched = Get("o2CombAirEnriched");
    const double flueGasTemp = Get("flueGasTemp");
    const double flueGasTempEnriched = Get("flueGasTempEnriched");
    const double o2FlueGas = Get("o2FlueGas");
    const double o2FlueGasEnriched = Get("o2FlueGasEnriched");
    const double combAirTemp = Get("combAirTemp");
    const double combAirTempEnriched = Get("combAirTempEnriched");
    const double fuelConsumption = Get("fuelConsumption");

    O2Enrichment oe(o2CombAir, o2CombAirEnriched, flueGasTemp, flueGasTempEnriched, o2FlueGas,
                    o2FlueGasEnriched, combAirTemp, combAirTempEnriched, fuelConsumption);
    double availableHeatInput = oe.getAvailableHeat();
    double availableHeatEnriched = oe.getAvailableHeatEnriched();
    double fuelSavingsEnriched = oe.getFuelSavingsEnriched();
    double fuelConsumptionEnriched = oe.getFuelConsumptionEnriched();

    SetR("availableHeatInput", availableHeatInput);
    SetR("availableHeatEnriched", availableHeatEnriched);
    SetR("fuelSavingsEnriched", fuelSavingsEnriched);
    SetR("fuelConsumptionEnriched", fuelConsumptionEnriched);
    info.GetReturnValue().Set(r);
}

NAN_METHOD(energyInputExhaustGasLosses)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double excessAir = Get("excessAir");
    const double combustionAirTemp = Get("combustionAirTemp");
    const double exhaustGasTemp = Get("exhaustGasTemp");
    const double totalHeatInput = Get("totalHeatInput");

    EnergyInputExhaustGasLosses e(excessAir, combustionAirTemp, exhaustGasTemp, totalHeatInput);

    SetR("heatDelivered", e.getHeatDelivered());
    SetR("exhaustGasLosses", e.getExhaustGasLosses());
    SetR("availableHeat", e.getAvailableHeat());
    info.GetReturnValue().Set(r);
}

NAN_METHOD(humidityRatio)
{
    inp = Nan::To<Object>(info[0]).ToLocalChecked();
    r = Nan::New<Object>();

    const double atmosphericPressure = Get("atmosphericPressure");
    const double dryBulbTemp = Get("dryBulbTemp");
    const double relativeHumidity = Get("relativeHumidity");
    const double wetBulbTemp = Get("wetBulbTemp");

    HumidityRatio hr(atmosphericPressure, dryBulbTemp, relativeHumidity, wetBulbTemp);
    double humidityRatioUsingRH = hr.getHumidityRatioUsingRH();
    double humidityRatioUsingWBT = hr.getHumidityRatioUsingWBT();

    SetR("humidityRatioUsingRH", humidityRatioUsingRH);
    SetR("humidityRatioUsingWBT", humidityRatioUsingWBT);
    info.GetReturnValue().Set(r);
}

#endif //AMO_TOOLS_SUITE_LOSSES_H