public static bool CopyandInitStockCalculator(Calculator1 calc, ME2Stock newStock)
{
bool bHasCopy = false;
if (calc != null)
{
if (calc.GetType().Equals(newStock.GetType()))
{
ME2Stock oldStock = (ME2Stock)calc;
if (oldStock != null)
{
//initiate analyzer objects
newStock.InitTotalME2StocksProperties();
//but keep calc props
newStock.CopyCalculatorProperties(oldStock);
if (oldStock.CalcParameters != null)
{
newStock.CalcParameters = new CalculatorParameters(oldStock.CalcParameters);
}
bHasCopy = true;
}
}
}
return(bHasCopy);
}
private static bool SetBudgetChanges(ME2Stock me2Stock)
{
bool bHasChanges = false;
//replace list of totalstocks with list of changestocks
List <ME2Stock> obsStocks = new List <ME2Stock>();
List <int> baseIds = new List <int>();
List <int> xMinus1Ids = new List <int>();
int i = 0;
foreach (ME2Stock observation in me2Stock.Stocks)
{
//actual totals are contained in observation.Total1.Stocks (and Stocks are Total1s)
if (observation.Total1 != null &&
observation.ChangeType == CHANGE_TYPES.current.ToString())
{
//unlike totals, obsstock needs obs.CopyCalcs so it matches with baseelement
ME2Stock observationStock = new ME2Stock(observation.CalcParameters,
me2Stock.CalcParameters.AnalyzerParms.AnalyzerType);
//need the base el id
observationStock.CopyCalculatorProperties(observation);
//where the stats go
observationStock.Change1 = new ME2Change1(observation.CalcParameters);
observationStock.Change1.CalcParameters = new CalculatorParameters(me2Stock.CalcParameters);
observationStock.Change1.CopyCalculatorProperties(observation);
foreach (ME2Total1 total in observation.Total1.Stocks)
{
//add to observationStock for potential Ancestor calcs use
observationStock.Change1.InitTotalME2Change1Properties(observationStock.Change1);
observationStock.Change1.CopyTotalME2IndicatorStockProperties(observationStock.Change1, total);
}
//each of the stocks is a unique label-dependent total
observationStock.Change1.Stocks = new List <ME2Stock>();
//lists needed to store label-aggregated indicators (a1010, a1011) for each observation
List <ME2Change1> baseTotals = GetBaseChanges(baseIds, me2Stock, observation);
List <ME2Change1> xminus1Totals = GetXMinus1Changes(xMinus1Ids, me2Stock, observation);
AddChangesToStock(i, observation, observationStock,
baseTotals, xminus1Totals);
obsStocks.Add(observationStock);
i++;
}
}
if (obsStocks.Count > 0)
{
//replace the totalstocks with change stocks
me2Stock.Stocks = obsStocks;
bHasChanges = true;
}
return(bHasChanges);
}
public static ME2Stock GetNewME2Stock(CalculatorParameters calcParams,
Calculator1 baseElement, List <Calculator1> calcs, ME2Stock descendant)
{
ME2Stock newStock = new ME2Stock(calcParams, calcParams.AnalyzerParms.AnalyzerType);
if (calcs == null)
{
calcs = new List <Calculator1>();
}
if (calcs.Count > 0)
{
ME2AnalyzerHelper.CopyandInitStockCalculator(calcs
.FirstOrDefault(), newStock);
}
else
{
//need the options
newStock.CopyCalculatorProperties(descendant);
}
BIME2StockAnalyzer.CopyBaseElementProperties(baseElement, newStock);
return(newStock);
}
public ME2Stock SetME2Properties(CostBenefitCalculator baseElement,
XElement currentCalculationsElement, XElement currentElement)
{
ME2Stock me2 = new ME2Stock(this.GCCalculatorParams, this.GCCalculatorParams.AnalyzerParms.AnalyzerType);
//204 not used
//if (this.ME2DescendentStock != null)
//{
// //only property set by analyzer
// me2.TotalME2Stage = this.ME2DescendentStock.TotalME2Stage;
//}
ME2Calculator me2Calc = new ME2Calculator(this.GCCalculatorParams);
me2.CalcParameters.CurrentElementNodeName = currentElement.Name.LocalName;
bool bHasCalcs = false;
if (currentCalculationsElement != null)
{
//have to make sure its not a stockanalyzer
string sCalculatorType = CalculatorHelpers.GetAttribute(
currentCalculationsElement, Calculator1.cCalculatorType);
if (sCalculatorType == ME2CalculatorHelper.CALCULATOR_TYPES.me2.ToString())
{
//deserialize xml to object
me2Calc.SetME2Properties(currentCalculationsElement, currentElement);
//only need alttype and targettype (alts are groupedby using base elements)
baseElement.AlternativeType = me2Calc.AlternativeType;
baseElement.TargetType = me2Calc.TargetType;
bHasCalcs = true;
}
}
if (!bHasCalcs)
{
//see if a sibling holds the calculations (currentCalcs could be the analyzer)
XElement lv = CalculatorHelpers.GetChildLinkedViewUsingAttribute(currentElement,
Calculator1.cCalculatorType, ME2CalculatorHelper.CALCULATOR_TYPES.me2.ToString());
if (lv != null)
{
//deserialize xml to object
me2Calc.SetME2Properties(lv, currentElement);
//only need alttype and targettype (alts are groupedby using base elements)
baseElement.AlternativeType = me2Calc.AlternativeType;
baseElement.TargetType = me2Calc.TargetType;
bHasCalcs = true;
}
}
if (!bHasCalcs)
{
//else don't need the ids from calculator
me2.CopyCalculatorProperties(baseElement);
}
//all calcs and analyses are stored in the appropriate analysis object (i.e. me2.Total, me2.Stat)
me2.InitTotalME2StocksProperties();
//copy the initial calculator to the appropriate analysis object.ME2Indicators collection
me2.CopyME2CalculatorToME2Stock(me2Calc);
me2.AnalyzerType = this.GCCalculatorParams.AnalyzerParms.AnalyzerType;
//label and date comes from baseelement
me2.Label = baseElement.Label;
me2.Date = baseElement.Date;
//kiss with the multipliers
me2.Multiplier = baseElement.Multiplier;
me2.CalculatorId = me2Calc.Id;
//adjust id if children analyzers are being inserted/updated
ChangeCalculatorIdForUpdatedChildren(currentElement, ref currentCalculationsElement, me2);
return(me2);
}
public virtual void CopyTotalME2StocksProperties(
ME2Stock calculator)
{
if (calculator.Stocks != null)
{
//set up the new me2Stock
this.CopyCalculatorProperties(calculator);
this.AnalyzerType = calculator.AnalyzerType;
this.Stocks = new List <ME2Stock>();
foreach (ME2Stock obsStock in calculator.Stocks)
{
//set up the new stock for the stocks collection
ME2Stock stock = new ME2Stock(CalcParameters);
//stock gets same props as this (which are copied from calculator
stock.CopyCalculatorProperties(this);
stock.AnalyzerType = this.AnalyzerType;
//copy the analysis to the stock
if (this.AnalyzerType
== ME2AnalyzerHelper.ANALYZER_TYPES.mestat1.ToString())
{
if (obsStock.Stat1 != null)
{
stock.Stat1 = new ME2Stat1(this.CalcParameters);
stock.Stat1.CopyCalculatorProperties(this);
stock.Stat1.CopyTotalME2Stat1Properties(
obsStock.Stat1);
}
}
else if (this.AnalyzerType
== ME2AnalyzerHelper.ANALYZER_TYPES.mechangeyr.ToString() ||
this.AnalyzerType == ME2AnalyzerHelper.ANALYZER_TYPES.mechangeid.ToString() ||
this.AnalyzerType == ME2AnalyzerHelper.ANALYZER_TYPES.mechangealt.ToString())
{
if (obsStock.Change1 != null)
{
stock.Change1 = new ME2Change1(this.CalcParameters);
stock.Change1.CopyCalculatorProperties(this);
stock.Change1.CopyTotalME2Change1Properties(
obsStock.Change1);
}
}
else if (this.AnalyzerType
== ME2AnalyzerHelper.ANALYZER_TYPES.meprogress1.ToString())
{
this.Progress1 = new ME2Progress1(this.CalcParameters);
if (obsStock.Progress1 != null)
{
stock.Progress1 = new ME2Progress1(this.CalcParameters);
stock.Progress1.CopyCalculatorProperties(this);
stock.Progress1.CopyTotalME2Progress1Properties(
obsStock.Progress1);
}
}
else
{
if (obsStock.Total1 != null)
{
stock.Total1 = new ME2Total1(this.CalcParameters);
stock.Total1.CopyCalculatorProperties(this);
stock.Total1.CopyTotalME2Total1Properties(
obsStock.Total1);
}
}
this.Stocks.Add(stock);
}
}
}
private bool SetAnalyses(ME2Stock me2Stock)
{
bool bHasTotals = false;
if (me2Stock.Stocks != null)
{
//each of the stocks is an observation derived from alt2
List <ME2Stock> newStatStocks = new List <ME2Stock>();
foreach (ME2Stock totalStock in me2Stock.Stocks)
{
if (totalStock.Total1 != null)
{
if (totalStock.Total1.Stocks != null)
{
ME2Stock observationStock = new ME2Stock(this.CalcParameters,
me2Stock.CalcParameters.AnalyzerParms.AnalyzerType);
//stocks hold the calculatorids (sometimes me2Stock is parent running multiple children)
observationStock.CopyCalculatorProperties(totalStock);
//where the stats go
observationStock.Stat1 = new ME2Stat1(this.CalcParameters);
observationStock.Stat1.CalcParameters = new CalculatorParameters(totalStock.CalcParameters);
observationStock.Stat1.CopyCalculatorProperties(totalStock);
//each of the stocks is a unique label-dependent total
observationStock.Stat1.Stocks = new List <ME2Stock>();
foreach (ME2Stock totStock in totalStock.Total1.Stocks)
{
ME2Stat1 newStat = new ME2Stat1(this.CalcParameters);
//copy the totals and the indicators
CopyTotalME2IndicatorStockProperties(newStat, totStock);
if (newStat.ME2Indicators != null)
{
//set N
newStat.TME2N = newStat.ME2Indicators.Count;
//set the cost means
newStat.TotalME2MMean = newStat.TME2TMAmount / newStat.ME2Indicators.Count;
newStat.TotalME2LMean = newStat.TME2TLAmount / newStat.ME2Indicators.Count;
newStat.TotalME2UMean = newStat.TME2TUAmount / newStat.ME2Indicators.Count;
//set the median, variance, and standard deviation costs
SetME2TotalStatistics(newStat);
SetME2LTotalStatistics(newStat);
SetME2UTotalStatistics(newStat);
if (observationStock.Stat1.Stocks == null)
{
observationStock.Stat1.Stocks = new List <ME2Stock>();
}
observationStock.Stat1.Stocks.Add(newStat);
}
}
if (observationStock.Stat1.Stocks.Count > 0)
{
totalStock.Stocks = new List <ME2Stock>();
bHasTotals = true;
newStatStocks.Add(observationStock);
}
}
}
}
if (newStatStocks.Count > 0)
{
bHasTotals = true;
me2Stock.Stocks = newStatStocks;
}
}
return(bHasTotals);
}
private bool SetAnalyses(ME2Stock me2Stock, List <Calculator1> calcs)
{
bool bHasAnalysis = false;
bool bHasTotals = false;
//calcs are aggregated by their alternative2 property
//so calcs with alt2 = 0 are in first observation (i.e. year, alttype, wbs label); alt2 = 2nd observation
//put the calc totals in each observation and then run stats on observations (not calcs)
IEnumerable <System.Linq.IGrouping <int, Calculator1> >
calcsByAlt2 = calcs.GroupBy(c => c.Alternative2);
List <ME2Stock> obsStocks = new List <ME2Stock>();
foreach (var calcbyalt in calcsByAlt2)
{
//observationStock goes into me2Stock.Stocks
ME2Stock observationStock = new ME2Stock(me2Stock.CalcParameters,
me2Stock.CalcParameters.AnalyzerParms.AnalyzerType);
//set the calcprops using first calcbyalt -it has good calcids (me2Stock could be parent and have bad ids)
int i = 0;
//only the totStocks are used in results
//replace list of totalstocks with list of changestocks
foreach (Calculator1 calc in calcbyalt)
{
if (calc.GetType().Equals(me2Stock.GetType()))
{
//calc has the right ids and props
ME2Stock stock = (ME2Stock)calc;
if (i == 0)
{
//need base el id, not me2Stock id
observationStock.CopyCalculatorProperties(stock);
//where the totals go
observationStock.Total1 = new ME2Total1(this.CalcParameters);
observationStock.Total1.CalcParameters = new CalculatorParameters(stock.CalcParameters);
observationStock.Total1.CopyCalculatorProperties(stock);
}
if (stock != null)
{
//this initial calculator results are placed in this object
if (stock.Stocks != null)
{
foreach (ME2Stock obsStock in stock.Stocks)
{
if (obsStock.Total1 != null)
{
//set the multiplier; each calculator holds its own multiplier
obsStock.Total1.Multiplier = stock.Multiplier;
//run new calcs and put the result in stock.Total1.Stocks collection
//that is a label-dependent collection of totals1s
bHasTotals = observationStock.Total1.SetTotals(obsStock.Total1);
if (bHasTotals)
{
//1 total is enough for an analysis
bHasAnalysis = true;
}
}
}
}
}
}
i++;
}
if (bHasAnalysis)
{
//all analyes are now ready to run with good observations and collections of totals and indicators
obsStocks.Add(observationStock);
}
}
if (bHasAnalysis)
{
me2Stock.Stocks = new List <ME2Stock>();
me2Stock.Stocks = obsStocks;
}
return(bHasAnalysis);
}
private static bool SetChanges(ME2Stock me2Stock)
{
bool bHasChanges = false;
int i = 0;
//replace list of totalstocks with list of changestocks
List <ME2Stock> obsStocks = new List <ME2Stock>();
//lists needed to store label-aggregated indicators (a1010, a1011) for each observation
List <ME2Change1> baseTotals = new List <ME2Change1>();
List <ME2Change1> xminus1Totals = new List <ME2Change1>();
//loop throught the observations being compared
foreach (ME2Stock observation in me2Stock.Stocks)
{
//actual totals are contained in observation.Total1.Stocks (and Stocks are Total1s)
if (observation.Total1 != null)
{
if (observation.Total1.Stocks != null)
{
//unlike totals, obsstock needs obs.CopyCalcs so it matches with baseelement
ME2Stock observationStock = new ME2Stock(me2Stock.CalcParameters,
me2Stock.CalcParameters.AnalyzerParms.AnalyzerType);
//need the base el id
observationStock.CopyCalculatorProperties(observation);
//where the stats go
observationStock.Change1 = new ME2Change1(observation.CalcParameters);
observationStock.Change1.CalcParameters = new CalculatorParameters(me2Stock.CalcParameters);
//need the base el id
observationStock.Change1.CopyCalculatorProperties(observation);
//each of the stocks will be a unique label-dependent change
observationStock.Change1.Stocks = new List <ME2Stock>();
//if count == 0 will go to condition and insert all zeroes for change analysis
if (i == 0 &&
observation.Total1.Stocks.Count > 0)
{
//loop through the indicator label-aggregated totals
foreach (ME2Total1 total in observation.Total1.Stocks)
{
//and fill in the base list
ME2Change1 baseChange = new ME2Change1(observation.CalcParameters);
baseChange.CopyTotalME2IndicatorStockProperties(baseChange, total);
baseTotals.Add(baseChange);
//add to observationStock for potential Ancestor calcs use
observationStock.Change1.InitTotalME2Change1Properties(observationStock.Change1);
observationStock.Change1.CopyTotalME2IndicatorStockProperties(observationStock.Change1, total);
}
}
else
{
AddChangesToStock(i, observation, observationStock,
baseTotals, xminus1Totals);
xminus1Totals = new List <ME2Change1>();
//loop through the indicator label-aggregated totals
foreach (ME2Total1 total in observation.Total1.Stocks)
{
//and fill in the base list
ME2Change1 xminus1Change = new ME2Change1(observation.CalcParameters);
xminus1Change.CopyTotalME2IndicatorStockProperties(xminus1Change, total);
xminus1Totals.Add(xminus1Change);
//add to observationStock for potential Ancestor calcs use
observationStock.Change1.InitTotalME2Change1Properties(observationStock.Change1);
observationStock.Change1.CopyTotalME2IndicatorStockProperties(observationStock.Change1, total);
}
}
if (observationStock.Change1.Stocks.Count > 0)
{
obsStocks.Add(observationStock);
}
else
{
//insert zeroes
AddChangesToStock(i, observation, observationStock,
baseTotals, xminus1Totals);
obsStocks.Add(observationStock);
}
i++;
}
}
}
if (obsStocks.Count > 0)
{
//replace the totalstocks with change stocks
me2Stock.Stocks = obsStocks;
bHasChanges = true;
}
return(bHasChanges);
}
