SimpleOrbitSegmentCalculator.java

  1. // @formatter:off
  2. /*******************************************************************************
  3.  * This file is part of JMad. Copyright (c) 2008-2011, CERN. All rights reserved. Licensed under the Apache License,
  4.  * Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy
  5.  * of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in
  6.  * writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
  7.  * OF ANY KIND, either express or implied. See the License for the specific language governing permissions and
  8.  * limitations under the License.
  9.  ******************************************************************************/
  10. // @formatter:on

  12. package cern.accsoft.steering.jmad.tools.interpolate;

  14. import java.util.Collections;
  15. import java.util.HashMap;
  16. import java.util.LinkedList;
  17. import java.util.Map;

  19. import org.slf4j.Logger;
  20. import org.slf4j.LoggerFactory;

  22. import Jama.Matrix;
  23. import cern.accsoft.steering.jmad.domain.elem.Element;
  24. import cern.accsoft.steering.jmad.domain.optics.Optic;
  25. import cern.accsoft.steering.jmad.domain.optics.OpticPoint;
  26. import cern.accsoft.steering.jmad.domain.optics.OpticPointImpl;
  27. import cern.accsoft.steering.jmad.domain.orbit.Orbit;
  28. import cern.accsoft.steering.jmad.domain.types.enums.JMadPlane;
  29. import cern.accsoft.steering.jmad.domain.var.enums.JMadTwissVariable;
  30. import cern.accsoft.steering.jmad.domain.var.enums.MadxTwissVariable;

  32. /**
  33.  * This class does the actual interpolation of the orbit in one plane for one segment defined by two adjacent monitors.
  34.  * 
  35.  * @author muellerg
  36.  */
  37. public class SimpleOrbitSegmentCalculator implements OrbitSegmentCalculator {
  38.     private static final Logger LOGGER = LoggerFactory.getLogger(SimpleOrbitSegmentCalculator.class);

  40.     /** the plane this orbit segment calculator works on */
  41.     private JMadPlane plane;

  43.     /** the monitor at the beginning of this segment */
  44.     private Element startMonitor;
  45.     /** the monitor at the end of the segment */
  46.     private Element endMonitor;

  48.     /** the transfer matrix between the start and end monitor */
  49.     private Matrix monitorTransferMatrix = null;

  51.     /** the transfer matrix mapping from the start monitor to all the elements of the segment */
  52.     private Map<Element, Matrix> elementMatrices;

  54.     /** the list of elements in the segment, including the monitors (first/last) */
  55.     private LinkedList<Element> segmentElements = new LinkedList<Element>();

  57.     /** flag to determine if segment contains start and end of circular machine */
  58.     private boolean isCycleStartSegment = false;

  60.     /** the maximum mu in the segment */
  61.     private double maxMu;

  63.     public SimpleOrbitSegmentCalculator(JMadPlane plane) {
  64.         this.plane = plane;
  65.         this.elementMatrices = new HashMap<Element, Matrix>();
  66.     }

  68.     @Override
  69.     public void setStartSegmentMonitor(Element element) {
  70.         this.startMonitor = element;
  71.         this.segmentElements.addFirst(element);
  72.     }

  74.     @Override
  75.     public void setEndSegmentMonitor(Element element) {
  76.         this.endMonitor = element;
  77.         this.segmentElements.addLast(element);
  78.     }

  80.     @Override
  81.     public void addElementToCalculate(Element element) {
  82.         this.segmentElements.add(element);
  83.     }

  85.     @Override
  86.     public boolean update(Optic optic) {
  87.         if (this.isCycleStartSegment()) {
  88.             this.updateMuMax(optic);
  89.         }

  91.         if (!this.updateMonitorTransferMatrix(optic)) {
  92.             return false;
  93.         }

  95.         OpticPoint from = optic.getPoint(this.startMonitor);
  96.         for (Element element : this.segmentElements) {
  97.             if (element.equals(startMonitor) || element.equals(endMonitor)) {
  98.                 continue;
  99.             }

  101.             OpticPoint to = optic.getPoint(element);
  102.             if (to == null) {
  103.                 LOGGER.error("Could not update transfer matrix in " + this.getName() + " no optic data for element ["
  104.                         + element.getName() + "] in plane [" + this.getPlane() + "].");
  105.                 return false;
  106.             }

  108.             this.elementMatrices.put(element, this.calculateTransferMatrix(from, to));
  109.         }

  111.         return true;
  112.     }

  114.     private void updateMuMax(Optic optic) {
  115.         double maxMu = Double.MIN_VALUE;
  116.         for (Element element : this.segmentElements) {
  117.             double mu = optic.getPoint(element).getValue(JMadTwissVariable.MU, this.getPlane());
  118.             if (mu > maxMu) {
  119.                 maxMu = mu;
  120.             }
  121.         }

  123.         this.setMaxMu(maxMu);
  124.     }

  126.     private void setMaxMu(double maxMu) {
  127.         this.maxMu = maxMu;
  128.     }

  130.     private double getMaxMu() {
  131.         return this.maxMu;
  132.     }

  134.     private Matrix calculateTransferMatrix(OpticPoint from, OpticPoint to) {
  135.         if (!this.isCycleStartSegment()) {
  136.             return TransferMatrixCalculator.calculate(getPlane(), from, to);
  137.         }

  139.         double muFrom = from.getValue(JMadTwissVariable.MU, this.getPlane());
  140.         double muTo = to.getValue(JMadTwissVariable.MU, this.getPlane());

  142.         if (muTo < muFrom) {
  143.             muTo = muTo + (this.getMaxMu() - muFrom);
  144.             muFrom = 0.0;
  145.             return TransferMatrixCalculator.calculate(getPlane(), this.adaptOpticPoint(from, muFrom), this
  146.                     .adaptOpticPoint(to, muTo));
  147.         } else {
  148.             return TransferMatrixCalculator.calculate(getPlane(), from, to);
  149.         }
  150.     }

  152.     private OpticPoint adaptOpticPoint(OpticPoint point, double newMu) {
  153.         OpticPointImpl newPoint = new OpticPointImpl(point.getName());
  154.         for (JMadTwissVariable variable : TransferMatrixCalculator.REQUIRED_VARIABLES) {
  155.             newPoint.setValue(variable.getMadxTwissVariable(getPlane()), point.getValue(variable, this.getPlane()));
  156.         }

  158.         newPoint.setValue(JMadTwissVariable.MU.getMadxTwissVariable(getPlane()), newMu);
  159.         return newPoint;
  160.     }

  162.     private boolean updateMonitorTransferMatrix(Optic optic) {

  164.         OpticPoint from = optic.getPoint(this.startMonitor);
  165.         OpticPoint to = optic.getPoint(endMonitor);

  167.         if (from == null || to == null) {
  168.             LOGGER.error("Could not update monitor transfer matrix in " + this.getName()
  169.                     + " no optic data for monitors.");
  170.             this.monitorTransferMatrix = null;
  171.             return false;
  172.         }

  174.         this.monitorTransferMatrix = this.calculateTransferMatrix(from, to);
  175.         return true;
  176.     }

  178.     @Override
  179.     public Map<Element, Map<MadxTwissVariable, Double>> calculate(Orbit orbit) {
  180.         if (this.monitorTransferMatrix == null) {
  181.             LOGGER.error("Segment orbit interpolation calculator not initialized for " + this.getName());
  182.             return Collections.emptyMap();
  183.         }

  185.         Map<Element, Map<MadxTwissVariable, Double>> elementValueMapping = new HashMap<Element, Map<MadxTwissVariable, Double>>();
  186.         double pos_start = this.getMonitorPosition(this.startMonitor, orbit);
  187.         double pos_end = this.getMonitorPosition(this.endMonitor, orbit);

  189.         double c_seg = this.monitorTransferMatrix.get(0, 0);
  190.         double s_seg = this.monitorTransferMatrix.get(0, 1);

  192.         double factor = (pos_end - (c_seg * pos_start)) / s_seg;

  194.         for (Element element : this.segmentElements) {
  195.             Map<MadxTwissVariable, Double> valueMapping = new HashMap<MadxTwissVariable, Double>();
  196.             elementValueMapping.put(element, valueMapping);

  198.             /* for the monitors we just copy the reading */
  199.             boolean positionDone = false;
  200.             if (element.equals(startMonitor)) {
  201.                 valueMapping.put(JMadTwissVariable.POS.getMadxTwissVariable(getPlane()), pos_start);
  202.                 positionDone = true;
  203.             }
  204.             if (element.equals(endMonitor)) {
  205.                 valueMapping.put(JMadTwissVariable.POS.getMadxTwissVariable(getPlane()), pos_end);
  206.                 positionDone = true;
  207.             }

  209.             /* do the interpolation */
  210.             Matrix elementMatrix = this.elementMatrices.get(element);

  212.             if (!positionDone) {
  213.                 double c_elem = elementMatrix.get(0, 0);
  214.                 double s_elem = elementMatrix.get(0, 1);
  215.                 double value = c_elem * pos_start + s_elem * factor;

  217.                 valueMapping.put(JMadTwissVariable.POS.getMadxTwissVariable(getPlane()), value);

  219.                 double cp_elem = elementMatrix.get(1, 0);
  220.                 double sp_elem = elementMatrix.get(1, 1);
  221.                 value = cp_elem * pos_start + sp_elem * factor;
  222.                 valueMapping.put(JMadTwissVariable.P.getMadxTwissVariable(getPlane()), value);
  223.                 
  224.             } else {
  225.                 double cp_elem = this.monitorTransferMatrix.get(1, 0);
  226.                 double sp_elem = this.monitorTransferMatrix.get(1, 1);
  227.                 double value = cp_elem * pos_start + sp_elem * factor;
  228.                 valueMapping.put(JMadTwissVariable.P.getMadxTwissVariable(getPlane()), value);
  229.             }
  230.         }

  232.         return elementValueMapping;
  233.     }

  235.     private double getMonitorPosition(Element monitor, Orbit orbit) {
  236.         int index = orbit.getMonitorIndex(monitor.getName());
  237.         return orbit.getValues(this.getPlane()).get(index);
  238.     }

  240.     @Override
  241.     public String getName() {
  242.         return "segment [" + this.startMonitor.getName() + "-->" + this.endMonitor.getName() + "] for plane ["
  243.                 + this.getPlane() + "]";
  244.     }

  246.     @Override
  247.     public JMadPlane getPlane() {
  248.         return this.plane;
  249.     }

  251.     @Override
  252.     public void setIsCycleStartSegment(boolean isCycleStartSegment) {
  253.         this.isCycleStartSegment = isCycleStartSegment;
  254.     }

  256.     private boolean isCycleStartSegment() {
  257.         return isCycleStartSegment;
  258.     }
  259. }
Created with JaCoCo 0.8.3.201901230119