Misalignment.java

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

  23. /*
  24.  * $Id: Misalignment.java,v 1.2 2009-01-20 19:43:10 kfuchsbe Exp $
  25.  * 
  26.  * $Date: 2009-01-20 19:43:10 $ $Revision: 1.2 $ $Author: kfuchsbe $
  27.  * 
  28.  * Copyright CERN, All Rights Reserved.
  29.  */
  30. package cern.accsoft.steering.jmad.domain.misalign;

  32. import java.util.ArrayList;
  33. import java.util.List;

  35. import cern.accsoft.steering.jmad.util.bean.NamedBean;

  37. /**
  38.  * this class defines values, which describe a misalignment of one or more elements. When communicating with MadX this
  39.  * always results in a set of <a href="http://mad.web.cern.ch/mad/error/error_align.html">EALIGN</a> commands.
  40.  * 
  41.  * @author Kajetan Fuchsberger (kajetan.fuchsberger at cern.ch)
  42.  */
  43. public class Misalignment implements NamedBean {

  45.     /** the listeners */
  46.     private final List<MisalignmentListener> listeners = new ArrayList<MisalignmentListener>();

  48.     /**
  49.      * DX: The misalignment in the x-direction for the entry of the beam element (default: 0 m). DX>0 displaces the
  50.      * element in the positive x-direction
  51.      */
  52.     private Double deltaX = null;

  54.     /**
  55.      * DY: The misalignment in the y-direction for the entry of the beam element (default: 0 m). DY>0 displaces the
  56.      * element in the positive y-direction
  57.      */
  58.     private Double deltaY = null;

  60.     /**
  61.      * DS: The misalignment in the s-direction for the entry of the beam element (default: 0 m). DS>0 displaces the
  62.      * element in the positive s-direction
  63.      */
  64.     private Double deltaS = null;

  66.     /**
  67.      * DPHI: The rotation around the x-axis. A positive angle gives a greater x-coordinate for the exit than for the
  68.      * entry (default: 0 rad).
  69.      */
  70.     private Double deltaPhi = null;

  72.     /**
  73.      * DTHETA: The rotation around the y-axis according to the right hand rule (default: 0 rad).
  74.      */
  75.     private Double deltaTheta = null;

  77.     /**
  78.      * DPSI: The rotation around the s-axis according to the right hand rule (default: 0 rad).
  79.      */
  80.     private Double deltaPsi = null;

  82.     //
  83.     // the following values only apply to monitors
  84.     //

  86.     /**
  87.      * MREX: The horizontal read error for a monitor. This is ignored if the element is not a monitor If MREX>0 the
  88.      * reading for x is too high (default: 0 m).
  89.      */
  90.     private Double monitorReadErrorX = null;

  92.     /**
  93.      * MREY: The vertical read error for a monitor. This is ignored if the element is not a monitor If MREY>0, the
  94.      * reading for y is too high (default: 0 m).
  95.      */
  96.     private Double monitorReadErrorY = null;

  98.     /**
  99.      * MSCALX: The relative horizontal scaling error for a monitor. This is ignored if the element is not a monitor. If
  100.      * MSCALX>0 the reading for x is too high (default: 0). A value of 0.5 implies the actual reading is multiplied by
  101.      * 1.5.
  102.      */
  103.     private Double monitorScalingErrorX = null;

  105.     /**
  106.      * MSCALY: The relative vertical scaling error for a monitor. This is ignored if the element is not a monitor. If
  107.      * MSCALY>0 the reading for y is too high (default: 0). A value of -0.3 implies the actual reading is multiplied by
  108.      * 0.7.
  109.      */
  110.     private Double monitorScalingErrorY = null;

  112.     /**
  113.      * AREX: The misalignment in the x-direction for the entry of an aperture limit (default: 0 m). AREX>0 displaces the
  114.      * element in the positive x-direction
  115.      */
  116.     private Double apertureErrorX = null;

  118.     /**
  119.      * AREY: The misalignment in the y-direction for the entry of an aperture limit (default: 0 m). AREY>0 displaces the
  120.      * element in the positive y-direction
  121.      */
  122.     private Double apertureErrorY = null;

  124.     /**
  125.      * the name of the misalignment
  126.      */
  127.     private final String name;

  129.     /**
  130.      * the constructor-which needs a name
  131.      * 
  132.      * @param name the name
  133.      */
  134.     public Misalignment(String name) {
  135.         this.name = name;
  136.     }

  138.     /*
  139.      * Getters and setters
  140.      */

  142.     /**
  143.      * @return the deltaX
  144.      */
  145.     public final Double getDeltaX() {
  146.         return deltaX;
  147.     }

  149.     /**
  150.      * @param deltaX the deltaX to set
  151.      */
  152.     public final void setDeltaX(Double deltaX) {
  153.         this.deltaX = deltaX;
  154.         fireChangedValues();
  155.     }

  157.     /**
  158.      * @return the deltaY
  159.      */
  160.     public final Double getDeltaY() {
  161.         return deltaY;
  162.     }

  164.     /**
  165.      * @param deltaY the deltaY to set
  166.      */
  167.     public final void setDeltaY(Double deltaY) {
  168.         this.deltaY = deltaY;
  169.         fireChangedValues();
  170.     }

  172.     /**
  173.      * @return the deltaS
  174.      */
  175.     public final Double getDeltaS() {
  176.         return deltaS;
  177.     }

  179.     /**
  180.      * @param deltaS the deltaS to set
  181.      */
  182.     public final void setDeltaS(Double deltaS) {
  183.         this.deltaS = deltaS;
  184.         fireChangedValues();
  185.     }

  187.     /**
  188.      * @return the deltaPhi
  189.      */
  190.     public final Double getDeltaPhi() {
  191.         return deltaPhi;
  192.     }

  194.     /**
  195.      * @param deltaPhi the deltaPhi to set
  196.      */
  197.     public final void setDeltaPhi(Double deltaPhi) {
  198.         this.deltaPhi = deltaPhi;
  199.         fireChangedValues();
  200.     }

  202.     /**
  203.      * @return the deltaTheta
  204.      */
  205.     public final Double getDeltaTheta() {
  206.         return deltaTheta;
  207.     }

  209.     /**
  210.      * @param deltaTheta the deltaTheta to set
  211.      */
  212.     public final void setDeltaTheta(Double deltaTheta) {
  213.         this.deltaTheta = deltaTheta;
  214.         fireChangedValues();
  215.     }

  217.     /**
  218.      * @return the deltaPsi
  219.      */
  220.     public final Double getDeltaPsi() {
  221.         return deltaPsi;
  222.     }

  224.     /**
  225.      * @param deltaPsi the deltaPsi to set
  226.      */
  227.     public final void setDeltaPsi(Double deltaPsi) {
  228.         this.deltaPsi = deltaPsi;
  229.         fireChangedValues();
  230.     }

  232.     /**
  233.      * @return the monitorReadErrorX
  234.      */
  235.     public final Double getMonitorReadErrorX() {
  236.         return monitorReadErrorX;
  237.     }

  239.     /**
  240.      * @param monitorReadErrorX the monitorReadErrorX to set
  241.      */
  242.     public final void setMonitorReadErrorX(Double monitorReadErrorX) {
  243.         this.monitorReadErrorX = monitorReadErrorX;
  244.         fireChangedValues();
  245.     }

  247.     /**
  248.      * @return the monitorReadErrorY
  249.      */
  250.     public final Double getMonitorReadErrorY() {
  251.         return monitorReadErrorY;
  252.     }

  254.     /**
  255.      * @param monitorReadErrorY the monitorReadErrorY to set
  256.      */
  257.     public final void setMonitorReadErrorY(Double monitorReadErrorY) {
  258.         this.monitorReadErrorY = monitorReadErrorY;
  259.         fireChangedValues();
  260.     }

  262.     /**
  263.      * @return the monitorScalingErrorX
  264.      */
  265.     public final Double getMonitorScalingErrorX() {
  266.         return monitorScalingErrorX;
  267.     }

  269.     /**
  270.      * @param monitorScalingErrorX the monitorScalingErrorX to set
  271.      */
  272.     public final void setMonitorScalingErrorX(Double monitorScalingErrorX) {
  273.         this.monitorScalingErrorX = monitorScalingErrorX;
  274.         fireChangedValues();
  275.     }

  277.     /**
  278.      * @return the monitorScalingErrorY
  279.      */
  280.     public final Double getMonitorScalingErrorY() {
  281.         return monitorScalingErrorY;
  282.     }

  284.     /**
  285.      * @param monitorScalingErrorY the monitorScalingErrorY to set
  286.      */
  287.     public final void setMonitorScalingErrorY(Double monitorScalingErrorY) {
  288.         this.monitorScalingErrorY = monitorScalingErrorY;
  289.         fireChangedValues();
  290.     }

  292.     /**
  293.      * @return the apertureErrorX
  294.      */
  295.     public final Double getApertureErrorX() {
  296.         return apertureErrorX;
  297.     }

  299.     /**
  300.      * @param apertureErrorX the apertureErrorX to set
  301.      */
  302.     public final void setApertureErrorX(Double apertureErrorX) {
  303.         this.apertureErrorX = apertureErrorX;
  304.         fireChangedValues();
  305.     }

  307.     /**
  308.      * @return the apertureErrorY
  309.      */
  310.     public final Double getApertureErrorY() {
  311.         return apertureErrorY;
  312.     }

  314.     /**
  315.      * @param apertureErrorY the apertureErrorY to set
  316.      */
  317.     public final void setApertureErrorY(Double apertureErrorY) {
  318.         this.apertureErrorY = apertureErrorY;
  319.         fireChangedValues();
  320.     }

  322.     /*
  323.      * methods concerning listeners
  324.      */

  326.     /**
  327.      * notify the listeners, that values have changed
  328.      */
  329.     private void fireChangedValues() {
  330.         for (MisalignmentListener listener : this.listeners) {
  331.             listener.changedValues(this);
  332.         }
  333.     }

  335.     /**
  336.      * @param listener the listener to add
  337.      */
  338.     public void addListener(MisalignmentListener listener) {
  339.         this.listeners.add(listener);
  340.     }

  342.     /**
  343.      * @param listener the listener to remove
  344.      */
  345.     public void removeListener(MisalignmentListener listener) {
  346.         this.listeners.remove(listener);
  347.     }

  349.     @Override
  350.     public String getName() {
  351.         return this.name;
  352.     }

  354.     @Override
  355.     public String toString() {
  356.         return "Misalignment [deltaX=" + deltaX + ", deltaY=" + deltaY + ", deltaS=" + deltaS + ", monitorReadErrorX="
  357.                 + monitorReadErrorX + ", monitorReadErrorY=" + monitorReadErrorY + ", name=" + name + "]";
  358.     }

  360. }
Created with JaCoCo 0.8.3.201901230119