/// <summary>
/// Attaches a new outgoing stream to the process unit
/// </summary>
/// <param name="stream">The stream to attach</param>
/// <returns>Whether or not the stream was successfully attached</returns>
public virtual bool AttachOutgoingStream(AbstractStream stream)
{
if (CanAcceptOutgoingStream(stream))
{
m_outgoingStreams.Add(stream);
StreamsChanged(this, EventArgs.Empty);
return(true);
}
return(false);
}
public StreamPropertiesTable(AbstractStream parentStream)
{
m_type = (parentStream is HeatStream) ? StreamType.Heat : StreamType.Chemical;
// Keep a reference to the parent stream
m_parent = parentStream;
if (StreamType.Chemical == m_type)
{
m_temperature = "TM" + parentStream.Id.ToString();
}
// Add a default row for heat streams
if (StreamType.Heat == m_type)
{
AddNewRow();
}
}
/// <summary>
/// Gets whether or not the process unit can accept the specified stream as an outgoing stream
/// in its current state.
/// </summary>
public virtual bool CanAcceptOutgoingStream(AbstractStream stream)
{
// We can never accept a single stream as both incoming and outgoing (meaning this
// process unit would be both the source and destination of the stream), so check
// for this first.
if (this == stream.Destination)
{
return(false);
}
//first, figure out how many units we have
var result = from c in m_outgoingStreams
where c.GetType() == stream.GetType()
select c;
int numResults = result.Count();
//at this poing I'm breaking down and doing type checking. I think that there's
//a way to not check types, but for now, this is what I have to do
int maxTypes = 0;
if (stream is HeatStream)
{
maxTypes = MaxOutgoingHeatStreams;
}
else if (stream is ChemicalStream)
{
maxTypes = MaxOutgoingStreams;
}
//-1 because -1 means infinity
if (maxTypes == -1)
{
return(true);
}
else
{
return(maxTypes > numResults);
}
}
/// <summary>
/// Removes a stream from the workspace. Any process units that have this stream in
/// their list of incoming or outgoing streams will have it removed.
/// Note that no undo/redo actions are created in this function. If undo/redo actions
/// are desired, they must be handled elsewhere.
/// </summary>
public void RemoveStream(AbstractStream stream)
{
foreach (AbstractProcessUnit apu in m_procUnits)
{
if (apu.IncomingStreams.Contains(stream))
{
apu.DetachIncomingStream(stream);
}
if (apu.OutgoingStreams.Contains(stream))
{
apu.DetachOutgoingStream(stream);
}
}
m_streams.Remove(stream);
// Invoke the collection change event, if non-null
if (null != StreamsCollectionChanged)
{
StreamsCollectionChanged(this, EventArgs.Empty);
}
}
public void AddStream(AbstractStream stream)
{
if (null == stream)
{
throw new ArgumentNullException(
"Cannot add a null stream to a workspace");
}
// Make sure that the stream ID is unique. This is very important.
if (null != GetStream(stream.Id))
{
throw new InvalidOperationException(string.Format(
"A stream with ID={0} already exists in the workspace. The new stream that was " +
"passed to \"AddAStream\" also had this ID. Each stream in the workspace is required " +
"to have a unique ID.", stream.Id));
}
m_streams.Add(stream);
if (null != StreamsCollectionChanged)
{
StreamsCollectionChanged(this, EventArgs.Empty);
}
}
/// <summary>
/// Dettaches an outgoing stream to the process unit
/// </summary>
/// <param name="stream">The stream to dettach</param>
public virtual void DetachOutgoingStream(AbstractStream stream)
{
m_outgoingStreams.Remove(stream);
StreamsChanged(this, EventArgs.Empty);
}
public StreamPropertiesTable(XElement loadFromMe, AbstractStream parentStream)
{
// Keep a reference to the parent stream
m_parent = parentStream;
if (loadFromMe.Name.LocalName.Equals("ChemicalStreamPropertiesWindow"))
{
// Set the type
m_type = StreamType.Chemical;
// Load the data rows
XElement dataRowsEl = loadFromMe.Element("DataRows");
if (null == dataRowsEl)
{
throw new Exception("Chemical stream properties XML is missing \"DataRows\" element.");
}
// Load each <ChemicalStreamData>
foreach (XElement csdEl in dataRowsEl.Elements("ChemicalStreamData"))
{
AddRow(new ChemicalStreamData(csdEl));
}
// Load the location
XElement locEl = loadFromMe.Element("Location");
m_location.X = Convert.ToDouble(locEl.Element("X").Value);
m_location.Y = Convert.ToDouble(locEl.Element("Y").Value);
// Look for <Temperature> node
XElement temperatureEl = loadFromMe.Element("Temperature");
if (null != temperatureEl)
{
m_temperature = temperatureEl.Element("Quantity").Value;
m_temperatureUnits = Convert.ToInt32(temperatureEl.Element("Units").Value);
// Look for "UserHasChangedTemperature" element. This property was added in
// August 2012 which is after several professors had been working with
// ChemProV files. So in older files this element is not likely to be present.
XElement userChangedEl = temperatureEl.Element("UserHasChangedTemperature");
if (null != userChangedEl)
{
if (!bool.TryParse(userChangedEl.Value, out m_userHasChangedTemperature))
{
// Default to false if the parse fails
m_userHasChangedTemperature = false;
}
}
}
}
else if (loadFromMe.Name.LocalName.Equals("HeatStreamPropertiesWindow"))
{
// Set the type
m_type = StreamType.Heat;
// Load the data rows
XElement dataRowsEl = loadFromMe.Element("DataRows");
if (null == dataRowsEl)
{
throw new Exception("Chemical stream properties XML is missing \"DataRows\" element.");
}
// Load each <HeatStreamData>
foreach (XElement hsdEl in dataRowsEl.Elements("HeatStreamData"))
{
AddRow(new HeatStreamData(hsdEl));
}
// Load the location
XElement locEl = loadFromMe.Element("Location");
m_location.X = Convert.ToDouble(locEl.Element("X").Value);
m_location.Y = Convert.ToDouble(locEl.Element("Y").Value);
}
else
{
throw new Exception("Unknown stream property table element: " + loadFromMe.Name);
}
}
public void Load(XDocument doc)
{
// Start by clearing
Clear();
string setting = doc.Element("ProcessFlowDiagram").Attribute("DifficultySetting").Value;
TrySetDifficulty((OptionDifficultySetting)Enum.Parse(typeof(OptionDifficultySetting), setting, true));
// Load process units. We have to do this before the streams because the stream loading
// does the attaching to the process units.
XElement processUnits = doc.Descendants("ProcessUnits").ElementAt(0);
foreach (XElement xmPU in processUnits.Elements())
{
m_procUnits.Add(ProcessUnitFactory.Create(xmPU));
}
// Load streams (constructors attach process units)
XElement streamList = doc.Descendants("Streams").ElementAt(0);
foreach (XElement streamElement in streamList.Elements())
{
// Check the type so we know what to create
string unitType = (string)streamElement.Attribute("StreamType");
if ("Chemical" == unitType)
{
m_streams.Add(new ChemicalStream(streamElement, m_procUnits));
}
else
{
m_streams.Add(new HeatStream(streamElement, m_procUnits));
}
// Remember that the properties tables are not stored within the
// stream element and get loaded later
}
// Now that the streams are loaded, we can load the properties windows
XElement tablesList = doc.Descendants("PropertiesWindows").ElementAt(0);
foreach (XElement table in tablesList.Elements())
{
// Get the table's target
string parentName = (string)table.Element("ParentStream");
// Create the properties table
AbstractStream parentStream = GetStream(Convert.ToInt32(parentName.Split('_')[1]));
parentStream.PropertiesTable = new StreamPropertiesTable(table, parentStream);
}
// Load equations
XElement equations = doc.Descendants("Equations").ElementAt(0);
foreach (XElement xmlEquation in equations.Elements())
{
EquationModel rowModel = EquationModel.FromXml(xmlEquation);
m_equations.Add(rowModel);
}
// Load the sticky notes
XElement stickyNoteList = doc.Descendants("StickyNotes").ElementAt(0);
foreach (XElement note in stickyNoteList.Elements())
{
m_stickyNotes.Add(new Logic.StickyNote(note, null));
}
// Check for degrees of freedom analysis
XElement df = doc.Element("ProcessFlowDiagram").Element("DegreesOfFreedomAnalysis");
if (null != df)
{
m_dfAnalysis.Text = df.Element("Text").Value;
foreach (XElement el in df.Elements("Comment"))
{
string userName = string.Empty;
XAttribute userAttr = el.Attribute("UserName");
if (null != userAttr)
{
userName = userAttr.Value;
}
m_dfAnalysis.Comments.Add(new BasicComment(el.Value, userName));
}
}
else
{
m_dfAnalysis.Text = string.Empty;
}
// Fire events
StreamsCollectionChanged(this, EventArgs.Empty);
ProcessUnitsCollectionChanged(this, EventArgs.Empty);
}
