MagnetDataProcessorFESA_31082018_MS.java

package de.gsi.cs.co.ap.my_test_project.utils;

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

import cern.accsoft.commons.domain.particletransfers.ParticleTransfer;
import cern.colt.Arrays;
import cern.japc.AcquiredParameterValue;
import cern.japc.MapParameterValue;
import cern.japc.Parameter;
import cern.japc.ParameterException;
import cern.japc.Parameters;
import cern.japc.Selector;
import cern.japc.SubscriptionHandle;
import cern.japc.factory.ParameterFactory;
import cern.japc.factory.SelectorFactory;
import cern.japc.group.support.SysoutFailSafeParameterValueListener;
import cern.lsa.client.DeviceService;
import cern.lsa.client.Services;
import cern.lsa.domain.devices.Device;
import cern.lsa.domain.devices.DeviceMetaTypeEnum;
import cern.lsa.domain.devices.factory.DevicesRequestBuilder;
import cern.lsa.domain.settings.BeamProcess;
import cern.lsa.domain.settings.BeamProductionChain;
import cern.lsa.domain.settings.Contexts;
import cern.lsa.domain.settings.DrivableBeamProcess;
import cern.lsa.domain.settings.factory.ParametersRequestBuilder;
import cern.lsa.domain.settings.type.BeamProcessTypeCategory;
import cern.lsa.gui.fx.FilteredListView;
import de.gsi.aco.sv.japc.FAIRSelectorBuilder;
import de.gsi.cs.co.lsa.domain.GsiTimingDomain;

public class MagnetDataProcessorFESA {

    /**
     * @author fschirru
     */
    private static final MagnetDataProcessorFESA INSTANCE = new MagnetDataProcessorFESA();

    private final MagnetDataProcessorLSA mdpLSA = MagnetDataProcessorLSA.getInstance();
    private Set<Device> frsDevices;

    private final static String[] propertyname = { "Acquisition", "Acquisition", "DCValue", "DCMode", "Status",
            "Status", "Status", "DCValueAcq", "DCValueAcq" };
    private final static String[] propertyfield = { "current", "voltage", "current", "mode", "status", "detailedStatus",
            "detailedStatus_labels", "current", "voltage" };

    // private static final Selector MULTIPLEXED_SELECTOR = SelectorFactory.newSelector("FAIR.SELECTOR.ALL");
    // private static String devicename = "GTH4QD21";
    private static String parameterName;
    private static Parameter parameter;
    private static AcquiredParameterValue ParameterValue;
    private static MapParameterValue mapParameterValue;
    private static Object[] fieldValue = new Object[propertyname.length]; // to be changed into generic object

    // private static String[] fieldValue_labels = new String[24];

    // private final static ObservableList<Magnet> magnetData = FXCollections.observableArrayList();

    private final List<Object[]> magDataList = new ArrayList<>(); // to be changed into generic object

    private BeamProductionChain chain;
    private final DeviceService deviceService = Services.getDeviceService();

    private final DevicesRequestBuilder builder = new DevicesRequestBuilder();

    private Set<Device> myDevices;
    private Set<ParticleTransfer> particleTransfers;

    MagnetDataProcessorFESA() {

    }

    public static MagnetDataProcessorFESA getInstance() {

        return INSTANCE;
    }

    public void setBeamChain(final BeamProductionChain chain) {

        this.chain = chain;
    }

    public void setFrsDevices() {

        System.out.println("*********");
        System.out.println("*********");
        myDevices = mdpLSA.getStaticDevices();
        // System.out.println("frsDevices Dim: " + frsDevices.size());
        System.out.println(myDevices.size());

        System.out.println(myDevices);

        // System.exit(0);

        getDevicesData();
    }

    public void setDevices() {

        particleTransfers = Contexts.getParticleTransfersFromBeamProcesses(chain.getDrivableBeamProcesses());
        builder.setParticleTransfers(particleTransfers);
        builder.setMetaType(DeviceMetaTypeEnum.ACTUAL);
        builder.setDeviceTypeName("BasicPS");

        myDevices = deviceService.findDevices(builder.build());

        System.out.println("*********");
        System.out.println(myDevices);

        System.out.println("*********");

        System.out.println("FESA myDevice DIM " + myDevices.size());

        getDevicesData();
    }

    public void getDevicesData() {

        // Clear list to avoid summing up of items while changing the chain
        magDataList.clear();

        for (final Device device : myDevices) {

            final Selector newMULTIPLEXED_SELECTOR = getSelector(device);

            // final Selector newMULTIPLEXED_SELECTOR = SelectorFactory.newSelector("FAIR.SELECTOR.ALL");
            System.out.println(device.getName());
            System.out.println(newMULTIPLEXED_SELECTOR);

            for (int p = 0; p < propertyname.length; p++) {

                // if (p != 1) {

                try {

                    parameterName = Parameters.buildParameterName(device.getName().substring(8), propertyname[p]);
                    parameter = ParameterFactory.newInstance().newParameter(parameterName);
                    ParameterValue = parameter.getValue(newMULTIPLEXED_SELECTOR);

                    mapParameterValue = (MapParameterValue) ParameterValue.getValue();

                    // acquire the value of the considered property of the related device.
                    // The first five properties are numbers and retrieved as strings
                    if (p < 5) {

                        if (p != 1) {

                            fieldValue[p] = mapParameterValue.getString(propertyfield[p]);

                            System.out.println(fieldValue[p]);
                            System.out.println(p);

                        } else { // voltage treated only for Dipoles!

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

                                fieldValue[p] = mapParameterValue.getString(propertyfield[p]);

                                System.out.println(fieldValue[p]);
                                System.out.println(p);

                            } else {

                                fieldValue[p] = 0.0; // Assign null value to all other devices (quadrupoles ect)
                            }

                        }

                    }

                    if (p == 5) {

                        fieldValue[p] = mapParameterValue.getBooleans(propertyfield[p]);

                    }

                    if (p == 6) {

                        fieldValue[p] = mapParameterValue.getStrings(propertyfield[p]);
                    }

                    if (p == 7) { // DCValueAcq current

                        fieldValue[p] = mapParameterValue.getStrings(propertyfield[p]);
                    }

                    if (p == 8) { // DCValueAcq voltage

                        fieldValue[p] = mapParameterValue.getStrings(propertyfield[p]);
                    }

                } catch (final ParameterException e) {

                    // Assign an arbitrary value to the Acquisition/current of the related device.
                    if (fieldValue[0] == null) {

                        fieldValue[0] = "0.55";
                    }

                    if (fieldValue[1] == null) {

                        fieldValue[1] = "0.55";
                    }

                    if (fieldValue[3] == null) {

                        fieldValue[3] = "false";
                    }

                    if (fieldValue[4] == null) {

                        fieldValue[4] = "11";
                    }

                    if (fieldValue[7] == null) {

                        fieldValue[7] = "0.55";
                    }

                    if (fieldValue[8] == null) {

                        fieldValue[8] = "0.55";
                    }

                    /*
                     * if (fieldValue[5] == null) {
                     *
                     * fieldValue[5] = new String[] { "false", "false", "false" };
                     * }
                     *
                     * if (fieldValue[6] == null) {
                     *
                     * fieldValue[6] = new String[] { "Error", "Error", "Error" };
                     * }
                     */

                }

                // } else {

                /*
                 * try {
                 *
                 * parameterName = Parameters.buildParameterName(device.getName().substring(8), propertyname[p]);
                 * parameter = ParameterFactory.newInstance().newParameter(parameterName);
                 * ParameterValue = parameter.getValue(newMULTIPLEXED_SELECTOR);
                 * mapParameterValue = (MapParameterValue) ParameterValue.getValue();
                 * // fieldValue[1] = mapParameterValue.getString(propertyfield[1]); //to add
                 *
                 * fieldValue[1] = 0.0;
                 *
                 * } catch (final ParameterException e) {
                 *
                 * System.out.println(device.getName());
                 * System.out.println(newMULTIPLEXED_SELECTOR);
                 * fieldValue[p] = 0.5;
                 * // fieldValue[p] = 0.0; // Assign a temporary value for the HallProbe of the related device
                 * System.out.println(e);
                 * // System.exit(0);
                 *
                 * }
                 */

                // fieldValue[1] = 0.0; // Assign a temporary value for the HallProbe of the related device
                // end if p
                // }
            } // End for property

            /*
             * System.out.println("DATA ACQUIRED");
             *
             * System.out.println(device.getName().substring(8));
             * System.out.println(fieldValue[0]);
             * System.out.println(fieldValue[1]);
             * System.out.println(fieldValue[2]);
             * System.out.println(fieldValue[3]);
             * System.out.println(fieldValue[4]);
             * System.out.println(fieldValue[5]);
             * System.out.println(fieldValue[6]);
             *
             * System.out.println(n);
             * n++;
             */

            try {

                // Add processed device to the list
                magDataList.add(new Object[] { device.getName().substring(8), fieldValue[0], fieldValue[1],
                        fieldValue[7/* 2 */], fieldValue[3], fieldValue[4], fieldValue[5], fieldValue[6] });

            } catch (final Exception e) {

                System.out.println("**********");
                System.out.println(device.getName().substring(8));
                System.out.println(e);
                System.exit(0);
            }

            // System.exit(0);

        } // End for Device

        // retrieveDataFromFESA();
    }

    public List<Object[]> getMagnetData() {

        return magDataList;
    }

    // test method to check all devices processed within the getDeviceData method
    public void retrieveDataFromFESA() {

        System.out.println("******FESA DATA******");
        System.out.println(magDataList.get(0)[5]);
        System.out.println(magDataList.size());
        for (int i = 0; i < magDataList.size(); i++) {

            try {
                System.out.println(magDataList.get(i)[0] + " - " + magDataList.get(i)[1] + " - " + magDataList.get(i)[2]
                        + " - " + magDataList.get(i)[3] + " - " + magDataList.get(i)[4] + " - " + " - "
                        + Arrays.toString((boolean[]) fieldValue[5]) + Arrays.toString((String[]) fieldValue[6]));

            } catch (final Exception e) {

                System.out.println(e);
                System.exit(0);

            }
        }
        // System.exit(0);
    }

    public void generateDeviceSubscriptions() {

        for (final Device device : myDevices) {

            final DeviceUpdateFESA duf = new DeviceUpdateFESA(device.getName().substring(8));

            final Selector newMULTIPLEXED_SELECTOR = getSelector(device);

            /*
             * if (device.getName().substring(8).equals("GTS2QT12")) {
             *
             * System.out.println(newMULTIPLEXED_SELECTOR);
             * System.exit(0);
             * }
             */

            for (int p = 0; p < propertyname.length; p++) {

                try {

                    duf.subscribe(newMULTIPLEXED_SELECTOR, propertyname[p]);

                } catch (final Exception e) {

                    System.out.println("Exception: " + e);
                    System.exit(0);
                }
            } // for property

            /*
             * // Treat special devices equipped with HallProbe
             * if (device.getName().substring(8).equals("GTS7MU1") || device.getName().substring(8).equals("GTS3MU1")
             * || device.getName().substring(8).equals("GHFSMU1")
             * || device.getName().substring(8).equals("GTS6MU1")) {
             *
             * try {
             *
             * final DeviceUpdateFESA duf_0 = new DeviceUpdateFESA(device.getName().substring(8) + "_0");
             *
             * // start subscription of the considered property (HallProbe) of the related device
             * duf_0.subscribe(newMULTIPLEXED_SELECTOR, propertyname[1]);
             *
             * } catch (final Exception e) {
             *
             * System.out.println("Exception: " + e);
             * System.exit(0);
             * }
             * }
             */
        }
    }

    private Selector getSelector(final Device device) {

        final Set<ParticleTransfer> particleTransfersForDevice = device.getAcceleratorZone().getParticleTransfers();
        if (particleTransfersForDevice.size() > 1) {
            throw new IllegalStateException("There was more then one particle transfer found for device "
                    + device.getName() + " but it should be only one.");
        }
        final List<DrivableBeamProcess> chainBeamProcesses = chain.getDrivableBeamProcesses();
        final ParticleTransfer particleTransferForDevice = particleTransfersForDevice.iterator().next();
        final List<DrivableBeamProcess> beamProcessesForDevice = Contexts.filterBeamProcesses(chainBeamProcesses,
                particleTransferForDevice, BeamProcessTypeCategory.FUNCTION_BEAM_IN);

        final Selector selector = FAIRSelectorBuilder.parse(beamProcessesForDevice.get(0).getUser()).build();

        /*
         * if (chain.getName().contains("HFS")) {
         *
         * System.out.println(selector);
         * System.out.println(chainBeamProcesses);
         * System.out.println("END " + device);
         * System.out.println(beamProcessesForDevice);
         * System.exit(0);
         * }
         */

        return selector;
    }
}