//////////////////////////////////////////////////////////////// 
// 
// PURPOSE: This contains ScienceModule parameters for Tethys.
//
// NOTES:   All values (except "strings") must be followed by
//          a unit abbreviation (or one of the unit-like
//          abbreviations: n/a, bool, enum, count). 
// 
//////////////////////////////////////////////////////////////// 

   Aanderaa_O2.loadAtStartup    = 0 bool;
   Aanderaa_O2.simulateHardware = 1 bool;
   Aanderaa_O2.model            = "";
   Aanderaa_O2.power            = 0.42 watt;
   
   BackSeatDriver.loadAtStartup        = 0 bool;
   BackSeatDriver.simulateHardware     = 0 bool;
   BackSeatDriver.lcmListenChannelName = "BackSeatDriverStatus";
   BackSeatDriver.shutdownCmd          = "shutdown";
   BackSeatDriver.lcmListenerTimeout   = 2.5 second;
   BackSeatDriver.verbosity            = 0 count;
   
   CANONSampler.loadAtStartup    = 0 bool;
   CANONSampler.simulateHardware = 0 bool;
   CANONSampler.rotateOnly       = 0 bool;
   CANONSampler.sampleTimeout    = 6 minute;

   CTD_NeilBrown.loadAtStartup    = 0 bool;
   CTD_NeilBrown.simulateHardware = 0 bool;
   CTD_NeilBrown.maxPressBound    = 500 decibar;
   CTD_NeilBrown.minPressBound    = -10 decibar;
   CTD_NeilBrown.maxSalinityBound = 38 psu;
   CTD_NeilBrown.minSalinityBound = 28 psu;
   CTD_NeilBrown.offset           = 0 decibar;
   CTD_NeilBrown.power            = 0.29 watt;

   CTD_Seabird.loadAtStartup         = 0 bool;
   CTD_Seabird.simulateHardware      = 1 bool;
   CTD_Seabird.maxPressBound         = 500 decibar;
   CTD_Seabird.minPressBound         = -10 decibar;
   CTD_Seabird.maxSalinityBound      = 38 psu;
   CTD_Seabird.minSalinityBound      = 28 psu;
   CTD_Seabird.offset                = 0 decibar;
   CTD_Seabird.verbosity             = 0 count;
   CTD_Seabird.SBE43FSerialNumber    = 0 n/a int32; // Set SBE43FSerialNumber to 0 if the oxygen sensor is not installed
   CTD_Seabird.oxygenCalCoeffFOffset = 0.0 n/a;
   CTD_Seabird.oxygenCalCoeffSoc     = 0.0 n/a;
   CTD_Seabird.oxygenCalCoeffA       = 0.0 n/a;
   CTD_Seabird.oxygenCalCoeffB       = 0.0 n/a;
   CTD_Seabird.oxygenCalCoeffC       = 0.0 n/a;
   CTD_Seabird.oxygenCalCoeffE       = 0.0 n/a;

   CTD_SeabirdLCM.loadAtStartup    = 0 bool;
   CTD_SeabirdLCM.simulateHardware = 1 bool;
   CTD_SeabirdLCM.maxPressBound    = 500 decibar;
   CTD_SeabirdLCM.minPressBound    = -10 decibar;
   CTD_SeabirdLCM.maxSalinityBound = 38 psu;
   CTD_SeabirdLCM.minSalinityBound = 28 psu;
   
   ESPComponent.loadAtStartup          = 0 bool;
   ESPComponent.simulateHardware       = 0 bool;
   ESPComponent.connectTimeout         = 30 second; // to connect as client to the ESP
   ESPComponent.debug                  = 0 bool;
   ESPComponent.espLogFilterRegex      = "Selecting Cartridge|Sampled|Error|Underpressure|Overpressure|Fail|Retry|Cmd::|Sampler::";  // if non-empty, regex to select lines from ESP log in final report upon sampling completion
   ESPComponent.espServerHost          = ""; // when non-empty must have the format "hostname:portNumber", indicating where the ESP is listening as a server
   ESPComponent.filterCompleteTimeout  = 120 minute; // Per Brent, 120min to allow for error masking (previously 90min)
   ESPComponent.filterResultTimeout    = 30 second;
   ESPComponent.initialPromptTimeout   = 20 second;
   ESPComponent.loadCartridgeTimeout   = 10 minute;
   ESPComponent.poTimeout              = 150 second; // to wait for ESP to connect once it's powered on
   ESPComponent.power                  = 10 watt;
   ESPComponent.pppConnect             = "linkname esp noauth local lock 115200 134.89.10.51:134.89.10.60 persist maxfail 0 holdoff 10 lcp-echo-interval 60 lcp-echo-failure 3 proxyarp ktune deflate 12 ms-dns 134.89.10.32 ms-dns 134.89.10.10";
   ESPComponent.pppFlow                = "xonxoff asyncmap A0000";
   ESPComponent.processCompleteTimeout = 90 minute; // This allows for Surface Plasmon Resonance (SPR) analytics to run.
   ESPComponent.processResultTimeout   = 30 second;
   ESPComponent.sampleTimeout          = 30 minute; // only applies when simulateHardware is true; otherwise, the overall sample timeout is the aggregation of the following timeouts
   ESPComponent.socketServerPort       = 9999 count; // used when LRAUV starts as a server (then waiting for the ESP to connect as a client)
   ESPComponent.stopResultTimeout      = 2 minute;
   ESPComponent.upsync                 = "rsync -azPq --timeout=60 esp@esp:'/var/log/esp/real /var/log/esp/real.out /var/log/esp/real.slot /var/log/esp/*.spr' /LRAUV/ESPlogs";
   ESPComponent.upsyncTimeout          = 5 minute;

   ISUS.loadAtStartup    = 0 bool;
   ISUS.simulateHardware = 1 bool;
   ISUS.nitrateAccuracy  = 4 umol/l;
   ISUS.power            = 7.78 watt;

   PAR_Licor.loadAtStartup    = 1 bool;
   PAR_Licor.simulateHardware = 1 bool;
   PAR_Licor.adcCal           = 5.90145e-6 uA/count; // = Vref/gain/ohms/ADCRange*1e6 uA/A ~= 2.5/101/2000/2^21*1e6
   PAR_Licor.darkCount        = 930 count;
   PAR_Licor.maxBound         = 3600 umol/s/m2;
   PAR_Licor.maxValidPitch    = 25 degree;
   PAR_Licor.minBound         = 0 umol/s/m2;
   PAR_Licor.minValidPitch    = 15 degree;
   PAR_Licor.multiplier       = 315.79 umol/s/m2/uA; // from calibration sheet
   PAR_Licor.parCal           = 1.0 none; // determine in the lab per sensor to account for light attenuation in the filter, etc.
   PAR_Licor.serial           = "UWQ4562";

   Turner_Cyclops_rhodamine.loadAtStartup         = 0 bool;
   Turner_Cyclops_rhodamine.simulateHardware      = 0 bool;
   Turner_Cyclops_rhodamine.concentrationStandard = 10 ppb;
   Turner_Cyclops_rhodamine.maxBound              = 36000 ppb;
   Turner_Cyclops_rhodamine.minBound              = 0 ppb;
   Turner_Cyclops_rhodamine.scale                 = 2.384 microvolt; // per count of A/D
   Turner_Cyclops_rhodamine.serial                = "TBD";
   Turner_Cyclops_rhodamine.voltageBlank          = 0.4 volt;
   Turner_Cyclops_rhodamine.voltageStandard       = 0.5 volt;

   Turbulence_NPS.loadAtStartup    = 0 bool;
   Turbulence_NPS.simulateHardware = 1 bool;
   Turbulence_NPS.power            = 2.0 watt;

   VemcoVR2C.loadAtStartup    = 0 bool;
   VemcoVR2C.simulateHardware = 0 bool;
   VemcoVR2C0.power           = 0.18 watt

   WetLabsBB2FL.loadAtStartup    = 1 bool;
   WetLabsBB2FL.simulateHardware = 1 bool;
   WetLabsBB2FL.chlAccuracy      = NaN ug/l;
   WetLabsBB2FL.darkCounts470    = -1 count;
   WetLabsBB2FL.darkCounts650    = -1 count;
   WetLabsBB2FL.darkCountsChl    = -1 count;
   WetLabsBB2FL.power            = 0.75 watt;
   WetLabsBB2FL.scaleFactor470   = NaN 1/m/sr/count;
   WetLabsBB2FL.scaleFactor650   = NaN 1/m/sr/count;
   WetLabsBB2FL.scaleFactorChl   = NaN ug/l/count;
   WetLabsBB2FL.serial           = "";

   WetLabsSeaOWL_UV_A.loadAtStartup    = 0 bool;
   WetLabsSeaOWL_UV_A.simulateHardware = 1 bool;
   WetLabsSeaOWL_UV_A.chlAccuracy      = 1.475 ug/l;
   WetLabsSeaOWL_UV_A.darkCounts700    = 48 count;
   WetLabsSeaOWL_UV_A.darkCountsChl    = 50 count;
   WetLabsSeaOWL_UV_A.darkCountsFDOM   = 50 count;
   WetLabsSeaOWL_UV_A.darkCountsOil    = 50 count;
   WetLabsSeaOWL_UV_A.fdomAccuracy     = 8.19 ppb;
   WetLabsSeaOWL_UV_A.oilAccuracy      = 3.6 ppb;
   WetLabsSeaOWL_UV_A.period           = 0.400 s;
   WetLabsSeaOWL_UV_A.power            = 0.75 watt;
   WetLabsSeaOWL_UV_A.scaleFactor700   = 3.204e-7 1/m/sr/count;
   WetLabsSeaOWL_UV_A.scaleFactorChl   = 2.170e-3 ug/l/count;
   WetLabsSeaOWL_UV_A.scaleFactorFDOM  = 8.096e-3 ppb/count;
   WetLabsSeaOWL_UV_A.scaleFactorOil   = 2.8 ppb/count;
   WetLabsSeaOWL_UV_A.serial           = "";
   WetLabsSeaOWL_UV_A.timeout          = 15 s;
   
   WetLabsUBAT.loadAtStartup           = 0 bool;
   WetLabsUBAT.simulateHardware        = 1 bool;
   WetLabsUBAT.serial                  = "UBAT####"; // replace with installed UBAT S/N
   WetLabsUBAT.flowrateCalibCoeff      = 0.0004 none_float; // obtain from UBAT cal sheet
   WetLabsUBAT.minFlowrate             = 0.05 liter_per_second;
   WetLabsUBAT.optionalArgs            = "";