Package fr.soleil.salsa.entity

Examples of fr.soleil.salsa.entity.ITrajectory


                //First rename actuator
                swapDevice(actuatorName1, actuatorName2, tmpActuatorList);
                List<? extends IRange> rangeList = dimension.getRangeList();
                if (rangeList != null) {
                    List<ITrajectory> trajectoryList = null;
                    ITrajectory t1 = null;
                    ITrajectory t2 = null;
                    for (IRange range : rangeList) {
                        trajectoryList = range.getTrajectoriesList();
                        if ((trajectoryList != null) && (actuator1pos < trajectoryList.size())
                                && (actuator2pos < trajectoryList.size())) {
                            t1 = trajectoryList.get(actuator1pos);
View Full Code Here


            int dimensionIndex = 1;
            int rangeIndex = 1;
            String rangeInfo = null;
            String actuatorInfo = null;
            String trajectoryInfo = "trajectory/";
            ITrajectory trajectory = null;
            IActuator actuator = null;

            for (IDimension dimension : dimensionList) {
                // Get the actuator List
                actuatorList = dimension.getActuatorsList();
                if ((actuatorList != null) && !actuatorList.isEmpty()) {
                    rangeList = dimension.getRangeList();
                    if ((rangeList != null) && !rangeList.isEmpty()) {
                        for (int i = 0; i < actuatorList.size(); i++) {
                            rangeIndex = 1;
                            for (IRange range : rangeList) {
                                rangeInfo = "";
                                trajectoryList = range.getTrajectoriesList();
                                if ((trajectoryList != null) && !trajectoryList.isEmpty()
                                        && (actuatorList.size() <= trajectoryList.size())) {
                                    actuator = actuatorList.get(i);
                                    if (actuator.isEnabled()) {
                                        actuatorInfo = trajectoryInfo + "actuator_" + dimensionIndex + "_" + (i + 1)
                                        + "/";

                                        // Display actuator name only for the
                                        // first range
                                        if (rangeIndex == 1) {
                                            scanInfoList.add(actuatorInfo + "name:" + actuator.getName());
                                        }
                                        if (rangeList.size() > 1) {
                                            rangeInfo = "range_" + rangeIndex + "/";
                                        }

                                        trajectory = trajectoryList.get(i);
                                        if (dimension instanceof IDimensionK) {
                                            ITrajectoryK ktraj = ((IDimensionK) dimension).getTrajectory();
                                            scanInfoList.add(actuatorInfo + "type:K");
                                            scanInfoList.add(actuatorInfo + "emin:" + ktraj.getEMin());
                                            scanInfoList.add(actuatorInfo + "pre_edge_delta:"
                                                    + ktraj.getEDeltaPreEdge());
                                            scanInfoList.add(actuatorInfo + "e0:" + ktraj.getE0());
                                            scanInfoList.add(actuatorInfo + "e1:" + ktraj.getE1());
                                            scanInfoList.add(actuatorInfo + "e2:" + ktraj.getE2());
                                            scanInfoList.add(actuatorInfo + "edge_delta:" + ktraj.getEDeltaEdge());
                                            if (ktraj.getM() > 0) {
                                                scanInfoList.add(actuatorInfo + "m:" + ktraj.getM());
                                            }
                                            scanInfoList.add(actuatorInfo + "kmin:" + ktraj.getKMin());
                                            scanInfoList.add(actuatorInfo + "kmax:" + ktraj.getKMax());
                                            scanInfoList.add(actuatorInfo + "kdelta" + ktraj.getKDelta());
                                        } else {
                                            if (trajectory instanceof ITrajectoryHCS) {
                                                scanInfoList.add(actuatorInfo + "type:HCS");
                                            }
                                            if (trajectory instanceof ITrajectoryEnergy) {
                                                scanInfoList.add(actuatorInfo + "type:Energy");
                                            }

                                            scanInfoList.add(actuatorInfo + rangeInfo + "steps:"
                                                    + range.getStepsNumber());
                                            if (trajectory.getRelative()) {
                                                scanInfoList.add(actuatorInfo + rangeInfo + "relative:true");
                                            }
                                            if (trajectory.isCustomTrajectory()) {
                                                scanInfoList.add(actuatorInfo + rangeInfo + "custom_values:"
                                                        + Arrays.toString(trajectory.getTrajectory()));
                                            } else {
                                                scanInfoList.add(actuatorInfo + rangeInfo + "from:"
                                                        + trajectory.getBeginPosition());
                                                scanInfoList.add(actuatorInfo + rangeInfo + "to:"
                                                        + trajectory.getEndPosition());
                                                scanInfoList.add(actuatorInfo + rangeInfo + "delta:"
                                                        + trajectory.getDelta());
                                            }
                                        }
                                    }// if actuator enable
                                }// end if trajectory list
                                rangeIndex++;
View Full Code Here

                            }
                        }
                        if (!trajectories.isEmpty()) {

                            for (int i = 0; i < trajectories.size(); i++) {
                                ITrajectory trajectory = trajectories.get(i);
                                String tempId = trajectory.getName();
                                StringTokenizer st = new StringTokenizer(tempId, "/");
                                String id = null;
                                while (st.hasMoreTokens()) {
                                    id = st.nextToken();
                                }
                                Double from = trajectory.getBeginPosition();
                                Double to = trajectory.getEndPosition();
                                Element actuator = document.createElement("actuator");
                                actuator.setAttribute("id", id);
                                actuator.setAttribute("from", String.valueOf(from));
                                actuator.setAttribute("to", String.valueOf(to));
                                actuators.appendChild(actuator);
                            }
                            element.appendChild(actuators);
                        }

                        break;

                    case SCAN_2D:
                        IConfig2D config2d = (IConfig2D) config;
                        IDimension2DX dimension2DX = config2d.getDimensionX();
                        List<IActuator> listActuator2DX = dimension2DX.getActuatorsList();

                        ArrayList<ITrajectory> trajectories2DX = new ArrayList<ITrajectory>();

                        List<IRange2DX> range2DX = dimension2DX.getRangesList();

                        for (int i = 0; i < range2DX.size(); i++) {
                            List<ITrajectory> listTrajectory = range2DX.get(i)
                                    .getTrajectoriesList();
                            for (int j = 0; j < listTrajectory.size(); j++) {
                                ITrajectory trajectory = new TrajectoryImpl();
                                trajectory.setName(listActuator2DX.get(j).getName());
                                trajectory.setBeginPosition(listTrajectory.get(j)
                                        .getBeginPosition());
                                trajectory.setEndPosition(listTrajectory.get(j).getEndPosition());
                                trajectories2DX.add(trajectory);
                            }
                        }
                        if (!trajectories2DX.isEmpty()) {

                            for (int i = 0; i < trajectories2DX.size(); i++) {
                                ITrajectory trajectory2DX = trajectories2DX.get(i);
                                String tempId = trajectory2DX.getName();
                                StringTokenizer st = new StringTokenizer(tempId, "/");
                                String id = null;
                                while (st.hasMoreTokens()) {
                                    id = st.nextToken();
                                }
                                Double from = trajectory2DX.getBeginPosition();
                                Double to = trajectory2DX.getEndPosition();
                                Element actuator = document.createElement("actuator");
                                actuator.setAttribute("id", id);
                                actuator.setAttribute("from", String.valueOf(from));
                                actuator.setAttribute("to", String.valueOf(to));
                                actuators.appendChild(actuator);
                            }
                            element.appendChild(actuators);
                        }
                        IDimension2DY dimension2DY = config2d.getDimensionY();
                        List<IActuator> listActuator2DY = dimension2DY.getActuatorsList();

                        ArrayList<ITrajectory> trajectories2DY = new ArrayList<ITrajectory>();
                        List<IRange2DY> range2DY = dimension2DY.getRangesList();

                        for (int i = 0; i < range2DY.size(); i++) {
                            List<ITrajectory> listTrajectory = range2DY.get(i)
                                    .getTrajectoriesList();
                            for (int j = 0; j < listTrajectory.size(); j++) {
                                ITrajectory trajectory = new TrajectoryImpl();
                                trajectory.setName(listActuator2DY.get(j).getName());
                                trajectory.setBeginPosition(listTrajectory.get(j)
                                        .getBeginPosition());
                                trajectory.setEndPosition(listTrajectory.get(j).getEndPosition());
                                trajectories2DY.add(trajectory);
                            }
                        }
                        if (!trajectories2DY.isEmpty()) {

                            for (int i = 0; i < trajectories2DY.size(); i++) {
                                ITrajectory trajectory2DY = trajectories2DY.get(i);
                                String tempId = trajectory2DY.getName();
                                StringTokenizer st = new StringTokenizer(tempId, "/");
                                String id = null;
                                while (st.hasMoreTokens()) {
                                    id = st.nextToken();
                                }
                                Double from = trajectory2DY.getBeginPosition();
                                Double to = trajectory2DY.getEndPosition();
                                Element actuator = document.createElement("actuator");
                                actuator.setAttribute("id", id);
                                actuator.setAttribute("from", String.valueOf(from));
                                actuator.setAttribute("to", String.valueOf(to));
                                actuators.appendChild(actuator);
                            }
                            element.appendChild(actuators);
                        }

                        break;

                    case SCAN_HCS:

                        IConfigHCS configHCS = (IConfigHCS) config;
                        IDimensionHCS dimensionHCS = configHCS.getDimensionX();
                        List<IActuator> listActuatorHCS = dimensionHCS.getActuatorsList();

                        ArrayList<ITrajectory> trajectoriesHCS = new ArrayList<ITrajectory>();

                        List<IRangeHCS> rangeHCS = dimensionHCS.getRangesXList();
                        for (int i = 0; i < rangeHCS.size(); i++) {
                            List<ITrajectory> listTrajectory = rangeHCS.get(i)
                                    .getTrajectoriesList();
                            for (int j = 0; j < listTrajectory.size(); j++) {
                                ITrajectory trajectory = new TrajectoryImpl();
                                trajectory.setName(listActuatorHCS.get(j).getName());
                                trajectory.setBeginPosition(listTrajectory.get(j)
                                        .getBeginPosition());
                                trajectory.setEndPosition(listTrajectory.get(j).getEndPosition());
                                trajectoriesHCS.add(trajectory);
                            }
                        }
                        if (!trajectoriesHCS.isEmpty()) {

                            for (int i = 0; i < trajectoriesHCS.size(); i++) {
                                ITrajectory trajectoryHCS = trajectoriesHCS.get(i);
                                String tempId = trajectoryHCS.getName();
                                StringTokenizer st = new StringTokenizer(tempId, "/");
                                String id = null;
                                while (st.hasMoreTokens()) {
                                    id = st.nextToken();
                                }
                                Double from = trajectoryHCS.getBeginPosition();
                                Double to = trajectoryHCS.getEndPosition();
                                Element actuator = document.createElement("actuator");
                                actuator.setAttribute("id", id);
                                actuator.setAttribute("from", String.valueOf(from));
                                actuator.setAttribute("to", String.valueOf(to));
                                actuators.appendChild(actuator);
                            }
                            element.appendChild(actuators);
                        }
                        break;

                    case SCAN_K:

                        IConfigK configK = (IConfigK) config;
                        IDimensionK dimensionK = configK.getDimensionX();
                        List<IActuator> listTrajectory = dimensionK.getActuatorsList();
                        for (int i = 0; i < listTrajectory.size(); i++) {
                            String tempId = dimensionK.getActuatorsList().get(i).getName();
                            StringTokenizer st = new StringTokenizer(tempId, "/");
                            String id = null;
                            while (st.hasMoreTokens()) {
                                id = st.nextToken();
                            }
                            Element actuator = document.createElement("actuator");
                            actuator.setAttribute("id", id);
                            actuator.setAttribute("from", "0.0");
                            actuator.setAttribute("to", "0.0");
                            actuators.appendChild(actuator);
                            element.appendChild(actuators);
                        }

                        break;

                    case SCAN_ENERGY:

                        IConfigEnergy configEnergy = (IConfigEnergy) config;
                        IDimensionEnergy dimensionEnergy = configEnergy.getDimensionX();
                        List<IActuator> listActuatorEnergy = dimensionEnergy.getActuatorsList();

                        ArrayList<ITrajectory> trajectoriesEnergy = new ArrayList<ITrajectory>();

                        List<IRangeEnergy> rangeEnergy = dimensionEnergy.getRangesEnergyList();
                        for (int i = 0; i < rangeEnergy.size(); i++) {
                            List<ITrajectory> listTrajectories = rangeEnergy.get(i)
                                    .getTrajectoriesList();
                            for (int j = 0; j < listTrajectories.size(); j++) {
                                ITrajectory trajectoryEnergy = new TrajectoryImpl();
                                trajectoryEnergy.setName(listActuatorEnergy.get(j).getName());
                                trajectoryEnergy.setBeginPosition(listTrajectories.get(j)
                                        .getBeginPosition());
                                trajectoryEnergy.setEndPosition(listTrajectories.get(j)
                                        .getEndPosition());
                                trajectoriesEnergy.add(trajectoryEnergy);
                            }
                        }
                        if (!trajectoriesEnergy.isEmpty()) {
                            for (int i = 0; i < trajectoriesEnergy.size(); i++) {
                                ITrajectory trajectoryEnergy = trajectoriesEnergy.get(i);
                                String tempId = trajectoryEnergy.getName();
                                StringTokenizer st = new StringTokenizer(tempId, "/");
                                String id = null;
                                while (st.hasMoreTokens()) {
                                    id = st.nextToken();
                                }
                                Double from = trajectoryEnergy.getBeginPosition();
                                Double to = trajectoryEnergy.getEndPosition();
                                Element actuator = document.createElement("actuator");
                                actuator.setAttribute("id", id);
                                actuator.setAttribute("from", String.valueOf(from));
                                actuator.setAttribute("to", String.valueOf(to));
                                actuators.appendChild(actuator);
View Full Code Here

                List<ITrajectory> sourceTrajectoryList = rangeSource.getTrajectoriesList();
                List<ITrajectory> destTrajectoryList = rangeDest.getTrajectoriesList();
                if ((sourceTrajectoryList != null) && (destTrajectoryList != null)
                        && (sourceTrajectoryList.size() == destTrajectoryList.size())) {
                    for (int j = 0; j < sourceTrajectoryList.size(); j++) {
                        ITrajectory sourceT = sourceTrajectoryList.get(j);
                        ITrajectory destT = destTrajectoryList.get(j);
                        if (sourceT != null && destT != null) {
                            destT.setDeltaConstant(sourceT.isDeltaConstant());
                            destT.setRelative(sourceT.getRelative());
                        }
                    }
                }
            }
        }
View Full Code Here

                                int trajectorySize = listTrajectory.size();
                                // System.out.println("Trajectory Size=" + trajectorySize);
                                for (int trajectoryIndex = 0; trajectoryIndex < trajectorySize; trajectoryIndex++) {
                                    IActuator actuator = listActuator.get(trajectoryIndex);
                                    if (actuator != null && actuator.isEnabled()) {
                                        ITrajectory trajectory = copyToTrajectoryImpl(actuator,
                                                listTrajectory.get(trajectoryIndex));
                                        if (trajectory != null) {
                                            trajectories.add(trajectory);
                                        }
                                    }
                                }
                            }

                            break;

                        case SCAN_2D:
                            IConfig2D config2d = (IConfig2D) config;
                            IDimension2DX dimension2DX = config2d.getDimensionX();
                            List<IActuator> listActuator2DX = dimension2DX.getActuatorsList();
                            List<IRange2DX> range2DX = dimension2DX.getRangesList();

                            for (int i = 0; i < range2DX.size(); i++) {
                                List<ITrajectory> listTrajectory = range2DX.get(i)
                                        .getTrajectoriesList();
                                for (int j = 0; j < listTrajectory.size(); j++) {
                                    IActuator actuator = listActuator2DX.get(j);
                                    if (actuator != null && actuator.isEnabled()) {
                                        ITrajectory trajectory = copyToTrajectoryImpl(actuator,
                                                listTrajectory.get(j));
                                        if (trajectory != null) {
                                            trajectories.add(trajectory);
                                        }
                                    }
                                }
                            }

                            IDimension2DY dimension2DY = config2d.getDimensionY();
                            List<IActuator> listActuator2DY = dimension2DY.getActuatorsList();
                            List<IRange2DY> range2DY = dimension2DY.getRangesList();

                            for (int i = 0; i < range2DY.size(); i++) {
                                List<ITrajectory> listTrajectory = range2DY.get(i)
                                        .getTrajectoriesList();
                                for (int j = 0; j < listTrajectory.size(); j++) {
                                    IActuator actuator = listActuator2DY.get(j);
                                    if (actuator != null && actuator.isEnabled()) {
                                        ITrajectory trajectory = copyToTrajectoryImpl(actuator,
                                                listTrajectory.get(j));
                                        if (trajectory != null) {
                                            trajectories.add(trajectory);
                                        }
                                    }
                                }
                            }

                            break;

                        case SCAN_HCS:

                            IConfigHCS configHCS = (IConfigHCS) config;
                            IDimensionHCS dimensionHCS = configHCS.getDimensionX();
                            List<IActuator> listActuatorHCS = dimensionHCS.getActuatorsList();

                            List<IRangeHCS> rangeHCS = dimensionHCS.getRangesXList();
                            for (int i = 0; i < rangeHCS.size(); i++) {
                                List<ITrajectory> listTrajectory = rangeHCS.get(i)
                                        .getTrajectoriesList();
                                for (int j = 0; j < listTrajectory.size(); j++) {
                                    IActuator actuator = listActuatorHCS.get(j);
                                    if (actuator != null && actuator.isEnabled()) {
                                        ITrajectory trajectory = copyToTrajectoryImpl(actuator,
                                                listTrajectory.get(j));
                                        if (trajectory != null) {
                                            trajectories.add(trajectory);
                                        }
                                    }
                                }
                            }
                            break;

                        case SCAN_K:
                            IConfigK configK = (IConfigK) config;
                            IDimensionK dimensionK = configK.getDimensionX();
                            ITrajectoryK trajectoryK = dimensionK.getRangeX().getTrajectory();
                            List<IActuator> listTrajectory = dimensionK.getActuatorsList();
                            for (int i = 0; i < listTrajectory.size(); i++) {
                                IActuator actuatork = listTrajectory.get(i);
                                if (actuatork != null && actuatork.isEnabled()) {
                                    ITrajectory trajectory = copyToTrajectoryImpl(actuatork,
                                            trajectoryK);
                                    if (trajectory != null) {
                                        trajectories.add(trajectory);
                                    }
                                }
                            }

                            break;

                        case SCAN_ENERGY:
                            IConfigEnergy configEnergy = (IConfigEnergy) config;
                            IDimensionEnergy dimensionEnergy = configEnergy.getDimensionX();
                            List<IActuator> listActuatorEnergy = dimensionEnergy.getActuatorsList();

                            List<IRangeEnergy> rangeEnergy = dimensionEnergy.getRangesEnergyList();
                            for (int i = 0; i < rangeEnergy.size(); i++) {
                                List<ITrajectory> listTrajectories = rangeEnergy.get(i)
                                        .getTrajectoriesList();
                                for (int j = 0; j < listTrajectories.size(); j++) {
                                    IActuator actuator = listActuatorEnergy.get(j);
                                    if (actuator != null && actuator.isEnabled()) {
                                        ITrajectory trajectory = copyToTrajectoryImpl(actuator,
                                                listTrajectories.get(j));
                                        if (trajectory != null) {
                                            trajectories.add(trajectory);
                                        }
                                    }
                                }
                            }
                            break;
                    }

                    if (!trajectories.isEmpty()) {
                        for (int i = 0; i < trajectories.size(); i++) {
                            ITrajectory trajectory = trajectories.get(i);
                            Element actuator = getActuator(document, trajectory);
                            actuators.appendChild(actuator);
                        }
                        element.appendChild(actuators);
                    }
View Full Code Here

            throw new SalsaLoggingException(e.getMessage(), e);
        }
    }

    private ITrajectory copyToTrajectoryImpl(IActuator actuator, ITrajectory trajectory) {
        ITrajectory trajectoryImpl = null;
        // System.out.println("copyToTrajectoryImpl= " + name + " trajectory= " + trajectory);
        if (trajectory != null && actuator != null) {
            if (trajectory instanceof ITrajectoryK) {
                ITrajectoryK trajectoryK = (ITrajectoryK) trajectory;
                TrajectoryKImpl trajectoryKImpl = new TrajectoryKImpl();
                trajectoryKImpl.setRelative(false);
                trajectoryKImpl.setE0(trajectoryK.getE0());
                trajectoryKImpl.setE1(trajectoryK.getE1());
                trajectoryKImpl.setE2(trajectoryK.getE2());
                trajectoryKImpl.setEDeltaEdge(trajectoryK.getEDeltaEdge());
                trajectoryKImpl.setEDeltaPreEdge(trajectoryK.getEDeltaPreEdge());
                trajectoryKImpl.setEMin(trajectoryK.getEMin());
                trajectoryKImpl.setKDelta(trajectoryK.getKDelta());
                trajectoryKImpl.setKMax(trajectoryK.getKMax());
                trajectoryKImpl.setKMin(trajectoryK.getKMin());
                trajectoryKImpl.setM(trajectoryK.getM());
                trajectoryKImpl.setN(trajectoryK.getN());
                trajectoryImpl = trajectoryKImpl;
            }
            else {
                trajectoryImpl = new TrajectoryImpl();
                Double beginPosition = trajectory.getBeginPosition();
                Double endPosition = trajectory.getEndPosition();
                if (trajectory.getRelative()) {
                    try {
                        Double initialValue = ActuatorConnector.getData(actuator);
                        beginPosition = beginPosition + initialValue;
                        endPosition = endPosition + initialValue;
                    }
                    catch (SalsaDeviceException e) {
                    }
                }
                trajectoryImpl.setRelative(trajectory.getRelative());
                trajectoryImpl.setBeginPosition(beginPosition);
                trajectoryImpl.setEndPosition(endPosition);
                trajectoryImpl.setDelta(trajectory.getDelta());
            }
            if (trajectoryImpl != null) {
                trajectoryImpl.setName(actuator.getName());
            }
        }
        return trajectoryImpl;
    }
View Full Code Here

                if (nbrnodeActuatorElement != 0) {
                    ArrayList<ITrajectory> trajectoriesList = new ArrayList<ITrajectory>();
                    Element element = null;
                    for (int i = 0; i < nbrnodeActuatorElement; i++) {
                        element = (Element) nodeActuatorElementList.item(i);
                        ITrajectory tmpTrajectory = copyToTrajectoryImpl(element);
                        if (tmpTrajectory != null) {
                            trajectoriesList.add(tmpTrajectory);
                        }

                    }
View Full Code Here

        historicLogLine.setScan(elementEvent.getAttribute("scan"));
        historicLogArray.add(historicLogLine);
    }

    private ITrajectory copyToTrajectoryImpl(Element element) {
        ITrajectory tmpTrajectory = null;
        if (element != null && element.hasAttribute("id")) {

            // IF IT IS K SCAN
            if (element.hasAttribute("kdelta") && element.hasAttribute("e0")
                    && element.hasAttribute("e1") && element.hasAttribute("e2")
                    && element.hasAttribute("edeltaedge") && element.hasAttribute("edeltapreEdge")
                    && element.hasAttribute("emin") && element.hasAttribute("kmax")
                    && element.hasAttribute("kmin") && element.hasAttribute("m")
                    && element.hasAttribute("n")) {

                TrajectoryKImpl trajectoryK = new TrajectoryKImpl();
                trajectoryK.setE0(Double.parseDouble(element.getAttribute("e0")));
                trajectoryK.setE1(Double.parseDouble(element.getAttribute("e1")));
                trajectoryK.setE2(Double.parseDouble(element.getAttribute("e2")));
                trajectoryK.setEDeltaEdge(Double.parseDouble(element.getAttribute("edeltaedge")));
                trajectoryK.setEDeltaPreEdge(Double.parseDouble(element
                        .getAttribute("edeltapreEdge")));
                trajectoryK.setEMin(Double.parseDouble(element.getAttribute("emin")));
                trajectoryK.setKDelta(Double.parseDouble(element.getAttribute("kdelta")));
                trajectoryK.setKMax(Double.parseDouble(element.getAttribute("kmax")));
                trajectoryK.setKMin(Double.parseDouble(element.getAttribute("kmin")));
                trajectoryK.setM(Double.parseDouble(element.getAttribute("m")));
                trajectoryK.setN(Double.parseDouble(element.getAttribute("n")));
                tmpTrajectory = trajectoryK;
            }
            else if (element.hasAttribute("from") && element.hasAttribute("to")
                    && element.hasAttribute("id") && element.hasAttribute("delta")) {

                tmpTrajectory = new TrajectoryImpl();
                tmpTrajectory.setBeginPosition(Double.parseDouble(element.getAttribute("from")));
                tmpTrajectory.setEndPosition(Double.parseDouble(element.getAttribute("to")));
                tmpTrajectory.setDelta(Double.parseDouble(element.getAttribute("delta")));

            }
            if (tmpTrajectory != null) {
                // Always set on false
                tmpTrajectory.setRelative(false);
                tmpTrajectory.setName(element.getAttribute("id"));
            }

        }
        return tmpTrajectory;
    }
View Full Code Here

     */
    private List<ITrajectory> findActuatorTrajectories(IDimensionHCS dimension, int index) {
        List<ITrajectory> actuatorTrajectoriesList = new ArrayList<ITrajectory>(dimension
                .getRangesXList().size());
        for (IRangeHCS range : dimension.getRangesXList()) {
            ITrajectory trajectory = range.getTrajectoriesList().get(index);
            actuatorTrajectoriesList.add(trajectory);
        }
        return actuatorTrajectoriesList;
    }
View Full Code Here

     */
    private List<ITrajectory> findActuatorTrajectories(IDimension1D dimension, int index) {
        List<ITrajectory> actuatorTrajectoriesList = new ArrayList<ITrajectory>(dimension
                .getRangesXList().size());
        for (IRange1D range : dimension.getRangesXList()) {
            ITrajectory trajectory = range.getTrajectoriesList().get(index);
            actuatorTrajectoriesList.add(trajectory);
        }
        return actuatorTrajectoriesList;
    }
View Full Code Here

TOP

Related Classes of fr.soleil.salsa.entity.ITrajectory

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.