DeviceUpdateFESA_MagStat_20112019.java

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



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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cern.japc.core.AcquiredParameterValue;
import cern.japc.core.Parameter;
import cern.japc.core.ParameterException;
import cern.japc.core.ParameterValueListener;
import cern.japc.core.Parameters;
import cern.japc.core.Selector;
import cern.japc.core.SubscriptionHandle;
import cern.japc.core.factory.ParameterFactory;
import cern.japc.value.MapParameterValue;

/**
 * @author fschirru
 */
public class DeviceUpdateFESA implements ParameterValueListener {

	private static final DeviceUpdateFESA INSTANCE = new DeviceUpdateFESA();

	private static final DeviceCalibrationCurveConverter dccc = DeviceCalibrationCurveConverter.getInstance();
	private static final Logger LOGGER = LoggerFactory.getLogger(DeviceUpdateFESA.class);

	private final AcquiredParameterValue parameterValue = null;

	private String devicename;
	
	private double currentDiff_rel = 0;

	private List<Boolean> listOfBooleans = new ArrayList<>();
	private List<String> listOfLabels = new ArrayList<>();

	// private final AcquiredParameterValue parameterValue = null;
	private ParameterException parameterException;
	private SubscriptionHandle subscriptionHandle;

	private static final List<SubscriptionHandle> subscriptionHandlers = new ArrayList<>();

	private static final MagnetDataJoiner mdpj = MagnetDataJoiner.getInstance();

	/**
	*
	*/
	public DeviceUpdateFESA() {

	}

	public DeviceUpdateFESA(final String devicename) {

		this.devicename = devicename;

	}

	public static DeviceUpdateFESA getInstance() {

		return INSTANCE;
	}

	public AcquiredParameterValue getParameterValue(final Selector selector, final String propertyname) {
		try {
			final String parametername = Parameters.buildParameterName(devicename, propertyname);
			final Parameter parameter = ParameterFactory.newInstance().newParameter(parametername);

			/*- final AcquiredParameterValue parameterValue = parameter.getValue(NULL_SELECTOR); //commented on 25/5/2018 */
			final AcquiredParameterValue parameterValue = parameter.getValue(selector); /*- placed on 25/5/2018 */

			final MapParameterValue mapParameterValue = (MapParameterValue) parameterValue.getValue();
			final int powerState = mapParameterValue.getInt("powerState");
			LOGGER.info("Parameter value for " + devicename + ", " + propertyname + ", " + " received : " + powerState);
		} catch (final ParameterException e) {
			LOGGER.error(e.getMessage());
		}
		return parameterValue;
	}

	public void subscribe(final Selector selector, final String propertyname) {
		final String parametername = Parameters.buildParameterName(devicename, propertyname);

		/*- DCValueDaq will be managed by the MagnetRampingMonitor class */

		try {

			final Parameter parameter = ParameterFactory.newInstance().newParameter(parametername);

			subscriptionHandle = parameter.createSubscription(selector, this);
			subscriptionHandle.startMonitoring();
			subscriptionHandlers.add(subscriptionHandle);

			LOGGER.info("Subscription for '" + propertyname + "' started");

		} catch (final ParameterException e) {

			LOGGER.error(e.getMessage());
		}
	}

	@Override
	public void valueReceived(final String parameterName, final AcquiredParameterValue value) {

		final String propertyname = parameterName.substring(parameterName.indexOf("/") + 1);
		final AcquiredParameterValue parameterValue_ = value;
		final MapParameterValue mapParameterValue = (MapParameterValue) parameterValue_.getValue();
		final String device_name = parameterName.substring(0, parameterName.indexOf("/"));

		if (propertyname.equals("Acquisition")) {
		    
		    //System.out.println(device_name);

			final double acquisitionCurrentValue = Double.parseDouble(mapParameterValue.getString("current"));
			//final double bFieldConverted = dccc.getValueFromCalibrationCurve("LOGICAL." + device_name,
				//	acquisitionCurrentValue, "current");
			final double bFieldConverted = dccc.getValueFromCalibrationCurve(device_name,
              acquisitionCurrentValue, "current");

			// Attempt to retrieve voltage value for all the devices
			double acquisitionVoltageValue;
			double currentConverted_v = 999.0;
			double bFieldConverted_v = 999.0;

			try {
				// Hall Probe value treatment

				// 1) get the value in voltage from the Hall probe
				// 2) convert this value into a current value
				// 3) convert the current value into magnetic field value

				// Filter is needed otherwise it throws an exception!
				if (device_name.equals("GTS3MU1") || device_name.equals("GTS3MU2") || device_name.equals("GTS4MU1")
						|| device_name.equals("GHFSMU1") || device_name.equals("GTS5MU1")
						|| device_name.equals("GTS6MU1") || device_name.equals("GTS7MU1")) {

					acquisitionVoltageValue = Double.parseDouble(mapParameterValue.getString("voltage"));
					/*- acquisitionVoltageValue = 0.0; change this value to test the voltage conversion */

					/*
					currentConverted_v = dccc.getValueFromCalibrationCurve("LOGICAL." + device_name,
							acquisitionVoltageValue, "voltage");

					bFieldConverted_v = dccc.getValueFromCalibrationCurve("LOGICAL." + device_name, currentConverted_v,
							"current"); */
					
					
					currentConverted_v = dccc.getValueFromCalibrationCurve(device_name,
                            acquisitionVoltageValue, "voltage");

                    bFieldConverted_v = dccc.getValueFromCalibrationCurve(device_name, currentConverted_v,
                            "current");
					
					//System.out.println("Hall Probe: " + device_name);
					//System.out.println(acquisitionVoltageValue);
					//System.out.println(currentConverted_v);
					//System.out.println(bFieldConverted_v);
					//System.out.println("**************");
				}

			} catch (final Exception e) {

				System.out.println(e);

				acquisitionVoltageValue = 999.0;
				bFieldConverted_v = acquisitionVoltageValue;
			}

			for (int k = 0; k < mdpj.getData().size(); k++) {

				if (device_name.equals(mdpj.getData().get(k).getId())) {

					mdpj.getData().get(k).setCurrent_meas(acquisitionCurrentValue);
					// Update current difference for the device // old version using deltaI only
					//mdpj.getData().get(k).setCurrent_diff(
						//	-mdpj.getData().get(k).getCurrent_exp() + mdpj.getData().get(k).getCurrent_meas());
					// Update current difference for the device -> new version using deltaI/I ratio
					if(acquisitionCurrentValue != 0) {
                    
					    currentDiff_rel = (-mdpj.getData().get(k).getCurrent_exp() + mdpj.getData().get(k).getCurrent_meas())/mdpj.getData().get(k).getCurrent_meas();
					    
					    if(currentDiff_rel <= 100 && currentDiff_rel >=-100) { 
					    
					        mdpj.getData().get(k).setCurrent_diff(currentDiff_rel);
					        
					    } else {
					        
					        if(currentDiff_rel < 0) {
					            
					            mdpj.getData().get(k).setCurrent_diff(-100);
					        
					        } else {
					            
					            mdpj.getData().get(k).setCurrent_diff(100);     
					        }				       
					    }
					
					} else {
					
					    mdpj.getData().get(k).setCurrent_diff(100);
					}
					
                    //System.out.println("*****");
                    //System.out.println(mdpj.getData().get(k).getId());
                    //System.out.println(bFieldConverted);
                    //System.out.println(mdpj.getData().get(k).getK0lfield_exp());
                    //System.out.println(bFieldConverted / mdpj.getData().get(k).getK0lfield_exp());
                    if (mdpj.getData().get(k).getK0lfield_exp() != 0) {
                        mdpj.getData().get(k).setBfield_meas(bFieldConverted / mdpj.getData().get(k).getK0lfield_exp());
                    } else {
                        mdpj.getData().get(k).setBfield_meas(999.0);
                    }
                    //mdpj.getData().get(k).setBfield_meas(bFieldConverted);
					// mdpj.getData().get(k).setBfield_meas(100.10);
					mdpj.getData().get(k).setHallprobe(bFieldConverted_v);

					k = mdpj.getData().size(); // exit for-loop
				}
			}
		}

		if (propertyname.equals("DCMode")) {

			/*- final String device_name = parameterName.substring(0, parameterName.indexOf("/")); */
			final String str = mapParameterValue.getString("mode");

			for (int k = 0; k < mdpj.getData().size(); k++) {

				if (device_name.equals(mdpj.getData().get(k).getId())) {

					mdpj.getData().get(k).setDcmode(Boolean.valueOf(str));

					k = mdpj.getData().size(); // exit for-loop
				}
			}
		}

		if (propertyname.equals("Status")) {

			/*- final String device_name = parameterName.substring(0, parameterName.indexOf("/")); */

			final String str = mapParameterValue.getString("status");

			final boolean[] arrayOfBooleans = mapParameterValue.getBooleans("detailedStatus");
			listOfBooleans = toListBooleanArray(arrayOfBooleans);

			final String[] arrayOfLabels = mapParameterValue.getStrings("detailedStatus_labels");
			listOfLabels = toListStringArray(arrayOfLabels);

			for (int k = 0; k < mdpj.getData().size(); k++) {

				if (device_name.equals(mdpj.getData().get(k).getId())) {

					mdpj.getData().get(k).setStatus(Integer.valueOf(str));
					mdpj.getData().get(k).setListOfBooleans(listOfBooleans);
					mdpj.getData().get(k).setListOfLabels(listOfLabels);

					k = mdpj.getData().size(); // exit for-loop
				}
			}
		}
	}

	@Override
	public void exceptionOccured(final String parameterName, final String description,
			final ParameterException exception) {

		String message;

		if (exception == null) {
			parameterException = new ParameterException(description);
			message = parameterException.getMessage();

		} else {

			message = exception.getMessage();
		}

		LOGGER.error(message);
		stopSubscription();
	}

	private void stopSubscription() {

		subscriptionHandle.stopMonitoring();

		LOGGER.info("subscription stopped");
	}

	/*
	 * close the logical channel of subscription
	 *
	 * @param conn logical channel of subscription
	 */

	public List<SubscriptionHandle> get_subscriptionHandle() {

		return subscriptionHandlers;
	}

	private List<Boolean> toListBooleanArray(final boolean[] booleanArray) {

		final int arraySize = booleanArray.length;

		for (int i = 0; i < arraySize; i++) {

			listOfBooleans.add(booleanArray[i]);
		}

		return listOfBooleans;
	}

	private List<String> toListStringArray(final String[] stringArray) {

		final int arraySize = stringArray.length;

		for (int i = 0; i < arraySize; i++) {

			listOfLabels.add(stringArray[i]);
		}

		return listOfLabels;
	}
}