private bool dataOnboard(SEP_ExperimentHandler handler, int level)
        {
            float science = handler.currentMaxScience(level);

            if (science > handler.submittedData)
            {
                if (handler.GetScienceCount() > 0)
                {
                    ScienceData dat = handler.GetData()[0];

                    ScienceSubject sub = ResearchAndDevelopment.GetSubjectByID(dat.subjectID);

                    if (sub != null)
                    {
                        float d = dat.dataAmount / sub.dataScale;

                        //SEP_Utilities.log("Science Data value check: {0:N2} - {1:N2}", logLevels.warning, science, d);

                        if (science <= d)
                        {
                            return(true);
                        }
                    }
                    else
                    {
                        return(true);
                    }
                }

                return(false);
            }

            return(true);
        }
        private bool checkTransmission(SEP_ExperimentHandler exp)
        {
            int   level   = exp.getMaxLevel(false);
            float science = exp.currentMaxScience(level);

            if (science > exp.submittedData)
            {
                return(transmitData(exp, level, exp.submittedData, science));
            }

            return(false);
        }
        private bool checkTransmission(SEP_ExperimentHandler exp)
        {
            int   level   = exp.getMaxLevel(false);
            float science = exp.currentMaxScience(level);

            //SEP_Utilities.log("Science Value Check: {0}\nVessel: {1}\nScience: {2:F4}\nSubmitted Science: {3:F4}", logLevels.warning, exp.experimentTitle, exp.vessel.vesselName, science, exp.submittedData);

            if (science > (exp.submittedData + (science / 10)))
            {
                return(transmitData(exp, level, exp.submittedData, science));
            }

            return(false);
        }
        private void experimentCheck(double time)
        {
            int l = experiments.Count;

            if (l > 0)
            {
                SEP_Utilities.log("Performing SEP background check on {0} experiments at time: {1:N0}", logLevels.log, l, time);
            }

            for (int i = 0; i < l; i++)
            {
                List <SEP_ExperimentHandler> modules = experiments.ElementAt(i).Value;

                int c = modules.Count;

                for (int j = 0; j < c; j++)
                {
                    SEP_ExperimentHandler m = modules[j];

                    if (m == null)
                    {
                        continue;
                    }

                    if (!m.loaded)
                    {
                        continue;
                    }

                    if (!m.experimentRunning)
                    {
                        continue;
                    }

                    if (m.usingECResource && !m.vessel.loaded)
                    {
                        List <string> generators = FinePrint.ContractDefs.GetModules("Power");

                        if (!FinePrint.Utilities.VesselUtilities.VesselHasAnyModules(generators, m.vessel))
                        {
                            continue;
                        }
                    }

                    if (m.vessel.loaded)
                    {
                        if (m.host != null && m.host.Controller != null)
                        {
                            if (m.host.vessel != m.host.Controller.vessel)
                            {
                                continue;
                            }
                        }
                        else
                        {
                            continue;
                        }
                    }

                    double t = m.experimentTime;

                    t /= m.calibration;

                    double length = time - m.lastBackgroundCheck;

                    m.lastBackgroundCheck = time;

                    double days = length / 21600;

                    if (days < t)
                    {
                        double n = days / t;

                        //SEPUtilities.log("Updating SEP Experiment Handler [{0}]: Add {1:P6}", logLevels.warning, m.experimentTitle, n);

                        m.completion += (float)n;
                    }
                    else
                    {
                        m.completion = 1;
                    }

                    float max = m.getMaxCompletion();

                    if (max <= 0.5f)
                    {
                        if (m.completion >= 0.5f)
                        {
                            m.completion = 0.5f;
                        }
                    }
                    else if (max <= 0.75f)
                    {
                        if (m.completion >= 0.75f)
                        {
                            m.completion = 0.75f;
                        }
                    }
                    else
                    {
                        if (m.completion >= 1f)
                        {
                            m.completion = 1f;
                        }
                    }

                    bool transmitted = false;

                    m.submittedData = m.getSubmittedData();

                    if (m.canTransmit && m.controllerAutoTransmit && transmissionUpgrade)
                    {
                        transmitted = checkTransmission(m);
                    }
                    else
                    {
                        int   level   = m.getMaxLevel(false);
                        float science = m.currentMaxScience(level);

                        if (science > m.submittedData)
                        {
                            bool flag = true;
                            if (m.GetScienceCount() > 0)
                            {
                                ScienceData dat = m.GetData()[0];

                                ScienceSubject sub = ResearchAndDevelopment.GetSubjectByID(dat.subjectID);

                                if (sub != null)
                                {
                                    float d = dat.dataAmount / sub.dataScale;

                                    //SEPUtilities.log("Science Data value check: {0:N2} - {1:N2}", logLevels.warning, science, d);

                                    if (science <= d)
                                    {
                                        flag = false;
                                    }
                                }
                                else
                                {
                                    flag = false;
                                }
                            }

                            if (flag)
                            {
                                m.addData(SEP_Utilities.getScienceData(m, m.getExperimentLevel(level), level));

                                if (m.vessel.loaded && m.host != null)
                                {
                                    m.host.Events["ReviewDataEvent"].active = true;
                                    m.host.Events["CollectData"].active     = true;
                                    if (m.host.Controller != null)
                                    {
                                        m.host.Controller.setCollectEvent();
                                    }
                                }
                            }
                        }
                    }

                    if (transmitted)
                    {
                        m.clearData();
                    }

                    if (m.completion >= max)
                    {
                        m.experimentRunning = false;
                        if (m.vessel.loaded && m.host != null)
                        {
                            int count = m.GetScienceCount();
                            m.host.Events["ReviewDataEvent"].active = !transmitted && count > 0;
                            m.host.Events["CollectData"].active     = !transmitted && count > 0;
                            m.host.PauseExperiment();
                            if (m.host.Controller != null)
                            {
                                m.host.Controller.setCollectEvent();
                            }
                        }
                    }
                }
            }
        }