ArtemisManager.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;

using Molecule.Model;

using ArtemisClientPointer = System.IntPtr;
using System.Collections.Generic;
using UI;
using System.Threading;

public class ArtemisThreadedClient{
    GameObject artemisGo;

    private float[] pos2;

    private bool initialized = false;
    private bool run = false;
    private bool kill_simulation = false;

    public void stop_simulation(ArtemisClientPointer client)
    {
        kill_simulation = true;
    }

    public void disconnect(ArtemisClientPointer client)
    {
        if (!initialized)
            return;

        ArtemisWrapper.artemis_client_disconnect(client);
        
        initialized = false;
    }

    public void mainProc(ArtemisClientPointer client, int capacity)
    {
        ArtemisWrapper.ArtemisHeader header = new ArtemisWrapper.ArtemisHeader();
        ArtemisWrapper.ArtemisImdEnergies e = new ArtemisWrapper.ArtemisImdEnergies();

        kill_simulation = false;

        pos2 = new float[capacity * 3];
        run = true;
        while(run)
        {
            int ready = ArtemisWrapper.artemis_client_receive(client);
            if (ready != 0)
            {
                // Get the IMD header
                ArtemisWrapper.artemis_client_read_header(client, ref header);
                
                switch(header.type)
                {
                case ArtemisWrapper.artemis_imd_type_e.IMD_ENERGIES:
                    ArtemisWrapper.artemis_client_read_energies(client, ref e);
                    PlotManager.Instance.PlotAdd("Total Energy", e.Etot);
                    PlotManager.Instance.PlotAdd("Hydrogen Bonds Energy", e.Evdw);
                    PlotManager.Instance.PlotAdd("Stacking Energy", e.Eelec);

                    ArtemisManager.Etot = e.Etot;
                    ArtemisManager.Evdw = e.Evdw;
                    ArtemisManager.Eelec = e.Eelec;
                    break;
                case ArtemisWrapper.artemis_imd_type_e.IMD_FCOORDS:

                    if (ArtemisWrapper.artemis_client_read_coords(client, pos2, capacity) == 1)
                    {
                        List<Vector3> lst = new List<Vector3>();
                        for (int i = 0; i < capacity; i++)
                        {
                            lst.Add(new Vector3(pos2[i*3],pos2[i*3+1],pos2[i*3+2]));
                        }

                        MoleculeModel.atomsIMDSimulationLocationlist = lst;
                    }

                    break;
                default:
                    break;
                }
            }
        }

        disconnect (client);

        if (kill_simulation) {
            ArtemisWrapper.artemis_client_send_kill(client);
        }
    }

    public void send_forces(ArtemisClientPointer client, int nb_forces, int[] indices, float[] coordinates)
    {
        ArtemisWrapper.artemis_client_send_forces(client, nb_forces, indices, coordinates);
    }

    public void stop()
    {
        run = false;
    }
}

public class ArtemisManager{
    ArtemisThreadedClient threadedClient;

    ArtemisClientPointer client;

    Thread oThread;
    GameObject artemisGo;

    bool initialized = false;
    private bool connected = false;

    public static float Etot = 0.0f;
    public static float Evdw = 0.0f;
    public static float Eelec = 0.0f;

    public bool isConnected()
    {
        return connected;
    }

    public ArtemisManager()
    {
        threadedClient = new ArtemisThreadedClient();
    }

    public void connect()
    {
        Debug.Log("ArtemisManager::Connect");

        ArtemisOldGUI.artemisNotificationMessage = "Connecting...";

        int capacity = (int) MoleculeModel.atomsnumber;
        MoleculeModel.atomsIMDSimulationLocationlist = new List<Vector3>();
        for (int i = 0; i < capacity; i++)
        {
            MoleculeModel.atomsIMDSimulationLocationlist.Add(new Vector3(0.0f, 0.0f, 0.0f));
        }

        if(!initialized)
        {
            client = ArtemisWrapper.artemis_client_create(capacity);
            initialized = true;
        }

        int portAsInt;

        if(!int.TryParse(ArtemisOldGUI.portString, out portAsInt))
        {
            ArtemisOldGUI.artemisNotificationMessage = "Wrong port";
            return;
        }

        Debug.Log ("Artemis Threaded Client connect");
        int res = ArtemisWrapper.artemis_client_connect(client, ArtemisOldGUI.host, portAsInt);
        Debug.Log(res);
        if(res == 0)
        {
            ArtemisOldGUI.artemisNotificationMessage = "Connected to " + ArtemisOldGUI.host + ":" + ArtemisOldGUI.portString;

            artemisGo = new GameObject("Artemis");
            ArtemisClientLoop s = artemisGo.AddComponent<ArtemisClientLoop>();
                    
            GenericAtomManager atomManager = (GenericAtomManager) UnityMolMain.getCurrentAtomManager();
            atomManager.CreateMouseOversIMDSimulation();
            GUIMoleculeController.toggle_IMD = true;

            oThread = new Thread(() => threadedClient.mainProc(client, capacity));
            oThread.Start();
            while (!oThread.IsAlive);

            connected = true;
        }
        else
        {
            ArtemisOldGUI.artemisNotificationMessage = "Can't connect to " + ArtemisOldGUI.host + ":" + ArtemisOldGUI.portString;
        }
    }

    public void stop_simulation()
    {
        if (connected)
        {
            threadedClient.stop_simulation(client);
            disconnect();
        }
    }

    public void disconnect()
    {
        if (connected)
        {
            connected = false;

            GenericAtomManager atomManager = (GenericAtomManager) UnityMolMain.getCurrentAtomManager();
            atomManager.DestroyMouseOversIMDSimulation();
            GUIMoleculeController.toggle_IMD = false;

            Debug.Log("Destroying GO");
            GameObject.DestroyImmediate(artemisGo);
            Debug.Log("Destroyed");

            threadedClient.stop();

            oThread.Join();

            ArtemisWrapper.artemis_client_destroy(client);

            initialized = false;

            Debug.Log ("Thread joined");
        }
    }

    public void send_forces(int nb_forces, int[] indices, float[] coordinates)
    {
        threadedClient.send_forces(client, nb_forces, indices, coordinates);
    }

}