{

// Class used to store a spectrum

public class Spectrum

{

// List of channels

private List<float> mChannels;

// Name of parent session

public string SessionName { get; set; }

// This spectrums session index

public int SessionIndex { get; set; }

// Label to use for this spectrum

public string Label { get; set; }

// Property to access channels

public List<float> Channels { get { return mChannels; } }

// Number of channels used for this spectrum

public float NumChannels { get; set; }

// Max count found in this spectrum

public float MaxCount { get; set; }

// Min count found in this spectrum

public float MinCount { get; set; }

// Total counts stored in this spectrum

public float TotalCount { get; set; }

// Latitude when this spectrum was started

public double Latitude { get; set; }

// Latitude error when this spectrum was started

public double LatitudeError { get; set; }

// Longitude when this spectrum was started

public double Longitude { get; set; }

// Longitude error when this spectrum was started

public double LongitudeError { get; set; }

// Altitude when this spectrum was started

public double Altitude { get; set; }

// Altitude error when this spectrum was started

public double AltitudeError { get; set; }

// Date and time when this spectrum was started

public DateTime GpsTime { get; set; }

public float GpsTrack { get; set; }

public float GpsTrackError { get; set; }

// Speed when this spectrum was started

public float GpsSpeed { get; set; }

// Speed error when this spectrum was started

public float GpsSpeedError { get; set; }

// Climb when this spectrum was started

public float GpsClimb { get; set; }

// Climb error when this spectrum was started

public float GpsClimbError { get; set; }

// Realtime for this spectrum

public int Realtime { get; set; }

// Livetime for this spectrum

public int Livetime { get; set; }

// Doserate for this spectrum in nanosievert per hour

public double Doserate { get; set; }

public Spectrum()

{

mChannels = new List<float>();

}

public Spectrum(burn.ProtocolMessage msg)

{

SessionName = msg.Params["session_name"].ToString();

SessionIndex = Convert.ToInt32(msg.Params["index"]);

Label = "Spectrum " + SessionIndex;

NumChannels = Convert.ToInt32(msg.Params["num_channels"]);

Latitude = Convert.ToDouble(msg.Params["latitude"], CultureInfo.InvariantCulture);

LatitudeError = Convert.ToDouble(msg.Params["latitude_error"], CultureInfo.InvariantCulture);

Longitude = Convert.ToDouble(msg.Params["longitude"], CultureInfo.InvariantCulture);

LongitudeError = Convert.ToDouble(msg.Params["longitude_error"], CultureInfo.InvariantCulture);

Altitude = Convert.ToDouble(msg.Params["altitude"], CultureInfo.InvariantCulture);

AltitudeError = Convert.ToDouble(msg.Params["altitude_error"], CultureInfo.InvariantCulture);

if(msg.Params["time"] == null || String.IsNullOrEmpty(msg.Params["time"].ToString().Trim()))

GpsTime = new DateTime(1900, 1, 1, 1, 1, 1);

else

GpsTime = Convert.ToDateTime(msg.Params["time"]);

GpsTrack = Convert.ToSingle(msg.Params["track"], CultureInfo.InvariantCulture);

GpsTrackError = Convert.ToSingle(msg.Params["track_error"], CultureInfo.InvariantCulture);

GpsSpeed = Convert.ToSingle(msg.Params["speed"], CultureInfo.InvariantCulture);

GpsSpeedError = Convert.ToSingle(msg.Params["speed_error"], CultureInfo.InvariantCulture);

GpsClimb = Convert.ToSingle(msg.Params["climb"], CultureInfo.InvariantCulture);

GpsClimbError = Convert.ToSingle(msg.Params["climb_error"], CultureInfo.InvariantCulture);

Realtime = Convert.ToInt32(msg.Params["realtime"]);

Livetime = Convert.ToInt32(msg.Params["livetime"]);

TotalCount = 0f;

Doserate = 0.0;

mChannels = new List<float>();

// Split channel string and store each count in channel array

LoadSpectrumString(msg.Params["channels"].ToString());

}

public override string ToString()

{

return SessionName + " - " + SessionIndex.ToString();

}

public void LoadSpectrumString(string spectrums)

{

mChannels.Clear();

string[] items = spectrums.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

foreach (string item in items)

{

float ch = Convert.ToSingle(item, CultureInfo.InvariantCulture);

mChannels.Add(ch);

if (ch > MaxCount)

MaxCount = ch;

if (ch < MinCount)

MinCount = ch;

TotalCount += ch;

}

}

public float GetCountInROI(int start, int end)

{

// Get count for a given ROI

if (start < 0 || start >= mChannels.Count || end < 0 || end >= mChannels.Count)

return 0f;

float max = 0f;

for (int i = start; i < end; i++)

max += mChannels[i];

return max;

}

public double CalculateDoserate(Detector det, LuaFunction GEFactorFunc)

{

// Calculate doserate for this spectrum

if (det == null)

throw new Exception("Unable to calculate doserate, detector is null");

if (GEFactorFunc == null)

throw new Exception("Unable to calculate doserate, GEFactorFunc is null");

Doserate = 0.0;

// Trim off discriminators

int startChan = (int)((double)det.NumChannels * (det.LLD / 100.0));

int endChan = (int)((double)det.NumChannels * (det.ULD / 100.0));

if(endChan > det.NumChannels) // FIXME: Can not exceed 100% atm

endChan = det.NumChannels;

// Accumulate doserates of each channel

for (int i = startChan; i < endChan; i++)

{

float sec = (float)Livetime / 1000000f;

float cps = Channels[i] / sec;

double E = det.GetEnergy(i) / 1000.0;

if (E < 0.05) // Energies below 0.05 are invalid

continue;

double GE = (double)GEFactorFunc.Call(E).GetValue(0);

double chanDose = GE * (cps * 60.0);

Doserate += chanDose;

}

return Doserate;

}

public Spectrum Clone()

{

// Create a clone of this spectrum

Spectrum res = new Spectrum();

res.mChannels.AddRange(mChannels.ToArray());

res.SessionName = SessionName;

res.SessionIndex = SessionIndex;

res.Label = Label;

res.NumChannels = NumChannels;

res.MaxCount = MaxCount;

res.MinCount = MinCount;

res.TotalCount = TotalCount;

res.Latitude = Latitude;

res.LatitudeError = LatitudeError;

res.Longitude = Longitude;

res.LongitudeError = LongitudeError;

res.Altitude = Altitude;

res.AltitudeError = AltitudeError;

res.GpsTime = GpsTime;

res.GpsTrack = GpsTrack;

res.GpsTrackError = GpsTrackError;

res.GpsSpeed = GpsSpeed;

res.GpsSpeedError = GpsSpeedError;

res.GpsClimb = GpsClimb;

res.GpsClimbError = GpsClimbError;

res.Realtime = Realtime;

res.Livetime = Livetime;

res.Doserate = Doserate;

return res;

}

public void Merge(Spectrum s)

{

// Merge a given spectrum

Livetime += s.Livetime;

Realtime += s.Realtime;

for(int i=0; i<mChannels.Count; i++)

mChannels[i] += s.mChannels[i];

}

}

public class APISpectrum

{

public APISpectrum(Spectrum spec)

{

SessionName = spec.SessionName;

SessionIndex = spec.SessionIndex;

StartTime = spec.GpsTime.ToString("yyyy-MM-ddThh:mm:ss.fffZ");

Latitude = spec.Latitude;

Longitude = spec.Longitude;

Altitude = spec.Altitude;

Track = spec.GpsTrack;

Speed = spec.GpsSpeed;

Climb = spec.GpsClimb;

Livetime = spec.Livetime;

Realtime = spec.Realtime;

NumChannels = (int)spec.NumChannels;

Channels = string.Join(" ", spec.Channels);

Doserate = spec.Doserate;

}

[JsonProperty("session_name")]

public string SessionName { get; set; }

[JsonProperty("session_index")]

public int SessionIndex { get; set; }

[JsonProperty("start_time")]

public string StartTime { get; set; }

[JsonProperty("latitude")]

public double Latitude { get; set; }

[JsonProperty("longitude")]

public double Longitude { get; set; }

[JsonProperty("altitude")]

public double Altitude { get; set; }

[JsonProperty("track")]

public double Track { get; set; }

[JsonProperty("speed")]

public double Speed { get; set; }

[JsonProperty("climb")]

public double Climb { get; set; }

[JsonProperty("livetime")]

public double Livetime { get; set; }

[JsonProperty("realtime")]

public double Realtime { get; set; }

[JsonProperty("num_channels")]

public int NumChannels { get; set; }

[JsonProperty("channels")]

public string Channels { get; set; }

[JsonProperty("doserate")]

public double Doserate { get; set; }

}