tests for dose objectives

amitantony · Oct 10, 2024 · 334a4ca · 334a4ca
1 parent f87e333
commit 334a4ca
Show file tree

Hide file tree

Showing 8 changed files with 372 additions and 1 deletion.
diff --git a/matRad/optimization/+DoseObjectives/matRad_EUD.m b/matRad/optimization/+DoseObjectives/matRad_EUD.m
@@ -96,7 +96,8 @@
             fDoseGrad = 2 * nthroot(1/numel(dose),k) * powersum^((1-k)/k) * (dose.^(k-1)) .* (nthroot(powersum/numel(dose),k) - obj.parameters{1});
             %end
             if any(~isfinite(fDoseGrad)) % check for inf and nan for numerical stability
-                error(['EUD computation failed. Reduce exponent to resolve numerical problems.']);
+                matRad_cfg = MatRad_Config.instance();
+                matRad_cfg.dispError(['EUD computation failed. Reduce exponent to resolve numerical problems.']);
             end
         end
     end

diff --git a/test/doseObjectives/test_doseObejctiveEUD.m b/test/doseObjectives/test_doseObejctiveEUD.m
@@ -0,0 +1,47 @@
+function test_suite = test_doseObejctiveEUD 
+
+test_functions=localfunctions();
+
+initTestSuite;
+
+function test_doseObjective_EUD_construct
+
+    obj = DoseObjectives.matRad_EUD();   %default
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_EUD'));
+    assertEqual(obj.parameters{1},0);
+    assertEqual(obj.parameters{2},3.5);
+    assertEqual(obj.penalty,1);
+
+    obj = DoseObjectives.matRad_EUD(100,60,3.5); 
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_EUD'));
+
+function test_doseObjective_EUD_computeObjFunction
+
+    obj = DoseObjectives.matRad_EUD(100,60,3.5); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 0.0579;
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+
+    assertTrue(isnan(test_fDose));
+
+
+function test_doseObjective_EUD_computeGradient
+
+   obj = DoseObjectives.matRad_EUD(100,10,2); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+    expected_fDose = [ 18.3392   19.3395   20.0064   20.6733   21.6736]'; 
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    assertExceptionThrown(@()computeDoseObjectiveGradient(obj,dose),'matRad:Error')
+
diff --git a/test/doseObjectives/test_doseObejctiveMaxDVH.m b/test/doseObjectives/test_doseObejctiveMaxDVH.m
@@ -0,0 +1,57 @@
+function test_suite = test_doseObejctiveMaxDVH 
+
+test_functions=localfunctions();
+
+initTestSuite;
+
+function test_doseObjective_MaxDVH_construct
+
+    obj = DoseObjectives.matRad_MaxDVH();   %default
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_MaxDVH'));
+    assertEqual(obj.parameters{1},30);
+    assertEqual(obj.parameters{2},95);
+    assertEqual(obj.penalty,1);
+
+    obj = DoseObjectives.matRad_MaxDVH(100,30,95); 
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_MaxDVH'));
+
+function test_doseObjective_MaxDVH_computeObjFunction
+
+    obj = DoseObjectives.matRad_MaxDVH(100,60,50); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 0;
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    obj = DoseObjectives.matRad_MaxDVH(100,50,95); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 5;
+
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+
+    assertTrue(isnan(test_fDose));
+
+
+function test_doseObjective_MaxDVH_computeGradient
+
+   obj = DoseObjectives.matRad_MaxDVH(100,50,95); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+    expected_fDose = [ 2 0 0 0 0]'; 
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+
+    assertTrue(isnan(test_fDose(4)));
diff --git a/test/doseObjectives/test_doseObejctiveMinDVH.m b/test/doseObjectives/test_doseObejctiveMinDVH.m
@@ -0,0 +1,57 @@
+function test_suite = test_doseObejctiveMinDVH 
+
+test_functions=localfunctions();
+
+initTestSuite;
+
+function test_doseObjective_MinDVH_construct
+
+    obj = DoseObjectives.matRad_MinDVH();   %default
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_MinDVH'));
+    assertEqual(obj.parameters{1},60);
+    assertEqual(obj.parameters{2},95);
+    assertEqual(obj.penalty,1);
+
+    obj = DoseObjectives.matRad_MinDVH(100,60,95); 
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_MinDVH'));
+
+function test_doseObjective_MinDVH_computeObjFunction
+
+    obj = DoseObjectives.matRad_MinDVH(100,60,50); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 0;
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    obj = DoseObjectives.matRad_MinDVH(100,60,95); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 5.8;
+
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+
+    assertTrue(isnan(test_fDose));
+
+
+function test_doseObjective_MinDVH_computeGradient
+
+   obj = DoseObjectives.matRad_MinDVH(100,60); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+    expected_fDose = [ -2.0000 -0.8000 0 0 0]'; 
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+
+    assertTrue(isnan(test_fDose(4)));
diff --git a/test/doseObjectives/test_doseObejctiveSquaredDeviation.m b/test/doseObjectives/test_doseObejctiveSquaredDeviation.m
@@ -0,0 +1,47 @@
+function test_suite = test_doseObejctiveSquaredDeviation 
+
+test_functions=localfunctions();
+
+initTestSuite;
+
+function test_doseObjective_squaredDeviation_construct
+
+    obj = DoseObjectives.matRad_SquaredDeviation();   %default
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_SquaredDeviation'));
+    assertEqual(obj.parameters{1},60);
+    assertEqual(obj.penalty,1);
+
+    obj = DoseObjectives.matRad_SquaredDeviation(100,60); 
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_SquaredDeviation'));
+
+function test_doseObjective_SquaredDeviation_computeObjFunction
+
+    obj = DoseObjectives.matRad_SquaredDeviation(100,60); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 11.6000;
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+
+    assertTrue(isnan(test_fDose));
+
+
+function test_doseObjective_SquaredDeviation_computeGradient
+
+   obj = DoseObjectives.matRad_SquaredDeviation(100,60); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+    expected_fDose = [-2.0000; -0.8000; 0; 0.8000; 2.0000]; 
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+
+    assertTrue(isnan(test_fDose(4)));
diff --git a/test/doseObjectives/test_doseObejctiveSquaredOverdosing.m b/test/doseObjectives/test_doseObejctiveSquaredOverdosing.m
@@ -0,0 +1,46 @@
+function test_suite = test_doseObejctiveSquaredOverdosing 
+
+test_functions=localfunctions();
+
+initTestSuite;
+
+function test_doseObjective_SquaredOverdosing_construct
+    obj = DoseObjectives.matRad_SquaredOverdosing();   %default
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_SquaredOverdosing'));
+    assertEqual(obj.parameters{1},30);
+    assertEqual(obj.penalty,1);
+
+    obj = DoseObjectives.matRad_SquaredOverdosing(100,60); 
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_SquaredOverdosing'));
+
+function test_doseObjective_SquaredOverdosing_computeObjFunction
+
+    obj = DoseObjectives.matRad_SquaredOverdosing(100,60); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 5.8;
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+
+    assertTrue(isnan(test_fDose));
+
+
+function test_doseObjective_SquaredOverdosing_computeGradient
+
+   obj = DoseObjectives.matRad_SquaredOverdosing(100,60); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+    expected_fDose = [0         0         0    0.8000    2.0000]'; 
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+
+    assertTrue(isnan(test_fDose(4)));
diff --git a/test/doseObjectives/test_doseObejctiveSquaredUnderdosing.m b/test/doseObjectives/test_doseObejctiveSquaredUnderdosing.m
@@ -0,0 +1,47 @@
+function test_suite = test_doseObejctiveSquaredUnderdosing 
+
+test_functions=localfunctions();
+
+initTestSuite;
+
+function test_doseObjective_SquaredUnderdosing_construct
+
+    obj = DoseObjectives.matRad_SquaredUnderdosing();   %default
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_SquaredUnderdosing'));
+    assertEqual(obj.parameters{1},60);
+    assertEqual(obj.penalty,1);
+
+    obj = DoseObjectives.matRad_SquaredUnderdosing(100,60); 
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_SquaredUnderdosing'));
+
+function test_doseObjective_SquaredUnderdosing_computeObjFunction
+
+    obj = DoseObjectives.matRad_SquaredUnderdosing(100,60); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 5.8;
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+
+    assertTrue(isnan(test_fDose));
+
+
+function test_doseObjective_SquaredUnderdosing_computeGradient
+
+   obj = DoseObjectives.matRad_SquaredUnderdosing(100,60); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+    expected_fDose = [ -2.0000 -0.8000 0 0 0]'; 
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+
+    assertTrue(isnan(test_fDose(4)));
diff --git a/test/test_doseObejctiveMeanDose.m b/test/test_doseObejctiveMeanDose.m
@@ -0,0 +1,69 @@
+function test_suite = test_doseObejctiveMeanDose 
+
+test_functions=localfunctions();
+
+initTestSuite;
+
+function test_doseObjective_squaredDeviation_construct
+
+    obj = DoseObjectives.matRad_MeanDose();   %default
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_MeanDose'));
+    assertEqual(obj.parameters{1},0);
+    assertEqual(obj.parameters{2},1);
+    assertEqual(obj.penalty,1);
+
+    obj = DoseObjectives.matRad_MeanDose(100,0,'Linear'); 
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_MeanDose'));
+
+    obj = DoseObjectives.matRad_MeanDose(100,10,4);
+    assertTrue(isobject(obj));
+    assertTrue(isa(obj, 'DoseObjectives.matRad_MeanDose'));
+    assertEqual(obj.parameters{1},10);
+    assertEqual(obj.parameters{2},1);
+
+function test_doseObjective_MeanDose_computeObjFunction
+
+    obj = DoseObjectives.matRad_MeanDose(100,10,'Linear'); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 50;
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    obj = DoseObjectives.matRad_MeanDose(100,0,'Quadratic'); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+    expected_fDose = 3600;
+
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveFunction(obj,dose);
+
+    assertTrue(isnan(test_fDose));
+
+
+function test_doseObjective_MeanDose_computeGradient
+
+   obj = DoseObjectives.matRad_MeanDose(100,0,'Linear'); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+    expected_fDose = [0.2; 0.2; 0.2; 0.2; 0.2]; 
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    obj = DoseObjectives.matRad_MeanDose(100,0,'Quadratic'); 
+
+    dose = [55,58,60,62,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+    expected_fDose = [24; 24; 24; 24; 24]; 
+    assertElementsAlmostEqual(test_fDose,expected_fDose,'absolute', 1e-4);
+
+    dose = [55,58,60,nan,65]';
+    test_fDose = computeDoseObjectiveGradient(obj,dose);
+
+    assertTrue(isnan(test_fDose(4)));