DeviceCalibrationCurveConverter_20112019.java

package de.gsi.cs.co.ap.app.magstat.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import cern.accsoft.commons.value.BoundedPolynomial;
import cern.accsoft.commons.value.BoundedPolynomialSequence;
//import cern.accsoft.commons.value.Interval;
//import cern.japc.group.support.SysoutFailSafeParameterValueListener;
// import cern.accsoft.commons.value.Polynomial;
// import cern.accsoft.commons.value.operation.BoundedPolynomialOperations;
// import cern.accsoft.commons.value.operation.BoundedPolynomialSequenceOperations;
// import cern.accsoft.commons.value.operation.PolynomialOperations;
import cern.lsa.client.OpticService;
import cern.lsa.client.Services;
// import cern.lsa.domain.commons.BoundedFunction;
// import cern.lsa.domain.commons.CalibrationFunction;
import cern.lsa.domain.commons.spi.CalibrationFunctionWrapper;
import cern.lsa.domain.devices.factory.DevicesRequestBuilder;
// import cern.lsa.domain.devices.Device;
import cern.lsa.domain.optics.Calibration;
import cern.lsa.domain.optics.CalibrationFunctionTypes;
import cern.lsa.domain.optics.LogicalHardware;

/**
 * @author fschirru
 */

public class DeviceCalibrationCurveConverter {

	public DeviceCalibrationCurveConverter() {

	}
	
	private List<Object[]> deviceSign_list = new ArrayList<>();

	private int logicalDeviceSign;
		
	private String logicalDeviceName;

	private DevicesRequestBuilder builder = new DevicesRequestBuilder();

	private Set<LogicalHardware> logicalHardware;
	
	final OpticService opticService = Services.getOpticService();

	private static final RegulaFalsiMethod rfm = RegulaFalsiMethod.getInstance();

	private static final DeviceCalibrationCurveConverter INSTANCE = new DeviceCalibrationCurveConverter();

	public static DeviceCalibrationCurveConverter getInstance() {

		return INSTANCE;
	}
	
	public void clearDeviceCalibrationSign() {
	    
	    deviceSign_list.clear();
	}
	
	//separate method to retrieve the calibration sign
	public void setDeviceCalibrationSign(final String device_name) {
	    	    
	    logicalDeviceName = "LOGICAL." + device_name;
    
        builder.setDeviceName(logicalDeviceName);

        logicalHardware = Services.getDeviceService().findLogicalHardware(builder.build());

        logicalDeviceSign = logicalHardware.iterator().next().getCalibrationSign();
  	    
	    deviceSign_list.add(new Object[] { device_name, logicalDeviceSign});	    
	}
	
	public void printDeviceCalibrationSign() {
	    
	    for(int i = 0; i < deviceSign_list.size(); i++) {
	        
	        System.out.println("List of DEVICES with CALBRATION SIGN");
	        System.out.println(deviceSign_list.get(i)[0] + " " + deviceSign_list.get(i)[1]);
	    }
	}
	
	public double getValueFromCalibrationCurve(final String name, final double y, final String calType) {
	    
	    logicalDeviceName = "LOGICAL." + name;
		double invertedValue = 0.0;

		try {

			final Calibration calibration = opticService.findCalibrationByLogicalHardware(logicalDeviceName);
						    
			// Case of conversion current to bfield
			if (calType.equals("current")) {

				// System.out.println("Current processing");

				final CalibrationFunctionWrapper currentAsFunctionOfIntegralField = (CalibrationFunctionWrapper) calibration
						.getCalibrationFunction(CalibrationFunctionTypes.MAG_INTFIELD2CURRENT);

				// System.out.println(currentAsFunctionOfIntegralField);

				final BoundedPolynomialSequence boundedPolynomialSequence = (BoundedPolynomialSequence) currentAsFunctionOfIntegralField
						.getInterpolable();

				// System.out.println(boundedPolynomialSequence);

				final BoundedPolynomial polynomial = findBoundedPolynomial(boundedPolynomialSequence, y);

				if (polynomial != null) {

					invertedValue = rfm.findRoot(polynomial.getInterval().getLowerBound(),
							polynomial.getInterval().getUpperBound(), 5E-8, 1000, polynomial, y);
								
					//retrieve the proper calibration sign
					// the sign applies only when converting I -> B
	                for(int i = 0; i < deviceSign_list.size(); i++) {
	                    
	                    if(name.equals(deviceSign_list.get(i)[0].toString())) {
	                     
	                        //System.out.println("device found " + deviceSign_list.get(i)[0].toString() + " " + deviceSign_list.get(i)[1].toString());
	                        invertedValue = invertedValue * Integer.parseInt(deviceSign_list.get(i)[1].toString());
	                        
	                        break;
	                    }
	                }	
					
				} else {

					invertedValue = 0.0;
				}	
			}

			// Case of conversion voltage to bfield
			if (calType.equals("voltage")) {

				if (logicalDeviceName.substring(8).equals("GTS3MU1") || logicalDeviceName.substring(8).equals("GTS3MU2")
						|| logicalDeviceName.substring(8).equals("GTS4MU1")
						|| logicalDeviceName.substring(8).equals("GHFSMU1")
						|| logicalDeviceName.substring(8).equals("GTS5MU1")
						|| logicalDeviceName.substring(8).equals("GTS6MU1")
						|| logicalDeviceName.substring(8).equals("GTS7MU1")) {

					// System.out.println("Voltage processing");

					final CalibrationFunctionWrapper voltageAsFunctionOfIntegralField = (CalibrationFunctionWrapper) calibration
							.getCalibrationFunction(CalibrationFunctionTypes.CURRENT2HALL_VOLTAGE);

					// System.out.println(voltageAsFunctionOfIntegralField);

					final BoundedPolynomialSequence boundedPolynomialSequence = (BoundedPolynomialSequence) voltageAsFunctionOfIntegralField
							.getInterpolable();

					// System.out.println(boundedPolynomialSequence);

					final BoundedPolynomial polynomial = findBoundedPolynomial(boundedPolynomialSequence, y);

					if (polynomial != null) {

						invertedValue = rfm.findRoot(polynomial.getInterval().getLowerBound(),
								polynomial.getInterval().getUpperBound(), 5E-8, 1000, polynomial, y);
						
						//for hall probe the sign will not be retrieved otherwise calibration out of range
						
					} else {

						invertedValue = 0.0;
					}
				}
			}

		} catch (final Exception e) {

			System.out.println("Exception found for calibration process!!! " + logicalDeviceName);
			System.out.println(e);
			// invertedValue = -0.5;
			// System.exit(0);
		}

		return invertedValue;
	}

	private static BoundedPolynomial findBoundedPolynomial(final BoundedPolynomialSequence boundedPolynomialSequence,
			final double y) {

		final BoundedPolynomial[] boundedPolynomials = boundedPolynomialSequence.getBoundedPolynomials();

		for (final BoundedPolynomial boundedPolynomial : boundedPolynomials) {

			final double lowerBound = boundedPolynomial.getInterval().getLowerBound();
			final double upperBound = boundedPolynomial.getInterval().getUpperBound();
			// System.out.println("Lower bound: " + lowerBound);
			// System.out.println("Upper bound: " + upperBound);

			final double x1_interpolated = boundedPolynomial.interpolate(lowerBound);
			final double x2_interpolated = boundedPolynomial.interpolate(upperBound);

			// System.out.println("Interpolated x1: " + x1_interpolated);
			// System.out.println("Interpolated x2: " + x2_interpolated);

			// interval = Interval.of(boundedPolynomial.interpolate(lowerBound),
			// boundedPolynomial.interpolate(upperBound));

			if (x1_interpolated < x2_interpolated) {

				if (y >= x1_interpolated && y <= x2_interpolated) {

					return boundedPolynomial;
				}
			}

			if (x1_interpolated > x2_interpolated) {

				if (y >= x2_interpolated && y <= x1_interpolated) {

					return boundedPolynomial;
				}
			}

			// if (interval.contains(y)) {

			// System.out.println("Retrieved polynom: " + boundedPolynomial);
			// return boundedPolynomial;
			// }
		}

		return null;
	}
}