public void CalculateEdgePenalty()
        {
            if (Plans != null)
            {
                foreach (PlanViewModel plan in Plans)
                {
                    try
                    {
                        plan.Penalty = EdgePenaltyCalculator
                                       .CalculateForPlan(plan.Patient, plan.Plan);

                        foreach (FieldViewModel field in plan.Fields)
                        {
                            CalculateEdgePenaltyForField(field);
                        }
                    }
                    catch (Exception e)
                    {
                        string message = e.Message;

                        if (e.InnerException != null)
                        {
                            message += "\n" + e.InnerException.Message;
                        }

                        NotifyUserMessaged(message, UserMessageType.Error);
                    }
                }
            }

            UpdatePlotModel();
            HistogramViewModel.Refresh();
        }
        public void CalculateEdgePenaltyForField(FieldViewModel field)
        {
            double[] edgePenalties = EdgePenaltyCalculator.
                                     CalculatePerControlPointWeighted(field.Plan.Patient, field.Plan.Plan, field.Beam);

            field.Penalty = edgePenalties.Sum();

            SetEdgePenaltiesForControlPoints(field, edgePenalties);
        }
 public void CalculateWeightsOnlyForControlPointsOnly()
 {
     if (Plans != null)
     {
         foreach (PlanViewModel plan in Plans)
         {
             foreach (FieldViewModel field in plan.Fields)
             {
                 double[] penalties = EdgePenaltyCalculator.
                                      CalculatePerControlPointWeightsOnly(field.Beam);
                 SetEdgePenaltiesForControlPoints(field, penalties);
             }
         }
     }
 }
 public void CalculateUnweightedEdgePenaltiesForControlPointsOnly()
 {
     if (Plans != null)
     {
         foreach (PlanViewModel plan in Plans)
         {
             try
             {
                 foreach (FieldViewModel field in plan.Fields)
                 {
                     double[] penalties = EdgePenaltyCalculator.
                                          CalculatePerControlPointUnweighted(
                         field.Plan.Patient, field.Plan.Plan, field.Beam);
                     SetEdgePenaltiesForControlPoints(field, penalties);
                 }
             }
             catch (Exception e)
             {
                 NotifyUserMessaged(e.Message, UserMessageType.Error);
             }
         }
     }
 }