Result models - Revision history

Peder at 07:14, 26 May 2010

2010-05-26T07:14:51Z

Peder: /* Creating copies of results */

2010-05-26T07:11:50Z

Creating copies of results

Fkl at 12:28, 19 May 2010

2010-05-19T12:28:18Z

Fkl at 11:45, 19 May 2010

2010-05-19T11:45:57Z

Fkl: /* The inner workings of the result class */

2010-05-19T11:35:35Z

The inner workings of the result class

Fkl at 11:20, 19 May 2010

2010-05-19T11:20:58Z

Fkl: /* Different types of result models */

2010-05-19T11:20:16Z

Different types of result models

Fkl at 10:18, 19 May 2010

2010-05-19T10:18:56Z

Fkl: /* Implementing a Result Model */

2010-05-19T10:15:39Z

Implementing a Result Model

Fkl: /* Getting results in code */

2010-05-19T10:11:17Z

Getting results in code

@@ Line 1: / Line 1: @@
 == Implementing a Result Model ==
 A result model is implemented as a class that is depending on:
@@ Line 25: / Line 26: @@
 == Different types of result models ==
 There are several different types of result models:
@@ Line 34: / Line 34: @@
 == Advanced result model implementation considerations ==
 Results that depend on year or their relative position among other results (e.g. <tt>CarbonAndNitrogenData</tt>) must implement the  <tt>IRecalculatableResult</tt> interface. The reason for this is that for efficiency reasons results may be copied from one generation to another (e.g. if generation 3 of a <tt>TreatmentUnit</tt> should be identical to generation 2). The interface is implemented as follows:

@@ Line 81: / Line 81: @@
 === Creating copies of results ===
-When results are copied (see [[#Getting results in code|Getting results in code]], this is done as follows:
+When results are copied (see [[#Getting results in code|Getting results in code]]), this is done as follows:
 # A new list with results is created

@@ Line 20: / Line 20: @@
 All result model classes should implement <tt>IClonable</tt> and return a deep copy of the result when cloned.
-Note that if a result model needs results from other result models, these results must be retrieved from the passed result list parameter in the constructor, not via the <tt>TreatmentUnit</tt>. This is due to the fact that sometimes the result is created via copying of results (see [[#Getting results in code]], and the passed parameter contains the results being copied.
+Note that if a result model needs results from other result models, these results must be retrieved from the passed result list parameter in the constructor, not via the <tt>TreatmentUnit</tt>. This is due to the fact that sometimes the result is created via copying of results (see [[#Getting results in code|Getting results in code]], and the passed parameter contains the results being copied.
 Once the model is implemented as above, the result variables will be available in maps, diagrams, tables, optimization models, and forest domains.
@@ Line 73: / Line 73: @@
 # If the result exists in the given dictionary it is returned from the given dictionary.
 # If the <tt>alternativeExistingResults</tt> parameter is passed and the result is identical before and after treatment, and the result exists in that dictionary, it is returned from that dictionary. Alternative dictionary to the before dictionary is the after dictionary and vice versa, this means that if the result has been calculated for "after" it can be used for "before" and vice versa (given that no treatment has occured).
-# If none of the above works, and <tt>TreatmentUnit</tt> is available (which is true if the result was "getted", not copied, see [[#Getting results in code]], the result is created (see [[#Creating result model objects]].
+# If none of the above works, and <tt>TreatmentUnit</tt> is available (which is true if the result was "getted", not copied, see [[#Getting results in code|Getting results in code]], the result is created (see [[#Creating result model objects|Creating result model objects]].
 === Creating result model objects ===
@@ Line 80: / Line 80: @@
 === Creating copies of results ===

@@ Line 19: / Line 19: @@
 All result model classes should implement <tt>IClonable</tt> and return a deep copy of the result when cloned.
 Once the model is implemented as above, the result variables will be available in maps, diagrams, tables, optimization models, and forest domains.
@@ Line 71: / Line 73: @@
 # If the result exists in the given dictionary it is returned from the given dictionary.
 # If the <tt>alternativeExistingResults</tt> parameter is passed and the result is identical before and after treatment, and the result exists in that dictionary, it is returned from that dictionary. Alternative dictionary to the before dictionary is the after dictionary and vice versa, this means that if the result has been calculated for "after" it can be used for "before" and vice versa (given that no treatment has occured).
+# If none of the above works, and <tt>TreatmentUnit</tt> is available (which is true if the result was "getted", not copied, see [[#Getting results in code]], the result is created (see [[#Creating result model objects]].

← Older revision		Revision as of 11:35, 19 May 2010
Line 58:		Line 58:

	== The inner workings of the result class ==		== The inner workings of the result class ==
		+
		+	=== Storage of result model objects ===
		+
		+	The <tt>Result</tt> class stores result model objects in dictionaries with the <tt>Type</tt> of the result model as key. There is one dictionary for before results, one for after results, and one for treatment and single results.
		+
		+	=== Getting result model objects ===
		+
		+	Results are retrieved via the private method <tt>getResult(Type resultType, Dictionary<Type, object[]> existingResults, Dictionary<Type, object[]> alternativeExistingResults, TreatmentUnitResultType treatmentUnitResultType)</tt>.
		+
		+	The method will do the following:
		+
		+	# If the result exists in the given dictionary it is returned from the given dictionary.
		+	# If the <tt>alternativeExistingResults</tt> parameter is passed and the result is identical before and after treatment, and the result exists in that dictionary, it is returned from that dictionary. Alternative dictionary to the before dictionary is the after dictionary and vice versa, this means that if the result has been calculated for "after" it can be used for "before" and vice versa (given that no treatment has occured).
		+	#

@@ Line 24: / Line 24: @@
 There are several different types of result models:
-;Before/After result: Results that are affected by treatments, e.g.
+;Before/After result: Results that might be changed when a treatment occurs, e.g. volume, biomass
-== Advanced result model implementation considerations
+== Advanced result model implementation considerations ==
 == Getting results in code ==

← Older revision		Revision as of 10:18, 19 May 2010
Line 19:		Line 19:

	Once the model is implemented as above, the result variables will be available in maps, diagrams, tables, optimization models, and forest domains.		Once the model is implemented as above, the result variables will be available in maps, diagrams, tables, optimization models, and forest domains.
		+
		+	== Different types of result models ==
		+
		+	There are several different types of result models:
		+
		+	;Before/After result: Results that are affected by treatments, e.g.
		+
		+	== Advanced result model implementation considerations

	== Getting results in code ==		== Getting results in code ==

@@ Line 7: / Line 7: @@
 # Before or after treatment in the period (optional)
 # Other results (optional)
-The class is given the attribute <tt>Slu.Heureka.DomainLayer.Forest.TreatmentUnitResult</tt>. In the attribute it is specified which of the above parameters that are required by the model.
+The class is given the attribute <tt>Slu.Heureka.DomainLayer.Forest.TreatmentUnitResult</tt>. In the attribute it is specified which of the above parameters that are required by the model (the attribute also specifices more information about the result model, see code for more details).
 The class must also have a constructor with the required parameters, in the same order as above. When a new instance of the class is created, the results of the model should be calculated.

← Older revision		Revision as of 10:11, 19 May 2010
Line 22:		Line 22:

	== Getting results in code ==		== Getting results in code ==
		+
		+	The results of each result model is managed by the <tt>Result</tt> class, which acts as a container of result model objects, and can be accessed via a <tt>TreatmentUnit</tt>:
		+
		+	;<tt>GetResult(int period)</tt>: Gets the results in a given period changes)
		+	;<tt>GetResults()</tt>: Gets all results up to current period
		+
		+	;<tt>CopyResults(IList<Type> resultTypes)</tt>: Gets a deep copy of all results up to current period, with all result models of the given types calculated.
		+
		+	Note that results retrieved via the first two methods might later be changed if the state of the <tt>TreatmentUnit</tt> changes. The values from a given result model can be retrieved on demand when the result(s) has been retrieved. Results retrieved via the last method are a copy and thus will not be changed, and the result models must be specified beforehand, values from result models not given in the call cannot be retrieved at a later time.
		+
		+	Once a <tt>Result</tt> object has been retrieved, it is possible to get result model objects from it:
		+
		+	;<tt>ContainsBefore(Type t), ContainsAfter(Type t), ContainsTreatment(Type t)</tt>: Checks if the given result model type exists in the result
		+	;<tt>Before(Type t), After(Type t), Treatment(Type t)</tt>: Gets the result model objects of the given type (note that several objects may be retrieved)
		+	;BeforeAndAfterSame: Returns a value indicating that values before treatment are identical to values after treatment (e.g. no treatment has been performed in the period the result belongs to)

	== The inner workings of the result class ==		== The inner workings of the result class ==