protected void OnStreamDetached(UnitOperation uo, ProcessStreamBase ps)
{
if (StreamDetached != null)
{
StreamDetached(uo, ps);
}
}
protected void OnStreamAttached(UnitOperation uo, ProcessStreamBase ps, int streamIndex)
{
if (StreamAttached != null)
{
StreamAttached(uo, ps, streamIndex);
}
}
private void QueueStreamsAndUnitOpsForErase(UnitOperation unitOp)
{
if (!eraseSolvableQueue.Contains(unitOp) && !unitOp.IsBeingExecuted)
{
eraseSolvableQueue.Enqueue(unitOp);
}
IList inletStreams = unitOp.InOutletStreams;
foreach (ProcessStreamBase ps in inletStreams)
{
//if ps has already been queued go to next ps
if (eraseSolvableQueue.Contains(ps))
{
continue;
}
eraseSolvableQueue.Enqueue(ps);
if (ps.UpStreamOwner != null && ps.UpStreamOwner != unitOp)
{
QueueStreamsAndUnitOpsForErase(ps.UpStreamOwner);
}
if (ps.DownStreamOwner != null && ps.DownStreamOwner != unitOp)
{
QueueStreamsAndUnitOpsForErase(ps.DownStreamOwner);
}
}
}
protected void OnUnitOpAdded(UnitOperation unitOp)
{
if (UnitOpAdded != null)
{
UnitOpAdded(unitOp);
}
OnSystemChanged();
}
public CrossSectionGeometry(CrossSectionType crossSectionType, UnitOperation owner) : base()
{
this.owner = owner;
this.crossSectionType = crossSectionType;
diameter = new ProcessVarDouble(StringConstants.DIAMETER, PhysicalQuantity.SmallLength, VarState.Specified, owner);
width = new ProcessVarDouble(StringConstants.WIDTH, PhysicalQuantity.Length, VarState.Specified, owner);
height = new ProcessVarDouble(StringConstants.HEIGHT, PhysicalQuantity.Length, VarState.Specified, owner);
heightWidthRatio = new ProcessVarDouble(StringConstants.HEIGHT_WIDTH_RATIO, PhysicalQuantity.Unknown, VarState.Specified, owner);
InitializeVarListAndRegisterVars();
}
public UnitOperation GetUnitOperation(string name)
{
UnitOperation retValue = null;
ArrayList unitOps = GetUnitOpList();
foreach (UnitOperation uo in unitOps)
{
if (uo.Name.Equals(name))
{
retValue = uo;
break;
}
}
return(retValue);
}
private void QueueStreamsAndUnitOpsForErase(ProcessStreamBase stream)
{
UnitOperation uo = stream.UpStreamOwner;
if (uo != null && !eraseSolvableQueue.Contains(uo))
{
QueueStreamsAndUnitOpsForErase(stream.UpStreamOwner);
}
uo = stream.DownStreamOwner;
if (uo != null && !eraseSolvableQueue.Contains(uo))
{
QueueStreamsAndUnitOpsForErase(stream.DownStreamOwner);
}
}
private void QueueStreamsAndUnitOpsforForCalculate(ProcessStreamBase stream, bool specify)
{
//debug code
Trace.WriteLine("Queue stream " + stream.Name);
//debug code
UnitOperation uo = stream.UpStreamOwner;
if (uo != null && (specify || (!specify && !uo.HasSolvedAlready)) && !calculateUnitOpQueue.Contains(uo))
{
QueueStreamsAndUnitOpsForCalculate(stream.UpStreamOwner, specify);
}
uo = stream.DownStreamOwner;
if (uo != null && (specify || (!specify && !uo.HasSolvedAlready)) && !calculateUnitOpQueue.Contains(stream.DownStreamOwner))
{
QueueStreamsAndUnitOpsForCalculate(stream.DownStreamOwner, specify);
}
}
private void QueueStreamsAndUnitOpsForCalculate(UnitOperation unitOp, bool specify)
{
//debug code
Trace.WriteLine("Queue unitOp " + unitOp.Name);
//debug code
//if (unitOp != currentUnitOp && !unitOp.AllDone && !calculateUnitOpQueue.Contains(unitOp)) {
if (!unitOp.HasSolvedAlready && !calculateUnitOpQueue.Contains(unitOp) && !unitOp.IsBeingExecuted)
{
//calculateUnitOpQueue.Enqueue(unitOp);
EnqueueCalculateUnitOp(unitOp);
}
if (!specify)
{
return;
}
IList inletStreams = unitOp.InOutletStreams;
foreach (ProcessStreamBase ps in inletStreams)
{
//if ps has already been queued go to next ps
if (calculateStreamQueue.Contains(ps))
{
continue;
}
if (!ps.HasSolvedAlready && !calculateStreamQueue.Contains(ps))
{
calculateStreamQueue.Enqueue(ps);
}
if (ps.UpStreamOwner != null && ps.UpStreamOwner != unitOp)
{
QueueStreamsAndUnitOpsForCalculate(ps.UpStreamOwner, specify);
}
if (ps.DownStreamOwner != null && ps.DownStreamOwner != unitOp)
{
QueueStreamsAndUnitOpsForCalculate(ps.DownStreamOwner, specify);
}
}
}
private void QueueStreamsAndUnitOpsForErase(Solvable solvable)
{
ProcessStreamBase ps = solvable as ProcessStreamBase;
if (ps != null)
{
if (!eraseSolvableQueue.Contains(ps))
{
eraseSolvableQueue.Enqueue(ps);
}
QueueStreamsAndUnitOpsForErase(ps);
}
else
{
UnitOperation uo = solvable as UnitOperation;
if (uo != null && !eraseSolvableQueue.Contains(uo))
{
QueueStreamsAndUnitOpsForErase(uo);
}
}
}
private void EnqueueCalculateUnitOp(UnitOperation unitOp)
{
UnitOperation aUnitOp;
if (calculateUnitOpQueue.Count == 0)
{
calculateUnitOpQueue.Add(unitOp);
}
else
{
for (int i = calculateUnitOpQueue.Count - 1; i >= 0; i--)
{
aUnitOp = calculateUnitOpQueue[i] as UnitOperation;
if (unitOp.SolvingPriority >= aUnitOp.SolvingPriority)
{
calculateUnitOpQueue.Insert(i + 1, unitOp);
return;
}
}
calculateUnitOpQueue.Insert(0, unitOp);
}
}
private void QueueStreamsAndUnitOpsForCalculate(Solvable solvable, bool specify)
{
Trace.WriteLine("Queue solvable " + solvable.Name);
if (solvable is ProcessStreamBase)
{
ProcessStreamBase ps = solvable as ProcessStreamBase;
if (!ps.HasSolvedAlready)
{
calculateStreamQueue.Enqueue(ps);
}
QueueStreamsAndUnitOpsforForCalculate(ps, specify);
}
else if (solvable is UnitOperation)
{
UnitOperation uo = solvable as UnitOperation;
if (!calculateUnitOpQueue.Contains(uo))
{
QueueStreamsAndUnitOpsForCalculate(uo, specify);
}
}
}
public CrossSectionGeometry(UnitOperation owner) :
this(CrossSectionType.Circle, owner)
{
}
