## setting file for PowerGetBatch
## version 0.2.2


#include = path/to/other/paramfile.txt            // relative path from this file can be set



# job selection -------------------------

job.peakdetection.new         = true              // if true, executes peak detection
job.peakselection.new         = false             // if true, executes peak selection
job.peakcharacterization.new  = false             // if true, executes peak characteriztion
job.peakeditor.new            = false             // if true, executes peak detection
                                                  // creation of MSMS.txt file, calculation of exact mass,
                                                  // calculation of 13C/12C ratio, and prediction of ionization mode
                                                  // (adduct) were preformed, and resuls are saved.
                                                  // the resulted files can be opened with PowerFT GUI version.

job.peakeditor.autoDbSearch   = false             // execute all database search with MFSearcher according to the
                                                  // settings in the mfsearcher.txt file.
                                                  // the data sets created by "job.peakeditor.new" is used.

job.peakeditor.annotation     = false             // execute annotation according to the annotation.txt file.
                                                  // the data sets created by "job.peakeditor.autoDbSearch" is used.

job.peakeditor.togomdOutput   = false             // output resulted files in TogoMD format. (under construction)

job.peakeditor.recalcAdduct   = false             // re-calculate adducts by new algorithm.

job.peakeditor.rejectAlonePeak = true              // reject alone peaks (not grouped nor not having other adduct)

job.peakeditor.overwrite      = false             // overwrite the peak information by a peak list

job.peakeditor.checkFileOutput= false             // output a check file for MassChroViewer (with component IDs).

job.peakselection.checkFileOutputAllPeak = false  // output a check file of all detected peaks before characterizing.

job.peakselection.overwriteCheckFileAllPeak = true // overwrite valid/invalid states of the peaks from a checkfile
                                                  // defined as a extra file.

job.peakselection.outputAllMsn = false            // output all Msn data for all detected peaks (0.2.1)

job.peakeditor.outputAllMsn   = false             // output all MSn data related to the valid peaks.(0.2.1)
job.peakeditor.outputBestAllMsn   = true

job.peakeditor.peakFileIsoExOutput= false         // output a peak file for IsotopeExplorer.

job.peakeditor.dbSearchDataOutput = false         // output DB search data in a file.

# general -------------------------------

marginFindPrecDefault = 0.5                       // A margin for finding precursor ions (Da).
                                                  // If there are scan data which ms levels are larger than MS4,
                                                  // the default value is used.
marginFindPrecMs2 = 0.5                           // A margin for finding precursor ions for MS2 scans.
marginFindPrecMs3 = 0.5                           // A margin for finding precursor ions for MS3 scans.



# peak detection ------------------------

peakdetection.ms1FileIntensityCutoff  = 0         // if the value is greater than 0, the ions that have
                                                  // an intensity less than the value are removed from the MS1 file
                                                  // and the result is overwritten on the current MS1 file.
                                                  // this function is used for the reduction of file size.

# ion grouping --------

peakdetection.isNeighbor              = true      // defines method for ion group generation.
                                                  // true: by mass diferences between the neighbor ions     (m1)
                                                  // false: by rounded mass at a defined decimal place used (m2)

peakdetection.roundDecimal            = 4         // decimal place for (m2)
peakdetection.neighborMargin          = 7         // mass margin for (m1)
peakdetection.isNeighborPpm           = true      // unit of mass margin for (m1). true: ppm, false: dalton
peakdetection.neighborGap             = 2         // gap of scan event allowed for (m1)
peakdetection.isEnabledIntensityLimit = true      // if true, ions less than the defined intensity is ignored for
                                                  // the grouping

peakdetection.AutoIntensityLimit         = false  // if true, average, median, and SD of the
                                                  // detected signals (log 10 transfered) in raw data are calculated
                                                  // for the threshold value of "peakdetection.intensityLimit"
                                                  // for peak detection.
                                                  // calculation of the threshold is done by (eq.1) with the Center
                                                  // and Factor defined below.

peakdetection.AutoIntensityLimitCenter   = 1      // the Center of (eq. 1). 0: average, 1: median
peakdetection.AutoIntensityLimitSdFactor = 2      // the Factor of (eq. 1).

peakdetection.intensityLimit          = 1000      // intensity limit

peakdetection.perScanIntensityCutoffRatio = 0.000 // 0-1:
                                                  // ion whose intensity ratio to the base peak ion in the scan
                                                  // is less than the given value is ignored

# group merging -------

peakdetection.mergeMargin             = 3         // margin for group merging
peakdetection.isMergePpm              = true      // unit of group merging. true: ppm, false: dalton
peakdetection.mergeGap                = 2         // gap of scan event allowed for group merging


# peak detection ------

peakdetection.isSummation             = false     // method for drawing mass chromatograms of grouped ions
                                                  // for peak detection.
                                                  // true: summation of ion signals in the scan
                                                  // false: highest ion signal in the scan

## settings for chromatogram smoothing
peakdetection.isSavitzky              = true      // method for smoothing
                                                  // true: Savitzky-Golay method (SG), false: moving average
peakdetection.numSmoothing            = 21        // scan number for moving average
peakdetection.numSmoothingMin         = 5         // minimum scan number for moving average
peakdetection.sgNL                    = 10        // left data points for SG
peakdetection.sgNR                    = 10        // right data points for SG
peakdetection.sgNLMin                 = 3         // minimum left data points for SG
peakdetection.sgNRMin                 = 3         // minimum left data points for SG
peakdetection.sgM                     = 4         // order of polynomial for SG
peakdetection.numSmoothingTrial       = 1         // number of smoothing trial

## settings for noise estimation
peakdetection.numAveCalc              = 20        // num. of scans for moving average calculation
peakdetection.sdFactorStrongPeakDetection = 0.5   // factor for large peak detection.
                                                  // large peak is recognized by
                                                  //     Center + standard deveation (SD) * Factor  (eq.1)
                                                  // where Center is moving average of the smoothed chromatogram,
                                                  // and Factor is the value set for this parameter.
                                                  // then the background of the chromatogram without the large peaks
                                                  // is calculated.

peakdetection.confIntervalLargePeak   = 95        // ( this is not used )
peakdetection.sdFactorNoisePeakRejection = 1      // factor for noise peak rejection.
                                                  // noise peak is recognized by (eq.1) where Center is moving
                                                  // average of the background described in the
                                                  // "peakdetection.sdFactorStrongPeakDetection" parameter,
                                                  // and Factor is the value set for this parameter.

## settings for peak detection

peakdetection.method                   = 1        // 0: classic, 1: new

peakdetection.numGradient              = 3        // num of data points for gradient calculation
peakdetection.thresholdAccumulator     = 2        // data points to detect start and end of the peak.
                                                  // min number of the continuous data points that have a greater
                                                  // value than the threshold described in the
                                                  // "peakdetection.sdFactorSlopeSensitivity" parameter

peakdetection.sensitivitySlope         = 100      // depends on the modeCalcSensitivitySlope
peakdetection.sdFactorSlopeSensitivity = 0        // used for calculation of threshold value to detect start and
                                                  // end of the peak.
                                                  // the threshold value is calcluated by (eq.1), where
                                                  // Center is average of gradient, and Factor is value defined for
                                                  // this parameter.

peakdetection.doMinMaxCutoffSensitivitySlope = false
peakdetection.minSensitivitySlope         = 100
peakdetection.maxSensitivitySlope         = 10000
peakdetection.neighborScopeValley         = 2
peakdetection.modeCalcSensitivitySlope    = 1     // 0: classic (by noise. works only for method 1)
                                                  // 1: by neighbor valley (smoothed int. near valleys)
                                                  // 2: absolute (signal increase / second)
                                                  // 3: ratio to peak top
                                                  // 4: ratio to max slope

peakdetection.maxPeakWidthFactor          = 2.5   // max half width (scan points) of the peak is set to
                                                  // half width of half height * the factor + 1
                                                  // ignored if <= 1

peakdetection.maxScanAsNoSegWithoutStartEnd = 3   // max scan num of a peak without start and end point required for
                                                  // recognizing as no segregated peak.

peakdetection.ratioHeightShareBackGround = 0.3    // ratio used for ditecting neighbor peak pairs that can share
                                                  // same base line.

peakdetection.minPeakHeight              = 2000   // height rejection threshold after ion grouping.
                                                  //   the peak height is calculated as
                                                  //   peak top intensity - average intensity of ions at the peak
                                                  //   start and end.


peakdetection.minPearsonCor              = 0

peakdetection.maxHighestNumber   = 5              //
peakdetection.maxHighestValue    = 0.05           //

peakdetection.minScanNo                = 6        // minimum scan numbers of a peak.


peakdetection.maxDeconvNeighborMarginPpm = 7      // m/z margin between a pair of neighbor ions for extraction of
                                                     peaks from the ion groups.

# peak selection --------------------------------

peakselection.fMinIonNo  = 5                      // unlimit if negative value is set, minimum ion number
peakselection.fMinInt    = 10                     // unlimit if negative value is set, minimum intensity
peakselection.fMinCor    = 0.4                    // unlimit if < -1 or > 1,
                                                  // minimum Pearson's correlation coefficient (CC)

peakselection.fMaxPValue = -1                   // unlimit if neagtive or > 100, maximum P-value for Pearson's CC
peakselection.fMinRt     = -1                     // unlimit if negative value, minimum retention time (RT) (min)
peakselection.fMaxRt     = -1                     // unlimit if negative value, maximum RT (min)
peakselection.fMinMz     = -1                     // unlimit if negative value, minimum m/z
peakselection.fMaxMz     = -1                     // unlimit if negative value, maximum m/z

peakselection.fMinCorCos    = -1                  // unlimit if < -1 or > 1, cos theta CC
peakselection.fMaxPValueCos = -1                 // unlimit if neagtive or > 100, P-value for cos theta CC

peakselection.fMinIonValidRatio  = 0.6    // If the ratio of valid scans with ions to the total scan events in the peak is
                                          // greater than the specified value, the peak will be invalid.
                                          // (The paaks with a large number of gaps will be invalid)

peakselection.fMaxNeighborDifPpm = 3      // If the average value of mass differences between the ions in the scans
                                          // is more the the specified value, the peak will be invalid.

peakselection.minPeakTopHeight   = 5000   // If the maximum ion intensity in the peak is less than the specified value
                                          // (absolute value) the peak will be invalid.

peakselection.maxMinTopRatio     = 0.2    // If the ratio of minimum to maximum ion intensity in the peak is larger than
                                          // the specified value (0-1), the peak will be invalid.

peakselection.removeConstantPeaks      = false
peakselection.removeConstantOnlyValid  = false
peakselection.removeConstantPpm        = 3
peakselection.removeConstantRt         = 2
peakselection.removeConstantLimitNum   = 8
peakselection.removeConstantLimitRatio = 0.01
peakselection.removeConstantLimitCor   = 0.6




# peak characterization ---------------------------------

peakcharacter.maxChargeFind13C = 5                // max charge for finding 13C isotope peaks.[0.1.1~]
peakcharacter.marginMzFind13C  = 3                // m/z margin for finding 13C isotope peaks.
peakcharacter.isPpmFind13C     = true             // if true, the unit of the margin is recognized as ppm.
                                                  // if false, the unit is dalton.
                                                  // these two values set in the "adductIon.ini" file
                                                  // of old PowerGet are ignored. [0.1.1~]

peakcharacter.maxPeakNum13C    = 6

peakcharacter.dsMaxDist        = 2                // unlimit if negative, maximum distance of peak RT (sec)
peakcharacter.dsMaxPvalueTTest = 100              // unlimit if negative or > 100, maximum P-value of t-test
peakcharacter.dsMinCC          = 0.6             // set to -1 if < -1, to 1 if > 1, minimum cos theta CC
peakcharacter.dsMaxPvalueCC    = 0.0001           // set to 100 if negative or > 100, maximum P-value for cos theta CC.


peakcharacter.removeGhostPeaks   = false
peakcharacter.removeGhostPpm                = 60
peakcharacter.removeGhostIntRatio           = 0.1
peakcharacter.removeGhostCor                = 0.90
peakcharacter.removeGhostRt                 = 6              // second


# peak editor -------------------------------------------

peakeditor.defaultIonizationMode       = [M+H]+   // title of default ionization mode

peakeditor.exactMassCalc_minIonNum     = 5        // minimum ion number used for exact mass calculation
peakeditor.exactMassCalc_confInterval  = 99.9999  // confidence interval (%) of masses of ions in the peak.
                                                  // outlier ions are removed until all ions are within the interval.
peakeditor.exactMassCalc_usedCorrectedMass = false // if true, corrected mass value (if calculated) is used.

peakeditor.ratio13CCalc_minPairNum     = 5        // minimum ion pairs used for 13C/12C ratio calculation
peakeditor.ratio13CCalc_confInterval   = 99.999   // confidence interval (%) of ratio values fo the pairs
                                                  // outlier pairs are removed until all pairs are within the interval.

peakeditor.exactMassCalc.method        = 1        // 0: classic
                                                  // 1: maxmum mass ions in a mass range

peakeditor.exactMassCalc_1_marginPpm   = 1        // ppm (used in method 1)


peakeditor.recalcAdduct.marginPpm      = 3        // margin to find peak pairs.
peakeditor.recalcAdduct.limitRatioToGroupMax   = 0.01
peakeditor.recalcAdduct.limitRatioBetweenPeaks = 0.01
peakeditor.recalcAdduct.modeComponentPriority = 0 // priority of selection of component ID when multiple IDs
                                                  // are assigned.
                                                  // 0: max intensity of peaks in the component.
                                                  // 1: max intensity of the average value of the peak pair which are
                                                  //    used for determine adducts.
                                                  // 2: average intensity of peaks in the component.


peakeditor.find_msn_precursor_margin = 0.05        // Da. The margin for finding the precursor ion.

peakeditor.find_best_msn.cleanup.round_decimal_fragment = 1
peakeditor.find_best_msn.cleanup.round_decimal_precursor = 1
peakeditor.find_best_msn.cleanup.cutoff_intensity_ratio = 0.05
peakeditor.find_best_msn.cleanup.cutoff_intensity_absolute = 500.0
peakeditor.find_best_msn.cleanup.num_top_ions = 50
peakeditor.find_best_msn.grouping.limit_ratio_group_member = 0.5
peakeditor.find_best_msn.grouping.limit_ratio_base_peak_intensity = 0.5

peakeditor.find_best_msn.matcher.add_new = 0.9, 0.01
peakeditor.find_best_msn.matcher.add = 0.98, 0.05
peakeditor.find_best_msn.matcher.add = 0.7, 0.0001
peakeditor.find_best_msn.matcher.add = 0.8, 0.001

peakeditor.find_best_msn.ms_level_to_top_ions.add_new = 3, 2


peakeditor.rejectAlonePeak.minPeakTopHeight = 7500 // used for reject alone peak
peakeditor.rejectAlonePeak.maxMinTopRatio = 0.3    // used for reject alone peak

peakeditor.overwrite.rt                = false
peakeditor.overwrite.mass              = false
peakeditor.overwrite.valid             = false
peakeditor.overwrite.componentIds      = false
peakeditor.overwrite.charge            = false
peakeditor.overwrite.adducts           = false
peakeditor.overwrite.validEachPeak     = false    // overwrite each peak data too (for PowerMatch) (0.2.1)

