def analyzeData(self,gd): """ Analysis of the BasicGraphData() instance with data. Returns the error value. """ if(gd.getNumbOfPoints() == 0): return 0. y_max = gd.getMaxY() y_min = gd.getMinY() amp0 = (y_max - y_min)/2.0 amp_step = 0.05*amp0 phase_step = 3.0 self.param_arr[0] = (y_max + y_min)/2.0 for i_h in range(self.n_harm+1): param_local_arr = self.param_arr[0:2*i_h+1] #print "debug i_h=",i_h," =====start ==== param_arr=",param_local_arr variables = ArrayList() delta_hint = InitialDelta() var = Variable("base",param_local_arr[0], - Double.MAX_VALUE, Double.MAX_VALUE) variables.add(var) delta_hint.addInitialDelta(var,amp_step) for i_fit in range(i_h): var = Variable("amp"+str(i_fit),param_local_arr[2*i_fit+1], - Double.MAX_VALUE, Double.MAX_VALUE) variables.add(var) delta_hint.addInitialDelta(var,amp_step) var = Variable("phase"+str(i_fit),param_local_arr[2*i_fit+2], - Double.MAX_VALUE, Double.MAX_VALUE) variables.add(var) delta_hint.addInitialDelta(var,phase_step) scorer = HarmScorer(gd,variables) self.harm_func = scorer.getHarmFunc() if(i_h == 0): scorer.copyFromExternalParams(self.param_arr) (amp,shift) = scorer.getNextHarm_Amp_Shift() #print "debug zero harm (amp,shift)=",(amp,shift) self.param_arr[2*i_h+1] = amp self.param_arr[2*i_h+2] = shift #print "debug i_h=",i_h," =====final ==== param_arr=", self.param_arr continue maxSolutionStopper = SolveStopperFactory.maxEvaluationsStopper((i_h+1)*self.n_iter) solver = Solver(SimplexSearchAlgorithm(),maxSolutionStopper) problem = ProblemFactory.getInverseSquareMinimizerProblem(variables,scorer,0.0001) problem.addHint(delta_hint) solver.solve(problem) #------- get results trial = solver.getScoreBoard().getBestSolution() err2 = scorer.score(trial,variables) scorer.copyToExternalParams(self.param_arr) #print "debug i_h=",i_h," =====final err2=",math.sqrt(err2),"==== param_arr=", self.param_arr if(i_h != self.n_harm): (amp,shift) = scorer.getNextHarm_Amp_Shift() #print "debug last step (amp,shift)=",(amp,shift) self.param_arr[2*i_h+1] = amp self.param_arr[2*i_h+2] = shift #print "debug i_h=",i_h," ===== last step==== param_arr=", self.param_arr return math.sqrt(err2)
class SCL_One_Cavity_Tracker_Model: def __init__(self,scl_long_tuneup_controller): self.scl_long_tuneup_controller = scl_long_tuneup_controller self.scl_accSeq = self.scl_long_tuneup_controller.scl_accSeq self.part_tracker = AlgorithmFactory.createParticleTracker(self.scl_accSeq) self.part_tracker.setRfGapPhaseCalculation(true) self.part_probe_init = ProbeFactory.createParticleProbe(self.scl_accSeq,self.part_tracker) self.scenario = Scenario.newScenarioFor(self.scl_accSeq) self.scenario.setSynchronizationMode(Scenario.SYNC_MODE_DESIGN) self.scenario.resync() # in the dictionary we will have # cav_wrappers_param_dict[cav_wrapper] = [cavAmp,phase,[[gapLattElem,E0,ETL],...]] # E0 and ETL are parameters for all RF gaps self.cav_wrappers_param_dict = {} cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers self.cav_amp_phase_dict = {} for cav_wrapper in cav_wrappers: amp = cav_wrapper.cav.getDfltCavAmp() phase = cav_wrapper.cav.getDfltCavPhase() self.cav_amp_phase_dict[cav_wrapper] = (amp,phase) #------ Make rf gap arrays for each cavity. #------ The elements are IdealRfGap instances not AcceleratorNode. #------ self.cavToGapsDict has {cav_name:[irfGaps]} rfGaps = self.scl_accSeq.getAllNodesWithQualifier(AndTypeQualifier().and((OrTypeQualifier()).or(RfGap.s_strType))) self.cavToGapsDict = {} for cav_wrapper in cav_wrappers: self.cavToGapsDict[cav_wrapper] = [] for rfGap in rfGaps: if(rfGap.getId().find(cav_wrapper.cav.getId()) >= 0): irfGaps = self.scenario.elementsMappedTo(rfGap) self.cavToGapsDict[cav_wrapper].append(irfGaps[0]) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_PHASE,phase) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_ETL,val) #self.scenario.setModelInput(self.gap_first,RfGapPropertyAccessor.PROPERTY_E0,val) #self.scenario.setModelInput(quad,ElectromagnetPropertyAccessor,PROPERTY_FIELD,val) #---------------------------------------------------------------- self.scan_gd = BasicGraphData() self.harmonicsAnalyzer = HarmonicsAnalyzer(2) self.eKin_in = 185.6 self.cav_amp = 14.0 self.cav_phase_shift = 0. #------------------------ self.active_cav_wrapper = null self.solver = null def restoreInitAmpPhases(self): cav_wrappers = self.scl_long_tuneup_controller.cav_wrappers for cav_wrapper in cav_wrappers: (amp,phase) = self.cav_amp_phase_dict[cav_wrapper] self.active_cav_wrapper.cav.updateDesignAmp(amp) self.active_cav_wrapper.cav.updateDesignPhase(phase) self.setActiveCavity(null) def getEkinAmpPhaseShift(self): return (self.eKin_in,self.cav_amp,self.cav_phase_shift) def setModelAmpPhaseToActiveCav(self,amp,phase,phase_shift): if(self.active_cav_wrapper != null): self.active_cav_wrapper.cav.updateDesignAmp(amp) self.active_cav_wrapper.cav.updateDesignPhase(phase-phase_shift) def getAvgGapPhase(self): #------------- calculate avg. RF gap phase ----------- if(self.active_cav_wrapper == null): return 0. rf_gap_arr = self.cavToGapsDict[self.active_cav_wrapper] phase_rf_gaps_avg = 0. for irfGap in rf_gap_arr: phase_rf_gaps_avg += makePhaseNear(irfGap.getPhase(),0.) phase_rf_gaps_avg /= len(rf_gap_arr) phase_rf_gaps_avg = makePhaseNear((phase_rf_gaps_avg*180./math.pi)%360.,0.) return phase_rf_gaps_avg def getModelEnergyOut(self,eKin_in,amp,phase,phase_shift): if(self.active_cav_wrapper == null): return 0. self.setModelAmpPhaseToActiveCav(amp,phase,phase_shift) part_probe = ParticleProbe(self.part_probe_init) part_probe.setKineticEnergy(eKin_in*1.0e+6) self.scenario.setProbe(part_probe) self.scenario.resync() self.scenario.run() return self.scenario.getTrajectory().finalState().getKineticEnergy()/1.0e+6 def fillOutEneregyVsPhase(self,eKin_in,amp,phase_shift,phase_arr): self.scan_gd.removeAllPoints() if(self.active_cav_wrapper == null): return self.active_cav_wrapper.cav.updateDesignAmp(amp) self.scenario.resync() irfGap = self.cavToGapsDict[self.active_cav_wrapper][0] for phase in phase_arr: part_probe = ParticleProbe(self.part_probe_init) part_probe.setKineticEnergy(eKin_in*1.0e+6) self.scenario.setProbe(part_probe) #self.active_cav_wrapper.cav.updateDesignPhase(phase-phase_shift) #self.scenario.resync() irfGap.setPhase((phase-phase_shift)*math.pi/180.) self.scenario.run() eKin_out = self.scenario.getTrajectory().finalState().getKineticEnergy()/1.0e+6 self.scan_gd.addPoint(phase,eKin_out) return self.scan_gd def getDiff2(self,eKin_in,amp,phase_shift): if(self.active_cav_wrapper == null): return 0. scan_gdExp = self.active_cav_wrapper.eKinOutPlot n_points = scan_gdExp.getNumbOfPoints() if(n_points <= 0): return 0. phase_arr = [] for ip in range(n_points): phase_arr.append(scan_gdExp.getX(ip)) scan_gd = self.fillOutEneregyVsPhase(eKin_in,amp,phase_shift,phase_arr) diff2 = 0. for ip in range(n_points): diff2 += (scan_gd.getY(ip) - scan_gdExp.getY(ip))**2 diff2 /= n_points return diff2 def setActiveCavity(self,cav_wrapper): self.active_cav_wrapper = cav_wrapper if(cav_wrapper != null): self.gap_list = cav_wrapper.cav.getGapsAsList() self.gap_first = self.gap_list.get(0) self.gap_last = self.gap_list.get(self.gap_list.size()-1) self.scenario.setStartNode(self.gap_first.getId()) self.scenario.setStopNode(self.gap_last.getId()) else: self.scenario.unsetStartNode() self.scenario.unsetStopNode() self.gap_first = null self.gap_last = null self.gap_list = null def harmonicsAnalysisStep(self): if(self.active_cav_wrapper == null): return self.eKin_in = self.active_cav_wrapper.eKin_in self.cav_amp = 14.0 self.cav_phase_shift = 0. #--------- first iteration self.getDiff2(self.eKin_in,self.cav_amp,self.cav_phase_shift) err = self.harmonicsAnalyzer.analyzeData(self.scan_gd) harm_function = self.harmonicsAnalyzer.getHrmonicsFunction() energy_amp_test = harm_function.getParamArr()[1] energy_amp_exp = self.active_cav_wrapper.energy_guess_harm_funcion.getParamArr()[1] self.cav_amp = self.cav_amp*energy_amp_exp/energy_amp_test #--------- second iteration self.getDiff2(self.eKin_in,self.cav_amp,self.cav_phase_shift) err = self.harmonicsAnalyzer.analyzeData(self.scan_gd) harm_function = self.harmonicsAnalyzer.getHrmonicsFunction() energy_amp_test = harm_function.getParamArr()[1] energy_amp_exp = self.active_cav_wrapper.energy_guess_harm_funcion.getParamArr()[1] self.cav_amp = self.cav_amp*energy_amp_exp/energy_amp_test max_model_energy_phase = self.harmonicsAnalyzer.getPositionOfMax() max_exp_energy_phase = self.active_cav_wrapper.energy_guess_harm_funcion.findMax() self.cav_phase_shift = makePhaseNear(-(max_model_energy_phase - max_exp_energy_phase),0.) #print "debug model max=",max_model_energy_phase," exp=",max_exp_energy_phase," shift=",self.cav_phase_shift," amp=",self.cav_amp def fit(self): if(self.active_cav_wrapper == null): return variables = ArrayList() delta_hint = InitialDelta() #----- variable eKin_in var = Variable("eKin_in",self.eKin_in, - Double.MAX_VALUE, Double.MAX_VALUE) variables.add(var) delta_hint.addInitialDelta(var,0.3) #----- variable cavity amplitude var = Variable("cav_amp",self.cav_amp, - Double.MAX_VALUE, Double.MAX_VALUE) variables.add(var) delta_hint.addInitialDelta(var,self.cav_amp*0.01) #----- variable cavity phase offset var = Variable("phase_offset",self.cav_phase_shift, - Double.MAX_VALUE, Double.MAX_VALUE) variables.add(var) delta_hint.addInitialDelta(var,1.0) #-------- solve the fitting problem scorer = CavAmpPhaseScorer(self,variables) maxSolutionStopper = SolveStopperFactory.maxEvaluationsStopper(120) self.solver = Solver(SimplexSearchAlgorithm(),maxSolutionStopper) problem = ProblemFactory.getInverseSquareMinimizerProblem(variables,scorer,0.0001) problem.addHint(delta_hint) self.solver.solve(problem) #------- get results trial = self.solver.getScoreBoard().getBestSolution() err2 = scorer.score(trial,variables) [self.eKin_in,self.cav_amp,self.cav_phase_shift] = scorer .getTrialParams(trial) self.active_cav_wrapper.eKin_in = self.eKin_in self.active_cav_wrapper.designPhase = makePhaseNear(self.active_cav_wrapper.livePhase - self.cav_phase_shift,0.) self.active_cav_wrapper.eKin_err = math.sqrt(err2) cav_phase = self.active_cav_wrapper.livePhase self.active_cav_wrapper.eKin_out = self.getModelEnergyOut(self.eKin_in,self.cav_amp,cav_phase,self.cav_phase_shift) #print "debug cav=",self.active_cav_wrapper.alias," shift=",self.cav_phase_shift," amp=",self.cav_amp," err2=", math.sqrt(err2)," ekinOut=", self.active_cav_wrapper.eKin_out #----- this defenition of the avg. gap phase will be replaced by another with self.model_eKin_in self.active_cav_wrapper.avg_gap_phase = self.getAvgGapPhase() self.active_cav_wrapper.designAmp = self.cav_amp self.solver = null #----make theory graph plot x_arr = [] y_arr = [] for i in range(self.scan_gd.getNumbOfPoints()): phase = self.scan_gd.getX(i) y = self.scan_gd.getY(i) x_arr.append(phase) y_arr.append(y) self.active_cav_wrapper.eKinOutPlotTh.addPoint(x_arr,y_arr) def stopFitting(self): if(self.solver != null): self.solver.stopSolving()
dch = dchs[dch_ind] field = dch.getField() var = Variable(dch.getId(), field, field_min, field_max) variables.add(var) delta_hint.addInitialDelta(var, field_step) scorer = OrbitScorer(bpms, dchs, variables) n_iterations = 200 maxSolutionStopper = SolveStopperFactory.maxEvaluationsStopper(n_iterations) #solver = Solver(SimplexSearchAlgorithm(),maxSolutionStopper) solver = Solver(RandomShrinkSearch(), maxSolutionStopper) problem = ProblemFactory.getInverseSquareMinimizerProblem( variables, scorer, 0.00000001) problem.addHint(delta_hint) solver.solve(problem) #------- get optimization results trial = solver.getScoreBoard().getBestSolution() dch_field_arr = scorer.getDCH_Field_Arr_for_Trial(trial) print "========== put new dch fields into VA ======" #---- send all results to EPICS for dch_ind in range(len(dchs)): dch = dchs[dch_ind] field = dch_field_arr[dch_ind] dch.setField(field) print "dch=", dch.getId(), " field= %+8.6f " % field print "Done."
def run(self): tr_twiss_analysis_controller = self.linac_wizard_document.tr_twiss_analysis_controller transverse_twiss_fitting_controller = tr_twiss_analysis_controller.transverse_twiss_fitting_controller init_and_fit_params_controller = transverse_twiss_fitting_controller.init_and_fit_params_controller initial_twiss_params_holder = transverse_twiss_fitting_controller.initial_twiss_params_holder final_twiss_params_holder = init_and_fit_params_controller.final_twiss_params_holder nIterations = int(init_and_fit_params_controller.fit_iter_text.getValue()) #print "debug Twiss_Fitter start to run! Iter=",nIterations (alphaX, betaX, emittX) = initial_twiss_params_holder.getParams(0) (alphaY, betaY, emittY) = initial_twiss_params_holder.getParams(1) (alphaZ, betaZ, emittZ) = initial_twiss_params_holder.getParams(2) twiss_arr = [] twiss_arr.append(Twiss(alphaX, betaX, emittX)) twiss_arr.append(Twiss(alphaY, betaY, emittY)) twiss_arr.append(Twiss(alphaZ, betaZ, emittZ)) (alphaXStep, betaXStep, emittXStep) = initial_twiss_params_holder.getParamsStep(0) (alphaYStep, betaYStep, emittYStep) = initial_twiss_params_holder.getParamsStep(1) (alphaZStep, betaZStep, emittZStep) = initial_twiss_params_holder.getParamsStep(2) variables = ArrayList() variables.add(Variable("alphaX", alphaX, - Double.MAX_VALUE, Double.MAX_VALUE)) variables.add(Variable("betaX", betaX, - Double.MAX_VALUE, Double.MAX_VALUE)) variables.add(Variable("emittX", emittX, - Double.MAX_VALUE, Double.MAX_VALUE)) variables.add(Variable("alphaY", alphaY, - Double.MAX_VALUE, Double.MAX_VALUE)) variables.add(Variable("betaY", betaY, - Double.MAX_VALUE, Double.MAX_VALUE)) variables.add(Variable("emittY", emittY, - Double.MAX_VALUE, Double.MAX_VALUE)) variables.add(Variable("alphaZ", alphaZ, - Double.MAX_VALUE, Double.MAX_VALUE)) variables.add(Variable("betaZ", betaZ, - Double.MAX_VALUE, Double.MAX_VALUE)) variables.add(Variable("emittZ", emittZ, - Double.MAX_VALUE, Double.MAX_VALUE)) delta_hint = InitialDelta() variables_fit = ArrayList() #---------- X if(alphaXStep != 0.): variables_fit.add(variables.get(0)) delta_hint.addInitialDelta(variables.get(0), alphaXStep) if(betaXStep != 0.): variables_fit.add(variables.get(1)) delta_hint.addInitialDelta(variables.get(1), betaXStep) if(emittXStep != 0.): variables_fit.add(variables.get(2)) delta_hint.addInitialDelta(variables.get(2), emittXStep) #---------- Y if(alphaYStep != 0.): variables_fit.add(variables.get(3)) delta_hint.addInitialDelta(variables.get(3), alphaYStep) if(betaYStep != 0.): variables_fit.add(variables.get(4)) delta_hint.addInitialDelta(variables.get(4), betaYStep) if(emittYStep != 0.): variables_fit.add(variables.get(5)) delta_hint.addInitialDelta(variables.get(5), emittYStep) #---------- Z if(alphaZStep != 0.): variables_fit.add(variables.get(6)) delta_hint.addInitialDelta(variables.get(6), alphaZStep) if(betaZStep != 0.): variables_fit.add(variables.get(7)) delta_hint.addInitialDelta(variables.get(7), betaZStep) if(emittZStep != 0.): variables_fit.add(variables.get(8)) delta_hint.addInitialDelta(variables.get(8), emittZStep) #------- fitting process with solver if(variables_fit.isEmpty()): return scorer = AccScoreCalculator(self.linac_wizard_document,variables,twiss_arr) maxSolutionStopper = SolveStopperFactory.maxEvaluationsStopper(nIterations) solver = Solver(SimplexSearchAlgorithm(),maxSolutionStopper) self.solver = solver problem = ProblemFactory.getInverseSquareMinimizerProblem(variables_fit,scorer,0.001) problem.addHint(delta_hint) solver.solve(problem) #------- get results trial = solver.getScoreBoard().getBestSolution() scorer.trialToTwiss(trial) twiss_arr = scorer.getTwissArr() (alphaX, betaX, emittX) = (twiss_arr[0].getAlpha(),twiss_arr[0].getBeta(),twiss_arr[0].getEmittance()) (alphaY, betaY, emittY) = (twiss_arr[1].getAlpha(),twiss_arr[1].getBeta(),twiss_arr[1].getEmittance()) (alphaZ, betaZ, emittZ) = (twiss_arr[2].getAlpha(),twiss_arr[2].getBeta(),twiss_arr[2].getEmittance()) final_twiss_params_holder.setParams(0,alphaX, betaX, emittX) final_twiss_params_holder.setParams(1,alphaY, betaY, emittY) final_twiss_params_holder.setParams(2,alphaZ, betaZ, emittZ) init_and_fit_params_controller.finalTwiss_table.getModel().fireTableDataChanged() init_and_fit_params_controller.fit_iter_left_text.setValue(0.) scorer.setUpLastNode(false) scorer.calculateDiff2()