예제 #1
0
		def partial_sum(spectrum, function_evaluation_mesh, local_max, positions, coefficients_of_base_BPs, plateau_shape_coefs):
			"""Calculates partial sum"""

	   		
	   		a0, a1, a2, a3 = plateau_shape_coefs

			grad = [0] * len(coefficients_of_base_BPs)

			maximum = -100
			minimum = 100
						
			from src import pyamtrack_SPC
			
			total = 0			
			for x in function_evaluation_mesh:
				dose_at_depth_x = [pyamtrack_SPC.dose_at_depth(x, local_max, positions[i], spectrum) for i in range(len(coefficients_of_base_BPs))]
			
				sum_of_BPs_for_this_x = sum([coefficients_of_base_BPs[i] * dose_at_depth_x[i] for i in range(len(coefficients_of_base_BPs)) ])

				value_at_plateau = a3 * x * x * x + a2 * x * x + a1 * x + a0

				total += (value_at_plateau - sum_of_BPs_for_this_x) ** 2

				for i in range(len(coefficients_of_base_BPs)):
					grad[i] += -2.0 * (value_at_plateau - sum_of_BPs_for_this_x) * dose_at_depth_x[i]

				if sum_of_BPs_for_this_x - value_at_plateau > maximum:
					maximum = sum_of_BPs_for_this_x - value_at_plateau
				if sum_of_BPs_for_this_x - value_at_plateau < minimum:
					minimum = sum_of_BPs_for_this_x - value_at_plateau

			return total, grad, minimum, maximum
예제 #2
0
        def partial_sum(spectrum, function_evaluation_mesh, local_max,
                        positions, coefficients_of_base_BPs,
                        plateau_shape_coefs):
            """Calculates partial sum"""

            a0, a1, a2, a3 = plateau_shape_coefs

            grad = [0] * len(coefficients_of_base_BPs)

            maximum = -100
            minimum = 100

            from src import pyamtrack_SPC

            total = 0
            for x in function_evaluation_mesh:
                dose_at_depth_x = [
                    pyamtrack_SPC.dose_at_depth(x, local_max, positions[i],
                                                spectrum)
                    for i in range(len(coefficients_of_base_BPs))
                ]

                sum_of_BPs_for_this_x = sum([
                    coefficients_of_base_BPs[i] * dose_at_depth_x[i]
                    for i in range(len(coefficients_of_base_BPs))
                ])

                value_at_plateau = a3 * x * x * x + a2 * x * x + a1 * x + a0

                total += (value_at_plateau - sum_of_BPs_for_this_x)**2

                for i in range(len(coefficients_of_base_BPs)):
                    grad[i] += -2.0 * (value_at_plateau - sum_of_BPs_for_this_x
                                       ) * dose_at_depth_x[i]

                if sum_of_BPs_for_this_x - value_at_plateau > maximum:
                    maximum = sum_of_BPs_for_this_x - value_at_plateau
                if sum_of_BPs_for_this_x - value_at_plateau < minimum:
                    minimum = sum_of_BPs_for_this_x - value_at_plateau

            return total, grad, minimum, maximum
예제 #3
0
	def calculateYc(X_vect, coefficient, maximum, base_BP_position, spectrum):
	        from src import pyamtrack_SPC
		return [coefficient * pyamtrack_SPC.dose_at_depth(x, maximum, base_BP_position, spectrum) for x in X_vect]
예제 #4
0
	def calculateYb(X_vect, maximum, base_BP_positions, spectrum, coefficients):
	        from src import pyamtrack_SPC
	        Y_vect = [sum( [coefficients[i] * pyamtrack_SPC.dose_at_depth(x, maximum, base_BP_positions[i], spectrum)
                                          for i in range(len(coefficients)) ] ) for x in X_vect]
		return Y_vect
예제 #5
0
	def calculateYa(X_vect, maximum, base_BP_positions, spectrum, plateau_dist, plateau_prox, coefficients):
	        from src import pyamtrack_SPC
	        Y_vect = [sum( [coefficients[i] * (pyamtrack_SPC.dose_at_depth(x, maximum, base_BP_positions[i], spectrum) + 
                                           pyamtrack_SPC.dose_at_depth(plateau_dist +  plateau_prox - x, maximum, base_BP_positions[i], spectrum))
                                          for i in range(len(coefficients)) ] ) for x in X_vect]
		return Y_vect
예제 #6
0
def plot_Dose(filename, spectrum, maximum, base_BP_positions, coefficients, two_beams, plot_format = 'png', show = True):
    logging.info('Plotting Dose... ')

    # clear previous plots
    pylab.clf()

    # first take wide range to determine where should plot end
    dx = 0.01
    X_wide = [ n * dx for n in range( int((base_BP_positions[-1] + 4) / dx)) ]

    serial = common.check_option('serial')
    parallel = common.check_option('parallel')

    if parallel:
       coefficients_p = []
       for c in coefficients:
       	coefficients_p.append(float(c))

    Y_SOBP = []
           
    if two_beams:
        X_wide = [ n * dx for n in range( int((base_BP_positions[0] + base_BP_positions[-1]) / dx)) ]
        plateau_dist = base_BP_positions[-1]
        plateau_prox = base_BP_positions[0]

	def calculateYa(X_vect, maximum, base_BP_positions, spectrum, plateau_dist, plateau_prox, coefficients):
	        from src import pyamtrack_SPC
	        Y_vect = [sum( [coefficients[i] * (pyamtrack_SPC.dose_at_depth(x, maximum, base_BP_positions[i], spectrum) + 
                                           pyamtrack_SPC.dose_at_depth(plateau_dist +  plateau_prox - x, maximum, base_BP_positions[i], spectrum))
                                          for i in range(len(coefficients)) ] ) for x in X_vect]
		return Y_vect

    	if serial:
		Y_SOBP = calculateYa(X_wide, maximum, base_BP_positions, spectrum, plateau_dist, plateau_prox, coefficients)

	if parallel:
		args = (maximum, base_BP_positions, spectrum, plateau_dist, plateau_prox, coefficients_p)
		Y_SOBP = executeParallelMap( calculateYa, args, X_wide)

    else:

	def calculateYb(X_vect, maximum, base_BP_positions, spectrum, coefficients):
	        from src import pyamtrack_SPC
	        Y_vect = [sum( [coefficients[i] * pyamtrack_SPC.dose_at_depth(x, maximum, base_BP_positions[i], spectrum)
                                          for i in range(len(coefficients)) ] ) for x in X_vect]
		return Y_vect

    	if serial:
		Y_SOBP = calculateYb(X_wide, maximum, base_BP_positions, spectrum, coefficients)

	if parallel:
		args = (maximum, base_BP_positions, spectrum, coefficients_p)
		Y_SOBP = executeParallelMap( calculateYb, args, X_wide)

    # plot line at 1
    pylab.axhline(1, color = 'g')

    pylab.plot(X_wide, Y_SOBP, color = 'r', label = 'calculated SOBP')

    listPartPeaksY = []
    for i in range(len(coefficients)):
	def calculateYc(X_vect, coefficient, maximum, base_BP_position, spectrum):
	        from src import pyamtrack_SPC
		return [coefficient * pyamtrack_SPC.dose_at_depth(x, maximum, base_BP_position, spectrum) for x in X_vect]
	if serial:
		Yi = calculateYc(X_wide, coefficients[i], maximum, base_BP_positions[i], spectrum)
	if parallel:
		args = (coefficients_p[i], maximum, base_BP_positions[i], spectrum)
		Yi = executeParallelMap( calculateYc, args, X_wide)

        listPartPeaksY.append(Yi)
        pylab.plot(X_wide, Yi, color = 'g', label = 'BP nr ' + str(i))
        if two_beams:
            plateau_dist = base_BP_positions[-1]
            plateau_prox = base_BP_positions[0]
            Yis = [coefficients[i] * pyamtrack_SPC.dose_at_depth(plateau_dist +  plateau_prox - x, maximum, base_BP_positions[i], spectrum) for x in X_wide]
            pylab.plot(X_wide, Yis, color = 'g', label = 'BP nr ' + str(i) + ' bis')
        
                
    pylab.xlim(0.,X_wide[-1])

    pylab.grid(True)

    # save plot to file
    if filename != None:
        logging.info('Saving SOBP plot to file\'' + filename + '.' + plot_format + '\'...')
        pylab.savefig(filename + '.' + plot_format, format = plot_format)
        save_datafile(filename + '.dat', [X_wide,Y_SOBP]+listPartPeaksY)

    # show what has been plotted
    if show:
        pylab.show()