private void PrepareIterationPar()
{
// assess parameters which define the number of iterations
breakCond = GetUniquePar <ParCond>(DefPar.Loop.BreakCond);
if (breakCond == null)
{
ParNumber parIt = GetUniquePar <ParNumber>(DefPar.Loop.Num_Iterations);
if (parIt != null)
{
nIterations = (int)parIt.GetValue();
}
else
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()}: neither parameter {DefPar.Loop.Num_Iterations} nor {DefPar.Loop.BreakCond} defined"
});
}
}
else
{
if (!breakCond.IsGlobal())
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{breakCond.description.Get()}: condition is supposed to be global but contains personal/household related operands"
});
}
}
}
protected override void PrepareNonCommonPar()
{
parShare = GetUniquePar <ParFormula>(DefPar.Allocate.Share);
parShareBetween = GetUniquePar <ParCond>(DefPar.Allocate.Share_Between);
parShareProp = GetUniquePar <ParVarIL>(DefPar.Allocate.Share_Prop);
shareAllIfNoElig = GetParBoolValueOrDefault(DefFun.Allocate, DefPar.Allocate.Share_All_IfNoElig);
shareEquIfZero = GetParBoolValueOrDefault(DefFun.Allocate, DefPar.Allocate.Share_Equ_IfZero);
ignoreNegProp = GetParBoolValueOrDefault(DefFun.Allocate, DefPar.Allocate.Ignore_Neg_Prop);
}
private static bool IsCondMetByTU(HH hh, List <Person> tu, string who, ParCond parCond = null, int iEligVar = -1)
{
int i = 0; if (who == DefPar.Value.WHO_NOBODY)
{
return(true);
}
if (parCond != null)
{
foreach (var pe in parCond.GetTUValues(hh, tu))
{
bool elig = pe.Value; Person p = tu[i++];
bool?ew = EvalWho(elig, p); if (ew != null)
{
return(ew == true ? true : false);
}
}
}
else
{
foreach (Person p in tu)
{
bool elig = hh.GetPersonValue(iEligVar, p.indexInHH) != 0;
bool?ew = EvalWho(elig, p); if (ew != null)
{
return(ew == true ? true : false);
}
}
}
return(who == DefPar.Value.WHO_ALL || who == DefPar.Value.WHO_ALL_ADULTS);
bool?EvalWho(bool elig, Person p)
{
if (who == DefPar.Value.WHO_ONE && elig)
{
return(true);
}
if (who == DefPar.Value.WHO_ALL && !elig)
{
return(false);
}
if (who == DefPar.Value.WHO_ONE_ADULT && !p.isDepChild && elig)
{
return(true);
}
if ((who == DefPar.Value.WHO_ALL_ADULTS) && !p.isDepChild && !elig)
{
return(false);
}
if (who == DefPar.Value.WHO_NOBODY)
{
return(true);
}
return(null);
}
}
private void PrepareIterationPar()
{
ParTU parEligUnit = GetUniquePar <ParTU>(DefPar.UnitLoop.Elig_Unit); if (parEligUnit != null)
{
eligUnit = parEligUnit.name;
}
parEligUnitCond = GetUniquePar <ParCond>(DefPar.UnitLoop.Elig_Unit_Cond);
ParCateg parWho = GetUniquePar <ParCateg>(DefPar.UnitLoop.Elig_Unit_Cond_Who); if (parWho != null)
{
who = parWho.GetCateg();
}
}
private void PrepareRunCond(List <ParBase> nonFootnotePar)
{
coParRunCond = GetUniquePar <ParCond>(DefPar.Common.Run_Cond);
if (coParRunCond == null)
{
return;
}
coParRunCond.CheckAndPrepare(this);
if (!coParRunCond.IsGlobal())
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $"{coParRunCond.description.Get()}: condition must use global variables only"
});
}
else if (coParRunCond.IsGlobal(true)) // if read-time checking is possible (e.g. for IsUsedDataset, GetSystemYear, ...)
{
runCondMet_ReadTime = IsRunCondMet();
}
nonFootnotePar.Remove(coParRunCond); // remove, to not check and prepare again with the other parameters
}
/// <summary>
/// try to identify parameters and, if valid, generate the respective ParXXX and put into respective lists (see above)
/// </summary>
private void ClassifyParameters(Dictionary <string, ExeXml.Par> xmlParList, DefinitionAdmin.Fun funDef)
{
int dummyGroupNumber = -9999; // this is for placeholder-parameters, see below
foreach (var xmlPar in xmlParList)
{
Description parDescription = new Description(description, xmlPar.Value, xmlPar.Key);
string xmlParName = xmlPar.Value.Name;
// first check if it is an 'ordinary' parameter ...
DefinitionAdmin.Par parDef = funDef.GetParDef(xmlParName);
if (parDef != null)
{
string officialParName = funDef.GetOfficalParName(xmlParName); // is (in contrast to xmlParName) case-sensitive and
// corresponds to constants as defined in Common-library
// generate parameter ...
ParBase par = GeneratePar(xmlPar, parDef, parDescription);
// ... and put it into the list it belongs too ...
if (parDef.isFootnote) // ... footnote-list
{
if (GetGroupNumber(xmlPar.Value, parDescription, out int dummy))
{
if (!footnotePar.ContainsKey(xmlPar.Value.Group))
{
footnotePar.Add(xmlPar.Value.Group, new Dictionary <string, ParBase>());
}
if (!footnotePar[xmlPar.Value.Group].ContainsKey(officialParName))
{
footnotePar[xmlPar.Value.Group].Add(officialParName, par);
}
else
{
ReportDoubleDef(parDescription);
}
}
}
else if (parDef.maxCount == 1) // ... unique-parameter-list
{
if (!uniquePar.ContainsKey(officialParName))
{
uniquePar.Add(officialParName, par);
if (infoStore.runConfig.warnAboutUselessGroups && !string.IsNullOrEmpty(xmlPar.Value.Group))
{
ReportUselessGroup(parDescription);
}
}
else
{
ReportDoubleDef(parDescription);
}
}
else // ... non-unique-parameter-list
{
if (!nonUniquePar.ContainsKey(officialParName))
{
nonUniquePar.Add(officialParName, new List <ParBase>());
}
nonUniquePar[officialParName].Add(par);
if (infoStore.runConfig.warnAboutUselessGroups && !string.IsNullOrEmpty(xmlPar.Value.Group))
{
ReportUselessGroup(parDescription);
}
}
continue;
}
// ... if not successuful, check if it is a group parameter ...
parDef = funDef.GetGroupParDef(xmlParName, out string groupName);
if (parDef != null)
{
if (GetGroupNumber(xmlPar.Value, parDescription, out int groupNo))
{
// generate parameter ...
ParBase par = GeneratePar(xmlPar, parDef, parDescription);
// ... and put it into group-parameter-list
if (!groupPar.ContainsKey(groupName))
{
groupPar.Add(groupName, new SortedList <int, List <ParBase> >());
}
if (!groupPar[groupName].ContainsKey(groupNo))
{
groupPar[groupName].Add(groupNo, new List <ParBase>());
}
if (parDef.maxCount > 1 || GetUniqueGroupPar <ParBase>(xmlPar.Value.Name, groupPar[groupName][groupNo]) == null)
{
groupPar[groupName][groupNo].Add(par);
}
else
{
ReportDoubleDef(parDescription);
}
}
continue;
}
// ... if still not successful, it could still be placehoder parameter ...
if (funDef.AllowsForPlaceholders())
{
parDef = funDef.GetPlaceholderDef(out string phGroupName);
ParBase par = GeneratePar(xmlPar, parDef, parDescription, true);
if (phGroupName == null) // non-group placeholder, as e.g. in SetDefault, DefIL
{
if (!placeholderPar.TryAdd(xmlParName, par))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $" {parDescription.Get()}: {xmlParName} double definition (is ignored)"
});
}
}
else // group placeholder, as e.g. in DefVar (PH, IsGlobal, IsMonetary), Uprate (PH, FactorCond)
{
GetGroupNumber(xmlPar.Value, parDescription, // note that this returns a dummy-group if the user didn't indicate one
out int groupNo, true); // as placeholders only actually need a group if they are "further specified" (e.g. uprating-factors: factor_condition)
if (!groupPar.ContainsKey(phGroupName))
{
groupPar.Add(phGroupName, new SortedList <int, List <ParBase> >());
}
if (!groupPar[phGroupName].ContainsKey(groupNo))
{
groupPar[phGroupName].Add(groupNo, new List <ParBase>());
}
groupPar[phGroupName][groupNo].Add(par);
}
continue;
}
// ... now we give up
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $" {parDescription.Get()}: unknown parameter"
});
}
if (infoStore.runConfig.warnAboutUselessGroups)
{
foreach (var groupType in groupPar)
{
if (groupType.Key.ToLower() == DefPar.SchedCalc.Band_XXX.ToLower())
{
continue;
}
foreach (var group in groupType.Value)
{
if (group.Key >= 0 && group.Value.Count == 1)
{
ReportUselessGroup(group.Value[0].description);
}
}
}
}
// internal function for generating parameters
ParBase GeneratePar(KeyValuePair <string, ExeXml.Par> xmlPar, DefinitionAdmin.Par parDef,
Description parDescription, bool isPlaceholder = false)
{
ParBase par;
switch (parDef.valueType)
{
case DefPar.PAR_TYPE.FORMULA: par = new ParFormula(infoStore); break;
case DefPar.PAR_TYPE.CONDITION: par = new ParCond(infoStore); break;
case DefPar.PAR_TYPE.BOOLEAN: par = new ParBool(infoStore); break;
case DefPar.PAR_TYPE.NUMBER: par = new ParNumber(infoStore); break;
case DefPar.PAR_TYPE.TEXT: par = new ParBase(infoStore); break;
case DefPar.PAR_TYPE.VAR: par = new ParVar(infoStore); break;
case DefPar.PAR_TYPE.OUTVAR: par = new ParOutVar(infoStore); break;
case DefPar.PAR_TYPE.IL: par = new ParIL(infoStore); break;
case DefPar.PAR_TYPE.TU: par = new ParTU(infoStore); break;
case DefPar.PAR_TYPE.VARorIL: par = new ParVarIL(infoStore); break;
case DefPar.PAR_TYPE.CATEG: par = new ParCateg(infoStore, parDef.categValues); break;
case DefPar.PAR_TYPE.PLACEHOLDER: par = new ParBase(infoStore); break;
default: throw new Exception($"Not yet properly implemented parameter value type {parDef.valueType}");
}
par.description = parDescription;
par.xmlValue = xmlPar.Value.val;
par.description.isPlaceholder = isPlaceholder;
return(par);
}
bool GetGroupNumber(ExeXml.Par p, Description parDescription, out int groupNumber, bool allowDummy = false)
{
groupNumber = dummyGroupNumber++; // placeholders (e.g.uprating factors) only actually need a group
if (string.IsNullOrEmpty(p.Group)) // if they are "further specified" (e.g.factor_condition)
{
if (allowDummy)
{
return(true);
}
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {parDescription.Get()}: missing group"
});
return(false);
}
if (int.TryParse(p.Group, out groupNumber))
{
return(true);
}
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {parDescription.Get()}: invalid group {p.Group} (must be an integer number)"
});
return(false);
}
void ReportDoubleDef(Description parDescription)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {parDescription.Get()}: defined more than once"
});
}
void ReportUselessGroup(Description parDescription)
{
if (parDescription.GetFunName() != DefFun.Store) // add a special exception for Store, as it has its own reporting
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $" {parDescription.Get()}: group has no use"
});
}
}
}
protected override void PrepareNonCommonPar()
{
eligCond = GetUniquePar <ParCond>(DefPar.Elig.Elig_Cond);
}
protected override void PrepareNonCommonPar()
{
if (!IsRunCondMet()) // note that this works for info that is clearly available at read-time, e.g. {IsUsedDatabase} or {1}
{
return; // but simply returns true for global variables, which may (in theory) change over run-time
}
// to handle the latter IsRunCond is called again in the Run-function (see below)
// consequently for e.g. {0} the variables are not even generated
// while for {$Const}, with $Const=0 at the point of request, the variables exist but are set to 0
// this also reflects the behaviour of the old executable
ParBase parSysYear = GetUniquePar <ParBase>(isConst ? DefPar.DefConst.Const_SystemYear : DefPar.DefVar.Var_SystemYear);
if (parSysYear != null && !EM_Helpers.DoesValueMatchPattern(parSysYear.xmlValue, infoStore.country.sys.year))
{
return;
}
ParBase parDataSet = GetUniquePar <ParBase>(isConst ? DefPar.DefConst.Const_Dataset : DefPar.DefVar.Var_Dataset);
if (parDataSet != null && !infoStore.IsUsedDatabase(parDataSet.xmlValue))
{
return;
}
foreach (var g in GetParGroups(isConst ? DefPar.DefConst.THE_ONLY_GROUP : DefPar.DefVar.THE_ONLY_GROUP))
{
List <ParBase> group = g.Value;
// global variables (DefConst) allow for parameter Condition (but there is no reason why it wouldn't work for DefVar as well, thus no check)
ParCond cond = GetUniqueGroupPar <ParCond>(DefPar.DefConst.Condition, group);
List <ParFormula> initFormulas = GetPlaceholderGroupPar <ParFormula>(group);
if (initFormulas.Count == 0) // there can be single Monetary parameters if definition is n/a for this system
{
continue;
}
if (cond == null && initFormulas.Count > 1)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{initFormulas[0].description.Get()}: multiple definition, group {g.Key} is already in use"
});
continue;
}
foreach (ParFormula initFormula in initFormulas)
{
string varName = initFormula.description.GetParName();
if (!EM_Helpers.IsValidName(varName, out string illegal))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{initFormula.description.Get()}: name contains illegal character(s) '{illegal}'"
});
continue;
}
if (isConst && cond == null && !initFormula.IsGlobal())
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true,
message = $"{initFormula.description.Get()}: trying to initialise global variable with a non-global amount"
});
}
bool isMonetary = false;
if (!isConst) // variables defined with DefConst cannot be monetary (more precisely, should not be added over TUs)
{
// if monetary-parameter is defined, use it, otherwise monetary=true (more precisely, get the default value from lib-def)
ParBool parMonetary = GetUniqueGroupPar <ParBool>(DefPar.DefVar.Var_Monetary, group);
isMonetary = parMonetary != null?parMonetary.GetBoolValue()
: DefinitionAdmin.GetParDefault <bool>(funName: DefFun.DefVar, parName: DefPar.DefVar.Var_Monetary);
}
if (!infoStore.operandAdmin.Exists(varName)) // double definition is not illegal (maybe questionable, but handled like this in old exe)
{
infoStore.operandAdmin.RegisterVar(name: varName, creatorFun: DefFun.DefVar, description: initFormula.description,
isMonetary: isMonetary,
isGlobal: isConst && cond == null,
isWriteable: true, // DefVar defined variables can be used as output-var (this is a bit lax with DefConst)
setInitialised: true); // DefVar defined variables always have an initial value -
// if user sets it n/a it does not exist, otherwise she needs to assign a value
// actual initialisation is done in the Run function
if (!infoStore.operandAdmin.Exists(varName))
{
continue; // registration failed
}
}
else if (infoStore.operandAdmin.GetCreatorFun(varName) != DefFun.DefVar && infoStore.operandAdmin.GetCreatorFun(varName) != DefFun.DefConst)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()} {varName}: {DefFun.DefVar}/{DefFun.DefConst} can only overwrite variables created by (another) {DefFun.DefVar}/{DefFun.DefConst}"
});
continue;
}
// variable cannot yet be initialised, as at this stage the hh-data does not exist (no formula interpretation possible yet)
// note on still setting the variable initialised at this stage, in context with the "not-initialised" warning:
// parameters are prepared in the spine-order, thus parameters which are prepared before would get a "not known"
// and parameters prepared afterwards are "legal" users
if (!varDefs.ContainsKey(varName))
{
varDefs.Add(varName, new List <VarDef>()); // see definition of varDefs for reason for Dictionary
}
varDefs[varName].Add(new VarDef()
{
varSpec = new VarSpec()
{
name = varName
}, initFormula = initFormula, condition = cond, groupNo = g.Key
});
}
}
// a variable can only be defined more than once within one function, if it is conditioned:
// only one definition can exist without a condition (which will be used as the default fallback value if conditions also exist)
foreach (List <VarDef> condConstDef in varDefs.Values)
{
if (condConstDef.Count > 1 && (from c in condConstDef where c.condition == null select c).Count() > 1)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()}: multiple definitions of {condConstDef[0].varSpec.name} without {DefPar.DefConst.Condition} found"
});
}
}
}
protected override void PrepareNonCommonPar()
{
ParCateg parType = GetUniquePar <ParCateg>(DefPar.DefTu.Type);
if (parType != null)
{
tuType = parType.GetCateg();
}
if (tuType != DefPar.Value.TUTYPE_IND)
{
// get the INCOME used to define the head
headDefInc = GetUniquePar <ParVarIL>(DefPar.DefTu.HeadDefInc);
if (headDefInc == null) // if no income defined, use ils_origy as default
{
headDefInc = new ParVarIL(infoStore);
headDefInc.xmlValue = infoStore.country.sys.headDefInc == string.Empty ? DefVarName.ILSORIGY : infoStore.country.sys.headDefInc;
headDefInc.description = description;
headDefInc.CheckAndPrepare(this);
}
// get all the conditions and set the defaults if they did not exist before
if (extHeadCond == null)
{
extHeadCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.EXTHEAD, description = description
};
extHeadCond.CheckAndPrepare(this);
}
}
if (partnerCond == null)
{
partnerCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.PARTNER, description = description
};
partnerCond.CheckAndPrepare(this);
}
if (depChildCond == null)
{
depChildCond = new ParCond(infoStore)
{
xmlValue = "{0}", description = description
};
depChildCond.CheckAndPrepare(this);
}
if (ownChildCond == null)
{
ownChildCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.OWNCHILD, description = description
};
ownChildCond.CheckAndPrepare(this);
}
if (ownDepChildCond == null)
{
ownDepChildCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.OWNDEPCHILD, description = description
};
ownDepChildCond.CheckAndPrepare(this);
}
if (looseDepChildCond == null)
{
looseDepChildCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.LOOSEDEPCHILD, description = description
};
looseDepChildCond.CheckAndPrepare(this);
}
if (depParentCond == null)
{
depParentCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.DEPPARENT, description = description
};
depParentCond.CheckAndPrepare(this);
}
if (depRelativeCond == null)
{
depRelativeCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.DEPRELATIVE, description = description
};
depRelativeCond.CheckAndPrepare(this);
}
if (loneParentCond == null)
{
loneParentCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.LONEPARENT, description = description
};
loneParentCond.CheckAndPrepare(this);
}
// get all the booleans and set the values
ParBool noChildIfHeadPar = GetUniquePar <ParBool>(DefPar.DefTu.NoChildIfHead);
noChildIfHead = noChildIfHeadPar != null && noChildIfHeadPar.GetBoolValue();
ParBool noChildIfPartnerPar = GetUniquePar <ParBool>(DefPar.DefTu.NoChildIfPartner);
noChildIfPartner = noChildIfPartnerPar != null && noChildIfPartnerPar.GetBoolValue();
ParBool assignDepChOfDependentsPar = GetUniquePar <ParBool>(DefPar.DefTu.AssignDepChOfDependents);
assignDepChOfDependents = assignDepChOfDependentsPar != null && assignDepChOfDependentsPar.GetBoolValue();
ParBool assignPartnerOfDependentsPar = GetUniquePar <ParBool>(DefPar.DefTu.AssignPartnerOfDependents);
assignPartnerOfDependents = assignPartnerOfDependentsPar != null && assignPartnerOfDependentsPar.GetBoolValue();
ParBool stopIfNoHeadFoundPar = GetUniquePar <ParBool>(DefPar.DefTu.StopIfNoHeadFound);
stopIfNoHeadFound = stopIfNoHeadFoundPar != null && stopIfNoHeadFoundPar.GetBoolValue();
ParCateg multiplePartnersPar = GetUniquePar <ParCateg>(DefPar.DefTu.MultiplePartners);
multiplePartners = multiplePartnersPar == null ? string.Empty : multiplePartnersPar.GetCateg();
}
internal static bool IsCondMetByTU(HH hh, List <Person> tu, ParCond parCond, string who)
{
return(IsCondMetByTU(hh, tu, who, parCond));
}
protected override void PrepareNonCommonPar()
{
aggs = GetNonUniquePar <ParVarIL>(DefPar.Totals.Agg);
if (aggs.Count == 0)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $"{description.Get()}: missing required parameter AGG"
});
return;
}
foreach (string t in new List <string> {
DefPar.Totals.Varname_Sum, DefPar.Totals.Varname_Mean, DefPar.Totals.Varname_Median,
DefPar.Totals.Varname_Decile, DefPar.Totals.Varname_Quintile, DefPar.Totals.Varname_Count, DefPar.Totals.Varname_PosCount,
DefPar.Totals.Varname_NegCount, DefPar.Totals.Varname_Min, DefPar.Totals.Varname_Max
})
{
ParBase par = GetUniquePar <ParBase>(t); if (par == null)
{
continue;
}
actions.Add(t);
foreach (ParVarIL agg in aggs)
{
string aggName = agg.GetName();
agg.CheckAndPrepare(this);
int n = 1; if (t == DefPar.Totals.Varname_Decile)
{
n = 9;
}
if (t == DefPar.Totals.Varname_Quintile)
{
n = 4;
}
for (int i = 1; i <= n; ++i)
{
string counter = t == DefPar.Totals.Varname_Decile || t == DefPar.Totals.Varname_Quintile ? i.ToString() : string.Empty;
string varName = $"{par.xmlValue}{counter}_{aggName}";
infoStore.operandAdmin.RegisterVar( // generate the variable that will take the total
name: varName,
creatorFun: DefFun.Totals,
description: par.description,
isMonetary: false, // not really clear, but adding over TU does not make sense
isGlobal: true, // equal for each person
isWriteable: false, // cannot be use as output-variable
setInitialised: true);
if (infoStore.operandAdmin.Exists(varName))
{
totals.Add(t + (n > 1 ? i.ToString() : "") + aggName, new VarSpec()
{
name = varName
});
}
}
}
}
// setup booleans
hasMedian = actions.Contains(DefPar.Totals.Varname_Median);
hasQuint = actions.Contains(DefPar.Totals.Varname_Quintile);
hasDec = actions.Contains(DefPar.Totals.Varname_Decile);
hasSum = actions.Contains(DefPar.Totals.Varname_Sum);
hasMean = actions.Contains(DefPar.Totals.Varname_Mean);
// check if there is a condition for inclusion
ParCond inclCond = GetUniquePar <ParCond>(DefPar.Totals.Incl_Cond);
if (inclCond != null)
{
ParCateg inclWho = GetUniquePar <ParCateg>(DefPar.Totals.Incl_Cond_Who);
string inclWhoVal = (inclWho == null) ? DefPar.Value.WHO_ALL : inclWho.GetCateg();
include = new Tuple <ParCond, string>(inclCond, inclWhoVal);
}
// check if results should be weighted
useWeights = GetParBoolValueOrDefault(DefFun.Totals, DefPar.Totals.Use_Weights);
if (useWeights) // get the weight var, if null use dwt
{
ParVar dwtPar = GetUniquePar <ParVar>(DefPar.Totals.Weight_Var);
dwtName = dwtPar != null ? dwtPar.name : DefVarName.DWT;
infoStore.operandAdmin.CheckRegistration(dwtName, false, false, description);
}
//
}
protected override void PrepareNonCommonPar()
{
if (!IsRunCondMet())
{
return;
}
infoStore.applicableUprateFunctions.Add(description); // to allow for checking if there is no/more than one applicable Uprate
// get the "function-internal" (rather outdated) factor definitions, i.e. those defined by parameters Factor_Name/Factor_Value
Dictionary <string, double> internalFactorDefs = GetInternalFactorDefs();
// check if DBYearVar exists and handle accordingly
ParVar parDBYearVarPar = GetUniquePar <ParVar>(DefPar.Uprate.DBYearVar);
isDBYearVarUsed = parDBYearVarPar != null && parDBYearVarPar.name != DefPar.Value.NA;
if (isDBYearVarUsed)
{
if (parDBYearVarPar.name.Trim() != string.Empty)
{
infoStore.operandAdmin.CheckRegistration(name: parDBYearVarPar.name.Trim(), isOutVar: false,
warnIfNotInit: false, description: parDBYearVarPar.description);
if (!infoStore.operandAdmin.GetVarExistsInPersonVarList(parDBYearVarPar.name))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{parDBYearVarPar.description.Get()}: Parameter {DefPar.Uprate.DBYearVar} was used with value '{parDBYearVarPar.name}', but this variable is not defined"
});
}
else
{
DBYearVar = parDBYearVarPar.name;
}
}
else
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{this.description.Get()}: Parameter {DefPar.Uprate.DBYearVar} was used and left empty"
});
}
}
// (1) "NORMAL" VARIABLES:
// an uprating-group consists of the variable to uprate (e.g. yem=$f_cpi) and optionally of a condition (e.g. Factor_Cond={dgn=0})
foreach (var group in GetParGroups(DefPar.Uprate.GROUP_MAIN).Values)
{
// optional condition parameter
ParCond parCond = GetUniqueGroupPar <ParCond>(DefPar.Uprate.Factor_Condition, group);
// compulsory var-name/factor-parameter (e.g. yem (in policy-column) / $f_cpi (in system-column))
// usually this will be one placeholder-parameter but it is possible that one condition applies to several variables
List <ParBase> listParMain = GetPlaceholderGroupPar <ParBase>(group);
if (listParMain.Count == 0)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{parCond.description.Get()}: loose condition {parCond.xmlValue}"
});
continue;
}
foreach (ParBase parMain in listParMain)
{
string upVarName = parMain.description.GetParName(); // get the name of the variable to uprate (e.g. yem)
// check for double uprating, but take care of conditions, e.g. twice yem-uprating without condition -> warning, yem-uprating different for men and women -> ok
bool exists = ExistsUpVar(upVarName, out bool conditioned);
if (exists && (!conditioned || parCond == null))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $"{parMain.description.Get()}: double uprating of variable {upVarName}"
});
}
Dictionary <double, double> upFactors = GetFactors(internalFactorDefs, parMain);
upVars.Add(new UpVar()
{
varSpec = new VarSpec()
{
name = upVarName
},
factors = upFactors,
parCondition = parCond
});
// the main purpose of this registration is to ensure the variable exists (an error is issued if not)
// in fact uprated variables are likely to be registered by usage (why uprate a variable that is not used?)
// (it could still be that an uprated but otherwise unused variable should be in the output and would not if VarGroup is used)
infoStore.operandAdmin.CheckRegistration(name: upVarName, isOutVar: false,
warnIfNotInit: false, description: parMain.description);
}
}
// check for double conditioned uprating
foreach (UpVar condUpVar in from cuv in upVars where cuv.parCondition != null select cuv)
{
if ((from cuv in upVars
where upVars.IndexOf(cuv) > upVars.IndexOf(condUpVar) && cuv.varSpec.name.ToLower() == condUpVar.varSpec.name.ToLower() &&
cuv.parCondition != null && cuv.parCondition.description.GetParGroup() == condUpVar.parCondition.description.GetParGroup()
select cuv).Count() > 0)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $"{condUpVar.parCondition.description.Get()}: double uprating of variable {condUpVar.varSpec.name}"
});
}
}
// (2) AGGREGATE VARIABLES:
// the group consists of AggVar_Name (the agg-var to uprate) and a list of AggVar_Part (the vars summing up to the agg-var)
// and optionally of AggVar_Tolerance (a tolerance for the check if part-vars actually sum up to agg-var)
foreach (var group in GetParGroups(DefPar.Uprate.GROUP_AGG).Values)
{
ParVar parName = GetUniqueGroupPar <ParVar>(DefPar.Uprate.AggVar_Name, group);
if (parName == null)
{
continue; // error is issued by general checking
}
if (ExistsUpVar(parName.name, out bool dummy))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $"{parName.description.Get()}: double uprating of variable {parName.name} (aggregate and normally)"
});
}
ParNumber parTol = GetUniqueGroupPar <ParNumber>(DefPar.Uprate.AggVar_Tolerance, group);
AggUpVar aggUpVar = new AggUpVar()
{
varSpec = new VarSpec()
{
name = parName.name
}
};
if (parTol != null)
{
aggUpVar.tolerance = parTol.GetValue();
}
foreach (ParVar parPart in GetNonUniqueGroupPar <ParVar>(DefPar.Uprate.AggVar_Part, group))
{
aggUpVar.parts.Add(new VarSpec()
{
name = parPart.name
});
}
if (aggUpVar.parts.Count > 0)
{
aggUpVars.Add(aggUpVar);
}
}
// (3) VARIABLES DEFINED BY REGULAR EXPRESSION (e.g. for updating expenditure variables)
foreach (var group in GetParGroups(DefPar.Uprate.GROUP_REGEXP).Values)
{
ParBase parDef = GetUniqueGroupPar <ParBase>(DefPar.Uprate.RegExp_Def, group);
ParBase parFactor = GetUniqueGroupPar <ParBase>(DefPar.Uprate.RegExp_Factor, group);
if (parDef == null || parFactor == null)
{
continue;
}
upRegExp.Add(parDef.xmlValue, GetFactors(internalFactorDefs, parFactor));
}
// get default factor ...
ParBase parDefFac = GetUniquePar <ParBase>(DefPar.Uprate.Def_Factor);
if (parDefFac != null)
{
defaultFactor = GetFactors(internalFactorDefs, parDefFac);
}
// ... and the optional parameter WarnIfNoFactor
warnIfNoFactor = GetParBoolValueOrDefault(DefFun.Uprate, DefPar.Uprate.WarnIfNoFactor);
// ... and the optional parameter WarnIfNonMonetary
warnIfNonMonetary = GetParBoolValueOrDefault(DefFun.Uprate, DefPar.Uprate.WarnIfNonMonetary);
if (zeroFactorSysCollector.Count > 0)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true,
message = $"{description.Get()}: uprating-index for system year is 0 for {string.Join(", ", zeroFactorSysCollector)}, resulting in uprating concerned variables by 0."
});
}
if (zeroFactorDataCollector.Count > 0)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true,
message = $"{description.Get()}: uprating-index for data year is 0 for {string.Join(", ", zeroFactorDataCollector)}, resulting in setting concerned variables to NaN."
});
}
}
protected override void PrepareNonCommonPar()
{
ParVar fv = GetUniquePar <ParVar>(DefPar.AddHHMembers.FlagVar);
if (fv != null)
{
flagVar = new VarSpec()
{
name = fv.name
}
}
;
foreach (var g in GetParGroups(DefPar.AddHHMembers.GROUP_MAIN))
{
var group = g.Value; int groupNo = g.Key;
AddInstruction addInstruction = new AddInstruction();
// first find out whether we are adding children or partners or other persons ...
ParCateg parWho = GetUniqueGroupPar <ParCateg>(DefPar.AddHHMembers.Add_Who, group); if (parWho == null)
{
continue; // compulsory parameter, error already issued
}
addInstruction.addWho = parWho.GetCateg();
// ... depending on that, check the add-condition
ParCond parParent = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.ParentCond, group);
ParCond parPartner = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.PartnerCond, group);
ParCond parOther = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.HHCond, group);
string missing = string.Empty; string tooMuch = string.Empty;
switch (addInstruction.addWho)
{
case DefPar.Value.ADDHHMEMBERS_CHILD:
if (parParent != null)
{
addInstruction.cond = parParent;
}
else
{
missing = DefPar.AddHHMembers.ParentCond;
}
if (parPartner != null)
{
tooMuch = DefPar.AddHHMembers.PartnerCond + " ";
}
if (parOther != null)
{
tooMuch = DefPar.AddHHMembers.HHCond;
}
ParBool parIsPP = GetUniqueGroupPar <ParBool>(DefPar.AddHHMembers.IsPartnerParent, group);
if (parIsPP != null)
{
addInstruction.isPartnerParent = parIsPP.GetBoolValue();
}
break;
case DefPar.Value.ADDHHMEMBERS_PARTNER:
if (parParent != null)
{
tooMuch = DefPar.AddHHMembers.ParentCond + " ";
}
if (parPartner != null)
{
addInstruction.cond = parPartner;
}
else
{
missing = DefPar.AddHHMembers.PartnerCond;
}
if (parOther != null)
{
tooMuch = DefPar.AddHHMembers.HHCond;
}
break;
case DefPar.Value.ADDHHMEMBERS_OTHER:
if (parParent != null)
{
tooMuch = DefPar.AddHHMembers.ParentCond + " ";
}
if (parPartner != null)
{
tooMuch = DefPar.AddHHMembers.PartnerCond;
}
if (parOther != null)
{
addInstruction.cond = parOther;
}
else
{
missing = DefPar.AddHHMembers.HHCond;
}
break;
default: continue; // error is caught by general error handling
}
if (missing != string.Empty)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()} (group {groupNo}): {DefPar.AddHHMembers.Add_Who}={addInstruction.addWho} requires parameter {missing}"
});
}
if (tooMuch != string.Empty)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true,
message = $"{description.Get()} (group {groupNo}): {DefPar.AddHHMembers.Add_Who}={addInstruction.addWho} does not require {tooMuch}"
});
}
// here we are only gathering the variables that are to be set, but do not evaluate whether they exist
// note: this function does not "register" variables, i.e. if a variable is not used anywhere else, it cannot be set
foreach (ParFormula parVarDefinition in GetPlaceholderGroupPar <ParFormula>(group))
{
string varName = parVarDefinition.description.GetParName();
if (addInstruction.prepVarDefinitions.ContainsKey(varName))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{parVarDefinition.description.Get()}: double definition of variable {varName}"
});
continue;
}
if (varName == DefVarName.IDHH || varName == DefVarName.IDPERSON || varName == DefVarName.DWT || varName == DefVarName.DCT)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{parVarDefinition.description.Get()}: variable {varName} is system-set and cannot be changed"
});
continue;
}
addInstruction.prepVarDefinitions.Add(varName, parVarDefinition);
}
addInstructions.Add(addInstruction);
}
}
