Example #1
0
 public bool NeedsReprocess(ProcessingOptions r)
 {
     return(false);
 }
Example #2
0
        public bool NeedsReprocessPost(ProcessingOptions r)
        {
            bool Equal = !NeedsReprocessInput(r) &&
                         !NeedsReprocessPre(r) &&
                         !NeedsReprocessCTF(r) &&
                         !NeedsReprocessMovement(r);

            Equal &= !r.PostAverage || PostAverage;
            Equal &= !r.PostStack || (PostStack && r.PostStackGroupSize == PostStackGroupSize);

            return !Equal;
        }
Example #3
0
        public bool NeedsReprocessPre(ProcessingOptions r)
        {
            bool Equal = !NeedsReprocessInput(r);

            if (r.CorrectGain)
                Equal = r.CorrectGain == CorrectGain &&
                        r.GainPath == GainPath;

            return !Equal;
        }
Example #4
0
        public bool NeedsReprocessParticles(ProcessingOptions r)
        {
            bool Equal = r.DataStarPath == DataStarPath &&
                         r.ModelStarPath == ModelStarPath &&
                         r.ReferencePath == ReferencePath &&
                         r.MaskPath == MaskPath &&
                         r.ProjectionOversample == ProjectionOversample;

            return !Equal;
        }
Example #5
0
        public bool NeedsReprocessMovement(ProcessingOptions r)
        {
            bool Equal = !NeedsReprocessInput(r) &&
                         !NeedsReprocessPre(r);

            if (r.ProcessMovement)
            {
                Equal = Equal &&
                        r.MovementRangeMin == MovementRangeMin &&
                        r.MovementRangeMax == MovementRangeMax &&
                        r.MovementBfactor == MovementBfactor &&
                        r.GridMoveX == GridMoveX &&
                        r.GridMoveY == GridMoveY &&
                        r.GridMoveZ == GridMoveZ &&
                        r.MovementGridReduction == MovementGridReduction;

                if (r.ProcessParticleShift)
                    Equal = Equal &&
                            r.ProcessParticleShift == ProcessParticleShift &&
                            !NeedsReprocessParticles(r);
            }

            return !Equal;
        }
Example #6
0
        public bool NeedsReprocessInput(ProcessingOptions r)
        {
            bool Equal = r.PixelMin == PixelMin &&
                         r.PixelMax == PixelMax &&
                         r.PixelAngle == PixelAngle &&
                         r.DetectorPixel == DetectorPixel &&
                         r.BinTimes == BinTimes;

            return !Equal;
        }
Example #7
0
        public bool NeedsReprocessCTF(ProcessingOptions r)
        {
            bool Equal = !NeedsReprocessInput(r) &&
                         !NeedsReprocessPre(r);

            if (r.ProcessCTF)
            {
                Equal = Equal &&
                        r.CTFWindow == CTFWindow &&
                        r.CTFRangeMin == CTFRangeMin &&
                        r.CTFRangeMax == CTFRangeMax &&
                        r.CTFVoltage == CTFVoltage &&
                        r.CTFCs == CTFCs &&
                        r.CTFAmplitude == CTFAmplitude &&
                        r.CTFDoPhase == CTFDoPhase &&
                        r.CTFAstigmatism == CTFAstigmatism &&
                        r.CTFAstigmatismAngle == CTFAstigmatismAngle &&
                        r.CTFZMin == CTFZMin &&
                        r.CTFZMax == CTFZMax &&
                        r.GridCTFX == GridCTFX &&
                        r.GridCTFY == GridCTFY &&
                        r.GridCTFZ == GridCTFZ;

                if (r.ProcessParticleCTF)
                    Equal = Equal &&
                            r.ProcessParticleCTF == ProcessParticleCTF &&
                            !NeedsReprocessParticles(r);
            }

            return !Equal;
        }
Example #8
0
 public bool NeedsReprocess(ProcessingOptions r)
 {
     return false;
 }