// ----------------------------------------------------
// =======================================================================
//
public override bool PreProcess(int year, WaterSimManagerClass WSimClass)
{
WaterSimManager WSim = (WSimClass as WaterSimManager);
PreProcessMyWaterManagementProcess(year, WSim);
PreProcessMyDroughtManagementProcess(year, WSim);
PreProcessIndicatorsProcess(year, WSim);
return(base.PreProcess(year, WSim));
}
public void MyPreProcess(int year, WaterSimManager WS)
{
if (year == 2000)
{
for (int p = 0; p < ProviderClass.NumberOfProviders; p++)
{
Initial_Credits[p] = WS.Groundwater_Balance.getvalues().Values[p];
}
}
}
public override bool ProcessStarted(int year, WaterSimManagerClass WSimClass)
{
WaterSimManager WS = (WSimClass as WaterSimManager);
//
ProcessWaterManagement(year, WS);
ProcessDrought(year, WS);
ProcessIndicators(year, WS);
//
return(base.ProcessStarted(year, WS));
}
///-------------------------------------------------------------------------------------------------
/// <summary> Method called when Sumulation is stopped. </summary>
/// <param name="WSim"> The simulation. </param>
/// <returns> true if it succeeds, false if it fails. </returns>
///-------------------------------------------------------------------------------------------------
public override bool ProcessStop(WaterSimManagerClass WSimClass)
{
WaterSimManager WSim = (WSimClass as WaterSimManager);
// Reset Pop Overide
ProviderIntArray Reset = new ProviderIntArray(-1);
WSim.Population_Override_On.setvalues(Reset);
WSim.Population_Override_Other.setvalues(Reset);
return(base.ProcessStop(WSim));
}
///-------------------------------------------------------------------------------------------------
/// <summary> Method that is called before each annual run. </summary>
/// <param name="year"> The year about to be run. </param>
/// <param name="WSim"> The WaterSimManager that is making call. </param>
/// <returns> true if it succeeds, false if it fails. Error should be placed in FErrorMessage.
/// </returns>
///-------------------------------------------------------------------------------------------------
public override bool PreProcess(int year, WaterSimManagerClass WSimClass)
{
WaterSimManager WSim = (WSimClass as WaterSimManager);
// ProviderIntArray NewPopOff = new ProviderIntArray(0);
bool TempLock = WSim.isLocked();
WSim.UnLockSimulation();
//bool ManagingPop = false;
// for 2000 to 2010 just grab the projections
if (year < 2015)
{
} //WSim.Simulation_Start_Year + 1))
else
{
ProviderIntArray YearForZero = WSim.ParamManager.Model_ParameterBaseClass(eModelParam.epYearCreditsGoesNeg).ProviderProperty.getvalues();
ProviderIntArray IsTriggered = new ProviderIntArray(0);
// Check which are in unassured year range
for (int i = 0; i < YearForZero.Length; i++)
{
if (TestPolicy(YearForZero[i], (WSim as WaterSimManager)))
{
ConsecutiveDeficitYears[i]++;
if (ConsecutiveDeficitYears[i] > Max_Years_Deficit_Trigger)
{
IsTriggered[i] = 1;
// Once triggered always being managed
BeingManaged[i] = 1;
}
}
else
{
ConsecutiveDeficitYears[i] = 0;
}
}
PolicyClass.ManagePolicies(WSim, year, BeingManaged, IsTriggered);
//PopulationClass.LimitAndReallocateGrowth(WSim, year, BeingManaged, IsTriggered, FMaxUnassuredYears, ref NewPopOn, ref NewPopOff);
}
// Ok Set PopOverride Values
// for (int i = 0; i < NewPopOn.Length; i++)
// {
// WSim.Population_Override_On[i] = NewPopOn[i];
// }
// for (int i = 0; i < NewPopOff.Length; i++)
// {
// WSim.Population_Override_Other[i] = NewPopOff[i];
// }
// if (TempLock) WSim.LockSimulation();
return(base.PreProcess(year, WSim));
}
///-------------------------------------------------------------------------------------------------
/// <summary> method that is called right before the first year of a simulation is called.
/// </summary>
/// <param name="year"> The year about to be run. </param>
/// <param name="WSim"> The WaterSimManager that is making call. </param>
/// <returns> true if it succeeds, false if it fails. </returns>
///-------------------------------------------------------------------------------------------------
public override bool ProcessStarted(int year, WaterSimManagerClass WSimClass)
{
WaterSimManager WSim = (WSimClass as WaterSimManager);
// OK Simulation Starting, Parameters have been set, fetch the ReduceGOCD factor and use it to calculate rate
YrCount = 1;
FGPCDDeclineFactor = WSim.ParamManager.Model_Parameter(eModelParam.epPCT_Alter_GPCD).Value; // 7/29 WSim.ParamManager.BaseModel_ParameterBaseClass(eModelParam.epPCT_Reduce_GPCD).Value;
double TotalYears = Convert.ToDouble((WSim.Simulation_End_Year - WSim.Simulation_Start_Year) + 1);
AdjustFactor_Double = (Convert.ToDouble(FGPCDDeclineFactor) / 100) / TotalYears;
return(base.ProcessStarted(year, WSim));
}
///-------------------------------------------------------------------------------------------------
/// <summary> Constructor. </summary>
///<remarks> Does not evoke Form to set initial values, sets them to default values.</remarks>
/// <param name="WSim"> The WatewrSimManager who will register process. </param>
/// <param name="Quiet"> true to quiet. </param>
///-------------------------------------------------------------------------------------------------
public AWSLimitFeedbackProcess(WaterSimManager WSim, bool Quiet)
: base("AWS Limit Feedback")
{
if (Quiet)
{
Fname = "DEFAULT AWS LIMIT PROCESS";
}
else
{
EvokeDialogAndFetchValues();
}
SetUpProcessAndParameters(WSim);
}
///-------------------------------------------------------------------------------------------------
/// <summary> Constructor. </summary>
///<remarks>If Quiet Form to set initial values is not evoked and defualts used, otherwise form is evoked.</remarks>
/// <param name="WSim"> The WatewrSimManager who will register process. </param>
/// <param name="Quiet"> true to quiet. </param>
/// <remarks> Adds tracking parameter </remarks>
///-------------------------------------------------------------------------------------------------
public TrackProviderDeficitsParameter(WaterSimManager WSim, bool Quiet)
: base("Count Years of Provider Deficits")
{
AddTrackingParameter(WSim);
if (Quiet)
{
Fname = "DEFAULT DEFICIT TRACKING PROCESS";
}
else
{
EvokeDialogAndFetchValues(WSim);
}
}
//============================================
internal void SetUpProcessAndParameters(WaterSimManager WSim)
{
ModelParameterBaseClass MP = WSim.ParamManager.Model_ParameterBaseClass(eModelParam.epYearsNotAssured);
FWSim = WSim;
if (MP == null)
{
FAFPTracker = new TrackAvailableGroundwater("Tracking Support for AWS Limit", WSim);
WSim.ProcessManager.AddProcess(FAFPTracker);
}
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epYearsOfNonAWSTrigger, "Trigger for NonAWS Years", "NONAWSTRG", modelParamtype.mptInputBase, rangeChecktype.rctNoRangeCheck, 0, 0, geti_Max_Years_NonAWS_Trigger, null, seti_Max_Years_NonAWS_Trigger, null, null, null, null));
WSim.ProcessManager.ProcessManagerChangeEvent += OnProcessManagerProcessEventHandler;
}
//============================================
internal void SetUpPolicyProcessAndParameters(WaterSimManager WSim)
{
ModelParameterBaseClass MP = WSim.ParamManager.Model_ParameterBaseClass(eModelParam.epDeficit_Years);
FWSim = WSim;
if (MP == null)
{
FAFPTracker = new TrackGroundwaterCreditsProcess("Tracking Support for Credits Limit", WSim);
//FAFPTracker = new TrackAvailableGroundwater("Tracking Support for AWS Limit", WSim);
WSim.ProcessManager.AddProcess(FAFPTracker);
}
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epYearsOfCreditsTrigger, "Trigger for Negative Credit Balance", "NEGCREDITS", modelParamtype.mptInputBase, rangeChecktype.rctNoRangeCheck, 0, 0, geti_Max_Years_Deficit_Trigger, null, seti_Max_Years_Deficit_Trigger, null, null, null, null));
WSim.ProcessManager.ProcessManagerChangeEvent += OnProcessManagerProcessEventHandler;
}
///-------------------------------------------------------------------------------------------------
/// <summary> Constructor. </summary>
/// <remarks>Does not evoke form for initial State Values. Values set at defaults</remarks>
/// <param name="WSim"> The WatewrSimManager who will register process. </param>
/// <param name="Quiet"> true to quiet. </param>
///-------------------------------------------------------------------------------------------------
public AlterGPCDFeedbackProcess(WaterSimManager WSim, bool Quiet)
: base("Alter GPCD Based on Groundwater Credit Balance")
{
if (Quiet)
{
Fname = "DEFAULT PROCESS";
FMaxDifference = MAXDifferenceAllowed;
FMinGPCD = MINGPCDALLOWED;
}
else
{
EvokeDialogAndFetchValues();
}
}
///-------------------------------------------------------------------------------------------------
/// <summary> Evokes dialog and fetches values. </summary>
///-------------------------------------------------------------------------------------------------
protected void EvokeDialogAndFetchValues(WaterSimManager WSim)
{
TrackDeficitFeedbackProcessForm TPF = new TrackDeficitFeedbackProcessForm();
if (Fname != "")
{
TPF.ProcessName = Fname;
}
if (TPF.ShowDialog() == DialogResult.OK)
{
Fname = TPF.ProcessName;
FMaxDeficit = TPF.MaxDeficit;
}
}
// -------------------------------------------------------------
void ProcessDrought(int year, WaterSimManager WS)
{
double tempD = 1.0;
FDroughtManagementFactor = WS.ParamManager.Model_ParameterBaseClass(eModelParam.epClimateDrought).Value;
int temp = FDroughtManagementFactor;
switch (temp)
{
// Bypass the Process Drought Case Structure
case 0:
break;
// Use Canned Drought Scenarios
case 1:
WS.startDrought = 2030;
WS.endDrought = 2065;
tempD = 0.9;
break;
case 2:
WS.startDrought = 2020;
WS.endDrought = 2065;
tempD = 0.9;
break;
case 3:
WS.startDrought = 2030;
WS.endDrought = 2065;
tempD = 0.8;
break;
case 4:
WS.startDrought = 2020;
WS.endDrought = 2065;
tempD = 0.8;
break;
default:
if (2015 < year && year < 2020)
{
tempD = 1.0;
}
break;
}
modDrought = tempD;
// END of 0 < use
}
public override bool PreProcess(int year, WaterSimManagerClass WSimClass)
{
WaterSimManager WSim = (WSimClass as WaterSimManager);
bool TempLock = WSim.isLocked();
WSim.UnLockSimulation();
FetchValuesForPersonal(WSim);
if (TempLock)
{
WSim.LockSimulation();
}
return(base.PreProcess(year, WSim));
}
/// <summary>
/// Sampson 10.07.15
/// </summary>
/// <param name="WSim"></param>
/// <param name="Quiet"></param>
///
public AlterGPCDFeedbackProcess(WaterSimManager WSim, bool Quiet, string Astep)
: base("Alter GPCD Based annually")
{
if (Quiet)
{
Ftemporal = Quiet;
Fname = "Annual PROCESS";
//FMaxDifference = MAXDifferenceAllowed;
//FMinGPCD = MINGPCDALLOWED;
int year = 2000;
}
else
{
EvokeDialogAndFetchValues();
}
}
///-------------------------------------------------------------------------------------------------
/// <summary> Constructor. </summary>
///<remarks>If Quiet does not call Form to set initial values, uses defaults, else Form is opened</remarks>
/// <param name="WSim"> The WatewrSimManager who will register process. </param>
/// <param name="Quiet"> true to quiet. </param>
///-------------------------------------------------------------------------------------------------
public AlterGPCDAWSFeedbackProcess(WaterSimManager WSim, bool Quiet)
: base("Alter GPCD Based on AWS Rule")
{
if (Quiet)
{
Fname = "DEFUALT AWS ALTER GPCD PROCESS";
FMaxAWS = MAXAWS;
FMinGPCD = MINGPCDALLOWED;
FAnnualPercentDecline = MAXGPCDDECLINE;
}
else
{
EvokeDialogAndFetchValues();
}
SetUpProcessAndParameters(WSim);
}
internal void SetupParameters(WaterSimManager WSim)
{
// Only add one parameter Checking just in case more than one is added, Process manager should not allow more than one but that will
// not stop someone from constructing two objects and not add to ProcessManager
if (ClassCount == 0)
{
ClassCount++;
// Add % Groundwater
Percent_Credits_Available = new providerArrayProperty(WSim.ParamManager, eModelParam.epPCT_CreditsAvailable, get_PCT_CreditsAvail, eProviderAggregateMode.agWeighted);
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epPCT_CreditsAvailable, "Percent of Initial Groundwater Credits Available", "PCTCRED", modelParamtype.mptOutputProvider, rangeChecktype.rctNoRangeCheck, 0, 0, null, get_PCT_CreditsAvail, null, null, null, null, Percent_Credits_Available));
// epYearCreditsGoesNeg
Year_Credits_Go_Negative = new providerArrayProperty(WSim.ParamManager, eModelParam.epYearCreditsGoesNeg, get_PCT_CreditsAvail, eProviderAggregateMode.agWeighted);
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epYearCreditsGoesNeg, "Year that Credts go negative", "YRCREDNEG", modelParamtype.mptOutputProvider, rangeChecktype.rctNoRangeCheck, 0, 0, null, get_Year_CreditsGoNegative, null, null, null, null, Year_Credits_Go_Negative));
}
this.FWsim = WSim;
}
void PreProcessMyDroughtManagementProcess(int year, WaterSimManager WS)
{
if (WS.startDrought == year)
{
//WS.ParamManager.Model_Parameter("DC").Value = Convert.ToInt32(modDrought * 100);
}
if (WS.startDrought + 1 == year)
{
WS.ParamManager.Model_Parameter("DC").Value = 100;
}
if (WS.endDrought == year)
{
// WS.ParamManager.Model_Parameter("SUR").Value = Convert.ToInt32(initialFlowSurface);
}
//}
}
//----------------------------------------------------
/// <summary>
/// This is the ProcessMethod that keeps track of Deficits by provider
/// </summary>
/// <param name="year">Simulation Year (not used)</param>
/// <param name="WSim">The WaterSimManager object (used to get data)</param>
/// <returns></returns>
override public bool PostProcess(int year, WaterSimManagerClass WSimClass)
{
WaterSimManager WSim = (WSimClass as WaterSimManager);
ProviderIntArray Deficits = new ProviderIntArray();
ProviderIntArray CreditDeficits = new ProviderIntArray();
// get the deficit data
Deficits = WSim.Demand_Deficit.getvalues();
CreditDeficits = WSim.AF_water_CreditDeficits.getvalues();
foreach (eProvider ep in ProviderClass.providers())
{
if (Deficits[ep] > FMaxDeficit)
{
CountList[ep]++;
TotalList[ep] += Deficits[ep];
ContinuousList[ep]++;
if (LongestContinuous[ep] < ContinuousList[ep])
{
LongestContinuous[ep] = ContinuousList[ep];
}
}
else
{
ContinuousList[ep] = 0;
}
//
if (CreditDeficits[ep] > FMaxCreditDeficit)
{
CountList_2[ep]++;
TotalList_2[ep] += CreditDeficits[ep];
ContinuousList_2[ep]++;
if (LongestContinuous_2[ep] < ContinuousList_2[ep])
{
LongestContinuous_2[ep] = ContinuousList_2[ep];
}
}
}
return(true);
}
//
void PreProcessMyWaterManagementProcess(int year, WaterSimManager WS)
{
int surf = FSURFManagementFactor;
int gw = FGWManagementFactor;
int policy = FPolicyStartYear;
// Assumes the same management period for all management actions
//
//if (WS.startSGWM == year)
if (policy == year)
{
if (0 < surf)
{
WS.ParamManager.Model_Parameter("SWMC").Value = Convert.ToInt32(modSurface * 100);
}
if (0 < gw)
{
WS.ParamManager.Model_Parameter("GWMC").Value = Convert.ToInt32(modGroundwater * 100);
}
WS.WaterSimAmerica.invokePolicies = true;
}
//if (WS.startSGWM+1 == year)
if (policy + 1 == year)
{
WS.ParamManager.Model_Parameter("SWMC").Value = 100;
WS.ParamManager.Model_Parameter("GWMC").Value = 100;
WS.ParamManager.Model_Parameter("LWM").Value = 0;
WS.ParamManager.Model_Parameter("DESAL").Value = 0;
}
if (WS.endSGWM == year)
{
// This may need un-commenting
// 03.09.16
//WS.ParamManager.Model_Parameter("SUR").Value = Convert.ToInt32(initialFlowSurface);
//WS.ParamManager.Model_Parameter("GW").Value = Convert.ToInt32(initialFlowModGW);
//WS.ParamManager.Model_Parameter("SURL").Value = Convert.ToInt32(initialFlowLake);
//WS.ParamManager.Model_Parameter("DESAL").Value = Convert.ToInt32(initialDesal);
}
//
}
internal void SetupParameters(WaterSimManager WSim)
{
// Only add one parameter Checking just in case more than one is added, Process manager should not allow more than one but that will
// not stop someone from constructing two objects and not add to ProcessManager
if (ClassCount == 0)
{
ClassCount++;
// Add % Groundwater
Percent_Groundwater_Available = new providerArrayProperty(WSim.ParamManager, eModelParam.epPCT_GWAvailable, get_PCT_GWAvail, eProviderAggregateMode.agWeighted);
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epPCT_GWAvailable, "Percent of Initial Groundwater Available", "PCTGWAVL", modelParamtype.mptOutputProvider, rangeChecktype.rctNoRangeCheck, 0, 0, null, get_PCT_GWAvail, null, null, null, null, Percent_Groundwater_Available));
// Add Years of groundwater below zero
Years_GW_At_or_Below_Zero = new providerArrayProperty(WSim.ParamManager, eModelParam.epYrsGWZero, get_YearsOfZero, eProviderAggregateMode.agAverage);
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epYrsGWZero, "# of Years of Groundwater At or Below Zero", "YRGW0", modelParamtype.mptOutputProvider, rangeChecktype.rctNoRangeCheck, 0, 0, null, get_YearsOfZero, null, null, null, null, Years_GW_At_or_Below_Zero));
// add Year GW goes zero estimator
Year_Groundwater_Will_Be_Zero = new providerArrayProperty(WSim.ParamManager, eModelParam.epYearGWGoesZero, get_YearGWWillBeZero, eProviderAggregateMode.agAverage);
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epYearGWGoesZero, "The Year Estimated Groundwater Will Be Zero", "GW0WHEN", modelParamtype.mptOutputProvider, rangeChecktype.rctNoRangeCheck, 0, 0, null, get_YearGWWillBeZero, null, null, null, null, Year_Groundwater_Will_Be_Zero));
// add Years_Groundwater_Not_Assured/
Years_Groundwater_Not_Assured = new providerArrayProperty(WSim.ParamManager, eModelParam.epYearsNotAssured, get_Years_NotAssured, eProviderAggregateMode.agAverage);
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epYearsNotAssured, "# of Years Groundwater is Not ADWR Assured", "GWNOTAS", modelParamtype.mptOutputProvider, rangeChecktype.rctNoRangeCheck, 0, 0, null, get_Years_NotAssured, null, null, null, null, Years_Groundwater_Not_Assured));
}
this.FWsim = WSim;
}
///-------------------------------------------------------------------------------------------------
/// <summary> Adds a tracking model parameters. </summary>
///
/// <param name="WSim"> The WatewrSimManager who will mabage tracking aprameters. </param>
///-------------------------------------------------------------------------------------------------
private void AddTrackingParameter(WaterSimManager WSim)
{
Deficit_Years = new providerArrayProperty(WSim.ParamManager, eModelParam.epDeficit_Years, this.get_Deficit_Years, eProviderAggregateMode.agAverage);
// Added on 08.23.16 das
CreditDeficit_Years = new providerArrayProperty(WSim.ParamManager, eModelParam.epCreditDeficit_Years, this.get_CreditDeficit_Years, eProviderAggregateMode.agAverage);
// Only add one parameter Checking just in case more than one is added, Process manager should not allow more than one but that will
// not stop someone from constructing two objects and not add to ProcessManager
if (ClassCount == 0)
{
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epDeficit_Years, "Cumulative Years of Demand Deficit", "CUMDEF", modelParamtype.mptOutputProvider, rangeChecktype.rctNoRangeCheck, 0, 0, null, this.get_Deficit_Years, null, null, null, null, Deficit_Years));
FWSim = WSim;
}
ClassCount++;
if (ClassCount_2 == 0)
{
WSim.ParamManager.AddParameter(new ModelParameterClass(eModelParam.epCreditDeficit_Years, "Cumulative Years of Credit Deficit", "CREDDEF", modelParamtype.mptOutputProvider, rangeChecktype.rctNoRangeCheck, 0, 0, null, this.get_CreditDeficit_Years, null, null, null, null, Deficit_Years));
FWSim = WSim;
}
ClassCount_2++;
}
///-------------------------------------------------------------------------------------------------
/// <summary> Constructor. </summary>
///<remarks>Form to set initial values is evoked.</remarks>
/// <param name="WSim"> The WatewrSimManager who will register process. </param>
/// <remarks> Adds tracking parameter and evokes input dialog</remarks>
///-------------------------------------------------------------------------------------------------
public TrackProviderDeficitsParameter(WaterSimManager WSim)
: base("Count Years of Provider Deficits")
{
AddTrackingParameter(WSim);
EvokeDialogAndFetchValues(WSim);
}
protected void FetchValuesForPersonal(WaterSimManager WSim)
{
WSim.Web_Personal_PCT = WSim.PCT_Personal;
}
public Personal_GPCD_WebFeedbackProcess(string aName, WaterSimManager WSim)
: base(aName, WSim)
{
FetchValuesForPersonal(WSim);
}
public Personal_GPCD_WebFeedbackProcess(WaterSimManager WSim)
: base("Personal Use of Water")
{
FetchValuesForPersonal(WSim);
}
///-------------------------------------------------------------------------------------------------
/// <summary> Constructor. </summary>
/// <param name="aName"> Name of Process. </param>
/// <param name="WSim"> The WatewrSimManager who will register process</param>
/// <remarks> Adds tracking parameter and evokes input dialog</remarks>
///-------------------------------------------------------------------------------------------------
public TrackProviderDeficitsParameter(string aName, WaterSimManager WSim) : base(aName, WSim)
{
AddTrackingParameter(WSim);
EvokeDialogAndFetchValues(WSim);
}
///-------------------------------------------------------------------------------------------------
/// <summary> Method that is called before each annual run. </summary>
/// <param name="year"> The year about to be run. </param>
/// <param name="WSim"> The WaterSimManager that is making call. </param>
/// <returns> true if it succeeds, false if it fails. Error should be placed in FErrorMessage.
/// </returns>
///-------------------------------------------------------------------------------------------------
public override bool PreProcess(int year, WaterSimManagerClass WSimClass)
{
WaterSimManager WSim = (WSimClass as WaterSimManager);
ProviderIntArray PulledPopOn = WSim.Projected_OnProject_Pop.getvalues();
ProviderIntArray PulledPopOff = WSim.Projected_Other_Pop.getvalues();
ProviderIntArray NewPopOn = new ProviderIntArray(0);
ProviderIntArray NewPopOff = new ProviderIntArray(0);
bool TempLock = WSim.isLocked();
WSim.UnLockSimulation();
//bool ManagingPop = false;
// for 2000 to 2010 just grab the projections
if (year < 2011)
{
for (int i = 0; i < NewPopOn.Length; i++)
{
NewPopOn[i] = PulledPopOn[i];
}
for (int i = 0; i < NewPopOff.Length; i++)
{
NewPopOff[i] = PulledPopOff[i];
}
} //WSim.Simulation_Start_Year + 1))
else
{
ProviderIntArray LastYearOnPop = WSim.ParamManager.Model_ParameterBaseClass(eModelParam.epOnProjectPopulation).ProviderProperty.getvalues();
ProviderIntArray LastYearOffPop = WSim.ParamManager.Model_ParameterBaseClass(eModelParam.epOtherPopulation).ProviderProperty.getvalues();
ProviderIntArray YearForZero = WSim.ParamManager.Model_ParameterBaseClass(eModelParam.epYearGWGoesZero).ProviderProperty.getvalues();
ProviderIntArray IsTriggered = new ProviderIntArray(0);
// Check which are in unassured year range
for (int i = 0; i < YearForZero.Length; i++)
{
if (TestUnassured(YearForZero[i], (WSim as WaterSimManager)))
{
ConsecutiveUnassuredYears[i]++;
if (ConsecutiveUnassuredYears[i] > FMaxUnassuredYears)
{
IsTriggered[i] = 1;
// Once triggered always being managed
BeingManaged[i] = 1;
}
}
else
{
ConsecutiveUnassuredYears[i] = 0;
}
}
PopulationClass.LimitAndReallocateGrowth(WSim, year, BeingManaged, IsTriggered, FMaxUnassuredYears, ref NewPopOn, ref NewPopOff);
}
// Ok Set PopOverride Values
for (int i = 0; i < NewPopOn.Length; i++)
{
WSim.Population_Override_On[i] = NewPopOn[i];
}
for (int i = 0; i < NewPopOff.Length; i++)
{
WSim.Population_Override_Other[i] = NewPopOff[i];
}
if (TempLock)
{
WSim.LockSimulation();
}
return(base.PreProcess(year, WSim));
}
//============================================
private bool TestUnassured(int year, WaterSimManager WSim)
{
return((year > WSim.Simulation_Start_Year) && (year < (WSim.Simulation_Start_Year + 100)));
}
///-------------------------------------------------------------------------------------------------
/// <summary> Constructor. </summary>
///<remarks> Evokes Form to set initial values.</remarks>
/// <param name="WSim"> The WatewrSimManager who will register process. </param>
///-------------------------------------------------------------------------------------------------
public AWSLimitFeedbackProcess(WaterSimManager WSim)
: base("AWS Limit Feedback")
{
EvokeDialogAndFetchValues();
SetUpProcessAndParameters(WSim);
}
