ApertureSlice.java
// @formatter:off
/*******************************************************************************
*
* This file is part of JMad.
*
* Copyright (c) 2008-2011, CERN. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
// @formatter:on
package cern.accsoft.steering.jmad.domain.aperture;
import cern.accsoft.steering.jmad.domain.types.enums.JMadPlane;
/**
* Represents one slice of aperture in the aperture model. Such a slice is not necessarily equivalent with one element.
* In the contrary on element might have many slices.
* <p>
* This class contains the original values as well as the calculated min/max values for the both planes. Additionaly the
* positions for a so-called reference trajectory are stored, around which the aperture can later be centered.
*
* @author Kajetan Fuchsberger (kajetan.fuchsberger at cern.ch)
*/
public class ApertureSlice {
private static final double MAX_APERTURE = 0.2;
private AperType type;
private double xMin;
private double xMax;
private double yMin;
private double yMax;
private double aper1;
private double aper2;
private double aper3;
private double aper4;
private double posX;
private double posY;
private double posS;
/**
* Create a new ApertureSlice and calculate the Aperture Extrema
*
* @param type {@link AperType} of this Element
* @param aper1 Aperture Value 1
* @param aper2 Aperture Value 2
* @param aper3 Aperture Value 3
* @param aper4 Aperture Value 4
* @param pos Position of this Element in the Sequence
*/
public ApertureSlice(AperType type, double aper1, double aper2, double aper3, double aper4, double pos) {
this.posS = pos;
this.type = type;
this.setApertureValues(aper1, aper2, aper3, aper4);
}
/**
* Create a new ApertureSlice only defined by its Type and Position
*
* @param type {@link AperType} of this Element
* @param pos Position of this Element in the Sequence
*/
public ApertureSlice(AperType type, double pos) {
this.posS = pos;
this.type = type;
}
public double getAper1() {
return aper1;
}
public double getAper2() {
return aper2;
}
public double getAper3() {
return aper3;
}
public double getAper4() {
return aper4;
}
/**
* Calculate the Aperture Extrema for the Aperture Slice according to the type and the 4 Aperture Values
*
* @param aper1 the value of the madx-variable aper1
* @param aper2 the value of the madx-variable aper2
* @param aper3 the value of the madx-variable aper3
* @param aper4 the value of the madx-variable aper4
*/
public final void setApertureValues(double aper1, double aper2, double aper3, double aper4) {
// Ensure visibility in Plots
this.aper1 = (aper1 > MAX_APERTURE ? MAX_APERTURE : aper1);
this.aper2 = (aper2 > MAX_APERTURE ? MAX_APERTURE : aper2);
this.aper3 = (aper3 > MAX_APERTURE ? MAX_APERTURE : aper3);
this.aper4 = (aper4 > MAX_APERTURE ? MAX_APERTURE : aper4);
switch (this.type) {
case RACETRACK:
this.xMin = -aper1 - aper3;
this.xMax = +aper1 + aper3;
this.yMin = -aper2 - aper3;
this.yMax = +aper2 + aper3;
break;
case RECTELLIPSE:
this.xMin = (-1.0) * Math.min(aper1, aper3);
this.xMax = Math.min(aper1, aper3);
this.yMin = (-1.0) * Math.min(aper2, aper4);
this.yMax = Math.min(aper2, aper4);
break;
case CIRCLE:
this.xMin = (-1.0) * aper1;
this.xMax = aper1;
this.yMin = (-1.0) * aper1;
this.yMax = aper1;
break;
case RECTANGLE:
this.xMin = (-1.0) * aper1;
this.xMax = aper1;
this.yMin = (-1.0) * aper2;
this.yMax = aper2;
break;
default:
}
}
/**
* Compares two aperture slices
*
* @param actSlice aperture slice to compare to this one
* @return <code>true</code> when type/position and all 4 ApertureValues are equal
*/
public boolean sameAperInfo(ApertureSlice actSlice) {
if (actSlice.type.equals(this.type) && actSlice.posS == this.posS && actSlice.aper1 == this.aper1
&& actSlice.aper2 == this.aper2 && actSlice.aper3 == this.aper3 && actSlice.aper4 == this.aper4) {
return true;
}
return false;
}
public AperType getType() {
return type;
}
public void setType(AperType type) {
this.type = type;
}
public double getXmin() {
return xMin;
}
public void setXmin(double xMin) {
this.xMin = xMin;
}
public double getXmax() {
return xMax;
}
public void setXmax(double xMax) {
this.xMax = xMax;
}
public double getS() {
return posS;
}
public void setS(double posS) {
this.posS = posS;
}
public double getYmin() {
return yMin;
}
public void setYmin(double yMin) {
this.yMin = yMin;
}
public double getYmax() {
return yMax;
}
public void setYmax(double yMax) {
this.yMax = yMax;
}
public double getX() {
return posX;
}
public void setX(double x) {
this.posX = x;
}
public double getY() {
return posY;
}
public void setY(double y) {
this.posY = y;
}
/**
* retrieves the trajectory-position for the given plane. This is the position around which the aperture can be
* centered.
*
* @param plane the plane for which to get the position
* @return the position in the given plane
*/
public double getPos(JMadPlane plane) {
switch (plane) {
case H:
return getX();
case V:
return getY();
default:
throw new IllegalArgumentException("Unknown plane '" + plane + "'.");
}
}
/**
* returns max value of the aperture in the given plane.
*
* @param plane the plane for which to get the value
* @return the max aperture value in the given plane
*/
public double getMax(JMadPlane plane) {
switch (plane) {
case H:
return getXmax();
case V:
return getYmax();
default:
throw new IllegalArgumentException("Unknown plane '" + plane + "'.");
}
}
/**
* returns the aperture minimum value in the given plane
*
* @param plane the plane for which to retrieve the minimum value
* @return the aperture minimum value in the given plane
*/
public double getMin(JMadPlane plane) {
switch (plane) {
case H:
return getXmin();
case V:
return getYmin();
default:
throw new IllegalArgumentException("Unknown plane '" + plane + "'.");
}
}
}