public static void ConditionCategoryWeights(SimulationStore simulation)
{
List <String> assets = new List <String>();
assets.Add(simulation.Asset);
ConditionCategoryWeights(simulation.SimulationID, assets);
}
private static void Performance(SimulationStore simulation)
{
List <String> assets = new List <String>();
assets.Add(simulation.Asset);
PrepareAnalysis.Performance(simulation.SimulationID, assets);
}
//Retreives OMS default files and adds them to the RoadCare database.
private static void InsertOMSActivities(SimulationStore simulation)
{
List <OMSActivityStore> activities = OMS.GetActivities(simulation.Asset);
foreach (OMSActivityStore activity in activities)
{
AddActivity(activity, simulation);
}
AddNoTreatment(simulation);
}
private static void Priorities(SimulationStore simulation)
{
DeleteScenario.DeletePriority(simulation.SimulationID);
int identity = 0;
try
{
using (SqlConnection connection = new SqlConnection(DB.ConnectionString))
{
connection.Open();
string insert = "INSERT INTO " + DB.TablePrefix + "PRIORITY " +
"(SIMULATIONID,PRIORITYLEVEL)" +
"VALUES('" + simulation.SimulationID + "','1')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
string table = DB.TablePrefix + "PRIORITY";
string selectIdentity = "SELECT IDENT_CURRENT ('" + table + "') FROM " + table;
cmd = new SqlCommand(selectIdentity, connection);
identity = Convert.ToInt32(cmd.ExecuteScalar());
}
}
catch (Exception ex)
{
identity = 0;
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(ex, false);
}
foreach (CategoryBudgetStore budget in simulation.CategoryBudgets)
{
try
{
using (SqlConnection connection = new SqlConnection(DB.ConnectionString))
{
connection.Open();
string insert = "INSERT INTO " + DB.TablePrefix + "PRIORITYFUND " +
"(PRIORITYID,BUDGET,FUNDING)" +
"VALUES('" + identity + "','" + budget.Key + "','100')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
}
}
catch (Exception ex)
{
identity = 0;
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(ex, false);
}
}
}
/// <summary>
/// This function for testing purposes. This should be filled by the interface.
/// </summary>
/// <param name="simulation"></param>
private static void ActivityFeasibilityCostConsequences(SimulationStore simulation)
{
if (!IsTreamentsDefined(simulation.SimulationID))
{
List <OMSActivityStore> activities = OMS.GetActivities(simulation.Asset);
if (activities != null)
{
foreach (OMSActivityStore activity in activities)
{
CreateScenario.AddActivity(activity, simulation);
}
}
}
}
/// <summary>
/// Fills the Targets and Deficients tables with values from SimulationStore
/// </summary>
/// <param name="simulation">SimulationStore for this scenario</param>
public static void TargetAndDeficients(SimulationStore simulation)
{
string simulationID = simulation.SimulationID;
//Delete previous Targets and deficient. Recalculate from SimulationStore
DeleteScenario.DeleteTargets(simulationID);
//This function will only perform useful work if Deficients are added below.
DeleteScenario.DeleteDeficients(simulationID);
try
{
//If USE_TARGET then set analysis type to Until Targets and Deficients Met
using (SqlConnection connection = new SqlConnection(DB.ConnectionString))
{
connection.Open();
string insert = "INSERT INTO " + DB.TablePrefix + "TARGETS " +
"(SIMULATIONID,ATTRIBUTE_,TARGETMEAN,TARGETNAME)" +
"VALUES('" + simulationID + "','OverallConditionIndex','" + simulation.TargetOCI + "','OMS')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
//Allow determination of OCI limit and possible separate OCI Remaining Life
insert = "INSERT INTO " + DB.TablePrefix + "DEFICIENTS " +
"(SIMULATIONID,ATTRIBUTE_,DEFICIENTNAME,DEFICIENT,PERCENTDEFICIENT)" +
"VALUES('" + simulationID + "','OverallConditionIndex','OCI Deficient','0','0')";
cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
//This is so remaining life can be calculated for each individiual condition index
OMSAssetConditionIndexStore oci = OMS.GetAssetConditionIndex(simulation.Asset);
foreach (OMSConditionIndexStore ci in oci.ConditionIndexes)
{
insert = "INSERT INTO " + DB.TablePrefix + "DEFICIENTS " +
"(SIMULATIONID,ATTRIBUTE_,DEFICIENTNAME,DEFICIENT,PERCENTDEFICIENT)" +
"VALUES('" + simulationID + "','" + ci.AttributeDE + "','" + ci.AttributeDE + " Deficient','0','0')";
cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(ex, false);
}
}
private static void InsertSimulationOCITargets(SimulationStore simulation)
{
int startYear = simulation.StartDate.Year;
for (int i = 0; i < simulation.Years; i++)
{
int year = startYear + i;
using (SqlConnection connection = new SqlConnection(DB.ConnectionString))
{
connection.Open();
string insert = "INSERT INTO " + DB.TablePrefix + "TARGETS " +
"(SIMULATIONID,ATTRIBUTE_,YEARS,TARGETMEAN,TARGETNAME,IS_OMS_PRIORITY)" +
"VALUES('" + simulation.SimulationID + "','OverallConditionIndex','" + year.ToString() + "','75','OCI TARGET','0')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// Convert SimulationStore into necessary tables entries for RoadCare
/// </summary>
/// <param name="simulationID"></param>
public static void Simulation(string simulationID)
{
SimulationStore simulation = SelectScenario.GetSimulationStore(simulationID);
OMSAssetConditionIndexStore oci = OMS.GetAssetConditionIndex(simulation.Asset);
PrepareAnalysis.Priorities(simulation);
//PrepareAnalysis.TargetAndDeficients(simulation);
PrepareAnalysis.ConditionCategoryWeights(simulation);
//PrepareAnalysis.Performance(simulation);
//PrepareAnalysis.RepeatedActivities(simulation);
//PrepareAnalysis.ActivityFeasibilityCostConsequences(simulation);
List <AttributeStore> attributes = PrepareAnalysis.Attributes(simulation);
AssetRequestOMSDataStore assetRequest = new AssetRequestOMSDataStore(DateTime.Now, attributes, oci);
Dictionary <string, AssetReplyOMSLookupTable> assetLookups = OMS.GetAssetLookupData(assetRequest);
List <AssetReplyOMSDataStore> assets = OMS.GetAssetData(assetRequest);
List <AssetReplyOMSDataStore> assetsWithCondition = assets.FindAll(delegate(AssetReplyOMSDataStore arods) { return(arods.ConditionIndices != null); });
PrepareAnalysis.Assets(simulation, assetsWithCondition, attributes, assetRequest, assetLookups);
}
/// <summary>
/// Creates a new Decision Engine Simulation and initializes it.
/// </summary>
/// <param name="username">Login username who created simulation.</param>
/// <param name="asset">Asset for which scenario is being created</param>
/// <returns>Returns the SimulationStore created so user interface can be populated.</returns>
public static SimulationStore CreateNewSimulationStore(string username, string asset)
{
SimulationStore simulation = null;
if (!string.IsNullOrWhiteSpace(username) && !string.IsNullOrWhiteSpace(asset))
{
try
{
using (SqlConnection connection = new SqlConnection(DB.ConnectionString))
{
connection.Open();
string insert = "INSERT INTO " + DB.TablePrefix + "SIMULATIONS " +
"(SIMULATION,NETWORKID,DATECREATED,USERNAME,BENEFIT_VARIABLE,BENEFIT_LIMIT,ANALYSIS, BUDGET_CONSTRAINT,ASSET_TYPE,RUN_TIME,USE_TARGET,TARGET_OCI,SIMULATION_AREA)" +
"VALUES('New Simulation',1,'" + DateTime.Now.ToString() + "',@username,'OCI',0,'Benefit/Cost','Budget Target',@asset,'0','false','" + DB.DefaultTargetOCI.ToString() + "','1')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.Parameters.Add(new SqlParameter("username", username));
cmd.Parameters.Add(new SqlParameter("asset", asset));
cmd.ExecuteNonQuery();
string table = DB.TablePrefix + "SIMULATIONS";
string selectIdentity = "SELECT IDENT_CURRENT ('" + table + "') FROM " + table;
cmd = new SqlCommand(selectIdentity, connection);
int identity = Convert.ToInt32(cmd.ExecuteScalar());
InsertNewInvestment(identity.ToString(), asset);
simulation = SelectScenario.GetSimulationStore(identity.ToString());
InsertOMSActivities(simulation);
InsertSimulationOCITargets(simulation);
LoadPerformanceCurvesToDecisionEngine(identity, asset);
}
}
catch (Exception ex)
{
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(ex, false);
}
}
return(simulation);
}
private static void Assets(SimulationStore simulation, List <AssetReplyOMSDataStore> assets, List <AttributeStore> attributes, AssetRequestOMSDataStore assetRequest, Dictionary <string, AssetReplyOMSLookupTable> assetLookups)
{
PrepareAnalysis.Assets(simulation.SimulationID, assets, attributes, assetRequest, assetLookups, true);
}
private static List <AttributeStore> Attributes(SimulationStore simulation)
{
DeleteScenario.DeleteAttributes(simulation.SimulationID);
List <AttributeStore> attributes = DecisionEngine.GetTreatmentAttributes(simulation.Asset, simulation.SimulationID);
List <AttributeStore> attributePriority = DecisionEngine.GetPriorityAttributes(simulation.Asset, simulation.SimulationID);
foreach (AttributeStore attribute in attributePriority)
{
if (!attributes.Contains(attribute))
{
attributes.Add(attribute);
}
}
List <AttributeStore> attributePerformance = DecisionEngine.GetPerformanceAttributes(simulation.Asset, simulation.SimulationID);
foreach (AttributeStore attribute in attributePerformance)
{
if (!attributes.Contains(attribute))
{
attributes.Add(attribute);
}
}
List <AttributeStore> attributeArea = OMS.ParseAttributes(simulation.Asset, simulation.SimulationArea);
foreach (AttributeStore attribute in attributeArea)
{
if (!attributes.Contains(attribute))
{
attributes.Add(attribute);
}
}
//Retrieve a list of attributes that are marked as condition categories.
List <AttributeStore> conditionCategoryAttributes = OMS.GetAssetAttributes(simulation.Asset).FindAll(delegate(AttributeStore a) { return(a.IsConditionCategory == true); });
foreach (AttributeStore attribute in conditionCategoryAttributes)
{
if (!attributes.Contains(attribute))
{
attributes.Add(attribute);
}
}
OMSAssetConditionIndexStore oci = OMS.GetAssetConditionIndex(simulation.Asset);
for (int i = 0; i < oci.ConditionIndexes.Count; i++)
{
string criteria = oci.Weights[i].Criteria;
if (criteria != null)
{
List <AttributeStore> ociCriteriaAttributes = OMS.ParseAttributes(simulation.Asset, criteria);
foreach (AttributeStore attribute in ociCriteriaAttributes)
{
if (!attributes.Contains(attribute))
{
attributes.Add(attribute);
}
}
}
}
//Adds attributes for JurisdictionFilter
List <AttributeStore> jurisdictionAttributes = OMS.ParseAttributes(simulation.Asset, simulation.Jurisdiction);
foreach (AttributeStore attribute in jurisdictionAttributes)
{
if (!attributes.Contains(attribute))
{
attributes.Add(attribute);
}
}
//Add street for output display
AttributeStore attributeStreet = OMS.GetAssetAttributes(simulation.Asset).Find(delegate(AttributeStore a) { return(a.OmsObjectUserIDHierarchy == "Street"); });
if (attributeStreet != null && !attributes.Contains(attributeStreet))
{
attributes.Add(attributeStreet);
}
//Add ID for output display
AttributeStore attributeID = OMS.GetAssetAttributes(simulation.Asset).Find(delegate(AttributeStore a) { return(a.OmsObjectUserIDHierarchy == "ID"); });
if (attributeID != null && !attributes.Contains(attributeID))
{
attributes.Add(attributeID);
}
//Add Installed for calculation of AGE
AttributeStore attributeInstalled = OMS.GetAssetAttributes(simulation.Asset).Find(delegate(AttributeStore a) { return(a.OmsObjectUserIDHierarchy == "Installed"); });
if (attributeInstalled != null && !attributes.Contains(attributeInstalled))
{
attributes.Add(attributeInstalled);
}
//Add Replaced for calculation of AGE
AttributeStore attributeReplaced = OMS.GetAssetAttributes(simulation.Asset).Find(delegate(AttributeStore a) { return(a.OmsObjectUserIDHierarchy == "Replaced"); });
if (attributeReplaced != null && !attributes.Contains(attributeReplaced))
{
attributes.Add(attributeReplaced);
}
//Add gis shape for output display
AttributeStore attributecgShape = OMS.GetAssetAttributes(simulation.Asset).Find(delegate(AttributeStore a) { return(a.OmsObjectUserIDHierarchy == "cgShape"); });
if (attributecgShape != null && !attributes.Contains(attributecgShape))
{
attributes.Add(attributecgShape);
}
foreach (AttributeStore attribute in attributes)
{
string simulationID = simulation.SimulationID;
string attribute_ = attribute.OmsObjectUserIDHierarchy;
if (attribute.IsConditionCategory && attribute_ != "OverallConditionIndex")
{
attribute_ = "__" + attribute_.Replace(" ", "").Replace("/", "");
}
string type_ = attribute.FieldType;
string default_value = "";
string maximum = "";
string minimum = "";
bool ascending = attribute.Ascending;
string format = "";
string isConditionCategory = attribute.IsConditionCategory.ToString();;
if (attribute.InitialValue != null)
{
default_value = attribute.InitialValue;
}
if (!float.IsNaN(attribute.Minimum))
{
minimum = attribute.Minimum.ToString();
}
if (!float.IsNaN(attribute.Maximum))
{
maximum = attribute.Maximum.ToString();
}
if (attribute.Format != null)
{
format = attribute.Format;
}
switch (type_)
{
case "Time":
case "Date":
case "DateTime":
type_ = "DATETIME";
break;
case "YesNo":
case "Text":
case "Lookup":
case "Quantity.unit":
type_ = "STRING";
break;
case "Number":
case "Integer":
case "Quantity":
case "Currency":
type_ = "NUMBER";
break;
default:
break;
}
try
{
using (SqlConnection connection = new SqlConnection(DB.ConnectionString))
{
connection.Open();
string insert = "INSERT INTO " + DB.TablePrefix + "OMS_ATTRIBUTES " +
"(SIMULATIONID,ATTRIBUTE_,TYPE_,DEFAULT_VALUE,MINIMUM_,MAXIMUM,ASCENDING,FORMAT,IS_CONDITION_INDEX,ATTRIBUTE_OMS)" +
"VALUES('" + simulationID + "','" + attribute_ + "','" + type_ + "','" + default_value + "','" + minimum + "','" + maximum + "','" + ascending.ToString() + "','" + format + "','" + isConditionCategory + "','" + attribute.OmsHierarchy + "')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
}
}
catch (Exception ex)
{
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(ex, false);
}
}
return(attributes);
}
private static void RepeatedActivities(SimulationStore simulation)
{
// Delete previous repeated activities
DeleteScenario.DeleteRepeatedActivities(simulation.SimulationID);
//Insert current repeated activities
}
public static void AddNoTreatment(SimulationStore simulation)
{
AddNoTreatment(simulation.SimulationID);
}
public static void AddActivity(OMSActivityStore activity, SimulationStore simulation)
{
//Insert activity in treatments
//Get Identity
string treatmentID = null;
int year = DateTime.Now.Year + 1;
using (SqlConnection connection = new SqlConnection(DB.ConnectionString))
{
connection.Open();
string insert = "INSERT INTO " + DB.TablePrefix + "TREATMENTS (SIMULATIONID,TREATMENT,BEFOREANY,BEFORESAME,OMS_REPEAT_START, OMS_REPEAT_INTERVAL, OMS_OID, OMS_IS_SELECTED,OMS_IS_EXCLUSIVE, OMS_IS_REPEAT)"
+ " VALUES ('" + simulation.SimulationID + "','" + activity.ActivityName + "','1','1','" + year + "','1','" + activity.ActivityOID + "','0','0','0')";
try
{
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
string selectIdentity = "SELECT IDENT_CURRENT ('" + DB.TablePrefix + "TREATMENTS') FROM " + DB.TablePrefix + "TREATMENTS";
cmd = new SqlCommand(selectIdentity, connection);
treatmentID = cmd.ExecuteScalar().ToString();
}
catch (Exception e)
{
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(e, false);
}
try
{
double cost = 0;
if (activity.OmsCost.CostPerUnit != double.NaN)
{
cost = activity.OmsCost.CostPerUnit;
if (cost <= 0)
{
cost = 1;
}
}
else
{
cost = 1;
}
insert = "INSERT INTO " + DB.TablePrefix + "COSTS (TREATMENTID,COST_) VALUES ('" + treatmentID + "','" + cost.ToString() + "')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(e, false);
}
OMSAssetConditionIndexStore oci = OMS.GetAssetConditionIndex(simulation.Asset);
foreach (OMSConsequenceStore consequence in activity.ConsequenceList)
{
try
{
OMSConditionIndexStore condition = oci.ConditionIndexes.Find(delegate(OMSConditionIndexStore ci) { return(ci.ConditionCategory == consequence.ConditionCategory); });
if (condition != null)
{
insert = "INSERT INTO " + DB.TablePrefix + "CONSEQUENCES (TREATMENTID,ATTRIBUTE_,CHANGE_) VALUES ('" + treatmentID + "','__" + condition.AttributeDE + "','" + consequence.GetDecisionEngineConsequence() + "')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
}
}
catch (Exception e)
{
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(e, false);
}
}
try
{
string conditionIndexCriteria = GetConditionIndexCriteria(activity.ConsequenceList);
insert = "INSERT INTO " + DB.TablePrefix + "FEASIBILITY (TREATMENTID,CRITERIA) VALUES ('" + treatmentID + "','" + conditionIndexCriteria + "')";
SqlCommand cmd = new SqlCommand(insert, connection);
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
Utility.ExceptionHandling.DataAccessExceptionHandler.HandleException(e, false);
}
}
}
